solverpilot 0.1__py3-none-any.whl

solverpilot/backends/osqp_native.py

@@ -0,0 +1,297 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+import importlib.util
+from importlib.metadata import PackageNotFoundError, version
+
+import numpy as np
+from scipy import sparse
+
+from solverpilot.capabilities import BackendManifest, Capability, SupportLevel
+from solverpilot.problem import LinearProblem, QuadraticProblem
+from solverpilot.problem.quadratic import require_confirmed_convexity
+
+from .base import BackendSolveResult, BackendUnavailableError
+
+
+@dataclass(frozen=True, slots=True)
+class OSQPData:
+    P: sparse.csc_matrix
+    q: np.ndarray
+    A: sparse.csc_matrix
+    l: np.ndarray
+    u: np.ndarray
+
+
+def _osqp_data(problem: QuadraticProblem) -> OSQPData:
+    """Translate canonical QP data into OSQP's l <= A x <= u form.
+
+    Canonical variable bounds are appended as identity rows. P is reduced to its
+    upper triangle because OSQP's Python interface consumes only that triangle.
+    """
+
+    if not isinstance(problem, QuadraticProblem):
+        raise TypeError("OSQP native backend supports QuadraticProblem only")
+    n = problem.n_variables
+    P = sparse.triu(problem.P, format="csc")
+    base_A = problem.linear.A.tocsc()
+    identity = sparse.eye(n, format="csc")
+    A = sparse.vstack([base_A, identity], format="csc")
+    l = np.concatenate([problem.linear.constraint_lower, problem.linear.variable_lower])
+    u = np.concatenate([problem.linear.constraint_upper, problem.linear.variable_upper])
+    return OSQPData(
+        P=P,
+        q=np.asarray(problem.linear.c, dtype=np.float64),
+        A=A,
+        l=np.asarray(l, dtype=np.float64),
+        u=np.asarray(u, dtype=np.float64),
+    )
+
+
+def _osqp_status(status: str, has_solution: bool) -> str:
+    s = status.strip().lower()
+    if s == "solved":
+        return "optimal"
+    if s == "solved inaccurate":
+        return "converged_candidate"
+    if s == "primal infeasible":
+        return "infeasible"
+    if s == "primal infeasible inaccurate":
+        return "infeasible_candidate"
+    if s == "dual infeasible":
+        return "unbounded"
+    if s == "dual infeasible inaccurate":
+        return "unbounded_candidate"
+    if any(token in s for token in ("maximum iterations", "run time limit", "time limit")):
+        return "limit_feasible" if has_solution else "limit_no_solution"
+    if "non convex" in s or "error" in s:
+        return "solver_error"
+    return "unknown"
+
+
+def _primal_certificate_check(data: OSQPData, certificate: np.ndarray | None, *, eps: float) -> dict[str, object]:
+    if certificate is None:
+        return {"valid": False, "reason": "missing_certificate"}
+    v = np.asarray(certificate, dtype=np.float64)
+    if v.shape != (data.A.shape[0],) or not np.all(np.isfinite(v)):
+        return {"valid": False, "reason": "invalid_shape_or_nonfinite"}
+    atv = np.asarray(data.A.T @ v).reshape(-1)
+    stationarity_inf = float(np.max(np.abs(atv), initial=0.0))
+    pos = v > 0.0
+    neg = v < 0.0
+    if np.any(pos & np.isposinf(data.u)) or np.any(neg & np.isneginf(data.l)):
+        separating_value = float("inf")
+    else:
+        separating_value = float(np.dot(data.u[pos], v[pos]) + np.dot(data.l[neg], v[neg]))
+    valid = stationarity_inf <= eps and np.isfinite(separating_value) and separating_value < 0.0
+    return {
+        "valid": bool(valid),
+        "stationarity_inf": stationarity_inf,
+        "separating_value": separating_value,
+        "eps": float(eps),
+    }
+
+
+def _dual_certificate_check(problem: QuadraticProblem, data: OSQPData, certificate: np.ndarray | None, *, eps: float) -> dict[str, object]:
+    if certificate is None:
+        return {"valid": False, "reason": "missing_certificate"}
+    s = np.asarray(certificate, dtype=np.float64)
+    if s.shape != (problem.n_variables,) or not np.all(np.isfinite(s)):
+        return {"valid": False, "reason": "invalid_shape_or_nonfinite"}
+    ps = np.asarray(problem.P @ s).reshape(-1)
+    ps_inf = float(np.max(np.abs(ps), initial=0.0))
+    q_dot_s = float(problem.linear.c @ s)
+    a_s = np.asarray(data.A @ s).reshape(-1)
+    finite_l = np.isfinite(data.l)
+    finite_u = np.isfinite(data.u)
+    both = finite_l & finite_u
+    lower_only = finite_l & ~finite_u
+    upper_only = ~finite_l & finite_u
+    row_violation = 0.0
+    if np.any(both):
+        row_violation = max(row_violation, float(np.max(np.abs(a_s[both]), initial=0.0)))
+    if np.any(lower_only):
+        row_violation = max(row_violation, float(np.max(np.maximum(-a_s[lower_only], 0.0), initial=0.0)))
+    if np.any(upper_only):
+        row_violation = max(row_violation, float(np.max(np.maximum(a_s[upper_only], 0.0), initial=0.0)))
+    valid = ps_inf <= eps and q_dot_s < 0.0 and row_violation <= eps
+    return {
+        "valid": bool(valid),
+        "ps_inf": ps_inf,
+        "q_dot_s": q_dot_s,
+        "row_sign_violation": row_violation,
+        "eps": float(eps),
+    }
+
+
+@dataclass(slots=True)
+class OSQPNativeBackend:
+    """Optional native OSQP adapter with same-sparsity state reuse.
+
+    The adapter is import-safe when OSQP is absent. When the same backend object is
+    reused for a QP whose structural hash is unchanged, it calls OSQP's documented
+    ``update`` API and relies on OSQP's automatic primal/dual warm start.
+    """
+
+    time_limit_s: float | None = None
+    max_iter: int | None = None
+    eps_abs: float | None = None
+    eps_rel: float | None = None
+    eps_prim_inf: float = 1e-4
+    eps_dual_inf: float = 1e-4
+    polishing: bool = False
+    _solver: object | None = field(default=None, init=False, repr=False)
+    _structural_hash: str | None = field(default=None, init=False, repr=False)
+
+    @property
+    def manifest(self) -> BackendManifest:
+        pkg_version = None
+        if self.is_available():
+            try:
+                pkg_version = version("osqp")
+            except PackageNotFoundError:
+                pass
+        return BackendManifest(
+            name="osqp-native",
+            version=pkg_version,
+            capabilities={
+                Capability.LP: SupportLevel.UNSUPPORTED,
+                Capability.CONVEX_QP: SupportLevel.NATIVE,
+                Capability.MILP: SupportLevel.UNSUPPORTED,
+                Capability.MIP_START: SupportLevel.UNSUPPORTED,
+                Capability.PRIMAL_START: SupportLevel.NATIVE,
+                Capability.DUAL_START: SupportLevel.NATIVE,
+                Capability.BASIS_START: SupportLevel.UNSUPPORTED,
+                Capability.SAME_SPARSITY_DATA_UPDATE: SupportLevel.NATIVE,
+                Capability.STRUCTURAL_INCREMENTAL_UPDATE: SupportLevel.UNSUPPORTED,
+                Capability.NATIVE_REOPTIMIZATION: SupportLevel.UNSUPPORTED,
+                Capability.CALLBACK_PROGRESS: SupportLevel.UNSUPPORTED,
+                Capability.IIS: SupportLevel.UNSUPPORTED,
+                Capability.INFEASIBILITY_CERTIFICATE: SupportLevel.NATIVE,
+            },
+            metadata={
+                "native_adapter": True,
+                "stateful": True,
+                "reuse_semantics": "same sparsity update + OSQP automatic warm start",
+            },
+        )
+
+    def is_available(self) -> bool:
+        return importlib.util.find_spec("osqp") is not None
+
+    def _settings(self) -> dict[str, object]:
+        settings: dict[str, object] = {
+            "verbose": False,
+            "warm_starting": True,
+            "polishing": bool(self.polishing),
+        }
+        if self.time_limit_s is not None:
+            if self.time_limit_s <= 0:
+                raise ValueError("time_limit_s must be positive")
+            settings["time_limit"] = float(self.time_limit_s)
+        if self.max_iter is not None:
+            if self.max_iter <= 0:
+                raise ValueError("max_iter must be positive")
+            settings["max_iter"] = int(self.max_iter)
+        if self.eps_abs is not None:
+            if self.eps_abs <= 0:
+                raise ValueError("eps_abs must be positive")
+            settings["eps_abs"] = float(self.eps_abs)
+        if self.eps_rel is not None:
+            if self.eps_rel <= 0:
+                raise ValueError("eps_rel must be positive")
+            settings["eps_rel"] = float(self.eps_rel)
+        if self.eps_prim_inf <= 0 or self.eps_dual_inf <= 0:
+            raise ValueError("OSQP infeasibility tolerances must be positive")
+        settings["eps_prim_inf"] = float(self.eps_prim_inf)
+        settings["eps_dual_inf"] = float(self.eps_dual_inf)
+        return settings
+
+    def solve(self, problem: LinearProblem | QuadraticProblem) -> BackendSolveResult:
+        if not self.is_available():
+            raise BackendUnavailableError("OSQP is not installed")
+        if not isinstance(problem, QuadraticProblem):
+            raise ValueError("osqp-native supports convex continuous QP only")
+
+        import osqp
+
+        data = _osqp_data(problem)
+        reuse_applied = self._solver is not None and self._structural_hash == problem.structural_hash
+        if not reuse_applied:
+            solver = osqp.OSQP()
+            solver.setup(P=data.P, q=data.q, A=data.A, l=data.l, u=data.u, **self._settings())
+            self._solver = solver
+            self._structural_hash = problem.structural_hash
+            reuse_mode = "cold_setup"
+        else:
+            # OSQP documents vector updates and P/A value updates with unchanged sparsity.
+            # Supplying all numerical values avoids guessing which mutation occurred.
+            self._solver.update(q=data.q, l=data.l, u=data.u, Px=data.P.data, Ax=data.A.data)
+            # Mutable settings may be changed without setup; keep configured values aligned.
+            update_settings = {
+                k: v
+                for k, v in self._settings().items()
+                if k in {"verbose", "warm_starting", "polishing", "time_limit", "max_iter", "eps_abs", "eps_rel", "eps_prim_inf", "eps_dual_inf"}
+            }
+            if update_settings:
+                self._solver.update_settings(**update_settings)
+            reuse_mode = "same_sparsity_update+automatic_warm_start"
+
+        result = self._solver.solve(raise_error=False)
+        info = result.info
+        status_text = str(info.status)
+        x_raw = getattr(result, "x", None)
+        x_candidate = None if x_raw is None else np.asarray(x_raw, dtype=np.float64)
+        has_finite_solution = x_candidate is not None and x_candidate.shape == (problem.n_variables,) and np.all(np.isfinite(x_candidate))
+        backend_status = _osqp_status(status_text, has_finite_solution)
+        certificate_kind = None
+        certificate_check = None
+        status_lower = status_text.strip().lower()
+        if status_lower.startswith("primal infeasible"):
+            certificate_kind = "primal_infeasibility"
+            multiplier = 10.0 if status_lower.endswith("inaccurate") else 1.0
+            certificate_check = _primal_certificate_check(
+                data, getattr(result, "prim_inf_cert", None), eps=self.eps_prim_inf * multiplier
+            )
+            if status_lower == "primal infeasible" and not certificate_check.get("valid"):
+                backend_status = "infeasible_candidate"
+        elif status_lower.startswith("dual infeasible"):
+            certificate_kind = "dual_infeasibility"
+            multiplier = 10.0 if status_lower.endswith("inaccurate") else 1.0
+            certificate_check = _dual_certificate_check(
+                problem, data, getattr(result, "dual_inf_cert", None), eps=self.eps_dual_inf * multiplier
+            )
+            if status_lower == "dual infeasible" and not certificate_check.get("valid"):
+                backend_status = "unbounded_candidate"
+
+        x = x_candidate if backend_status in {"optimal", "converged_candidate", "limit_feasible"} and has_finite_solution else None
+
+        objective = None
+        objective_internal = None
+        if x is not None:
+            raw_obj = getattr(info, "obj_val", None)
+            if raw_obj is not None and np.isfinite(float(raw_obj)):
+                objective_internal = float(raw_obj)
+                objective = objective_internal + float(problem.linear.objective_offset)
+
+        raw: dict[str, object] = {
+            "osqp_status": status_text,
+            "status_val": int(getattr(info, "status_val", 0)),
+            "iter": int(getattr(info, "iter", 0)),
+            "setup_time": float(getattr(info, "setup_time", 0.0)),
+            "solve_time": float(getattr(info, "solve_time", 0.0)),
+            "update_time": float(getattr(info, "update_time", 0.0)),
+            "polish_time": float(getattr(info, "polish_time", 0.0)),
+            "run_time": float(getattr(info, "run_time", 0.0)),
+            "reuse_applied": bool(reuse_applied),
+            "reuse_mode": reuse_mode,
+            "certificate_kind": certificate_kind,
+            "certificate_check": certificate_check,
+            "objective_internal": objective_internal,
+        }
+        return BackendSolveResult(
+            backend_status=backend_status,
+            x=x,
+            objective_reported=objective,
+            raw_statistics=raw,
+        )

solverpilot/backends/protocol_v2.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any, Mapping, Protocol, runtime_checkable
+
+import numpy as np
+
+from solverpilot.capabilities import BackendCapabilityManifestV2
+
+
+class CallbackEventKind(str, Enum):
+    PROGRESS = "progress"
+    INCUMBENT = "incumbent"
+    NODE = "node"
+    MESSAGE = "message"
+
+
+@dataclass(frozen=True, slots=True)
+class CallbackEvent:
+    kind: CallbackEventKind
+    runtime_s: float | None = None
+    objective: float | None = None
+    bound: float | None = None
+    gap: float | None = None
+    node_count: int | None = None
+    payload: Mapping[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True)
+class BackendArtifactBundle:
+    """Raw backend artifacts before original-space reconstruction/validation.
+
+    P3 intentionally keeps artifacts optional and independent. A backend may return a
+    primal vector without duals, or a basis without rays. Absence is represented by
+    ``None`` rather than inferred from solver termination.
+    """
+
+    primal: np.ndarray | None = None
+    objective: float | None = None
+    dual: np.ndarray | None = None
+    slacks: np.ndarray | None = None
+    reduced_costs: np.ndarray | None = None
+    primal_ray: np.ndarray | None = None
+    dual_ray: np.ndarray | None = None
+    basis: Any | None = None
+    iis: Any | None = None
+    solution_pool: tuple[np.ndarray, ...] = ()
+    infeasibility_certificate: Any | None = None
+    metadata: Mapping[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True)
+class BackendSolveRequestV2:
+    time_limit_s: float | None = None
+    thread_limit: int | None = None
+    primal_start: np.ndarray | None = None
+    dual_start: np.ndarray | None = None
+    basis_start: Any | None = None
+    mip_start: np.ndarray | None = None
+    options: Mapping[str, Any] = field(default_factory=dict)
+
+
+@dataclass(frozen=True, slots=True)
+class BackendSolveResultV2:
+    termination: str
+    artifacts: BackendArtifactBundle
+    statistics: Mapping[str, Any] = field(default_factory=dict)
+
+
+@runtime_checkable
+class BackendCallbackControllerV2(Protocol):
+    def terminate(self) -> None: ...
+    def add_lazy_constraint(self, constraint: Any) -> None: ...
+    def add_user_cut(self, constraint: Any) -> None: ...
+    def submit_heuristic_solution(self, values: np.ndarray) -> None: ...
+
+
+@runtime_checkable
+class BackendCallbackV2(Protocol):
+    def __call__(self, event: CallbackEvent, controller: BackendCallbackControllerV2) -> None: ...
+
+
+@runtime_checkable
+class BackendProtocolV2(Protocol):
+    """Future adapter protocol consumed by P4/P5.
+
+    Current M-track adapters do not automatically satisfy this protocol. P3 freezes the
+    surface so later milestones can implement it capability-by-capability without
+    retrofitting callback/mutation semantics after the Bridge Engine is built.
+    """
+
+    @property
+    def capability_manifest_v2(self) -> BackendCapabilityManifestV2: ...
+
+    def is_available(self) -> bool: ...
+
+    def solve_v2(
+        self,
+        problem: Any,
+        request: BackendSolveRequestV2,
+        callback: BackendCallbackV2 | None = None,
+    ) -> BackendSolveResultV2: ...
+
+
+@runtime_checkable
+class IncrementalBackendProtocolV2(Protocol):
+    def update_variable_bounds(self, lower: np.ndarray, upper: np.ndarray) -> None: ...
+    def update_rhs(self, lower: np.ndarray, upper: np.ndarray) -> None: ...
+    def update_objective(self, linear: np.ndarray, quadratic: Any | None = None) -> None: ...
+    def update_matrix_values(self, values: np.ndarray, indices: np.ndarray | None = None) -> None: ...
+
+
+@runtime_checkable
+class StructuralIncrementalBackendProtocolV2(Protocol):
+    def add_variable(self, specification: Any) -> Any: ...
+    def delete_variable(self, handle: Any) -> None: ...
+    def add_constraint(self, specification: Any) -> Any: ...
+    def delete_constraint(self, handle: Any) -> None: ...

solverpilot/backends/pyscipopt_native.py

@@ -0,0 +1,200 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import importlib.util
+from importlib.metadata import PackageNotFoundError, version
+
+import numpy as np
+
+from solverpilot.capabilities import BackendManifest, Capability, SupportLevel
+from solverpilot.problem import LinearProblem, ObjectiveSense, QuadraticProblem, VariableDomain
+from solverpilot.problem.quadratic import require_confirmed_convexity
+
+from .base import BackendSolveResult, BackendUnavailableError
+
+
+def _scip_status(status: str, has_solution: bool) -> str:
+    s = status.strip().lower().replace("_", "")
+    if s == "optimal":
+        return "optimal"
+    if s == "infeasible":
+        return "infeasible"
+    if s == "unbounded":
+        return "unbounded"
+    if s in {"inforunbd", "infeasibleorunbounded"}:
+        return "infeasible_or_unbounded"
+    if any(token in s for token in ("timelimit", "nodelimit", "stallnodelimit", "gaplimit", "sollimit", "bestsollimit", "memlimit")):
+        return "limit_feasible" if has_solution else "limit_no_solution"
+    if s in {"userinterrupt", "restartlimit"}:
+        return "limit_feasible" if has_solution else "limit_no_solution"
+    if s in {"unknown", "terminate"}:
+        return "unknown"
+    return "solver_error"
+
+
+@dataclass(frozen=True, slots=True)
+class SCIPIISResult:
+    constraint_names: tuple[str, ...]
+    variable_names: tuple[str, ...]
+    irreducible: bool
+    time_s: float
+    nodes: int
+
+
+@dataclass(slots=True)
+class PySCIPOptNativeBackend:
+    """Optional native SCIP adapter for LP/MILP plus IIS extraction.
+
+    The implementation intentionally uses only documented PySCIPOpt surface APIs.
+    Native reoptimization and solution injection are left unclaimed until exercised in
+    an environment containing PySCIPOpt/SCIP.
+    """
+
+    time_limit_s: float | None = None
+    display: bool = False
+
+    @property
+    def manifest(self) -> BackendManifest:
+        pkg_version = None
+        if self.is_available():
+            try:
+                pkg_version = version("pyscipopt")
+            except PackageNotFoundError:
+                pass
+        return BackendManifest(
+            name="pyscipopt-native",
+            version=pkg_version,
+            capabilities={
+                Capability.LP: SupportLevel.NATIVE,
+                Capability.CONVEX_QP: SupportLevel.UNSUPPORTED,
+                Capability.MILP: SupportLevel.NATIVE,
+                Capability.MIP_START: SupportLevel.UNKNOWN,
+                Capability.PRIMAL_START: SupportLevel.UNKNOWN,
+                Capability.DUAL_START: SupportLevel.UNKNOWN,
+                Capability.BASIS_START: SupportLevel.UNKNOWN,
+                Capability.SAME_SPARSITY_DATA_UPDATE: SupportLevel.UNKNOWN,
+                Capability.STRUCTURAL_INCREMENTAL_UPDATE: SupportLevel.UNKNOWN,
+                Capability.NATIVE_REOPTIMIZATION: SupportLevel.UNKNOWN,
+                Capability.CALLBACK_PROGRESS: SupportLevel.UNKNOWN,
+                Capability.IIS: SupportLevel.NATIVE,
+                Capability.INFEASIBILITY_CERTIFICATE: SupportLevel.UNKNOWN,
+            },
+            metadata={
+                "native_adapter": True,
+                "iis_method": "Model.generateIIS",
+                "reuse_claim": "none in M2 adapter",
+            },
+        )
+
+    def is_available(self) -> bool:
+        return importlib.util.find_spec("pyscipopt") is not None
+
+    def _build_model(self, problem: LinearProblem):
+        if not self.is_available():
+            raise BackendUnavailableError("PySCIPOpt is not installed")
+        from pyscipopt import Model, quicksum
+
+        model = Model("solverpilot")
+        if not self.display:
+            model.hideOutput()
+        if self.time_limit_s is not None:
+            if self.time_limit_s <= 0:
+                raise ValueError("time_limit_s must be positive")
+            model.setParam("limits/time", float(self.time_limit_s))
+
+        variables = []
+        for j, domain in enumerate(problem.domains):
+            lbv = float(problem.variable_lower[j])
+            ubv = float(problem.variable_upper[j])
+            lb = None if np.isneginf(lbv) else lbv
+            ub = None if np.isposinf(ubv) else ubv
+            if domain == VariableDomain.BINARY.value:
+                vtype = "B"
+            elif domain == VariableDomain.INTEGER.value:
+                vtype = "I"
+            else:
+                vtype = "C"
+            variables.append(model.addVar(name=f"x_{j}", vtype=vtype, lb=lb, ub=ub))
+
+        objective = quicksum(float(problem.c[j]) * variables[j] for j in range(problem.n_variables) if problem.c[j] != 0.0)
+        sense = "minimize" if problem.objective_sense is ObjectiveSense.MINIMIZE else "maximize"
+        model.setObjective(objective, sense=sense)
+        if problem.objective_offset != 0.0:
+            # PySCIPOpt exposes objective constants separately from the linear expression.
+            # Keeping the offset in the native model makes solver-reported bounds/gaps and
+            # objective values semantically consistent with the canonical problem.
+            model.addObjoffset(float(problem.objective_offset))
+
+        A = problem.A.tocsr()
+        for i in range(problem.n_constraints):
+            start, end = A.indptr[i], A.indptr[i + 1]
+            expr = quicksum(float(A.data[k]) * variables[int(A.indices[k])] for k in range(start, end))
+            lo = float(problem.constraint_lower[i])
+            hi = float(problem.constraint_upper[i])
+            if np.isfinite(lo) and np.isfinite(hi) and lo == hi:
+                model.addCons(expr == lo, name=f"row_{i}_eq")
+            else:
+                if np.isfinite(lo):
+                    model.addCons(expr >= lo, name=f"row_{i}_lower")
+                if np.isfinite(hi):
+                    model.addCons(expr <= hi, name=f"row_{i}_upper")
+        return model, variables
+
+    def solve(self, problem: LinearProblem | QuadraticProblem) -> BackendSolveResult:
+        if isinstance(problem, QuadraticProblem):
+            raise ValueError("M2 PySCIPOpt adapter supports LP/MILP only")
+        if not isinstance(problem, LinearProblem):
+            raise TypeError(f"unsupported problem type: {type(problem)!r}")
+        model, variables = self._build_model(problem)
+        model.optimize()
+        status_text = str(model.getStatus())
+        has_solution = int(model.getNSols()) > 0
+        backend_status = _scip_status(status_text, has_solution)
+        x = None
+        if has_solution and backend_status in {"optimal", "limit_feasible"}:
+            sol = model.getBestSol()
+            x_candidate = np.asarray([model.getSolVal(sol, v) for v in variables], dtype=np.float64)
+            if np.all(np.isfinite(x_candidate)):
+                x = x_candidate
+        objective = None if x is None else float(problem.c @ x + problem.objective_offset)
+        raw: dict[str, object] = {
+            "scip_status": status_text,
+            "n_solutions": int(model.getNSols()),
+            "solve_time": float(model.getSolvingTime()),
+            "nodes": int(model.getNTotalNodes()),
+            "reuse_applied": False,
+            "reuse_mode": "cold_native_solve",
+        }
+        if has_solution:
+            try:
+                raw["gap"] = float(model.getGap())
+                raw["dual_bound"] = float(model.getDualbound())
+            except Exception:
+                pass
+        return BackendSolveResult(
+            backend_status=backend_status,
+            x=x,
+            objective_reported=objective,
+            raw_statistics=raw,
+        )
+
+    def generate_iis(self, problem: LinearProblem) -> SCIPIISResult:
+        """Generate a SCIP IIS for an infeasible LP/MILP.
+
+        Raises ValueError when SCIP does not classify the model as infeasible.
+        """
+        if not isinstance(problem, LinearProblem):
+            raise TypeError("SCIP IIS adapter currently accepts LinearProblem only")
+        model, _ = self._build_model(problem)
+        model.optimize()
+        if str(model.getStatus()).strip().lower() != "infeasible":
+            raise ValueError("IIS requested for a model not classified infeasible by SCIP")
+        iis = model.generateIIS()
+        subscip = iis.getSubscip()
+        return SCIPIISResult(
+            constraint_names=tuple(sorted(str(c.name) for c in subscip.getConss())),
+            variable_names=tuple(sorted(str(v.name) for v in subscip.getVars())),
+            irreducible=bool(iis.isSubscipIrreducible()),
+            time_s=float(iis.getTime()),
+            nodes=int(iis.getNNodes()),
+        )

solverpilot/backends/registry.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from .base import Backend
+from solverpilot.exceptions import UnknownBackendError
+
+
+class BackendRegistry:
+    def __init__(self) -> None:
+        self._backends: dict[str, Backend] = {}
+
+    def register(self, backend: Backend) -> None:
+        name = backend.manifest.name
+        if name in self._backends:
+            raise ValueError(f"backend already registered: {name}")
+        self._backends[name] = backend
+
+    def get(self, name: str) -> Backend:
+        try:
+            return self._backends[name]
+        except KeyError as exc:
+            raise UnknownBackendError(f"unknown backend: {name}") from exc
+
+    def all(self) -> tuple[Backend, ...]:
+        return tuple(self._backends.values())
+
+    def available(self) -> tuple[Backend, ...]:
+        return tuple(b for b in self._backends.values() if b.is_available())
+
+    def names(self) -> tuple[str, ...]:
+        return tuple(sorted(self._backends))
+
+    def capability_manifest_v2(self, name: str, *, verify: bool = False):
+        from solverpilot.capabilities import resolve_backend_capabilities
+        return resolve_backend_capabilities(self.get(name), verify=verify)
+
+    def capability_manifests_v2(self, *, verify: bool = False):
+        from solverpilot.capabilities import resolve_backend_capabilities
+        return tuple(resolve_backend_capabilities(b, verify=verify) for b in self.all())