solverpilot 0.1__py3-none-any.whl

solverpilot/bridges/types.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+import hashlib
+import json
+from types import MappingProxyType
+from typing import Any, Mapping
+
+
+class ExactnessClass(str, Enum):
+    EXACT_EQUIVALENT = "exact_equivalent"
+    CERTIFIED_RELAXATION = "certified_relaxation"
+    HEURISTIC = "heuristic"
+
+
+class MappingAvailability(str, Enum):
+    IDENTITY = "identity"
+    AVAILABLE = "available"
+    UNAVAILABLE = "unavailable"
+
+
+def _freeze(value: Any) -> Any:
+    if isinstance(value, Mapping):
+        return MappingProxyType({str(k): _freeze(v) for k, v in value.items()})
+    if isinstance(value, list):
+        return tuple(_freeze(v) for v in value)
+    if isinstance(value, tuple):
+        return tuple(_freeze(v) for v in value)
+    return value
+
+
+def _jsonable(value: Any) -> Any:
+    if isinstance(value, Mapping):
+        return {str(k): _jsonable(v) for k, v in value.items()}
+    if isinstance(value, tuple):
+        return [_jsonable(v) for v in value]
+    if isinstance(value, Enum):
+        return value.value
+    return value
+
+
+@dataclass(frozen=True, slots=True)
+class PreconditionCertificate:
+    kind: str
+    payload: Mapping[str, Any] = field(default_factory=dict)
+    certificate_version: str = "solverpilot.bridge-certificate.p4.v1"
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "payload", _freeze(self.payload))
+
+    @property
+    def sha256(self) -> str:
+        raw = json.dumps(
+            {"version": self.certificate_version, "kind": self.kind, "payload": _jsonable(self.payload)},
+            sort_keys=True,
+            separators=(",", ":"),
+            ensure_ascii=True,
+        ).encode()
+        return hashlib.sha256(raw).hexdigest()
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "kind": self.kind,
+            "payload": _jsonable(self.payload),
+            "certificate_version": self.certificate_version,
+            "sha256": self.sha256,
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class TransformationStep:
+    step_id: str
+    bridge_id: str
+    bridge_version: str
+    source_entity_ids: tuple[str, ...]
+    generated_target_ids: tuple[str, ...]
+    exactness: ExactnessClass
+    preconditions: tuple[PreconditionCertificate, ...] = ()
+    primal_mapping: MappingAvailability = MappingAvailability.IDENTITY
+    dual_mapping: MappingAvailability = MappingAvailability.UNAVAILABLE
+    certificate_mapping: MappingAvailability = MappingAvailability.UNAVAILABLE
+    mutation_compatibility: tuple[str, ...] = ()
+    size_delta: Mapping[str, int] = field(default_factory=dict)
+    numerical_risk: Mapping[str, Any] = field(default_factory=dict)
+    notes: tuple[str, ...] = ()
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "size_delta", _freeze(self.size_delta))
+        object.__setattr__(self, "numerical_risk", _freeze(self.numerical_risk))
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "step_id": self.step_id,
+            "bridge_id": self.bridge_id,
+            "bridge_version": self.bridge_version,
+            "source_entity_ids": list(self.source_entity_ids),
+            "generated_target_ids": list(self.generated_target_ids),
+            "exactness": self.exactness.value,
+            "preconditions": [c.to_dict() for c in self.preconditions],
+            "primal_mapping": self.primal_mapping.value,
+            "dual_mapping": self.dual_mapping.value,
+            "certificate_mapping": self.certificate_mapping.value,
+            "mutation_compatibility": list(self.mutation_compatibility),
+            "size_delta": dict(self.size_delta),
+            "numerical_risk": _jsonable(self.numerical_risk),
+            "notes": list(self.notes),
+        }
+
+
+@dataclass(frozen=True, slots=True)
+class TransformationTape:
+    steps: tuple[TransformationStep, ...] = ()
+    schema_version: str = "solverpilot.transformation-tape.p4.v1"
+
+    def to_dicts(self) -> tuple[dict[str, Any], ...]:
+        return tuple(step.to_dict() for step in self.steps)
+
+    @property
+    def certificate_hashes(self) -> tuple[str, ...]:
+        return tuple(cert.sha256 for step in self.steps for cert in step.preconditions)
+
+    @property
+    def plan_sensitive_dependencies(self) -> tuple[str, ...]:
+        deps: list[str] = []
+        for step in self.steps:
+            for cert in step.preconditions:
+                raw = cert.payload.get("parameter_dependencies", ())
+                for dep in raw:
+                    dep = str(dep)
+                    if dep not in deps:
+                        deps.append(dep)
+        return tuple(deps)
+
+
+@dataclass(frozen=True, slots=True)
+class BridgePolicy:
+    mode: str = "safe"
+    allow_certified_relaxations: bool = False
+    allow_heuristic: bool = False
+    require_finite_certified_big_m: bool = True
+    policy_version: str = "solverpilot.bridge-policy.p4.safe.v1"
+
+    def permits(self, exactness: ExactnessClass) -> bool:
+        if exactness is ExactnessClass.EXACT_EQUIVALENT:
+            return True
+        if exactness is ExactnessClass.CERTIFIED_RELAXATION:
+            return self.allow_certified_relaxations
+        return self.allow_heuristic

solverpilot/bridges/validation.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+import numpy as np
+
+from solverpilot.problem import VariableDomain
+
+from .indicator import AffineScalar
+
+
+@dataclass(frozen=True, slots=True)
+class SemanticPrimalValidation:
+    valid: bool
+    max_violation: float
+    violations: tuple[str, ...]
+
+
+def _eval_expr(model, node, xflat: np.ndarray):
+    from solverpilot.model.compiler import _Evaluator, _variable_layout
+    offsets, *_ = _variable_layout(model)
+    ev = _Evaluator(model, offsets)
+    arr = ev.evaluate(node)
+    out = np.empty(arr.shape, dtype=float)
+    if arr.shape:
+        for idx in np.ndindex(arr.shape):
+            p = arr[idx]
+            val = p.constant + sum(float(a) * float(xflat[i]) for i, a in p.linear.items())
+            if p.quadratic:
+                val += sum(float(q) * float(xflat[i]) * float(xflat[j]) for (i, j), q in p.quadratic.items())
+            out[idx] = val
+    else:
+        p = arr[()]
+        val = p.constant + sum(float(a) * float(xflat[i]) for i, a in p.linear.items())
+        if p.quadratic:
+            val += sum(float(q) * float(xflat[i]) * float(xflat[j]) for (i, j), q in p.quadratic.items())
+        out = np.asarray(val)
+    return out
+
+
+def validate_semantic_primal(model, x: Any, *, atol: float = 1e-8) -> SemanticPrimalValidation:
+    from solverpilot.model.model import Constraint, IndicatorConstraint
+    from solverpilot.model.sets import EqualTo, GreaterThan, Interval, LessThan, PositiveSemidefiniteCone, RotatedSecondOrderCone, SecondOrderCone
+    from solverpilot.model.compiler import _variable_layout
+
+    if isinstance(atol, bool) or type(atol) not in (int, float) or not np.isfinite(float(atol)) or float(atol) < 0:
+        raise ValueError("atol must be finite and non-negative")
+    atol = float(atol)
+    offsets, n, vl, vu, domains, _ = _variable_layout(model)
+    xx = np.asarray(x, dtype=float).reshape(-1)
+    if xx.shape != (n,):
+        return SemanticPrimalValidation(False, float("inf"), (f"expected primal shape ({n},), got {xx.shape}",))
+    if not np.all(np.isfinite(xx)):
+        return SemanticPrimalValidation(False, float("inf"), ("primal solution contains NaN or infinity",))
+    violations: list[str] = []
+    max_v = 0.0
+    for i in range(n):
+        v = max(float(vl[i] - xx[i]), float(xx[i] - vu[i]), 0.0)
+        if domains[i] in {VariableDomain.INTEGER.value, VariableDomain.BINARY.value}:
+            v = max(v, abs(float(xx[i] - round(xx[i]))))
+        if v > atol:
+            violations.append(f"variable[{i}] violation={v}")
+        max_v = max(max_v, v)
+
+    def check_set(value: float, set_, label: str) -> None:
+        nonlocal max_v
+        if isinstance(set_, LessThan): v = max(0.0, value - set_.upper)
+        elif isinstance(set_, GreaterThan): v = max(0.0, set_.lower - value)
+        elif isinstance(set_, EqualTo): v = abs(value - set_.value)
+        elif isinstance(set_, Interval): v = max(0.0, set_.lower - value, value - set_.upper)
+        else: v = float("inf")
+        max_v = max(max_v, v)
+        if v > atol: violations.append(f"{label} violation={v}")
+
+    for constraint in model.constraints:
+        if isinstance(constraint, Constraint):
+            arr = np.asarray(_eval_expr(model, constraint.function._node, xx), dtype=float)
+            if isinstance(constraint.set, SecondOrderCone):
+                y = arr.reshape(-1); t = float(y[0]); norm = float(np.linalg.norm(y[1:])); v = max(0.0, norm - t)
+                max_v = max(max_v, v)
+                if v > atol: violations.append(f"constraint {constraint.entity_id.value} SOC violation={v}")
+                continue
+            if isinstance(constraint.set, RotatedSecondOrderCone):
+                y = arr.reshape(-1); u = float(y[0]); vv = float(y[1]); norm2 = float(np.dot(y[2:], y[2:])); v = max(0.0, -u, -vv, norm2 - 2.0*u*vv)
+                max_v = max(max_v, v)
+                if v > atol: violations.append(f"constraint {constraint.entity_id.value} rotated-SOC violation={v}")
+                continue
+            if isinstance(constraint.set, PositiveSemidefiniteCone):
+                M = arr.reshape(constraint.set.dimension, constraint.set.dimension)
+                asym = float(np.max(np.abs(M-M.T))) if M.size else 0.0
+                eigmin = float(np.linalg.eigvalsh(0.5*(M+M.T))[0]) if M.size else 0.0
+                v = max(asym, max(0.0, -eigmin))
+                max_v = max(max_v, v)
+                if v > atol: violations.append(f"constraint {constraint.entity_id.value} PSD violation={v}")
+                continue
+            vals = arr.reshape(-1) if arr.shape else np.asarray([float(arr)])
+            for k, value in enumerate(vals):
+                check_set(float(value), constraint.set, f"constraint {constraint.entity_id.value}[{k}]")
+        elif isinstance(constraint, IndicatorConstraint):
+            start, end = offsets[constraint.indicator.id.value]
+            if end - start != 1:
+                violations.append(f"indicator {constraint.entity_id.value} is not scalar")
+                max_v = float("inf")
+                continue
+            z = int(round(float(xx[start])))
+            if z == constraint.active_value:
+                value = float(np.asarray(_eval_expr(model, constraint.function._node, xx)))
+                check_set(value, constraint.set, f"indicator {constraint.entity_id.value}")
+    return SemanticPrimalValidation(not violations, max_v, tuple(violations))

solverpilot/capabilities/__init__.py

@@ -0,0 +1,32 @@
+from .enums import Capability, SupportLevel
+from .manifest import BackendManifest
+from .requirements import CapabilityRequirements, compatible, requirements_for
+
+__all__ = [
+    "BackendManifest",
+    "Capability",
+    "CapabilityRequirements",
+    "SupportLevel",
+    "compatible",
+    "requirements_for",
+]
+
+from .v2 import (
+    CAPABILITY_SCHEMA_VERSION, BackendCapabilityManifestV2, CapabilityCheck, CapabilityClaim,
+    CapabilityEvidence, CapabilityKey, CapabilityMode, CapabilityStatus, VerificationLevel,
+    project_legacy_manifest, with_verified_claims, CapabilityRequirementsV2, requirements_v2_for, compatible_v2,
+)
+from .conformance import BackendConformanceReport, ConformanceCheck, conform_backend_problem_classes, conform_backends
+
+__all__ += [
+    "CAPABILITY_SCHEMA_VERSION", "BackendCapabilityManifestV2", "CapabilityCheck", "CapabilityClaim",
+    "CapabilityEvidence", "CapabilityKey", "CapabilityMode", "CapabilityStatus", "VerificationLevel",
+    "project_legacy_manifest", "with_verified_claims", "CapabilityRequirementsV2", "requirements_v2_for", "compatible_v2", "BackendConformanceReport", "ConformanceCheck",
+    "conform_backend_problem_classes", "conform_backends",
+]
+
+from .resolve import BackendCapabilityProviderV2, resolve_backend_capabilities
+__all__ += ["BackendCapabilityProviderV2", "resolve_backend_capabilities"]
+
+from .ontology import ConvexityClass, IntegralityClass, ProblemClass, ProblemDescriptor, ProofRequirement, capability_requirements_for_descriptor, describe_problem
+__all__ += ["ConvexityClass","IntegralityClass","ProblemClass","ProblemDescriptor","ProofRequirement","capability_requirements_for_descriptor","describe_problem"]

solverpilot/capabilities/backend-capability-v2.schema.json

@@ -0,0 +1,21 @@
+{
+  "$id": "solverpilot.backend-capability-v2",
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "backend", "backend_version", "binding_version", "problem_classes", "incremental", "result_artifacts"],
+  "properties": {
+    "schema_version": {"const": "2.0"},
+    "backend": {"type": "string", "minLength": 1},
+    "backend_version": {"type": "string"},
+    "binding_version": {"type": "string"},
+    "problem_classes": {"type": "object", "additionalProperties": {"enum": ["unsupported", "supported", "restricted"]}},
+    "native_constraints": {"type": "object", "additionalProperties": {"enum": ["unsupported", "supported", "restricted"]}},
+    "incremental": {"type": "object", "additionalProperties": {"enum": ["unsupported", "supported", "restricted"]}},
+    "starts": {"type": "object", "additionalProperties": {"enum": ["unsupported", "supported", "restricted"]}},
+    "callbacks": {"type": "object", "additionalProperties": {"enum": ["unsupported", "supported", "restricted"]}},
+    "result_artifacts": {"type": "object", "additionalProperties": {"enum": ["unsupported", "supported", "restricted"]}},
+    "restrictions": {"type": "object"},
+    "verified_on": {"type": "object"}
+  }
+}

solverpilot/capabilities/conformance.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import date
+import importlib.metadata
+from typing import Iterable
+
+from solverpilot.backends.health import BackendProbeStatus, probe_backend
+
+from .v2 import (
+    BackendCapabilityManifestV2,
+    CapabilityEvidence,
+    CapabilityKey,
+    project_legacy_manifest,
+    with_verified_claims,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class ConformanceCheck:
+    capability: CapabilityKey
+    passed: bool
+    evidence_id: str
+    detail: str
+
+
+@dataclass(frozen=True, slots=True)
+class BackendConformanceReport:
+    backend: str
+    available: bool
+    checks: tuple[ConformanceCheck, ...]
+    manifest: BackendCapabilityManifestV2
+
+    @property
+    def passed(self) -> bool:
+        return self.available and all(check.passed for check in self.checks)
+
+
+def _package_version(name: str) -> str | None:
+    try:
+        return importlib.metadata.version(name)
+    except importlib.metadata.PackageNotFoundError:
+        return None
+
+
+def _binding_identity(backend) -> tuple[str, str | None]:
+    module = type(backend).__module__
+    if module.startswith("solverpilot.backends.scipy_"):
+        return "scipy", _package_version("scipy")
+    if module.endswith("nlopt_native"):
+        return "nlopt", _package_version("nlopt")
+    if module.endswith("osqp_native"):
+        return "osqp", _package_version("osqp")
+    if module.endswith("highspy_native"):
+        return "highspy", _package_version("highspy")
+    if module.endswith("pyscipopt_native"):
+        return "pyscipopt", _package_version("pyscipopt")
+    if module.endswith("casadi_conic") or module.endswith("bundled_capi"):
+        return "casadi", _package_version("casadi")
+    return module, None
+
+
+def _adapter_version() -> str | None:
+    # Prefer the imported source version so source-tree conformance cannot silently bind
+    # evidence to an older wheel installed in the same environment.
+    try:
+        import solverpilot
+        return solverpilot.__version__
+    except Exception:
+        return _package_version("solverpilot")
+
+
+def conform_backend_problem_classes(backend) -> BackendConformanceReport:
+    """Verify currently exposed solve/result channels against native smoke problems.
+
+    P3 deliberately verifies only what the current adapter surface can exercise without
+    inventing a new stateful/callback API. Advanced legacy declarations remain projected
+    and are therefore unusable by a verified-only P4 compiler until their own conformance
+    tests are added in the milestone that exposes those adapter methods.
+    """
+
+    binding, binding_version = _binding_identity(backend)
+    adapter_version = _adapter_version()
+    projected = project_legacy_manifest(
+        backend.manifest,
+        binding=binding,
+        binding_version=binding_version,
+        adapter_version=adapter_version,
+    )
+    if not backend.is_available():
+        return BackendConformanceReport(
+            backend=backend.manifest.name,
+            available=False,
+            checks=(),
+            manifest=projected,
+        )
+
+    health = probe_backend(backend)
+    verified = {}
+    checks: list[ConformanceCheck] = []
+    capability_map = {
+        "lp": CapabilityKey.PROBLEM_LP,
+        "milp": CapabilityKey.PROBLEM_MILP,
+        "convex_qp": CapabilityKey.PROBLEM_CONVEX_QP,
+    }
+    today = date.today().isoformat()
+    for check in health.checks:
+        key = capability_map.get(check.capability.value)
+        if key is None:
+            continue
+        evidence_id = f"p3.native-smoke:{backend.manifest.name}:{check.capability.value}"
+        passed = bool(check.passed and check.validation_valid)
+        checks.append(
+            ConformanceCheck(
+                capability=key,
+                passed=passed,
+                evidence_id=evidence_id,
+                detail=(
+                    "native smoke solved and original-space validation passed"
+                    if passed
+                    else f"native smoke failed: {check.error or check.backend_status}"
+                ),
+            )
+        )
+        if passed:
+            ev = CapabilityEvidence(
+                evidence_id=evidence_id,
+                kind="native_solve_validation",
+                backend_versions=(backend.manifest.version,) if backend.manifest.version else (),
+                binding_versions=(binding_version,) if binding_version else (),
+                adapter_versions=(adapter_version,) if adapter_version else (),
+                verified_on=today,
+                notes=("smoke result independently validated in canonical problem space",),
+            )
+            verified[key] = ev
+            # The current BackendSolveResult surface demonstrably returns these artifacts.
+            verified.setdefault(CapabilityKey.RESULT_PRIMAL, ev)
+            verified.setdefault(CapabilityKey.RESULT_OBJECTIVE, ev)
+            verified.setdefault(CapabilityKey.CONSTRAINT_LINEAR, ev)
+
+    manifest = with_verified_claims(projected, verified)
+    return BackendConformanceReport(
+        backend=backend.manifest.name,
+        available=True,
+        checks=tuple(checks),
+        manifest=manifest,
+    )
+
+
+def conform_backends(backends: Iterable[object]) -> tuple[BackendConformanceReport, ...]:
+    return tuple(conform_backend_problem_classes(backend) for backend in backends)

solverpilot/capabilities/enums.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from enum import Enum
+
+
+class Capability(str, Enum):
+    LP = "lp"
+    CONVEX_QP = "convex_qp"
+    MILP = "milp"
+    MIP_START = "mip_start"
+    PRIMAL_START = "primal_start"
+    DUAL_START = "dual_start"
+    BASIS_START = "basis_start"
+    SAME_SPARSITY_DATA_UPDATE = "same_sparsity_data_update"
+    STRUCTURAL_INCREMENTAL_UPDATE = "structural_incremental_update"
+    NATIVE_REOPTIMIZATION = "native_reoptimization"
+    CALLBACK_PROGRESS = "callback_progress"
+    IIS = "iis"
+    INFEASIBILITY_CERTIFICATE = "infeasibility_certificate"
+
+
+class SupportLevel(str, Enum):
+    NATIVE = "native"
+    EMULATED_SAFE = "emulated_safe"
+    EMULATED_RISKY = "emulated_risky"
+    UNSUPPORTED = "unsupported"
+    UNKNOWN = "unknown"

solverpilot/capabilities/manifest.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from .enums import Capability, SupportLevel
+
+
+@dataclass(frozen=True, slots=True)
+class BackendManifest:
+    name: str
+    version: str | None = None
+    capabilities: dict[Capability, SupportLevel] = field(default_factory=dict)
+    metadata: dict[str, object] = field(default_factory=dict)
+
+    def support(self, capability: Capability) -> SupportLevel:
+        return self.capabilities.get(capability, SupportLevel.UNKNOWN)
+
+    def supports_without_risky_emulation(self, capability: Capability) -> bool:
+        return self.support(capability) in {SupportLevel.NATIVE, SupportLevel.EMULATED_SAFE}

solverpilot/capabilities/ontology.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from enum import Enum
+from typing import Any
+
+from solverpilot.problem import ConvexityStatus, LinearProblem, QuadraticProblem
+
+
+class ProblemClass(str, Enum):
+    LP="LP"; MILP="MILP"; CONVEX_QP="CONVEX_QP"; QP_UNVERIFIED="QP_UNVERIFIED"; CONIC="CONIC"; NLP="NLP"; MINLP="MINLP"; CP="CP"; UNKNOWN="UNKNOWN"
+class ConvexityClass(str, Enum):
+    CONFIRMED_CONVEX="confirmed_convex"; CERTIFIED_CONVEX="certified_convex"; UNKNOWN="unknown"; NOT_APPLICABLE="not_applicable"
+class IntegralityClass(str, Enum):
+    CONTINUOUS="continuous"; MIXED_INTEGER="mixed_integer"; DISCRETE="discrete"; UNKNOWN="unknown"
+class ProofRequirement(str, Enum):
+    FEASIBILITY="feasibility"; OPTIMALITY="optimality"; GLOBAL_OPTIMALITY="global_optimality"
+
+
+@dataclass(frozen=True, slots=True)
+class ProblemDescriptor:
+    problem_class: ProblemClass
+    convexity: ConvexityClass
+    integrality: IntegralityClass
+    objective_family: str
+    constraint_families: tuple[str, ...]
+    proof_requirement: ProofRequirement
+    source_type: str
+    def to_dict(self) -> dict[str,Any]:
+        p=asdict(self)
+        for k in ("problem_class","convexity","integrality","proof_requirement"): p[k]=getattr(self,k).value
+        return p
+
+
+def describe_problem(problem: object) -> ProblemDescriptor:
+    if isinstance(problem,QuadraticProblem):
+        confirmed=problem.convexity_status is ConvexityStatus.CONFIRMED
+        return ProblemDescriptor(ProblemClass.CONVEX_QP if confirmed else ProblemClass.QP_UNVERIFIED,ConvexityClass.CONFIRMED_CONVEX if confirmed else ConvexityClass.UNKNOWN,IntegralityClass.CONTINUOUS,"quadratic",("linear",),ProofRequirement.OPTIMALITY,type(problem).__qualname__)
+    if isinstance(problem,LinearProblem):
+        integer=bool(problem.has_integer_variables)
+        return ProblemDescriptor(ProblemClass.MILP if integer else ProblemClass.LP,ConvexityClass.CONFIRMED_CONVEX,IntegralityClass.MIXED_INTEGER if integer else IntegralityClass.CONTINUOUS,"linear",("linear",),ProofRequirement.GLOBAL_OPTIMALITY if integer else ProofRequirement.OPTIMALITY,type(problem).__qualname__)
+    try:
+        from solverpilot.conic.ir import ConicProblem
+        if isinstance(problem,ConicProblem): return ProblemDescriptor(ProblemClass.CONIC,ConvexityClass.CONFIRMED_CONVEX,IntegralityClass.CONTINUOUS,"linear_or_conic",("affine","cone"),ProofRequirement.OPTIMALITY,type(problem).__qualname__)
+    except ImportError: pass
+    try:
+        from solverpilot.minlp.ir import MINLPProblem
+        if isinstance(problem,MINLPProblem): return ProblemDescriptor(ProblemClass.MINLP,ConvexityClass.CERTIFIED_CONVEX,IntegralityClass.MIXED_INTEGER,"nonlinear",("nonlinear","integrality"),ProofRequirement.GLOBAL_OPTIMALITY,type(problem).__qualname__)
+    except ImportError: pass
+    try:
+        from solverpilot.nlp.ir import NLPProblem
+        if isinstance(problem,NLPProblem): return ProblemDescriptor(ProblemClass.NLP,ConvexityClass.UNKNOWN,IntegralityClass.CONTINUOUS,"nonlinear",("nonlinear",),ProofRequirement.OPTIMALITY,type(problem).__qualname__)
+    except ImportError: pass
+    try:
+        from solverpilot.cp.ir import CPProblem
+        if isinstance(problem,CPProblem):
+            fam=tuple(sorted({getattr(c,"kind",type(c).__name__) for c in problem.constraints}))
+            return ProblemDescriptor(ProblemClass.CP,ConvexityClass.NOT_APPLICABLE,IntegralityClass.DISCRETE,"linear_integer_or_none",fam,ProofRequirement.GLOBAL_OPTIMALITY if problem.objective is not None else ProofRequirement.FEASIBILITY,type(problem).__qualname__)
+    except ImportError: pass
+    return ProblemDescriptor(ProblemClass.UNKNOWN,ConvexityClass.UNKNOWN,IntegralityClass.UNKNOWN,"unknown",(),ProofRequirement.FEASIBILITY,type(problem).__qualname__)
+
+
+def capability_requirements_for_descriptor(descriptor: ProblemDescriptor):
+    from .v2 import CapabilityKey, CapabilityRequirementsV2
+    mapping={ProblemClass.LP:CapabilityKey.PROBLEM_LP,ProblemClass.MILP:CapabilityKey.PROBLEM_MILP,ProblemClass.CONVEX_QP:CapabilityKey.PROBLEM_CONVEX_QP,ProblemClass.CONIC:CapabilityKey.PROBLEM_CONIC,ProblemClass.NLP:CapabilityKey.PROBLEM_NLP,ProblemClass.MINLP:CapabilityKey.PROBLEM_MINLP,ProblemClass.CP:CapabilityKey.PROBLEM_CP}
+    if descriptor.problem_class is ProblemClass.QP_UNVERIFIED: raise ValueError("unverified QP cannot be mapped to a verified convex-QP capability")
+    key=mapping.get(descriptor.problem_class)
+    if key is None: raise ValueError(f"no capability mapping for problem class {descriptor.problem_class.value}")
+    keys=[key]
+    family_map={"linear":CapabilityKey.CONSTRAINT_LINEAR,"nonlinear":CapabilityKey.CONSTRAINT_NONLINEAR,"all_different":CapabilityKey.CONSTRAINT_ALL_DIFFERENT,"exactly_one":CapabilityKey.CONSTRAINT_EXACTLY_ONE,"table":CapabilityKey.CONSTRAINT_TABLE,"element":CapabilityKey.CONSTRAINT_ELEMENT,"circuit":CapabilityKey.CONSTRAINT_CIRCUIT,"no_overlap":CapabilityKey.CONSTRAINT_NO_OVERLAP,"cumulative":CapabilityKey.CONSTRAINT_CUMULATIVE}
+    for family in descriptor.constraint_families:
+        if family in family_map: keys.append(family_map[family])
+    return CapabilityRequirementsV2(tuple(dict.fromkeys(keys)))

solverpilot/capabilities/requirements.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from solverpilot.problem import ConvexityStatus, LinearProblem, QuadraticProblem
+
+from .enums import Capability, SupportLevel
+from .manifest import BackendManifest
+
+
+@dataclass(frozen=True, slots=True)
+class CapabilityRequirements:
+    required: frozenset[Capability]
+
+
+def requirements_for(problem: LinearProblem | QuadraticProblem) -> CapabilityRequirements:
+    if isinstance(problem, QuadraticProblem):
+        if problem.convexity_status is not ConvexityStatus.CONFIRMED:
+            raise ValueError("unverified quadratic problem cannot be routed as convex_qp")
+        return CapabilityRequirements(frozenset({Capability.CONVEX_QP}))
+    if isinstance(problem, LinearProblem):
+        return CapabilityRequirements(
+            frozenset({Capability.MILP if problem.has_integer_variables else Capability.LP})
+        )
+    raise TypeError(f"unsupported problem type: {type(problem)!r}")
+
+
+def compatible(
+    manifest: BackendManifest,
+    requirements: CapabilityRequirements,
+    *,
+    allow_risky_emulation: bool = False,
+) -> bool:
+    allowed = {SupportLevel.NATIVE, SupportLevel.EMULATED_SAFE}
+    if allow_risky_emulation:
+        allowed.add(SupportLevel.EMULATED_RISKY)
+    return all(manifest.support(cap) in allowed for cap in requirements.required)

solverpilot/capabilities/resolve.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+from .conformance import conform_backend_problem_classes
+from .v2 import BackendCapabilityManifestV2, project_legacy_manifest
+
+
+@runtime_checkable
+class BackendCapabilityProviderV2(Protocol):
+    @property
+    def capability_manifest_v2(self) -> BackendCapabilityManifestV2: ...
+
+
+def resolve_backend_capabilities(backend, *, verify: bool = False) -> BackendCapabilityManifestV2:
+    """Resolve a backend's v2 manifest without upgrading unverified declarations.
+
+    Future adapters may expose an explicit ``capability_manifest_v2``. Current Track-M
+    adapters are projected conservatively from v1. ``verify=True`` runs the P3 native
+    problem-class conformance kit and upgrades only claims directly exercised by it.
+    """
+    explicit = getattr(backend, "capability_manifest_v2", None)
+    if explicit is not None:
+        manifest = explicit() if callable(explicit) else explicit
+        if not isinstance(manifest, BackendCapabilityManifestV2):
+            raise TypeError("capability_manifest_v2 must be BackendCapabilityManifestV2")
+        return manifest
+    if verify:
+        return conform_backend_problem_classes(backend).manifest
+    return project_legacy_manifest(backend.manifest)