solverpilot 0.1__py3-none-any.whl

solverpilot/conic/backend.py

@@ -0,0 +1,263 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import importlib.util
+from importlib.metadata import PackageNotFoundError, version
+from typing import Any
+
+import numpy as np
+
+from .ir import ConeKind, ConicProblem
+from .validation import ConicValidationReport, validate_conic_solution
+
+
+def _casadi_version() -> str | None:
+    try:
+        return version("casadi")
+    except PackageNotFoundError:
+        try:
+            import casadi as ca
+            return getattr(ca, "__version__", None)
+        except Exception:
+            return None
+
+
+def _superscs_available() -> bool:
+    if importlib.util.find_spec("casadi") is None:
+        return False
+    try:
+        import casadi as ca
+        return bool(ca.has_conic("superscs"))
+    except Exception:
+        return False
+
+
+@dataclass(frozen=True, slots=True)
+class ConicSolveResult:
+    backend: str
+    backend_status: str
+    x: np.ndarray | None
+    objective_reported: float | None
+    validation: ConicValidationReport
+    raw_statistics: dict[str, Any]
+
+    @property
+    def validated(self) -> bool:
+        return bool(self.validation.valid)
+
+
+@dataclass(slots=True)
+class CasadiSuperSCSBackend:
+    """Verified P6 bridge to the SuperSCS plugin bundled by CasADi 3.7.2.
+
+    This adapter is intentionally labeled a bridge, not a public SuperSCS Python
+    binding. It is used because dedicated Clarabel/SCS packages are unavailable in
+    the current release environment. Verified P6 solve scope is linear-objective SOC
+    and rotated SOC (the latter via an exact linear map to SOC). PSD is represented
+    and independently validated by P6 but intentionally solve-disabled for this adapter
+    after negative objective-accuracy conformance.
+    """
+
+    max_iter: int = 20_000
+    eps: float = 1e-8
+    verbose: bool = False
+
+    @property
+    def name(self) -> str:
+        return "casadi-superscs-conic-bridge"
+
+    @property
+    def capability_manifest_v2(self):
+        from solverpilot import __version__
+        from solverpilot.capabilities.v2 import (
+            BackendCapabilityManifestV2, CapabilityClaim, CapabilityEvidence, CapabilityKey,
+            CapabilityMode, CapabilityStatus, VerificationLevel,
+        )
+        binding_version = self.binding_version
+        backend_version = f"bundled-with-casadi-{binding_version or 'unknown'}"
+        evidence = CapabilityEvidence(
+            evidence_id="p6-casadi-superscs-conformance-v1",
+            kind="native-runtime-conformance",
+            backend_versions=(backend_version,),
+            binding_versions=(() if binding_version is None else (binding_version,)),
+            adapter_versions=(__version__,),
+            verified_on="2026-09-06",
+            notes=(
+                "CasADi SuperSCS plugin exercised on SOC/rotated-SOC models; PSD negative conformance retained",
+                "rotated SOC is exact adapter transformation to SOC",
+            ),
+        )
+        def verified(mode=CapabilityMode.NATIVE, restrictions=None):
+            restrictions = {} if restrictions is None else restrictions
+            status = CapabilityStatus.SUPPORTED if not restrictions else CapabilityStatus.RESTRICTED
+            return CapabilityClaim(status=status, mode=mode, verification=VerificationLevel.VERIFIED, restrictions=restrictions, evidence=(evidence,))
+        claims = {
+            CapabilityKey.PROBLEM_CONIC: verified(CapabilityMode.EMULATED_SAFE, {"binding": "CasADi SuperSCS bridge", "continuous_only": True, "verified_objective": "linear"}),
+            CapabilityKey.PROBLEM_CONIC_QUADRATIC: CapabilityClaim(status=CapabilityStatus.UNVERIFIED, mode=CapabilityMode.UNKNOWN, verification=VerificationLevel.UNVERIFIED, notes=("P6 generic quadratic-SOCP conformance failed on feasible analytic projection cases",)),
+            CapabilityKey.CONSTRAINT_LINEAR: verified(CapabilityMode.NATIVE),
+            CapabilityKey.CONSTRAINT_SOC: verified(CapabilityMode.EMULATED_SAFE, {"transport": "PSD Schur-complement representation via casadi.soc"}),
+            CapabilityKey.CONSTRAINT_ROTATED_SOC: verified(CapabilityMode.EMULATED_SAFE, {"transport": "exact linear map to SOC then PSD representation"}),
+            CapabilityKey.CONSTRAINT_PSD: CapabilityClaim(status=CapabilityStatus.UNVERIFIED, mode=CapabilityMode.UNKNOWN, verification=VerificationLevel.UNVERIFIED, notes=("P6 PSD semantic IR is implemented, but bundled SuperSCS failed objective-accuracy conformance for generic PSD programs",)),
+            CapabilityKey.RESULT_PRIMAL: verified(CapabilityMode.NATIVE),
+            CapabilityKey.RESULT_OBJECTIVE: verified(CapabilityMode.NATIVE),
+        }
+        return BackendCapabilityManifestV2(
+            backend=self.name,
+            backend_version=backend_version,
+            binding="casadi",
+            binding_version=binding_version,
+            adapter_version=__version__,
+            claims=claims,
+            numeric_limits={"p6_tolerance": self.eps},
+            metadata={"verification_only_bridge": True, "plugin": "superscs"},
+        )
+
+    @property
+    def binding_version(self) -> str | None:
+        return _casadi_version()
+
+    def is_available(self) -> bool:
+        return _superscs_available()
+
+    def _build_solver(self, problem: ConicProblem):
+        import casadi as ca
+
+        n = problem.n_variables
+        x = ca.MX.sym("x", n)
+        P = ca.DM(problem.P.toarray())
+        q = ca.DM(problem.q)
+        f = 0.5 * ca.mtimes([x.T, P, x]) + ca.dot(q, x) + float(problem.objective_offset)
+
+        g_exprs = []
+        lbg: list[float] = []
+        ubg: list[float] = []
+        if problem.n_linear_constraints:
+            Ad = ca.DM(problem.A.toarray())
+            lin = ca.mtimes(Ad, x)
+            g_exprs.append(lin)
+            lbg.extend(problem.constraint_lower.tolist())
+            ubg.extend(problem.constraint_upper.tolist())
+
+        psd_blocks = []
+        for block in problem.cones:
+            F = ca.DM(block.F.toarray())
+            g = ca.DM(block.g)
+            y = ca.mtimes(F, x) + g
+            if block.kind is ConeKind.SECOND_ORDER:
+                psd_blocks.append(ca.soc(y[1:], y[0]))
+            elif block.kind is ConeKind.ROTATED_SECOND_ORDER:
+                # 2*u*v >= ||z||^2, u,v>=0  <=>
+                # ||[sqrt(2)z, u-v]|| <= u+v.
+                u = y[0]; v = y[1]; z = y[2:]
+                soc_vec = ca.vertcat(np.sqrt(2.0) * z, u - v)
+                psd_blocks.append(ca.soc(soc_vec, u + v))
+                # Explicit nonnegativity keeps the semantic boundary obvious and
+                # protects against numerical interpretations of the transformed SOC.
+                g_exprs.append(ca.vertcat(u, v))
+                lbg.extend([0.0, 0.0]); ubg.extend([np.inf, np.inf])
+            elif block.kind is ConeKind.POSITIVE_SEMIDEFINITE:
+                rows, cols = block.output_shape
+                M = ca.reshape(y, cols, rows).T  # row-major semantic flattening
+                psd_blocks.append(M)
+            else:  # pragma: no cover
+                raise ValueError(block.kind)
+
+        h = None
+        if psd_blocks:
+            h = psd_blocks[0]
+            for blk in psd_blocks[1:]:
+                r1, c1 = h.shape; r2, c2 = blk.shape
+                h = ca.blockcat([[h, ca.MX.zeros(r1, c2)], [ca.MX.zeros(r2, c1), blk]])
+
+        qp: dict[str, Any] = {"x": x, "f": f}
+        if g_exprs:
+            qp["g"] = ca.vertcat(*g_exprs)
+        if h is not None:
+            qp["h"] = h
+
+        opts: dict[str, Any] = {"error_on_fail": False}
+        # SuperSCS option names follow its native interface. Keep the set minimal;
+        # unsupported verbosity options have differed across CasADi builds.
+        opts["superscs"] = {
+            "max_iters": int(self.max_iter),
+            "eps": float(self.eps),
+            "verbose": 1 if self.verbose else 0,
+        }
+        try:
+            solver = ca.qpsol("solverpilot_p6_superscs", "superscs", qp, opts)
+        except Exception:
+            # Some bundled SuperSCS builds reject the verbose key. Retry with only
+            # convergence controls rather than silently abandoning the backend.
+            opts["superscs"] = {"max_iters": int(self.max_iter), "eps": float(self.eps)}
+            solver = ca.qpsol("solverpilot_p6_superscs", "superscs", qp, opts)
+        return solver, np.asarray(lbg, dtype=float), np.asarray(ubg, dtype=float)
+
+    def solve(self, problem: ConicProblem) -> ConicSolveResult:
+        if not self.is_available():
+            raise RuntimeError("CasADi SuperSCS conic plugin is unavailable")
+        if problem.P.nnz:
+            raise RuntimeError("P6 fail-closed: quadratic conic objective conformance did not pass for the bundled CasADi SuperSCS plugin")
+        if any(block.kind is ConeKind.POSITIVE_SEMIDEFINITE for block in problem.cones):
+            raise RuntimeError("P6 fail-closed: generic PSD solve conformance did not pass for the bundled CasADi SuperSCS plugin; install a future verified PSD backend instead")
+        solver, lbg, ubg = self._build_solver(problem)
+        kwargs: dict[str, Any] = {
+            "lbx": problem.variable_lower,
+            "ubx": problem.variable_upper,
+        }
+        if lbg.size:
+            kwargs["lbg"] = lbg
+            kwargs["ubg"] = ubg
+        error = None
+        result = None
+        try:
+            result = solver(**kwargs)
+        except Exception as exc:
+            error = f"{type(exc).__name__}: {exc}"
+        try:
+            stats = dict(solver.stats())
+        except Exception:
+            stats = {}
+        x = None
+        objective = None
+        if result is not None and "x" in result:
+            arr = np.asarray(result["x"], dtype=float).reshape(-1)
+            if arr.shape == (problem.n_variables,) and np.all(np.isfinite(arr)):
+                x = arr
+                objective = problem.objective_value(arr)
+        raw = " ".join(str(stats.get(k, "")) for k in ("return_status", "unified_return_status")).lower()
+        if bool(stats.get("success")) and x is not None:
+            status = "optimal_candidate"
+        elif "infeasible" in raw:
+            status = "infeasible"
+        elif "unbounded" in raw:
+            status = "unbounded"
+        elif x is not None:
+            status = "candidate"
+        else:
+            status = "solver_error"
+        validation_tol = max(self.eps * 25.0, 5e-7)
+        validation = validate_conic_solution(problem, x, atol=validation_tol, rtol=validation_tol)
+        stats["independent_validation_tolerance"] = validation_tol
+        stats.update({
+            "casadi_version": _casadi_version(),
+            "conic_plugin": "superscs",
+            "error": error,
+            "verification_only_bridge": True,
+            "cone_families": sorted({c.kind.value for c in problem.cones}),
+            "adapter_transformations": (["rotated_second_order->second_order_exact_linear_map"] if any(c.kind is ConeKind.ROTATED_SECOND_ORDER for c in problem.cones) else []),
+        })
+        return ConicSolveResult(self.name, status, x, objective, validation, stats)
+
+
+def solve_conic(problem: ConicProblem, *, backend: CasadiSuperSCSBackend | None = None) -> ConicSolveResult:
+    backend = CasadiSuperSCSBackend() if backend is None else backend
+    from solverpilot.capabilities.v2 import compatible_v2, requirements_v2_for
+    manifest = backend.capability_manifest_v2
+    ok, checks = compatible_v2(
+        manifest, requirements_v2_for(problem),
+        allow_safe_emulation=True, allow_risky_emulation=False, require_verified=True,
+    )
+    if not ok:
+        reasons = "; ".join(f"{c.key.value}: {c.reason}" for c in checks if not c.usable)
+        raise RuntimeError(f"P6 conic backend capability gate rejected solve: {reasons}")
+    return backend.solve(problem)

solverpilot/conic/compiler.py

@@ -0,0 +1,310 @@
+from __future__ import annotations
+
+from collections import OrderedDict
+from dataclasses import dataclass, replace
+import hashlib
+import json
+from time import perf_counter
+from typing import Any
+
+import numpy as np
+from scipy import sparse
+
+from solverpilot.problem import ObjectiveSense, VariableDomain
+from solverpilot.model.errors import CompileError
+from solverpilot.model.sets import (
+    EqualTo, GreaterThan, Interval, LessThan,
+    PositiveSemidefiniteCone, RotatedSecondOrderCone, SecondOrderCone,
+)
+
+from .ir import ConeAffineBlock, ConeKind, ConicProblem
+
+
+_P6_CACHE_KEY = "conic-ir:p6:v1"
+_P6_CAPABILITY_SIGNATURE = "conic-ir:p6:v1:casadi-superscs-bridge-verified-soc-rsoc-psd-unverified"
+_P6_POLICY = "p0-rfc-012:p6-convex-conic-v1"
+_MAX_SNAPSHOTS = 8
+
+
+@dataclass(slots=True)
+class _ConicCacheEntry:
+    semantic_hash: str
+    current: Any
+    parameter_versions: dict[str, int]
+    snapshots: OrderedDict[str, Any]
+    full_compiles: int = 1
+    snapshot_hits: int = 0
+
+
+def _compilation_hash(model) -> str:
+    payload = {
+        "semantic_hash": model.semantic_hash,
+        "target": "conic-ir-v1",
+        "capability_signature": _P6_CAPABILITY_SIGNATURE,
+        "numerical_policy": _P6_POLICY,
+        "cone_semantics": ["soc", "rotated_soc", "psd"],
+    }
+    return hashlib.sha256(json.dumps(payload, sort_keys=True, separators=(",", ":")).encode()).hexdigest()
+
+
+def _poly_to_affine(poly, n: int, *, context: str) -> tuple[dict[int, float], float]:
+    if poly.degree > 1:
+        raise CompileError(f"{context} must be affine for P6 conic lowering")
+    return dict(poly.linear), float(poly.constant)
+
+
+def _affine_map(evaluator, node, n: int, *, context: str) -> tuple[sparse.csr_matrix, np.ndarray, tuple[int, ...]]:
+    arr = np.asarray(evaluator.evaluate(node), dtype=object)
+    shape = tuple(arr.shape)
+    flat = arr.reshape(-1)
+    rr: list[int] = []
+    cc: list[int] = []
+    vv: list[float] = []
+    g = np.zeros(flat.size, dtype=float)
+    for r, poly in enumerate(flat):
+        coeffs, const = _poly_to_affine(poly, n, context=context)
+        g[r] = const
+        for c, value in coeffs.items():
+            if value != 0.0:
+                rr.append(r); cc.append(int(c)); vv.append(float(value))
+    F = sparse.csr_matrix((vv, (rr, cc)), shape=(flat.size, n), dtype=float)
+    return F, g, shape
+
+
+def _assert_psd_affine_symmetry(evaluator, node, *, context: str) -> None:
+    arr = np.asarray(evaluator.evaluate(node), dtype=object)
+    if arr.ndim != 2 or arr.shape[0] != arr.shape[1]:
+        raise CompileError(f"{context} must be a square matrix")
+    for i in range(arr.shape[0]):
+        for j in range(i + 1, arr.shape[1]):
+            if arr[i, j] != arr[j, i]:
+                raise CompileError(
+                    f"{context} is not structurally symmetric; P6 refuses to silently symmetrize PSD semantics"
+                )
+
+
+def _build_conic(model, *, cache_status: str, changed_parameters: tuple[str, ...]):
+    # Import P2/P4 compiler internals only at execution time to avoid module init cycles.
+    from solverpilot.model.compiler import (
+        CompiledModel, CompilationReport, _Evaluator, _constraint_block,
+        _objective_data, _rows_to_csr, _variable_layout,
+    )
+
+    total_t0 = perf_counter()
+    if model.objective is None:
+        raise CompileError("model has no objective")
+    if model.objective.sense is not ObjectiveSense.MINIMIZE:
+        raise CompileError("P6 conic compilation supports convex minimization only")
+    if any(data.domain is not VariableDomain.CONTINUOUS for data in model._variables.values()):
+        raise CompileError("P6 conic execution currently supports continuous variables only")
+    if model.objective.expression.polynomial_degree is None or model.objective.expression.polynomial_degree > 2:
+        raise CompileError("P6 objective must be affine or convex quadratic")
+
+    analysis_t0 = perf_counter()
+    offsets, n, vl, vu, domains, source_vars = _variable_layout(model)
+    semantic_analysis_s = perf_counter() - analysis_t0
+    evaluator = _Evaluator(model, offsets)
+
+    lower_t0 = perf_counter()
+    rows: list[dict[int, float]] = []
+    cl: list[float] = []
+    cu: list[float] = []
+    cones: list[ConeAffineBlock] = []
+    source_constraints: dict[str, Any] = {}
+    cone_dependencies: set[str] = set()
+
+    for constraint in model.constraints:
+        cid = constraint.entity_id.value
+        set_ = constraint.set
+        if isinstance(set_, (LessThan, GreaterThan, EqualTo, Interval)):
+            block_rows, block_cl, block_cu = _constraint_block(evaluator, constraint)
+            start = len(rows)
+            rows.extend(block_rows); cl.extend(block_cl); cu.extend(block_cu)
+            source_constraints[cid] = {
+                "semantic_kind": "function_in_scalar_set",
+                "execution_rows": list(range(start, len(rows))),
+                "shape": list(constraint.function.shape),
+            }
+            continue
+
+        F, g, shape = _affine_map(evaluator, constraint.function._node, n, context=f"cone constraint {cid}")
+        deps = tuple(sorted(constraint.function.parameter_dependencies))
+        cone_dependencies.update(deps)
+        if isinstance(set_, SecondOrderCone):
+            kind = ConeKind.SECOND_ORDER
+            expected = (set_.dimension,)
+        elif isinstance(set_, RotatedSecondOrderCone):
+            kind = ConeKind.ROTATED_SECOND_ORDER
+            expected = (set_.dimension,)
+        elif isinstance(set_, PositiveSemidefiniteCone):
+            _assert_psd_affine_symmetry(evaluator, constraint.function._node, context=f"PSD constraint {cid}")
+            kind = ConeKind.POSITIVE_SEMIDEFINITE
+            expected = (set_.dimension, set_.dimension)
+        else:
+            raise CompileError(f"unsupported P6 constraint set {type(set_).__name__}")
+        if shape != expected:
+            raise CompileError(f"cone shape mismatch for {cid}: expected {expected}, got {shape}")
+        index = len(cones)
+        cones.append(ConeAffineBlock(kind, F, g, expected, source_id=cid, metadata={"parameter_dependencies": deps}))
+        source_constraints[cid] = {
+            "semantic_kind": kind.value,
+            "cone_block": index,
+            "shape": list(shape),
+            "parameter_dependencies": list(deps),
+        }
+
+    if not cones:
+        raise CompileError("P6 conic compiler received a model with no cone constraints")
+    A = _rows_to_csr(rows, n)
+    # Reuse the already verified P2 quadratic convention 0.5*x'P*x + q'x + offset.
+    target = "legacy-qp-v1" if model.objective.expression.polynomial_degree == 2 else "legacy-linear-v1"
+    q, offset, P = _objective_data(evaluator, model, n, target)
+    if P is None:
+        P = sparse.csr_matrix((n, n), dtype=float)
+    try:
+        problem = ConicProblem.from_data(
+            P=P,
+            q=q,
+            A=A,
+            variable_lower=vl,
+            variable_upper=vu,
+            constraint_lower=np.asarray(cl, dtype=float),
+            constraint_upper=np.asarray(cu, dtype=float),
+            cones=cones,
+            objective_offset=offset,
+            name=model.name,
+            metadata={
+                "semantic_hash": model.semantic_hash,
+                "compiled_by": "solverpilot-p6",
+                "compiler_policy": _P6_POLICY,
+                "cone_families": sorted({c.kind.value for c in cones}),
+            },
+            verify_convexity=True,
+        )
+    except ValueError as exc:
+        raise CompileError(str(exc)) from exc
+
+    pmap: dict[str, Any] = {}
+    for pid, pdata in model._parameters.items():
+        regions: list[str] = []
+        for cid, info in source_constraints.items():
+            if pid in info.get("parameter_dependencies", []):
+                regions.append(f"cone:{cid}")
+        if model.objective is not None and pid in model.objective.expression.parameter_dependencies:
+            regions.append("objective")
+        for c in model.constraints:
+            if pid in c.function.parameter_dependencies and f"cone:{c.entity_id.value}" not in regions:
+                regions.append(f"constraint:{c.entity_id.value}")
+        pmap[pid] = {
+            "shape": list(pdata.shape),
+            "patchable": False,
+            "parameter_compile_class": "p6_full_conic_relower",
+            "plan_sensitive": True if regions else False,
+            "execution_regions": regions,
+        }
+    comp_hash = _compilation_hash(model)
+    source_map = {
+        "variables": source_vars,
+        "constraints": source_constraints,
+        "objective": {model.objective.entity_id.value: {"execution_objective": True}},
+    }
+    lowering_s = perf_counter() - lower_t0
+    report = CompilationReport(
+        target="conic-ir-v1",
+        semantic_analysis_s=semantic_analysis_s,
+        lowering_s=lowering_s,
+        total_s=perf_counter() - total_t0,
+        n_semantic_variables=len(model._variables),
+        n_execution_variables=n,
+        n_semantic_constraints=len(model._constraints),
+        n_execution_constraints=len(rows) + len(cones),
+        cache_status=cache_status,
+        changed_parameters=changed_parameters,
+        reused_execution_rows=0,
+        recompiled_execution_rows=len(rows) + len(cones),
+        objective_recompiled=True,
+        execution_mutations=(),
+        n_transformations=0,
+    )
+    return CompiledModel(
+        execution_ir=problem,
+        semantic_hash=model.semantic_hash,
+        data_hash=model.data_hash,
+        compilation_hash=comp_hash,
+        parameter_map=pmap,
+        source_map=source_map,
+        transformation_tape=(),
+        capability_signature=_P6_CAPABILITY_SIGNATURE,
+        mutation_plan={
+            "mode": "p6_full_conic_relower",
+            "incremental_parameter_patching": False,
+            "backend_session_patch": False,
+            "changed_parameters": list(changed_parameters),
+            "affected_regions": [r for pid in changed_parameters for r in pmap.get(pid, {}).get("execution_regions", [])],
+            "execution_mutations": [],
+            "reason": "P6 cone maps are rebuilt from semantic affine expressions; persistent conic mutation is outside P6 scope",
+        },
+        plan_sensitive_dependencies=tuple(sorted(cone_dependencies)),
+        precondition_certificate_hashes=(),
+        compilation_report=report,
+        reconstruction_contract={
+            "primal": "identity_by_source_map",
+            "dual": "backend_specific_not_standardized_p6",
+            "certificate": "none_p6",
+            "original_space_validation": "solverpilot.conic.validate_conic_solution + semantic validator",
+        },
+        schema_version="solverpilot.compiled-model.p6.v1",
+    )
+
+
+def compile_conic_model(model, *, use_cache: bool = True):
+    entry = model._compiler_cache.get(_P6_CACHE_KEY)
+    changed: tuple[str, ...] = ()
+    if isinstance(entry, _ConicCacheEntry):
+        changed = tuple(
+            pid for pid in model._parameters
+            if model._parameter_versions.get(pid, 0) != entry.parameter_versions.get(pid, 0)
+        )
+    if not use_cache:
+        return _build_conic(model, cache_status="disabled", changed_parameters=changed)
+    if not isinstance(entry, _ConicCacheEntry) or entry.semantic_hash != model.semantic_hash:
+        compiled = _build_conic(model, cache_status="miss", changed_parameters=())
+        snapshots = OrderedDict([(compiled.data_hash, compiled)])
+        model._compiler_cache[_P6_CACHE_KEY] = _ConicCacheEntry(
+            semantic_hash=model.semantic_hash,
+            current=compiled,
+            parameter_versions=dict(model._parameter_versions),
+            snapshots=snapshots,
+        )
+        return compiled
+    if model.data_hash in entry.snapshots:
+        entry.snapshot_hits += 1
+        snap = entry.snapshots[model.data_hash]
+        hit = replace(
+            snap,
+            compilation_report=replace(
+                snap.compilation_report,
+                semantic_analysis_s=0.0,
+                lowering_s=0.0,
+                total_s=0.0,
+                cache_status="snapshot_hit",
+                changed_parameters=changed,
+                reused_execution_rows=snap.compilation_report.n_execution_constraints,
+                recompiled_execution_rows=0,
+                objective_recompiled=False,
+            ),
+        )
+        entry.current = hit
+        entry.parameter_versions = dict(model._parameter_versions)
+        entry.snapshots[model.data_hash] = hit
+        entry.snapshots.move_to_end(model.data_hash)
+        return hit
+    compiled = _build_conic(model, cache_status="full_conic_relower", changed_parameters=changed)
+    entry.full_compiles += 1
+    entry.current = compiled
+    entry.parameter_versions = dict(model._parameter_versions)
+    entry.snapshots[compiled.data_hash] = compiled
+    entry.snapshots.move_to_end(compiled.data_hash)
+    while len(entry.snapshots) > _MAX_SNAPSHOTS:
+        entry.snapshots.popitem(last=False)
+    return compiled

solverpilot/conic/conformance.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import numpy as np
+
+from .backend import CasadiSuperSCSBackend
+
+
+@dataclass(frozen=True, slots=True)
+class ConicConformanceCheck:
+    name: str
+    passed: bool
+    detail: str
+
+
+@dataclass(frozen=True, slots=True)
+class ConicConformanceReport:
+    backend: str
+    binding_version: str | None
+    checks: tuple[ConicConformanceCheck, ...]
+
+    @property
+    def passed(self) -> bool:
+        return all(c.passed for c in self.checks)
+
+
+def conform_casadi_superscs_backend(backend: CasadiSuperSCSBackend | None = None) -> ConicConformanceReport:
+    import solverpilot as om
+    backend = CasadiSuperSCSBackend(eps=1e-9, max_iter=100000) if backend is None else backend
+    checks: list[ConicConformanceCheck] = []
+    if not backend.is_available():
+        return ConicConformanceReport(backend.name, backend.binding_version, (ConicConformanceCheck("availability", False, "plugin unavailable"),))
+
+    m=om.Model(); x=m.variable(2,lower=[3,4],upper=[3,4]); t=m.variable(lower=0,upper=10); m.soc(t,x); m.minimize(t)
+    r=backend.solve(m.compile(use_cache=False).execution_ir)
+    ok=r.validation.valid and r.objective_reported is not None and abs(r.objective_reported-5.0) <= 2e-6
+    checks.append(ConicConformanceCheck("soc-3-4-5", ok, f"objective={r.objective_reported}, valid={r.validation.valid}"))
+
+    m=om.Model(); z=m.variable(1,lower=[1],upper=[1]); u=m.variable(lower=0,upper=5); v=m.variable(lower=0,upper=5); m.rotated_soc(u,v,z); m.minimize(u+v)
+    r=backend.solve(m.compile(use_cache=False).execution_ir)
+    expected=float(np.sqrt(2.0)); ok=r.validation.valid and r.objective_reported is not None and abs(r.objective_reported-expected) <= 5e-6
+    checks.append(ConicConformanceCheck("rotated-soc-analytic", ok, f"objective={r.objective_reported}, expected={expected}, valid={r.validation.valid}"))
+
+    # Negative evidence is part of conformance: generic PSD must not be silently accepted.
+    m=om.Model(); tt=m.variable(lower=0,upper=5); m.psd(tt*m.constant(np.eye(2))+m.constant([[0.,1.],[1.,0.]])); m.minimize(tt)
+    try:
+        backend.solve(m.compile(use_cache=False).execution_ir)
+        refused=False; detail="PSD unexpectedly solved"
+    except RuntimeError as exc:
+        refused="PSD solve conformance did not pass" in str(exc); detail=str(exc)
+    checks.append(ConicConformanceCheck("psd-fail-closed", refused, detail))
+
+    m=om.Model(); xx=m.variable(3,lower=-10,upper=10); a=np.array([0.4322322767575165,-0.861140634080589,0.06823807914880933]); m.soc(2.848110356815995,xx); m.minimize(0.5*((xx-m.constant(a))**2).sum())
+    try:
+        backend.solve(m.compile(use_cache=False).execution_ir)
+        qrefused=False; qdetail="quadratic conic objective unexpectedly solved"
+    except RuntimeError as exc:
+        qrefused="quadratic conic objective conformance did not pass" in str(exc); qdetail=str(exc)
+    checks.append(ConicConformanceCheck("quadratic-conic-fail-closed", qrefused, qdetail))
+    return ConicConformanceReport(backend.name, backend.binding_version, tuple(checks))

solverpilot/conic/conic-ir-v1.schema.json

@@ -0,0 +1,24 @@
+{
+  "$id": "solverpilot.conic-ir.v1",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "required": ["schema", "P", "q", "A", "variable_lower", "variable_upper", "constraint_lower", "constraint_upper", "cones", "objective_sense", "objective_offset", "structural_hash", "data_hash"],
+  "properties": {
+    "schema": {"const": "solverpilot.conic-ir.v1"},
+    "P": {"type": "object"},
+    "q": {"type": "array", "items": {"type": "number"}},
+    "A": {"type": "object"},
+    "variable_lower": {"type": "array", "items": {"anyOf": [{"type": "number"}, {"enum": ["+inf", "-inf"]}]}},
+    "variable_upper": {"type": "array", "items": {"anyOf": [{"type": "number"}, {"enum": ["+inf", "-inf"]}]}},
+    "constraint_lower": {"type": "array", "items": {"anyOf": [{"type": "number"}, {"enum": ["+inf", "-inf"]}]}},
+    "constraint_upper": {"type": "array", "items": {"anyOf": [{"type": "number"}, {"enum": ["+inf", "-inf"]}]}},
+    "cones": {"type": "array", "minItems": 1, "items": {"type": "object", "required": ["kind", "F", "g", "output_shape", "structural_hash", "data_hash"], "properties": {"kind": {"enum": ["second_order", "rotated_second_order", "positive_semidefinite"]}}}},
+    "objective_sense": {"const": "minimize"},
+    "objective_offset": {"type": "number"},
+    "name": {"type": ["string", "null"]},
+    "metadata": {"type": "object"},
+    "convexity_status": {"type": "string"},
+    "structural_hash": {"type": "string"},
+    "data_hash": {"type": "string"}
+  }
+}