feat: Szenario ohne Ergebnis nicht mehr zuverlässig; Schlupf aus dem Solver-Prompt

check_scenarios_solved meldet Szenarien ohne Zielwert, die nicht belegt unlösbar
sind (beobachtet: SCIP-Zeitlimit ohne Lösung als 'keine Lösung' gemeldet);
Befund löst Solver-Reparatur aus, bleibt er, reliable=False. Solver-Prompt:
timelimit ohne Lösung ist keine Unlösbarkeit, Warmstart über createSol/addSol.
Der Fachbegriff Schlupf kam aus dem Prompt selbst und ist entfernt.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

TextToModel.py

@@ -186,6 +186,10 @@ def _solver_stage(session, task: str, result: PipelineResult, model: str,
         result.reliable = False
         result.reliability_issues += [f"Datenherkunft: {p}" for p in run.undeclared_data]
         log("ERGEBNIS UNZUVERLÄSSIG – selbst erzeugte Eingabedaten sind nicht ausgewiesen.")
+    if run.unsolved_scenarios:
+        result.reliable = False
+        result.reliability_issues += [f"Szenario ohne Ergebnis: {p}" for p in run.unsolved_scenarios]
+        log("ERGEBNIS UNZUVERLÄSSIG – mindestens ein Szenario hat kein Ergebnis und ist nicht als unlösbar belegt.")
     if result.solver_code.data_assumptions:
         log(f"  Mit angenommenen Daten gelöst ({len(result.solver_code.data_assumptions)} Annahmen).")
 

core/model_schema.py

@@ -257,6 +257,8 @@ class Scenario(BaseModel):
         default=None, description="Zielwert dieser Konfiguration, vom Programm berechnet")
     verified_value: Optional[float] = Field(
         default=None, description="Vom Runner durch erneutes Ausführen bestätigter Zielwert (ohne LLM)")
+    verified_status: Optional[str] = Field(
+        default=None, description="Status des Nachlaufs mit data_override (vom Runner gesetzt, ohne LLM)")
 
 
 class Multistart(BaseModel):
@@ -318,6 +320,8 @@ class SolverRun(BaseModel):
         default_factory=list, description="Befunde der deterministischen Zulässigkeitsprüfung; leer = Lösung hält alles ein")
     undeclared_data: List[str] = Field(
         default_factory=list, description="Selbst erzeugte, nicht ausgewiesene Eingabedaten; leer = alles ausgewiesen")
+    unsolved_scenarios: List[str] = Field(
+        default_factory=list, description="Szenarien ohne Ergebnis, die nicht als unlösbar belegt sind; leer = jedes hat eines")
     warnings: List[str] = Field(default_factory=list, description="Deterministische Prüfungen der Ergebnistabellen")
     error: Optional[str] = None
     attempts: int = 1

solving/Solver-Prompt.txt

@@ -26,7 +26,8 @@ API je target_stack:
 - SCIP (pyscipopt): `from pyscipopt import Model, quicksum`; `model = Model(); model.hideOutput(); model.setParam("limits/time", 30)`; Variablen `model.addVar(name, vtype="C"|"I"|"B", lb=..., ub=...)` (Achtung: Standard lb=0; für unbeschränkt `lb=None`); Restriktionen `model.addCons(ausdruck <= wert)` – auch quadratisch, z. B. `model.addCons(t * t >= quicksum(...))`.
   WICHTIG: SCIP akzeptiert KEINE nichtlineare Zielfunktion (`setObjective` mit quadratischem Ausdruck wirft ValueError). Verwende eine Hilfsvariable (Epigraph): bei Maximierung `z = model.addVar("z", lb=None, ub=None)`, `model.addCons(z <= quadratischer_ausdruck)`, `model.setObjective(z, "maximize")`; bei Minimierung `model.addCons(z >= quadratischer_ausdruck)`, `model.setObjective(z, "minimize")`.
   Standardabweichung/Volatilität: `t = model.addVar("t", lb=0)`, `model.addCons(t * t >= quicksum(Sigma[i][j] * w[i] * w[j] ...))`, `model.setObjective(t, "minimize")`.
-  Lösen `model.optimize()`; Status `model.getStatus()` ("optimal", "infeasible", "unbounded", "inforunbd", "timelimit" → bei vorhandener Lösung `model.getNSols() > 0` als "feasible" melden); Zielwert `model.getObjVal()`; Werte `model.getVal(var)`. Binärwerte mit `round()` ausgeben.
+  Lösen `model.optimize()`; Status `model.getStatus()` ("optimal", "infeasible", "unbounded", "inforunbd", "timelimit" → bei vorhandener Lösung `model.getNSols() > 0` als "feasible" melden; `timelimit` mit `getNSols() == 0` ist KEINE Unlösbarkeit – dann nie „keine Lösung" oder „unlösbar" schreiben); Zielwert `model.getObjVal()`; Werte `model.getVal(var)`. Binärwerte mit `round()` ausgeben.
+  Startlösung (Warmstart): `sol = model.createSol(); model.setSolVal(sol, var, wert)` für jede Variable, dann `model.addSol(sol)` vor `model.optimize()`.
 - NetworkX (Dijkstra): `import networkx as nx`; `G = nx.DiGraph()`; Bögen mit `G.add_edge(i, j, weight=c)`; `laenge, pfad = nx.single_source_dijkstra(G, quelle, ziel, weight="weight")` liefert Weglänge und Knotenfolge; alle endgültigen Marken in der Reihenfolge ihrer Vergabe: `marken = nx.single_source_dijkstra_path_length(G, quelle, weight="weight")` (das Wörterbuch ist in genau dieser Reihenfolge gefüllt). Ist das Ziel nicht erreichbar, wirft `single_source_dijkstra` `nx.NetworkXNoPath` – dann Status "infeasible" melden.
   WICHTIG: Bei negativen Bogengewichten wirft networkx KEINEN Fehler, liefert aber ein falsches Ergebnis (geprüft: 3 statt 2). Prüfe die Gewichte im Programm und melde Status "error" mit einem Hinweis, falls eines negativ ist.
   Melde den Graphen im Argument graph (siehe unten) – ohne ihn kann der Report die verlangte Zeichnung nicht erzeugen. Die Restriktionen der Spezifikation (Flusserhaltung) sind trotzdem in constraints auszuweisen, ausgewertet am gefundenen Weg.
@@ -74,7 +75,7 @@ Ergebnisausgabe:
   - variables: Liste aller Entscheidungsvariablen mit Wert, Typ und Schranken:
       {"name": "...", "value": <Zahl>, "var_type": "continuous" | "integer" | "binary", "lb": <Zahl oder null>, "ub": <Zahl oder null>}
     Die Pipeline prüft damit Schranken und Ganzzahligkeit. Höchstens 200 Einträge; bei mehr nur die Variablen ungleich 0.
-  - sensitivity: Wirkung der bindenden Restriktionen, durch NEULÖSEN ermittelt (nicht aus Solver-Attributen ablesen). Für höchstens 8 bindende Restriktionen (Schlupf = 0), am besten die inhaltlich wichtigsten:
+  - sensitivity: Wirkung der bindenden Restriktionen, durch NEULÖSEN ermittelt (nicht aus Solver-Attributen ablesen). Für höchstens 8 bindende Restriktionen (linke Seite erreicht die Grenze genau), am besten die inhaltlich wichtigsten:
       {"name": "<wie in constraints>", "delta": <Verschiebung > 0>, "objective_plus": <Zielwert mit rhs+delta oder null>, "objective_minus": <Zielwert mit rhs-delta oder null>, "unit": "€ je Einheit"}
     - delta klein wählen (etwa 1 % der rechten Seite, mindestens eine sinnvolle Einheit), das Modell je Richtung einmal neu lösen und den Zielwert eintragen; bei unlösbar null.
     - Nur ausführen, wenn das Neulösen schnell geht (Gesamtlaufzeit unter 60 s), sonst leere Liste.
@@ -93,6 +94,7 @@ Ergebnisausgabe:
     - data_override enthält genau die Einträge von DATA, die sich ändern. Das Programm rechnet jedes Szenario selbst und trägt seinen objective_value ein.
     - Die Pipeline führt dein Programm anschließend mit jedem data_override ERNEUT aus und vergleicht – abweichende Werte fallen auf. Kein LLM ist daran beteiligt. [→ verify_scenarios]
     - Damit das funktioniert, muss das Programm ausschließlich aus DATA lesen; höchstens fünf Szenarien werden nachgerechnet.
+    - Jedes Szenario braucht einen objective_value – null nur, wenn es bewiesen unlösbar ist. Unterscheiden sich Szenarien nur in Zielgewichten, ist die Lösung eines Szenarios für die anderen zulässig: übergib sie als Startlösung, dann endet keines im Zeitlimit ohne Ergebnis. Zeitlimits so wählen, dass alle Läufe zusammen unter 60 s bleiben. [→ check_scenarios_solved]
   - graph: NUR bei Graphenproblemen (Stack NetworkX), sonst null. Grundlage für die Zeichnung im Report:
       {"nodes": ["0", "1", "2", "3"],
        "arcs": [{"source": "0", "target": "1", "weight": 8}, ...],
@@ -121,7 +123,7 @@ Ergebnisausgabe:
   Erzeuge nach Möglichkeit diese drei Tabellen (in dieser Reihenfolge):
     1. Die Objekttabelle wie oben beschrieben.
     2. "Zielwert-Zerlegung": Zeilen für die Bestandteile der Zielfunktion (z. B. "Erwartete Rendite", "Risiko (λ·Varianz)", "Transaktionskosten") mit Spalten ["Bestandteil", "Wert", "Einheit"], Vorzeichen wie in der Zielfunktion (Abzüge negativ), objective_column "Wert", danach die Summenzeile "Zielwert". Alle Bestandteile müssen dieselbe Einheit haben; steht dort Unterschiedliches (z. B. "€" neben "dimensionslos"), ist das Modell fehlerhaft.
-    3. "Bindende Restriktionen": welche Grenzen die Lösung ausreizt, mit Spalten ["Restriktion", "Wert", "Grenze", "bindend"] und Werten aus der Lösung (z. B. "Höchstgewicht A02" | "30,00 %" | "30,00 %" | "ja"). Nur Tatsachen aus der Lösung, keine Bewertung; ohne objective_column.
+    3. "Bindende Restriktionen": welche Grenzen die Lösung ausreizt, mit Spalten ["Restriktion", "Wert", "Grenze", "bindend"] und Werten aus der Lösung (z. B. "Höchstgewicht A02" | "30,00 %" | "30,00 %" | "ja"). Nur Tatsachen aus der Lösung, keine Bewertung; ohne objective_column. Die note erklärt „bindend" in Alltagssprache („die Lösung schöpft diese Grenze voll aus") – ohne Fachbegriffe. [→ check_text_quality]
   Zahlen in der objective_column immer im Maßstab von objective_value (nicht in Prozent umrechnen); Datenspalten dagegen in lesbaren Einheiten als Text ("1,63 %", "0,74 %", "36 h").
 - Weitere print-Ausgaben sind erlaubt, aber nicht nötig.
 - Liefere im Feld code nur den reinen Python-Code ohne Markdown-Codeblock.

solving/solver_stage.py

@@ -707,6 +707,7 @@ def verify_scenarios(run, code: str, timeout: int = 60, data_files=()) -> list:
         nachlauf = run_solver_code(code, timeout=timeout, data={**(run.data or {}), **szenario.data_override},
                                    data_files=data_files)
         szenario.verified_value = nachlauf.objective_value
+        szenario.verified_status = nachlauf.status.value
         if nachlauf.status == SolverStatus.ERROR:
             grund = (nachlauf.error or "").strip()[:120] or (
                 "das Programm meldete selbst Status 'error' ohne Fehlertext (z. B. keine Lösung im Zeitlimit)")
@@ -719,6 +720,29 @@ def verify_scenarios(run, code: str, timeout: int = 60, data_files=()) -> list:
     return warnings
 
 
+def check_scenarios_solved(run) -> list:
+    """Hat jedes nachgerechnete Szenario ein Ergebnis – oder ist es belegt unlösbar?
+
+    Beobachtet an Portfolio Nr. 2: „Ausgewogene Skalarisierung" ohne Zielwert, Teil 2b antwortete
+    „keine Lösung", das Ergebnis galt trotzdem als zuverlässig. Nachgestellt ohne LLM: SCIP meldete
+    nach 8 s `timelimit` mit 0 Lösungen, nach 30 s mit einer – bei derselben zulässigen Menge wie die
+    beiden gelösten Konfigurationen. Ein abgelaufenes Zeitlimit ist keine Unlösbarkeit.
+    """
+    befunde = []
+    for szenario in run.scenarios[:MAX_SCENARIOS]:
+        if not szenario.data_override or szenario.objective_value is not None:
+            continue
+        if szenario.verified_status in (SolverStatus.INFEASIBLE.value, SolverStatus.UNBOUNDED.value):
+            continue
+        befunde.append(
+            f"Szenario '{szenario.name}' hat keinen Zielwert, ist aber nicht als unlösbar belegt (Nachlauf: "
+            f"{szenario.verified_status or 'nicht ausgeführt'}) – vermutlich ein Zeitlimit ohne Lösung. "
+            f"„Keine Lösung\" nur bei bewiesener Unlösbarkeit. Haben die Szenarien dieselben Restriktionen, die "
+            f"Lösung eines anderen Szenarios als Startlösung übergeben; Zeitlimits so wählen, dass alle Läufe "
+            f"zusammen unter 60 s bleiben.")
+    return befunde
+
+
 # Zehnerpotenzen, mit denen Antworten Einheiten umrechnen: „9,00 Tsd. € (also 9000 €)", „%" statt Anteil
 SCALES = [10 ** k for k in range(-3, 4)]
 
@@ -939,6 +963,7 @@ def _check_and_run(code: str, timeout: int, spec: OptimizationModelSpecification
                                  understanding.model_dump_json() if understanding else ""))
     run.warnings += check_answers(run, understanding, task, data_summary)
     run.warnings += verify_scenarios(run, code, timeout, data_files)
+    run.unsolved_scenarios = check_scenarios_solved(run)
     return run
 
 
@@ -956,12 +981,14 @@ def solve(session: LLMSession, task: str, spec: OptimizationModelSpecification,
     run.undeclared_data = check_generated_data(solver_code.code, solver_code, spec)
     einheiten = check_answer_units(run, task, data_prompt)
     attempt = 1
-    while (run.status == SolverStatus.ERROR or run.feasibility or run.undeclared_data or einheiten) \
+    while (run.status == SolverStatus.ERROR or run.feasibility or run.undeclared_data or run.unsolved_scenarios
-            and attempt <= retries:
+           or einheiten) and attempt <= retries:
         fehler = run.error or (("Die Lösung hält das Modell nicht ein:\n- " + "\n- ".join(run.feasibility))
                                if run.feasibility else
                                ("Eingabedaten nicht ausgewiesen:\n- " + "\n- ".join(run.undeclared_data))
                                if run.undeclared_data else
+                               ("Szenario ohne Ergebnis:\n- " + "\n- ".join(run.unsolved_scenarios))
+                               if run.unsolved_scenarios else
                                ("Einheit in der Antwort erfunden:\n- " + "\n- ".join(einheiten)))
         log(f"Solver-Code fehlgeschlagen – Reparaturversuch {attempt}/{retries}: {fehler[:200]}")
         solver_code = generate_solver_code(session, task, spec, previous=solver_code, previous_error=fehler,

tests/test_pipeline.py

@@ -583,3 +583,25 @@ def test_rejected_result_cannot_be_continued_and_counts_as_failure(tmp_path, mon
     zeile = benchmark.run_case({"name": "gleichung", "task": "x! = 120", "expected": {}}, "fake", 1)
     assert zeile["solver_status"] == "abgelehnt" and zeile["task_ok"] is False
     benchmark.print_table([zeile])                   # die Ergebnistabelle verkraftet die Zeile
+
+
+def _mit_szenario(wert):
+    return STRUCTURED_CODE.replace(
+        "    )\n\n\nif __name__",
+        '        scenarios=[{"name": "Ausgewogen", "description": "-", "data_override": {"faktor": 2}, '
+        f'"objective_value": {wert}}}],\n    )\n\n\nif __name__')
+
+
+def test_scenario_without_result_is_repaired():
+    # beobachtet (Portfolio Nr. 2): Zeitlimit ohne Lösung wurde als „keine Lösung" gemeldet
+    session = FakeSession([GOOD], [OK], [SolverCode(code=_mit_szenario(None)), SolverCode(code=_mit_szenario(8.0))])
+    result = run_pipeline("Minimiere die Kosten.", session=session, max_revisions=0, max_restarts=0, solver_retries=1)
+    assert session.calls[SolverCode] == 2                    # der Befund hat eine Reparatur ausgelöst
+    assert result.reliable and result.solver_run.unsolved_scenarios == []
+
+
+def test_persistent_scenario_without_result_is_unreliable():
+    session = FakeSession([GOOD], [OK], [SolverCode(code=_mit_szenario(None))] * 2)
+    result = run_pipeline("Minimiere die Kosten.", session=session, max_revisions=0, max_restarts=0, solver_retries=1)
+    assert not result.reliable
+    assert any(p.startswith("Szenario ohne Ergebnis") for p in result.reliability_issues)

tests/test_solver_stage.py

@@ -765,3 +765,49 @@ def test_scenario_failing_without_error_text_gets_a_reason():
     run = run_solver_code(code)
     befunde = verify_scenarios(run, code)
     assert any("doppelter Preis" in b and "ohne Fehlertext" in b for b in befunde)
+
+
+def test_scip_warm_start_as_in_the_prompt():
+    # Solver-Prompt: Lösung eines Szenarios als Startlösung für das nächste (createSol/setSolVal/addSol)
+    code = (
+        "from pyscipopt import Model, quicksum\n"
+        "m = Model(); m.hideOutput(); m.setParam('limits/time', 5)\n"
+        "x = [m.addVar(f'x{i}', vtype='B') for i in range(3)]\n"
+        "m.addCons(quicksum(x) == 2)\n"
+        "m.setObjective(quicksum((i + 1) * x[i] for i in range(3)), 'maximize')\n"
+        "sol = m.createSol()\n"
+        "for v, wert in zip(x, [1, 1, 0]):\n"
+        "    m.setSolVal(sol, v, wert)\n"
+        "assert m.addSol(sol)\n"
+        "m.optimize()\n"
+        "report(m.getStatus(), m.getObjVal(), {})"
+    )
+    run = run_solver_code(code)
+    assert run.status == SolverStatus.OPTIMAL, run.error
+    assert run.objective_value == 5.0
+
+
+def test_verify_scenarios_records_the_status_of_the_rerun():
+    from solving.solver_stage import verify_scenarios
+    run = run_solver_code(SZENARIO_CODE)
+    verify_scenarios(run, SZENARIO_CODE)
+    assert [s.verified_status for s in run.scenarios] == ["optimal", "optimal"]
+
+
+@pytest.mark.parametrize("wert, status, befund", [
+    (None, "error", True),        # beobachtet: Zeitlimit ohne Lösung, als „keine Lösung" gemeldet
+    (None, None, True),           # gar nicht nachgerechnet
+    (None, "infeasible", False),  # belegt unlösbar – ehrlich
+    (None, "unbounded", False),
+    (12.5, "optimal", False),
+])
+def test_scenario_without_result_is_a_finding_unless_proven_unsolvable(wert, status, befund):
+    from core.model_schema import Scenario, SolverRun
+    from solving.solver_stage import check_scenarios_solved
+    run = SolverRun(status=SolverStatus.OPTIMAL, objective_value=1.0, scenarios=[
+        Scenario(name="Ausgewogene Skalarisierung", description="-", data_override={"lambda_1": 0.5},
+                 objective_value=wert, verified_status=status)])
+    befunde = check_scenarios_solved(run)
+    assert bool(befunde) == befund
+    if befund:
+        assert "Ausgewogene Skalarisierung" in befunde[0] and "Startlösung" in befunde[0]