diff --git a/Notebooks_04/praxisfallen.ipynb b/Notebooks_04/praxisfallen.ipynb
index 9af1b14..d1958eb 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": {},
diff --git a/OR_HTML_04/Notebooks_04/praxisfallen.ipynb b/OR_HTML_04/Notebooks_04/praxisfallen.ipynb
index 9af1b14..d1958eb 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": {},
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 fbf9d44..4e50397 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-loesungen.html b/OR_HTML_04/anhang-loesungen.html
index 35b8014..d7f775e 100644
--- a/OR_HTML_04/anhang-loesungen.html
+++ b/OR_HTML_04/anhang-loesungen.html
@@ -1348,8 +1348,9 @@ T \ge \left(\frac{2\sigma}{\mu}\right)^2 = \left(\frac{2 \cdot 0{,}012}{0{,}0004
 <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 — 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.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>
+<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>
@@ -1409,6 +1410,8 @@ 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>
diff --git a/OR_HTML_04/assets/programme.js b/OR_HTML_04/assets/programme.js
index 5c39e70..ed78974 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", "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 48224fc..f2b493e 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 — 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":""}];
+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 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":"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/bruecke.html b/OR_HTML_04/bruecke.html
index 4b1fdb0..b2280cd 100644
--- a/OR_HTML_04/bruecke.html
+++ b/OR_HTML_04/bruecke.html
@@ -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 />
diff --git a/OR_HTML_04/cpsat.html b/OR_HTML_04/cpsat.html
index 12d75b1..74c78ff 100644
--- a/OR_HTML_04/cpsat.html
+++ b/OR_HTML_04/cpsat.html
@@ -721,7 +721,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>
diff --git a/OR_HTML_04/einfuehrung.html b/OR_HTML_04/einfuehrung.html
index 328ac8d..7cafecd 100644
--- a/OR_HTML_04/einfuehrung.html
+++ b/OR_HTML_04/einfuehrung.html
@@ -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>
diff --git a/OR_HTML_04/gesamtdokument.html b/OR_HTML_04/gesamtdokument.html
index 2dd808a..4267787 100644
--- a/OR_HTML_04/gesamtdokument.html
+++ b/OR_HTML_04/gesamtdokument.html
@@ -939,20 +939,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>
@@ -1866,41 +1871,46 @@ Alles bereit — Sie können mit dem ersten Kapitel beginnen.</code></pre>
 <td><a href="#kap-praxisfallen">Kapitel 22</a></td>
 </tr>
 <tr class="odd">
+<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="even">
 <td><code>Betriebsueberwachung.py</code></td>
 <td>Status, Gap und Zeitausschöpfung</td>
 <td><a href="#kap-praxisfallen">Kapitel 22</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>or_kern.py</code></td>
 <td>Gemeinsamer Unterbau: Domäne, Status, Prüfung</td>
 <td><a href="#kap-praxisfallen">Kapitel 22</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Solverwechsel_CPSAT_HiGHS.py</code></td>
 <td>Derselbe Fall in zwei Solvern</td>
 <td><a href="#kap-praxisfallen">Kapitel 22</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>test_or_kern.py</code></td>
 <td>Testsuite für ein Optimierungsmodell</td>
 <td><a href="#kap-testing">Kapitel 23</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Mutationstest.py</code></td>
 <td>Findet die Lücken der eigenen Tests</td>
 <td><a href="#kap-testing">Kapitel 23</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Benchmark_Skalierung.py</code></td>
 <td>Aufbau gegen Lösen, vier Bibliotheken</td>
 <td><a href="#kap-testing">Kapitel 23</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Optimierungsdienst.py</code></td>
 <td>Das Modell als HTTP-Dienst</td>
 <td><a href="#kap-testing">Kapitel 23</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Konfliktsuche.py</code></td>
 <td>Deletion Filter: den Widerspruch einkreisen</td>
 <td><a href="#anhang-fehlerdiagnose">Anhang C</a></td>
@@ -3976,7 +3986,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 +4051,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>
@@ -9385,7 +9395,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 +9666,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>
@@ -11184,7 +11194,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>
@@ -19749,7 +19759,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 />
@@ -24646,6 +24656,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>
@@ -24725,6 +24736,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>
@@ -24972,6 +24984,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>
@@ -25019,7 +25032,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="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"># Constraint_Attribution.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: Welche Bedingung kostet wie viel - und was sagt man</span></span>
+<span id="cb206-6"><a href="#cb206-6" aria-hidden="true" tabindex="-1"></a><span class="co">dem Management?</span></span>
+<span id="cb206-7"><a href="#cb206-7" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-8"><a href="#cb206-8" aria-hidden="true" tabindex="-1"></a><span class="co">Zwischen den beiden bekannten Faellen klafft eine Luecke:</span></span>
+<span id="cb206-9"><a href="#cb206-9" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-10"><a href="#cb206-10" aria-hidden="true" tabindex="-1"></a><span class="co">  * Erklaerbarkeit.py beantwortet &quot;warum diese eine Zuweisung?&quot;</span></span>
+<span id="cb206-11"><a href="#cb206-11" aria-hidden="true" tabindex="-1"></a><span class="co">  * Konfliktsuche.py (Anhang Fehlerdiagnose) beantwortet &quot;warum geht es gar</span></span>
+<span id="cb206-12"><a href="#cb206-12" aria-hidden="true" tabindex="-1"></a><span class="co">    nicht?&quot;</span></span>
+<span id="cb206-13"><a href="#cb206-13" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-14"><a href="#cb206-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="cb206-15"><a href="#cb206-15" aria-hidden="true" tabindex="-1"></a><span class="co">Plan ist zulaessig - und trotzdem unbefriedigend. Niemand weiss, WORAN es</span></span>
+<span id="cb206-16"><a href="#cb206-16" aria-hidden="true" tabindex="-1"></a><span class="co">liegt. Genau das beantwortet Constraint Attribution.</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">Gerechnet wird auf derselben Fabrik wie in Konfliktsuche.py, nur nach der</span></span>
+<span id="cb206-19"><a href="#cb206-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="cb206-20"><a href="#cb206-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="cb206-21"><a href="#cb206-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="cb206-22"><a href="#cb206-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="cb206-23"><a href="#cb206-23" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;was kostet uns was?&quot;.</span></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><span class="co">Gezeigt werden vier Dinge:</span></span>
+<span id="cb206-26"><a href="#cb206-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="cb206-27"><a href="#cb206-27" aria-hidden="true" tabindex="-1"></a><span class="co">  2. Dass der Schattenpreis eine MOMENTAUFNAHME ist: hochgerechnet auf eine</span></span>
+<span id="cb206-28"><a href="#cb206-28" aria-hidden="true" tabindex="-1"></a><span class="co">     realistische Sonderschicht verspricht er hier das Doppelte des</span></span>
+<span id="cb206-29"><a href="#cb206-29" aria-hidden="true" tabindex="-1"></a><span class="co">     tatsaechlichen Nutzens.</span></span>
+<span id="cb206-30"><a href="#cb206-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="cb206-31"><a href="#cb206-31" aria-hidden="true" tabindex="-1"></a><span class="co">     kann - und welche Bedingungen ihn gemeinsam blockieren.</span></span>
+<span id="cb206-32"><a href="#cb206-32" aria-hidden="true" tabindex="-1"></a><span class="co">  4. Wie aus alledem ein Bericht in Alltagssprache wird.</span></span>
+<span id="cb206-33"><a href="#cb206-33" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-34"><a href="#cb206-34" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, scipy</span></span>
+<span id="cb206-35"><a href="#cb206-35" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb206-36"><a href="#cb206-36" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-37"><a href="#cb206-37" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb206-38"><a href="#cb206-38" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-39"><a href="#cb206-39" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> textwrap</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="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb206-42"><a href="#cb206-42" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</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>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="cb206-45"><a href="#cb206-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="cb206-46"><a href="#cb206-46" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-47"><a href="#cb206-47" aria-hidden="true" tabindex="-1"></a><span class="co"># Dieselben Bedingungen wie in Konfliktsuche.py, mit den beiden Reparaturen.</span></span>
+<span id="cb206-48"><a href="#cb206-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="cb206-49"><a href="#cb206-49" aria-hidden="true" tabindex="-1"></a><span class="co"># der jemandem ausserhalb der Modellierung etwas sagt.</span></span>
+<span id="cb206-50"><a href="#cb206-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="cb206-51"><a href="#cb206-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="cb206-52"><a href="#cb206-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="cb206-53"><a href="#cb206-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="cb206-54"><a href="#cb206-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="cb206-55"><a href="#cb206-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="cb206-56"><a href="#cb206-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="cb206-57"><a href="#cb206-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="cb206-58"><a href="#cb206-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="cb206-59"><a href="#cb206-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="cb206-60"><a href="#cb206-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="cb206-61"><a href="#cb206-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="cb206-62"><a href="#cb206-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="cb206-63"><a href="#cb206-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="cb206-64"><a href="#cb206-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="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>
+<span id="cb206-67"><a href="#cb206-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="cb206-68"><a href="#cb206-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="cb206-69"><a href="#cb206-69" aria-hidden="true" tabindex="-1"></a><span class="co"># Sonderschicht, ein nachverhandelter Vertrag. Genau an dieser Groesse</span></span>
+<span id="cb206-70"><a href="#cb206-70" aria-hidden="true" tabindex="-1"></a><span class="co"># scheitert das blosse Hochrechnen des Schattenpreises.</span></span>
+<span id="cb206-71"><a href="#cb206-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="cb206-72"><a href="#cb206-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="cb206-73"><a href="#cb206-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="cb206-74"><a href="#cb206-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="cb206-75"><a href="#cb206-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="cb206-76"><a href="#cb206-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="cb206-77"><a href="#cb206-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="cb206-78"><a href="#cb206-78" aria-hidden="true" tabindex="-1"></a>}</span>
+<span id="cb206-79"><a href="#cb206-79" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-80"><a href="#cb206-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="cb206-81"><a href="#cb206-81" aria-hidden="true" tabindex="-1"></a>WUNSCH_PRODUKT <span class="op">=</span> <span class="st">&quot;Rahmen&quot;</span></span>
+<span id="cb206-82"><a href="#cb206-82" aria-hidden="true" tabindex="-1"></a></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="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="cb206-85"><a href="#cb206-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="cb206-86"><a href="#cb206-86" aria-hidden="true" tabindex="-1"></a>    matrix, rechte_seite <span class="op">=</span> [], []</span>
+<span id="cb206-87"><a href="#cb206-87" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> _, koeffizienten, richtung, grenze <span class="kw">in</span> bedingungen:</span>
+<span id="cb206-88"><a href="#cb206-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="cb206-89"><a href="#cb206-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="cb206-90"><a href="#cb206-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="cb206-91"><a href="#cb206-91" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> linprog(<span class="op">-</span>DECKUNGSBEITRAG,</span>
+<span id="cb206-92"><a href="#cb206-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="cb206-93"><a href="#cb206-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="cb206-94"><a href="#cb206-94" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-95"><a href="#cb206-95" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-96"><a href="#cb206-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="cb206-97"><a href="#cb206-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="cb206-98"><a href="#cb206-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="cb206-99"><a href="#cb206-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="cb206-100"><a href="#cb206-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="cb206-101"><a href="#cb206-101" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-102"><a href="#cb206-102" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-103"><a href="#cb206-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="cb206-104"><a href="#cb206-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="cb206-105"><a href="#cb206-105" aria-hidden="true" tabindex="-1"></a>    x <span class="op">=</span> ergebnis.x</span>
+<span id="cb206-106"><a href="#cb206-106" aria-hidden="true" tabindex="-1"></a>    dual <span class="op">=</span> ergebnis.ineqlin.marginals</span>
+<span id="cb206-107"><a href="#cb206-107" aria-hidden="true" tabindex="-1"></a>    zeilen <span class="op">=</span> []</span>
+<span id="cb206-108"><a href="#cb206-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="cb206-109"><a href="#cb206-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="cb206-110"><a href="#cb206-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="cb206-111"><a href="#cb206-111" aria-hidden="true" tabindex="-1"></a>        zeilen.append((name, links, richtung, grenze, schlupf, <span class="bu">abs</span>(dual[i])))</span>
+<span id="cb206-112"><a href="#cb206-112" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> zeilen</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>
+<span id="cb206-115"><a href="#cb206-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="cb206-116"><a href="#cb206-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="cb206-117"><a href="#cb206-117" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-118"><a href="#cb206-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="cb206-119"><a href="#cb206-119" aria-hidden="true" tabindex="-1"></a><span class="co">    umgekehrtem Vorzeichen: Dort wird gesucht, was den Widerspruch AUSMACHT,</span></span>
+<span id="cb206-120"><a href="#cb206-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="cb206-121"><a href="#cb206-121" aria-hidden="true" tabindex="-1"></a><span class="co">    loesbar, gehoert sie zum Konflikt.</span></span>
+<span id="cb206-122"><a href="#cb206-122" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb206-123"><a href="#cb206-123" aria-hidden="true" tabindex="-1"></a>    gefunden <span class="op">=</span> []</span>
+<span id="cb206-124"><a href="#cb206-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="cb206-125"><a href="#cb206-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="cb206-126"><a href="#cb206-126" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> loese(rest).success:</span>
+<span id="cb206-127"><a href="#cb206-127" aria-hidden="true" tabindex="-1"></a>            gefunden.append(name)</span>
+<span id="cb206-128"><a href="#cb206-128" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> gefunden</span>
+<span id="cb206-129"><a href="#cb206-129" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-130"><a href="#cb206-130" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-131"><a href="#cb206-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="cb206-132"><a href="#cb206-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="cb206-133"><a href="#cb206-133" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-134"><a href="#cb206-134" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-135"><a href="#cb206-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="cb206-136"><a href="#cb206-136" aria-hidden="true" tabindex="-1"></a>    basis <span class="op">=</span> loese(BEDINGUNGEN)</span>
+<span id="cb206-137"><a href="#cb206-137" aria-hidden="true" tabindex="-1"></a>    db_basis <span class="op">=</span> <span class="op">-</span>basis.fun</span>
+<span id="cb206-138"><a href="#cb206-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="cb206-139"><a href="#cb206-139" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-140"><a href="#cb206-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="cb206-141"><a href="#cb206-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="cb206-142"><a href="#cb206-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="cb206-143"><a href="#cb206-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="cb206-144"><a href="#cb206-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="cb206-145"><a href="#cb206-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="cb206-146"><a href="#cb206-146" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-147"><a href="#cb206-147" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 1. Wer begrenzt den Plan? -----------------------------------------</span></span>
+<span id="cb206-148"><a href="#cb206-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="cb206-149"><a href="#cb206-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="cb206-150"><a href="#cb206-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="cb206-151"><a href="#cb206-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="cb206-152"><a href="#cb206-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="cb206-153"><a href="#cb206-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="cb206-154"><a href="#cb206-154" aria-hidden="true" tabindex="-1"></a>    bindend <span class="op">=</span> []</span>
+<span id="cb206-155"><a href="#cb206-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="cb206-156"><a href="#cb206-156" aria-hidden="true" tabindex="-1"></a>        marke <span class="op">=</span> <span class="st">&quot;&quot;</span></span>
+<span id="cb206-157"><a href="#cb206-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="cb206-158"><a href="#cb206-158" aria-hidden="true" tabindex="-1"></a>            bindend.append((name, dual))</span>
+<span id="cb206-159"><a href="#cb206-159" aria-hidden="true" tabindex="-1"></a>            marke <span class="op">=</span> <span class="st">&quot;  &lt;-- bindend&quot;</span></span>
+<span id="cb206-160"><a href="#cb206-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="cb206-161"><a href="#cb206-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="cb206-162"><a href="#cb206-162" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-163"><a href="#cb206-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="cb206-164"><a href="#cb206-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="cb206-165"><a href="#cb206-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="cb206-166"><a href="#cb206-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="cb206-167"><a href="#cb206-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="cb206-168"><a href="#cb206-168" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-169"><a href="#cb206-169" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 2. Der Schattenpreis als Momentaufnahme ---------------------------</span></span>
+<span id="cb206-170"><a href="#cb206-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="cb206-171"><a href="#cb206-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="cb206-172"><a href="#cb206-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="cb206-173"><a href="#cb206-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="cb206-174"><a href="#cb206-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="cb206-175"><a href="#cb206-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="cb206-176"><a href="#cb206-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="cb206-177"><a href="#cb206-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="cb206-178"><a href="#cb206-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="cb206-179"><a href="#cb206-179" aria-hidden="true" tabindex="-1"></a>    wirkung <span class="op">=</span> {}</span>
+<span id="cb206-180"><a href="#cb206-180" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, (delta, _) <span class="kw">in</span> STELLSCHRAUBEN.items():</span>
+<span id="cb206-181"><a href="#cb206-181" aria-hidden="true" tabindex="-1"></a>        ergebnis <span class="op">=</span> loese(geaendert(name, delta))</span>
+<span id="cb206-182"><a href="#cb206-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="cb206-183"><a href="#cb206-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="cb206-184"><a href="#cb206-184" aria-hidden="true" tabindex="-1"></a>        wirkung[name] <span class="op">=</span> echt</span>
+<span id="cb206-185"><a href="#cb206-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="cb206-186"><a href="#cb206-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="cb206-187"><a href="#cb206-187" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-188"><a href="#cb206-188" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Wo endet der Gueltigkeitsbereich? Schrittweise nachfahren.</span></span>
+<span id="cb206-189"><a href="#cb206-189" aria-hidden="true" tabindex="-1"></a>    abweichler <span class="op">=</span> <span class="bu">max</span>(STELLSCHRAUBEN,</span>
+<span id="cb206-190"><a href="#cb206-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="cb206-191"><a href="#cb206-191" aria-hidden="true" tabindex="-1"></a>    delta_max <span class="op">=</span> STELLSCHRAUBEN[abweichler][<span class="dv">0</span>]</span>
+<span id="cb206-192"><a href="#cb206-192" aria-hidden="true" tabindex="-1"></a>    grenze_gueltig <span class="op">=</span> <span class="fl">0.0</span></span>
+<span id="cb206-193"><a href="#cb206-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="cb206-194"><a href="#cb206-194" aria-hidden="true" tabindex="-1"></a>    vorher <span class="op">=</span> db_basis</span>
+<span id="cb206-195"><a href="#cb206-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="cb206-196"><a href="#cb206-196" aria-hidden="true" tabindex="-1"></a>        d <span class="op">=</span> schritt <span class="op">*</span> i</span>
+<span id="cb206-197"><a href="#cb206-197" aria-hidden="true" tabindex="-1"></a>        e <span class="op">=</span> loese(geaendert(abweichler, d))</span>
+<span id="cb206-198"><a href="#cb206-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="cb206-199"><a href="#cb206-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="cb206-200"><a href="#cb206-200" aria-hidden="true" tabindex="-1"></a>            grenze_gueltig <span class="op">=</span> d</span>
+<span id="cb206-201"><a href="#cb206-201" aria-hidden="true" tabindex="-1"></a>        vorher <span class="op">=</span> db</span>
+<span id="cb206-202"><a href="#cb206-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="cb206-203"><a href="#cb206-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="cb206-204"><a href="#cb206-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="cb206-205"><a href="#cb206-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="cb206-206"><a href="#cb206-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="cb206-207"><a href="#cb206-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="cb206-208"><a href="#cb206-208" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-209"><a href="#cb206-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="cb206-210"><a href="#cb206-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="cb206-211"><a href="#cb206-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="cb206-212"><a href="#cb206-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="cb206-213"><a href="#cb206-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="cb206-214"><a href="#cb206-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="cb206-215"><a href="#cb206-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="cb206-216"><a href="#cb206-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="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="co"># --- 3. Der Wunsch aus dem Vertrieb ------------------------------------</span></span>
+<span id="cb206-219"><a href="#cb206-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="cb206-220"><a href="#cb206-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="cb206-221"><a href="#cb206-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="cb206-222"><a href="#cb206-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="cb206-223"><a href="#cb206-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="cb206-224"><a href="#cb206-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="cb206-225"><a href="#cb206-225" aria-hidden="true" tabindex="-1"></a>    mit_wunsch <span class="op">=</span> loese(BEDINGUNGEN <span class="op">+</span> [wunsch])</span>
+<span id="cb206-226"><a href="#cb206-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="cb206-227"><a href="#cb206-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="cb206-228"><a href="#cb206-228" aria-hidden="true" tabindex="-1"></a>    wunsch_gratis <span class="op">=</span> <span class="va">False</span></span>
+<span id="cb206-229"><a href="#cb206-229" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-230"><a href="#cb206-230" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> mit_wunsch.success:</span>
+<span id="cb206-231"><a href="#cb206-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="cb206-232"><a href="#cb206-232" aria-hidden="true" tabindex="-1"></a>    <span class="cf">else</span>:</span>
+<span id="cb206-233"><a href="#cb206-233" aria-hidden="true" tabindex="-1"></a>        schuldige <span class="op">=</span> blockierer(BEDINGUNGEN, wunsch)</span>
+<span id="cb206-234"><a href="#cb206-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="cb206-235"><a href="#cb206-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="cb206-236"><a href="#cb206-236" aria-hidden="true" tabindex="-1"></a>              <span class="ss">f&quot;Faellt eine davon&quot;</span>)</span>
+<span id="cb206-237"><a href="#cb206-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="cb206-238"><a href="#cb206-238" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> name <span class="kw">in</span> schuldige:</span>
+<span id="cb206-239"><a href="#cb206-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="cb206-240"><a href="#cb206-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="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>        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="cb206-243"><a href="#cb206-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="cb206-244"><a href="#cb206-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="cb206-245"><a href="#cb206-245" aria-hidden="true" tabindex="-1"></a>                noetig <span class="op">=</span> schritt</span>
+<span id="cb206-246"><a href="#cb206-246" aria-hidden="true" tabindex="-1"></a>                <span class="cf">break</span></span>
+<span id="cb206-247"><a href="#cb206-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="cb206-248"><a href="#cb206-248" aria-hidden="true" tabindex="-1"></a>            e <span class="op">=</span> loese(geaendert(engpass, noetig) <span class="op">+</span> [wunsch])</span>
+<span id="cb206-249"><a href="#cb206-249" aria-hidden="true" tabindex="-1"></a>            ohne <span class="op">=</span> loese(geaendert(engpass, noetig))</span>
+<span id="cb206-250"><a href="#cb206-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="cb206-251"><a href="#cb206-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="cb206-252"><a href="#cb206-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="cb206-253"><a href="#cb206-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="cb206-254"><a href="#cb206-254" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> wunsch_gratis:</span>
+<span id="cb206-255"><a href="#cb206-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="cb206-256"><a href="#cb206-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="cb206-257"><a href="#cb206-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="cb206-258"><a href="#cb206-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="cb206-259"><a href="#cb206-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="cb206-260"><a href="#cb206-260" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-261"><a href="#cb206-261" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- 4. Der Bericht ----------------------------------------------------</span></span>
+<span id="cb206-262"><a href="#cb206-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="cb206-263"><a href="#cb206-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="cb206-264"><a href="#cb206-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="cb206-265"><a href="#cb206-265" aria-hidden="true" tabindex="-1"></a>    <span class="co"># irgendwann leise falsch wird.</span></span>
+<span id="cb206-266"><a href="#cb206-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="cb206-267"><a href="#cb206-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="cb206-268"><a href="#cb206-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="cb206-269"><a href="#cb206-269" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-270"><a href="#cb206-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="cb206-271"><a href="#cb206-271" aria-hidden="true" tabindex="-1"></a>    gross <span class="op">=</span> STELLSCHRAUBEN[nach_wirkung][<span class="dv">1</span>]</span>
+<span id="cb206-272"><a href="#cb206-272" aria-hidden="true" tabindex="-1"></a>    klein <span class="op">=</span> STELLSCHRAUBEN[abweichler][<span class="dv">1</span>]</span>
+<span id="cb206-273"><a href="#cb206-273" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-274"><a href="#cb206-274" aria-hidden="true" tabindex="-1"></a>    absaetze <span class="op">=</span> [</span>
+<span id="cb206-275"><a href="#cb206-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="cb206-276"><a href="#cb206-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="cb206-277"><a href="#cb206-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="cb206-278"><a href="#cb206-278" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-279"><a href="#cb206-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="cb206-280"><a href="#cb206-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="cb206-281"><a href="#cb206-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="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="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="cb206-284"><a href="#cb206-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="cb206-285"><a href="#cb206-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="cb206-286"><a href="#cb206-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="cb206-287"><a href="#cb206-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="cb206-288"><a href="#cb206-288" aria-hidden="true" tabindex="-1"></a>        <span class="ss">f&quot;bezahlt die zweite Haelfte umsonst.&quot;</span>,</span>
+<span id="cb206-289"><a href="#cb206-289" aria-hidden="true" tabindex="-1"></a>    ]</span>
+<span id="cb206-290"><a href="#cb206-290" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-291"><a href="#cb206-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="cb206-292"><a href="#cb206-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="cb206-293"><a href="#cb206-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="cb206-294"><a href="#cb206-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="cb206-295"><a href="#cb206-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="cb206-296"><a href="#cb206-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="cb206-297"><a href="#cb206-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="cb206-298"><a href="#cb206-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="cb206-299"><a href="#cb206-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="cb206-300"><a href="#cb206-300" aria-hidden="true" tabindex="-1"></a>        absaetze.append(satz)</span>
+<span id="cb206-301"><a href="#cb206-301" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb206-302"><a href="#cb206-302" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> absatz <span class="kw">in</span> absaetze:</span>
+<span id="cb206-303"><a href="#cb206-303" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>()</span>
+<span id="cb206-304"><a href="#cb206-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="cb206-305"><a href="#cb206-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>
@@ -25083,7 +25527,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>
@@ -25200,510 +25644,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="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"># or_kern.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: Der gemeinsame Unterbau fuer produktionsreife OR-Modelle.</span></span>
+<span id="cb208-6"><a href="#cb208-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-7"><a href="#cb208-7" aria-hidden="true" tabindex="-1"></a><span class="co">Alle Beispiele dieses Buchs loesen dieselben vier Aufgaben immer wieder:</span></span>
+<span id="cb208-8"><a href="#cb208-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="cb208-9"><a href="#cb208-9" aria-hidden="true" tabindex="-1"></a><span class="co">Loesung gegen die Wirklichkeit kontrollieren. Dieses Modul zieht diese vier</span></span>
+<span id="cb208-10"><a href="#cb208-10" aria-hidden="true" tabindex="-1"></a><span class="co">Aufgaben aus den Einzelprogrammen heraus.</span></span>
+<span id="cb208-11"><a href="#cb208-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-12"><a href="#cb208-12" aria-hidden="true" tabindex="-1"></a><span class="co">    Rohdaten (Excel/CSV)</span></span>
+<span id="cb208-13"><a href="#cb208-13" aria-hidden="true" tabindex="-1"></a><span class="co">        -&gt; Domaenenmodell (Pydantic, geprueft)</span></span>
+<span id="cb208-14"><a href="#cb208-14" aria-hidden="true" tabindex="-1"></a><span class="co">            -&gt; Modellbauer (solverabhaengig)</span></span>
+<span id="cb208-15"><a href="#cb208-15" aria-hidden="true" tabindex="-1"></a><span class="co">                -&gt; Loesung (DTO, solverunabhaengig)</span></span>
+<span id="cb208-16"><a href="#cb208-16" aria-hidden="true" tabindex="-1"></a><span class="co">                    -&gt; Abnahmepruefung</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">Der Sinn dieser Trennung: Die Domaenenschicht weiss nichts von Solvern, die</span></span>
+<span id="cb208-19"><a href="#cb208-19" aria-hidden="true" tabindex="-1"></a><span class="co">Loesungsschicht weiss nichts vom Modellaufbau. Wer den Solver wechselt, tauscht</span></span>
+<span id="cb208-20"><a href="#cb208-20" aria-hidden="true" tabindex="-1"></a><span class="co">genau EINEN Baustein aus - der Rest bleibt.</span></span>
+<span id="cb208-21"><a href="#cb208-21" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-22"><a href="#cb208-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="cb208-23"><a href="#cb208-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="cb208-24"><a href="#cb208-24" aria-hidden="true" tabindex="-1"></a><span class="co">nicht im selben Prozess. Die Statusuebersetzer laden ihre Bibliothek erst,</span></span>
+<span id="cb208-25"><a href="#cb208-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="cb208-26"><a href="#cb208-26" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-27"><a href="#cb208-27" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: pydantic (v2), numpy; optional pandas und openpyxl fuer Excel.</span></span>
+<span id="cb208-28"><a href="#cb208-28" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb208-29"><a href="#cb208-29" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-30"><a href="#cb208-30" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb208-31"><a href="#cb208-31" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-32"><a href="#cb208-32" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> enum <span class="im">import</span> Enum</span>
+<span id="cb208-33"><a href="#cb208-33" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> typing <span class="im">import</span> Annotated, Any, Sequence</span>
+<span id="cb208-34"><a href="#cb208-34" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-35"><a href="#cb208-35" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb208-36"><a href="#cb208-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="cb208-37"><a href="#cb208-37" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-38"><a href="#cb208-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="cb208-39"><a href="#cb208-39" aria-hidden="true" tabindex="-1"></a><span class="co"># damit gilt sie ueberall, wo der Typ verwendet wird.</span></span>
+<span id="cb208-40"><a href="#cb208-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="cb208-41"><a href="#cb208-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="cb208-42"><a href="#cb208-42" aria-hidden="true" tabindex="-1"></a></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><span class="co"># --- 1. Solverstatus: eine Sprache fuer fuenf Bibliotheken -------------------</span></span>
+<span id="cb208-45"><a href="#cb208-45" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-46"><a href="#cb208-46" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> SolverStatus(<span class="bu">str</span>, Enum):</span>
+<span id="cb208-47"><a href="#cb208-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="cb208-48"><a href="#cb208-48" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-49"><a href="#cb208-49" aria-hidden="true" tabindex="-1"></a><span class="co">    Die fuenf im Buch verwendeten Bibliotheken benennen dasselbe Ergebnis</span></span>
+<span id="cb208-50"><a href="#cb208-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="cb208-51"><a href="#cb208-51" aria-hidden="true" tabindex="-1"></a><span class="co">    prueft, bindet seinen Auswertungscode an eine Bibliothek.</span></span>
+<span id="cb208-52"><a href="#cb208-52" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb208-53"><a href="#cb208-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="cb208-54"><a href="#cb208-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="cb208-55"><a href="#cb208-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="cb208-56"><a href="#cb208-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="cb208-57"><a href="#cb208-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="cb208-58"><a href="#cb208-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="cb208-59"><a href="#cb208-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="cb208-60"><a href="#cb208-60" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-61"><a href="#cb208-61" aria-hidden="true" tabindex="-1"></a>    <span class="at">@property</span></span>
+<span id="cb208-62"><a href="#cb208-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="cb208-63"><a href="#cb208-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="cb208-64"><a href="#cb208-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="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 class="at">@property</span></span>
+<span id="cb208-67"><a href="#cb208-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="cb208-68"><a href="#cb208-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="cb208-69"><a href="#cb208-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="cb208-70"><a href="#cb208-70" aria-hidden="true" tabindex="-1"></a>                        SolverStatus.FEHLERHAFT)</span>
+<span id="cb208-71"><a href="#cb208-71" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-72"><a href="#cb208-72" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-73"><a href="#cb208-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="cb208-74"><a href="#cb208-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="cb208-75"><a href="#cb208-75" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> ortools.linear_solver <span class="im">import</span> pywraplp</span>
+<span id="cb208-76"><a href="#cb208-76" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> {</span>
+<span id="cb208-77"><a href="#cb208-77" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.OPTIMAL: SolverStatus.OPTIMAL,</span>
+<span id="cb208-78"><a href="#cb208-78" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.FEASIBLE: SolverStatus.ZULAESSIG,</span>
+<span id="cb208-79"><a href="#cb208-79" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.INFEASIBLE: SolverStatus.UNZULAESSIG,</span>
+<span id="cb208-80"><a href="#cb208-80" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.UNBOUNDED: SolverStatus.UNBESCHRAENKT,</span>
+<span id="cb208-81"><a href="#cb208-81" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.ABNORMAL: SolverStatus.FEHLERHAFT,</span>
+<span id="cb208-82"><a href="#cb208-82" aria-hidden="true" tabindex="-1"></a>        pywraplp.Solver.NOT_SOLVED: SolverStatus.ZEITLIMIT,</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="cf">return</span> zuordnung.get(rohstatus, SolverStatus.UNBEKANNT)</span>
+<span id="cb208-85"><a href="#cb208-85" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-86"><a href="#cb208-86" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-87"><a href="#cb208-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="cb208-88"><a href="#cb208-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="cb208-89"><a href="#cb208-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="cb208-90"><a href="#cb208-90" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> {</span>
+<span id="cb208-91"><a href="#cb208-91" aria-hidden="true" tabindex="-1"></a>        cp_model.OPTIMAL: SolverStatus.OPTIMAL,</span>
+<span id="cb208-92"><a href="#cb208-92" aria-hidden="true" tabindex="-1"></a>        cp_model.FEASIBLE: SolverStatus.ZULAESSIG,</span>
+<span id="cb208-93"><a href="#cb208-93" aria-hidden="true" tabindex="-1"></a>        cp_model.INFEASIBLE: SolverStatus.UNZULAESSIG,</span>
+<span id="cb208-94"><a href="#cb208-94" aria-hidden="true" tabindex="-1"></a>        cp_model.MODEL_INVALID: SolverStatus.FEHLERHAFT,</span>
+<span id="cb208-95"><a href="#cb208-95" aria-hidden="true" tabindex="-1"></a>        cp_model.UNKNOWN: SolverStatus.ZEITLIMIT,</span>
+<span id="cb208-96"><a href="#cb208-96" aria-hidden="true" tabindex="-1"></a>    }</span>
+<span id="cb208-97"><a href="#cb208-97" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> zuordnung.get(rohstatus, SolverStatus.UNBEKANNT)</span>
+<span id="cb208-98"><a href="#cb208-98" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-99"><a href="#cb208-99" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-100"><a href="#cb208-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="cb208-101"><a href="#cb208-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="cb208-102"><a href="#cb208-102" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> {</span>
+<span id="cb208-103"><a href="#cb208-103" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Optimal&quot;</span>: SolverStatus.OPTIMAL,</span>
+<span id="cb208-104"><a href="#cb208-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="cb208-105"><a href="#cb208-105" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Solution limit reached&quot;</span>: SolverStatus.ZULAESSIG,</span>
+<span id="cb208-106"><a href="#cb208-106" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Infeasible&quot;</span>: SolverStatus.UNZULAESSIG,</span>
+<span id="cb208-107"><a href="#cb208-107" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Unbounded&quot;</span>: SolverStatus.UNBESCHRAENKT,</span>
+<span id="cb208-108"><a href="#cb208-108" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Primal infeasible or unbounded&quot;</span>: SolverStatus.UNZULAESSIG,</span>
+<span id="cb208-109"><a href="#cb208-109" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Model error&quot;</span>: SolverStatus.FEHLERHAFT,</span>
+<span id="cb208-110"><a href="#cb208-110" aria-hidden="true" tabindex="-1"></a>    }</span>
+<span id="cb208-111"><a href="#cb208-111" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> zuordnung.get(statustext, SolverStatus.UNBEKANNT)</span>
+<span id="cb208-112"><a href="#cb208-112" aria-hidden="true" tabindex="-1"></a></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 class="kw">def</span> status_von_scipy(ergebnis: Any) <span class="op">-&gt;</span> SolverStatus:</span>
+<span id="cb208-115"><a href="#cb208-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="cb208-116"><a href="#cb208-116" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> {</span>
+<span id="cb208-117"><a href="#cb208-117" aria-hidden="true" tabindex="-1"></a>        <span class="dv">0</span>: SolverStatus.OPTIMAL,</span>
+<span id="cb208-118"><a href="#cb208-118" aria-hidden="true" tabindex="-1"></a>        <span class="dv">1</span>: SolverStatus.ZEITLIMIT,        <span class="co"># Iterations-/Zeitgrenze</span></span>
+<span id="cb208-119"><a href="#cb208-119" aria-hidden="true" tabindex="-1"></a>        <span class="dv">2</span>: SolverStatus.UNZULAESSIG,</span>
+<span id="cb208-120"><a href="#cb208-120" aria-hidden="true" tabindex="-1"></a>        <span class="dv">3</span>: SolverStatus.UNBESCHRAENKT,</span>
+<span id="cb208-121"><a href="#cb208-121" aria-hidden="true" tabindex="-1"></a>        <span class="dv">4</span>: SolverStatus.FEHLERHAFT,       <span class="co"># numerische Schwierigkeiten</span></span>
+<span id="cb208-122"><a href="#cb208-122" aria-hidden="true" tabindex="-1"></a>    }</span>
+<span id="cb208-123"><a href="#cb208-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="cb208-124"><a href="#cb208-124" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-125"><a href="#cb208-125" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-126"><a href="#cb208-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="cb208-127"><a href="#cb208-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="cb208-128"><a href="#cb208-128" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> {</span>
+<span id="cb208-129"><a href="#cb208-129" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;optimal&quot;</span>: SolverStatus.OPTIMAL,</span>
+<span id="cb208-130"><a href="#cb208-130" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;optimal_inaccurate&quot;</span>: SolverStatus.ZULAESSIG,</span>
+<span id="cb208-131"><a href="#cb208-131" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;infeasible&quot;</span>: SolverStatus.UNZULAESSIG,</span>
+<span id="cb208-132"><a href="#cb208-132" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;infeasible_inaccurate&quot;</span>: SolverStatus.UNZULAESSIG,</span>
+<span id="cb208-133"><a href="#cb208-133" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;unbounded&quot;</span>: SolverStatus.UNBESCHRAENKT,</span>
+<span id="cb208-134"><a href="#cb208-134" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;unbounded_inaccurate&quot;</span>: SolverStatus.UNBESCHRAENKT,</span>
+<span id="cb208-135"><a href="#cb208-135" aria-hidden="true" tabindex="-1"></a>    }</span>
+<span id="cb208-136"><a href="#cb208-136" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> zuordnung.get(statustext, SolverStatus.UNBEKANNT)</span>
+<span id="cb208-137"><a href="#cb208-137" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-138"><a href="#cb208-138" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-139"><a href="#cb208-139" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 2. Die Loesung als solverunabhaengiges Datenobjekt ----------------------</span></span>
+<span id="cb208-140"><a href="#cb208-140" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-141"><a href="#cb208-141" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Loesung(BaseModel):</span>
+<span id="cb208-142"><a href="#cb208-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="cb208-143"><a href="#cb208-143" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-144"><a href="#cb208-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="cb208-145"><a href="#cb208-145" aria-hidden="true" tabindex="-1"></a><span class="co">    Test oder eine Weiterverarbeitung soll nicht wissen muessen, womit</span></span>
+<span id="cb208-146"><a href="#cb208-146" aria-hidden="true" tabindex="-1"></a><span class="co">    gerechnet wurde.</span></span>
+<span id="cb208-147"><a href="#cb208-147" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb208-148"><a href="#cb208-148" aria-hidden="true" tabindex="-1"></a>    status: SolverStatus</span>
+<span id="cb208-149"><a href="#cb208-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="cb208-150"><a href="#cb208-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="cb208-151"><a href="#cb208-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="cb208-152"><a href="#cb208-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="cb208-153"><a href="#cb208-153" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Schattenpreise je Nebenbedingung, sofern der Solver sie liefert</span></span>
+<span id="cb208-154"><a href="#cb208-154" aria-hidden="true" tabindex="-1"></a>    <span class="co"># (nur bei kontinuierlichen Problemen, siehe Kapitel LP). Auch das ist</span></span>
+<span id="cb208-155"><a href="#cb208-155" aria-hidden="true" tabindex="-1"></a>    <span class="co"># ein solverunabhaengiger Begriff und gehoert deshalb hierher.</span></span>
+<span id="cb208-156"><a href="#cb208-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="cb208-157"><a href="#cb208-157" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-158"><a href="#cb208-158" aria-hidden="true" tabindex="-1"></a>    <span class="at">@property</span></span>
+<span id="cb208-159"><a href="#cb208-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="cb208-160"><a href="#cb208-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="cb208-161"><a href="#cb208-161" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-162"><a href="#cb208-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="cb208-163"><a href="#cb208-163" aria-hidden="true" tabindex="-1"></a><span class="co">        Zusage - schlechter als das kann die Loesung nicht sein.</span></span>
+<span id="cb208-164"><a href="#cb208-164" aria-hidden="true" tabindex="-1"></a><span class="co">        &quot;&quot;&quot;</span></span>
+<span id="cb208-165"><a href="#cb208-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="cb208-166"><a href="#cb208-166" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> <span class="va">None</span></span>
+<span id="cb208-167"><a href="#cb208-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="cb208-168"><a href="#cb208-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="cb208-169"><a href="#cb208-169" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-170"><a href="#cb208-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="cb208-171"><a href="#cb208-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="cb208-172"><a href="#cb208-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="cb208-173"><a href="#cb208-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="cb208-174"><a href="#cb208-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="cb208-175"><a href="#cb208-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="cb208-176"><a href="#cb208-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="cb208-177"><a href="#cb208-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="cb208-178"><a href="#cb208-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="cb208-179"><a href="#cb208-179" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="st">&quot; | &quot;</span>.join(teile)</span>
+<span id="cb208-180"><a href="#cb208-180" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-181"><a href="#cb208-181" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-182"><a href="#cb208-182" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 3. Domaenenmodell: die Fakten, bevor ein Solver sie sieht ---------------</span></span>
+<span id="cb208-183"><a href="#cb208-183" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-184"><a href="#cb208-184" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Produkt(BaseModel):</span>
+<span id="cb208-185"><a href="#cb208-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="cb208-186"><a href="#cb208-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="cb208-187"><a href="#cb208-187" aria-hidden="true" tabindex="-1"></a>    deckungsbeitrag: <span class="bu">float</span></span>
+<span id="cb208-188"><a href="#cb208-188" aria-hidden="true" tabindex="-1"></a>    verbrauch: <span class="bu">dict</span>[<span class="bu">str</span>, NichtNegativ]</span>
+<span id="cb208-189"><a href="#cb208-189" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-190"><a href="#cb208-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="cb208-191"><a href="#cb208-191" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-192"><a href="#cb208-192" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-193"><a href="#cb208-193" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Produktionsproblem(BaseModel):</span>
+<span id="cb208-194"><a href="#cb208-194" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Produktionsprogrammplanung - das Modell aus Kapitel Einfuehrung.</span></span>
+<span id="cb208-195"><a href="#cb208-195" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-196"><a href="#cb208-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="cb208-197"><a href="#cb208-197" aria-hidden="true" tabindex="-1"></a><span class="co">    unabhaengig davon, mit welcher Bibliothek spaeter gerechnet wird - und sie</span></span>
+<span id="cb208-198"><a href="#cb208-198" aria-hidden="true" tabindex="-1"></a><span class="co">    schlagen beim EINLESEN zu, wo der Fehler noch zuzuordnen ist.</span></span>
+<span id="cb208-199"><a href="#cb208-199" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb208-200"><a href="#cb208-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="cb208-201"><a href="#cb208-201" aria-hidden="true" tabindex="-1"></a>    kapazitaeten: <span class="bu">dict</span>[<span class="bu">str</span>, PositiveZahl]</span>
+<span id="cb208-202"><a href="#cb208-202" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-203"><a href="#cb208-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="cb208-204"><a href="#cb208-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="cb208-205"><a href="#cb208-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="cb208-206"><a href="#cb208-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="cb208-207"><a href="#cb208-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="cb208-208"><a href="#cb208-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="cb208-209"><a href="#cb208-209" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-210"><a href="#cb208-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="cb208-211"><a href="#cb208-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="cb208-212"><a href="#cb208-212" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> unbekannt:</span>
+<span id="cb208-213"><a href="#cb208-213" aria-hidden="true" tabindex="-1"></a>                <span class="cf">raise</span> <span class="pp">ValueError</span>(</span>
+<span id="cb208-214"><a href="#cb208-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="cb208-215"><a href="#cb208-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="cb208-216"><a href="#cb208-216" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">self</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="at">@property</span></span>
+<span id="cb208-219"><a href="#cb208-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="cb208-220"><a href="#cb208-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="cb208-221"><a href="#cb208-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="cb208-222"><a href="#cb208-222" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-223"><a href="#cb208-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="cb208-224"><a href="#cb208-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="cb208-225"><a href="#cb208-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="cb208-226"><a href="#cb208-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="cb208-227"><a href="#cb208-227" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-228"><a href="#cb208-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="cb208-229"><a href="#cb208-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="cb208-230"><a href="#cb208-230" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-231"><a href="#cb208-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="cb208-232"><a href="#cb208-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="cb208-233"><a href="#cb208-233" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-234"><a href="#cb208-234" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-235"><a href="#cb208-235" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 4. Abnahmepruefung: Loesung gegen Anforderung, ohne Solver --------------</span></span>
+<span id="cb208-236"><a href="#cb208-236" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-237"><a href="#cb208-237" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> pruefe_loesung(problem: Produktionsproblem, loesung: Loesung,</span>
+<span id="cb208-238"><a href="#cb208-238" aria-hidden="true" tabindex="-1"></a>                   ganzzahlig: Sequence[<span class="bu">str</span>] <span class="op">=</span> (),</span>
+<span id="cb208-239"><a href="#cb208-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="cb208-240"><a href="#cb208-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="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><span class="co">    Diese Funktion darf ausdruecklich KEIN Solverobjekt und keine</span></span>
+<span id="cb208-243"><a href="#cb208-243" aria-hidden="true" tabindex="-1"></a><span class="co">    Modellvariable benutzen. Eine Pruefung aus denselben Bausteinen wie das</span></span>
+<span id="cb208-244"><a href="#cb208-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="cb208-245"><a href="#cb208-245" aria-hidden="true" tabindex="-1"></a><span class="co">    Denkfehler in den Kapiteln Graphen und MILP).</span></span>
+<span id="cb208-246"><a href="#cb208-246" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-247"><a href="#cb208-247" aria-hidden="true" tabindex="-1"></a><span class="co">    Liefert eine Liste von Beanstandungen; leer heisst bestanden.</span></span>
+<span id="cb208-248"><a href="#cb208-248" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb208-249"><a href="#cb208-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="cb208-250"><a href="#cb208-250" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-251"><a href="#cb208-251" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> loesung.status.brauchbar:</span>
+<span id="cb208-252"><a href="#cb208-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="cb208-253"><a href="#cb208-253" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-254"><a href="#cb208-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="cb208-255"><a href="#cb208-255" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> fehlend:</span>
+<span id="cb208-256"><a href="#cb208-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="cb208-257"><a href="#cb208-257" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-258"><a href="#cb208-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="cb208-259"><a href="#cb208-259" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-260"><a href="#cb208-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="cb208-261"><a href="#cb208-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="cb208-262"><a href="#cb208-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="cb208-263"><a href="#cb208-263" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-264"><a href="#cb208-264" aria-hidden="true" tabindex="-1"></a>    verbrauch <span class="op">=</span> problem.verbrauchsmatrix() <span class="op">@</span> mengen</span>
+<span id="cb208-265"><a href="#cb208-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="cb208-266"><a href="#cb208-266" aria-hidden="true" tabindex="-1"></a>                                      problem.kapazitaetsvektor()):</span>
+<span id="cb208-267"><a href="#cb208-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="cb208-268"><a href="#cb208-268" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(</span>
+<span id="cb208-269"><a href="#cb208-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="cb208-270"><a href="#cb208-270" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-271"><a href="#cb208-271" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name <span class="kw">in</span> ganzzahlig:</span>
+<span id="cb208-272"><a href="#cb208-272" aria-hidden="true" tabindex="-1"></a>        wert <span class="op">=</span> loesung.werte[name]</span>
+<span id="cb208-273"><a href="#cb208-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="cb208-274"><a href="#cb208-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="cb208-275"><a href="#cb208-275" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-276"><a href="#cb208-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="cb208-277"><a href="#cb208-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="cb208-278"><a href="#cb208-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="cb208-279"><a href="#cb208-279" aria-hidden="true" tabindex="-1"></a>            beanstandungen.append(</span>
+<span id="cb208-280"><a href="#cb208-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="cb208-281"><a href="#cb208-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="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="cf">return</span> beanstandungen</span>
+<span id="cb208-284"><a href="#cb208-284" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-285"><a href="#cb208-285" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-286"><a href="#cb208-286" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 5. Ein Modellbauer je Solver - austauschbar ----------------------------</span></span>
+<span id="cb208-287"><a href="#cb208-287" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-288"><a href="#cb208-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="cb208-289"><a href="#cb208-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="cb208-290"><a href="#cb208-290" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> time</span>
+<span id="cb208-291"><a href="#cb208-291" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> ortools.linear_solver <span class="im">import</span> pywraplp</span>
+<span id="cb208-292"><a href="#cb208-292" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-293"><a href="#cb208-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="cb208-294"><a href="#cb208-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="cb208-295"><a href="#cb208-295" aria-hidden="true" tabindex="-1"></a>             <span class="cf">for</span> p <span class="kw">in</span> problem.produkte}</span>
+<span id="cb208-296"><a href="#cb208-296" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Die Nebenbedingung wird gemerkt - ohne die Referenz gibt es spaeter</span></span>
+<span id="cb208-297"><a href="#cb208-297" aria-hidden="true" tabindex="-1"></a>    <span class="co"># keinen Schattenpreis (siehe Kapitel LP).</span></span>
+<span id="cb208-298"><a href="#cb208-298" aria-hidden="true" tabindex="-1"></a>    bedingung <span class="op">=</span> {}</span>
+<span id="cb208-299"><a href="#cb208-299" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> ressource <span class="kw">in</span> problem.ressourcen:</span>
+<span id="cb208-300"><a href="#cb208-300" aria-hidden="true" tabindex="-1"></a>        bedingung[ressource] <span class="op">=</span> solver.Add(</span>
+<span id="cb208-301"><a href="#cb208-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="cb208-302"><a href="#cb208-302" aria-hidden="true" tabindex="-1"></a>                <span class="cf">for</span> p <span class="kw">in</span> problem.produkte)</span>
+<span id="cb208-303"><a href="#cb208-303" aria-hidden="true" tabindex="-1"></a>            <span class="op">&lt;=</span> problem.kapazitaeten[ressource], name<span class="op">=</span>ressource)</span>
+<span id="cb208-304"><a href="#cb208-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="cb208-305"><a href="#cb208-305" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-306"><a href="#cb208-306" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb208-307"><a href="#cb208-307" aria-hidden="true" tabindex="-1"></a>    rohstatus <span class="op">=</span> solver.Solve()</span>
+<span id="cb208-308"><a href="#cb208-308" aria-hidden="true" tabindex="-1"></a>    laufzeit <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb208-309"><a href="#cb208-309" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-310"><a href="#cb208-310" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> status_von_pywraplp(rohstatus)</span>
+<span id="cb208-311"><a href="#cb208-311" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> status.brauchbar:</span>
+<span id="cb208-312"><a href="#cb208-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="cb208-313"><a href="#cb208-313" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Loesung(status<span class="op">=</span>status,</span>
+<span id="cb208-314"><a href="#cb208-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="cb208-315"><a href="#cb208-315" aria-hidden="true" tabindex="-1"></a>                   zielwert<span class="op">=</span>solver.Objective().Value(),</span>
+<span id="cb208-316"><a href="#cb208-316" aria-hidden="true" tabindex="-1"></a>                   schranke<span class="op">=</span>solver.Objective().Value(),</span>
+<span id="cb208-317"><a href="#cb208-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="cb208-318"><a href="#cb208-318" aria-hidden="true" tabindex="-1"></a>                   laufzeit<span class="op">=</span>laufzeit)</span>
+<span id="cb208-319"><a href="#cb208-319" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-320"><a href="#cb208-320" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-321"><a href="#cb208-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="cb208-322"><a href="#cb208-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="cb208-323"><a href="#cb208-323" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-324"><a href="#cb208-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="cb208-325"><a href="#cb208-325" aria-hidden="true" tabindex="-1"></a><span class="co">    dem Domaenenmodell, die Auswertung geht ans gemeinsame Loesung-Objekt.</span></span>
+<span id="cb208-326"><a href="#cb208-326" aria-hidden="true" tabindex="-1"></a><span class="co">    Genau das ist der Ertrag der Trennung.</span></span>
+<span id="cb208-327"><a href="#cb208-327" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb208-328"><a href="#cb208-328" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> time</span>
+<span id="cb208-329"><a href="#cb208-329" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
+<span id="cb208-330"><a href="#cb208-330" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-331"><a href="#cb208-331" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb208-332"><a href="#cb208-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="cb208-333"><a href="#cb208-333" aria-hidden="true" tabindex="-1"></a>                       A_ub<span class="op">=</span>problem.verbrauchsmatrix(),</span>
+<span id="cb208-334"><a href="#cb208-334" aria-hidden="true" tabindex="-1"></a>                       b_ub<span class="op">=</span>problem.kapazitaetsvektor(),</span>
+<span id="cb208-335"><a href="#cb208-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="cb208-336"><a href="#cb208-336" aria-hidden="true" tabindex="-1"></a>    laufzeit <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb208-337"><a href="#cb208-337" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-338"><a href="#cb208-338" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> status_von_scipy(ergebnis)</span>
+<span id="cb208-339"><a href="#cb208-339" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> status.brauchbar:</span>
+<span id="cb208-340"><a href="#cb208-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="cb208-341"><a href="#cb208-341" aria-hidden="true" tabindex="-1"></a>    <span class="co"># linprog rechnet minimierend mit negierten Kosten - die Dualwerte</span></span>
+<span id="cb208-342"><a href="#cb208-342" aria-hidden="true" tabindex="-1"></a>    <span class="co"># muessen entsprechend zurueckgedreht werden.</span></span>
+<span id="cb208-343"><a href="#cb208-343" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Loesung(status<span class="op">=</span>status,</span>
+<span id="cb208-344"><a href="#cb208-344" aria-hidden="true" tabindex="-1"></a>                   werte<span class="op">=</span>{p.name: <span class="bu">float</span>(x)</span>
+<span id="cb208-345"><a href="#cb208-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="cb208-346"><a href="#cb208-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="cb208-347"><a href="#cb208-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="cb208-348"><a href="#cb208-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="cb208-349"><a href="#cb208-349" aria-hidden="true" tabindex="-1"></a>                                   <span class="bu">zip</span>(problem.ressourcen,</span>
+<span id="cb208-350"><a href="#cb208-350" aria-hidden="true" tabindex="-1"></a>                                       ergebnis.ineqlin.marginals)},</span>
+<span id="cb208-351"><a href="#cb208-351" aria-hidden="true" tabindex="-1"></a>                   laufzeit<span class="op">=</span>laufzeit)</span>
+<span id="cb208-352"><a href="#cb208-352" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-353"><a href="#cb208-353" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-354"><a href="#cb208-354" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 6. Ein- und Ausgabe: Tabellen sind die Wirklichkeit ---------------------</span></span>
+<span id="cb208-355"><a href="#cb208-355" aria-hidden="true" tabindex="-1"></a><span class="co">#</span></span>
+<span id="cb208-356"><a href="#cb208-356" aria-hidden="true" tabindex="-1"></a><span class="co"># In den meisten Betrieben liegen die Zahlen in einer Tabellenkalkulation</span></span>
+<span id="cb208-357"><a href="#cb208-357" aria-hidden="true" tabindex="-1"></a><span class="co"># (Kapitel Einfuehrung). Diese beiden Funktionen sind die einzige Stelle im</span></span>
+<span id="cb208-358"><a href="#cb208-358" aria-hidden="true" tabindex="-1"></a><span class="co"># Modul, die das weiss - alles andere arbeitet mit dem Domaenenmodell.</span></span>
+<span id="cb208-359"><a href="#cb208-359" aria-hidden="true" tabindex="-1"></a><span class="co">#</span></span>
+<span id="cb208-360"><a href="#cb208-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="cb208-361"><a href="#cb208-361" aria-hidden="true" tabindex="-1"></a><span class="co"># fuer Statusauswertung und Pruefung benutzt, soll sie nicht installieren</span></span>
+<span id="cb208-362"><a href="#cb208-362" aria-hidden="true" tabindex="-1"></a><span class="co"># muessen.</span></span>
+<span id="cb208-363"><a href="#cb208-363" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-364"><a href="#cb208-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="cb208-365"><a href="#cb208-365" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-366"><a href="#cb208-366" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-367"><a href="#cb208-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="cb208-368"><a href="#cb208-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="cb208-369"><a href="#cb208-369" aria-hidden="true" tabindex="-1"></a>                            ) <span class="op">-&gt;</span> Produktionsproblem:</span>
+<span id="cb208-370"><a href="#cb208-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="cb208-371"><a href="#cb208-371" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-372"><a href="#cb208-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="cb208-373"><a href="#cb208-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="cb208-374"><a href="#cb208-374" aria-hidden="true" tabindex="-1"></a><span class="co">    Mappe und erfordert keine Codeaenderung.</span></span>
+<span id="cb208-375"><a href="#cb208-375" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-376"><a href="#cb208-376" aria-hidden="true" tabindex="-1"></a><span class="co">    Die eigentliche Pruefung passiert nicht hier, sondern im Konstruktor von</span></span>
+<span id="cb208-377"><a href="#cb208-377" aria-hidden="true" tabindex="-1"></a><span class="co">    Produktionsproblem. Diese Funktion uebersetzt nur Tabelle in Objekt; was</span></span>
+<span id="cb208-378"><a href="#cb208-378" aria-hidden="true" tabindex="-1"></a><span class="co">    ein gueltiges Problem ist, steht an genau einer Stelle.</span></span>
+<span id="cb208-379"><a href="#cb208-379" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb208-380"><a href="#cb208-380" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> pandas <span class="im">as</span> pd</span>
+<span id="cb208-381"><a href="#cb208-381" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-382"><a href="#cb208-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="cb208-383"><a href="#cb208-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="cb208-384"><a href="#cb208-384" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-385"><a href="#cb208-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="cb208-386"><a href="#cb208-386" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> fehlende:</span>
+<span id="cb208-387"><a href="#cb208-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="cb208-388"><a href="#cb208-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="cb208-389"><a href="#cb208-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="cb208-390"><a href="#cb208-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="cb208-391"><a href="#cb208-391" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-392"><a href="#cb208-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="cb208-393"><a href="#cb208-393" aria-hidden="true" tabindex="-1"></a>    produkte <span class="op">=</span> [</span>
+<span id="cb208-394"><a href="#cb208-394" aria-hidden="true" tabindex="-1"></a>        Produkt(name<span class="op">=</span><span class="bu">str</span>(zeile.Produkt),</span>
+<span id="cb208-395"><a href="#cb208-395" aria-hidden="true" tabindex="-1"></a>                deckungsbeitrag<span class="op">=</span><span class="bu">float</span>(zeile.Deckungsbeitrag),</span>
+<span id="cb208-396"><a href="#cb208-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="cb208-397"><a href="#cb208-397" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> zeile <span class="kw">in</span> produkte_tabelle.itertuples()</span>
+<span id="cb208-398"><a href="#cb208-398" aria-hidden="true" tabindex="-1"></a>    ]</span>
+<span id="cb208-399"><a href="#cb208-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="cb208-400"><a href="#cb208-400" aria-hidden="true" tabindex="-1"></a>                    <span class="cf">for</span> z <span class="kw">in</span> kapazitaeten_tabelle.itertuples()}</span>
+<span id="cb208-401"><a href="#cb208-401" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-402"><a href="#cb208-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="cb208-403"><a href="#cb208-403" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-404"><a href="#cb208-404" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-405"><a href="#cb208-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="cb208-406"><a href="#cb208-406" aria-hidden="true" tabindex="-1"></a>                      loesung: Loesung) <span class="op">-&gt;</span> <span class="va">None</span>:</span>
+<span id="cb208-407"><a href="#cb208-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="cb208-408"><a href="#cb208-408" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-409"><a href="#cb208-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="cb208-410"><a href="#cb208-410" aria-hidden="true" tabindex="-1"></a><span class="co">    Akzeptanz entscheidet ueber Projekterfolg (Kapitel Praxisfallen).</span></span>
+<span id="cb208-411"><a href="#cb208-411" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb208-412"><a href="#cb208-412" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> pandas <span class="im">as</span> pd</span>
+<span id="cb208-413"><a href="#cb208-413" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-414"><a href="#cb208-414" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> loesung.status.brauchbar:</span>
+<span id="cb208-415"><a href="#cb208-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="cb208-416"><a href="#cb208-416" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-417"><a href="#cb208-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="cb208-418"><a href="#cb208-418" aria-hidden="true" tabindex="-1"></a>    plan <span class="op">=</span> pd.DataFrame({</span>
+<span id="cb208-419"><a href="#cb208-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="cb208-420"><a href="#cb208-420" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Menge&quot;</span>: mengen,</span>
+<span id="cb208-421"><a href="#cb208-421" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Deckungsbeitrag&quot;</span>: mengen <span class="op">*</span> problem.deckungsbeitragsvektor(),</span>
+<span id="cb208-422"><a href="#cb208-422" aria-hidden="true" tabindex="-1"></a>    })</span>
+<span id="cb208-423"><a href="#cb208-423" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-424"><a href="#cb208-424" aria-hidden="true" tabindex="-1"></a>    verbrauch <span class="op">=</span> problem.verbrauchsmatrix() <span class="op">@</span> mengen</span>
+<span id="cb208-425"><a href="#cb208-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="cb208-426"><a href="#cb208-426" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Status&quot;</span>: loesung.status.value,</span>
+<span id="cb208-427"><a href="#cb208-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="cb208-428"><a href="#cb208-428" aria-hidden="true" tabindex="-1"></a>    }</span>
+<span id="cb208-429"><a href="#cb208-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="cb208-430"><a href="#cb208-430" aria-hidden="true" tabindex="-1"></a>                                      problem.kapazitaetsvektor()):</span>
+<span id="cb208-431"><a href="#cb208-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="cb208-432"><a href="#cb208-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="cb208-433"><a href="#cb208-433" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> ressource <span class="kw">in</span> loesung.schattenpreise:</span>
+<span id="cb208-434"><a href="#cb208-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="cb208-435"><a href="#cb208-435" aria-hidden="true" tabindex="-1"></a>                loesung.schattenpreise[ressource]</span>
+<span id="cb208-436"><a href="#cb208-436" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-437"><a href="#cb208-437" aria-hidden="true" tabindex="-1"></a>    kennzahlen_tabelle <span class="op">=</span> pd.DataFrame({</span>
+<span id="cb208-438"><a href="#cb208-438" aria-hidden="true" tabindex="-1"></a>        <span class="st">&quot;Kennzahl&quot;</span>: <span class="bu">list</span>(kennzahlen),</span>
+<span id="cb208-439"><a href="#cb208-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="cb208-440"><a href="#cb208-440" aria-hidden="true" tabindex="-1"></a>                 <span class="cf">for</span> w <span class="kw">in</span> kennzahlen.values()],</span>
+<span id="cb208-441"><a href="#cb208-441" aria-hidden="true" tabindex="-1"></a>    })</span>
+<span id="cb208-442"><a href="#cb208-442" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-443"><a href="#cb208-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="cb208-444"><a href="#cb208-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="cb208-445"><a href="#cb208-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="cb208-446"><a href="#cb208-446" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-447"><a href="#cb208-447" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-448"><a href="#cb208-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="cb208-449"><a href="#cb208-449" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Die Schreinerei aus Kapitel Einfuehrung - jetzt als Domaenenmodell.</span></span>
+<span id="cb208-450"><a href="#cb208-450" aria-hidden="true" tabindex="-1"></a>    schreinerei <span class="op">=</span> Produktionsproblem(</span>
+<span id="cb208-451"><a href="#cb208-451" aria-hidden="true" tabindex="-1"></a>        produkte<span class="op">=</span>[</span>
+<span id="cb208-452"><a href="#cb208-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="cb208-453"><a href="#cb208-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="cb208-454"><a href="#cb208-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="cb208-455"><a href="#cb208-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="cb208-456"><a href="#cb208-456" aria-hidden="true" tabindex="-1"></a>        ],</span>
+<span id="cb208-457"><a href="#cb208-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="cb208-458"><a href="#cb208-458" aria-hidden="true" tabindex="-1"></a>    )</span>
+<span id="cb208-459"><a href="#cb208-459" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-460"><a href="#cb208-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="cb208-461"><a href="#cb208-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="cb208-462"><a href="#cb208-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="cb208-463"><a href="#cb208-463" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-464"><a href="#cb208-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="cb208-465"><a href="#cb208-465" aria-hidden="true" tabindex="-1"></a>                        (<span class="st">&quot;scipy / HiGHS&quot;</span>, loese_mit_scipy)]:</span>
+<span id="cb208-466"><a href="#cb208-466" aria-hidden="true" tabindex="-1"></a>        loesung <span class="op">=</span> bauer(schreinerei)</span>
+<span id="cb208-467"><a href="#cb208-467" aria-hidden="true" tabindex="-1"></a>        beanstandungen <span class="op">=</span> pruefe_loesung(schreinerei, loesung)</span>
+<span id="cb208-468"><a href="#cb208-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="cb208-469"><a href="#cb208-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="cb208-470"><a href="#cb208-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="cb208-471"><a href="#cb208-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="cb208-472"><a href="#cb208-472" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Abnahmepruefung: &quot;</span></span>
+<span id="cb208-473"><a href="#cb208-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="cb208-474"><a href="#cb208-474" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-475"><a href="#cb208-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="cb208-476"><a href="#cb208-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="cb208-477"><a href="#cb208-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="cb208-478"><a href="#cb208-478" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-479"><a href="#cb208-479" aria-hidden="true" tabindex="-1"></a>    faelle <span class="op">=</span> [</span>
+<span id="cb208-480"><a href="#cb208-480" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;Kapazitaet 0&quot;</span>, <span class="bu">dict</span>(</span>
+<span id="cb208-481"><a href="#cb208-481" aria-hidden="true" tabindex="-1"></a>            produkte<span class="op">=</span>schreinerei.produkte,</span>
+<span id="cb208-482"><a href="#cb208-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="cb208-483"><a href="#cb208-483" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;Ressource ohne Kapazitaet&quot;</span>, <span class="bu">dict</span>(</span>
+<span id="cb208-484"><a href="#cb208-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="cb208-485"><a href="#cb208-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="cb208-486"><a href="#cb208-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="cb208-487"><a href="#cb208-487" aria-hidden="true" tabindex="-1"></a>        (<span class="st">&quot;doppelter Produktname&quot;</span>, <span class="bu">dict</span>(</span>
+<span id="cb208-488"><a href="#cb208-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="cb208-489"><a href="#cb208-489" aria-hidden="true" tabindex="-1"></a>            kapazitaeten<span class="op">=</span>schreinerei.kapazitaeten)),</span>
+<span id="cb208-490"><a href="#cb208-490" aria-hidden="true" tabindex="-1"></a>    ]</span>
+<span id="cb208-491"><a href="#cb208-491" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> beschreibung, daten <span class="kw">in</span> faelle:</span>
+<span id="cb208-492"><a href="#cb208-492" aria-hidden="true" tabindex="-1"></a>        <span class="cf">try</span>:</span>
+<span id="cb208-493"><a href="#cb208-493" aria-hidden="true" tabindex="-1"></a>            Produktionsproblem(<span class="op">**</span>daten)</span>
+<span id="cb208-494"><a href="#cb208-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="cb208-495"><a href="#cb208-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="cb208-496"><a href="#cb208-496" aria-hidden="true" tabindex="-1"></a>            meldung <span class="op">=</span> <span class="bu">str</span>(fehler).splitlines()</span>
+<span id="cb208-497"><a href="#cb208-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="cb208-498"><a href="#cb208-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="cb208-499"><a href="#cb208-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="cb208-500"><a href="#cb208-500" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb208-501"><a href="#cb208-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="cb208-502"><a href="#cb208-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="cb208-503"><a href="#cb208-503" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Domaenenschicht.&quot;</span>)</span>
+<span id="cb208-504"><a href="#cb208-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
@@ -25800,7 +26244,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>
@@ -25845,330 +26289,330 @@ 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="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="bu">print</span>(MODELLBAUER[sys.argv[<span class="dv">1</span>]](problem).model_dump_json())   <span class="co"># im Kindprozess</span></span>
+<span id="cb210-2"><a href="#cb210-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="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"># Solverwechsel_CPSAT_HiGHS.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: Denselben Fall einmal mit CP-SAT und einmal mit HiGHS rechnen.</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">Die Trennung aus or_kern.py behauptet, ein Solverwechsel koste genau EINEN</span></span>
+<span id="cb211-8"><a href="#cb211-8" aria-hidden="true" tabindex="-1"></a><span class="co">Baustein. Dieses Programm loest diese Behauptung ein. Aufgabe ist eine</span></span>
+<span id="cb211-9"><a href="#cb211-9" aria-hidden="true" tabindex="-1"></a><span class="co">Standortplanung: Welche Lager oeffnen wir, und wer beliefert welchen Kunden?</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">    Standortproblem  (Pydantic, geprueft)   &lt;- gemeinsam</span></span>
+<span id="cb211-12"><a href="#cb211-12" aria-hidden="true" tabindex="-1"></a><span class="co">        baue_und_loese_mit_cpsat()          &lt;- der EINE Baustein</span></span>
+<span id="cb211-13"><a href="#cb211-13" aria-hidden="true" tabindex="-1"></a><span class="co">        baue_und_loese_mit_highs()          &lt;- ... in zwei Ausfuehrungen</span></span>
+<span id="cb211-14"><a href="#cb211-14" aria-hidden="true" tabindex="-1"></a><span class="co">    Loesung          (DTO)                  &lt;- gemeinsam</span></span>
+<span id="cb211-15"><a href="#cb211-15" aria-hidden="true" tabindex="-1"></a><span class="co">    pruefe_zuordnung()                      &lt;- gemeinsam</span></span>
+<span id="cb211-16"><a href="#cb211-16" aria-hidden="true" tabindex="-1"></a><span class="co">    berichte()                              &lt;- gemeinsam</span></span>
+<span id="cb211-17"><a href="#cb211-17" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-18"><a href="#cb211-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="cb211-19"><a href="#cb211-19" aria-hidden="true" tabindex="-1"></a><span class="co">solverabhaengige Teil des Programms. Alles andere wird zweimal benutzt und</span></span>
+<span id="cb211-20"><a href="#cb211-20" aria-hidden="true" tabindex="-1"></a><span class="co">einmal geschrieben.</span></span>
+<span id="cb211-21"><a href="#cb211-21" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-22"><a href="#cb211-22" aria-hidden="true" tabindex="-1"></a><span class="co">WARUM ZWEI PROZESSE? ortools und highspy bringen beide eine eigene</span></span>
+<span id="cb211-23"><a href="#cb211-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="cb211-24"><a href="#cb211-24" aria-hidden="true" tabindex="-1"></a><span class="co">importieren (Kapitel Oekosystem). Das Hauptprogramm startet deshalb fuer jeden</span></span>
+<span id="cb211-25"><a href="#cb211-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="cb211-26"><a href="#cb211-26" aria-hidden="true" tabindex="-1"></a><span class="co">zurueckgeben - das DTO ist nicht nur eine Sprachregelung, sondern ein</span></span>
+<span id="cb211-27"><a href="#cb211-27" aria-hidden="true" tabindex="-1"></a><span class="co">Datenformat, das eine Prozessgrenze ueberlebt.</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="co">Aufruf:</span></span>
+<span id="cb211-30"><a href="#cb211-30" aria-hidden="true" tabindex="-1"></a><span class="co">    python3 Solverwechsel_CPSAT_HiGHS.py            # beide, mit Vergleich</span></span>
+<span id="cb211-31"><a href="#cb211-31" aria-hidden="true" tabindex="-1"></a><span class="co">    python3 Solverwechsel_CPSAT_HiGHS.py cpsat      # nur der Kindprozess</span></span>
+<span id="cb211-32"><a href="#cb211-32" aria-hidden="true" tabindex="-1"></a><span class="co">    python3 Solverwechsel_CPSAT_HiGHS.py highs</span></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="co">Benoetigt: numpy, pydantic, ortools, highspy (jeweils im eigenen Prozess)</span></span>
+<span id="cb211-35"><a href="#cb211-35" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></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><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb211-38"><a href="#cb211-38" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-39"><a href="#cb211-39" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> subprocess</span>
+<span id="cb211-40"><a href="#cb211-40" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> sys</span>
+<span id="cb211-41"><a href="#cb211-41" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
+<span id="cb211-42"><a href="#cb211-42" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-43"><a href="#cb211-43" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb211-44"><a href="#cb211-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="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="im">from</span> or_kern <span class="im">import</span> Loesung, SolverStatus, status_von_cpsat, status_von_highs</span>
+<span id="cb211-47"><a href="#cb211-47" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-48"><a href="#cb211-48" aria-hidden="true" tabindex="-1"></a>ZEITLIMIT <span class="op">=</span> <span class="fl">30.0</span></span>
+<span id="cb211-49"><a href="#cb211-49" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-50"><a href="#cb211-50" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-51"><a href="#cb211-51" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 1. Domaenenmodell: dieselben Fakten fuer beide Solver -------------------</span></span>
+<span id="cb211-52"><a href="#cb211-52" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-53"><a href="#cb211-53" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Standortproblem(BaseModel):</span>
+<span id="cb211-54"><a href="#cb211-54" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Kapazitierte Standortplanung mit Einzelbelieferung.</span></span>
+<span id="cb211-55"><a href="#cb211-55" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-56"><a href="#cb211-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="cb211-57"><a href="#cb211-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="cb211-58"><a href="#cb211-58" aria-hidden="true" tabindex="-1"></a><span class="co">    Solver, und sie schlagen beim Einlesen zu.</span></span>
+<span id="cb211-59"><a href="#cb211-59" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-60"><a href="#cb211-60" aria-hidden="true" tabindex="-1"></a><span class="co">    Alle Kosten sind ganzzahlig (Euro). Das ist keine Bequemlichkeit, sondern</span></span>
+<span id="cb211-61"><a href="#cb211-61" aria-hidden="true" tabindex="-1"></a><span class="co">    Voraussetzung: CP-SAT rechnet ausschliesslich ganzzahlig.</span></span>
+<span id="cb211-62"><a href="#cb211-62" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb211-63"><a href="#cb211-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="cb211-64"><a href="#cb211-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="cb211-65"><a href="#cb211-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="cb211-66"><a href="#cb211-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="cb211-67"><a href="#cb211-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="cb211-68"><a href="#cb211-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="cb211-69"><a href="#cb211-69" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-70"><a href="#cb211-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="cb211-71"><a href="#cb211-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="cb211-72"><a href="#cb211-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="cb211-73"><a href="#cb211-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="cb211-74"><a href="#cb211-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="cb211-75"><a href="#cb211-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="cb211-76"><a href="#cb211-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="cb211-77"><a href="#cb211-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="cb211-78"><a href="#cb211-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="cb211-79"><a href="#cb211-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="cb211-80"><a href="#cb211-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="cb211-81"><a href="#cb211-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="cb211-82"><a href="#cb211-82" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> <span class="va">self</span></span>
+<span id="cb211-83"><a href="#cb211-83" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-84"><a href="#cb211-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="cb211-85"><a href="#cb211-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="cb211-86"><a href="#cb211-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="cb211-87"><a href="#cb211-87" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-88"><a href="#cb211-88" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-89"><a href="#cb211-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="cb211-90"><a href="#cb211-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="cb211-91"><a href="#cb211-91" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
+<span id="cb211-92"><a href="#cb211-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="cb211-93"><a href="#cb211-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="cb211-94"><a href="#cb211-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="cb211-95"><a href="#cb211-95" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Standortproblem(</span>
+<span id="cb211-96"><a href="#cb211-96" aria-hidden="true" tabindex="-1"></a>        lager<span class="op">=</span>lager,</span>
+<span id="cb211-97"><a href="#cb211-97" aria-hidden="true" tabindex="-1"></a>        kunden<span class="op">=</span>kunden,</span>
+<span id="cb211-98"><a href="#cb211-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="cb211-99"><a href="#cb211-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="cb211-100"><a href="#cb211-100" aria-hidden="true" tabindex="-1"></a>        bedarf<span class="op">=</span>bedarf.tolist(),</span>
+<span id="cb211-101"><a href="#cb211-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="cb211-102"><a href="#cb211-102" aria-hidden="true" tabindex="-1"></a>    )</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></span>
+<span id="cb211-105"><a href="#cb211-105" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 2. Der eine Baustein, der sich aendert: der Modellbauer -----------------</span></span>
+<span id="cb211-106"><a href="#cb211-106" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-107"><a href="#cb211-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="cb211-108"><a href="#cb211-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="cb211-109"><a href="#cb211-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="cb211-110"><a href="#cb211-110" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-111"><a href="#cb211-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="cb211-112"><a href="#cb211-112" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> cp_model.CpModel()</span>
+<span id="cb211-113"><a href="#cb211-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="cb211-114"><a href="#cb211-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="cb211-115"><a href="#cb211-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="cb211-116"><a href="#cb211-116" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-117"><a href="#cb211-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="cb211-118"><a href="#cb211-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="cb211-119"><a href="#cb211-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="cb211-120"><a href="#cb211-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="cb211-121"><a href="#cb211-121" aria-hidden="true" tabindex="-1"></a>            modell.AddImplication(x[i, j], y[i])</span>
+<span id="cb211-122"><a href="#cb211-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="cb211-123"><a href="#cb211-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="cb211-124"><a href="#cb211-124" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-125"><a href="#cb211-125" aria-hidden="true" tabindex="-1"></a>    modell.Minimize(</span>
+<span id="cb211-126"><a href="#cb211-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="cb211-127"><a href="#cb211-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="cb211-128"><a href="#cb211-128" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-129"><a href="#cb211-129" aria-hidden="true" tabindex="-1"></a>    loeser <span class="op">=</span> cp_model.CpSolver()</span>
+<span id="cb211-130"><a href="#cb211-130" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.max_time_in_seconds <span class="op">=</span> ZEITLIMIT</span>
+<span id="cb211-131"><a href="#cb211-131" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.num_workers <span class="op">=</span> <span class="dv">1</span></span>
+<span id="cb211-132"><a href="#cb211-132" aria-hidden="true" tabindex="-1"></a>    loeser.parameters.random_seed <span class="op">=</span> <span class="dv">1</span></span>
+<span id="cb211-133"><a href="#cb211-133" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> status_von_cpsat(loeser.Solve(modell))</span>
+<span id="cb211-134"><a href="#cb211-134" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> status.brauchbar:</span>
+<span id="cb211-135"><a href="#cb211-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="cb211-136"><a href="#cb211-136" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-137"><a href="#cb211-137" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Loesung(</span>
+<span id="cb211-138"><a href="#cb211-138" aria-hidden="true" tabindex="-1"></a>        status<span class="op">=</span>status,</span>
+<span id="cb211-139"><a href="#cb211-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="cb211-140"><a href="#cb211-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="cb211-141"><a href="#cb211-141" aria-hidden="true" tabindex="-1"></a>        zielwert<span class="op">=</span>loeser.ObjectiveValue(),</span>
+<span id="cb211-142"><a href="#cb211-142" aria-hidden="true" tabindex="-1"></a>        schranke<span class="op">=</span>loeser.BestObjectiveBound(),</span>
+<span id="cb211-143"><a href="#cb211-143" aria-hidden="true" tabindex="-1"></a>        laufzeit<span class="op">=</span>loeser.WallTime())</span>
+<span id="cb211-144"><a href="#cb211-144" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-145"><a href="#cb211-145" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-146"><a href="#cb211-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="cb211-147"><a href="#cb211-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="cb211-148"><a href="#cb211-148" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> highspy</span>
+<span id="cb211-149"><a href="#cb211-149" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-150"><a href="#cb211-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="cb211-151"><a href="#cb211-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="cb211-152"><a href="#cb211-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="cb211-153"><a href="#cb211-153" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-154"><a href="#cb211-154" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> highspy.Highs()</span>
+<span id="cb211-155"><a href="#cb211-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="cb211-156"><a href="#cb211-156" aria-hidden="true" tabindex="-1"></a>    modell.setOptionValue(<span class="st">&quot;time_limit&quot;</span>, ZEITLIMIT)</span>
+<span id="cb211-157"><a href="#cb211-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="cb211-158"><a href="#cb211-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="cb211-159"><a href="#cb211-159" aria-hidden="true" tabindex="-1"></a>        modell.changeColIntegrality(spalte, highspy.HighsVarType.kInteger)</span>
+<span id="cb211-160"><a href="#cb211-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="cb211-161"><a href="#cb211-161" aria-hidden="true" tabindex="-1"></a>        modell.changeColCost(spalte_y(i), <span class="bu">float</span>(problem.fixkosten[i]))</span>
+<span id="cb211-162"><a href="#cb211-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="cb211-163"><a href="#cb211-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="cb211-164"><a href="#cb211-164" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-165"><a href="#cb211-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="cb211-166"><a href="#cb211-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="cb211-167"><a href="#cb211-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="cb211-168"><a href="#cb211-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="cb211-169"><a href="#cb211-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="cb211-170"><a href="#cb211-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="cb211-171"><a href="#cb211-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="cb211-172"><a href="#cb211-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="cb211-173"><a href="#cb211-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="cb211-174"><a href="#cb211-174" aria-hidden="true" tabindex="-1"></a>                         dtype<span class="op">=</span>np.int32)                 <span class="co"># Kapazitaet</span></span>
+<span id="cb211-175"><a href="#cb211-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="cb211-176"><a href="#cb211-176" aria-hidden="true" tabindex="-1"></a>                                [<span class="op">-</span><span class="bu">float</span>(problem.kapazitaet[i])]])</span>
+<span id="cb211-177"><a href="#cb211-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="cb211-178"><a href="#cb211-178" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-179"><a href="#cb211-179" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb211-180"><a href="#cb211-180" aria-hidden="true" tabindex="-1"></a>    modell.run()</span>
+<span id="cb211-181"><a href="#cb211-181" aria-hidden="true" tabindex="-1"></a>    laufzeit <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb211-182"><a href="#cb211-182" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-183"><a href="#cb211-183" aria-hidden="true" tabindex="-1"></a>    status <span class="op">=</span> status_von_highs(modell.modelStatusToString(modell.getModelStatus()))</span>
+<span id="cb211-184"><a href="#cb211-184" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> status.brauchbar:</span>
+<span id="cb211-185"><a href="#cb211-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="cb211-186"><a href="#cb211-186" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-187"><a href="#cb211-187" aria-hidden="true" tabindex="-1"></a>    loesungswerte <span class="op">=</span> modell.getSolution().col_value</span>
+<span id="cb211-188"><a href="#cb211-188" aria-hidden="true" tabindex="-1"></a>    info <span class="op">=</span> modell.getInfo()</span>
+<span id="cb211-189"><a href="#cb211-189" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Loesung(</span>
+<span id="cb211-190"><a href="#cb211-190" aria-hidden="true" tabindex="-1"></a>        status<span class="op">=</span>status,</span>
+<span id="cb211-191"><a href="#cb211-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="cb211-192"><a href="#cb211-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="cb211-193"><a href="#cb211-193" aria-hidden="true" tabindex="-1"></a>        zielwert<span class="op">=</span>info.objective_function_value,</span>
+<span id="cb211-194"><a href="#cb211-194" aria-hidden="true" tabindex="-1"></a>        schranke<span class="op">=</span>info.mip_dual_bound,</span>
+<span id="cb211-195"><a href="#cb211-195" aria-hidden="true" tabindex="-1"></a>        laufzeit<span class="op">=</span>laufzeit)</span>
+<span id="cb211-196"><a href="#cb211-196" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-197"><a href="#cb211-197" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-198"><a href="#cb211-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="cb211-199"><a href="#cb211-199" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-200"><a href="#cb211-200" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-201"><a href="#cb211-201" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 3. Alles Weitere ist wieder gemeinsam -----------------------------------</span></span>
+<span id="cb211-202"><a href="#cb211-202" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-203"><a href="#cb211-203" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> pruefe_zuordnung(problem: Standortproblem, loesung: Loesung,</span>
+<span id="cb211-204"><a href="#cb211-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="cb211-205"><a href="#cb211-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="cb211-206"><a href="#cb211-206" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> <span class="kw">not</span> loesung.status.brauchbar:</span>
+<span id="cb211-207"><a href="#cb211-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="cb211-208"><a href="#cb211-208" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-209"><a href="#cb211-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="cb211-210"><a href="#cb211-210" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> np.array([[loesung.werte[problem.schluessel(i, j)]</span>
+<span id="cb211-211"><a href="#cb211-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="cb211-212"><a href="#cb211-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="cb211-213"><a href="#cb211-213" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-214"><a href="#cb211-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="cb211-215"><a href="#cb211-215" aria-hidden="true" tabindex="-1"></a>        beanstandungen.append(<span class="st">&quot;Zuordnungen sind nicht 0/1&quot;</span>)</span>
+<span id="cb211-216"><a href="#cb211-216" aria-hidden="true" tabindex="-1"></a>    zuordnung <span class="op">=</span> np.<span class="bu">round</span>(zuordnung)</span>
+<span id="cb211-217"><a href="#cb211-217" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-218"><a href="#cb211-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="cb211-219"><a href="#cb211-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="cb211-220"><a href="#cb211-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="cb211-221"><a href="#cb211-221" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-222"><a href="#cb211-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="cb211-223"><a href="#cb211-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="cb211-224"><a href="#cb211-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="cb211-225"><a href="#cb211-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="cb211-226"><a href="#cb211-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="cb211-227"><a href="#cb211-227" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-228"><a href="#cb211-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="cb211-229"><a href="#cb211-229" aria-hidden="true" tabindex="-1"></a>        offen <span class="op">=</span> beliefert <span class="op">&gt;</span> toleranz</span>
+<span id="cb211-230"><a href="#cb211-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="cb211-231"><a href="#cb211-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="cb211-232"><a href="#cb211-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="cb211-233"><a href="#cb211-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="cb211-234"><a href="#cb211-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="cb211-235"><a href="#cb211-235" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> beanstandungen</span>
+<span id="cb211-236"><a href="#cb211-236" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-237"><a href="#cb211-237" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-238"><a href="#cb211-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="cb211-239"><a href="#cb211-239" aria-hidden="true" tabindex="-1"></a>    m <span class="op">=</span> <span class="bu">len</span>(problem.kunden)</span>
+<span id="cb211-240"><a href="#cb211-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="cb211-241"><a href="#cb211-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="cb211-242"><a href="#cb211-242" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-243"><a href="#cb211-243" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-244"><a href="#cb211-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="cb211-245"><a href="#cb211-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="cb211-246"><a href="#cb211-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="cb211-247"><a href="#cb211-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="cb211-248"><a href="#cb211-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="cb211-249"><a href="#cb211-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="cb211-250"><a href="#cb211-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="cb211-251"><a href="#cb211-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="cb211-252"><a href="#cb211-252" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-253"><a href="#cb211-253" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-254"><a href="#cb211-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="cb211-255"><a href="#cb211-255" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> beispielproblem()</span>
+<span id="cb211-256"><a href="#cb211-256" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-257"><a href="#cb211-257" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Kindprozess: rechnen und das DTO als JSON ausgeben ---------------</span></span>
+<span id="cb211-258"><a href="#cb211-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="cb211-259"><a href="#cb211-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="cb211-260"><a href="#cb211-260" aria-hidden="true" tabindex="-1"></a>        sys.exit(<span class="dv">0</span>)</span>
+<span id="cb211-261"><a href="#cb211-261" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-262"><a href="#cb211-262" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Hauptprozess: beide Solver anstossen und vergleichen -------------</span></span>
+<span id="cb211-263"><a href="#cb211-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="cb211-264"><a href="#cb211-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="cb211-265"><a href="#cb211-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="cb211-266"><a href="#cb211-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="cb211-267"><a href="#cb211-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="cb211-268"><a href="#cb211-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="cb211-269"><a href="#cb211-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="cb211-270"><a href="#cb211-270" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-271"><a href="#cb211-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="cb211-272"><a href="#cb211-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="cb211-273"><a href="#cb211-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="cb211-274"><a href="#cb211-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="cb211-275"><a href="#cb211-275" aria-hidden="true" tabindex="-1"></a>        beanstandungen <span class="op">=</span> pruefe_zuordnung(problem, loesung)</span>
+<span id="cb211-276"><a href="#cb211-276" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-277"><a href="#cb211-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="cb211-278"><a href="#cb211-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="cb211-279"><a href="#cb211-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="cb211-280"><a href="#cb211-280" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Abnahmepruefung:  &quot;</span></span>
+<span id="cb211-281"><a href="#cb211-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="cb211-282"><a href="#cb211-282" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-283"><a href="#cb211-283" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Was der Vergleich zeigt -----------------------------------------</span></span>
+<span id="cb211-284"><a href="#cb211-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="cb211-285"><a href="#cb211-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="cb211-286"><a href="#cb211-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="cb211-287"><a href="#cb211-287" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-288"><a href="#cb211-288" aria-hidden="true" tabindex="-1"></a>    gleich_belegt <span class="op">=</span> <span class="bu">all</span>(</span>
+<span id="cb211-289"><a href="#cb211-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="cb211-290"><a href="#cb211-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="cb211-291"><a href="#cb211-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="cb211-292"><a href="#cb211-292" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-293"><a href="#cb211-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="cb211-294"><a href="#cb211-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="cb211-295"><a href="#cb211-295" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb211-296"><a href="#cb211-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="cb211-297"><a href="#cb211-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="cb211-298"><a href="#cb211-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="cb211-299"><a href="#cb211-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="cb211-300"><a href="#cb211-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="cb211-301"><a href="#cb211-301" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb211-302"><a href="#cb211-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="cb211-303"><a href="#cb211-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="cb211-304"><a href="#cb211-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="cb211-305"><a href="#cb211-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="cb211-306"><a href="#cb211-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="cb211-307"><a href="#cb211-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="cb211-308"><a href="#cb211-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="cb211-309"><a href="#cb211-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="cb211-310"><a href="#cb211-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="cb211-311"><a href="#cb211-311" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb211-312"><a href="#cb211-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="cb211-313"><a href="#cb211-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="cb211-314"><a href="#cb211-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="cb211-315"><a href="#cb211-315" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb211-316"><a href="#cb211-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="cb211-317"><a href="#cb211-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="cb211-318"><a href="#cb211-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="cb211-319"><a href="#cb211-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="cb211-320"><a href="#cb211-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>
 <p><strong>Erwartete Ausgabe</strong> (Laufzeiten hardwareabhängig):</p>
 <pre><code>==================================================================================
   DERSELBE FALL, ZWEI SOLVER - UND EIN AUSWERTUNGSCODE
@@ -26227,14 +26671,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>
@@ -26284,7 +26728,7 @@ 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>
@@ -26292,10 +26736,11 @@ ein unzuverlaessiger Test (siehe JobShop_Intervalle.py).
 <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.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: Das Modell, das seit einem Jahr nicht mehr optimiert</strong></p>
@@ -26336,186 +26781,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="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"># Betriebsueberwachung.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: Das Modell, das still aufgehoert hat zu optimieren.</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">Ein Optimierungsmodell geht in Betrieb und laeuft jede Nacht. Es liefert</span></span>
+<span id="cb213-8"><a href="#cb213-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="cb213-9"><a href="#cb213-9" aria-hidden="true" tabindex="-1"></a><span class="co">Fehlermeldung. Alles sieht gut aus.</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">Waehrenddessen waechst das Unternehmen. Aus 15 Lagern werden 40, dann 80. Das</span></span>
+<span id="cb213-12"><a href="#cb213-12" aria-hidden="true" tabindex="-1"></a><span class="co">Zeitlimit von drei Sekunden - vor zwei Jahren grosszuegig bemessen - reicht</span></span>
+<span id="cb213-13"><a href="#cb213-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="cb213-14"><a href="#cb213-14" aria-hidden="true" tabindex="-1"></a><span class="co">er bis dahin gefunden hat.</span></span>
+<span id="cb213-15"><a href="#cb213-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-16"><a href="#cb213-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="cb213-17"><a href="#cb213-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="cb213-18"><a href="#cb213-18" aria-hidden="true" tabindex="-1"></a><span class="co">Protokoll nur die Kosten stehen.</span></span>
+<span id="cb213-19"><a href="#cb213-19" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-20"><a href="#cb213-20" aria-hidden="true" tabindex="-1"></a><span class="co">Dieses Programm zeigt die Verschlechterung und die Ueberwachung, die sie</span></span>
+<span id="cb213-21"><a href="#cb213-21" aria-hidden="true" tabindex="-1"></a><span class="co">sichtbar macht.</span></span>
+<span id="cb213-22"><a href="#cb213-22" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-23"><a href="#cb213-23" aria-hidden="true" tabindex="-1"></a><span class="co">WICHTIG: ortools wird hier nicht importiert (Konflikt mit highspy, siehe</span></span>
+<span id="cb213-24"><a href="#cb213-24" aria-hidden="true" tabindex="-1"></a><span class="co">Kapitel Oekosystem).</span></span>
+<span id="cb213-25"><a href="#cb213-25" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-26"><a href="#cb213-26" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, highspy</span></span>
+<span id="cb213-27"><a href="#cb213-27" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</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="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb213-30"><a href="#cb213-30" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-31"><a href="#cb213-31" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
+<span id="cb213-32"><a href="#cb213-32" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> dataclasses <span class="im">import</span> dataclass</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="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb213-35"><a href="#cb213-35" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> highspy</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>ZEITLIMIT <span class="op">=</span> <span class="fl">3.0</span>                  <span class="co"># das Budget, das der Nachtjob hat</span></span>
+<span id="cb213-38"><a href="#cb213-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="cb213-39"><a href="#cb213-39" aria-hidden="true" tabindex="-1"></a>ZEITAUSLASTUNG_WARNSCHWELLE <span class="op">=</span> <span class="fl">0.9</span></span>
+<span id="cb213-40"><a href="#cb213-40" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-41"><a href="#cb213-41" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-42"><a href="#cb213-42" aria-hidden="true" tabindex="-1"></a><span class="at">@dataclass</span></span>
+<span id="cb213-43"><a href="#cb213-43" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Laufprotokoll:</span>
+<span id="cb213-44"><a href="#cb213-44" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Was nach JEDEM Produktivlauf protokolliert gehoert.</span></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="co">    Die meisten Systeme schreiben nur &#39;kosten&#39;. Genau deshalb faellt eine</span></span>
+<span id="cb213-47"><a href="#cb213-47" aria-hidden="true" tabindex="-1"></a><span class="co">    schleichende Verschlechterung ueber Monate nicht auf.</span></span>
+<span id="cb213-48"><a href="#cb213-48" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb213-49"><a href="#cb213-49" aria-hidden="true" tabindex="-1"></a>    zeitpunkt: <span class="bu">str</span></span>
+<span id="cb213-50"><a href="#cb213-50" aria-hidden="true" tabindex="-1"></a>    lager: <span class="bu">int</span></span>
+<span id="cb213-51"><a href="#cb213-51" aria-hidden="true" tabindex="-1"></a>    kunden: <span class="bu">int</span></span>
+<span id="cb213-52"><a href="#cb213-52" aria-hidden="true" tabindex="-1"></a>    status: <span class="bu">str</span></span>
+<span id="cb213-53"><a href="#cb213-53" aria-hidden="true" tabindex="-1"></a>    kosten: <span class="bu">float</span></span>
+<span id="cb213-54"><a href="#cb213-54" aria-hidden="true" tabindex="-1"></a>    gap: <span class="bu">float</span></span>
+<span id="cb213-55"><a href="#cb213-55" aria-hidden="true" tabindex="-1"></a>    laufzeit: <span class="bu">float</span></span>
+<span id="cb213-56"><a href="#cb213-56" aria-hidden="true" tabindex="-1"></a>    knoten: <span class="bu">int</span></span>
+<span id="cb213-57"><a href="#cb213-57" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-58"><a href="#cb213-58" aria-hidden="true" tabindex="-1"></a>    <span class="at">@property</span></span>
+<span id="cb213-59"><a href="#cb213-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="cb213-60"><a href="#cb213-60" aria-hidden="true" tabindex="-1"></a>        meldungen <span class="op">=</span> []</span>
+<span id="cb213-61"><a href="#cb213-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="cb213-62"><a href="#cb213-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="cb213-63"><a href="#cb213-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="cb213-64"><a href="#cb213-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="cb213-65"><a href="#cb213-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="cb213-66"><a href="#cb213-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="cb213-67"><a href="#cb213-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="cb213-68"><a href="#cb213-68" aria-hidden="true" tabindex="-1"></a>                             <span class="ss">f&quot;ausgeschoepft&quot;</span>)</span>
+<span id="cb213-69"><a href="#cb213-69" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> meldungen</span>
+<span id="cb213-70"><a href="#cb213-70" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-71"><a href="#cb213-71" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-72"><a href="#cb213-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="cb213-73"><a href="#cb213-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="cb213-74"><a href="#cb213-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="cb213-75"><a href="#cb213-75" aria-hidden="true" tabindex="-1"></a>    rng <span class="op">=</span> np.random.default_rng(saat)</span>
+<span id="cb213-76"><a href="#cb213-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="cb213-77"><a href="#cb213-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="cb213-78"><a href="#cb213-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="cb213-79"><a href="#cb213-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="cb213-80"><a href="#cb213-80" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-81"><a href="#cb213-81" aria-hidden="true" tabindex="-1"></a>    modell <span class="op">=</span> highspy.Highs()</span>
+<span id="cb213-82"><a href="#cb213-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="cb213-83"><a href="#cb213-83" aria-hidden="true" tabindex="-1"></a>    modell.setOptionValue(<span class="st">&quot;time_limit&quot;</span>, zeitlimit)</span>
+<span id="cb213-84"><a href="#cb213-84" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-85"><a href="#cb213-85" aria-hidden="true" tabindex="-1"></a>    anzahl_x <span class="op">=</span> n_lager <span class="op">*</span> n_kunden</span>
+<span id="cb213-86"><a href="#cb213-86" aria-hidden="true" tabindex="-1"></a>    unendlich <span class="op">=</span> highspy.kHighsInf</span>
+<span id="cb213-87"><a href="#cb213-87" aria-hidden="true" tabindex="-1"></a>    modell.addVars(anzahl_x, np.zeros(anzahl_x), np.full(anzahl_x, unendlich))</span>
+<span id="cb213-88"><a href="#cb213-88" aria-hidden="true" tabindex="-1"></a>    modell.addVars(n_lager, np.zeros(n_lager), np.ones(n_lager))</span>
+<span id="cb213-89"><a href="#cb213-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="cb213-90"><a href="#cb213-90" aria-hidden="true" tabindex="-1"></a>        modell.changeColIntegrality(anzahl_x <span class="op">+</span> i, highspy.HighsVarType.kInteger)</span>
+<span id="cb213-91"><a href="#cb213-91" aria-hidden="true" tabindex="-1"></a>        modell.changeColCost(anzahl_x <span class="op">+</span> i, fixkosten[i])</span>
+<span id="cb213-92"><a href="#cb213-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="cb213-93"><a href="#cb213-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="cb213-94"><a href="#cb213-94" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-95"><a href="#cb213-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="cb213-96"><a href="#cb213-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="cb213-97"><a href="#cb213-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="cb213-98"><a href="#cb213-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="cb213-99"><a href="#cb213-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="cb213-100"><a href="#cb213-100" aria-hidden="true" tabindex="-1"></a>                         dtype<span class="op">=</span>np.int32)</span>
+<span id="cb213-101"><a href="#cb213-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="cb213-102"><a href="#cb213-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="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>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb213-105"><a href="#cb213-105" aria-hidden="true" tabindex="-1"></a>    modell.run()</span>
+<span id="cb213-106"><a href="#cb213-106" aria-hidden="true" tabindex="-1"></a>    laufzeit <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb213-107"><a href="#cb213-107" aria-hidden="true" tabindex="-1"></a>    info <span class="op">=</span> modell.getInfo()</span>
+<span id="cb213-108"><a href="#cb213-108" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> (modell.modelStatusToString(modell.getModelStatus()),</span>
+<span id="cb213-109"><a href="#cb213-109" aria-hidden="true" tabindex="-1"></a>            info.objective_function_value, info.mip_gap, laufzeit,</span>
+<span id="cb213-110"><a href="#cb213-110" aria-hidden="true" tabindex="-1"></a>            info.mip_node_count)</span>
+<span id="cb213-111"><a href="#cb213-111" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-112"><a href="#cb213-112" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-113"><a href="#cb213-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="cb213-114"><a href="#cb213-114" aria-hidden="true" tabindex="-1"></a>    <span class="co"># So ist das Unternehmen ueber zwei Jahre gewachsen.</span></span>
+<span id="cb213-115"><a href="#cb213-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="cb213-116"><a href="#cb213-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="cb213-117"><a href="#cb213-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="cb213-118"><a href="#cb213-118" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-119"><a href="#cb213-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="cb213-120"><a href="#cb213-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="cb213-121"><a href="#cb213-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="cb213-122"><a href="#cb213-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="cb213-123"><a href="#cb213-123" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-124"><a href="#cb213-124" aria-hidden="true" tabindex="-1"></a>    protokolle <span class="op">=</span> []</span>
+<span id="cb213-125"><a href="#cb213-125" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> zeitpunkt, lager, kunden <span class="kw">in</span> entwicklung:</span>
+<span id="cb213-126"><a href="#cb213-126" aria-hidden="true" tabindex="-1"></a>        status, kosten, gap, laufzeit, knoten <span class="op">=</span> plane_netzwerk(</span>
+<span id="cb213-127"><a href="#cb213-127" aria-hidden="true" tabindex="-1"></a>            lager, kunden, ZEITLIMIT)</span>
+<span id="cb213-128"><a href="#cb213-128" aria-hidden="true" tabindex="-1"></a>        protokolle.append(Laufprotokoll(zeitpunkt, lager, kunden, status,</span>
+<span id="cb213-129"><a href="#cb213-129" aria-hidden="true" tabindex="-1"></a>                                        kosten, gap, laufzeit, knoten))</span>
+<span id="cb213-130"><a href="#cb213-130" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-131"><a href="#cb213-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="cb213-132"><a href="#cb213-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="cb213-133"><a href="#cb213-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="cb213-134"><a href="#cb213-134" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> protokolle:</span>
+<span id="cb213-135"><a href="#cb213-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="cb213-136"><a href="#cb213-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="cb213-137"><a href="#cb213-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="cb213-138"><a href="#cb213-138" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-139"><a href="#cb213-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="cb213-140"><a href="#cb213-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="cb213-141"><a href="#cb213-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="cb213-142"><a href="#cb213-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="cb213-143"><a href="#cb213-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="cb213-144"><a href="#cb213-144" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> protokolle:</span>
+<span id="cb213-145"><a href="#cb213-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="cb213-146"><a href="#cb213-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="cb213-147"><a href="#cb213-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="cb213-148"><a href="#cb213-148" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-149"><a href="#cb213-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="cb213-150"><a href="#cb213-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="cb213-151"><a href="#cb213-151" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> protokolle:</span>
+<span id="cb213-152"><a href="#cb213-152" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> p.warnungen:</span>
+<span id="cb213-153"><a href="#cb213-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="cb213-154"><a href="#cb213-154" aria-hidden="true" tabindex="-1"></a>        <span class="cf">else</span>:</span>
+<span id="cb213-155"><a href="#cb213-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="cb213-156"><a href="#cb213-156" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-157"><a href="#cb213-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="cb213-158"><a href="#cb213-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="cb213-159"><a href="#cb213-159" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb213-160"><a href="#cb213-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="cb213-161"><a href="#cb213-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="cb213-162"><a href="#cb213-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="cb213-163"><a href="#cb213-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="cb213-164"><a href="#cb213-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="cb213-165"><a href="#cb213-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="cb213-166"><a href="#cb213-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="cb213-167"><a href="#cb213-167" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb213-168"><a href="#cb213-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="cb213-169"><a href="#cb213-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="cb213-170"><a href="#cb213-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="cb213-171"><a href="#cb213-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="cb213-172"><a href="#cb213-172" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb213-173"><a href="#cb213-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="cb213-174"><a href="#cb213-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="cb213-175"><a href="#cb213-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="cb213-176"><a href="#cb213-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="cb213-177"><a href="#cb213-177" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb213-178"><a href="#cb213-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="cb213-179"><a href="#cb213-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="cb213-180"><a href="#cb213-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
@@ -26579,7 +27024,7 @@ 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 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>
@@ -26588,7 +27033,7 @@ sichtbar wird, und gibt Zeit zum Handeln.
 <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>
@@ -26598,12 +27043,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>
@@ -26617,7 +27068,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 />
@@ -26633,22 +27084,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="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="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb215-2"><a href="#cb215-2" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
+<span id="cb215-3"><a href="#cb215-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-4"><a href="#cb215-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="cb215-5"><a href="#cb215-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="cb215-6"><a href="#cb215-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="cb215-7"><a href="#cb215-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="cb215-8"><a href="#cb215-8" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-9"><a href="#cb215-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="cb215-10"><a href="#cb215-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="cb215-11"><a href="#cb215-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="cb215-12"><a href="#cb215-12" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb215-13"><a href="#cb215-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="cb215-14"><a href="#cb215-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="cb215-15"><a href="#cb215-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="cb215-16"><a href="#cb215-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;
@@ -26675,7 +27126,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="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="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>
@@ -26722,315 +27173,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="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"># test_or_kern.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: Eine Testsuite fuer ein Optimierungsmodell.</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">Das Grundproblem beim Testen von Optimierungsmodellen: Man kennt die richtige</span></span>
+<span id="cb218-8"><a href="#cb218-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="cb218-9"><a href="#cb218-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="cb218-10"><a href="#cb218-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="cb218-11"><a href="#cb218-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-12"><a href="#cb218-12" aria-hidden="true" tabindex="-1"></a><span class="co">Deshalb testet man nicht den WERT, sondern vier andere Dinge:</span></span>
+<span id="cb218-13"><a href="#cb218-13" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-14"><a href="#cb218-14" aria-hidden="true" tabindex="-1"></a><span class="co">  1. EIGENSCHAFTEN  Die Loesung haelt jede Nebenbedingung ein, und der</span></span>
+<span id="cb218-15"><a href="#cb218-15" aria-hidden="true" tabindex="-1"></a><span class="co">                    ausgewiesene Zielwert passt zu den Mengen.</span></span>
+<span id="cb218-16"><a href="#cb218-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="cb218-17"><a href="#cb218-17" aria-hidden="true" tabindex="-1"></a><span class="co">                    Produkte, die Waehrungseinheit, ein zusaetzliches Produkt</span></span>
+<span id="cb218-18"><a href="#cb218-18" aria-hidden="true" tabindex="-1"></a><span class="co">                    mit Deckungsbeitrag 0.</span></span>
+<span id="cb218-19"><a href="#cb218-19" aria-hidden="true" tabindex="-1"></a><span class="co">  3. REGRESSION     Eine kleine Instanz mit von Hand nachgerechnetem Optimum.</span></span>
+<span id="cb218-20"><a href="#cb218-20" aria-hidden="true" tabindex="-1"></a><span class="co">  4. FEHLERFAELLE   Unsinnige Eingaben werden abgewiesen, unloesbare Modelle</span></span>
+<span id="cb218-21"><a href="#cb218-21" aria-hidden="true" tabindex="-1"></a><span class="co">                    als unloesbar erkannt - und die Abnahmepruefung schlaegt</span></span>
+<span id="cb218-22"><a href="#cb218-22" aria-hidden="true" tabindex="-1"></a><span class="co">                    tatsaechlich an, wenn man ihr eine kaputte Loesung gibt.</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">Der vierte Punkt ist der wichtigste und wird am haeufigsten vergessen: Eine</span></span>
+<span id="cb218-25"><a href="#cb218-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="cb218-26"><a href="#cb218-26" aria-hidden="true" tabindex="-1"></a><span class="co">Vermutung. Die Tests unten fuettern `pruefe_loesung()` deshalb absichtlich mit</span></span>
+<span id="cb218-27"><a href="#cb218-27" aria-hidden="true" tabindex="-1"></a><span class="co">falschen Loesungen und verlangen, dass sie anschlaegt.</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">Aufruf:</span></span>
+<span id="cb218-30"><a href="#cb218-30" aria-hidden="true" tabindex="-1"></a><span class="co">    pytest test_or_kern.py -v</span></span>
+<span id="cb218-31"><a href="#cb218-31" aria-hidden="true" tabindex="-1"></a><span class="co">    python3 test_or_kern.py          # ruft pytest selbst auf</span></span>
+<span id="cb218-32"><a href="#cb218-32" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-33"><a href="#cb218-33" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: pytest, numpy, pydantic, ortools, scipy (ueber or_kern)</span></span>
+<span id="cb218-34"><a href="#cb218-34" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb218-35"><a href="#cb218-35" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-36"><a href="#cb218-36" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb218-37"><a href="#cb218-37" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-38"><a href="#cb218-38" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> pytest</span>
+<span id="cb218-39"><a href="#cb218-39" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-40"><a href="#cb218-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="cb218-41"><a href="#cb218-41" aria-hidden="true" tabindex="-1"></a>                     loese_mit_glop, loese_mit_scipy, pruefe_loesung,</span>
+<span id="cb218-42"><a href="#cb218-42" aria-hidden="true" tabindex="-1"></a>                     status_von_scipy)</span>
+<span id="cb218-43"><a href="#cb218-43" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-44"><a href="#cb218-44" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-45"><a href="#cb218-45" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Die Instanz, gegen die getestet wird ----------------------------------</span></span>
+<span id="cb218-46"><a href="#cb218-46" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-47"><a href="#cb218-47" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> schreinerei() <span class="op">-&gt;</span> Produktionsproblem:</span>
+<span id="cb218-48"><a href="#cb218-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="cb218-49"><a href="#cb218-49" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-50"><a href="#cb218-50" aria-hidden="true" tabindex="-1"></a><span class="co">    Optimum: 30 Tische, 60 Stuehle, Deckungsbeitrag 10.800 EUR.</span></span>
+<span id="cb218-51"><a href="#cb218-51" aria-hidden="true" tabindex="-1"></a><span class="co">    Beide Ressourcen sind voll ausgelastet (3*30 + 1*60 = 150,</span></span>
+<span id="cb218-52"><a href="#cb218-52" aria-hidden="true" tabindex="-1"></a><span class="co">    6*30 + 1*60 = 240).</span></span>
+<span id="cb218-53"><a href="#cb218-53" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb218-54"><a href="#cb218-54" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> Produktionsproblem(</span>
+<span id="cb218-55"><a href="#cb218-55" aria-hidden="true" tabindex="-1"></a>        produkte<span class="op">=</span>[</span>
+<span id="cb218-56"><a href="#cb218-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="cb218-57"><a href="#cb218-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="cb218-58"><a href="#cb218-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="cb218-59"><a href="#cb218-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="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>        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="cb218-62"><a href="#cb218-62" aria-hidden="true" tabindex="-1"></a>    )</span>
+<span id="cb218-63"><a href="#cb218-63" aria-hidden="true" tabindex="-1"></a></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="co"># Beide Modellbauer durchlaufen JEDEN Test. Ein Test, der nur mit einem Solver</span></span>
+<span id="cb218-66"><a href="#cb218-66" aria-hidden="true" tabindex="-1"></a><span class="co"># laeuft, prueft die Bibliothek mit - nicht das Modell.</span></span>
+<span id="cb218-67"><a href="#cb218-67" aria-hidden="true" tabindex="-1"></a>MODELLBAUER <span class="op">=</span> [loese_mit_glop, loese_mit_scipy]</span>
+<span id="cb218-68"><a href="#cb218-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="cb218-69"><a href="#cb218-69" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-70"><a href="#cb218-70" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-71"><a href="#cb218-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="cb218-72"><a href="#cb218-72" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> bauer(request):</span>
+<span id="cb218-73"><a href="#cb218-73" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> request.param</span>
+<span id="cb218-74"><a href="#cb218-74" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-75"><a href="#cb218-75" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-76"><a href="#cb218-76" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 1. Eigenschaften ------------------------------------------------------</span></span>
+<span id="cb218-77"><a href="#cb218-77" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-78"><a href="#cb218-78" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_loesung_haelt_alle_nebenbedingungen_ein(bauer):</span>
+<span id="cb218-79"><a href="#cb218-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="cb218-80"><a href="#cb218-80" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
+<span id="cb218-81"><a href="#cb218-81" aria-hidden="true" tabindex="-1"></a>    loesung <span class="op">=</span> bauer(problem)</span>
+<span id="cb218-82"><a href="#cb218-82" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> loesung.status <span class="kw">is</span> SolverStatus.OPTIMAL</span>
+<span id="cb218-83"><a href="#cb218-83" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> pruefe_loesung(problem, loesung) <span class="op">==</span> []</span>
+<span id="cb218-84"><a href="#cb218-84" aria-hidden="true" tabindex="-1"></a></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 class="kw">def</span> test_zielwert_passt_zu_den_mengen(bauer):</span>
+<span id="cb218-87"><a href="#cb218-87" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Der ausgewiesene Zielwert wird unabhaengig nachgerechnet.</span></span>
+<span id="cb218-88"><a href="#cb218-88" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-89"><a href="#cb218-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="cb218-90"><a href="#cb218-90" aria-hidden="true" tabindex="-1"></a><span class="co">    zusammensetzt als im Bericht (etwa Gebuehren einmal abgezogen, einmal</span></span>
+<span id="cb218-91"><a href="#cb218-91" aria-hidden="true" tabindex="-1"></a><span class="co">    nicht), merkt es sonst nie.</span></span>
+<span id="cb218-92"><a href="#cb218-92" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb218-93"><a href="#cb218-93" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
+<span id="cb218-94"><a href="#cb218-94" aria-hidden="true" tabindex="-1"></a>    loesung <span class="op">=</span> bauer(problem)</span>
+<span id="cb218-95"><a href="#cb218-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="cb218-96"><a href="#cb218-96" aria-hidden="true" tabindex="-1"></a>                        <span class="cf">for</span> p <span class="kw">in</span> problem.produkte)</span>
+<span id="cb218-97"><a href="#cb218-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="cb218-98"><a href="#cb218-98" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-99"><a href="#cb218-99" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-100"><a href="#cb218-100" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_beide_solver_liefern_dasselbe():</span>
+<span id="cb218-101"><a href="#cb218-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="cb218-102"><a href="#cb218-102" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
+<span id="cb218-103"><a href="#cb218-103" aria-hidden="true" tabindex="-1"></a>    glop, scipy_ <span class="op">=</span> loese_mit_glop(problem), loese_mit_scipy(problem)</span>
+<span id="cb218-104"><a href="#cb218-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="cb218-105"><a href="#cb218-105" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> ressource <span class="kw">in</span> problem.ressourcen:</span>
+<span id="cb218-106"><a href="#cb218-106" aria-hidden="true" tabindex="-1"></a>        <span class="cf">assert</span> glop.schattenpreise[ressource] <span class="op">==</span> pytest.approx(</span>
+<span id="cb218-107"><a href="#cb218-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="cb218-108"><a href="#cb218-108" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-109"><a href="#cb218-109" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-110"><a href="#cb218-110" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 2. Invarianten --------------------------------------------------------</span></span>
+<span id="cb218-111"><a href="#cb218-111" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-112"><a href="#cb218-112" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_produktreihenfolge_aendert_nichts(bauer):</span>
+<span id="cb218-113"><a href="#cb218-113" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Dieselben Daten in anderer Zeilenreihenfolge - gleiches Ergebnis.</span></span>
+<span id="cb218-114"><a href="#cb218-114" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-115"><a href="#cb218-115" aria-hidden="true" tabindex="-1"></a><span class="co">    Das faengt die Spaltenvertauschungsfalle aus Kapitel Finanzdaten ab: ein</span></span>
+<span id="cb218-116"><a href="#cb218-116" aria-hidden="true" tabindex="-1"></a><span class="co">    Modell, das Positionen statt Namen benutzt, faellt hier durch.</span></span>
+<span id="cb218-117"><a href="#cb218-117" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb218-118"><a href="#cb218-118" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
+<span id="cb218-119"><a href="#cb218-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="cb218-120"><a href="#cb218-120" aria-hidden="true" tabindex="-1"></a>                                 kapazitaeten<span class="op">=</span>problem.kapazitaeten)</span>
+<span id="cb218-121"><a href="#cb218-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="cb218-122"><a href="#cb218-122" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-123"><a href="#cb218-123" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-124"><a href="#cb218-124" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_waehrungseinheit_skaliert_linear(bauer):</span>
+<span id="cb218-125"><a href="#cb218-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="cb218-126"><a href="#cb218-126" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-127"><a href="#cb218-127" aria-hidden="true" tabindex="-1"></a><span class="co">    Der Test prueft nicht die Mathematik - die ist offensichtlich -, sondern</span></span>
+<span id="cb218-128"><a href="#cb218-128" aria-hidden="true" tabindex="-1"></a><span class="co">    die NUMERIK. Wer schlecht skalierte Modelle baut (Kapitel Fundament),</span></span>
+<span id="cb218-129"><a href="#cb218-129" aria-hidden="true" tabindex="-1"></a><span class="co">    bekommt hier Abweichungen weit ueber der Toleranz.</span></span>
+<span id="cb218-130"><a href="#cb218-130" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb218-131"><a href="#cb218-131" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
+<span id="cb218-132"><a href="#cb218-132" aria-hidden="true" tabindex="-1"></a>    in_cent <span class="op">=</span> Produktionsproblem(</span>
+<span id="cb218-133"><a href="#cb218-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="cb218-134"><a href="#cb218-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="cb218-135"><a href="#cb218-135" aria-hidden="true" tabindex="-1"></a>        kapazitaeten<span class="op">=</span>problem.kapazitaeten)</span>
+<span id="cb218-136"><a href="#cb218-136" aria-hidden="true" tabindex="-1"></a>    basis, skaliert <span class="op">=</span> bauer(problem), bauer(in_cent)</span>
+<span id="cb218-137"><a href="#cb218-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="cb218-138"><a href="#cb218-138" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> p <span class="kw">in</span> problem.produkte:</span>
+<span id="cb218-139"><a href="#cb218-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="cb218-140"><a href="#cb218-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="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>
+<span id="cb218-143"><a href="#cb218-143" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_produkt_ohne_deckungsbeitrag_aendert_das_optimum_nicht(bauer):</span>
+<span id="cb218-144"><a href="#cb218-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="cb218-145"><a href="#cb218-145" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
+<span id="cb218-146"><a href="#cb218-146" aria-hidden="true" tabindex="-1"></a>    mit_nullprodukt <span class="op">=</span> Produktionsproblem(</span>
+<span id="cb218-147"><a href="#cb218-147" aria-hidden="true" tabindex="-1"></a>        produkte<span class="op">=</span>problem.produkte <span class="op">+</span> [</span>
+<span id="cb218-148"><a href="#cb218-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="cb218-149"><a href="#cb218-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="cb218-150"><a href="#cb218-150" aria-hidden="true" tabindex="-1"></a>        kapazitaeten<span class="op">=</span>problem.kapazitaeten)</span>
+<span id="cb218-151"><a href="#cb218-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="cb218-152"><a href="#cb218-152" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-153"><a href="#cb218-153" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-154"><a href="#cb218-154" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 3. Regression ---------------------------------------------------------</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="kw">def</span> test_bekanntes_optimum(bauer):</span>
+<span id="cb218-157"><a href="#cb218-157" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Von Hand nachgerechnet (Kapitel Einfuehrung, Handrechnung).</span></span>
+<span id="cb218-158"><a href="#cb218-158" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-159"><a href="#cb218-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="cb218-160"><a href="#cb218-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="cb218-161"><a href="#cb218-161" aria-hidden="true" tabindex="-1"></a><span class="co">    diesen Test nicht; dort tragen die Eigenschaften und Invarianten.</span></span>
+<span id="cb218-162"><a href="#cb218-162" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb218-163"><a href="#cb218-163" aria-hidden="true" tabindex="-1"></a>    loesung <span class="op">=</span> bauer(schreinerei())</span>
+<span id="cb218-164"><a href="#cb218-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="cb218-165"><a href="#cb218-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="cb218-166"><a href="#cb218-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="cb218-167"><a href="#cb218-167" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-168"><a href="#cb218-168" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-169"><a href="#cb218-169" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_schattenpreise_bekannt(bauer):</span>
+<span id="cb218-170"><a href="#cb218-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="cb218-171"><a href="#cb218-171" aria-hidden="true" tabindex="-1"></a>    loesung <span class="op">=</span> bauer(schreinerei())</span>
+<span id="cb218-172"><a href="#cb218-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="cb218-173"><a href="#cb218-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="cb218-174"><a href="#cb218-174" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-175"><a href="#cb218-175" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-176"><a href="#cb218-176" aria-hidden="true" tabindex="-1"></a><span class="co"># --- 4. Fehlerfaelle: schlaegt die Pruefung ueberhaupt an? -----------------</span></span>
+<span id="cb218-177"><a href="#cb218-177" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-178"><a href="#cb218-178" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_pruefung_findet_kapazitaetsverletzung():</span>
+<span id="cb218-179"><a href="#cb218-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="cb218-180"><a href="#cb218-180" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
+<span id="cb218-181"><a href="#cb218-181" aria-hidden="true" tabindex="-1"></a>    kaputt <span class="op">=</span> Loesung(status<span class="op">=</span>SolverStatus.OPTIMAL,</span>
+<span id="cb218-182"><a href="#cb218-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="cb218-183"><a href="#cb218-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="cb218-184"><a href="#cb218-184" aria-hidden="true" tabindex="-1"></a>    beanstandungen <span class="op">=</span> pruefe_loesung(problem, kaputt)</span>
+<span id="cb218-185"><a href="#cb218-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="cb218-186"><a href="#cb218-186" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-187"><a href="#cb218-187" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-188"><a href="#cb218-188" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_pruefung_findet_falschen_zielwert():</span>
+<span id="cb218-189"><a href="#cb218-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="cb218-190"><a href="#cb218-190" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
+<span id="cb218-191"><a href="#cb218-191" aria-hidden="true" tabindex="-1"></a>    kaputt <span class="op">=</span> Loesung(status<span class="op">=</span>SolverStatus.OPTIMAL,</span>
+<span id="cb218-192"><a href="#cb218-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="cb218-193"><a href="#cb218-193" aria-hidden="true" tabindex="-1"></a>                     zielwert<span class="op">=</span><span class="fl">99_999.0</span>)</span>
+<span id="cb218-194"><a href="#cb218-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="cb218-195"><a href="#cb218-195" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-196"><a href="#cb218-196" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-197"><a href="#cb218-197" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_pruefung_findet_negative_mengen():</span>
+<span id="cb218-198"><a href="#cb218-198" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
+<span id="cb218-199"><a href="#cb218-199" aria-hidden="true" tabindex="-1"></a>    kaputt <span class="op">=</span> Loesung(status<span class="op">=</span>SolverStatus.OPTIMAL,</span>
+<span id="cb218-200"><a href="#cb218-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="cb218-201"><a href="#cb218-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="cb218-202"><a href="#cb218-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="cb218-203"><a href="#cb218-203" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-204"><a href="#cb218-204" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-205"><a href="#cb218-205" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_pruefung_findet_gebrochene_ganzzahligkeit():</span>
+<span id="cb218-206"><a href="#cb218-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="cb218-207"><a href="#cb218-207" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
+<span id="cb218-208"><a href="#cb218-208" aria-hidden="true" tabindex="-1"></a>    fast_ganz <span class="op">=</span> Loesung(status<span class="op">=</span>SolverStatus.OPTIMAL,</span>
+<span id="cb218-209"><a href="#cb218-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="cb218-210"><a href="#cb218-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="cb218-211"><a href="#cb218-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="cb218-212"><a href="#cb218-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="cb218-213"><a href="#cb218-213" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-214"><a href="#cb218-214" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-215"><a href="#cb218-215" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_pruefung_verweigert_unbrauchbaren_status():</span>
+<span id="cb218-216"><a href="#cb218-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="cb218-217"><a href="#cb218-217" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
+<span id="cb218-218"><a href="#cb218-218" aria-hidden="true" tabindex="-1"></a>    ohne <span class="op">=</span> Loesung(status<span class="op">=</span>SolverStatus.UNZULAESSIG)</span>
+<span id="cb218-219"><a href="#cb218-219" aria-hidden="true" tabindex="-1"></a>    beanstandungen <span class="op">=</span> pruefe_loesung(problem, ohne)</span>
+<span id="cb218-220"><a href="#cb218-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="cb218-221"><a href="#cb218-221" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-222"><a href="#cb218-222" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-223"><a href="#cb218-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="cb218-224"><a href="#cb218-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="cb218-225"><a href="#cb218-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="cb218-226"><a href="#cb218-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="cb218-227"><a href="#cb218-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="cb218-228"><a href="#cb218-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="cb218-229"><a href="#cb218-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="cb218-230"><a href="#cb218-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="cb218-231"><a href="#cb218-231" aria-hidden="true" tabindex="-1"></a>])</span>
+<span id="cb218-232"><a href="#cb218-232" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_unsinnige_eingaben_werden_beim_einlesen_abgewiesen(daten, stichwort):</span>
+<span id="cb218-233"><a href="#cb218-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="cb218-234"><a href="#cb218-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="cb218-235"><a href="#cb218-235" aria-hidden="true" tabindex="-1"></a>        Produktionsproblem(<span class="op">**</span>daten)</span>
+<span id="cb218-236"><a href="#cb218-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="cb218-237"><a href="#cb218-237" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-238"><a href="#cb218-238" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-239"><a href="#cb218-239" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_doppelter_produktname_wird_abgewiesen():</span>
+<span id="cb218-240"><a href="#cb218-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="cb218-241"><a href="#cb218-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="cb218-242"><a href="#cb218-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="cb218-243"><a href="#cb218-243" aria-hidden="true" tabindex="-1"></a>        Produktionsproblem(produkte<span class="op">=</span>[produkt, produkt],</span>
+<span id="cb218-244"><a href="#cb218-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="cb218-245"><a href="#cb218-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="cb218-246"><a href="#cb218-246" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-247"><a href="#cb218-247" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-248"><a href="#cb218-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="cb218-249"><a href="#cb218-249" aria-hidden="true" tabindex="-1"></a>    (<span class="dv">0</span>, SolverStatus.OPTIMAL),</span>
+<span id="cb218-250"><a href="#cb218-250" aria-hidden="true" tabindex="-1"></a>    (<span class="dv">1</span>, SolverStatus.ZEITLIMIT),</span>
+<span id="cb218-251"><a href="#cb218-251" aria-hidden="true" tabindex="-1"></a>    (<span class="dv">2</span>, SolverStatus.UNZULAESSIG),</span>
+<span id="cb218-252"><a href="#cb218-252" aria-hidden="true" tabindex="-1"></a>    (<span class="dv">3</span>, SolverStatus.UNBESCHRAENKT),</span>
+<span id="cb218-253"><a href="#cb218-253" aria-hidden="true" tabindex="-1"></a>    (<span class="dv">4</span>, SolverStatus.FEHLERHAFT),</span>
+<span id="cb218-254"><a href="#cb218-254" aria-hidden="true" tabindex="-1"></a>    (<span class="dv">99</span>, SolverStatus.UNBEKANNT),</span>
+<span id="cb218-255"><a href="#cb218-255" aria-hidden="true" tabindex="-1"></a>])</span>
+<span id="cb218-256"><a href="#cb218-256" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_statusuebersetzung_scipy(rohstatus, erwartet):</span>
+<span id="cb218-257"><a href="#cb218-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="cb218-258"><a href="#cb218-258" aria-hidden="true" tabindex="-1"></a>    <span class="kw">class</span> Ergebnis:</span>
+<span id="cb218-259"><a href="#cb218-259" aria-hidden="true" tabindex="-1"></a>        status <span class="op">=</span> rohstatus</span>
+<span id="cb218-260"><a href="#cb218-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="cb218-261"><a href="#cb218-261" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-262"><a href="#cb218-262" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-263"><a href="#cb218-263" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_status_eigenschaften_sind_konsistent():</span>
+<span id="cb218-264"><a href="#cb218-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="cb218-265"><a href="#cb218-265" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> status <span class="kw">in</span> SolverStatus:</span>
+<span id="cb218-266"><a href="#cb218-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="cb218-267"><a href="#cb218-267" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-268"><a href="#cb218-268" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-269"><a href="#cb218-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="cb218-270"><a href="#cb218-270" aria-hidden="true" tabindex="-1"></a><span class="co"># Mutationstest.py zwei eingebaute Fehler UEBERLEBEN liess - siehe den</span></span>
+<span id="cb218-271"><a href="#cb218-271" aria-hidden="true" tabindex="-1"></a><span class="co"># Abschnitt &quot;Wer testet die Tests?&quot;.</span></span>
+<span id="cb218-272"><a href="#cb218-272" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-273"><a href="#cb218-273" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_nur_optimal_und_zulaessig_gelten_als_brauchbar():</span>
+<span id="cb218-274"><a href="#cb218-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="cb218-275"><a href="#cb218-275" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-276"><a href="#cb218-276" aria-hidden="true" tabindex="-1"></a><span class="co">    Der Unterschied entscheidet, ob ein Nachtjob einen Plan ausliefert oder</span></span>
+<span id="cb218-277"><a href="#cb218-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="cb218-278"><a href="#cb218-278" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb218-279"><a href="#cb218-279" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> SolverStatus.OPTIMAL.brauchbar</span>
+<span id="cb218-280"><a href="#cb218-280" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> SolverStatus.ZULAESSIG.brauchbar</span>
+<span id="cb218-281"><a href="#cb218-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="cb218-282"><a href="#cb218-282" aria-hidden="true" tabindex="-1"></a>                   SolverStatus.UNBESCHRAENKT, SolverStatus.FEHLERHAFT,</span>
+<span id="cb218-283"><a href="#cb218-283" aria-hidden="true" tabindex="-1"></a>                   SolverStatus.UNBEKANNT):</span>
+<span id="cb218-284"><a href="#cb218-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="cb218-285"><a href="#cb218-285" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-286"><a href="#cb218-286" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-287"><a href="#cb218-287" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> test_ressourcenreihenfolge_haengt_nicht_an_der_eingabe():</span>
+<span id="cb218-288"><a href="#cb218-288" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Zwei Mappings mit gleichem Inhalt, andere Einfuegereihenfolge.</span></span>
+<span id="cb218-289"><a href="#cb218-289" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-290"><a href="#cb218-290" aria-hidden="true" tabindex="-1"></a><span class="co">    Die Verbrauchsmatrix muss zeilenweise identisch sein. Ohne diese</span></span>
+<span id="cb218-291"><a href="#cb218-291" aria-hidden="true" tabindex="-1"></a><span class="co">    Zusicherung passt die Matrix irgendwann nicht mehr zum</span></span>
+<span id="cb218-292"><a href="#cb218-292" aria-hidden="true" tabindex="-1"></a><span class="co">    Kapazitaetsvektor - die Vertauschungsfalle aus Kapitel Finanzdaten,</span></span>
+<span id="cb218-293"><a href="#cb218-293" aria-hidden="true" tabindex="-1"></a><span class="co">    nur eine Ebene tiefer.</span></span>
+<span id="cb218-294"><a href="#cb218-294" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb218-295"><a href="#cb218-295" aria-hidden="true" tabindex="-1"></a>    produkte <span class="op">=</span> schreinerei().produkte</span>
+<span id="cb218-296"><a href="#cb218-296" aria-hidden="true" tabindex="-1"></a>    vorwaerts <span class="op">=</span> Produktionsproblem(</span>
+<span id="cb218-297"><a href="#cb218-297" aria-hidden="true" tabindex="-1"></a>        produkte<span class="op">=</span>produkte,</span>
+<span id="cb218-298"><a href="#cb218-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="cb218-299"><a href="#cb218-299" aria-hidden="true" tabindex="-1"></a>    rueckwaerts <span class="op">=</span> Produktionsproblem(</span>
+<span id="cb218-300"><a href="#cb218-300" aria-hidden="true" tabindex="-1"></a>        produkte<span class="op">=</span>produkte,</span>
+<span id="cb218-301"><a href="#cb218-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="cb218-302"><a href="#cb218-302" aria-hidden="true" tabindex="-1"></a>    <span class="cf">assert</span> vorwaerts.ressourcen <span class="op">==</span> rueckwaerts.ressourcen</span>
+<span id="cb218-303"><a href="#cb218-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="cb218-304"><a href="#cb218-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="cb218-305"><a href="#cb218-305" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-306"><a href="#cb218-306" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb218-307"><a href="#cb218-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="cb218-308"><a href="#cb218-308" aria-hidden="true" tabindex="-1"></a>    <span class="im">import</span> sys</span>
+<span id="cb218-309"><a href="#cb218-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>
@@ -27107,185 +27558,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="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"># Mutationstest.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: Wer testet die Tests?</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">`test_or_kern.py` besteht aus 31 Tests, und alle sind gruen. Das ist noch kein</span></span>
+<span id="cb220-8"><a href="#cb220-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="cb220-9"><a href="#cb220-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="cb220-10"><a href="#cb220-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-11"><a href="#cb220-11" aria-hidden="true" tabindex="-1"></a><span class="co">Dieses Programm prueft die Pruefung. Es baut nacheinander KLEINE, gezielte</span></span>
+<span id="cb220-12"><a href="#cb220-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="cb220-13"><a href="#cb220-13" aria-hidden="true" tabindex="-1"></a><span class="co">Programmieren tatsaechlich macht - und laesst die Testsuite darauf los. Fuer</span></span>
+<span id="cb220-14"><a href="#cb220-14" aria-hidden="true" tabindex="-1"></a><span class="co">jede Mutation gibt es genau zwei moegliche Ausgaenge:</span></span>
+<span id="cb220-15"><a href="#cb220-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-16"><a href="#cb220-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="cb220-17"><a href="#cb220-17" aria-hidden="true" tabindex="-1"></a><span class="co">                in der Praxis gefunden.</span></span>
+<span id="cb220-18"><a href="#cb220-18" aria-hidden="true" tabindex="-1"></a><span class="co">    UEBERLEBT   Alle Tests bleiben gruen. Die Suite haette diesen Fehler</span></span>
+<span id="cb220-19"><a href="#cb220-19" aria-hidden="true" tabindex="-1"></a><span class="co">                DURCHGEHEN LASSEN - hier fehlt ein Test.</span></span>
+<span id="cb220-20"><a href="#cb220-20" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-21"><a href="#cb220-21" aria-hidden="true" tabindex="-1"></a><span class="co">Ueberlebende Mutationen sind das eigentliche Ergebnis: Sie zeigen die Luecken,</span></span>
+<span id="cb220-22"><a href="#cb220-22" aria-hidden="true" tabindex="-1"></a><span class="co">und zwar ohne dass man sie erraten muss.</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">Das Verfahren heisst Mutationstest und ist alt; neu ist nur, wie gut es zu</span></span>
+<span id="cb220-25"><a href="#cb220-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="cb220-26"><a href="#cb220-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="cb220-27"><a href="#cb220-27" aria-hidden="true" tabindex="-1"></a><span class="co">die Ersatzpruefungen (Eigenschaften, Invarianten) ueberhaupt greifen.</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">WICHTIG: Es wird nichts veraendert. Jede Mutation laeuft in einem eigenen</span></span>
+<span id="cb220-30"><a href="#cb220-30" aria-hidden="true" tabindex="-1"></a><span class="co">temporaeren Verzeichnis mit einer Kopie von or_kern.py.</span></span>
+<span id="cb220-31"><a href="#cb220-31" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-32"><a href="#cb220-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="cb220-33"><a href="#cb220-33" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb220-34"><a href="#cb220-34" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-35"><a href="#cb220-35" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb220-36"><a href="#cb220-36" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-37"><a href="#cb220-37" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> os</span>
+<span id="cb220-38"><a href="#cb220-38" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> shutil</span>
+<span id="cb220-39"><a href="#cb220-39" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> subprocess</span>
+<span id="cb220-40"><a href="#cb220-40" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> sys</span>
+<span id="cb220-41"><a href="#cb220-41" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> tempfile</span>
+<span id="cb220-42"><a href="#cb220-42" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-43"><a href="#cb220-43" aria-hidden="true" tabindex="-1"></a><span class="co"># (Name, gesuchter Text, Ersatz) - jede Zeile ein realistischer Fehler.</span></span>
+<span id="cb220-44"><a href="#cb220-44" aria-hidden="true" tabindex="-1"></a>MUTATIONEN <span class="op">=</span> [</span>
+<span id="cb220-45"><a href="#cb220-45" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Nebenbedingung umgedreht (&lt;= wird &gt;=)&quot;</span>,</span>
+<span id="cb220-46"><a href="#cb220-46" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;&lt;= problem.kapazitaeten[ressource], name=ressource)&quot;</span>,</span>
+<span id="cb220-47"><a href="#cb220-47" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;&gt;= problem.kapazitaeten[ressource], name=ressource)&quot;</span>),</span>
+<span id="cb220-48"><a href="#cb220-48" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-49"><a href="#cb220-49" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Maximierung wird Minimierung&quot;</span>,</span>
+<span id="cb220-50"><a href="#cb220-50" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;solver.Maximize(sum(menge[p.name] * p.deckungsbeitrag&quot;</span>,</span>
+<span id="cb220-51"><a href="#cb220-51" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;solver.Minimize(sum(menge[p.name] * p.deckungsbeitrag&quot;</span>),</span>
+<span id="cb220-52"><a href="#cb220-52" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-53"><a href="#cb220-53" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Vorzeichen der Dualwerte vergessen&quot;</span>,</span>
+<span id="cb220-54"><a href="#cb220-54" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;schattenpreise={r: float(-m) for r, m in&quot;</span>,</span>
+<span id="cb220-55"><a href="#cb220-55" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;schattenpreise={r: float(m) for r, m in&quot;</span>),</span>
+<span id="cb220-56"><a href="#cb220-56" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-57"><a href="#cb220-57" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Abnahmepruefung aufgeweicht (Toleranz 1e-6 -&gt; 1.0)&quot;</span>,</span>
+<span id="cb220-58"><a href="#cb220-58" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;toleranz: float = 1e-6) -&gt; list[str]:&quot;</span>,</span>
+<span id="cb220-59"><a href="#cb220-59" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;toleranz: float = 1.0) -&gt; list[str]:&quot;</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>    (<span class="st">&quot;Kapazitaetspruefung uebersprungen&quot;</span>,</span>
+<span id="cb220-62"><a href="#cb220-62" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;if ist &gt; grenze + toleranz:&quot;</span>,</span>
+<span id="cb220-63"><a href="#cb220-63" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;if False:&quot;</span>),</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="st">&quot;Pruefung auf doppelte Produktnamen entfernt&quot;</span>,</span>
+<span id="cb220-66"><a href="#cb220-66" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;if len(set(namen)) != len(namen):&quot;</span>,</span>
+<span id="cb220-67"><a href="#cb220-67" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;if False:&quot;</span>),</span>
+<span id="cb220-68"><a href="#cb220-68" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-69"><a href="#cb220-69" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Ganzzahligkeitspruefung entfernt&quot;</span>,</span>
+<span id="cb220-70"><a href="#cb220-70" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;if abs(wert - round(wert)) &gt; toleranz:&quot;</span>,</span>
+<span id="cb220-71"><a href="#cb220-71" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;if False:&quot;</span>),</span>
+<span id="cb220-72"><a href="#cb220-72" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-73"><a href="#cb220-73" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Zielwertabgleich entfernt&quot;</span>,</span>
+<span id="cb220-74"><a href="#cb220-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="cb220-75"><a href="#cb220-75" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;if False:&quot;</span>),</span>
+<span id="cb220-76"><a href="#cb220-76" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-77"><a href="#cb220-77" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;ZEITLIMIT gilt faelschlich als brauchbar&quot;</span>,</span>
+<span id="cb220-78"><a href="#cb220-78" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;return self in (SolverStatus.OPTIMAL, SolverStatus.ZULAESSIG)&quot;</span>,</span>
+<span id="cb220-79"><a href="#cb220-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="cb220-80"><a href="#cb220-80" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;                        SolverStatus.ZEITLIMIT)&quot;</span>),</span>
+<span id="cb220-81"><a href="#cb220-81" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-82"><a href="#cb220-82" aria-hidden="true" tabindex="-1"></a>    (<span class="st">&quot;Ressourcenreihenfolge nicht mehr stabil&quot;</span>,</span>
+<span id="cb220-83"><a href="#cb220-83" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;return sorted(self.kapazitaeten)&quot;</span>,</span>
+<span id="cb220-84"><a href="#cb220-84" aria-hidden="true" tabindex="-1"></a>     <span class="st">&quot;return list(self.kapazitaeten)&quot;</span>),</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>
+<span id="cb220-87"><a href="#cb220-87" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-88"><a href="#cb220-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="cb220-89"><a href="#cb220-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="cb220-90"><a href="#cb220-90" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> subprocess.run(</span>
+<span id="cb220-91"><a href="#cb220-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="cb220-92"><a href="#cb220-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="cb220-93"><a href="#cb220-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="cb220-94"><a href="#cb220-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="cb220-95"><a href="#cb220-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="cb220-96"><a href="#cb220-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="cb220-97"><a href="#cb220-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="cb220-98"><a href="#cb220-98" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> wort <span class="kw">in</span> teil.split():</span>
+<span id="cb220-99"><a href="#cb220-99" aria-hidden="true" tabindex="-1"></a>            <span class="cf">if</span> wort.isdigit():</span>
+<span id="cb220-100"><a href="#cb220-100" aria-hidden="true" tabindex="-1"></a>                zahl <span class="op">=</span> <span class="bu">int</span>(wort)</span>
+<span id="cb220-101"><a href="#cb220-101" aria-hidden="true" tabindex="-1"></a>            <span class="cf">elif</span> wort.startswith(<span class="st">&quot;passed&quot;</span>):</span>
+<span id="cb220-102"><a href="#cb220-102" aria-hidden="true" tabindex="-1"></a>                bestanden <span class="op">=</span> zahl</span>
+<span id="cb220-103"><a href="#cb220-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="cb220-104"><a href="#cb220-104" aria-hidden="true" tabindex="-1"></a>                fehlgeschlagen <span class="op">+=</span> zahl</span>
+<span id="cb220-105"><a href="#cb220-105" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> bestanden, fehlgeschlagen, zeile</span>
+<span id="cb220-106"><a href="#cb220-106" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-107"><a href="#cb220-107" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-108"><a href="#cb220-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="cb220-109"><a href="#cb220-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="cb220-110"><a href="#cb220-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="cb220-111"><a href="#cb220-111" aria-hidden="true" tabindex="-1"></a>    <span class="cf">with</span> tempfile.TemporaryDirectory() <span class="im">as</span> verzeichnis:</span>
+<span id="cb220-112"><a href="#cb220-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="cb220-113"><a href="#cb220-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="cb220-114"><a href="#cb220-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="cb220-115"><a href="#cb220-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="cb220-116"><a href="#cb220-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="cb220-117"><a href="#cb220-117" aria-hidden="true" tabindex="-1"></a>        shutil.copy(ziel, verzeichnis)</span>
+<span id="cb220-118"><a href="#cb220-118" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span> fuehre_suite_aus(verzeichnis)</span>
+<span id="cb220-119"><a href="#cb220-119" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-120"><a href="#cb220-120" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-121"><a href="#cb220-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="cb220-122"><a href="#cb220-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="cb220-123"><a href="#cb220-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="cb220-124"><a href="#cb220-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="cb220-125"><a href="#cb220-125" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> pfad <span class="kw">in</span> (quelle, suite):</span>
+<span id="cb220-126"><a href="#cb220-126" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="kw">not</span> os.path.exists(pfad):</span>
+<span id="cb220-127"><a href="#cb220-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="cb220-128"><a href="#cb220-128" aria-hidden="true" tabindex="-1"></a>                             <span class="ss">f&quot;Beide Dateien muessen im selben Verzeichnis liegen.&quot;</span>)</span>
+<span id="cb220-129"><a href="#cb220-129" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-130"><a href="#cb220-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="cb220-131"><a href="#cb220-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="cb220-132"><a href="#cb220-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="cb220-133"><a href="#cb220-133" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-134"><a href="#cb220-134" aria-hidden="true" tabindex="-1"></a>    <span class="cf">with</span> tempfile.TemporaryDirectory() <span class="im">as</span> v:</span>
+<span id="cb220-135"><a href="#cb220-135" aria-hidden="true" tabindex="-1"></a>        shutil.copy(quelle, v)</span>
+<span id="cb220-136"><a href="#cb220-136" aria-hidden="true" tabindex="-1"></a>        shutil.copy(suite, v)</span>
+<span id="cb220-137"><a href="#cb220-137" aria-hidden="true" tabindex="-1"></a>        bestanden, fehlgeschlagen, _ <span class="op">=</span> fuehre_suite_aus(v)</span>
+<span id="cb220-138"><a href="#cb220-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="cb220-139"><a href="#cb220-139" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> fehlgeschlagen:</span>
+<span id="cb220-140"><a href="#cb220-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="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 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="cb220-143"><a href="#cb220-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="cb220-144"><a href="#cb220-144" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-145"><a href="#cb220-145" aria-hidden="true" tabindex="-1"></a>    getoetet, ueberlebt <span class="op">=</span> [], []</span>
+<span id="cb220-146"><a href="#cb220-146" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name, suche, ersatz <span class="kw">in</span> MUTATIONEN:</span>
+<span id="cb220-147"><a href="#cb220-147" aria-hidden="true" tabindex="-1"></a>        ergebnis <span class="op">=</span> mutiere_und_pruefe(quelle, suite, suche, ersatz)</span>
+<span id="cb220-148"><a href="#cb220-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="cb220-149"><a href="#cb220-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="cb220-150"><a href="#cb220-150" aria-hidden="true" tabindex="-1"></a>            <span class="cf">continue</span></span>
+<span id="cb220-151"><a href="#cb220-151" aria-hidden="true" tabindex="-1"></a>        _, rot, _ <span class="op">=</span> ergebnis</span>
+<span id="cb220-152"><a href="#cb220-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="cb220-153"><a href="#cb220-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="cb220-154"><a href="#cb220-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="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="bu">print</span>(<span class="st">&quot;-&quot;</span> <span class="op">*</span> <span class="dv">84</span>)</span>
+<span id="cb220-157"><a href="#cb220-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="cb220-158"><a href="#cb220-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="cb220-159"><a href="#cb220-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="cb220-160"><a href="#cb220-160" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb220-161"><a href="#cb220-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="cb220-162"><a href="#cb220-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="cb220-163"><a href="#cb220-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="cb220-164"><a href="#cb220-164" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> ueberlebt:</span>
+<span id="cb220-165"><a href="#cb220-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="cb220-166"><a href="#cb220-166" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> name <span class="kw">in</span> ueberlebt:</span>
+<span id="cb220-167"><a href="#cb220-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="cb220-168"><a href="#cb220-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="cb220-169"><a href="#cb220-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="cb220-170"><a href="#cb220-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="cb220-171"><a href="#cb220-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="cb220-172"><a href="#cb220-172" aria-hidden="true" tabindex="-1"></a>    <span class="cf">else</span>:</span>
+<span id="cb220-173"><a href="#cb220-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="cb220-174"><a href="#cb220-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="cb220-175"><a href="#cb220-175" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb220-176"><a href="#cb220-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="cb220-177"><a href="#cb220-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="cb220-178"><a href="#cb220-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="cb220-179"><a href="#cb220-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
@@ -27340,208 +27791,208 @@ 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="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"># Benchmark_Skalierung.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: Ein Vergleich, dem man glauben kann.</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">Solververgleiche stehen in jedem Blog, und die meisten sind wertlos - nicht</span></span>
+<span id="cb223-8"><a href="#cb223-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="cb223-9"><a href="#cb223-9" aria-hidden="true" tabindex="-1"></a><span class="co">Programm misst dasselbe Transportproblem in drei Groessen mit vier</span></span>
+<span id="cb223-10"><a href="#cb223-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="cb223-11"><a href="#cb223-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb223-12"><a href="#cb223-12" aria-hidden="true" tabindex="-1"></a><span class="co">  1. EIGENER PROZESS je Bibliothek. Nicht nur wegen des Importkonflikts</span></span>
+<span id="cb223-13"><a href="#cb223-13" aria-hidden="true" tabindex="-1"></a><span class="co">     zwischen ortools und highspy (Kapitel Oekosystem) - auch, damit der</span></span>
+<span id="cb223-14"><a href="#cb223-14" aria-hidden="true" tabindex="-1"></a><span class="co">     Speicherverbrauch der einen nicht in der Messung der anderen auftaucht.</span></span>
+<span id="cb223-15"><a href="#cb223-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="cb223-16"><a href="#cb223-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="cb223-17"><a href="#cb223-17" aria-hidden="true" tabindex="-1"></a><span class="co">     Gesamtzeit misst, optimiert am Ende die falsche Haelfte.</span></span>
+<span id="cb223-18"><a href="#cb223-18" aria-hidden="true" tabindex="-1"></a><span class="co">  3. ZIELWERTE GEGENEINANDER PRUEFEN. Eine Bibliothek, die schneller ist und</span></span>
+<span id="cb223-19"><a href="#cb223-19" aria-hidden="true" tabindex="-1"></a><span class="co">     etwas anderes ausrechnet, hat den Vergleich nicht gewonnen. Diese Pruefung</span></span>
+<span id="cb223-20"><a href="#cb223-20" aria-hidden="true" tabindex="-1"></a><span class="co">     ist der wichtigste Teil des Programms.</span></span>
+<span id="cb223-21"><a href="#cb223-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="cb223-22"><a href="#cb223-22" aria-hidden="true" tabindex="-1"></a><span class="co">     Zeit darueber, was auf einer Maschine noch laeuft.</span></span>
+<span id="cb223-23"><a href="#cb223-23" aria-hidden="true" tabindex="-1"></a><span class="co">  5. DIESELBE INSTANZ fuer alle. Feste Saat, kein Neuwuerfeln zwischendurch.</span></span>
+<span id="cb223-24"><a href="#cb223-24" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb223-25"><a href="#cb223-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="cb223-26"><a href="#cb223-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="cb223-27"><a href="#cb223-27" aria-hidden="true" tabindex="-1"></a><span class="co">sondern eine Entscheidungshilfe fuer genau diesen Fall. Wer es verallgemeinert,</span></span>
+<span id="cb223-28"><a href="#cb223-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="cb223-29"><a href="#cb223-29" aria-hidden="true" tabindex="-1"></a><span class="co">schliesst (Kapitel Handelsmaschine).</span></span>
+<span id="cb223-30"><a href="#cb223-30" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb223-31"><a href="#cb223-31" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy; in den Kindprozessen scipy, highspy, ortools, cvxpy</span></span>
+<span id="cb223-32"><a href="#cb223-32" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb223-33"><a href="#cb223-33" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb223-34"><a href="#cb223-34" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb223-35"><a href="#cb223-35" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb223-36"><a href="#cb223-36" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> json</span>
+<span id="cb223-37"><a href="#cb223-37" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> subprocess</span>
+<span id="cb223-38"><a href="#cb223-38" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> sys</span>
+<span id="cb223-39"><a href="#cb223-39" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> textwrap</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>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="cb223-42"><a href="#cb223-42" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb223-43"><a href="#cb223-43" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb223-44"><a href="#cb223-44" aria-hidden="true" tabindex="-1"></a><span class="co"># Jeder Eintrag ist ein eigenstaendiges Programm: Instanz aufbauen, loesen,</span></span>
+<span id="cb223-45"><a href="#cb223-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="cb223-46"><a href="#cb223-46" aria-hidden="true" tabindex="-1"></a><span class="co"># derselben Saat neu erzeugt - so reist nichts ueber die Prozessgrenze,</span></span>
+<span id="cb223-47"><a href="#cb223-47" aria-hidden="true" tabindex="-1"></a><span class="co"># was das Ergebnis verfaelschen koennte.</span></span>
+<span id="cb223-48"><a href="#cb223-48" aria-hidden="true" tabindex="-1"></a>VORSPANN <span class="op">=</span> <span class="st">&quot;&quot;&quot;</span></span>
+<span id="cb223-49"><a href="#cb223-49" aria-hidden="true" tabindex="-1"></a><span class="st">import json, time, resource</span></span>
+<span id="cb223-50"><a href="#cb223-50" aria-hidden="true" tabindex="-1"></a><span class="st">import numpy as np</span></span>
+<span id="cb223-51"><a href="#cb223-51" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb223-52"><a href="#cb223-52" aria-hidden="true" tabindex="-1"></a><span class="st">def instanz(m, n):</span></span>
+<span id="cb223-53"><a href="#cb223-53" aria-hidden="true" tabindex="-1"></a><span class="st">    rng = np.random.default_rng(20)</span></span>
+<span id="cb223-54"><a href="#cb223-54" aria-hidden="true" tabindex="-1"></a><span class="st">    kosten = rng.integers(5, 95, (m, n)).astype(float)</span></span>
+<span id="cb223-55"><a href="#cb223-55" aria-hidden="true" tabindex="-1"></a><span class="st">    angebot = rng.integers(50, 150, m).astype(float)</span></span>
+<span id="cb223-56"><a href="#cb223-56" aria-hidden="true" tabindex="-1"></a><span class="st">    bedarf = angebot.sum() * rng.dirichlet(np.ones(n))</span></span>
+<span id="cb223-57"><a href="#cb223-57" aria-hidden="true" tabindex="-1"></a><span class="st">    return kosten, angebot, bedarf</span></span>
+<span id="cb223-58"><a href="#cb223-58" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb223-59"><a href="#cb223-59" aria-hidden="true" tabindex="-1"></a><span class="st">def speicher_mb():</span></span>
+<span id="cb223-60"><a href="#cb223-60" aria-hidden="true" tabindex="-1"></a><span class="st">    # ru_maxrss ist unter Linux in Kilobyte</span></span>
+<span id="cb223-61"><a href="#cb223-61" aria-hidden="true" tabindex="-1"></a><span class="st">    return resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024</span></span>
+<span id="cb223-62"><a href="#cb223-62" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb223-63"><a href="#cb223-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="cb223-64"><a href="#cb223-64" aria-hidden="true" tabindex="-1"></a><span class="st">kosten, angebot, bedarf = instanz(M, N)</span></span>
+<span id="cb223-65"><a href="#cb223-65" aria-hidden="true" tabindex="-1"></a><span class="st">&quot;&quot;&quot;</span></span>
+<span id="cb223-66"><a href="#cb223-66" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb223-67"><a href="#cb223-67" aria-hidden="true" tabindex="-1"></a>ANSAETZE <span class="op">=</span> {</span>
+<span id="cb223-68"><a href="#cb223-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="cb223-69"><a href="#cb223-69" aria-hidden="true" tabindex="-1"></a><span class="st">        from scipy.optimize import linprog</span></span>
+<span id="cb223-70"><a href="#cb223-70" aria-hidden="true" tabindex="-1"></a><span class="st">        t0 = time.perf_counter()</span></span>
+<span id="cb223-71"><a href="#cb223-71" aria-hidden="true" tabindex="-1"></a><span class="st">        c = kosten.reshape(-1)</span></span>
+<span id="cb223-72"><a href="#cb223-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="cb223-73"><a href="#cb223-73" aria-hidden="true" tabindex="-1"></a><span class="st">        for i in range(M):</span></span>
+<span id="cb223-74"><a href="#cb223-74" aria-hidden="true" tabindex="-1"></a><span class="st">            A_ub[i, i * N:(i + 1) * N] = 1.0</span></span>
+<span id="cb223-75"><a href="#cb223-75" aria-hidden="true" tabindex="-1"></a><span class="st">        for j in range(N):</span></span>
+<span id="cb223-76"><a href="#cb223-76" aria-hidden="true" tabindex="-1"></a><span class="st">            A_eq[j, j::N] = 1.0</span></span>
+<span id="cb223-77"><a href="#cb223-77" aria-hidden="true" tabindex="-1"></a><span class="st">        aufbau = time.perf_counter() - t0</span></span>
+<span id="cb223-78"><a href="#cb223-78" aria-hidden="true" tabindex="-1"></a><span class="st">        t0 = time.perf_counter()</span></span>
+<span id="cb223-79"><a href="#cb223-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="cb223-80"><a href="#cb223-80" aria-hidden="true" tabindex="-1"></a><span class="st">                    bounds=(0, None), method=&quot;highs&quot;)</span></span>
+<span id="cb223-81"><a href="#cb223-81" aria-hidden="true" tabindex="-1"></a><span class="st">        loesen = time.perf_counter() - t0</span></span>
+<span id="cb223-82"><a href="#cb223-82" aria-hidden="true" tabindex="-1"></a><span class="st">        ausgabe = (float(r.fun), aufbau, loesen, speicher_mb())</span></span>
+<span id="cb223-83"><a href="#cb223-83" aria-hidden="true" tabindex="-1"></a><span class="st">    &quot;&quot;&quot;</span>,</span>
+<span id="cb223-84"><a href="#cb223-84" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb223-85"><a href="#cb223-85" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;highspy&quot;</span>: <span class="st">&quot;&quot;&quot;</span></span>
+<span id="cb223-86"><a href="#cb223-86" aria-hidden="true" tabindex="-1"></a><span class="st">        import highspy</span></span>
+<span id="cb223-87"><a href="#cb223-87" aria-hidden="true" tabindex="-1"></a><span class="st">        t0 = time.perf_counter()</span></span>
+<span id="cb223-88"><a href="#cb223-88" aria-hidden="true" tabindex="-1"></a><span class="st">        h = highspy.Highs(); h.setOptionValue(&quot;output_flag&quot;, False)</span></span>
+<span id="cb223-89"><a href="#cb223-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="cb223-90"><a href="#cb223-90" aria-hidden="true" tabindex="-1"></a><span class="st">        for k in range(M * N):</span></span>
+<span id="cb223-91"><a href="#cb223-91" aria-hidden="true" tabindex="-1"></a><span class="st">            h.changeColCost(k, float(kosten.reshape(-1)[k]))</span></span>
+<span id="cb223-92"><a href="#cb223-92" aria-hidden="true" tabindex="-1"></a><span class="st">        for i in range(M):</span></span>
+<span id="cb223-93"><a href="#cb223-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="cb223-94"><a href="#cb223-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="cb223-95"><a href="#cb223-95" aria-hidden="true" tabindex="-1"></a><span class="st">        for j in range(N):</span></span>
+<span id="cb223-96"><a href="#cb223-96" aria-hidden="true" tabindex="-1"></a><span class="st">            idx = np.arange(j, M * N, N, dtype=np.int32)</span></span>
+<span id="cb223-97"><a href="#cb223-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="cb223-98"><a href="#cb223-98" aria-hidden="true" tabindex="-1"></a><span class="st">        aufbau = time.perf_counter() - t0</span></span>
+<span id="cb223-99"><a href="#cb223-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="cb223-100"><a href="#cb223-100" aria-hidden="true" tabindex="-1"></a><span class="st">        ausgabe = (h.getInfo().objective_function_value, aufbau, loesen, speicher_mb())</span></span>
+<span id="cb223-101"><a href="#cb223-101" aria-hidden="true" tabindex="-1"></a><span class="st">    &quot;&quot;&quot;</span>,</span>
+<span id="cb223-102"><a href="#cb223-102" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb223-103"><a href="#cb223-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="cb223-104"><a href="#cb223-104" aria-hidden="true" tabindex="-1"></a><span class="st">        from ortools.linear_solver import pywraplp</span></span>
+<span id="cb223-105"><a href="#cb223-105" aria-hidden="true" tabindex="-1"></a><span class="st">        t0 = time.perf_counter()</span></span>
+<span id="cb223-106"><a href="#cb223-106" aria-hidden="true" tabindex="-1"></a><span class="st">        s = pywraplp.Solver.CreateSolver(&quot;GLOP&quot;)</span></span>
+<span id="cb223-107"><a href="#cb223-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="cb223-108"><a href="#cb223-108" aria-hidden="true" tabindex="-1"></a><span class="st">             for i in range(M)]</span></span>
+<span id="cb223-109"><a href="#cb223-109" aria-hidden="true" tabindex="-1"></a><span class="st">        for i in range(M):</span></span>
+<span id="cb223-110"><a href="#cb223-110" aria-hidden="true" tabindex="-1"></a><span class="st">            s.Add(sum(x[i]) &lt;= float(angebot[i]))</span></span>
+<span id="cb223-111"><a href="#cb223-111" aria-hidden="true" tabindex="-1"></a><span class="st">        for j in range(N):</span></span>
+<span id="cb223-112"><a href="#cb223-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="cb223-113"><a href="#cb223-113" aria-hidden="true" tabindex="-1"></a><span class="st">        s.Minimize(sum(float(kosten[i, j]) * x[i][j]</span></span>
+<span id="cb223-114"><a href="#cb223-114" aria-hidden="true" tabindex="-1"></a><span class="st">                       for i in range(M) for j in range(N)))</span></span>
+<span id="cb223-115"><a href="#cb223-115" aria-hidden="true" tabindex="-1"></a><span class="st">        aufbau = time.perf_counter() - t0</span></span>
+<span id="cb223-116"><a href="#cb223-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="cb223-117"><a href="#cb223-117" aria-hidden="true" tabindex="-1"></a><span class="st">        ausgabe = (s.Objective().Value(), aufbau, loesen, speicher_mb())</span></span>
+<span id="cb223-118"><a href="#cb223-118" aria-hidden="true" tabindex="-1"></a><span class="st">    &quot;&quot;&quot;</span>,</span>
+<span id="cb223-119"><a href="#cb223-119" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb223-120"><a href="#cb223-120" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;cvxpy&quot;</span>: <span class="st">&quot;&quot;&quot;</span></span>
+<span id="cb223-121"><a href="#cb223-121" aria-hidden="true" tabindex="-1"></a><span class="st">        import cvxpy as cp</span></span>
+<span id="cb223-122"><a href="#cb223-122" aria-hidden="true" tabindex="-1"></a><span class="st">        t0 = time.perf_counter()</span></span>
+<span id="cb223-123"><a href="#cb223-123" aria-hidden="true" tabindex="-1"></a><span class="st">        x = cp.Variable((M, N), nonneg=True)</span></span>
+<span id="cb223-124"><a href="#cb223-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="cb223-125"><a href="#cb223-125" aria-hidden="true" tabindex="-1"></a><span class="st">                             [cp.sum(x, axis=1) &lt;= angebot,</span></span>
+<span id="cb223-126"><a href="#cb223-126" aria-hidden="true" tabindex="-1"></a><span class="st">                              cp.sum(x, axis=0) == bedarf])</span></span>
+<span id="cb223-127"><a href="#cb223-127" aria-hidden="true" tabindex="-1"></a><span class="st">        aufbau = time.perf_counter() - t0</span></span>
+<span id="cb223-128"><a href="#cb223-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="cb223-129"><a href="#cb223-129" aria-hidden="true" tabindex="-1"></a><span class="st">        ausgabe = (float(problem.value), aufbau, loesen, speicher_mb())</span></span>
+<span id="cb223-130"><a href="#cb223-130" aria-hidden="true" tabindex="-1"></a><span class="st">    &quot;&quot;&quot;</span>,</span>
+<span id="cb223-131"><a href="#cb223-131" aria-hidden="true" tabindex="-1"></a>}</span>
+<span id="cb223-132"><a href="#cb223-132" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb223-133"><a href="#cb223-133" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb223-134"><a href="#cb223-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="cb223-135"><a href="#cb223-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="cb223-136"><a href="#cb223-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="cb223-137"><a href="#cb223-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="cb223-138"><a href="#cb223-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="cb223-139"><a href="#cb223-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="cb223-140"><a href="#cb223-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="cb223-141"><a href="#cb223-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="cb223-142"><a href="#cb223-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="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>
+<span id="cb223-145"><a href="#cb223-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="cb223-146"><a href="#cb223-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="cb223-147"><a href="#cb223-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="cb223-148"><a href="#cb223-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="cb223-149"><a href="#cb223-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="cb223-150"><a href="#cb223-150" aria-hidden="true" tabindex="-1"></a>          <span class="st">&quot;hardwareabhaengig,&quot;</span>)</span>
+<span id="cb223-151"><a href="#cb223-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="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="cf">for</span> m, n <span class="kw">in</span> GROESSEN:</span>
+<span id="cb223-154"><a href="#cb223-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="cb223-155"><a href="#cb223-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="cb223-156"><a href="#cb223-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="cb223-157"><a href="#cb223-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="cb223-158"><a href="#cb223-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="cb223-159"><a href="#cb223-159" aria-hidden="true" tabindex="-1"></a>        zielwerte <span class="op">=</span> {}</span>
+<span id="cb223-160"><a href="#cb223-160" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> name, quelltext <span class="kw">in</span> ANSAETZE.items():</span>
+<span id="cb223-161"><a href="#cb223-161" aria-hidden="true" tabindex="-1"></a>            werte, fehler <span class="op">=</span> messe(name, quelltext, m, n)</span>
+<span id="cb223-162"><a href="#cb223-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="cb223-163"><a href="#cb223-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="cb223-164"><a href="#cb223-164" aria-hidden="true" tabindex="-1"></a>                <span class="cf">continue</span></span>
+<span id="cb223-165"><a href="#cb223-165" aria-hidden="true" tabindex="-1"></a>            ziel, aufbau, loesen, speicher <span class="op">=</span> werte</span>
+<span id="cb223-166"><a href="#cb223-166" aria-hidden="true" tabindex="-1"></a>            zielwerte[name] <span class="op">=</span> ziel</span>
+<span id="cb223-167"><a href="#cb223-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="cb223-168"><a href="#cb223-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="cb223-169"><a href="#cb223-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="cb223-170"><a href="#cb223-170" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb223-171"><a href="#cb223-171" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Die wichtigste Zeile: Rechnen alle dasselbe aus?</span></span>
+<span id="cb223-172"><a href="#cb223-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="cb223-173"><a href="#cb223-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="cb223-174"><a href="#cb223-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="cb223-175"><a href="#cb223-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="cb223-176"><a href="#cb223-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="cb223-177"><a href="#cb223-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="cb223-178"><a href="#cb223-178" aria-hidden="true" tabindex="-1"></a>                  <span class="st">&quot;der Zeitvergleich ist wertlos.&quot;</span>)</span>
+<span id="cb223-179"><a href="#cb223-179" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>()</span>
+<span id="cb223-180"><a href="#cb223-180" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb223-181"><a href="#cb223-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="cb223-182"><a href="#cb223-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="cb223-183"><a href="#cb223-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="cb223-184"><a href="#cb223-184" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;DARF man ablesen:&quot;</span>)</span>
+<span id="cb223-185"><a href="#cb223-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="cb223-186"><a href="#cb223-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="cb223-187"><a href="#cb223-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="cb223-188"><a href="#cb223-188" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    (Kapitel Oekosystem).&quot;</span>)</span>
+<span id="cb223-189"><a href="#cb223-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="cb223-190"><a href="#cb223-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="cb223-191"><a href="#cb223-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="cb223-192"><a href="#cb223-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="cb223-193"><a href="#cb223-193" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb223-194"><a href="#cb223-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="cb223-195"><a href="#cb223-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="cb223-196"><a href="#cb223-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="cb223-197"><a href="#cb223-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="cb223-198"><a href="#cb223-198" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    umdrehen.&quot;</span>)</span>
+<span id="cb223-199"><a href="#cb223-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="cb223-200"><a href="#cb223-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="cb223-201"><a href="#cb223-201" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;    laufen lassen.&quot;</span>)</span>
+<span id="cb223-202"><a href="#cb223-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>
 <p><strong>Erwartete Ausgabe</strong> (Zeiten und Speicher hardwareabhängig, die Zielwerte nicht):</p>
 <pre><code>============================================================================================
   SKALIERUNGSVERGLEICH: TRANSPORTPROBLEM, VIER BIBLIOTHEKEN
@@ -27668,321 +28119,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="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"># Optimierungsdienst.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: Das Modell als Dienst - und warum es kein normaler Endpunkt ist.</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">Ein Optimierungsmodell hinter eine HTTP-Schnittstelle zu haengen sieht nach</span></span>
+<span id="cb225-8"><a href="#cb225-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="cb225-9"><a href="#cb225-9" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-10"><a href="#cb225-10" aria-hidden="true" tabindex="-1"></a><span class="co">    Eine gewoehnliche Anfrage dauert Millisekunden.</span></span>
+<span id="cb225-11"><a href="#cb225-11" aria-hidden="true" tabindex="-1"></a><span class="co">    Eine Optimierung dauert Sekunden bis Minuten - und manchmal laenger,</span></span>
+<span id="cb225-12"><a href="#cb225-12" aria-hidden="true" tabindex="-1"></a><span class="co">    als jemand warten will.</span></span>
+<span id="cb225-13"><a href="#cb225-13" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-14"><a href="#cb225-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="cb225-15"><a href="#cb225-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="cb225-16"><a href="#cb225-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="cb225-17"><a href="#cb225-17" aria-hidden="true" tabindex="-1"></a><span class="co">alle Arbeiter blockiert.</span></span>
+<span id="cb225-18"><a href="#cb225-18" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-19"><a href="#cb225-19" aria-hidden="true" tabindex="-1"></a><span class="co">Die tragfaehige Bauform ist deshalb ZWEISTUFIG:</span></span>
+<span id="cb225-20"><a href="#cb225-20" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-21"><a href="#cb225-21" aria-hidden="true" tabindex="-1"></a><span class="co">    POST /plaene         nimmt den Auftrag an, prueft ihn, gibt sofort</span></span>
+<span id="cb225-22"><a href="#cb225-22" aria-hidden="true" tabindex="-1"></a><span class="co">                         202 Accepted und eine Auftragsnummer zurueck</span></span>
+<span id="cb225-23"><a href="#cb225-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="cb225-24"><a href="#cb225-24" aria-hidden="true" tabindex="-1"></a><span class="co">                         Loesung samt Status und Gap</span></span>
+<span id="cb225-25"><a href="#cb225-25" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-26"><a href="#cb225-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="cb225-27"><a href="#cb225-27" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-28"><a href="#cb225-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="cb225-29"><a href="#cb225-29" aria-hidden="true" tabindex="-1"></a><span class="co">     unsinnige Anfrage wird von FastAPI mit 422 abgewiesen, bevor irgendein</span></span>
+<span id="cb225-30"><a href="#cb225-30" aria-hidden="true" tabindex="-1"></a><span class="co">     Solver startet - dieselbe Pruefung wie beim Excel-Import.</span></span>
+<span id="cb225-31"><a href="#cb225-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="cb225-32"><a href="#cb225-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="cb225-33"><a href="#cb225-33" aria-hidden="true" tabindex="-1"></a><span class="co">     Optimum oder einen Zeitlimit-Abbruch in der Hand haelt.</span></span>
+<span id="cb225-34"><a href="#cb225-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="cb225-35"><a href="#cb225-35" aria-hidden="true" tabindex="-1"></a><span class="co">     Instanz einen Arbeiter auf unbestimmte Zeit.</span></span>
+<span id="cb225-36"><a href="#cb225-36" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-37"><a href="#cb225-37" aria-hidden="true" tabindex="-1"></a><span class="co">Dieses Programm laeuft ohne Server: Der Selbsttest unten benutzt den</span></span>
+<span id="cb225-38"><a href="#cb225-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="cb225-39"><a href="#cb225-39" aria-hidden="true" tabindex="-1"></a><span class="co">Betrieb steht am Ende, was sich aendert.</span></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="co">Aufruf:</span></span>
+<span id="cb225-42"><a href="#cb225-42" aria-hidden="true" tabindex="-1"></a><span class="co">    python3 Optimierungsdienst.py          # Selbsttest, kein Server noetig</span></span>
+<span id="cb225-43"><a href="#cb225-43" aria-hidden="true" tabindex="-1"></a><span class="co">    uvicorn Optimierungsdienst:app         # echter Server auf Port 8000</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 class="co">Benoetigt: fastapi, httpx (fuer den Selbsttest), pydantic, ortools (ueber or_kern)</span></span>
+<span id="cb225-46"><a href="#cb225-46" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb225-47"><a href="#cb225-47" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-48"><a href="#cb225-48" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb225-49"><a href="#cb225-49" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-50"><a href="#cb225-50" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
+<span id="cb225-51"><a href="#cb225-51" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> uuid</span>
+<span id="cb225-52"><a href="#cb225-52" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> concurrent.futures <span class="im">import</span> ThreadPoolExecutor</span>
+<span id="cb225-53"><a href="#cb225-53" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> enum <span class="im">import</span> Enum</span>
+<span id="cb225-54"><a href="#cb225-54" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-55"><a href="#cb225-55" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> fastapi <span class="im">import</span> FastAPI, HTTPException</span>
+<span id="cb225-56"><a href="#cb225-56" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> pydantic <span class="im">import</span> BaseModel, Field</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 class="im">from</span> or_kern <span class="im">import</span> (Loesung, Produktionsproblem, loese_mit_glop,</span>
+<span id="cb225-59"><a href="#cb225-59" aria-hidden="true" tabindex="-1"></a>                     pruefe_loesung)</span>
+<span id="cb225-60"><a href="#cb225-60" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-61"><a href="#cb225-61" aria-hidden="true" tabindex="-1"></a>ZEITLIMIT_SEKUNDEN <span class="op">=</span> <span class="fl">30.0</span></span>
+<span id="cb225-62"><a href="#cb225-62" aria-hidden="true" tabindex="-1"></a>ARBEITER <span class="op">=</span> <span class="dv">2</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">class</span> Auftragsstand(<span class="bu">str</span>, Enum):</span>
+<span id="cb225-66"><a href="#cb225-66" aria-hidden="true" tabindex="-1"></a>    WARTET <span class="op">=</span> <span class="st">&quot;wartet&quot;</span></span>
+<span id="cb225-67"><a href="#cb225-67" aria-hidden="true" tabindex="-1"></a>    LAEUFT <span class="op">=</span> <span class="st">&quot;laeuft&quot;</span></span>
+<span id="cb225-68"><a href="#cb225-68" aria-hidden="true" tabindex="-1"></a>    FERTIG <span class="op">=</span> <span class="st">&quot;fertig&quot;</span></span>
+<span id="cb225-69"><a href="#cb225-69" aria-hidden="true" tabindex="-1"></a>    GESCHEITERT <span class="op">=</span> <span class="st">&quot;gescheitert&quot;</span></span>
+<span id="cb225-70"><a href="#cb225-70" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-71"><a href="#cb225-71" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-72"><a href="#cb225-72" aria-hidden="true" tabindex="-1"></a><span class="kw">class</span> Auftragsantwort(BaseModel):</span>
+<span id="cb225-73"><a href="#cb225-73" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Was der Aufrufer beim Abholen bekommt.</span></span>
+<span id="cb225-74"><a href="#cb225-74" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-75"><a href="#cb225-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="cb225-76"><a href="#cb225-76" aria-hidden="true" tabindex="-1"></a><span class="co">    (Status, Gap) sind der Unterschied zwischen einer Zahl und einer</span></span>
+<span id="cb225-77"><a href="#cb225-77" aria-hidden="true" tabindex="-1"></a><span class="co">    belastbaren Auskunft.</span></span>
+<span id="cb225-78"><a href="#cb225-78" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb225-79"><a href="#cb225-79" aria-hidden="true" tabindex="-1"></a>    <span class="bu">id</span>: <span class="bu">str</span></span>
+<span id="cb225-80"><a href="#cb225-80" aria-hidden="true" tabindex="-1"></a>    stand: Auftragsstand</span>
+<span id="cb225-81"><a href="#cb225-81" aria-hidden="true" tabindex="-1"></a>    eingegangen: <span class="bu">float</span></span>
+<span id="cb225-82"><a href="#cb225-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="cb225-83"><a href="#cb225-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="cb225-84"><a href="#cb225-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="cb225-85"><a href="#cb225-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="cb225-86"><a href="#cb225-86" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-87"><a href="#cb225-87" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-88"><a href="#cb225-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="cb225-89"><a href="#cb225-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="cb225-90"><a href="#cb225-90" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-91"><a href="#cb225-91" aria-hidden="true" tabindex="-1"></a><span class="co"># Fuer das Buchbeispiel: Auftragsbuch im Speicher, Arbeiter im selben Prozess.</span></span>
+<span id="cb225-92"><a href="#cb225-92" aria-hidden="true" tabindex="-1"></a><span class="co"># Was daran im echten Betrieb nicht reicht, steht unten.</span></span>
+<span id="cb225-93"><a href="#cb225-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="cb225-94"><a href="#cb225-94" aria-hidden="true" tabindex="-1"></a>POOL <span class="op">=</span> ThreadPoolExecutor(max_workers<span class="op">=</span>ARBEITER)</span>
+<span id="cb225-95"><a href="#cb225-95" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-96"><a href="#cb225-96" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-97"><a href="#cb225-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="cb225-98"><a href="#cb225-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="cb225-99"><a href="#cb225-99" aria-hidden="true" tabindex="-1"></a>    antwort <span class="op">=</span> AUFTRAEGE[auftrags_id]</span>
+<span id="cb225-100"><a href="#cb225-100" aria-hidden="true" tabindex="-1"></a>    antwort.stand <span class="op">=</span> Auftragsstand.LAEUFT</span>
+<span id="cb225-101"><a href="#cb225-101" aria-hidden="true" tabindex="-1"></a>    start <span class="op">=</span> time.perf_counter()</span>
+<span id="cb225-102"><a href="#cb225-102" aria-hidden="true" tabindex="-1"></a>    <span class="cf">try</span>:</span>
+<span id="cb225-103"><a href="#cb225-103" aria-hidden="true" tabindex="-1"></a>        loesung <span class="op">=</span> loese_mit_glop(problem)</span>
+<span id="cb225-104"><a href="#cb225-104" aria-hidden="true" tabindex="-1"></a>        antwort.loesung <span class="op">=</span> loesung</span>
+<span id="cb225-105"><a href="#cb225-105" aria-hidden="true" tabindex="-1"></a>        <span class="co"># Dieselbe Abnahmepruefung wie ueberall sonst. Ein Dienst, der sie</span></span>
+<span id="cb225-106"><a href="#cb225-106" aria-hidden="true" tabindex="-1"></a>        <span class="co"># weglaesst, liefert Fehler schneller aus als ein Mensch sie faende.</span></span>
+<span id="cb225-107"><a href="#cb225-107" aria-hidden="true" tabindex="-1"></a>        antwort.beanstandungen <span class="op">=</span> pruefe_loesung(problem, loesung)</span>
+<span id="cb225-108"><a href="#cb225-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="cb225-109"><a href="#cb225-109" aria-hidden="true" tabindex="-1"></a>                         <span class="kw">and</span> <span class="kw">not</span> antwort.beanstandungen</span>
+<span id="cb225-110"><a href="#cb225-110" aria-hidden="true" tabindex="-1"></a>                         <span class="cf">else</span> Auftragsstand.GESCHEITERT)</span>
+<span id="cb225-111"><a href="#cb225-111" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="kw">not</span> loesung.status.brauchbar:</span>
+<span id="cb225-112"><a href="#cb225-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="cb225-113"><a href="#cb225-113" aria-hidden="true" tabindex="-1"></a>        <span class="cf">elif</span> antwort.beanstandungen:</span>
+<span id="cb225-114"><a href="#cb225-114" aria-hidden="true" tabindex="-1"></a>            antwort.fehler <span class="op">=</span> <span class="st">&quot;Abnahmepruefung fehlgeschlagen&quot;</span></span>
+<span id="cb225-115"><a href="#cb225-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="cb225-116"><a href="#cb225-116" aria-hidden="true" tabindex="-1"></a>        antwort.stand <span class="op">=</span> Auftragsstand.GESCHEITERT</span>
+<span id="cb225-117"><a href="#cb225-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="cb225-118"><a href="#cb225-118" aria-hidden="true" tabindex="-1"></a>    <span class="cf">finally</span>:</span>
+<span id="cb225-119"><a href="#cb225-119" aria-hidden="true" tabindex="-1"></a>        antwort.laufzeit <span class="op">=</span> time.perf_counter() <span class="op">-</span> start</span>
+<span id="cb225-120"><a href="#cb225-120" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-121"><a href="#cb225-121" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-122"><a href="#cb225-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="cb225-123"><a href="#cb225-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="cb225-124"><a href="#cb225-124" aria-hidden="true" tabindex="-1"></a>    <span class="co">&quot;&quot;&quot;Nimmt an, prueft, gibt sofort zurueck.</span></span>
+<span id="cb225-125"><a href="#cb225-125" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-126"><a href="#cb225-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="cb225-127"><a href="#cb225-127" aria-hidden="true" tabindex="-1"></a><span class="co">    validiert die Anfrage damit gegen das Domaenenmodell und antwortet bei</span></span>
+<span id="cb225-128"><a href="#cb225-128" aria-hidden="true" tabindex="-1"></a><span class="co">    Unsinn mit 422, ohne dass hier eine Zeile Pruefcode steht.</span></span>
+<span id="cb225-129"><a href="#cb225-129" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb225-130"><a href="#cb225-130" aria-hidden="true" tabindex="-1"></a>    auftrags_id <span class="op">=</span> <span class="bu">str</span>(uuid.uuid4())</span>
+<span id="cb225-131"><a href="#cb225-131" aria-hidden="true" tabindex="-1"></a>    AUFTRAEGE[auftrags_id] <span class="op">=</span> Auftragsantwort(</span>
+<span id="cb225-132"><a href="#cb225-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="cb225-133"><a href="#cb225-133" aria-hidden="true" tabindex="-1"></a>    POOL.submit(rechne, auftrags_id, problem)</span>
+<span id="cb225-134"><a href="#cb225-134" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> AUFTRAEGE[auftrags_id]</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="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="cb225-138"><a href="#cb225-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="cb225-139"><a href="#cb225-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="cb225-140"><a href="#cb225-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="cb225-141"><a href="#cb225-141" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> AUFTRAEGE[auftrags_id]</span>
+<span id="cb225-142"><a href="#cb225-142" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-143"><a href="#cb225-143" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-144"><a href="#cb225-144" aria-hidden="true" tabindex="-1"></a><span class="at">@app.get</span>(<span class="st">&quot;/gesundheit&quot;</span>)</span>
+<span id="cb225-145"><a href="#cb225-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="cb225-146"><a href="#cb225-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="cb225-147"><a href="#cb225-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="cb225-148"><a href="#cb225-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="cb225-149"><a href="#cb225-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="cb225-150"><a href="#cb225-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="cb225-151"><a href="#cb225-151" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-152"><a href="#cb225-152" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-153"><a href="#cb225-153" aria-hidden="true" tabindex="-1"></a><span class="co"># --- Selbsttest ohne Server -------------------------------------------------</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>SCHREINEREI <span class="op">=</span> {</span>
+<span id="cb225-156"><a href="#cb225-156" aria-hidden="true" tabindex="-1"></a>    <span class="st">&quot;produkte&quot;</span>: [</span>
+<span id="cb225-157"><a href="#cb225-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="cb225-158"><a href="#cb225-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="cb225-159"><a href="#cb225-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="cb225-160"><a href="#cb225-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="cb225-161"><a href="#cb225-161" aria-hidden="true" tabindex="-1"></a>    ],</span>
+<span id="cb225-162"><a href="#cb225-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="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>
+<span id="cb225-165"><a href="#cb225-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="cb225-166"><a href="#cb225-166" aria-hidden="true" tabindex="-1"></a><span class="st">FROM python:3.12-slim</span></span>
+<span id="cb225-167"><a href="#cb225-167" aria-hidden="true" tabindex="-1"></a><span class="st">WORKDIR /app</span></span>
+<span id="cb225-168"><a href="#cb225-168" aria-hidden="true" tabindex="-1"></a><span class="st">COPY requirements.txt .</span></span>
+<span id="cb225-169"><a href="#cb225-169" aria-hidden="true" tabindex="-1"></a><span class="st">RUN pip install --no-cache-dir -r requirements.txt</span></span>
+<span id="cb225-170"><a href="#cb225-170" aria-hidden="true" tabindex="-1"></a><span class="st">COPY or_kern.py Optimierungsdienst.py .</span></span>
+<span id="cb225-171"><a href="#cb225-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="cb225-172"><a href="#cb225-172" aria-hidden="true" tabindex="-1"></a><span class="st"># mehr Prozesse machen ihn nicht schneller, sondern langsamer.</span></span>
+<span id="cb225-173"><a href="#cb225-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="cb225-174"><a href="#cb225-174" aria-hidden="true" tabindex="-1"></a><span class="st">&quot;&quot;&quot;</span></span>
+<span id="cb225-175"><a href="#cb225-175" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-176"><a href="#cb225-176" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-177"><a href="#cb225-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="cb225-178"><a href="#cb225-178" aria-hidden="true" tabindex="-1"></a>    ende <span class="op">=</span> time.time() <span class="op">+</span> grenze</span>
+<span id="cb225-179"><a href="#cb225-179" aria-hidden="true" tabindex="-1"></a>    <span class="cf">while</span> time.time() <span class="op">&lt;</span> ende:</span>
+<span id="cb225-180"><a href="#cb225-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="cb225-181"><a href="#cb225-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="cb225-182"><a href="#cb225-182" aria-hidden="true" tabindex="-1"></a>            <span class="cf">return</span> antwort</span>
+<span id="cb225-183"><a href="#cb225-183" aria-hidden="true" tabindex="-1"></a>        time.sleep(<span class="fl">0.02</span>)</span>
+<span id="cb225-184"><a href="#cb225-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="cb225-185"><a href="#cb225-185" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-186"><a href="#cb225-186" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-187"><a href="#cb225-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="cb225-188"><a href="#cb225-188" aria-hidden="true" tabindex="-1"></a>    <span class="im">from</span> fastapi.testclient <span class="im">import</span> TestClient</span>
+<span id="cb225-189"><a href="#cb225-189" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-190"><a href="#cb225-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="cb225-191"><a href="#cb225-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="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">80</span>)</span>
+<span id="cb225-193"><a href="#cb225-193" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-194"><a href="#cb225-194" aria-hidden="true" tabindex="-1"></a>    <span class="cf">with</span> TestClient(app) <span class="im">as</span> klient:</span>
+<span id="cb225-195"><a href="#cb225-195" aria-hidden="true" tabindex="-1"></a>        <span class="co"># 1. Gueltiger Auftrag</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;</span><span class="ch">\n</span><span class="st">1. Auftrag einreichen&quot;</span>)</span>
+<span id="cb225-197"><a href="#cb225-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="cb225-198"><a href="#cb225-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="cb225-199"><a href="#cb225-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="cb225-200"><a href="#cb225-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="cb225-201"><a href="#cb225-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="cb225-202"><a href="#cb225-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="cb225-203"><a href="#cb225-203" aria-hidden="true" tabindex="-1"></a>        <span class="co"># BEVOR es eine Loesung gibt. Genau dafuer ist 202 gedacht.</span></span>
+<span id="cb225-204"><a href="#cb225-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="cb225-205"><a href="#cb225-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="cb225-206"><a href="#cb225-206" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-207"><a href="#cb225-207" aria-hidden="true" tabindex="-1"></a>        fertig <span class="op">=</span> warte_auf_ergebnis(klient, auftrags_id)</span>
+<span id="cb225-208"><a href="#cb225-208" aria-hidden="true" tabindex="-1"></a>        loesung <span class="op">=</span> fertig[<span class="st">&quot;loesung&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;</span><span class="ch">\n</span><span class="st">2. Ergebnis abholen&quot;</span>)</span>
+<span id="cb225-210"><a href="#cb225-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="cb225-211"><a href="#cb225-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="cb225-212"><a href="#cb225-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="cb225-213"><a href="#cb225-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="cb225-214"><a href="#cb225-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="cb225-215"><a href="#cb225-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="cb225-216"><a href="#cb225-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="cb225-217"><a href="#cb225-217" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;   Abnahmepruefung         -&gt; &quot;</span></span>
+<span id="cb225-218"><a href="#cb225-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="cb225-219"><a href="#cb225-219" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-220"><a href="#cb225-220" aria-hidden="true" tabindex="-1"></a>        <span class="co"># 2. Unsinnige Anfrage - muss abgewiesen werden, BEVOR gerechnet wird</span></span>
+<span id="cb225-221"><a href="#cb225-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="cb225-222"><a href="#cb225-222" aria-hidden="true" tabindex="-1"></a>        <span class="cf">for</span> beschreibung, aenderung <span class="kw">in</span> [</span>
+<span id="cb225-223"><a href="#cb225-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="cb225-224"><a href="#cb225-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="cb225-225"><a href="#cb225-225" aria-hidden="true" tabindex="-1"></a>                (<span class="st">&quot;Ressource ohne Kapazitaet&quot;</span>,</span>
+<span id="cb225-226"><a href="#cb225-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="cb225-227"><a href="#cb225-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="cb225-228"><a href="#cb225-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="cb225-229"><a href="#cb225-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="cb225-230"><a href="#cb225-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="cb225-231"><a href="#cb225-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="cb225-232"><a href="#cb225-232" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-233"><a href="#cb225-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="cb225-234"><a href="#cb225-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="cb225-235"><a href="#cb225-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="cb225-236"><a href="#cb225-236" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-237"><a href="#cb225-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="cb225-238"><a href="#cb225-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="cb225-239"><a href="#cb225-239" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-240"><a href="#cb225-240" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Warum ein Thread je Auftrag genuegt -----------------------------</span></span>
+<span id="cb225-241"><a href="#cb225-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="cb225-242"><a href="#cb225-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="cb225-243"><a href="#cb225-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="cb225-244"><a href="#cb225-244" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-245"><a href="#cb225-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="cb225-246"><a href="#cb225-246" aria-hidden="true" tabindex="-1"></a>    <span class="co"># Millisekunden fertig ist, misst nur den Aufwand fuers Threadstarten -</span></span>
+<span id="cb225-247"><a href="#cb225-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="cb225-248"><a href="#cb225-248" aria-hidden="true" tabindex="-1"></a>    <span class="co"># eine Verlangsamung, wo in Wirklichkeit eine Beschleunigung steht.</span></span>
+<span id="cb225-249"><a href="#cb225-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="cb225-250"><a href="#cb225-250" aria-hidden="true" tabindex="-1"></a>        <span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb225-251"><a href="#cb225-251" aria-hidden="true" tabindex="-1"></a>        <span class="im">from</span> ortools.linear_solver <span class="im">import</span> pywraplp</span>
+<span id="cb225-252"><a href="#cb225-252" aria-hidden="true" tabindex="-1"></a>        rng <span class="op">=</span> np.random.default_rng(<span class="dv">3</span>)</span>
+<span id="cb225-253"><a href="#cb225-253" aria-hidden="true" tabindex="-1"></a>        n <span class="op">=</span> <span class="dv">260</span></span>
+<span id="cb225-254"><a href="#cb225-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="cb225-255"><a href="#cb225-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="cb225-256"><a href="#cb225-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="cb225-257"><a href="#cb225-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="cb225-258"><a href="#cb225-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="cb225-259"><a href="#cb225-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="cb225-260"><a href="#cb225-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="cb225-261"><a href="#cb225-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="cb225-262"><a href="#cb225-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="cb225-263"><a href="#cb225-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="cb225-264"><a href="#cb225-264" aria-hidden="true" tabindex="-1"></a>        solver.Solve()</span>
+<span id="cb225-265"><a href="#cb225-265" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-266"><a href="#cb225-266" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb225-267"><a href="#cb225-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="cb225-268"><a href="#cb225-268" aria-hidden="true" tabindex="-1"></a>        eine_rechnung()</span>
+<span id="cb225-269"><a href="#cb225-269" aria-hidden="true" tabindex="-1"></a>    seriell <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb225-270"><a href="#cb225-270" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb225-271"><a href="#cb225-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="cb225-272"><a href="#cb225-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="cb225-273"><a href="#cb225-273" aria-hidden="true" tabindex="-1"></a>    parallel <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb225-274"><a href="#cb225-274" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-275"><a href="#cb225-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="cb225-276"><a href="#cb225-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="cb225-277"><a href="#cb225-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="cb225-278"><a href="#cb225-278" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb225-279"><a href="#cb225-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="cb225-280"><a href="#cb225-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="cb225-281"><a href="#cb225-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="cb225-282"><a href="#cb225-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="cb225-283"><a href="#cb225-283" aria-hidden="true" tabindex="-1"></a>    <span class="cf">else</span>:</span>
+<span id="cb225-284"><a href="#cb225-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="cb225-285"><a href="#cb225-285" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb225-286"><a href="#cb225-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="cb225-287"><a href="#cb225-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="cb225-288"><a href="#cb225-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="cb225-289"><a href="#cb225-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="cb225-290"><a href="#cb225-290" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb225-291"><a href="#cb225-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="cb225-292"><a href="#cb225-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="cb225-293"><a href="#cb225-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="cb225-294"><a href="#cb225-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="cb225-295"><a href="#cb225-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="cb225-296"><a href="#cb225-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="cb225-297"><a href="#cb225-297" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb225-298"><a href="#cb225-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="cb225-299"><a href="#cb225-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="cb225-300"><a href="#cb225-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="cb225-301"><a href="#cb225-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="cb225-302"><a href="#cb225-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="cb225-303"><a href="#cb225-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="cb225-304"><a href="#cb225-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="cb225-305"><a href="#cb225-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="cb225-306"><a href="#cb225-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="cb225-307"><a href="#cb225-307" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb225-308"><a href="#cb225-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="cb225-309"><a href="#cb225-309" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb225-310"><a href="#cb225-310" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> zeile <span class="kw">in</span> DOCKERFILE.splitlines():</span>
+<span id="cb225-311"><a href="#cb225-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="cb225-312"><a href="#cb225-312" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>()</span>
+<span id="cb225-313"><a href="#cb225-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="cb225-314"><a href="#cb225-314" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot; Docker-Installation voraus.)&quot;</span>)</span>
+<span id="cb225-315"><a href="#cb225-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
@@ -28061,7 +28512,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>
@@ -28399,15 +28850,15 @@ 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="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="im">from</span> ortools.sat.python <span class="im">import</span> cp_model</span>
+<span id="cb227-2"><a href="#cb227-2" aria-hidden="true" tabindex="-1"></a>m <span class="op">=</span> cp_model.CpModel()</span>
+<span id="cb227-3"><a href="#cb227-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="cb227-4"><a href="#cb227-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="cb227-5"><a href="#cb227-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="cb227-6"><a href="#cb227-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="cb227-7"><a href="#cb227-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="cb227-8"><a href="#cb227-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="cb227-9"><a href="#cb227-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>
@@ -28422,14 +28873,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="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="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="cb228-2"><a href="#cb228-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="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">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="cb229-2"><a href="#cb229-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="cb229-3"><a href="#cb229-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>
@@ -28452,9 +28903,9 @@ 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="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="kw">def</span> repariere(P):</span>
+<span id="cb230-2"><a href="#cb230-2" aria-hidden="true" tabindex="-1"></a>    lam, V <span class="op">=</span> np.linalg.eigh(P)</span>
+<span id="cb230-3"><a href="#cb230-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-die-unauffällige-transposition">Finde den Denkfehler — Die unauffällige Transposition</h3>
 <ol type="a">
@@ -28467,8 +28918,8 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 <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="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">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="cb231-2"><a href="#cb231-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>
@@ -28504,24 +28955,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="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="co"># 1. Importe VOR die Messung</span></span>
+<span id="cb232-2"><a href="#cb232-2" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
+<span id="cb232-3"><a href="#cb232-3" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
+<span id="cb232-4"><a href="#cb232-4" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb232-5"><a href="#cb232-5" aria-hidden="true" tabindex="-1"></a><span class="co"># 2. Aufwaermlauf: einmal alles durchlaufen lassen, Ergebnis verwerfen</span></span>
+<span id="cb232-6"><a href="#cb232-6" aria-hidden="true" tabindex="-1"></a>loese_klein()</span>
+<span id="cb232-7"><a href="#cb232-7" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb232-8"><a href="#cb232-8" aria-hidden="true" tabindex="-1"></a><span class="co"># 3. Aufbau und Loesen GETRENNT messen, ueber mehrere Wiederholungen</span></span>
+<span id="cb232-9"><a href="#cb232-9" aria-hidden="true" tabindex="-1"></a>t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb232-10"><a href="#cb232-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="cb232-11"><a href="#cb232-11" aria-hidden="true" tabindex="-1"></a>t_aufbau <span class="op">=</span> time.perf_counter() <span class="op">-</span> t0</span>
+<span id="cb232-12"><a href="#cb232-12" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb232-13"><a href="#cb232-13" aria-hidden="true" tabindex="-1"></a>zeiten <span class="op">=</span> []</span>
+<span id="cb232-14"><a href="#cb232-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="cb232-15"><a href="#cb232-15" aria-hidden="true" tabindex="-1"></a>    t0 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb232-16"><a href="#cb232-16" aria-hidden="true" tabindex="-1"></a>    problem.solve()</span>
+<span id="cb232-17"><a href="#cb232-17" aria-hidden="true" tabindex="-1"></a>    zeiten.append(time.perf_counter() <span class="op">-</span> t0)</span>
+<span id="cb232-18"><a href="#cb232-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>
@@ -28542,10 +28993,10 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 <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>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="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>
+<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">for</span> kunde <span class="kw">in</span> STAMMKUNDEN:</span>
+<span id="cb233-2"><a href="#cb233-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="cb233-3"><a href="#cb233-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="cb233-4"><a href="#cb233-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>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>
@@ -28690,10 +29141,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="cb234"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb234-1"><a href="#cb234-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="cb234-2"><a href="#cb234-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="cb234-3"><a href="#cb234-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="cb234-4"><a href="#cb234-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>
@@ -28731,17 +29182,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="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="co"># 1. Sind die Binaervariablen wirklich binaer?</span></span>
+<span id="cb235-2"><a href="#cb235-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="cb235-3"><a href="#cb235-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb235-4"><a href="#cb235-4" aria-hidden="true" tabindex="-1"></a><span class="co"># 2. Widerspricht sich die Loesung selbst?</span></span>
+<span id="cb235-5"><a href="#cb235-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="cb235-6"><a href="#cb235-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="cb235-7"><a href="#cb235-7" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb235-8"><a href="#cb235-8" aria-hidden="true" tabindex="-1"></a><span class="co"># 3. Stimmt der Zielwert mit den Kosten der Loesung ueberein?</span></span>
+<span id="cb235-9"><a href="#cb235-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="cb235-10"><a href="#cb235-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="cb235-11"><a href="#cb235-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>
@@ -28763,15 +29214,15 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 <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="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>
+<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>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="cb236-2"><a href="#cb236-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="cb236-3"><a href="#cb236-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="cb236-4"><a href="#cb236-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="cb236-5"><a href="#cb236-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="cb236-6"><a href="#cb236-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="cb236-7"><a href="#cb236-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="cb236-8"><a href="#cb236-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="cb236-9"><a href="#cb236-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>7.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>7.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>
@@ -28925,12 +29376,12 @@ 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="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="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="cb237-2"><a href="#cb237-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="cb237-3"><a href="#cb237-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="cb238"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb238-1"><a href="#cb238-1" aria-hidden="true" tabindex="-1"></a><span class="co"># FALSCH als Pruefung:</span></span>
+<span id="cb238-2"><a href="#cb238-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="#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>
@@ -29056,9 +29507,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="cb239"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb239-1"><a href="#cb239-1" aria-hidden="true" tabindex="-1"></a>eigenwerte <span class="op">=</span> np.linalg.eigvalsh(S)</span>
+<span id="cb239-2"><a href="#cb239-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="cb239-3"><a href="#cb239-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>
@@ -29096,8 +29547,8 @@ Das zugehoerige Dockerfile ist kurz genug, um es ganz zu zeigen:
 <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="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>
+<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>abzug <span class="op">=</span> cp.sum_largest(cp.multiply(UNSICHERHEIT, w), Gamma)</span>
+<span id="cb240-2"><a href="#cb240-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-warum-jedes-projekt-zu-spät-fertig-wird">Finde den Denkfehler — Warum jedes Projekt zu spät fertig wird</h3>
 <ol type="a">
@@ -29128,8 +29579,8 @@ 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="cb241"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb241-1"><a href="#cb241-1" aria-hidden="true" tabindex="-1"></a>puffer <span class="op">=</span> np.quantile(projekt, <span class="fl">0.90</span>)</span>
+<span id="cb241-2"><a href="#cb241-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>
@@ -29151,12 +29602,12 @@ F(11{,}33) = 1 - \frac{(18-11{,}33)^2}{(18-6)(18-10)} = 1 - \frac{44{,}4}{96} =
 <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="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>
+<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>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="cb242-2"><a href="#cb242-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="cb242-3"><a href="#cb242-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="cb242-4"><a href="#cb242-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="cb242-5"><a href="#cb242-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="cb242-6"><a href="#cb242-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>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>
@@ -29164,7 +29615,7 @@ F(11{,}33) = 1 - \frac{(18-11{,}33)^2}{(18-6)(18-10)} = 1 - \frac{44{,}4}{96} =
 <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="cb243"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb243-1"><a href="#cb243-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">
@@ -29202,11 +29653,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="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="at">@functools.lru_cache</span>(<span class="va">None</span>)</span>
+<span id="cb244-2"><a href="#cb244-2" aria-hidden="true" tabindex="-1"></a><span class="kw">def</span> V(t, lager, lief_vorher):</span>
+<span id="cb244-3"><a href="#cb244-3" aria-hidden="true" tabindex="-1"></a>    ...</span>
+<span id="cb244-4"><a href="#cb244-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="cb244-5"><a href="#cb244-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>
@@ -29637,8 +30088,9 @@ T \ge \left(\frac{2\sigma}{\mu}\right)^2 = \left(\frac{2 \cdot 0{,}012}{0{,}0004
 <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 — 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.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>
+<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>
@@ -29698,6 +30150,8 @@ 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>
@@ -29705,19 +30159,19 @@ T \ge \left(\frac{2\sigma}{\mu}\right)^2 = \left(\frac{2 \cdot 0{,}012}{0{,}0004
 <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>23.2 — 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>
+<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><span class="kw">def</span> test_kapazitaeten_verdoppeln(bauer):</span>
+<span id="cb245-2"><a href="#cb245-2" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> schreinerei()</span>
+<span id="cb245-3"><a href="#cb245-3" aria-hidden="true" tabindex="-1"></a>    doppelt <span class="op">=</span> Produktionsproblem(</span>
+<span id="cb245-4"><a href="#cb245-4" aria-hidden="true" tabindex="-1"></a>        produkte<span class="op">=</span>problem.produkte,</span>
+<span id="cb245-5"><a href="#cb245-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="cb245-6"><a href="#cb245-6" aria-hidden="true" tabindex="-1"></a>    basis, gross <span class="op">=</span> bauer(problem), bauer(doppelt)</span>
+<span id="cb245-7"><a href="#cb245-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>23.3 — 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>
+<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="st">&quot;Kapazitaetspruefung mit falschem Vergleich&quot;</span>,</span>
+<span id="cb246-2"><a href="#cb246-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="cb246-3"><a href="#cb246-3" aria-hidden="true" tabindex="-1"></a>(<span class="st">&quot;Toleranz mit falschem Vorzeichen&quot;</span>,</span>
+<span id="cb246-4"><a href="#cb246-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>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>
@@ -29974,8 +30428,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="cb247"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb247-1"><a href="#cb247-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="cb247-2"><a href="#cb247-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>
@@ -29986,18 +30440,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="cb248"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb248-1"><a href="#cb248-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="cb249"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb249-1"><a href="#cb249-1" aria-hidden="true" tabindex="-1"></a><span class="co"># CP-SAT: viel eleganter ueber Reifizierung</span></span>
+<span id="cb249-2"><a href="#cb249-2" aria-hidden="true" tabindex="-1"></a>modell.Add(f_ausdruck <span class="op">&lt;=</span> b1).OnlyEnforceIf(y)</span>
+<span id="cb249-3"><a href="#cb249-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="cb250"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb250-1"><a href="#cb250-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>
@@ -30022,14 +30476,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="cb251"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb251-1"><a href="#cb251-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="cb252"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb252-1"><a href="#cb252-1" aria-hidden="true" tabindex="-1"></a>modell.AddMaxEquality(max_var, liste)   <span class="co"># CP-SAT</span></span>
+<span id="cb252-2"><a href="#cb252-2" aria-hidden="true" tabindex="-1"></a>modell.AddMinEquality(min_var, liste)</span>
+<span id="cb252-3"><a href="#cb252-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Fairness ueber die Spannweite:</span></span>
+<span id="cb252-4"><a href="#cb252-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>
@@ -30040,12 +30494,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="cb253"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb253-1"><a href="#cb253-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="cb253-2"><a href="#cb253-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="cb253-3"><a href="#cb253-3" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> s <span class="kw">in</span> lieferanten:</span>
+<span id="cb253-4"><a href="#cb253-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="cb253-5"><a href="#cb253-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="cb253-6"><a href="#cb253-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>
@@ -30056,11 +30510,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="cb254"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb254-1"><a href="#cb254-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="cb254-2"><a href="#cb254-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="cb254-3"><a href="#cb254-3" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> topf, grenze <span class="kw">in</span> BUDGETS.items():</span>
+<span id="cb254-4"><a href="#cb254-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="cb254-5"><a href="#cb254-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>
@@ -30075,16 +30529,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="cb255"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb255-1"><a href="#cb255-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="cb256"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb256-1"><a href="#cb256-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="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="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="cb257-2"><a href="#cb257-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>
@@ -30095,9 +30549,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="cb258"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb258-1"><a href="#cb258-1" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> t <span class="kw">in</span> perioden:</span>
+<span id="cb258-2"><a href="#cb258-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="cb258-3"><a href="#cb258-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>
@@ -30113,15 +30567,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="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="co"># Stufe 1: nur das Hauptziel</span></span>
+<span id="cb259-2"><a href="#cb259-2" aria-hidden="true" tabindex="-1"></a>modell.Minimize(unbesetzte_schichten)</span>
+<span id="cb259-3"><a href="#cb259-3" aria-hidden="true" tabindex="-1"></a>loeser.Solve(modell)</span>
+<span id="cb259-4"><a href="#cb259-4" aria-hidden="true" tabindex="-1"></a>bestwert <span class="op">=</span> loeser.ObjectiveValue()</span>
+<span id="cb259-5"><a href="#cb259-5" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb259-6"><a href="#cb259-6" aria-hidden="true" tabindex="-1"></a><span class="co"># Stufe 2: Hauptziel fixieren, Nebenziel optimieren</span></span>
+<span id="cb259-7"><a href="#cb259-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="cb259-8"><a href="#cb259-8" aria-hidden="true" tabindex="-1"></a>modell.Minimize(unfairness)</span>
+<span id="cb259-9"><a href="#cb259-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>
@@ -30130,7 +30584,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="cb260"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb260-1"><a href="#cb260-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>
@@ -30230,22 +30684,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="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">assert</span> summe_angebot <span class="op">&gt;=</span> summe_bedarf, <span class="st">&quot;Angebot deckt Bedarf nicht&quot;</span></span>
+<span id="cb261-2"><a href="#cb261-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="cb261-3"><a href="#cb261-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="cb261-4"><a href="#cb261-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="cb261-5"><a href="#cb261-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="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"># statt:  modell.Add(bedingung)</span></span>
+<span id="cb262-2"><a href="#cb262-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="cb262-3"><a href="#cb262-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="cb262-4"><a href="#cb262-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="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">for</span> kunde, (frueh, spaet) <span class="kw">in</span> <span class="bu">enumerate</span>(zeitfenster):</span>
+<span id="cb263-2"><a href="#cb263-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>
@@ -30254,231 +30708,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="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">#!/usr/bin/env python3</span></span>
+<span id="cb264-2"><a href="#cb264-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-3"><a href="#cb264-3" aria-hidden="true" tabindex="-1"></a><span class="co"># Konfliktsuche.py</span></span>
+<span id="cb264-4"><a href="#cb264-4" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb264-5"><a href="#cb264-5" aria-hidden="true" tabindex="-1"></a><span class="co">Anhang Fehlerdiagnose: Den Konflikt finden, der INFEASIBLE verursacht.</span></span>
+<span id="cb264-6"><a href="#cb264-6" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-7"><a href="#cb264-7" aria-hidden="true" tabindex="-1"></a><span class="co">Ein Deletion Filter (auch: IIS, Irreducible Infeasible Subset) isoliert aus</span></span>
+<span id="cb264-8"><a href="#cb264-8" aria-hidden="true" tabindex="-1"></a><span class="co">einem unloesbaren Modell eine kleinste widerspruechliche Teilmenge von</span></span>
+<span id="cb264-9"><a href="#cb264-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="cb264-10"><a href="#cb264-10" aria-hidden="true" tabindex="-1"></a><span class="co">der Rest wieder loesbar.</span></span>
+<span id="cb264-11"><a href="#cb264-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-12"><a href="#cb264-12" aria-hidden="true" tabindex="-1"></a><span class="co">Das Programm zeigt sechs Dinge:</span></span>
+<span id="cb264-13"><a href="#cb264-13" aria-hidden="true" tabindex="-1"></a><span class="co">  1. Der Solver meldet INFEASIBLE - und sonst nichts.</span></span>
+<span id="cb264-14"><a href="#cb264-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="cb264-15"><a href="#cb264-15" aria-hidden="true" tabindex="-1"></a><span class="co">  3. Der Deletion Filter findet einen Konflikt in n Solveraufrufen.</span></span>
+<span id="cb264-16"><a href="#cb264-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="cb264-17"><a href="#cb264-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="cb264-18"><a href="#cb264-18" aria-hidden="true" tabindex="-1"></a><span class="co">  6. Welchen davon man zu sehen bekommt, steuert die Pruefreihenfolge.</span></span>
+<span id="cb264-19"><a href="#cb264-19" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-20"><a href="#cb264-20" aria-hidden="true" tabindex="-1"></a><span class="co">Abgrenzung zu Infeasibility_Diagnose.py (Kapitel Praxisfallen): Dort geht es</span></span>
+<span id="cb264-21"><a href="#cb264-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="cb264-22"><a href="#cb264-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="cb264-23"><a href="#cb264-23" aria-hidden="true" tabindex="-1"></a><span class="co">ueberhaupt. Beides zusammen ergibt den Umgang mit INFEASIBLE in Produktion.</span></span>
+<span id="cb264-24"><a href="#cb264-24" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-25"><a href="#cb264-25" aria-hidden="true" tabindex="-1"></a><span class="co">Benoetigt: numpy, scipy</span></span>
+<span id="cb264-26"><a href="#cb264-26" aria-hidden="true" tabindex="-1"></a><span class="co">&quot;&quot;&quot;</span></span>
+<span id="cb264-27"><a href="#cb264-27" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-28"><a href="#cb264-28" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> __future__ <span class="im">import</span> annotations</span>
+<span id="cb264-29"><a href="#cb264-29" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-30"><a href="#cb264-30" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb264-31"><a href="#cb264-31" aria-hidden="true" tabindex="-1"></a><span class="im">from</span> scipy.optimize <span class="im">import</span> linprog</span>
+<span id="cb264-32"><a href="#cb264-32" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-33"><a href="#cb264-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="cb264-34"><a href="#cb264-34" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-35"><a href="#cb264-35" aria-hidden="true" tabindex="-1"></a><span class="co"># Jede Bedingung traegt einen sprechenden Namen - das ist keine Kosmetik,</span></span>
+<span id="cb264-36"><a href="#cb264-36" aria-hidden="true" tabindex="-1"></a><span class="co"># sondern die Voraussetzung dafuer, dass der Befund lesbar wird.</span></span>
+<span id="cb264-37"><a href="#cb264-37" aria-hidden="true" tabindex="-1"></a><span class="co"># (Name, Koeffizienten je Produkt, Richtung, rechte Seite)</span></span>
+<span id="cb264-38"><a href="#cb264-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="cb264-39"><a href="#cb264-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="cb264-40"><a href="#cb264-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="cb264-41"><a href="#cb264-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="cb264-42"><a href="#cb264-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="cb264-43"><a href="#cb264-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="cb264-44"><a href="#cb264-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="cb264-45"><a href="#cb264-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="cb264-46"><a href="#cb264-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="cb264-47"><a href="#cb264-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="cb264-48"><a href="#cb264-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="cb264-49"><a href="#cb264-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="cb264-50"><a href="#cb264-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="cb264-51"><a href="#cb264-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="cb264-52"><a href="#cb264-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="cb264-53"><a href="#cb264-53" aria-hidden="true" tabindex="-1"></a>]</span>
+<span id="cb264-54"><a href="#cb264-54" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-55"><a href="#cb264-55" aria-hidden="true" tabindex="-1"></a><span class="co"># Welche Bedingungen koennte ein Planer im Ernstfall wirklich veraendern?</span></span>
+<span id="cb264-56"><a href="#cb264-56" aria-hidden="true" tabindex="-1"></a><span class="co"># Kapazitaeten lassen sich durch Sonderschichten dehnen, Liefervertraege und</span></span>
+<span id="cb264-57"><a href="#cb264-57" aria-hidden="true" tabindex="-1"></a><span class="co"># Marktgrenzen nicht.</span></span>
+<span id="cb264-58"><a href="#cb264-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="cb264-59"><a href="#cb264-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="cb264-60"><a href="#cb264-60" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-61"><a href="#cb264-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="cb264-62"><a href="#cb264-62" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-63"><a href="#cb264-63" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-64"><a href="#cb264-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="cb264-65"><a href="#cb264-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="cb264-66"><a href="#cb264-66" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-67"><a href="#cb264-67" aria-hidden="true" tabindex="-1"></a><span class="co">    Es wird nur Zulaessigkeit geprueft, keine Zielfunktion optimiert: die</span></span>
+<span id="cb264-68"><a href="#cb264-68" aria-hidden="true" tabindex="-1"></a><span class="co">    Zielfunktion ist konstant null. INFEASIBLE haengt nie an der Zielfunktion.</span></span>
+<span id="cb264-69"><a href="#cb264-69" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb264-70"><a href="#cb264-70" aria-hidden="true" tabindex="-1"></a>    <span class="kw">global</span> aufrufe</span>
+<span id="cb264-71"><a href="#cb264-71" aria-hidden="true" tabindex="-1"></a>    aufrufe <span class="op">+=</span> <span class="dv">1</span></span>
+<span id="cb264-72"><a href="#cb264-72" aria-hidden="true" tabindex="-1"></a>    matrix, rechte_seite <span class="op">=</span> [], []</span>
+<span id="cb264-73"><a href="#cb264-73" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> auswahl:</span>
+<span id="cb264-74"><a href="#cb264-74" aria-hidden="true" tabindex="-1"></a>        _, koeffizienten, richtung, grenze <span class="op">=</span> BEDINGUNGEN[i]</span>
+<span id="cb264-75"><a href="#cb264-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="cb264-76"><a href="#cb264-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="cb264-77"><a href="#cb264-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="cb264-78"><a href="#cb264-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="cb264-79"><a href="#cb264-79" aria-hidden="true" tabindex="-1"></a>    ergebnis <span class="op">=</span> linprog(np.zeros(<span class="bu">len</span>(PRODUKTE)),</span>
+<span id="cb264-80"><a href="#cb264-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="cb264-81"><a href="#cb264-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="cb264-82"><a href="#cb264-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="cb264-83"><a href="#cb264-83" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-84"><a href="#cb264-84" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-85"><a href="#cb264-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="cb264-86"><a href="#cb264-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="cb264-87"><a href="#cb264-87" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-88"><a href="#cb264-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="cb264-89"><a href="#cb264-89" aria-hidden="true" tabindex="-1"></a><span class="co">    versuchsweise heraus. Bleibt der Rest unloesbar, wurde sie fuer den</span></span>
+<span id="cb264-90"><a href="#cb264-90" aria-hidden="true" tabindex="-1"></a><span class="co">    Widerspruch nicht gebraucht - sie darf endgueltig weg. Wird der Rest</span></span>
+<span id="cb264-91"><a href="#cb264-91" aria-hidden="true" tabindex="-1"></a><span class="co">    loesbar, war sie beteiligt und muss bleiben.</span></span>
+<span id="cb264-92"><a href="#cb264-92" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-93"><a href="#cb264-93" aria-hidden="true" tabindex="-1"></a><span class="co">    Nach genau einem Durchlauf ueber alle Bedingungen ist das Ergebnis</span></span>
+<span id="cb264-94"><a href="#cb264-94" aria-hidden="true" tabindex="-1"></a><span class="co">    unreduzierbar: n Solveraufrufe statt 2^n Teilmengen.</span></span>
+<span id="cb264-95"><a href="#cb264-95" aria-hidden="true" tabindex="-1"></a><span class="co">    &quot;&quot;&quot;</span></span>
+<span id="cb264-96"><a href="#cb264-96" aria-hidden="true" tabindex="-1"></a>    rest <span class="op">=</span> <span class="bu">list</span>(auswahl)</span>
+<span id="cb264-97"><a href="#cb264-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="cb264-98"><a href="#cb264-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="cb264-99"><a href="#cb264-99" aria-hidden="true" tabindex="-1"></a>        <span class="cf">if</span> <span class="kw">not</span> ist_loesbar(probe):</span>
+<span id="cb264-100"><a href="#cb264-100" aria-hidden="true" tabindex="-1"></a>            rest <span class="op">=</span> probe</span>
+<span id="cb264-101"><a href="#cb264-101" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> rest</span>
+<span id="cb264-102"><a href="#cb264-102" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-103"><a href="#cb264-103" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-104"><a href="#cb264-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="cb264-105"><a href="#cb264-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="cb264-106"><a href="#cb264-106" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-107"><a href="#cb264-107" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-108"><a href="#cb264-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="cb264-109"><a href="#cb264-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="cb264-110"><a href="#cb264-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="cb264-111"><a href="#cb264-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="cb264-112"><a href="#cb264-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="cb264-113"><a href="#cb264-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="cb264-114"><a href="#cb264-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="cb264-115"><a href="#cb264-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="cb264-116"><a href="#cb264-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="cb264-117"><a href="#cb264-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="cb264-118"><a href="#cb264-118" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-119"><a href="#cb264-119" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-120"><a href="#cb264-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="cb264-121"><a href="#cb264-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="cb264-122"><a href="#cb264-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="cb264-123"><a href="#cb264-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="cb264-124"><a href="#cb264-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="cb264-125"><a href="#cb264-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="cb264-126"><a href="#cb264-126" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> alle:</span>
+<span id="cb264-127"><a href="#cb264-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="cb264-128"><a href="#cb264-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="cb264-129"><a href="#cb264-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="cb264-130"><a href="#cb264-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="cb264-131"><a href="#cb264-131" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-132"><a href="#cb264-132" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-133"><a href="#cb264-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="cb264-134"><a href="#cb264-134" aria-hidden="true" tabindex="-1"></a>    <span class="kw">global</span> aufrufe</span>
+<span id="cb264-135"><a href="#cb264-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="cb264-136"><a href="#cb264-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="cb264-137"><a href="#cb264-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="cb264-138"><a href="#cb264-138" aria-hidden="true" tabindex="-1"></a>    vorher <span class="op">=</span> aufrufe</span>
+<span id="cb264-139"><a href="#cb264-139" aria-hidden="true" tabindex="-1"></a>    konflikt <span class="op">=</span> deletion_filter(alle)</span>
+<span id="cb264-140"><a href="#cb264-140" aria-hidden="true" tabindex="-1"></a>    kosten <span class="op">=</span> aufrufe <span class="op">-</span> vorher</span>
+<span id="cb264-141"><a href="#cb264-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="cb264-142"><a href="#cb264-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="cb264-143"><a href="#cb264-143" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name <span class="kw">in</span> namen(konflikt):</span>
+<span id="cb264-144"><a href="#cb264-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="cb264-145"><a href="#cb264-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="cb264-146"><a href="#cb264-146" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> i <span class="kw">in</span> konflikt:</span>
+<span id="cb264-147"><a href="#cb264-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="cb264-148"><a href="#cb264-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="cb264-149"><a href="#cb264-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="cb264-150"><a href="#cb264-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="cb264-151"><a href="#cb264-151" aria-hidden="true" tabindex="-1"></a>    <span class="cf">return</span> konflikt</span>
+<span id="cb264-152"><a href="#cb264-152" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-153"><a href="#cb264-153" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-154"><a href="#cb264-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="cb264-155"><a href="#cb264-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="cb264-156"><a href="#cb264-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="cb264-157"><a href="#cb264-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="cb264-158"><a href="#cb264-158" aria-hidden="true" tabindex="-1"></a>    entfernt <span class="op">=</span> konflikt[<span class="dv">0</span>]</span>
+<span id="cb264-159"><a href="#cb264-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="cb264-160"><a href="#cb264-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="cb264-161"><a href="#cb264-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="cb264-162"><a href="#cb264-162" aria-hidden="true" tabindex="-1"></a>    <span class="cf">if</span> ist_loesbar(rest):</span>
+<span id="cb264-163"><a href="#cb264-163" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="st">&quot;... loesbar. Fertig.&quot;</span>)</span>
+<span id="cb264-164"><a href="#cb264-164" aria-hidden="true" tabindex="-1"></a>        <span class="cf">return</span></span>
+<span id="cb264-165"><a href="#cb264-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="cb264-166"><a href="#cb264-166" aria-hidden="true" tabindex="-1"></a>    zweiter <span class="op">=</span> deletion_filter(rest)</span>
+<span id="cb264-167"><a href="#cb264-167" aria-hidden="true" tabindex="-1"></a>    <span class="cf">for</span> name <span class="kw">in</span> namen(zweiter):</span>
+<span id="cb264-168"><a href="#cb264-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="cb264-169"><a href="#cb264-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="cb264-170"><a href="#cb264-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="cb264-171"><a href="#cb264-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="cb264-172"><a href="#cb264-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="cb264-173"><a href="#cb264-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="cb264-174"><a href="#cb264-174" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-175"><a href="#cb264-175" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-176"><a href="#cb264-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="cb264-177"><a href="#cb264-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="cb264-178"><a href="#cb264-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="cb264-179"><a href="#cb264-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="cb264-180"><a href="#cb264-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="cb264-181"><a href="#cb264-181" aria-hidden="true" tabindex="-1"></a>    zufall <span class="op">=</span> np.random.default_rng(<span class="dv">0</span>)</span>
+<span id="cb264-182"><a href="#cb264-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="cb264-183"><a href="#cb264-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="cb264-184"><a href="#cb264-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="cb264-185"><a href="#cb264-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="cb264-186"><a href="#cb264-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="cb264-187"><a href="#cb264-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="cb264-188"><a href="#cb264-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="cb264-189"><a href="#cb264-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="cb264-190"><a href="#cb264-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="cb264-191"><a href="#cb264-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="cb264-192"><a href="#cb264-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="cb264-193"><a href="#cb264-193" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-194"><a href="#cb264-194" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-195"><a href="#cb264-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="cb264-196"><a href="#cb264-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="cb264-197"><a href="#cb264-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="cb264-198"><a href="#cb264-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="cb264-199"><a href="#cb264-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="cb264-200"><a href="#cb264-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="cb264-201"><a href="#cb264-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="cb264-202"><a href="#cb264-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="cb264-203"><a href="#cb264-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="cb264-204"><a href="#cb264-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="cb264-205"><a href="#cb264-205" aria-hidden="true" tabindex="-1"></a>                           (<span class="st">&quot;veraenderliche zuerst  &quot;</span>, frei <span class="op">+</span> fest)):</span>
+<span id="cb264-206"><a href="#cb264-206" aria-hidden="true" tabindex="-1"></a>        konflikt <span class="op">=</span> <span class="bu">sorted</span>(deletion_filter(ordnung))</span>
+<span id="cb264-207"><a href="#cb264-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="cb264-208"><a href="#cb264-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="cb264-209"><a href="#cb264-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="cb264-210"><a href="#cb264-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="cb264-211"><a href="#cb264-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="cb264-212"><a href="#cb264-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="cb264-213"><a href="#cb264-213" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-214"><a href="#cb264-214" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb264-215"><a href="#cb264-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="cb264-216"><a href="#cb264-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="cb264-217"><a href="#cb264-217" aria-hidden="true" tabindex="-1"></a>    teil_1_der_befund(alle)</span>
+<span id="cb264-218"><a href="#cb264-218" aria-hidden="true" tabindex="-1"></a>    teil_2_die_naive_suche(alle)</span>
+<span id="cb264-219"><a href="#cb264-219" aria-hidden="true" tabindex="-1"></a>    konflikt <span class="op">=</span> teil_3_der_filter(alle)</span>
+<span id="cb264-220"><a href="#cb264-220" aria-hidden="true" tabindex="-1"></a>    teil_4_der_naechste_konflikt(alle, konflikt)</span>
+<span id="cb264-221"><a href="#cb264-221" aria-hidden="true" tabindex="-1"></a>    teil_5_die_reihenfolge(alle)</span>
+<span id="cb264-222"><a href="#cb264-222" aria-hidden="true" tabindex="-1"></a>    teil_6_den_befund_steuern(alle)</span>
+<span id="cb264-223"><a href="#cb264-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="cb264-224"><a href="#cb264-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="cb264-225"><a href="#cb264-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
@@ -30608,31 +31062,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="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"># Diagnose: kuenstliche Schranke einziehen und sehen, wohin es laeuft</span></span>
+<span id="cb266-2"><a href="#cb266-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="cb266-3"><a href="#cb266-3" aria-hidden="true" tabindex="-1"></a>res <span class="op">=</span> linprog(...)</span>
+<span id="cb266-4"><a href="#cb266-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="cb266-5"><a href="#cb266-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="cb267"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb267-1"><a href="#cb267-1" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</span>
+<span id="cb267-2"><a href="#cb267-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="cb267-3"><a href="#cb267-3" aria-hidden="true" tabindex="-1"></a>loesen()<span class="op">;</span>                                  t2 <span class="op">=</span> time.perf_counter()</span>
+<span id="cb267-4"><a href="#cb267-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="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"># langsam:                       # schnell:</span></span>
+<span id="cb268-2"><a href="#cb268-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="cb268-3"><a href="#cb268-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="cb269"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb269-1"><a href="#cb269-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="cb269-2"><a href="#cb269-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>
@@ -30646,12 +31100,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="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"># Nach JEDEM Lösen: alle Regeln explizit nachprüfen</span></span>
+<span id="cb270-2"><a href="#cb270-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="cb270-3"><a href="#cb270-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="cb270-4"><a href="#cb270-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="cb270-5"><a href="#cb270-5" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> sektor, idx <span class="kw">in</span> sektoren.items():</span>
+<span id="cb270-6"><a href="#cb270-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>
@@ -30693,37 +31147,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="cb271"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb271-1"><a href="#cb271-1" aria-hidden="true" tabindex="-1"></a>eig <span class="op">=</span> np.linalg.eigvalsh(Sigma)</span>
+<span id="cb271-2"><a href="#cb271-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="cb271-3"><a href="#cb271-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="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="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="cb272-2"><a href="#cb272-2" aria-hidden="true" tabindex="-1"></a><span class="co"># Grobe Peilung: Wertebereiche der Koeffizienten anschauen</span></span>
+<span id="cb272-3"><a href="#cb272-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="cb272-4"><a href="#cb272-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="cb273"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb273-1"><a href="#cb273-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="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="cf">for</span> s, y <span class="kw">in</span> <span class="bu">zip</span>(res.slack, schattenpreise):</span>
+<span id="cb274-2"><a href="#cb274-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="cb275"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb275-1"><a href="#cb275-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="cb275-2"><a href="#cb275-2" aria-hidden="true" tabindex="-1"></a>zuwachs <span class="op">=</span> loese(b_plus) <span class="op">-</span> loese(b)</span>
+<span id="cb275-3"><a href="#cb275-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="cb276"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb276-1"><a href="#cb276-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="cb276-2"><a href="#cb276-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="cb276-3"><a href="#cb276-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="cb276-4"><a href="#cb276-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>
@@ -30779,10 +31233,10 @@ 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="cb278"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb278-1"><a href="#cb278-1" aria-hidden="true" tabindex="-1"></a><span class="bu">print</span>(problem.is_dcp())                      <span class="co"># False?</span></span>
+<span id="cb278-2"><a href="#cb278-2" aria-hidden="true" tabindex="-1"></a><span class="cf">for</span> c <span class="kw">in</span> problem.constraints:</span>
+<span id="cb278-3"><a href="#cb278-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="cb278-4"><a href="#cb278-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>
@@ -30793,10 +31247,10 @@ Insgesamt 2874 Solveraufrufe fuer die gesamte Diagnose.
 <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="cb280"><pre class="sourceCode python"><code class="sourceCode python"><span id="cb280-1"><a href="#cb280-1" aria-hidden="true" tabindex="-1"></a>signal_vorher <span class="op">=</span> berechne_signal(stichtag)</span>
+<span id="cb280-2"><a href="#cb280-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="cb280-3"><a href="#cb280-3" aria-hidden="true" tabindex="-1"></a>signal_nachher <span class="op">=</span> berechne_signal(stichtag)</span>
+<span id="cb280-4"><a href="#cb280-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>
@@ -30806,15 +31260,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="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="co"># IMMER nach dem Import:</span></span>
+<span id="cb281-2"><a href="#cb281-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="cb281-3"><a href="#cb281-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="cb281-4"><a href="#cb281-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="cb281-5"><a href="#cb281-5" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb281-6"><a href="#cb281-6" aria-hidden="true" tabindex="-1"></a><span class="co"># Und Gruppen NIE ueber Positionsindizes definieren:</span></span>
+<span id="cb281-7"><a href="#cb281-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="cb281-8"><a href="#cb281-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="cb281-9"><a href="#cb281-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>
@@ -30835,51 +31289,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="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">from</span> scipy.optimize <span class="im">import</span> linprog</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><span class="co"># linprog MINIMIERT immer -&gt; zum Maximieren die Zielfunktion negieren</span></span>
+<span id="cb282-5"><a href="#cb282-5" aria-hidden="true" tabindex="-1"></a>ergebnis <span class="op">=</span> linprog(</span>
+<span id="cb282-6"><a href="#cb282-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="cb282-7"><a href="#cb282-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="cb282-8"><a href="#cb282-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="cb282-9"><a href="#cb282-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="cb282-10"><a href="#cb282-10" aria-hidden="true" tabindex="-1"></a>    method<span class="op">=</span><span class="st">&quot;highs&quot;</span>)</span>
+<span id="cb282-11"><a href="#cb282-11" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb282-12"><a href="#cb282-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="cb282-13"><a href="#cb282-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="cb282-14"><a href="#cb282-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="cb282-15"><a href="#cb282-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="cb282-16"><a href="#cb282-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="cb282-17"><a href="#cb282-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="cb282-18"><a href="#cb282-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="cb282-19"><a href="#cb282-19" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;UNBOUNDED - Zielfunktion unbeschraenkt&quot;</span>)</span>
+<span id="cb282-20"><a href="#cb282-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="cb282-21"><a href="#cb282-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="cb282-22"><a href="#cb282-22" aria-hidden="true" tabindex="-1"></a><span class="cf">else</span>:</span>
+<span id="cb282-23"><a href="#cb282-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="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">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb283-2"><a href="#cb283-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="cb283-3"><a href="#cb283-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb283-4"><a href="#cb283-4" aria-hidden="true" tabindex="-1"></a><span class="co"># Ganzzahlig: dasselbe Problem, aber x muss ganzzahlig sein</span></span>
+<span id="cb283-5"><a href="#cb283-5" aria-hidden="true" tabindex="-1"></a>ergebnis <span class="op">=</span> milp(</span>
+<span id="cb283-6"><a href="#cb283-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="cb283-7"><a href="#cb283-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="cb283-8"><a href="#cb283-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="cb283-9"><a href="#cb283-9" aria-hidden="true" tabindex="-1"></a>    bounds<span class="op">=</span>Bounds(<span class="dv">0</span>, np.inf))</span>
+<span id="cb283-10"><a href="#cb283-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb283-11"><a href="#cb283-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="cb283-12"><a href="#cb283-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="cb283-13"><a href="#cb283-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="cb283-14"><a href="#cb283-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="cb283-15"><a href="#cb283-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="cb283-16"><a href="#cb283-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="cb283-17"><a href="#cb283-17" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;INFEASIBLE&quot;</span>)</span>
+<span id="cb283-18"><a href="#cb283-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="cb283-19"><a href="#cb283-19" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;UNBOUNDED&quot;</span>)</span>
+<span id="cb283-20"><a href="#cb283-20" aria-hidden="true" tabindex="-1"></a><span class="cf">else</span>:</span>
+<span id="cb283-21"><a href="#cb283-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>
@@ -30889,41 +31343,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="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">import</span> highspy</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>h <span class="op">=</span> highspy.Highs()</span>
+<span id="cb284-5"><a href="#cb284-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="cb284-6"><a href="#cb284-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="cb284-7"><a href="#cb284-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="cb284-8"><a href="#cb284-8" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb284-9"><a href="#cb284-9" aria-hidden="true" tabindex="-1"></a><span class="co"># Variablen: Anzahl, Untergrenzen, Obergrenzen</span></span>
+<span id="cb284-10"><a href="#cb284-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="cb284-11"><a href="#cb284-11" aria-hidden="true" tabindex="-1"></a>h.changeObjectiveSense(highspy.ObjSense.kMaximize)</span>
+<span id="cb284-12"><a href="#cb284-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="cb284-13"><a href="#cb284-13" aria-hidden="true" tabindex="-1"></a>    h.changeColCost(spalte, wert)</span>
+<span id="cb284-14"><a href="#cb284-14" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb284-15"><a href="#cb284-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="cb284-16"><a href="#cb284-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="cb284-17"><a href="#cb284-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="cb284-18"><a href="#cb284-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="cb284-19"><a href="#cb284-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="cb284-20"><a href="#cb284-20" aria-hidden="true" tabindex="-1"></a><span class="co"># Ganzzahligkeit: h.changeColsIntegrality(...) mit highspy.HighsVarType.kInteger</span></span>
+<span id="cb284-21"><a href="#cb284-21" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb284-22"><a href="#cb284-22" aria-hidden="true" tabindex="-1"></a>h.run()</span>
+<span id="cb284-23"><a href="#cb284-23" aria-hidden="true" tabindex="-1"></a>status <span class="op">=</span> h.getModelStatus()</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> highspy.HighsModelStatus.kOptimal:</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>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="cb284-26"><a href="#cb284-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="cb284-27"><a href="#cb284-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="cb284-28"><a href="#cb284-28" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> status <span class="op">==</span> highspy.HighsModelStatus.kInfeasible:</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&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> highspy.HighsModelStatus.kUnbounded:</span>
+<span id="cb284-31"><a href="#cb284-31" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;UNBOUNDED&quot;</span>)</span>
+<span id="cb284-32"><a href="#cb284-32" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> status <span class="op">==</span> highspy.HighsModelStatus.kTimeLimit:</span>
+<span id="cb284-33"><a href="#cb284-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="cb284-34"><a href="#cb284-34" aria-hidden="true" tabindex="-1"></a><span class="cf">else</span>:</span>
+<span id="cb284-35"><a href="#cb284-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>
@@ -30933,34 +31387,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="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">from</span> ortools.linear_solver <span class="im">import</span> pywraplp</span>
+<span id="cb285-2"><a href="#cb285-2" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb285-3"><a href="#cb285-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="cb285-4"><a href="#cb285-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="cb285-5"><a href="#cb285-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="cb285-6"><a href="#cb285-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="cb285-7"><a href="#cb285-7" aria-hidden="true" tabindex="-1"></a>loeser.SetTimeLimit(<span class="dv">60_000</span>)                        <span class="co"># Millisekunden!</span></span>
+<span id="cb285-8"><a href="#cb285-8" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb285-9"><a href="#cb285-9" aria-hidden="true" tabindex="-1"></a>unendlich <span class="op">=</span> loeser.infinity()</span>
+<span id="cb285-10"><a href="#cb285-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="cb285-11"><a href="#cb285-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="cb285-12"><a href="#cb285-12" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb285-13"><a href="#cb285-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="cb285-14"><a href="#cb285-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="cb285-15"><a href="#cb285-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="cb285-16"><a href="#cb285-16" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb285-17"><a href="#cb285-17" aria-hidden="true" tabindex="-1"></a>status <span class="op">=</span> loeser.Solve()</span>
+<span id="cb285-18"><a href="#cb285-18" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> status <span class="op">==</span> pywraplp.Solver.OPTIMAL:</span>
+<span id="cb285-19"><a href="#cb285-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="cb285-20"><a href="#cb285-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="cb285-21"><a href="#cb285-21" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> status <span class="op">==</span> pywraplp.Solver.FEASIBLE:</span>
+<span id="cb285-22"><a href="#cb285-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="cb285-23"><a href="#cb285-23" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> status <span class="op">==</span> pywraplp.Solver.INFEASIBLE:</span>
+<span id="cb285-24"><a href="#cb285-24" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;INFEASIBLE&quot;</span>)</span>
+<span id="cb285-25"><a href="#cb285-25" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> status <span class="op">==</span> pywraplp.Solver.UNBOUNDED:</span>
+<span id="cb285-26"><a href="#cb285-26" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;UNBOUNDED&quot;</span>)</span>
+<span id="cb285-27"><a href="#cb285-27" aria-hidden="true" tabindex="-1"></a><span class="cf">else</span>:</span>
+<span id="cb285-28"><a href="#cb285-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>
@@ -30970,40 +31424,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="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">from</span> ortools.sat.python <span class="im">import</span> cp_model</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> cp_model.CpModel()</span>
+<span id="cb286-4"><a href="#cb286-4" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb286-5"><a href="#cb286-5" aria-hidden="true" tabindex="-1"></a><span class="co"># Variablen - CP-SAT rechnet ausschliesslich mit GANZEN Zahlen</span></span>
+<span id="cb286-6"><a href="#cb286-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="cb286-7"><a href="#cb286-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="cb286-8"><a href="#cb286-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="cb286-9"><a href="#cb286-9" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb286-10"><a href="#cb286-10" aria-hidden="true" tabindex="-1"></a><span class="co"># Nebenbedingungen</span></span>
+<span id="cb286-11"><a href="#cb286-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="cb286-12"><a href="#cb286-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="cb286-13"><a href="#cb286-13" aria-hidden="true" tabindex="-1"></a>modell.AddAllDifferent([x, y])                     <span class="co"># globale Bedingung</span></span>
+<span id="cb286-14"><a href="#cb286-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="cb286-15"><a href="#cb286-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb286-16"><a href="#cb286-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="cb286-17"><a href="#cb286-17" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb286-18"><a href="#cb286-18" aria-hidden="true" tabindex="-1"></a>loeser <span class="op">=</span> cp_model.CpSolver()</span>
+<span id="cb286-19"><a href="#cb286-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="cb286-20"><a href="#cb286-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="cb286-21"><a href="#cb286-21" aria-hidden="true" tabindex="-1"></a>loeser.parameters.random_seed <span class="op">=</span> <span class="dv">1</span></span>
+<span id="cb286-22"><a href="#cb286-22" aria-hidden="true" tabindex="-1"></a>status <span class="op">=</span> loeser.Solve(modell)</span>
+<span id="cb286-23"><a href="#cb286-23" aria-hidden="true" tabindex="-1"></a></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> cp_model.OPTIMAL:</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>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="cb286-26"><a href="#cb286-26" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> status <span class="op">==</span> cp_model.FEASIBLE:</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;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="cb286-28"><a href="#cb286-28" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> status <span class="op">==</span> cp_model.INFEASIBLE:</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 - Bedingungen widersprechen sich&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> cp_model.MODEL_INVALID:</span>
+<span id="cb286-31"><a href="#cb286-31" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Modellfehler:&quot;</span>, modell.Validate())</span>
+<span id="cb286-32"><a href="#cb286-32" aria-hidden="true" tabindex="-1"></a><span class="cf">else</span>:</span>
+<span id="cb286-33"><a href="#cb286-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="cb286-34"><a href="#cb286-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>
@@ -31013,32 +31467,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="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> numpy <span class="im">as</span> np</span>
+<span id="cb287-2"><a href="#cb287-2" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> cvxpy <span class="im">as</span> cp</span>
+<span id="cb287-3"><a href="#cb287-3" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb287-4"><a href="#cb287-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="cb287-5"><a href="#cb287-5" aria-hidden="true" tabindex="-1"></a>gewichte <span class="op">=</span> cp.Variable(<span class="dv">3</span>)</span>
+<span id="cb287-6"><a href="#cb287-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="cb287-7"><a href="#cb287-7" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb287-8"><a href="#cb287-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="cb287-9"><a href="#cb287-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="cb287-10"><a href="#cb287-10" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb287-11"><a href="#cb287-11" aria-hidden="true" tabindex="-1"></a>problem <span class="op">=</span> cp.Problem(ziel, bedingungen)</span>
+<span id="cb287-12"><a href="#cb287-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="cb287-13"><a href="#cb287-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="cb287-14"><a href="#cb287-14" aria-hidden="true" tabindex="-1"></a>problem.solve()</span>
+<span id="cb287-15"><a href="#cb287-15" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb287-16"><a href="#cb287-16" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> problem.status <span class="op">==</span> cp.OPTIMAL:</span>
+<span id="cb287-17"><a href="#cb287-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="cb287-18"><a href="#cb287-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="cb287-19"><a href="#cb287-19" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> problem.status <span class="op">==</span> cp.OPTIMAL_INACCURATE:</span>
+<span id="cb287-20"><a href="#cb287-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="cb287-21"><a href="#cb287-21" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> problem.status <span class="op">==</span> cp.INFEASIBLE:</span>
+<span id="cb287-22"><a href="#cb287-22" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;INFEASIBLE&quot;</span>)</span>
+<span id="cb287-23"><a href="#cb287-23" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> problem.status <span class="op">==</span> cp.UNBOUNDED:</span>
+<span id="cb287-24"><a href="#cb287-24" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;UNBOUNDED&quot;</span>)</span>
+<span id="cb287-25"><a href="#cb287-25" aria-hidden="true" tabindex="-1"></a><span class="cf">else</span>:</span>
+<span id="cb287-26"><a href="#cb287-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>
@@ -31049,73 +31503,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="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">import</span> pyomo.environ <span class="im">as</span> pyo</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> pyo.ConcreteModel()</span>
+<span id="cb288-4"><a href="#cb288-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="cb288-5"><a href="#cb288-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="cb288-6"><a href="#cb288-6" aria-hidden="true" tabindex="-1"></a><span class="co"># ganzzahlig: domain=pyo.NonNegativeIntegers | binaer: domain=pyo.Binary</span></span>
+<span id="cb288-7"><a href="#cb288-7" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb288-8"><a href="#cb288-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="cb288-9"><a href="#cb288-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="cb288-10"><a href="#cb288-10" aria-hidden="true" tabindex="-1"></a>                            sense<span class="op">=</span>pyo.maximize)</span>
+<span id="cb288-11"><a href="#cb288-11" aria-hidden="true" tabindex="-1"></a>modell.montage <span class="op">=</span> pyo.Constraint(</span>
+<span id="cb288-12"><a href="#cb288-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="cb288-13"><a href="#cb288-13" aria-hidden="true" tabindex="-1"></a>modell.pruefung <span class="op">=</span> pyo.Constraint(</span>
+<span id="cb288-14"><a href="#cb288-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="cb288-15"><a href="#cb288-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="cb288-16"><a href="#cb288-16" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb288-17"><a href="#cb288-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="cb288-18"><a href="#cb288-18" aria-hidden="true" tabindex="-1"></a>zustand <span class="op">=</span> ergebnis.solver.termination_condition</span>
+<span id="cb288-19"><a href="#cb288-19" aria-hidden="true" tabindex="-1"></a><span class="cf">if</span> zustand <span class="op">==</span> pyo.TerminationCondition.optimal:</span>
+<span id="cb288-20"><a href="#cb288-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="cb288-21"><a href="#cb288-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="cb288-22"><a href="#cb288-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="cb288-23"><a href="#cb288-23" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> zustand <span class="op">==</span> pyo.TerminationCondition.infeasible:</span>
+<span id="cb288-24"><a href="#cb288-24" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;INFEASIBLE&quot;</span>)</span>
+<span id="cb288-25"><a href="#cb288-25" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> zustand <span class="op">==</span> pyo.TerminationCondition.unbounded:</span>
+<span id="cb288-26"><a href="#cb288-26" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;UNBOUNDED&quot;</span>)</span>
+<span id="cb288-27"><a href="#cb288-27" aria-hidden="true" tabindex="-1"></a><span class="cf">elif</span> zustand <span class="op">==</span> pyo.TerminationCondition.maxTimeLimit:</span>
+<span id="cb288-28"><a href="#cb288-28" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Zeitlimit&quot;</span>)</span>
+<span id="cb288-29"><a href="#cb288-29" aria-hidden="true" tabindex="-1"></a><span class="cf">else</span>:</span>
+<span id="cb288-30"><a href="#cb288-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="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> linopy</span>
+<span id="cb289-2"><a href="#cb289-2" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> numpy <span class="im">as</span> np</span>
+<span id="cb289-3"><a href="#cb289-3" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> pandas <span class="im">as</span> pd</span>
+<span id="cb289-4"><a href="#cb289-4" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> xarray <span class="im">as</span> xr</span>
+<span id="cb289-5"><a href="#cb289-5" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb289-6"><a href="#cb289-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="cb289-7"><a href="#cb289-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="cb289-8"><a href="#cb289-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="cb289-9"><a href="#cb289-9" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb289-10"><a href="#cb289-10" aria-hidden="true" tabindex="-1"></a>modell <span class="op">=</span> linopy.Model()</span>
+<span id="cb289-11"><a href="#cb289-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="cb289-12"><a href="#cb289-12" aria-hidden="true" tabindex="-1"></a>x <span class="op">=</span> modell.variables[<span class="st">&quot;menge&quot;</span>]</span>
+<span id="cb289-13"><a href="#cb289-13" aria-hidden="true" tabindex="-1"></a><span class="co"># ganzzahlig: integer=True | binaer: binary=True</span></span>
+<span id="cb289-14"><a href="#cb289-14" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb289-15"><a href="#cb289-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="cb289-16"><a href="#cb289-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="cb289-17"><a href="#cb289-17" aria-hidden="true" tabindex="-1"></a>                         coords<span class="op">=</span>[ressource, produkt])</span>
+<span id="cb289-18"><a href="#cb289-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="cb289-19"><a href="#cb289-19" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb289-20"><a href="#cb289-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="cb289-21"><a href="#cb289-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="cb289-22"><a href="#cb289-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="cb289-23"><a href="#cb289-23" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb289-24"><a href="#cb289-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="cb289-25"><a href="#cb289-25" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb289-26"><a href="#cb289-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="cb289-27"><a href="#cb289-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="cb289-28"><a href="#cb289-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="cb289-29"><a href="#cb289-29" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;Schattenpreise:&quot;</span>,</span>
+<span id="cb289-30"><a href="#cb289-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="cb289-31"><a href="#cb289-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="cb289-32"><a href="#cb289-32" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;INFEASIBLE&quot;</span>)</span>
+<span id="cb289-33"><a href="#cb289-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="cb289-34"><a href="#cb289-34" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</span>(<span class="st">&quot;UNBOUNDED&quot;</span>)</span>
+<span id="cb289-35"><a href="#cb289-35" aria-hidden="true" tabindex="-1"></a><span class="cf">else</span>:</span>
+<span id="cb289-36"><a href="#cb289-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/milp.html b/OR_HTML_04/milp.html
index 750f393..1224600 100644
--- a/OR_HTML_04/milp.html
+++ b/OR_HTML_04/milp.html
@@ -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>
diff --git a/OR_HTML_04/praxisfallen.html b/OR_HTML_04/praxisfallen.html
index 6d17934..b1e0088 100644
--- a/OR_HTML_04/praxisfallen.html
+++ b/OR_HTML_04/praxisfallen.html
@@ -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
@@ -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,330 @@ 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> subprocess</span>
+<span id="cb10-40"><a href="#cb10-40" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> sys</span>
+<span id="cb10-41"><a href="#cb10-41" aria-hidden="true" tabindex="-1"></a><span class="im">import</span> time</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>) <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;Startet dieses Programm noch einmal - mit genau einem Solverimport.&quot;&quot;&quot;</span></span>
+<span id="cb10-246"><a href="#cb10-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="cb10-247"><a href="#cb10-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="cb10-248"><a href="#cb10-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="cb10-249"><a href="#cb10-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="cb10-250"><a href="#cb10-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="cb10-251"><a href="#cb10-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="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>
+<span id="cb10-254"><a href="#cb10-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="cb10-255"><a href="#cb10-255" aria-hidden="true" tabindex="-1"></a>    problem <span class="op">=</span> beispielproblem()</span>
+<span id="cb10-256"><a href="#cb10-256" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-257"><a href="#cb10-257" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Kindprozess: rechnen und das DTO als JSON ausgeben ---------------</span></span>
+<span id="cb10-258"><a href="#cb10-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="cb10-259"><a href="#cb10-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="cb10-260"><a href="#cb10-260" aria-hidden="true" tabindex="-1"></a>        sys.exit(<span class="dv">0</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 class="co"># --- Hauptprozess: beide Solver anstossen und vergleichen -------------</span></span>
+<span id="cb10-263"><a href="#cb10-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="cb10-264"><a href="#cb10-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="cb10-265"><a href="#cb10-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="cb10-266"><a href="#cb10-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="cb10-267"><a href="#cb10-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="cb10-268"><a href="#cb10-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="cb10-269"><a href="#cb10-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="cb10-270"><a href="#cb10-270" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-271"><a href="#cb10-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="cb10-272"><a href="#cb10-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="cb10-273"><a href="#cb10-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="cb10-274"><a href="#cb10-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="cb10-275"><a href="#cb10-275" aria-hidden="true" tabindex="-1"></a>        beanstandungen <span class="op">=</span> pruefe_zuordnung(problem, loesung)</span>
+<span id="cb10-276"><a href="#cb10-276" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-277"><a href="#cb10-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="cb10-278"><a href="#cb10-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="cb10-279"><a href="#cb10-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="cb10-280"><a href="#cb10-280" aria-hidden="true" tabindex="-1"></a>        <span class="bu">print</span>(<span class="ss">f&quot;  Abnahmepruefung:  &quot;</span></span>
+<span id="cb10-281"><a href="#cb10-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="cb10-282"><a href="#cb10-282" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-283"><a href="#cb10-283" aria-hidden="true" tabindex="-1"></a>    <span class="co"># --- Was der Vergleich zeigt -----------------------------------------</span></span>
+<span id="cb10-284"><a href="#cb10-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="cb10-285"><a href="#cb10-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="cb10-286"><a href="#cb10-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="cb10-287"><a href="#cb10-287" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-288"><a href="#cb10-288" aria-hidden="true" tabindex="-1"></a>    gleich_belegt <span class="op">=</span> <span class="bu">all</span>(</span>
+<span id="cb10-289"><a href="#cb10-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="cb10-290"><a href="#cb10-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="cb10-291"><a href="#cb10-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="cb10-292"><a href="#cb10-292" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-293"><a href="#cb10-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="cb10-294"><a href="#cb10-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="cb10-295"><a href="#cb10-295" aria-hidden="true" tabindex="-1"></a></span>
+<span id="cb10-296"><a href="#cb10-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="cb10-297"><a href="#cb10-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="cb10-298"><a href="#cb10-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="cb10-299"><a href="#cb10-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="cb10-300"><a href="#cb10-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="cb10-301"><a href="#cb10-301" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</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;Nicht umsonst ist der Wechsel trotzdem:&quot;</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;  * CP-SAT rechnet ausschliesslich GANZZAHLIG. Alle Kosten sind hier&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;    deshalb int. Wer in Euro und Cent rechnet, skaliert vorher auf Cent -&quot;</span>)</span>
+<span id="cb10-305"><a href="#cb10-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="cb10-306"><a href="#cb10-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="cb10-307"><a href="#cb10-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="cb10-308"><a href="#cb10-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="cb10-309"><a href="#cb10-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="cb10-310"><a href="#cb10-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="cb10-311"><a href="#cb10-311" aria-hidden="true" tabindex="-1"></a>    <span class="bu">print</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;Der Ertrag: Beide beweisen denselben optimalen Zielwert, und die&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;Entscheidung zwischen ihnen ist eine Frage der Laufzeit geworden -&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;nicht eine Frage, wie viel Code man neu schreiben muss.&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;Verglichen wird deshalb der ZIELWERT, nicht der Plan: Gibt es mehrere&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;gleich teure Loesungen, darf jeder Solver eine andere davon liefern.&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;Hier stimmen sie zufaellig ueberein - darauf zu testen waere trotzdem&quot;</span>)</span>
+<span id="cb10-319"><a href="#cb10-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="cb10-320"><a href="#cb10-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>
 <p><strong>Erwartete Ausgabe</strong> (Laufzeiten hardwareabhängig):</p>
 <pre><code>==================================================================================
   DERSELBE FALL, ZWEI SOLVER - UND EIN AUSWERTUNGSCODE
@@ -1696,14 +2130,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,7 +2187,7 @@ 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>
@@ -1761,10 +2195,11 @@ ein unzuverlaessiger Test (siehe JobShop_Intervalle.py).
 <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.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>
@@ -1807,186 +2242,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,7 +2485,7 @@ 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 22: Drei Fragen zum Selbstcheck</strong></p>
@@ -2061,7 +2496,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 +2506,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>
diff --git a/OR_HTML_04/programme.html b/OR_HTML_04/programme.html
index ce6247d..93d17f8 100644
--- a/OR_HTML_04/programme.html
+++ b/OR_HTML_04/programme.html
@@ -99,7 +99,7 @@
     
     <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 75 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>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/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/stichwortverzeichnis.html b/OR_HTML_04/stichwortverzeichnis.html
index 66f726b..d015476 100644
--- a/OR_HTML_04/stichwortverzeichnis.html
+++ b/OR_HTML_04/stichwortverzeichnis.html
@@ -99,7 +99,7 @@
     
     <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-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>
+    <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-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>
     </article>
     
     <nav class="prev-next"><span class="prev-next-leer"></span><span class="prev-next-leer"></span></nav>
diff --git a/OR_HTML_04/testing.html b/OR_HTML_04/testing.html
index 9833ba3..b48e67f 100644
--- a/OR_HTML_04/testing.html
+++ b/OR_HTML_04/testing.html
@@ -104,7 +104,7 @@
 <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 />
@@ -1551,7 +1551,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>
diff --git a/OR_HTML_04/vorwort.html b/OR_HTML_04/vorwort.html
index 753f40f..497b758 100644
--- a/OR_HTML_04/vorwort.html
+++ b/OR_HTML_04/vorwort.html
@@ -714,41 +714,46 @@ Alles bereit — Sie können mit dem ersten Kapitel beginnen.</code></pre>
 <td><a href="praxisfallen.html#kap-praxisfallen">Kapitel 22</a></td>
 </tr>
 <tr class="odd">
+<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="even">
 <td><code>Betriebsueberwachung.py</code></td>
 <td>Status, Gap und Zeitausschöpfung</td>
 <td><a href="praxisfallen.html#kap-praxisfallen">Kapitel 22</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>or_kern.py</code></td>
 <td>Gemeinsamer Unterbau: Domäne, Status, Prüfung</td>
 <td><a href="praxisfallen.html#kap-praxisfallen">Kapitel 22</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Solverwechsel_CPSAT_HiGHS.py</code></td>
 <td>Derselbe Fall in zwei Solvern</td>
 <td><a href="praxisfallen.html#kap-praxisfallen">Kapitel 22</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>test_or_kern.py</code></td>
 <td>Testsuite für ein Optimierungsmodell</td>
 <td><a href="testing.html#kap-testing">Kapitel 23</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Mutationstest.py</code></td>
 <td>Findet die Lücken der eigenen Tests</td>
 <td><a href="testing.html#kap-testing">Kapitel 23</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Benchmark_Skalierung.py</code></td>
 <td>Aufbau gegen Lösen, vier Bibliotheken</td>
 <td><a href="testing.html#kap-testing">Kapitel 23</a></td>
 </tr>
-<tr class="odd">
+<tr class="even">
 <td><code>Optimierungsdienst.py</code></td>
 <td>Das Modell als HTTP-Dienst</td>
 <td><a href="testing.html#kap-testing">Kapitel 23</a></td>
 </tr>
-<tr class="even">
+<tr class="odd">
 <td><code>Konfliktsuche.py</code></td>
 <td>Deletion Filter: den Widerspruch einkreisen</td>
 <td><a href="anhang-fehlerdiagnose.html#anhang-fehlerdiagnose">Anhang C</a></td>
diff --git a/Operations_Research_mit_Python_Version_04.md b/Operations_Research_mit_Python_Version_04.md
index 2bbb60f..ed2d241 100644
--- a/Operations_Research_mit_Python_Version_04.md
+++ b/Operations_Research_mit_Python_Version_04.md
@@ -380,6 +380,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) |
@@ -1408,7 +1409,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 +1439,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.
 
@@ -6240,7 +6241,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 +6492,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 |
 >
@@ -7895,7 +7896,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**
 >
@@ -15967,7 +15968,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.
 >
@@ -20565,6 +20566,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`
@@ -20624,12 +20626,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.
 
 ---
 
@@ -20890,6 +20893,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.
@@ -20919,7 +20924,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)
 
@@ -20946,7 +21401,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.
 
@@ -21550,7 +22005,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.
 
@@ -21966,7 +22421,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:
 
@@ -21997,7 +22452,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.
@@ -22029,7 +22484,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).
 
@@ -22041,13 +22496,15 @@ Wenn Sie doch tiefer in die Methodik wollen, sind das die lohnendsten Richtungen
 
 **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**.
 
@@ -22323,7 +22780,7 @@ sichtbar wird, und gibt Zeit zum Handeln.
 
 ---
 
-## 22.11 Micro-Quiz {#sec:praxisfallen-quiz}
+## 22.12 Micro-Quiz {#sec:praxisfallen-quiz}
 
 > **❓ Micro-Quiz 22: Drei Fragen zum Selbstcheck**
 >
@@ -22337,7 +22794,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).
 
@@ -22346,13 +22803,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.
@@ -22370,7 +22833,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.
 >
@@ -23783,7 +24246,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.
 
@@ -25621,9 +26084,11 @@ Ein zweiter Blick auf denselben Testzeitraum ist deshalb kein „nochmal prüfen
 
 **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.
 
-**22.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.
 
-**22.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 %.
+
+**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
 
@@ -25669,6 +26134,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.
 
 ---
 
diff --git a/Operations_Research_mit_Python_Version_04.pdf b/Operations_Research_mit_Python_Version_04.pdf
index fbf9d44..4e50397 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..f5eb016 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
@@ -470,6 +470,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/50_Praxis.md b/Operations_Research_mit_Python_Version_04/50_Praxis.md
index a7acbca..c35cb78 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)
@@ -1615,6 +2116,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 %.
@@ -1962,6 +2474,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 +2487,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.
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 8be17ce..c08de8e 100644
--- a/Operations_Research_mit_Python_Version_04/90_Anhang_Loesungen.md
+++ b/Operations_Research_mit_Python_Version_04/90_Anhang_Loesungen.md
@@ -2878,6 +2878,26 @@ Verletzung wählt.
 Bestandteilen; (2) je Entscheidung die bindenden Bedingungen; (3) Schattenpreise der
 knappsten Ressourcen mit Handlungsempfehlung.
 
+**{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
@@ -2975,6 +2995,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.
 
 ---
 
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/README.md b/Operations_Research_mit_Python_Version_04_Programme/README.md
index a47a71c..782687e 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 75 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 75 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/PROGRESS.md b/PROGRESS.md
index fd42ca5..17885f3 100644
--- a/PROGRESS.md
+++ b/PROGRESS.md
@@ -77,14 +77,14 @@ sie unerwartet ab, ist etwas kaputtgegangen.
 | Kapiteldateien | 22 | **31** |
 | Kapitel | 15 | **23** |
 | Anhänge | 4 | **5** |
-| Zeilen im Gesamtdokument | 11 082 | **27 401** |
-| Größe des Gesamtdokuments | 606 KB | **1 536 KB** |
-| Hauptüberschriften | 131 | **289** |
-| registrierte Abschnitte | 122 | **293** |
-| aufgelöste Querverweise | 314 | **720** (0 unaufgelöst) |
-| Indexmarken | 295 | **327** |
-| Beispielprogramme | 41 | **74** (alle lauffähig) |
-| PDF-Seiten | — | **725** |
+| Zeilen im Gesamtdokument | 11 082 | **27 868** |
+| Größe des Gesamtdokuments | 606 KB | **1 565 KB** |
+| Hauptüberschriften | 131 | **297** |
+| registrierte Abschnitte | 122 | **294** |
+| aufgelöste Querverweise | 314 | **725** (0 unaufgelöst) |
+| Indexmarken | 295 | **328** |
+| Beispielprogramme | 41 | **75** (alle lauffähig) |
+| PDF-Seiten | — | **737** |
 | Notebooks | — | **25** |
 | Plotly-Figuren | — | **4** |
 | Diagramme (SVG) | 26 | **32**, davon **18** mit Generatorskript (15 Skripte) |
@@ -1512,6 +1512,59 @@ den Aufgabentiteln ab (gekürzt: „Zweistufiges Modell rechnen" → „Zweistuf
 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.
+
 ---
 
 ## 8. Commit-Historie des V04-Strangs
diff --git a/README.md b/README.md
index 7fc9beb..034719c 100644
--- a/README.md
+++ b/README.md
@@ -17,9 +17,9 @@ daraus ab, und alle Befehle unten werden **hier** ausgeführt.
 | `Operations_Research_mit_Python_Version_04/` | **Quelle**: 31 Kapiteldateien + 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, 737 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: 75 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`, …) |