solverpilot 0.1__py3-none-any.whl

solverpilot/session/conformance_v2.py

@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import date
+import importlib.metadata
+from typing import Any
+
+import numpy as np
+from scipy import sparse
+
+from solverpilot.capabilities import (
+    BackendCapabilityManifestV2,
+    CapabilityEvidence,
+    CapabilityKey,
+    CapabilityStatus,
+    project_legacy_manifest,
+    with_verified_claims,
+)
+from solverpilot.problem import LinearProblem, QuadraticProblem
+from solverpilot.validate import CandidateSolution, validate_solution
+
+
+@dataclass(frozen=True, slots=True)
+class PersistenceConformanceCheck:
+    capability: CapabilityKey
+    passed: bool
+    detail: str
+    evidence_id: str
+
+
+@dataclass(frozen=True, slots=True)
+class PersistenceConformanceReport:
+    backend: str
+    available: bool
+    checks: tuple[PersistenceConformanceCheck, ...]
+    manifest: BackendCapabilityManifestV2
+
+    @property
+    def passed(self) -> bool:
+        return self.available and bool(self.checks) and all(check.passed for check in self.checks)
+
+
+def _pkg(name: str) -> str | None:
+    try:
+        return importlib.metadata.version(name)
+    except importlib.metadata.PackageNotFoundError:
+        return None
+
+
+def _adapter_version() -> str | None:
+    try:
+        import solverpilot
+        return solverpilot.__version__
+    except Exception:
+        return None
+
+
+def _binding(backend) -> tuple[str, str | None]:
+    module = type(backend).__module__
+    if module.endswith("bundled_capi") or module.endswith("casadi_conic"):
+        return "casadi", _pkg("casadi")
+    if module.endswith("highspy_native"):
+        return "highspy", _pkg("highspy")
+    if module.endswith("osqp_native"):
+        return "osqp", _pkg("osqp")
+    if module.startswith("solverpilot.backends.scipy_"):
+        return "scipy", _pkg("scipy")
+    return module, None
+
+
+def _ev(backend, binding_version: str | None, key: CapabilityKey) -> CapabilityEvidence:
+    return CapabilityEvidence(
+        evidence_id=f"p5.persistence:{backend.manifest.name}:{key.value}",
+        kind="persistent_mutation_native_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=date.today().isoformat(),
+        notes=("same backend instance reused; native adapter reported reuse; candidate independently validated",),
+    )
+
+
+def _lp_base() -> LinearProblem:
+    return LinearProblem.from_data(
+        A=[[1.0, 1.0], [1.0, 0.0]], c=[1.0, 2.0],
+        variable_lower=[0.0, 0.0], variable_upper=[5.0, 5.0],
+        constraint_lower=[1.0, -np.inf], constraint_upper=[np.inf, 4.0],
+    )
+
+
+def _qp_base() -> QuadraticProblem:
+    return QuadraticProblem.from_data(
+        P=[[2.0, 0.0], [0.0, 2.0]], A=[[1.0, 1.0]], q=[-2.0, -4.0],
+        variable_lower=[-5.0, -5.0], variable_upper=[5.0, 5.0],
+        constraint_lower=[-np.inf], constraint_upper=[10.0], verify_convexity=True,
+    )
+
+
+def _variants(problem):
+    if isinstance(problem, LinearProblem):
+        yield CapabilityKey.INCREMENTAL_OBJECTIVE, LinearProblem.from_data(
+            A=problem.A, c=[2.0, 1.0], variable_lower=problem.variable_lower,
+            variable_upper=problem.variable_upper, constraint_lower=problem.constraint_lower,
+            constraint_upper=problem.constraint_upper,
+        )
+        yield CapabilityKey.INCREMENTAL_RHS, LinearProblem.from_data(
+            A=problem.A, c=problem.c, variable_lower=problem.variable_lower,
+            variable_upper=problem.variable_upper, constraint_lower=[1.5, -np.inf],
+            constraint_upper=problem.constraint_upper,
+        )
+        yield CapabilityKey.INCREMENTAL_VARIABLE_BOUNDS, LinearProblem.from_data(
+            A=problem.A, c=problem.c, variable_lower=[0.0, 0.0], variable_upper=[3.0, 5.0],
+            constraint_lower=problem.constraint_lower, constraint_upper=problem.constraint_upper,
+        )
+        A = problem.A.copy().tolil(); A[0, 0] = 1.5
+        yield CapabilityKey.INCREMENTAL_MATRIX_VALUES, LinearProblem.from_data(
+            A=A.tocsr(), c=problem.c, variable_lower=problem.variable_lower,
+            variable_upper=problem.variable_upper, constraint_lower=problem.constraint_lower,
+            constraint_upper=problem.constraint_upper,
+        )
+    else:
+        lin = problem.linear
+        yield CapabilityKey.INCREMENTAL_OBJECTIVE, QuadraticProblem.from_data(
+            P=problem.P, A=lin.A, q=[-3.0, -4.0], variable_lower=lin.variable_lower,
+            variable_upper=lin.variable_upper, constraint_lower=lin.constraint_lower,
+            constraint_upper=lin.constraint_upper, verify_convexity=True,
+        )
+        yield CapabilityKey.INCREMENTAL_RHS, QuadraticProblem.from_data(
+            P=problem.P, A=lin.A, q=lin.c, variable_lower=lin.variable_lower,
+            variable_upper=lin.variable_upper, constraint_lower=[-np.inf],
+            constraint_upper=[8.0], verify_convexity=True,
+        )
+        yield CapabilityKey.INCREMENTAL_VARIABLE_BOUNDS, QuadraticProblem.from_data(
+            P=problem.P, A=lin.A, q=lin.c, variable_lower=[-3.0, -5.0],
+            variable_upper=lin.variable_upper, constraint_lower=lin.constraint_lower,
+            constraint_upper=lin.constraint_upper, verify_convexity=True,
+        )
+        A = lin.A.copy().tolil(); A[0, 0] = 1.5
+        P = problem.P.copy().tolil(); P[0, 0] = 3.0
+        yield CapabilityKey.INCREMENTAL_MATRIX_VALUES, QuadraticProblem.from_data(
+            P=P.tocsr(), A=A.tocsr(), q=lin.c, variable_lower=lin.variable_lower,
+            variable_upper=lin.variable_upper, constraint_lower=lin.constraint_lower,
+            constraint_upper=lin.constraint_upper, verify_convexity=True,
+        )
+
+
+def conform_persistent_backend(backend) -> PersistenceConformanceReport:
+    binding, binding_version = _binding(backend)
+    base_manifest = project_legacy_manifest(
+        backend.manifest,
+        binding=binding,
+        binding_version=binding_version,
+        adapter_version=_adapter_version(),
+    )
+    if not backend.is_available():
+        return PersistenceConformanceReport(backend.manifest.name, False, (), base_manifest)
+
+    problem = None
+    if backend.manifest.name == "bundled-highs-capi":
+        problem = _lp_base()
+    elif backend.manifest.name == "bundled-osqp-capi":
+        problem = _qp_base()
+    else:
+        return PersistenceConformanceReport(backend.manifest.name, True, (), base_manifest)
+
+    checks: list[PersistenceConformanceCheck] = []
+    verified: dict[CapabilityKey, CapabilityEvidence] = {}
+    overrides: dict[CapabilityKey, CapabilityStatus] = {}
+    restriction_overrides: dict[CapabilityKey, dict[str, Any]] = {}
+
+    try:
+        first = backend.solve(problem)
+        valid0 = first.x is not None and validate_solution(
+            problem, CandidateSolution(x=first.x, objective_reported=first.objective_reported)
+        ).valid
+        cold_ok = bool(valid0 and not bool((first.raw_statistics or {}).get("reuse_applied", False)))
+        if not cold_ok:
+            return PersistenceConformanceReport(backend.manifest.name, True, (), base_manifest)
+
+        all_updates = True
+        for key, variant in _variants(problem):
+            # Rebase before each operation so every granular claim is independently exercised.
+            close = getattr(backend, "close", None)
+            if callable(close):
+                close()
+            base_result = backend.solve(problem)
+            result = backend.solve(variant)
+            raw = result.raw_statistics or {}
+            valid = result.x is not None and validate_solution(
+                variant, CandidateSolution(x=result.x, objective_reported=result.objective_reported)
+            ).valid
+            passed = bool(valid and raw.get("reuse_applied") is True)
+            if key is CapabilityKey.INCREMENTAL_MATRIX_VALUES:
+                passed = passed and (
+                    bool(raw.get("matrix_values_updated"))
+                    or int(raw.get("matrix_values_changed", 0)) > 0
+                )
+            evidence_id = f"p5.persistence:{backend.manifest.name}:{key.value}"
+            checks.append(PersistenceConformanceCheck(key, passed, "native same-instance mutation + independent validation", evidence_id))
+            all_updates = all_updates and passed
+            if passed:
+                verified[key] = _ev(backend, binding_version, key)
+                overrides[key] = CapabilityStatus.SUPPORTED
+                restriction_overrides[key] = {}
+
+        persistent_ok = all_updates
+        key = CapabilityKey.LIFECYCLE_PERSISTENT
+        checks.append(PersistenceConformanceCheck(key, persistent_ok, "same backend instance preserved across all verified numeric mutations", f"p5.persistence:{backend.manifest.name}:{key.value}"))
+        if persistent_ok:
+            verified[key] = _ev(backend, binding_version, key)
+            overrides[key] = CapabilityStatus.SUPPORTED
+            restriction_overrides[key] = {}
+
+        if backend.manifest.name == "bundled-highs-capi":
+            close = getattr(backend, "close", None)
+            if callable(close): close()
+            backend.solve(problem)
+            changed = next(v for k, v in _variants(problem) if k is CapabilityKey.INCREMENTAL_OBJECTIVE)
+            second = backend.solve(changed)
+            basis_ok = bool((second.raw_statistics or {}).get("basis_applied") is True)
+            key = CapabilityKey.START_BASIS
+            checks.append(PersistenceConformanceCheck(key, basis_ok, "captured LP basis was applied on second solve", f"p5.persistence:{backend.manifest.name}:{key.value}"))
+            if basis_ok:
+                verified[key] = _ev(backend, binding_version, key)
+                overrides[key] = CapabilityStatus.SUPPORTED
+                restriction_overrides[key] = {}
+    finally:
+        close = getattr(backend, "close", None)
+        if callable(close):
+            try: close()
+            except Exception: pass
+
+    manifest = with_verified_claims(
+        base_manifest,
+        verified,
+        status_overrides=overrides,
+        restriction_overrides=restriction_overrides,
+    )
+    return PersistenceConformanceReport(backend.manifest.name, True, tuple(checks), manifest)

solverpilot/session/mutations.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+
+import numpy as np
+from scipy import sparse
+
+from solverpilot.problem import LinearProblem, QuadraticProblem
+
+
+class MutationKind(str, Enum):
+    OBJECTIVE_VECTOR = "objective_vector"
+    OBJECTIVE_OFFSET = "objective_offset"
+    OBJECTIVE_SENSE = "objective_sense"
+    OBJECTIVE_QUADRATIC_VALUES = "objective_quadratic_values"
+    QUADRATIC_SPARSITY_CHANGED = "quadratic_sparsity_changed"
+    VARIABLE_BOUNDS = "variable_bounds"
+    CONSTRAINT_BOUNDS = "constraint_bounds"
+    MATRIX_VALUES_SAME_SPARSITY = "matrix_values_same_sparsity"
+    MATRIX_SPARSITY_CHANGED = "matrix_sparsity_changed"
+    VARIABLES_ADDED_REMOVED = "variables_added_removed"
+    CONSTRAINTS_ADDED_REMOVED = "constraints_added_removed"
+    INTEGRALITY_CHANGED = "integrality_changed"
+
+
+@dataclass(frozen=True, slots=True)
+class MutationRecord:
+    revision_before: int
+    revision_after: int
+    kinds: tuple[MutationKind, ...]
+    old_structural_hash: str
+    new_structural_hash: str
+    old_data_hash: str
+    new_data_hash: str
+
+    @property
+    def is_noop(self) -> bool:
+        return not self.kinds
+
+    @property
+    def structural_change(self) -> bool:
+        return self.old_structural_hash != self.new_structural_hash
+
+
+def _same_sparse_pattern(a: sparse.csr_matrix, b: sparse.csr_matrix) -> bool:
+    return (
+        a.shape == b.shape
+        and np.array_equal(a.indptr, b.indptr)
+        and np.array_equal(a.indices, b.indices)
+    )
+
+
+def classify_mutations(
+    old: LinearProblem | QuadraticProblem,
+    new: LinearProblem | QuadraticProblem,
+    *,
+    revision_before: int,
+    revision_after: int,
+) -> MutationRecord:
+    if type(old) is not type(new):
+        raise TypeError("session update cannot change problem class")
+
+    old_linear = old.linear if isinstance(old, QuadraticProblem) else old
+    new_linear = new.linear if isinstance(new, QuadraticProblem) else new
+    kinds: list[MutationKind] = []
+
+    if old_linear.n_variables != new_linear.n_variables:
+        kinds.append(MutationKind.VARIABLES_ADDED_REMOVED)
+    if old_linear.n_constraints != new_linear.n_constraints:
+        kinds.append(MutationKind.CONSTRAINTS_ADDED_REMOVED)
+
+    if not np.array_equal(old_linear.c, new_linear.c):
+        kinds.append(MutationKind.OBJECTIVE_VECTOR)
+    if old_linear.objective_offset != new_linear.objective_offset:
+        kinds.append(MutationKind.OBJECTIVE_OFFSET)
+    if old_linear.objective_sense != new_linear.objective_sense:
+        kinds.append(MutationKind.OBJECTIVE_SENSE)
+    if (
+        not np.array_equal(old_linear.variable_lower, new_linear.variable_lower)
+        or not np.array_equal(old_linear.variable_upper, new_linear.variable_upper)
+    ):
+        kinds.append(MutationKind.VARIABLE_BOUNDS)
+    if (
+        not np.array_equal(old_linear.constraint_lower, new_linear.constraint_lower)
+        or not np.array_equal(old_linear.constraint_upper, new_linear.constraint_upper)
+    ):
+        kinds.append(MutationKind.CONSTRAINT_BOUNDS)
+    if not np.array_equal(old_linear.domains, new_linear.domains):
+        kinds.append(MutationKind.INTEGRALITY_CHANGED)
+
+    same_a_pattern = _same_sparse_pattern(old_linear.A, new_linear.A)
+    if not same_a_pattern:
+        kinds.append(MutationKind.MATRIX_SPARSITY_CHANGED)
+    elif not np.array_equal(old_linear.A.data, new_linear.A.data):
+        kinds.append(MutationKind.MATRIX_VALUES_SAME_SPARSITY)
+
+    if isinstance(old, QuadraticProblem):
+        same_p_pattern = _same_sparse_pattern(old.P, new.P)
+        if not same_p_pattern:
+            kinds.append(MutationKind.QUADRATIC_SPARSITY_CHANGED)
+        elif not np.array_equal(old.P.data, new.P.data):
+            kinds.append(MutationKind.OBJECTIVE_QUADRATIC_VALUES)
+
+    # Keep enum order deterministic and avoid duplicates caused by broad changes.
+    deduped = tuple(dict.fromkeys(kinds))
+    return MutationRecord(
+        revision_before=revision_before,
+        revision_after=revision_after,
+        kinds=deduped,
+        old_structural_hash=old.structural_hash,
+        new_structural_hash=new.structural_hash,
+        old_data_hash=old.data_hash,
+        new_data_hash=new.data_hash,
+    )

solverpilot/session/persistent-session-trace.schema.json

@@ -0,0 +1,45 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://solverpilot.local/schemas/persistent-session-trace-v1.json",
+  "title": "SolverPilot Persistent Session Trace v1",
+  "type": "object",
+  "required": [
+    "revision", "path", "decision", "compiler_cache_status", "compile_s", "dispatch_s", "total_s",
+    "backend", "backend_reuse_applied", "backend_reset", "semantic_hash", "data_hash", "compilation_hash",
+    "transformation_count"
+  ],
+  "properties": {
+    "revision": {"type": "integer", "minimum": 0},
+    "path": {"enum": ["cold_build", "native_patch", "safe_rebuild", "full_rebuild", "no_mutation_reuse"]},
+    "decision": {
+      "type": "object",
+      "required": ["path", "reason", "mutation_kinds", "required_capabilities", "missing_capabilities"],
+      "properties": {
+        "path": {"type": "string"},
+        "reason": {"type": "string"},
+        "mutation_kinds": {"type": "array", "items": {"type": "string"}},
+        "required_capabilities": {"type": "array", "items": {"type": "string"}},
+        "missing_capabilities": {"type": "array", "items": {"type": "string"}},
+        "semantic_changed": {"type": "boolean"},
+        "execution_structure_changed": {"type": "boolean"},
+        "compilation_plan_changed": {"type": "boolean"},
+        "certificate_changed": {"type": "boolean"}
+      },
+      "additionalProperties": false
+    },
+    "compiler_cache_status": {"type": "string"},
+    "compile_s": {"type": "number", "minimum": 0},
+    "dispatch_s": {"type": "number", "minimum": 0},
+    "total_s": {"type": "number", "minimum": 0},
+    "backend": {"type": "string"},
+    "backend_reuse_applied": {"type": ["boolean", "null"]},
+    "backend_reuse_mode": {"type": ["string", "null"]},
+    "backend_reset": {"type": "boolean"},
+    "original_validation_valid": {"type": ["boolean", "null"]},
+    "semantic_hash": {"type": "string"},
+    "data_hash": {"type": "string"},
+    "compilation_hash": {"type": "string"},
+    "transformation_count": {"type": "integer", "minimum": 0}
+  },
+  "additionalProperties": false
+}