solverpilot 0.2__tar.gz → 0.3__tar.gz

solverpilot-0.3/BACKEND-CONTRACT-V0_3_0.json

@@ -0,0 +1,43 @@
+{
+  "milestone": "RELEASE_0_3",
+  "notes": [
+    "Backend IDs remain stable across the SolverPilot pre-GitHub cleanup.",
+    "Verification-only adapters are never admitted to the default solving registry.",
+    "Availability of optional public backends remains environment-dependent.",
+    "The legacy optimind Python package is not shipped in SolverPilot 0.1.",
+    "Clarabel has a separate conic capability/conformance surface; it is not an LP/MILP registry entry.",
+    "Unified catalog includes specialized conic/NLP/CP adapters; the legacy LP/QP registry remains compatible."
+  ],
+  "package_version": "0.3",
+  "production_baseline_policy": {
+    "convex_qp": "osqp-native when available; otherwise scipy-slsqp-qp-bridge for non-proof intents",
+    "learned_lp_performance_routing": false,
+    "lp": "scipy-highs-ds",
+    "milp": "scipy-highs-bridge"
+  },
+  "schema": "solverpilot.backend_contract.v1",
+  "stable_backend_ids": {
+    "base_runtime": [
+      "scipy-highs-ds",
+      "scipy-highs-ipm",
+      "scipy-highs-bridge",
+      "scipy-slsqp-qp-bridge"
+    ],
+    "optional_public": [
+      "highspy-native",
+      "osqp-native",
+      "pyscipopt-native",
+      "nlopt-slsqp-native"
+    ],
+    "verification_only": [
+      "casadi-osqp-bridge",
+      "casadi-highs-bridge",
+      "casadi-cbc-bridge",
+      "bundled-osqp-capi",
+      "bundled-highs-capi"
+    ]
+  },
+  "optional_conic_backends": [
+    "clarabel-native"
+  ]
+}

{solverpilot-0.2 → solverpilot-0.3}/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## 0.3 — Numerical trust, sparse modeling and scenario analysis
+
+- Correct Farkas, recession and LP/QP optimality checks using domain-aware bounds and exact operations on represented binary64 coefficients. Bound free QP residuals when a conservative strong-convexity bound is available.
+- Restore OSQP defaults when optional settings are cleared, and preserve owned solver workspaces under call-local budgets.
+- Reject cross-model conic results and freeze conic, NLP and MINLP result payloads.
+- Lower affine expressions in CSR blocks, retain sparse constants and cache unchanged affine subexpressions across parameter updates.
+- Add checked convex abs/norm/Huber/log-sum-exp/quad-form graphs with semantic variable reconstruction.
+- Add bounded streaming batches, persistent restartable workers and an explicit sequential mode. Retain isolated-per-job compatibility mode.
+- Add opt-in Clarabel data reuse, iteration progress, cooperative cancellation and raw dual/slack snapshots; expose common time/tolerance controls.
+- Add a common result view, strict verified solves, a unified backend catalog and Clarabel CLI conformance.
+- Add named canonical shadow prices, parameter marginals, regular QP directional derivatives and model scaling diagnostics.
+- Add lazy independent scenario sweeps, box-robust constraints, finite-scenario minimax objectives and four transparent application templates.
+- Add opt-in JSON model/run replay with effective backend configuration, version and data-hash checks.
+- Add adversarial scale/permutation regressions, typed common API checks and a required optional-integration coverage floor.
+- Preserve the historical 78-name top-level signatures and previous release evidence.
+
 ## 0.2 — Runtime, modeling and direct conic upgrade
 
 - Serialize process start/close across concurrent batches to prevent the Windows child-handle race found during release qualification.

{solverpilot-0.2 → solverpilot-0.3}/KNOWN-LIMITATIONS.md

@@ -1,5 +1,7 @@
 # Known limitations — 0.2
 
+Version 0.3 adds checked convex atoms, sparse affine lowering, bounded streaming, sensitivity and scenarios. See the current [0.3 guide](docs/release/SOLVERPILOT-PUBLIC-DOCS-0.3.md) for guarantees and remaining scope limits.
+
 ## Numerical evidence
 
 Primal validation is independent of backend termination. Continuous LP/QP duals from SciPy LP, native HiGHS and OSQP can additionally be checked for stationarity, complementarity and numerical gap. These are tolerance-qualified checks, not exact-arithmetic proofs. MILP/global nonlinear optimality is not proved by primal feasibility. Backend-only infeasible/unbounded statuses remain claims unless a certificate is checked.

{solverpilot-0.2 → solverpilot-0.3}/MANIFEST.in

@@ -38,3 +38,8 @@ include PUBLIC-API-V0_2_0.json
 include BACKEND-CONTRACT-V0_2_0.json
 include docs/release/SOLVERPILOT-PUBLIC-DOCS-0.2.md
 include docs/release/README-CHECKLIST-0.2.md
+
+include PUBLIC-API-V0_3_0.json
+include BACKEND-CONTRACT-V0_3_0.json
+include docs/release/SOLVERPILOT-PUBLIC-DOCS-0.3.md
+include docs/release/README-CHECKLIST-0.3.md

{solverpilot-0.2 → solverpilot-0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: solverpilot
-Version: 0.2
+Version: 0.3
 Summary: Trust-aware optimization runtime for mathematical and constraint programming in Python
 Author: Amirhossein Heidari Rashtabad
 Maintainer: Amirhossein Heidari Rashtabad
@@ -78,7 +78,7 @@ Dynamic: license-file
 
 # SolverPilot
 
-> **Current version:** `0.2`. Adds configurable validation, numerical optimality checks, faster preparation, owned reoptimization sessions, bounded batch execution, modeling conveniences and a direct Clarabel conic adapter. Historical `0.1.0rc2` correctness/trust hardening remains in place.
+> **Current version:** `0.3`. Repairs scale-sensitive numerical certificates, preserves sparse model data and solver workspaces, and adds convex atoms, streaming batches, sensitivity, scenarios, robust counterparts and application templates. Historical `0.1.0rc2` correctness/trust hardening remains in place. See the [0.3 guide](docs/release/SOLVERPILOT-PUBLIC-DOCS-0.3.md) for examples and precise guarantees.
 
 SolverPilot is a **trust-aware optimization runtime and modeling layer for Python**. It combines a small matrix-first solve API for LP/MILP/convex QP with a higher-level semantic modeling system that can compile into conic, smooth nonlinear, certified convex binary MINLP, and constraint-programming execution paths.
 

solverpilot-0.3/PUBLIC-API-V0_3_0.json

@@ -0,0 +1,475 @@
+{
+  "milestone": "RELEASE_0_3",
+  "package_version": "0.3",
+  "schema": "solverpilot.public_api.v1",
+  "symbols": [
+    {
+      "module": "solverpilot.backends.base",
+      "name": "Backend",
+      "qualname": "Backend",
+      "signature": "(*args, **kwargs)"
+    },
+    {
+      "module": "solverpilot.backends.health",
+      "name": "BackendHealthReport",
+      "qualname": "BackendHealthReport",
+      "signature": "(backend: 'str', version: 'str | None', available: 'bool', status: 'BackendProbeStatus', checks: 'tuple[BackendProbeCheck, ...]', metadata: 'dict[str, object]') -> None"
+    },
+    {
+      "module": "solverpilot.capabilities.manifest",
+      "name": "BackendManifest",
+      "qualname": "BackendManifest",
+      "signature": "(name: 'str', version: 'str | None' = None, capabilities: 'dict[Capability, SupportLevel]' = <factory>, metadata: 'dict[str, object]' = <factory>) -> None"
+    },
+    {
+      "module": "solverpilot.backends.health",
+      "name": "BackendProbeCheck",
+      "qualname": "BackendProbeCheck",
+      "signature": "(capability: 'Capability', passed: 'bool', public_status: 'str | None', validation_valid: 'bool | None', objective: 'float | None', expected_objective: 'float', objective_abs_error: 'float | None', duration_s: 'float', error: 'str | None' = None) -> None"
+    },
+    {
+      "module": "solverpilot.backends.health",
+      "name": "BackendProbeStatus",
+      "qualname": "BackendProbeStatus",
+      "signature": "(*values)"
+    },
+    {
+      "module": "solverpilot.backends.registry",
+      "name": "BackendRegistry",
+      "qualname": "BackendRegistry",
+      "signature": "() -> 'None'"
+    },
+    {
+      "module": "solverpilot.backends.base",
+      "name": "BackendSolveResult",
+      "qualname": "BackendSolveResult",
+      "signature": "(backend_status: 'str', x: 'np.ndarray | None', objective_reported: 'float | None' = None, raw_statistics: 'dict[str, object] | None' = None) -> None"
+    },
+    {
+      "module": "solverpilot.exceptions",
+      "name": "BackendUnavailableError",
+      "qualname": "BackendUnavailableError",
+      "signature": null
+    },
+    {
+      "module": "solverpilot.exceptions",
+      "name": "BudgetNotSupportedError",
+      "qualname": "BudgetNotSupportedError",
+      "signature": null
+    },
+    {
+      "module": "solverpilot.plan.model",
+      "name": "CandidatePlan",
+      "qualname": "CandidatePlan",
+      "signature": "(backend: 'str', score: 'float', rationale: 'tuple[str, ...]', health_status: 'str | None' = None) -> None"
+    },
+    {
+      "module": "solverpilot.validate.result",
+      "name": "CandidateSolution",
+      "qualname": "CandidateSolution",
+      "signature": "(x: 'np.ndarray', objective_reported: 'float | None' = None) -> None"
+    },
+    {
+      "module": "solverpilot.capabilities.enums",
+      "name": "Capability",
+      "qualname": "Capability",
+      "signature": "(*values)"
+    },
+    {
+      "module": "solverpilot.exceptions",
+      "name": "CapabilityMismatchError",
+      "qualname": "CapabilityMismatchError",
+      "signature": null
+    },
+    {
+      "module": "solverpilot.capabilities.requirements",
+      "name": "CapabilityRequirements",
+      "qualname": "CapabilityRequirements",
+      "signature": "(required: 'frozenset[Capability]') -> None"
+    },
+    {
+      "module": "solverpilot.diagnose.model",
+      "name": "ConflictAtom",
+      "qualname": "ConflictAtom",
+      "signature": "(kind: 'ViolationKind', index: 'int') -> None"
+    },
+    {
+      "module": "solverpilot.diagnose.model",
+      "name": "ConflictSetResult",
+      "qualname": "ConflictSetResult",
+      "signature": "(atoms: 'tuple[ConflictAtom, ...]', irreducible: 'bool', complete: 'bool', checks: 'int', solver_status: 'str', message: 'str') -> None"
+    },
+    {
+      "module": "solverpilot.problem.enums",
+      "name": "ConvexityStatus",
+      "qualname": "ConvexityStatus",
+      "signature": "(*values)"
+    },
+    {
+      "module": "solverpilot.diagnose.model",
+      "name": "DiagnosticIssue",
+      "qualname": "DiagnosticIssue",
+      "signature": "(kind: 'ViolationKind', index: 'int', message: 'str', amount: 'float | None' = None) -> None"
+    },
+    {
+      "module": "solverpilot.inspect.fingerprint",
+      "name": "DistributionStats",
+      "qualname": "DistributionStats",
+      "signature": "(minimum: 'float', q25: 'float', median: 'float', mean: 'float', q75: 'float', maximum: 'float') -> None"
+    },
+    {
+      "module": "solverpilot.diagnose.model",
+      "name": "ElasticRelaxationResult",
+      "qualname": "ElasticRelaxationResult",
+      "signature": "(feasible: 'bool', objective: 'float | None', x: 'np.ndarray | None', violations: 'tuple[RelaxationViolation, ...]', solver_status: 'str', message: 'str') -> None"
+    },
+    {
+      "module": "solverpilot.plan.production",
+      "name": "EvidenceClass",
+      "qualname": "EvidenceClass",
+      "signature": "(*values)"
+    },
+    {
+      "module": "solverpilot.diagnose.model",
+      "name": "EvidenceKind",
+      "qualname": "EvidenceKind",
+      "signature": "(*values)"
+    },
+    {
+      "module": "solverpilot.plan.model",
+      "name": "HealthPolicy",
+      "qualname": "HealthPolicy",
+      "signature": "(*values)"
+    },
+    {
+      "module": "solverpilot.diagnose.model",
+      "name": "InfeasibilityReport",
+      "qualname": "InfeasibilityReport",
+      "signature": "(confirmed_infeasible: 'bool', static_issues: 'tuple[DiagnosticIssue, ...]', iis: 'NormalizedIISEvidence | None', elastic: 'ElasticRelaxationResult | None', conflict: 'ConflictSetResult | None', evidence_order: 'tuple[EvidenceKind, ...]', warnings: 'tuple[str, ...]' = ()) -> None"
+    },
+    {
+      "module": "solverpilot.problem.linear",
+      "name": "LinearProblem",
+      "qualname": "LinearProblem",
+      "signature": "(A: 'sparse.csr_matrix', c: 'np.ndarray', variable_lower: 'np.ndarray', variable_upper: 'np.ndarray', constraint_lower: 'np.ndarray', constraint_upper: 'np.ndarray', domains: 'np.ndarray', objective_sense: 'ObjectiveSense' = <ObjectiveSense.MINIMIZE: 'minimize'>, objective_offset: 'float' = 0.0, name: 'str | None' = None, metadata: 'dict[str, object]' = <factory>) -> None"
+    },
+    {
+      "module": "solverpilot.problem.mps",
+      "name": "MPSParseError",
+      "qualname": "MPSParseError",
+      "signature": null
+    },
+    {
+      "module": "solverpilot.problem.mps",
+      "name": "MPSUnsupportedFeatureError",
+      "qualname": "MPSUnsupportedFeatureError",
+      "signature": null
+    },
+    {
+      "module": "solverpilot.session.mutations",
+      "name": "MutationKind",
+      "qualname": "MutationKind",
+      "signature": "(*values)"
+    },
+    {
+      "module": "solverpilot.session.mutations",
+      "name": "MutationRecord",
+      "qualname": "MutationRecord",
+      "signature": "(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') -> None"
+    },
+    {
+      "module": "solverpilot.diagnose.model",
+      "name": "NormalizedIISEvidence",
+      "qualname": "NormalizedIISEvidence",
+      "signature": "(backend: 'str', valid: 'bool', row_indices: 'tuple[int, ...]' = (), variable_indices: 'tuple[int, ...]' = (), constraint_names: 'tuple[str, ...]' = (), variable_names: 'tuple[str, ...]' = (), irreducible: 'bool | None' = None, raw_type: 'str | None' = None) -> None"
+    },
+    {
+      "module": "solverpilot.exceptions",
+      "name": "NoCompatibleBackendError",
+      "qualname": "NoCompatibleBackendError",
+      "signature": null
+    },
+    {
+      "module": "solverpilot.problem.enums",
+      "name": "ObjectiveSense",
+      "qualname": "ObjectiveSense",
+      "signature": "(*values)"
+    },
+    {
+      "module": "solverpilot.exceptions",
+      "name": "SolverPilotError",
+      "qualname": "SolverPilotError",
+      "signature": null
+    },
+    {
+      "module": "solverpilot.exceptions",
+      "name": "UnknownBackendError",
+      "qualname": "UnknownBackendError",
+      "signature": null
+    },
+    {
+      "module": "solverpilot.plan.production",
+      "name": "PerformancePolicy",
+      "qualname": "PerformancePolicy",
+      "signature": "(*values)"
+    },
+    {
+      "module": "solverpilot.trace.schema",
+      "name": "PhaseTimings",
+      "qualname": "PhaseTimings",
+      "signature": "(inspect_s: 'float' = 0.0, plan_s: 'float' = 0.0, backend_build_s: 'float' = 0.0, solve_s: 'float' = 0.0, validate_s: 'float' = 0.0, diagnose_s: 'float' = 0.0, total_s: 'float' = 0.0, backend_update_s: 'float' = 0.0, backend_total_s: 'float' = 0.0) -> None"
+    },
+    {
+      "module": "solverpilot.plan.model",
+      "name": "PlannerContext",
+      "qualname": "PlannerContext",
+      "signature": "(previous_backend: 'str | None' = None, session_revision: 'int | None' = None) -> None"
+    },
+    {
+      "module": "solverpilot.runtime.portfolio",
+      "name": "PortfolioAttempt",
+      "qualname": "PortfolioAttempt",
+      "signature": "(backend: 'str', status: 'str | None', objective: 'float | None', validation_valid: 'bool | None', duration_s: 'float', error: 'str | None' = None, skipped_reason: 'str | None' = None) -> None"
+    },
+    {
+      "module": "solverpilot.runtime.portfolio",
+      "name": "PortfolioSolveResult",
+      "qualname": "PortfolioSolveResult",
+      "signature": "(chosen: 'SolveResult | None', attempts: 'tuple[PortfolioAttempt, ...]', total_s: 'float', stopped_reason: 'str', budget_exhausted: 'bool') -> None"
+    },
+    {
+      "module": "solverpilot.inspect.fingerprint",
+      "name": "ProblemFingerprint",
+      "qualname": "ProblemFingerprint",
+      "signature": "(problem_class: 'str', n_variables: 'int', n_constraints: 'int', nnz_a: 'int', density_a: 'float', binary_fraction: 'float', integer_fraction: 'float', equality_fraction: 'float', fully_bounded_variable_fraction: 'float', free_variable_fraction: 'float', objective_nnz_fraction: 'float', coefficient_dynamic_range_log10: 'float | None', objective_dynamic_range_log10: 'float | None', rhs_dynamic_range_log10: 'float | None', row_nnz: 'DistributionStats', col_nnz: 'DistributionStats', singleton_rows: 'int', singleton_cols: 'int', positive_coefficient_fraction: 'float', negative_coefficient_fraction: 'float', quadratic_nnz: 'int | None', quadratic_density: 'float | None', convexity_status: 'str | None', structural_hash: 'str', estimated_numeric_bytes: 'int') -> None"
+    },
+    {
+      "module": "solverpilot.plan.production",
+      "name": "ProductionDecision",
+      "qualname": "ProductionDecision",
+      "signature": "(plan: 'SolvePlan', auto_performance_ranking_enabled: 'bool', evidence: 'ProductionEvidence', conservative_baseline: 'str | None', rationale: 'tuple[str, ...]', rejected_performance_override_reason: 'str | None' = None) -> None"
+    },
+    {
+      "module": "solverpilot.plan.production",
+      "name": "ProductionEvidence",
+      "qualname": "ProductionEvidence",
+      "signature": "(evidence_class: 'EvidenceClass', source: 'str', corpus_integrity_passed: 'bool' = False, outcome_accounting_passed: 'bool' = False, independent_validation_passed: 'bool' = False, reference_crosscheck_passed: 'bool' = False, comparative_backends: 'tuple[str, ...]' = (), heldout: 'bool' = False, feature_cost_accounted: 'bool' = False, fixed_environment: 'bool' = False, public_ood: 'bool' = False, pre_registered_policy: 'bool' = False, selection_opportunity_validated: 'bool' = False, performance_ranking_validated: 'bool' = False, selector_name: 'str | None' = None, notes: 'tuple[str, ...]' = ()) -> None"
+    },
+    {
+      "module": "solverpilot.validate.result",
+      "name": "PublicStatus",
+      "qualname": "PublicStatus",
+      "signature": "(*values)"
+    },
+    {
+      "module": "solverpilot.diagnose.model",
+      "name": "RelaxationViolation",
+      "qualname": "RelaxationViolation",
+      "signature": "(kind: 'ViolationKind', index: 'int', amount: 'float', normalized_amount: 'float') -> None"
+    },
+    {
+      "module": "solverpilot.problem.quadratic",
+      "name": "QuadraticProblem",
+      "qualname": "QuadraticProblem",
+      "signature": "(linear: 'LinearProblem', P: 'sparse.csr_matrix', convexity_status: 'ConvexityStatus' = <ConvexityStatus.UNKNOWN: 'unknown'>, metadata: 'dict[str, object]' = <factory>, *, _verify_convexity: 'InitVar[bool]' = False) -> None"
+    },
+    {
+      "module": "solverpilot.session.reuse",
+      "name": "ReuseAssessment",
+      "qualname": "ReuseAssessment",
+      "signature": "(backend: 'str', considered: 'tuple[Capability, ...]', supported: 'tuple[Capability, ...]', safe_candidate: 'bool', applied: 'bool', reason: 'str') -> None"
+    },
+    {
+      "module": "solverpilot.session.session",
+      "name": "Session",
+      "qualname": "Session",
+      "signature": "(problem: 'LinearProblem | QuadraticProblem', *, registry: 'BackendRegistry | None' = None) -> 'None'"
+    },
+    {
+      "module": "solverpilot.plan.model",
+      "name": "SolveBudget",
+      "qualname": "SolveBudget",
+      "signature": "(wall_time_s: 'float | None' = None, memory_mb: 'int | None' = None, threads: 'int | None' = None) -> None"
+    },
+    {
+      "module": "solverpilot.plan.model",
+      "name": "SolveIntent",
+      "qualname": "SolveIntent",
+      "signature": "(*values)"
+    },
+    {
+      "module": "solverpilot.plan.model",
+      "name": "SolvePlan",
+      "qualname": "SolvePlan",
+      "signature": "(selected_backend: 'str', candidates: 'tuple[CandidatePlan, ...]', intent: 'SolveIntent', budget: 'SolveBudget', fingerprint: 'ProblemFingerprint', strategy: 'str', rationale: 'tuple[str, ...]', evidence_level: 'str' = 'capability_only', health_policy: 'HealthPolicy' = <HealthPolicy.IGNORE: 'ignore'>) -> None"
+    },
+    {
+      "module": "solverpilot.runtime.result",
+      "name": "SolveResult",
+      "qualname": "SolveResult",
+      "signature": "(status: 'PublicStatus', x: 'np.ndarray | None', objective: 'float | None', backend_status: 'str', validation: 'ValidationReport | None', trace: 'SolveTrace', raw_statistics: 'dict[str, object] | None' = None, plan: 'SolvePlan | None' = None, session_revision: 'int | None' = None, diagnostics: \"'InfeasibilityReport | None'\" = None) -> None"
+    },
+    {
+      "module": "solverpilot.trace.schema",
+      "name": "SolveTrace",
+      "qualname": "SolveTrace",
+      "signature": "(problem_structural_hash: 'str', problem_data_hash: 'str', problem_class: 'str', backend: 'str | None' = None, backend_version: 'str | None' = None, parameters: 'dict[str, Any]' = <factory>, fingerprint: 'dict[str, Any] | None' = None, planner_selected_backend: 'str | None' = None, planner_evidence_level: 'str | None' = None, planner_health_policy: 'str | None' = None, transformations: 'tuple[str, ...]' = (), seed: 'int | None' = None, threads: 'int | None' = None, timings: 'PhaseTimings' = <factory>, termination: 'str | None' = None, validation_valid: 'bool | None' = None, reuse_applied: 'bool | None' = None, reuse_mode: 'str | None' = None, warnings: 'tuple[str, ...]' = (), schema_version: 'str' = '0.3', created_at_utc: 'str' = <factory>) -> None"
+    },
+    {
+      "module": "solverpilot.capabilities.enums",
+      "name": "SupportLevel",
+      "qualname": "SupportLevel",
+      "signature": "(*values)"
+    },
+    {
+      "module": null,
+      "name": "TRACE_SCHEMA_VERSION",
+      "qualname": null,
+      "signature": null
+    },
+    {
+      "module": "solverpilot.validate.result",
+      "name": "ValidationReport",
+      "qualname": "ValidationReport",
+      "signature": "(valid: 'bool', max_bound_violation: 'float', max_constraint_violation: 'float', max_integrality_violation: 'float | None', objective_recomputed: 'float | None', objective_reported: 'float | None', objective_difference: 'float | None', objective_consistent: 'bool | None', warnings: 'tuple[str, ...]' = ()) -> None"
+    },
+    {
+      "module": "solverpilot.validate.result",
+      "name": "ValidationTolerances",
+      "qualname": "ValidationTolerances",
+      "signature": "(feasibility: 'float' = 1e-07, integrality: 'float' = 1e-06, objective_abs: 'float' = 1e-07, objective_rel: 'float' = 1e-07, feasibility_rel: 'float' = 1e-09) -> None"
+    },
+    {
+      "module": "solverpilot.problem.enums",
+      "name": "VariableDomain",
+      "qualname": "VariableDomain",
+      "signature": "(*values)"
+    },
+    {
+      "module": "solverpilot.diagnose.model",
+      "name": "ViolationKind",
+      "qualname": "ViolationKind",
+      "signature": "(*values)"
+    },
+    {
+      "module": "solverpilot.runtime.auto",
+      "name": "builtin_backend_candidates",
+      "qualname": "builtin_backend_candidates",
+      "signature": "() -> 'tuple[Backend, ...]'"
+    },
+    {
+      "module": "solverpilot.capabilities.requirements",
+      "name": "compatible",
+      "qualname": "compatible",
+      "signature": "(manifest: 'BackendManifest', requirements: 'CapabilityRequirements', *, allow_risky_emulation: 'bool' = False) -> 'bool'"
+    },
+    {
+      "module": "solverpilot.runtime.auto",
+      "name": "default_registry",
+      "qualname": "default_registry",
+      "signature": "() -> 'BackendRegistry'"
+    },
+    {
+      "module": "solverpilot.diagnose.infeasibility",
+      "name": "deletion_filter_conflict",
+      "qualname": "deletion_filter_conflict",
+      "signature": "(problem: 'LinearProblem', *, max_checks: 'int' = 250, time_limit_s_per_check: 'float | None' = None) -> 'ConflictSetResult'"
+    },
+    {
+      "module": "solverpilot.diagnose.infeasibility",
+      "name": "diagnose_infeasibility",
+      "qualname": "diagnose_infeasibility",
+      "signature": "(problem: 'LinearProblem', *, backend: 'Any | None' = None, include_elastic: 'bool' = True, include_conflict: 'bool' = False, conflict_max_checks: 'int' = 250, time_limit_s: 'float | None' = None) -> 'InfeasibilityReport'"
+    },
+    {
+      "module": "solverpilot.diagnose.infeasibility",
+      "name": "elastic_relaxation",
+      "qualname": "elastic_relaxation",
+      "signature": "(problem: 'LinearProblem', *, time_limit_s: 'float | None' = None, relative_weighting: 'bool' = True, violation_tol: 'float' = 1e-09) -> 'ElasticRelaxationResult'"
+    },
+    {
+      "module": "solverpilot.runtime.executor",
+      "name": "execute",
+      "qualname": "execute",
+      "signature": "(problem: 'LinearProblem | QuadraticProblem', backend: 'Backend', *, tolerances: 'ValidationTolerances | None' = None) -> 'SolveResult'"
+    },
+    {
+      "module": "solverpilot.runtime.portfolio",
+      "name": "execute_portfolio",
+      "qualname": "execute_portfolio",
+      "signature": "(problem: 'LinearProblem | QuadraticProblem', backends: 'Iterable[Backend]', *, budget: 'SolveBudget | None' = None, stop_on_valid_optimal: 'bool' = True, health_reports: 'Iterable[BackendHealthReport] | None' = None, require_healthy: 'bool' = False, tolerances: 'ValidationTolerances | None' = None) -> 'PortfolioSolveResult'"
+    },
+    {
+      "module": "solverpilot.diagnose.infeasibility",
+      "name": "find_static_infeasibility",
+      "qualname": "find_static_infeasibility",
+      "signature": "(problem: 'LinearProblem', *, atol: 'float' = 1e-12) -> 'tuple[DiagnosticIssue, ...]'"
+    },
+    {
+      "module": "solverpilot.inspect.fingerprint",
+      "name": "inspect_problem",
+      "qualname": "inspect_problem",
+      "signature": "(problem: 'LinearProblem | QuadraticProblem') -> 'ProblemFingerprint'"
+    },
+    {
+      "module": "solverpilot.problem.mps",
+      "name": "parse_mps",
+      "qualname": "parse_mps",
+      "signature": "(text: 'str') -> 'LinearProblem'"
+    },
+    {
+      "module": "solverpilot.plan.production",
+      "name": "plan_production_solve",
+      "qualname": "plan_production_solve",
+      "signature": "(problem: 'LinearProblem | QuadraticProblem', registry: 'BackendRegistry', *, evidence: 'ProductionEvidence' = ProductionEvidence(evidence_class=<EvidenceClass.CORPUS_VALIDATED: 'corpus_validated'>, source='M22 official MIPLIB/QPLIB/PACE fixed-host gate', corpus_integrity_passed=True, outcome_accounting_passed=True, independent_validation_passed=True, reference_crosscheck_passed=True, comparative_backends=(), heldout=False, feature_cost_accounted=False, fixed_environment=True, public_ood=True, pre_registered_policy=False, selection_opportunity_validated=False, performance_ranking_validated=False, selector_name=None, notes=('official-byte integrity and outcome accounting passed', 'M22 did not benchmark multiple candidate backends under a held-out comparative protocol', 'timeouts were explicit outcomes and no solver-superiority claim was made')), intent: 'SolveIntent | str' = <SolveIntent.BALANCED: 'balanced'>, budget: 'SolveBudget | None' = None, fingerprint: 'ProblemFingerprint | None' = None, context: 'PlannerContext | None' = None, health_reports: 'Iterable[BackendHealthReport] | None' = None, health_policy: 'HealthPolicy | str' = <HealthPolicy.PREFER_HEALTHY: 'prefer_healthy'>, performance_policy: 'PerformancePolicy | str' = <PerformancePolicy.REQUIRE_COMPARATIVE: 'require_comparative'>, performance_override: 'Mapping[str, str] | None' = None) -> 'ProductionDecision'"
+    },
+    {
+      "module": "solverpilot.plan.planner",
+      "name": "plan_solve",
+      "qualname": "plan_solve",
+      "signature": "(problem: 'LinearProblem | QuadraticProblem', registry: 'BackendRegistry', *, intent: 'SolveIntent | str' = <SolveIntent.BALANCED: 'balanced'>, budget: 'SolveBudget | None' = None, fingerprint: 'ProblemFingerprint | None' = None, context: 'PlannerContext | None' = None, health_reports: 'Iterable[BackendHealthReport] | None' = None, health_policy: 'HealthPolicy | str' = <HealthPolicy.IGNORE: 'ignore'>) -> 'SolvePlan'"
+    },
+    {
+      "module": "solverpilot.backends.health",
+      "name": "probe_backend",
+      "qualname": "probe_backend",
+      "signature": "(backend: 'Backend', *, atol: 'float' = 1e-06, rtol: 'float' = 1e-07) -> 'BackendHealthReport'"
+    },
+    {
+      "module": "solverpilot.backends.health",
+      "name": "probe_backends",
+      "qualname": "probe_backends",
+      "signature": "(backends: 'Iterable[Backend]', *, atol: 'float' = 1e-06, rtol: 'float' = 1e-07) -> 'tuple[BackendHealthReport, ...]'"
+    },
+    {
+      "module": "solverpilot.problem.mps",
+      "name": "read_mps",
+      "qualname": "read_mps",
+      "signature": "(path: 'str | Path') -> 'LinearProblem'"
+    },
+    {
+      "module": "solverpilot.capabilities.requirements",
+      "name": "requirements_for",
+      "qualname": "requirements_for",
+      "signature": "(problem: 'LinearProblem | QuadraticProblem') -> 'CapabilityRequirements'"
+    },
+    {
+      "module": "solverpilot.runtime.auto",
+      "name": "solve",
+      "qualname": "solve",
+      "signature": "(problem: 'LinearProblem | QuadraticProblem', *, registry: 'BackendRegistry | None' = None, backend: 'str | Backend | None' = None, intent: 'SolveIntent | str' = <SolveIntent.BALANCED: 'balanced'>, budget: 'SolveBudget | None' = None, context: 'PlannerContext | None' = None, health_reports: 'tuple[BackendHealthReport, ...] | None' = None, health_policy: 'HealthPolicy | str' = <HealthPolicy.IGNORE: 'ignore'>, diagnose_infeasible: 'bool' = False, tolerances: 'ValidationTolerances | None' = None) -> 'SolveResult'"
+    },
+    {
+      "module": "solverpilot.runtime.auto",
+      "name": "solve_production",
+      "qualname": "solve_production",
+      "signature": "(problem: 'LinearProblem | QuadraticProblem', *, registry: 'BackendRegistry | None' = None, intent: 'SolveIntent | str' = <SolveIntent.BALANCED: 'balanced'>, budget: 'SolveBudget | None' = None, context: 'PlannerContext | None' = None, health_reports: 'tuple[BackendHealthReport, ...] | None' = None, health_policy: 'HealthPolicy | str' = <HealthPolicy.PREFER_HEALTHY: 'prefer_healthy'>, evidence: 'ProductionEvidence' = ProductionEvidence(evidence_class=<EvidenceClass.CORPUS_VALIDATED: 'corpus_validated'>, source='M22 official MIPLIB/QPLIB/PACE fixed-host gate', corpus_integrity_passed=True, outcome_accounting_passed=True, independent_validation_passed=True, reference_crosscheck_passed=True, comparative_backends=(), heldout=False, feature_cost_accounted=False, fixed_environment=True, public_ood=True, pre_registered_policy=False, selection_opportunity_validated=False, performance_ranking_validated=False, selector_name=None, notes=('official-byte integrity and outcome accounting passed', 'M22 did not benchmark multiple candidate backends under a held-out comparative protocol', 'timeouts were explicit outcomes and no solver-superiority claim was made')), performance_policy: 'PerformancePolicy | str' = <PerformancePolicy.REQUIRE_COMPARATIVE: 'require_comparative'>, performance_override: 'dict[str, str] | None' = None, diagnose_infeasible: 'bool' = False, tolerances: 'ValidationTolerances | None' = None) -> 'tuple[SolveResult, ProductionDecision]'"
+    },
+    {
+      "module": "solverpilot.validate.core",
+      "name": "validate_solution",
+      "qualname": "validate_solution",
+      "signature": "(problem: 'LinearProblem | QuadraticProblem', solution: 'CandidateSolution', *, tolerances: 'ValidationTolerances | None' = None) -> 'ValidationReport'"
+    }
+  ]
+}

{solverpilot-0.2 → solverpilot-0.3}/README.md

@@ -1,6 +1,6 @@
 # SolverPilot
 
-> **Current version:** `0.2`. Adds configurable validation, numerical optimality checks, faster preparation, owned reoptimization sessions, bounded batch execution, modeling conveniences and a direct Clarabel conic adapter. Historical `0.1.0rc2` correctness/trust hardening remains in place.
+> **Current version:** `0.3`. Repairs scale-sensitive numerical certificates, preserves sparse model data and solver workspaces, and adds convex atoms, streaming batches, sensitivity, scenarios, robust counterparts and application templates. Historical `0.1.0rc2` correctness/trust hardening remains in place. See the [0.3 guide](docs/release/SOLVERPILOT-PUBLIC-DOCS-0.3.md) for examples and precise guarantees.
 
 SolverPilot is a **trust-aware optimization runtime and modeling layer for Python**. It combines a small matrix-first solve API for LP/MILP/convex QP with a higher-level semantic modeling system that can compile into conic, smooth nonlinear, certified convex binary MINLP, and constraint-programming execution paths.
 

{solverpilot-0.2 → solverpilot-0.3}/docs/api/EXTENDED-MODELING-API.md

@@ -1,5 +1,7 @@
 # SolverPilot Extended Modeling API — 0.2
 
+Version 0.3 adds checked convex atoms, sparse affine lowering, bounded streaming, sensitivity and scenarios. See the current [0.3 guide](../release/SOLVERPILOT-PUBLIC-DOCS-0.3.md) for guarantees and remaining scope limits.
+
 Track P P0–P9 is merged into SolverPilot under explicit submodule namespaces. These APIs are available in version 0.2 but are **not** added to the M30-frozen 78-symbol `solverpilot.__all__` compatibility surface yet.
 
 ## `solverpilot.model`

solverpilot-0.3/docs/release/README-CHECKLIST-0.3.md

@@ -0,0 +1,11 @@
+# SolverPilot 0.3 release gates
+
+- Keep the 78 historical top-level names/signatures compatible.
+- Pass the six 0.2 audit regressions plus scaling, KKT derivative, atom and scenario oracles.
+- Check cold/repeated compilation and process/sequential batch costs independently.
+- Run Ruff correctness rules and mypy common-API contracts.
+- Require at least 80% combined line/branch coverage in full optional-integration CI.
+- Qualify the exact wheel and sdist on the supported Python/OS/optional-backend matrix.
+- Check package metadata, `py.typed`, artifact hashes, SBOM and dependency audit.
+- Preserve 0.1 and 0.2 release artifacts and historical evidence.
+- Publish only the exact artifacts that passed external qualification.