Notebook-Tests: nbmake + Subprocess-Zellen + inkrementeller Test

Alle 25 Notebooks sind nun fehlerfrei testbar (25 passed). Dafür drei
Änderungen im Build und eine neue Test-Infrastruktur:

1. pyproject.toml: nbmake>=1.5 in der dev-Gruppe.

2. build_version_04.py: Notebooks bekommen zwei Setup-Zellen und
   Subprocess-Zellen für Programme, die nicht direkt im Kernel laufen:
   - NOTEBOOK_SETUP_2: __file__ definieren, sys.path für or_kern,
     multiprocessing auf fork (Spawn findet Kernel-Funktionen nicht).
   - _braucht_subprocess: erkennt highspy (Solver-Konflikt), pytest
     (SystemExit), get_context('spawn'), subprocess+__file__ (sucht
     .py-Dateien), sys.exit (SystemExit). Diese Programme erscheinen
     als Markdown-Codeblock (sichtbar, nicht ausführbar) plus einer
     Subprocess-Zelle mit NO_COLOR=1 (verhindert ANSI-Codes, die der
     Parser von Mutationstest.py nicht verarbeitet).
   - Solver-Konflikt-Erkennung: wenn ein Kapitel sowohl ortools als
     auch highspy importiert, laufen auch reine ortools-Programme als
     Subprocess (highspy schon im Kernel).

3. teste_code_04.py: inkrementeller Test — nur geänderte/neue Programme
   und Notebooks (via git status). Netzabhängige Dateien (yfinance)
   werden automatisch erkannt und nur getestet, wenn Internet verfügbar.

4. PLAN.md Abschnitt 10: neuer Verifikationsschritt 4 (pytest --nbmake).
   PROGRESS.md und CLAUDE.md aktualisiert.

Gefundene und behobene Probleme:
- or_kern-Import: sys.path im Notebook erweitert.
- __file__ nicht definiert: zweite Setup-Zelle setzt es.
- multiprocessing spawn: fork erzwungen (Ein_System_Vier_Ansaetze.py).
- ortools/highspy-Konflikt: Subprocess für beide Solver.
- pytest SystemExit: Subprocess für test_or_kern.py und Mutationstest.py.
- sys.exit(0): Subprocess für Installationstest.py.
- ANSI-Codes in pytest-Ausgabe: NO_COLOR=1 in Subprocess-Zelle.

.gitignore

@@ -7,6 +7,9 @@ __pycache__/
 venv/
 .venv/
 
+# pip install -e . legt dieses Verzeichnis an (Metadaten des editierbaren Pakets)
+or_mit_python.egg-info/
+
 # LaTeX/xelatex-Nebenprodukte des PDF-Baus (build_version_04.py --pdf)
 build_v04.log
 build_v04.tex

CLAUDE.md

@@ -174,6 +174,31 @@ Auch das `README.md` im Programme-Verzeichnis wird erzeugt — aus der Vorlage
 **`or_kern.py` ist der gemeinsame Unterbau** aller Programme (Domänenmodell, `SolverStatus`,
 `Loesung`-DTO, Abnahmeprüfung). Abgedruckt im Kapitel Praxisfallen.
 
+**Notebook-Tests (`nbmake`).** Seit September 2026 sind die 25 Notebooks ebenso
+getestet wie die Programme. `pyproject.toml` hat `nbmake>=1.5` in der `dev`-Gruppe;
+`PLAN.md` Abschnitt 10 enthält den zusätzlichen Verifikationsschritt
+`pytest --nbmake --nbmake-timeout=900 Notebooks_04/ -q`. Dafür müssen die Notebooks im
+Build drei Dinge mitbringen, die ein Programmskript nicht braucht:
+* **Zweite Setup-Zelle** (`NOTEBOOK_SETUP_2` in `build_version_04.py`): definiert
+  `__file__` (Programme nutzen es für `OUTPUT_DIR`), erweitert `sys.path` um das
+  Programmverzeichnis (`from or_kern import …`) und stellt multiprocessing auf `fork`
+  (der Spawn-Modus findet Kernel-Funktionen nicht).
+* **Subprocess-Zellen** für Programme, die nicht direkt im Kernel laufen:
+  `import highspy` (Solver-Konflikt mit ortools), `import pytest` (`SystemExit`),
+  `get_context("spawn")` (multiprocessing), `import subprocess` + `__file__` (sucht
+  andere .py-Dateien), `sys.exit(` (`SystemExit` im Kernel). Diese Programme erscheinen
+  als Markdown-Codeblock (sichtbar, nicht ausführbar) plus einer Subprocess-Zelle, die
+  das Programm mit `NO_COLOR=1` aufruft (sonst gibt pytest ANSI-Codes aus, die der
+  Ausgabe-Parser von `Mutationstest.py` nicht verarbeitet).
+* **`%pip`-Setup-Zelle** trägt das Tag `nbmake-skip` (wird von nbmake aktuell noch
+  ignoriert, aber als Dokumentation gedacht — die Zelle ist schnell, wenn Pakete schon
+  installiert sind).
+* **Inkrementeller Test** (`teste_code_04.py`): testet nur Programme und Notebooks,
+  die sich seit dem letzten Commit geändert haben (via `git status`). Netzabhängige
+  Dateien (yfinance) werden automatisch erkannt und nur getestet, wenn Internet
+  verfügbar ist. Aufruf: `python3 …/teste_code_04.py` (geänderte), `--alles`
+  (alle), `--check` (nur anzeigen).
+
 **`ortools` und `highspy` lassen sich nicht im selben Prozess importieren** (beide bringen
 eine eigene HiGHS-Kopie mit). Deshalb lädt `or_kern.py` Solverbibliotheken erst in der
 aufrufenden Funktion, und Programme, die beide brauchen, starten getrennte Prozesse (Muster:

Notebooks_04/anhang-fehlerdiagnose.ipynb

@@ -12,7 +12,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "tags": [
+     "nbmake-skip"
+    ]
+   },
    "outputs": [],
    "source": [
     "# Einmalig ausfuehren: installiert alle im Buch verwendeten Pakete.\n",
@@ -21,6 +25,36 @@
     "    scikit-learn matplotlib plotly pyomo linopy pymoo pydantic openpyxl"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Notebook-spezifisches Setup: __file__ definieren (Programme nutzen es\n",
+    "# fuer OUTPUT_DIR), Programmverzeichnis in den Suchpfad aufnehmen (or_kern)\n",
+    "# und multiprocessing auf 'fork' stellen (Spawn findet Kernel-Funktionen nicht).\n",
+    "import os, sys\n",
+    "__file__ = os.path.join(os.getcwd(), '_notebook.py')\n",
+    "for _p in [os.path.join(os.path.dirname(os.getcwd()),\n",
+    "                       'Operations_Research_mit_Python_Version_04_Programme'),\n",
+    "            os.path.dirname(os.getcwd()), os.getcwd()]:\n",
+    "    if os.path.isfile(os.path.join(_p, 'or_kern.py')):\n",
+    "        sys.path.insert(0, _p); break\n",
+    "import multiprocessing as _mp\n",
+    "try: _mp.set_start_method('fork', force=True)\n",
+    "except (RuntimeError, ValueError): pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Wenn die fünf Schritte nicht reichen: den Konflikt einkreisen\n",
+    "\n",
+    "`Konfliktsuche.py`\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},

Notebooks_04/bruecke.ipynb

@@ -12,7 +12,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "tags": [
+     "nbmake-skip"
+    ]
+   },
    "outputs": [],
    "source": [
     "# Einmalig ausfuehren: installiert alle im Buch verwendeten Pakete.\n",
@@ -21,6 +25,36 @@
     "    scikit-learn matplotlib plotly pyomo linopy pymoo pydantic openpyxl"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Notebook-spezifisches Setup: __file__ definieren (Programme nutzen es\n",
+    "# fuer OUTPUT_DIR), Programmverzeichnis in den Suchpfad aufnehmen (or_kern)\n",
+    "# und multiprocessing auf 'fork' stellen (Spawn findet Kernel-Funktionen nicht).\n",
+    "import os, sys\n",
+    "__file__ = os.path.join(os.getcwd(), '_notebook.py')\n",
+    "for _p in [os.path.join(os.path.dirname(os.getcwd()),\n",
+    "                       'Operations_Research_mit_Python_Version_04_Programme'),\n",
+    "            os.path.dirname(os.getcwd()), os.getcwd()]:\n",
+    "    if os.path.isfile(os.path.join(_p, 'or_kern.py')):\n",
+    "        sys.path.insert(0, _p); break\n",
+    "import multiprocessing as _mp\n",
+    "try: _mp.set_start_method('fork', force=True)\n",
+    "except (RuntimeError, ValueError): pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Das Programm\n",
+    "\n",
+    "`Strukturbruecke.py`\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},

Notebooks_04/cpsat.ipynb

@@ -12,7 +12,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "tags": [
+     "nbmake-skip"
+    ]
+   },
    "outputs": [],
    "source": [
     "# Einmalig ausfuehren: installiert alle im Buch verwendeten Pakete.\n",
@@ -21,6 +25,36 @@
     "    scikit-learn matplotlib plotly pyomo linopy pymoo pydantic openpyxl"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Notebook-spezifisches Setup: __file__ definieren (Programme nutzen es\n",
+    "# fuer OUTPUT_DIR), Programmverzeichnis in den Suchpfad aufnehmen (or_kern)\n",
+    "# und multiprocessing auf 'fork' stellen (Spawn findet Kernel-Funktionen nicht).\n",
+    "import os, sys\n",
+    "__file__ = os.path.join(os.getcwd(), '_notebook.py')\n",
+    "for _p in [os.path.join(os.path.dirname(os.getcwd()),\n",
+    "                       'Operations_Research_mit_Python_Version_04_Programme'),\n",
+    "            os.path.dirname(os.getcwd()), os.getcwd()]:\n",
+    "    if os.path.isfile(os.path.join(_p, 'or_kern.py')):\n",
+    "        sys.path.insert(0, _p); break\n",
+    "import multiprocessing as _mp\n",
+    "try: _mp.set_start_method('fork', force=True)\n",
+    "except (RuntimeError, ValueError): pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Was Propagation leistet\n",
+    "\n",
+    "`Propagation_Demo.py`\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -116,6 +150,15 @@
     "`CP_SAT_Vertretungssystem.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Praxisfall: Dynamisches Vertretungssystem\n",
+    "\n",
+    "`CP_SAT_Vertretungssystem.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -375,6 +418,15 @@
     "`JobShop_Intervalle.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Intervallvariablen: Job-Shop-Scheduling\n",
+    "\n",
+    "`JobShop_Intervalle.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -505,6 +557,15 @@
     "`Parallele_Suche.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Parallele Suche: was `num_workers` wirklich bewirkt\n",
+    "\n",
+    "`Parallele_Suche.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -717,6 +778,15 @@
     "`CP_SAT_Statusfaelle.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Die fünf Antworten von CP-SAT\n",
+    "\n",
+    "`CP_SAT_Statusfaelle.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -957,6 +1027,15 @@
     "`Strafgewichte.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Finde den Denkfehler\n",
+    "\n",
+    "`Strafgewichte.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,

Notebooks_04/cvar.ipynb

@@ -12,7 +12,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "tags": [
+     "nbmake-skip"
+    ]
+   },
    "outputs": [],
    "source": [
     "# Einmalig ausfuehren: installiert alle im Buch verwendeten Pakete.\n",
@@ -21,6 +25,36 @@
     "    scikit-learn matplotlib plotly pyomo linopy pymoo pydantic openpyxl"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Notebook-spezifisches Setup: __file__ definieren (Programme nutzen es\n",
+    "# fuer OUTPUT_DIR), Programmverzeichnis in den Suchpfad aufnehmen (or_kern)\n",
+    "# und multiprocessing auf 'fork' stellen (Spawn findet Kernel-Funktionen nicht).\n",
+    "import os, sys\n",
+    "__file__ = os.path.join(os.getcwd(), '_notebook.py')\n",
+    "for _p in [os.path.join(os.path.dirname(os.getcwd()),\n",
+    "                       'Operations_Research_mit_Python_Version_04_Programme'),\n",
+    "            os.path.dirname(os.getcwd()), os.getcwd()]:\n",
+    "    if os.path.isfile(os.path.join(_p, 'or_kern.py')):\n",
+    "        sys.path.insert(0, _p); break\n",
+    "import multiprocessing as _mp\n",
+    "try: _mp.set_start_method('fork', force=True)\n",
+    "except (RuntimeError, ValueError): pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Die zwei Schwächen des Markowitz-Modells\n",
+    "\n",
+    "`VaR_CVaR_Demo.py`\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -152,6 +186,15 @@
     "`CVaR_Portfolio.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Implementierung: CVaR-Portfolio mit Reibung\n",
+    "\n",
+    "`CVaR_Portfolio.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,

Notebooks_04/dekomposition.ipynb

@@ -12,7 +12,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "tags": [
+     "nbmake-skip"
+    ]
+   },
    "outputs": [],
    "source": [
     "# Einmalig ausfuehren: installiert alle im Buch verwendeten Pakete.\n",
@@ -21,6 +25,36 @@
     "    scikit-learn matplotlib plotly pyomo linopy pymoo pydantic openpyxl"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Notebook-spezifisches Setup: __file__ definieren (Programme nutzen es\n",
+    "# fuer OUTPUT_DIR), Programmverzeichnis in den Suchpfad aufnehmen (or_kern)\n",
+    "# und multiprocessing auf 'fork' stellen (Spawn findet Kernel-Funktionen nicht).\n",
+    "import os, sys\n",
+    "__file__ = os.path.join(os.getcwd(), '_notebook.py')\n",
+    "for _p in [os.path.join(os.path.dirname(os.getcwd()),\n",
+    "                       'Operations_Research_mit_Python_Version_04_Programme'),\n",
+    "            os.path.dirname(os.getcwd()), os.getcwd()]:\n",
+    "    if os.path.isfile(os.path.join(_p, 'or_kern.py')):\n",
+    "        sys.path.insert(0, _p); break\n",
+    "import multiprocessing as _mp\n",
+    "try: _mp.set_start_method('fork', force=True)\n",
+    "except (RuntimeError, ValueError): pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Das Programm\n",
+    "\n",
+    "`Spaltengenerierung.py`\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},

Notebooks_04/dynamische-programmierung.ipynb

@@ -12,7 +12,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "tags": [
+     "nbmake-skip"
+    ]
+   },
    "outputs": [],
    "source": [
     "# Einmalig ausfuehren: installiert alle im Buch verwendeten Pakete.\n",
@@ -21,6 +25,36 @@
     "    scikit-learn matplotlib plotly pyomo linopy pymoo pydantic openpyxl"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Notebook-spezifisches Setup: __file__ definieren (Programme nutzen es\n",
+    "# fuer OUTPUT_DIR), Programmverzeichnis in den Suchpfad aufnehmen (or_kern)\n",
+    "# und multiprocessing auf 'fork' stellen (Spawn findet Kernel-Funktionen nicht).\n",
+    "import os, sys\n",
+    "__file__ = os.path.join(os.getcwd(), '_notebook.py')\n",
+    "for _p in [os.path.join(os.path.dirname(os.getcwd()),\n",
+    "                       'Operations_Research_mit_Python_Version_04_Programme'),\n",
+    "            os.path.dirname(os.getcwd()), os.getcwd()]:\n",
+    "    if os.path.isfile(os.path.join(_p, 'or_kern.py')):\n",
+    "        sys.path.insert(0, _p); break\n",
+    "import multiprocessing as _mp\n",
+    "try: _mp.set_start_method('fork', force=True)\n",
+    "except (RuntimeError, ValueError): pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Die Bellman-Gleichung\n",
+    "\n",
+    "`Bellman_Minimalbeispiel.py`\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -132,6 +166,15 @@
     "`Mehrperiodige_Order_Execution.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Das Almgren-Chriss-Problem: optimale Orderausführung\n",
+    "\n",
+    "`Mehrperiodige_Order_Execution.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,

Notebooks_04/einfuehrung.ipynb

@@ -12,7 +12,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "tags": [
+     "nbmake-skip"
+    ]
+   },
    "outputs": [],
    "source": [
     "# Einmalig ausfuehren: installiert alle im Buch verwendeten Pakete.\n",
@@ -21,6 +25,36 @@
     "    scikit-learn matplotlib plotly pyomo linopy pymoo pydantic openpyxl"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Notebook-spezifisches Setup: __file__ definieren (Programme nutzen es\n",
+    "# fuer OUTPUT_DIR), Programmverzeichnis in den Suchpfad aufnehmen (or_kern)\n",
+    "# und multiprocessing auf 'fork' stellen (Spawn findet Kernel-Funktionen nicht).\n",
+    "import os, sys\n",
+    "__file__ = os.path.join(os.getcwd(), '_notebook.py')\n",
+    "for _p in [os.path.join(os.path.dirname(os.getcwd()),\n",
+    "                       'Operations_Research_mit_Python_Version_04_Programme'),\n",
+    "            os.path.dirname(os.getcwd()), os.getcwd()]:\n",
+    "    if os.path.isfile(os.path.join(_p, 'or_kern.py')):\n",
+    "        sys.path.insert(0, _p); break\n",
+    "import multiprocessing as _mp\n",
+    "try: _mp.set_start_method('fork', force=True)\n",
+    "except (RuntimeError, ValueError): pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Warum Ausprobieren scheitert — mit eigener Rechnung\n",
+    "\n",
+    "`Brute_Force_Vergleich.py`\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -150,6 +184,15 @@
     "`Bausteine_Vorlage.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Die Bausteine in der Praxis: eine Vorlage\n",
+    "\n",
+    "`Bausteine_Vorlage.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -250,6 +293,15 @@
     "`Bot_Allokation.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Umsetzung mit Google OR-Tools\n",
+    "\n",
+    "`Bot_Allokation.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -363,6 +415,15 @@
     "`Excel_Bruecke.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Von Excel zu Python: Ihre Daten liegen schon da\n",
+    "\n",
+    "`Excel_Bruecke.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,

Notebooks_04/finanzdaten.ipynb

@@ -12,7 +12,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "tags": [
+     "nbmake-skip"
+    ]
+   },
    "outputs": [],
    "source": [
     "# Einmalig ausfuehren: installiert alle im Buch verwendeten Pakete.\n",
@@ -21,6 +25,36 @@
     "    scikit-learn matplotlib plotly pyomo linopy pymoo pydantic openpyxl"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Notebook-spezifisches Setup: __file__ definieren (Programme nutzen es\n",
+    "# fuer OUTPUT_DIR), Programmverzeichnis in den Suchpfad aufnehmen (or_kern)\n",
+    "# und multiprocessing auf 'fork' stellen (Spawn findet Kernel-Funktionen nicht).\n",
+    "import os, sys\n",
+    "__file__ = os.path.join(os.getcwd(), '_notebook.py')\n",
+    "for _p in [os.path.join(os.path.dirname(os.getcwd()),\n",
+    "                       'Operations_Research_mit_Python_Version_04_Programme'),\n",
+    "            os.path.dirname(os.getcwd()), os.getcwd()]:\n",
+    "    if os.path.isfile(os.path.join(_p, 'or_kern.py')):\n",
+    "        sys.path.insert(0, _p); break\n",
+    "import multiprocessing as _mp\n",
+    "try: _mp.set_start_method('fork', force=True)\n",
+    "except (RuntimeError, ValueError): pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Logarithmische Rendite{idx:Logarithmische Rendite}\n",
+    "\n",
+    "`Renditen_Vergleich.py`\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -115,6 +149,15 @@
     "`Schaetzrauschen_Demo.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Das Schätzfehler{idx:Schätzfehler}-Problem\n",
+    "\n",
+    "`Schaetzrauschen_Demo.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -228,6 +271,15 @@
     "`Finanzdaten_Ledoit_Wolf.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Praxis: Datenpipeline mit korrekter Spaltenreihenfolge\n",
+    "\n",
+    "`Finanzdaten_Ledoit_Wolf.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -392,6 +444,15 @@
     "`Kovarianz_Falle.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Finde den Denkfehler\n",
+    "\n",
+    "`Kovarianz_Falle.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,

Notebooks_04/fundament.ipynb

@@ -12,7 +12,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "tags": [
+     "nbmake-skip"
+    ]
+   },
    "outputs": [],
    "source": [
     "# Einmalig ausfuehren: installiert alle im Buch verwendeten Pakete.\n",
@@ -21,6 +25,36 @@
     "    scikit-learn matplotlib plotly pyomo linopy pymoo pydantic openpyxl"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Notebook-spezifisches Setup: __file__ definieren (Programme nutzen es\n",
+    "# fuer OUTPUT_DIR), Programmverzeichnis in den Suchpfad aufnehmen (or_kern)\n",
+    "# und multiprocessing auf 'fork' stellen (Spawn findet Kernel-Funktionen nicht).\n",
+    "import os, sys\n",
+    "__file__ = os.path.join(os.getcwd(), '_notebook.py')\n",
+    "for _p in [os.path.join(os.path.dirname(os.getcwd()),\n",
+    "                       'Operations_Research_mit_Python_Version_04_Programme'),\n",
+    "            os.path.dirname(os.getcwd()), os.getcwd()]:\n",
+    "    if os.path.isfile(os.path.join(_p, 'or_kern.py')):\n",
+    "        sys.path.insert(0, _p); break\n",
+    "import multiprocessing as _mp\n",
+    "try: _mp.set_start_method('fork', force=True)\n",
+    "except (RuntimeError, ValueError): pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Dasselbe in Python\n",
+    "\n",
+    "`Matrixform.py`\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -101,6 +135,15 @@
     "`Konvexitaet_Demo.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Konvexität sichtbar machen\n",
+    "\n",
+    "`Konvexitaet_Demo.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -191,6 +234,15 @@
     "`Visualisierung_Loesungsraum.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Geometrische Visualisierung des Lösungsraums\n",
+    "\n",
+    "`Visualisierung_Loesungsraum.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -348,6 +400,15 @@
     "`Skalierung_Kondition.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Das Experiment\n",
+    "\n",
+    "`Skalierung_Kondition.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,

Notebooks_04/graphen.ipynb

@@ -12,7 +12,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "tags": [
+     "nbmake-skip"
+    ]
+   },
    "outputs": [],
    "source": [
     "# Einmalig ausfuehren: installiert alle im Buch verwendeten Pakete.\n",
@@ -21,6 +25,36 @@
     "    scikit-learn matplotlib plotly pyomo linopy pymoo pydantic openpyxl"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Notebook-spezifisches Setup: __file__ definieren (Programme nutzen es\n",
+    "# fuer OUTPUT_DIR), Programmverzeichnis in den Suchpfad aufnehmen (or_kern)\n",
+    "# und multiprocessing auf 'fork' stellen (Spawn findet Kernel-Funktionen nicht).\n",
+    "import os, sys\n",
+    "__file__ = os.path.join(os.getcwd(), '_notebook.py')\n",
+    "for _p in [os.path.join(os.path.dirname(os.getcwd()),\n",
+    "                       'Operations_Research_mit_Python_Version_04_Programme'),\n",
+    "            os.path.dirname(os.getcwd()), os.getcwd()]:\n",
+    "    if os.path.isfile(os.path.join(_p, 'or_kern.py')):\n",
+    "        sys.path.insert(0, _p); break\n",
+    "import multiprocessing as _mp\n",
+    "try: _mp.set_start_method('fork', force=True)\n",
+    "except (RuntimeError, ValueError): pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Das Minimum-Cost-Flow-Problem (MCNFP)\n",
+    "\n",
+    "`Min_Cost_Flow.py`\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -144,6 +178,15 @@
     "`Zuordnung_Ungarisch.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Der Satz von Birkhoff und von Neumann{idx:Satz von Birkhoff und von Neumann}\n",
+    "\n",
+    "`Zuordnung_Ungarisch.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -266,6 +309,15 @@
     "`VRP_Flotten_Routing.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Praxisbeispiel: Flotten-Routing\n",
+    "\n",
+    "`VRP_Flotten_Routing.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -448,6 +500,15 @@
     "`VRP_Kapazitaetsfalle.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Finde den Denkfehler\n",
+    "\n",
+    "`VRP_Kapazitaetsfalle.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,

Notebooks_04/handelsmaschine.ipynb

@@ -12,7 +12,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "tags": [
+     "nbmake-skip"
+    ]
+   },
    "outputs": [],
    "source": [
     "# Einmalig ausfuehren: installiert alle im Buch verwendeten Pakete.\n",
@@ -21,6 +25,36 @@
     "    scikit-learn matplotlib plotly pyomo linopy pymoo pydantic openpyxl"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Notebook-spezifisches Setup: __file__ definieren (Programme nutzen es\n",
+    "# fuer OUTPUT_DIR), Programmverzeichnis in den Suchpfad aufnehmen (or_kern)\n",
+    "# und multiprocessing auf 'fork' stellen (Spawn findet Kernel-Funktionen nicht).\n",
+    "import os, sys\n",
+    "__file__ = os.path.join(os.getcwd(), '_notebook.py')\n",
+    "for _p in [os.path.join(os.path.dirname(os.getcwd()),\n",
+    "                       'Operations_Research_mit_Python_Version_04_Programme'),\n",
+    "            os.path.dirname(os.getcwd()), os.getcwd()]:\n",
+    "    if os.path.isfile(os.path.join(_p, 'or_kern.py')):\n",
+    "        sys.path.insert(0, _p); break\n",
+    "import multiprocessing as _mp\n",
+    "try: _mp.set_start_method('fork', force=True)\n",
+    "except (RuntimeError, ValueError): pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Die Engine\n",
+    "\n",
+    "`QuantitativeTradingEngine.py`\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -352,6 +386,15 @@
     "`Backtest_Fallen.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Die fünf Selbsttäuschungen des Backtestens\n",
+    "\n",
+    "`Backtest_Fallen.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -465,6 +508,15 @@
     "`Data_Snooping.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Finde den Denkfehler\n",
+    "\n",
+    "`Data_Snooping.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,

Notebooks_04/lp.ipynb

@@ -12,7 +12,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "tags": [
+     "nbmake-skip"
+    ]
+   },
    "outputs": [],
    "source": [
     "# Einmalig ausfuehren: installiert alle im Buch verwendeten Pakete.\n",
@@ -21,6 +25,36 @@
     "    scikit-learn matplotlib plotly pyomo linopy pymoo pydantic openpyxl"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Notebook-spezifisches Setup: __file__ definieren (Programme nutzen es\n",
+    "# fuer OUTPUT_DIR), Programmverzeichnis in den Suchpfad aufnehmen (or_kern)\n",
+    "# und multiprocessing auf 'fork' stellen (Spawn findet Kernel-Funktionen nicht).\n",
+    "import os, sys\n",
+    "__file__ = os.path.join(os.getcwd(), '_notebook.py')\n",
+    "for _p in [os.path.join(os.path.dirname(os.getcwd()),\n",
+    "                       'Operations_Research_mit_Python_Version_04_Programme'),\n",
+    "            os.path.dirname(os.getcwd()), os.getcwd()]:\n",
+    "    if os.path.isfile(os.path.join(_p, 'or_kern.py')):\n",
+    "        sys.path.insert(0, _p); break\n",
+    "import multiprocessing as _mp\n",
+    "try: _mp.set_start_method('fork', force=True)\n",
+    "except (RuntimeError, ValueError): pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Das Simplex-Tableau in Python\n",
+    "\n",
+    "`Simplex_Tableau_LP.py`\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -207,6 +241,15 @@
     "`Dualitaet_Nachweis.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Der starke Dualitätssatz\n",
+    "\n",
+    "`Dualitaet_Nachweis.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -302,6 +345,15 @@
     "`Sensitivitaetsanalyse.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Praxisfall: Sensitivitätsanalyse mit korrekten Schattenpreisen\n",
+    "\n",
+    "`Sensitivitaetsanalyse.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -429,6 +481,15 @@
     "`Toleranzen_und_Entartung.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Die ehrliche Auskunft: Schattenpreis-Spannen\n",
+    "\n",
+    "`Toleranzen_und_Entartung.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,

Notebooks_04/markowitz.ipynb

@@ -12,7 +12,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "tags": [
+     "nbmake-skip"
+    ]
+   },
    "outputs": [],
    "source": [
     "# Einmalig ausfuehren: installiert alle im Buch verwendeten Pakete.\n",
@@ -21,6 +25,36 @@
     "    scikit-learn matplotlib plotly pyomo linopy pymoo pydantic openpyxl"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Notebook-spezifisches Setup: __file__ definieren (Programme nutzen es\n",
+    "# fuer OUTPUT_DIR), Programmverzeichnis in den Suchpfad aufnehmen (or_kern)\n",
+    "# und multiprocessing auf 'fork' stellen (Spawn findet Kernel-Funktionen nicht).\n",
+    "import os, sys\n",
+    "__file__ = os.path.join(os.getcwd(), '_notebook.py')\n",
+    "for _p in [os.path.join(os.path.dirname(os.getcwd()),\n",
+    "                       'Operations_Research_mit_Python_Version_04_Programme'),\n",
+    "            os.path.dirname(os.getcwd()), os.getcwd()]:\n",
+    "    if os.path.isfile(os.path.join(_p, 'or_kern.py')):\n",
+    "        sys.path.insert(0, _p); break\n",
+    "import multiprocessing as _mp\n",
+    "try: _mp.set_start_method('fork', force=True)\n",
+    "except (RuntimeError, ValueError): pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Warum Diversifikation funktioniert\n",
+    "\n",
+    "`Diversifikation_Demo.py`\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -94,6 +128,15 @@
     "`Markowitz_CVXPY.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Vollimplementierung mit CVXPY\n",
+    "\n",
+    "`Markowitz_CVXPY.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -374,6 +417,15 @@
     "`Renditeschaetzung_Falle.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Finde den Denkfehler\n",
+    "\n",
+    "`Renditeschaetzung_Falle.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,

Notebooks_04/mehrziel.ipynb

@@ -12,7 +12,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "tags": [
+     "nbmake-skip"
+    ]
+   },
    "outputs": [],
    "source": [
     "# Einmalig ausfuehren: installiert alle im Buch verwendeten Pakete.\n",
@@ -21,6 +25,36 @@
     "    scikit-learn matplotlib plotly pyomo linopy pymoo pydantic openpyxl"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Notebook-spezifisches Setup: __file__ definieren (Programme nutzen es\n",
+    "# fuer OUTPUT_DIR), Programmverzeichnis in den Suchpfad aufnehmen (or_kern)\n",
+    "# und multiprocessing auf 'fork' stellen (Spawn findet Kernel-Funktionen nicht).\n",
+    "import os, sys\n",
+    "__file__ = os.path.join(os.getcwd(), '_notebook.py')\n",
+    "for _p in [os.path.join(os.path.dirname(os.getcwd()),\n",
+    "                       'Operations_Research_mit_Python_Version_04_Programme'),\n",
+    "            os.path.dirname(os.getcwd()), os.getcwd()]:\n",
+    "    if os.path.isfile(os.path.join(_p, 'or_kern.py')):\n",
+    "        sys.path.insert(0, _p); break\n",
+    "import multiprocessing as _mp\n",
+    "try: _mp.set_start_method('fork', force=True)\n",
+    "except (RuntimeError, ValueError): pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Das Programm\n",
+    "\n",
+    "`Mehrziel_Pareto.py`\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},

Notebooks_04/metaheuristiken.ipynb

@@ -12,7 +12,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "tags": [
+     "nbmake-skip"
+    ]
+   },
    "outputs": [],
    "source": [
     "# Einmalig ausfuehren: installiert alle im Buch verwendeten Pakete.\n",
@@ -21,6 +25,36 @@
     "    scikit-learn matplotlib plotly pyomo linopy pymoo pydantic openpyxl"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Notebook-spezifisches Setup: __file__ definieren (Programme nutzen es\n",
+    "# fuer OUTPUT_DIR), Programmverzeichnis in den Suchpfad aufnehmen (or_kern)\n",
+    "# und multiprocessing auf 'fork' stellen (Spawn findet Kernel-Funktionen nicht).\n",
+    "import os, sys\n",
+    "__file__ = os.path.join(os.getcwd(), '_notebook.py')\n",
+    "for _p in [os.path.join(os.path.dirname(os.getcwd()),\n",
+    "                       'Operations_Research_mit_Python_Version_04_Programme'),\n",
+    "            os.path.dirname(os.getcwd()), os.getcwd()]:\n",
+    "    if os.path.isfile(os.path.join(_p, 'or_kern.py')):\n",
+    "        sys.path.insert(0, _p); break\n",
+    "import multiprocessing as _mp\n",
+    "try: _mp.set_start_method('fork', force=True)\n",
+    "except (RuntimeError, ValueError): pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Simulated Annealing\n",
+    "\n",
+    "`Simulated_Annealing.py`\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -346,6 +380,15 @@
     "`Metaheuristik_vs_Exakt.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Ab wann lohnt es sich?\n",
+    "\n",
+    "`Metaheuristik_vs_Exakt.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -595,6 +638,15 @@
     "`Large_Neighborhood_Search.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Large Neighborhood Search\n",
+    "\n",
+    "`Large_Neighborhood_Search.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,

Notebooks_04/milp.ipynb

@@ -12,7 +12,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "tags": [
+     "nbmake-skip"
+    ]
+   },
    "outputs": [],
    "source": [
     "# Einmalig ausfuehren: installiert alle im Buch verwendeten Pakete.\n",
@@ -21,6 +25,36 @@
     "    scikit-learn matplotlib plotly pyomo linopy pymoo pydantic openpyxl"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Notebook-spezifisches Setup: __file__ definieren (Programme nutzen es\n",
+    "# fuer OUTPUT_DIR), Programmverzeichnis in den Suchpfad aufnehmen (or_kern)\n",
+    "# und multiprocessing auf 'fork' stellen (Spawn findet Kernel-Funktionen nicht).\n",
+    "import os, sys\n",
+    "__file__ = os.path.join(os.getcwd(), '_notebook.py')\n",
+    "for _p in [os.path.join(os.path.dirname(os.getcwd()),\n",
+    "                       'Operations_Research_mit_Python_Version_04_Programme'),\n",
+    "            os.path.dirname(os.getcwd()), os.getcwd()]:\n",
+    "    if os.path.isfile(os.path.join(_p, 'or_kern.py')):\n",
+    "        sys.path.insert(0, _p); break\n",
+    "import multiprocessing as _mp\n",
+    "try: _mp.set_start_method('fork', force=True)\n",
+    "except (RuntimeError, ValueError): pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Warum Runden fundamental scheitert\n",
+    "\n",
+    "`Runden_Gegenbeispiel.py`\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -138,6 +172,15 @@
     "`Rucksack.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Beispiel: Das Rucksackproblem{idx:Rucksackproblem}\n",
+    "\n",
+    "`Rucksack.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -213,6 +256,15 @@
     "`MILP_Portfolio_Fixgebuehren.py`\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Praxisfall: Portfolio mit Ordergebühren und Kardinalitätsgrenze\n",
+    "\n",
+    "`MILP_Portfolio_Fixgebuehren.py`\n"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
@@ -434,11 +486,14 @@
    ]
   },
   {
-   "cell_type": "code",
+   "cell_type": "markdown",
-   "execution_count": null,
    "metadata": {},
-   "outputs": [],
    "source": [
+    "## Alle Statusfälle behandeln\n",
+    "\n",
+    "`Solverstatus_und_Gap.py`\n",
+    "\n",
+    "```python\n",
     "#!/usr/bin/env python3\n",
     "\n",
     "# Solverstatus_und_Gap.py\n",
@@ -654,7 +709,36 @@
     "    print(\"    Warmstart_Effekt.py - dort halbiert ein Heuristik-Hinweis die Zeit).\")\n",
     "    print(\"  * Sie planen laufend neu und der gestrige Plan ist fast noch gueltig.\")\n",
     "    print(\"In beiden Faellen gilt: MESSEN, nicht glauben.\")\n",
-    "    print(\"=\" * 78)"
+    "    print(\"=\" * 78)\n",
+    "```\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# In einem Notebook kann 'Solverstatus_und_Gap.py' nicht direkt ausgefuehrt werden\n",
+    "# (ortools/highspy-Konflikt im selben Kernel, pytest oder multiprocessing).\n",
+    "# Deshalb als Subprocess — so laeuft es genauso wie im Terminal.\n",
+    "import subprocess, sys, os\n",
+    "# NO_COLOR/TERM=dumb verhindern ANSI-Codes in der Ausgabe (pytest\n",
+    "# im Jupyter-Kernel wuerde sonst farbige Escape-Sequenzen ausgeben).\n",
+    "_env = dict(os.environ, NO_COLOR='1', TERM='dumb')\n",
+    "for _d in [os.path.join(os.path.dirname(os.getcwd()),\n",
+    "                     'Operations_Research_mit_Python_Version_04_Programme'),\n",
+    "             os.path.dirname(os.getcwd()), os.getcwd()]:\n",
+    "    _p = os.path.join(_d, 'Solverstatus_und_Gap.py')\n",
+    "    if os.path.isfile(_p):\n",
+    "        _r = subprocess.run([sys.executable, _p], cwd=_d, env=_env,\n",
+    "                            capture_output=True, text=True)\n",
+    "        if _r.stdout: print(_r.stdout)\n",
+    "        if _r.stderr: print(_r.stderr)\n",
+    "        _r.check_returncode()\n",
+    "        break\n",
+    "else:\n",
+    "    print('Solverstatus_und_Gap.py nicht gefunden')"
    ]
   },
   {
@@ -667,11 +751,14 @@
    ]
   },
   {
-   "cell_type": "code",
+   "cell_type": "markdown",
-   "execution_count": null,
    "metadata": {},
-   "outputs": [],
    "source": [
+    "## Warm-Starts: was sie können und was nicht\n",
+    "\n",
+    "`Warmstart_Effekt.py`\n",
+    "\n",
+    "```python\n",
     "#!/usr/bin/env python3\n",
     "\n",
     "# Warmstart_Effekt.py\n",
@@ -819,7 +906,36 @@
     "    print(\"   davon ab, wie schnell der Solver von allein eine vergleichbar gute\")\n",
     "    print(\"   Loesung findet. Das ist die eigentliche Lehre: Ein Warm-Start ist\")\n",
     "    print(\"   eine Messung wert, keine Glaubensfrage.\")\n",
-    "    print(\"=\" * 78)"
+    "    print(\"=\" * 78)\n",
+    "```\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# In einem Notebook kann 'Warmstart_Effekt.py' nicht direkt ausgefuehrt werden\n",
+    "# (ortools/highspy-Konflikt im selben Kernel, pytest oder multiprocessing).\n",
+    "# Deshalb als Subprocess — so laeuft es genauso wie im Terminal.\n",
+    "import subprocess, sys, os\n",
+    "# NO_COLOR/TERM=dumb verhindern ANSI-Codes in der Ausgabe (pytest\n",
+    "# im Jupyter-Kernel wuerde sonst farbige Escape-Sequenzen ausgeben).\n",
+    "_env = dict(os.environ, NO_COLOR='1', TERM='dumb')\n",
+    "for _d in [os.path.join(os.path.dirname(os.getcwd()),\n",
+    "                     'Operations_Research_mit_Python_Version_04_Programme'),\n",
+    "             os.path.dirname(os.getcwd()), os.getcwd()]:\n",
+    "    _p = os.path.join(_d, 'Warmstart_Effekt.py')\n",
+    "    if os.path.isfile(_p):\n",
+    "        _r = subprocess.run([sys.executable, _p], cwd=_d, env=_env,\n",
+    "                            capture_output=True, text=True)\n",
+    "        if _r.stdout: print(_r.stdout)\n",
+    "        if _r.stderr: print(_r.stderr)\n",
+    "        _r.check_returncode()\n",
+    "        break\n",
+    "else:\n",
+    "    print('Warmstart_Effekt.py nicht gefunden')"
    ]
   },
   {
@@ -832,11 +948,14 @@
    ]
   },
   {
-   "cell_type": "code",
+   "cell_type": "markdown",
-   "execution_count": null,
    "metadata": {},
-   "outputs": [],
    "source": [
+    "## Finde den Denkfehler\n",
+    "\n",
+    "`Big_M_Falle.py`\n",
+    "\n",
+    "```python\n",
     "#!/usr/bin/env python3\n",
     "\n",
     "# Big_M_Falle.py\n",
@@ -1030,7 +1149,36 @@
     "    print(\"nicht darauf: Presolve kann das nur, wenn eine implizite Schranke\")\n",
     "    print(\"herleitbar ist. Die Pruefung aus pruefe() kostet Millisekunden und\")\n",
     "    print(\"funktioniert immer.\")\n",
-    "    print(\"=\" * 78)"
+    "    print(\"=\" * 78)\n",
+    "```\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# In einem Notebook kann 'Big_M_Falle.py' nicht direkt ausgefuehrt werden\n",
+    "# (ortools/highspy-Konflikt im selben Kernel, pytest oder multiprocessing).\n",
+    "# Deshalb als Subprocess — so laeuft es genauso wie im Terminal.\n",
+    "import subprocess, sys, os\n",
+    "# NO_COLOR/TERM=dumb verhindern ANSI-Codes in der Ausgabe (pytest\n",
+    "# im Jupyter-Kernel wuerde sonst farbige Escape-Sequenzen ausgeben).\n",
+    "_env = dict(os.environ, NO_COLOR='1', TERM='dumb')\n",
+    "for _d in [os.path.join(os.path.dirname(os.getcwd()),\n",
+    "                     'Operations_Research_mit_Python_Version_04_Programme'),\n",
+    "             os.path.dirname(os.getcwd()), os.getcwd()]:\n",
+    "    _p = os.path.join(_d, 'Big_M_Falle.py')\n",
+    "    if os.path.isfile(_p):\n",
+    "        _r = subprocess.run([sys.executable, _p], cwd=_d, env=_env,\n",
+    "                            capture_output=True, text=True)\n",
+    "        if _r.stdout: print(_r.stdout)\n",
+    "        if _r.stderr: print(_r.stderr)\n",
+    "        _r.check_returncode()\n",
+    "        break\n",
+    "else:\n",
+    "    print('Big_M_Falle.py nicht gefunden')"
    ]
   }
  ],

Notebooks_04/modellierung.ipynb

@@ -12,7 +12,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "tags": [
+     "nbmake-skip"
+    ]
+   },
    "outputs": [],
    "source": [
     "# Einmalig ausfuehren: installiert alle im Buch verwendeten Pakete.\n",
@@ -21,6 +25,36 @@
     "    scikit-learn matplotlib plotly pyomo linopy pymoo pydantic openpyxl"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Notebook-spezifisches Setup: __file__ definieren (Programme nutzen es\n",
+    "# fuer OUTPUT_DIR), Programmverzeichnis in den Suchpfad aufnehmen (or_kern)\n",
+    "# und multiprocessing auf 'fork' stellen (Spawn findet Kernel-Funktionen nicht).\n",
+    "import os, sys\n",
+    "__file__ = os.path.join(os.getcwd(), '_notebook.py')\n",
+    "for _p in [os.path.join(os.path.dirname(os.getcwd()),\n",
+    "                       'Operations_Research_mit_Python_Version_04_Programme'),\n",
+    "            os.path.dirname(os.getcwd()), os.getcwd()]:\n",
+    "    if os.path.isfile(os.path.join(_p, 'or_kern.py')):\n",
+    "        sys.path.insert(0, _p); break\n",
+    "import multiprocessing as _mp\n",
+    "try: _mp.set_start_method('fork', force=True)\n",
+    "except (RuntimeError, ValueError): pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Derselbe Datensatz, fünf Modelle\n",
+    "\n",
+    "`Vom_Wunsch_zum_Modell.py`\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},

Notebooks_04/oekosystem.ipynb

@@ -12,7 +12,11 @@
   {
    "cell_type": "code",
    "execution_count": null,
-   "metadata": {},
+   "metadata": {
+    "tags": [
+     "nbmake-skip"
+    ]
+   },
    "outputs": [],
    "source": [
     "# Einmalig ausfuehren: installiert alle im Buch verwendeten Pakete.\n",
@@ -21,6 +25,36 @@
     "    scikit-learn matplotlib plotly pyomo linopy pymoo pydantic openpyxl"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Notebook-spezifisches Setup: __file__ definieren (Programme nutzen es\n",
+    "# fuer OUTPUT_DIR), Programmverzeichnis in den Suchpfad aufnehmen (or_kern)\n",
+    "# und multiprocessing auf 'fork' stellen (Spawn findet Kernel-Funktionen nicht).\n",
+    "import os, sys\n",
+    "__file__ = os.path.join(os.getcwd(), '_notebook.py')\n",
+    "for _p in [os.path.join(os.path.dirname(os.getcwd()),\n",
+    "                       'Operations_Research_mit_Python_Version_04_Programme'),\n",
+    "            os.path.dirname(os.getcwd()), os.getcwd()]:\n",
+    "    if os.path.isfile(os.path.join(_p, 'or_kern.py')):\n",
+    "        sys.path.insert(0, _p); break\n",
+    "import multiprocessing as _mp\n",
+    "try: _mp.set_start_method('fork', force=True)\n",
+    "except (RuntimeError, ValueError): pass"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Die Entscheidung in drei Fragen\n",
+    "\n",
+    "`Solver_Wahl.py`\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -121,11 +155,14 @@
    ]
   },
   {
-   "cell_type": "code",
+   "cell_type": "markdown",
-   "execution_count": null,
    "metadata": {},
-   "outputs": [],
    "source": [
+    "## Wie die Isolation aussieht, wenn sie tragen soll\n",
+    "\n",
+    "`Ein_System_Vier_Ansaetze.py`\n",
+    "\n",
+    "```python\n",
     "#!/usr/bin/env python3\n",
     "\n",
     "# Ein_System_Vier_Ansaetze.py\n",
@@ -270,7 +307,45 @@
     "    print(\"Alle Wege fuehren zum selben, von Hand bestaetigten Optimum.\")\n",
     "    print(\"(Die Zeiten enthalten Prozessstart und Import - sie messen NICHT die\")\n",
     "    print(\" reine Solverleistung. Die Uebungsaufgabe 'Laufzeitvergleich' trennt beides.)\")\n",
-    "    print(\"=\" * 78)"
+    "    print(\"=\" * 78)\n",
+    "```\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# In einem Notebook kann 'Ein_System_Vier_Ansaetze.py' nicht direkt ausgefuehrt werden\n",
+    "# (ortools/highspy-Konflikt im selben Kernel, pytest oder multiprocessing).\n",
+    "# Deshalb als Subprocess — so laeuft es genauso wie im Terminal.\n",
+    "import subprocess, sys, os\n",
+    "# NO_COLOR/TERM=dumb verhindern ANSI-Codes in der Ausgabe (pytest\n",
+    "# im Jupyter-Kernel wuerde sonst farbige Escape-Sequenzen ausgeben).\n",
+    "_env = dict(os.environ, NO_COLOR='1', TERM='dumb')\n",
+    "for _d in [os.path.join(os.path.dirname(os.getcwd()),\n",
+    "                     'Operations_Research_mit_Python_Version_04_Programme'),\n",
+    "             os.path.dirname(os.getcwd()), os.getcwd()]:\n",
+    "    _p = os.path.join(_d, 'Ein_System_Vier_Ansaetze.py')\n",
+    "    if os.path.isfile(_p):\n",
+    "        _r = subprocess.run([sys.executable, _p], cwd=_d, env=_env,\n",
+    "                            capture_output=True, text=True)\n",
+    "        if _r.stdout: print(_r.stdout)\n",
+    "        if _r.stderr: print(_r.stderr)\n",
+    "        _r.check_returncode()\n",
+    "        break\n",
+    "else:\n",
+    "    print('Ein_System_Vier_Ansaetze.py nicht gefunden')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Die Schichten im Überblick\n",
+    "\n",
+    "`Modellierungsschichten.py`\n"
    ]
   },
   {
@@ -470,11 +545,14 @@
    ]
   },
   {
-   "cell_type": "code",
+   "cell_type": "markdown",
-   "execution_count": null,
    "metadata": {},
-   "outputs": [],
    "source": [
+    "## Vier Stufen an einem Transportproblem\n",
+    "\n",
+    "`Vektorisierte_Modellgenerierung.py`\n",
+    "\n",
+    "```python\n",
     "#!/usr/bin/env python3\n",
     "\n",
     "# Vektorisierte_Modellgenerierung.py\n",
@@ -714,7 +792,36 @@
     "    print(\"   Schreibweise derselben Matrix - Schleife gegen Kronecker-Produkt.\")\n",
     "    print(\"\\nDie Lesbarkeit von Variante A ist trotzdem viel wert: Fangen Sie dort an,\")\n",
     "    print(\"und vektorisieren Sie erst, wenn die Messung es verlangt.\")\n",
-    "    print(\"=\" * 88)"
+    "    print(\"=\" * 88)\n",
+    "```\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# In einem Notebook kann 'Vektorisierte_Modellgenerierung.py' nicht direkt ausgefuehrt werden\n",
+    "# (ortools/highspy-Konflikt im selben Kernel, pytest oder multiprocessing).\n",
+    "# Deshalb als Subprocess — so laeuft es genauso wie im Terminal.\n",
+    "import subprocess, sys, os\n",
+    "# NO_COLOR/TERM=dumb verhindern ANSI-Codes in der Ausgabe (pytest\n",
+    "# im Jupyter-Kernel wuerde sonst farbige Escape-Sequenzen ausgeben).\n",
+    "_env = dict(os.environ, NO_COLOR='1', TERM='dumb')\n",
+    "for _d in [os.path.join(os.path.dirname(os.getcwd()),\n",
+    "                     'Operations_Research_mit_Python_Version_04_Programme'),\n",
+    "             os.path.dirname(os.getcwd()), os.getcwd()]:\n",
+    "    _p = os.path.join(_d, 'Vektorisierte_Modellgenerierung.py')\n",
+    "    if os.path.isfile(_p):\n",
+    "        _r = subprocess.run([sys.executable, _p], cwd=_d, env=_env,\n",
+    "                            capture_output=True, text=True)\n",
+    "        if _r.stdout: print(_r.stdout)\n",
+    "        if _r.stderr: print(_r.stderr)\n",
+    "        _r.check_returncode()\n",
+    "        break\n",
+    "else:\n",
+    "    print('Vektorisierte_Modellgenerierung.py nicht gefunden')"
    ]
   }
  ],