solverpilot 0.1__py3-none-any.whl

solverpilot/benchmark/verify.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, asdict
+import json
+from pathlib import Path
+
+from solverpilot.evaluation import parse_miplib_solu, parse_test_manifest
+from .acquire import sha256_file
+
+_SCIENTIFIC_PROVENANCE_LEVELS = {"VERIFIED_FROZEN", "PINNED_EXTERNAL"}
+
+
+def _valid_sha256(value: object) -> bool:
+    text = str(value or "")
+    return len(text) == 64 and all(ch in "0123456789abcdefABCDEF" for ch in text)
+
+
+@dataclass(frozen=True, slots=True)
+class DatasetVerification:
+    ok: bool
+    target_dir: str
+    file_hashes_ok: bool
+    lock_integrity_ok: bool
+    manifest_entries: int | None
+    reference_records: int | None
+    instances_present: int | None
+    instances_missing: tuple[str, ...]
+    provenance_level: str
+    all_remote_inputs_pinned: bool
+    unpinned_roles: tuple[str, ...]
+    scientific_provenance_verified: bool
+    errors: tuple[str, ...]
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+
+def verify_acquired_dataset(target_dir: str | Path) -> DatasetVerification:
+    target = Path(target_dir)
+    lock_path = target / "acquisition-lock.json"
+    if not lock_path.exists():
+        raise FileNotFoundError(lock_path)
+
+    errors: list[str] = []
+    lock_integrity_ok = True
+    lock_sha_path = target / "acquisition-lock.sha256"
+    if lock_sha_path.exists():
+        parts = lock_sha_path.read_text(encoding="utf-8").strip().split()
+        expected_lock_sha = parts[0] if parts else ""
+        if not _valid_sha256(expected_lock_sha) or sha256_file(lock_path).lower() != expected_lock_sha.lower():
+            lock_integrity_ok = False
+            errors.append("acquisition lock checksum mismatch")
+
+    lock = json.loads(lock_path.read_text(encoding="utf-8"))
+    lock_schema_version = str(lock.get("schema_version") or "legacy")
+    if lock_schema_version == "2.0" and not lock_sha_path.exists():
+        lock_integrity_ok = False
+        errors.append("schema 2.0 acquisition lock is missing acquisition-lock.sha256")
+    if lock_schema_version == "2.0" and not _valid_sha256(lock.get("spec_fingerprint")):
+        errors.append("schema 2.0 acquisition lock has invalid spec_fingerprint")
+
+    provenance_level = str(lock.get("provenance_level") or "UNSPECIFIED").strip().upper()
+    hashes_ok = True
+    role_paths: dict[str, Path] = {}
+    observed_unpinned: list[str] = []
+    files = lock.get("files", [])
+    if not isinstance(files, list):
+        raise ValueError("acquisition lock files must be a list")
+
+    for item in files:
+        if not isinstance(item, dict):
+            hashes_ok = False; errors.append("invalid acquisition file record"); continue
+        role = str(item.get("role") or "")
+        path = Path(str(item.get("path") or ""))
+        if role: role_paths[role] = path
+        expected = item.get("expected_sha256")
+        if expected is None:
+            if role: observed_unpinned.append(role)
+        elif not _valid_sha256(expected):
+            hashes_ok = False; errors.append(f"invalid expected SHA-256 for role {role!r}")
+        if not path.exists():
+            hashes_ok = False; errors.append(f"missing acquired file: {path}"); continue
+        observed = sha256_file(path); recorded = item.get("sha256")
+        if not _valid_sha256(recorded) or observed.lower() != str(recorded).lower():
+            hashes_ok = False; errors.append(f"hash mismatch: {path}")
+        if expected is not None and observed.lower() != str(expected).lower():
+            hashes_ok = False; errors.append(f"expected hash mismatch: {path}")
+        if expected is not None and item.get("verified") is not True:
+            hashes_ok = False; errors.append(f"pinned role {role!r} was not recorded as verified")
+        if expected is None and item.get("verified") is True:
+            hashes_ok = False; errors.append(f"unpinned role {role!r} cannot be recorded as verified")
+
+    observed_unpinned_tuple = tuple(sorted(set(observed_unpinned)))
+    computed_all_pinned = bool(files) and not observed_unpinned_tuple
+    if lock_schema_version == "2.0":
+        recorded_unpinned = tuple(sorted(set(str(x) for x in lock.get("unpinned_roles", ()))))
+        recorded_all_pinned = bool(lock.get("all_remote_inputs_pinned", False))
+        if recorded_unpinned != observed_unpinned_tuple:
+            errors.append(f"acquisition provenance mismatch: recorded unpinned_roles={recorded_unpinned}, observed={observed_unpinned_tuple}")
+        if recorded_all_pinned != computed_all_pinned:
+            errors.append("acquisition provenance mismatch: all_remote_inputs_pinned does not match file records")
+
+    manifest_entries = reference_records = present = None
+    missing: list[str] = []
+    manifest = role_paths.get("manifest")
+    if manifest is not None and manifest.exists():
+        try:
+            filenames = parse_test_manifest(manifest.read_text(encoding="utf-8")); manifest_entries = len(filenames)
+            expected = lock.get("metadata", {}).get("benchmark_instances")
+            if expected is not None and manifest_entries != int(expected): errors.append(f"manifest count {manifest_entries} != expected {expected}")
+            instance_root = target / "instances"
+            if instance_root.exists():
+                for filename in filenames:
+                    direct = instance_root / filename
+                    if direct.exists(): continue
+                    matches = list(instance_root.rglob(filename))
+                    if len(matches) != 1: missing.append(filename)
+                present = manifest_entries - len(missing)
+        except Exception as exc:
+            errors.append(f"manifest verification failed: {type(exc).__name__}: {exc}")
+    if manifest is None and str(lock.get("spec_kind")) == "qplib":
+        instance_root = target / "instances"
+        if instance_root.exists():
+            present = len(list(instance_root.rglob("*.qplib")))
+            metadata = lock.get("metadata", {})
+            if metadata.get("continuous_instances") is not None and metadata.get("discrete_instances") is not None:
+                expected = int(metadata["continuous_instances"]) + int(metadata["discrete_instances"])
+                if present != expected: errors.append(f"QPLIB extracted count {present} != expected {expected}")
+    reference = role_paths.get("reference")
+    if reference is not None and reference.exists():
+        try:
+            refs = parse_miplib_solu(reference.read_text(encoding="utf-8")); reference_records = len(refs)
+            expected = lock.get("metadata", {}).get("solution_records")
+            if expected is not None and reference_records != int(expected): errors.append(f"reference record count {reference_records} != expected {expected}")
+        except Exception as exc:
+            errors.append(f"reference verification failed: {type(exc).__name__}: {exc}")
+
+    local_ok = lock_integrity_ok and hashes_ok and not errors and not missing
+    scientific = local_ok and computed_all_pinned and provenance_level in _SCIENTIFIC_PROVENANCE_LEVELS
+    return DatasetVerification(local_ok, str(target.resolve()), hashes_ok, lock_integrity_ok, manifest_entries,
+        reference_records, present, tuple(missing), provenance_level, computed_all_pinned,
+        observed_unpinned_tuple, scientific, tuple(errors))

solverpilot/benchmark/worker.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from time import perf_counter
+
+from solverpilot import SolveBudget, read_mps, solve
+
+from .registry import benchmark_registry
+
+
+def _trace_payload(trace) -> dict[str, object]:
+    total = float(trace.timings.total_s)
+    solve_s = float(trace.timings.solve_s)
+    return {
+        "backend_version": trace.backend_version,
+        "inspect_s": float(trace.timings.inspect_s),
+        "plan_s": float(trace.timings.plan_s),
+        "backend_build_s": float(trace.timings.backend_build_s),
+        "solve_s": solve_s,
+        "validate_s": float(trace.timings.validate_s),
+        "diagnose_s": float(trace.timings.diagnose_s),
+        "total_s": total,
+        "runtime_overhead_s": max(0.0, total - solve_s),
+        "reuse_applied": trace.reuse_applied,
+        "reuse_mode": trace.reuse_mode,
+        "planner_selected_backend": trace.planner_selected_backend,
+        "planner_evidence_level": trace.planner_evidence_level,
+    }
+
+
+def solve_file_worker(
+    *,
+    path: str | Path,
+    backend: str,
+    portfolio: tuple[str, ...],
+    time_limit_s: float | None,
+    solver_threads: int | None = None,
+) -> dict:
+    parse_t0 = perf_counter()
+    problem = read_mps(path)
+    parse_s = perf_counter() - parse_t0
+    registry = benchmark_registry(portfolio)
+    solve_t0 = perf_counter()
+    budget = None
+    if time_limit_s is not None or solver_threads is not None:
+        budget = SolveBudget(wall_time_s=time_limit_s, threads=solver_threads)
+    result = solve(
+        problem,
+        registry=registry,
+        backend=None if backend == "@auto" else backend,
+        budget=budget,
+    )
+    controller_s = perf_counter() - solve_t0
+    evidence = result.optimality_evidence
+    return {
+        "parse_s": parse_s,
+        "worker_solve_wall_s": controller_s,
+        "public_status": result.status.value,
+        "objective": result.objective,
+        "validated": None if result.validation is None else result.validation.valid,
+        "optimality_evidence": {
+            "backend_reported_optimal": evidence.backend_reported_optimal,
+            "primal_validated": evidence.primal_validated,
+            "dual_verified": evidence.dual_verified,
+            "gap_verified": evidence.gap_verified,
+            "certificate_verified": evidence.certificate_verified,
+            "independently_verified_optimal": evidence.independently_verified_optimal,
+        },
+        "trace": _trace_payload(result.trace),
+    }

solverpilot/bridges/__init__.py

@@ -0,0 +1,19 @@
+from .engine import BridgePathDecision, choose_indicator_path
+from .indicator import AffineScalar, BridgeUnavailable, IndicatorLowering, lower_indicator_big_m
+from .registry import BridgeCandidate, BridgeRegistry, BridgeSpec, default_bridge_registry
+from .types import (
+    BridgePolicy,
+    ExactnessClass,
+    MappingAvailability,
+    PreconditionCertificate,
+    TransformationStep,
+    TransformationTape,
+)
+from .validation import SemanticPrimalValidation, validate_semantic_primal
+
+__all__ = [
+    "AffineScalar", "BridgeCandidate", "BridgePathDecision", "BridgePolicy", "BridgeRegistry", "BridgeSpec", "BridgeUnavailable", "ExactnessClass",
+    "IndicatorLowering", "MappingAvailability", "PreconditionCertificate", "SemanticPrimalValidation",
+    "TransformationStep", "TransformationTape", "choose_indicator_path", "default_bridge_registry", "lower_indicator_big_m",
+    "validate_semantic_primal",
+]

solverpilot/bridges/engine.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from solverpilot.capabilities.v2 import BackendCapabilityManifestV2, CapabilityKey
+
+from .registry import default_bridge_registry
+from .types import BridgePolicy, ExactnessClass
+
+
+@dataclass(frozen=True, slots=True)
+class BridgePathDecision:
+    semantic_kind: str
+    selected_path: str
+    native_usable: bool
+    considered_paths: tuple[str, ...] = ()
+    rejected_paths: tuple[str, ...] = ()
+
+
+def choose_indicator_path(
+    capabilities: BackendCapabilityManifestV2 | None,
+    *,
+    native_transport_available: bool,
+    policy: BridgePolicy,
+) -> BridgePathDecision:
+    specs = default_bridge_registry().candidates("indicator", policy=policy)
+    considered = tuple(spec.bridge_id for spec in specs)
+    native_usable = False
+    rejected: list[str] = []
+    if capabilities is not None:
+        check = capabilities.check(CapabilityKey.CONSTRAINT_INDICATOR)
+        native_usable = check.usable
+        if check.usable and not native_transport_available:
+            rejected.append("native indicator capability verified but current execution IR has no native-indicator transport")
+        elif not check.usable:
+            rejected.append(f"native indicator path unavailable: {check.reason}")
+    else:
+        rejected.append("native indicator path unavailable: no backend capability manifest supplied")
+
+    if native_usable and native_transport_available:
+        return BridgePathDecision("indicator", "native", True, considered, tuple(rejected))
+    if not policy.permits(ExactnessClass.EXACT_EQUIVALENT):
+        raise RuntimeError("bridge policy rejects exact indicator bridge")
+    return BridgePathDecision("indicator", "certified_big_m", native_usable, considered, tuple(rejected))

solverpilot/bridges/indicator.py

@@ -0,0 +1,232 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import math
+from typing import Mapping
+
+from solverpilot.problem import VariableDomain
+
+from .types import (
+    BridgePolicy,
+    ExactnessClass,
+    MappingAvailability,
+    PreconditionCertificate,
+    TransformationStep,
+)
+
+
+class BridgeUnavailable(RuntimeError):
+    pass
+
+
+@dataclass(frozen=True, slots=True)
+class AffineScalar:
+    constant: float
+    linear: Mapping[int, float]
+
+
+@dataclass(frozen=True, slots=True)
+class IndicatorLowering:
+    rows: tuple[dict[int, float], ...]
+    lower: tuple[float, ...]
+    upper: tuple[float, ...]
+    step: TransformationStep
+
+
+def _affine_range(form: AffineScalar, lower, upper) -> tuple[float, float, list[dict[str, float | int]]]:
+    lo = float(form.constant)
+    hi = float(form.constant)
+    terms: list[dict[str, float | int]] = []
+    for index, coefficient in sorted(form.linear.items()):
+        a = float(coefficient)
+        if a == 0.0:
+            continue
+        v_lo = float(lower[index])
+        v_hi = float(upper[index])
+        need_lo = v_lo if a >= 0 else v_hi
+        need_hi = v_hi if a >= 0 else v_lo
+        if not math.isfinite(need_lo) or not math.isfinite(need_hi):
+            raise BridgeUnavailable(
+                f"cannot certify finite Big-M: variable index {index} has an infinite bound needed by affine range"
+            )
+        lo += a * need_lo
+        hi += a * need_hi
+        terms.append({"index": int(index), "coefficient": a, "lower": v_lo, "upper": v_hi})
+    return lo, hi, terms
+
+
+def _upper_row(form: AffineScalar, *, rhs: float, z_index: int, active_value: int, M: float):
+    coeffs = dict(form.linear)
+    if active_value == 1:
+        coeffs[z_index] = coeffs.get(z_index, 0.0) + M
+        upper = rhs + M - form.constant
+    else:
+        coeffs[z_index] = coeffs.get(z_index, 0.0) - M
+        upper = rhs - form.constant
+    return coeffs, -math.inf, float(upper)
+
+
+def _lower_row(form: AffineScalar, *, rhs: float, z_index: int, active_value: int, M: float):
+    coeffs = dict(form.linear)
+    if active_value == 1:
+        coeffs[z_index] = coeffs.get(z_index, 0.0) - M
+        lower = rhs - M - form.constant
+    else:
+        coeffs[z_index] = coeffs.get(z_index, 0.0) + M
+        lower = rhs - form.constant
+    return coeffs, float(lower), math.inf
+
+
+def lower_indicator_big_m(
+    *,
+    source_id: str,
+    indicator_index: int,
+    active_value: int,
+    indicator_domain: VariableDomain,
+    indicator_lower: float,
+    indicator_upper: float,
+    body: AffineScalar,
+    body_set,
+    variable_lower,
+    variable_upper,
+    parameter_dependencies: tuple[str, ...],
+    policy: BridgePolicy,
+) -> IndicatorLowering:
+    if active_value not in {0, 1}:
+        raise BridgeUnavailable("indicator active value must be 0 or 1")
+    if indicator_domain is not VariableDomain.BINARY:
+        raise BridgeUnavailable("indicator variable must be binary")
+    if indicator_lower < 0.0 or indicator_upper > 1.0:
+        raise BridgeUnavailable("indicator variable bounds must lie within [0, 1]")
+
+    # Exact simplification when the premise is fixed by variable bounds.
+    fixed = indicator_lower == indicator_upper and indicator_lower in {0.0, 1.0}
+    if fixed:
+        from solverpilot.model.sets import EqualTo, GreaterThan, Interval, LessThan
+        active = int(indicator_lower) == active_value
+        if not active:
+            cert = PreconditionCertificate(
+                "fixed-indicator-inactive",
+                {"indicator_index": indicator_index, "fixed_value": int(indicator_lower), "active_value": active_value},
+            )
+            step = TransformationStep(
+                step_id=f"{source_id}:indicator-fixed-inactive",
+                bridge_id="solverpilot.bridge.indicator.fixed",
+                bridge_version="1.0",
+                source_entity_ids=(source_id,),
+                generated_target_ids=(),
+                exactness=ExactnessClass.EXACT_EQUIVALENT,
+                preconditions=(cert,),
+                primal_mapping=MappingAvailability.IDENTITY,
+                dual_mapping=MappingAvailability.UNAVAILABLE,
+                certificate_mapping=MappingAvailability.UNAVAILABLE,
+                mutation_compatibility=("parameter_values",),
+                size_delta={"variables": 0, "constraints": -1},
+                numerical_risk={"class": "none", "reason": "no Big-M introduced"},
+                notes=("premise fixed false; semantic indicator is redundant",),
+            )
+            return IndicatorLowering((), (), (), step)
+
+        rows: list[dict[int, float]] = []
+        lo: list[float] = []
+        hi: list[float] = []
+        if isinstance(body_set, LessThan):
+            rows.append(dict(body.linear)); lo.append(-math.inf); hi.append(body_set.upper - body.constant)
+        elif isinstance(body_set, GreaterThan):
+            rows.append(dict(body.linear)); lo.append(body_set.lower - body.constant); hi.append(math.inf)
+        elif isinstance(body_set, EqualTo):
+            rows.append(dict(body.linear)); rhs = body_set.value - body.constant; lo.append(rhs); hi.append(rhs)
+        elif isinstance(body_set, Interval):
+            rows.append(dict(body.linear)); lo.append(body_set.lower - body.constant); hi.append(body_set.upper - body.constant)
+        else:
+            raise BridgeUnavailable(f"unsupported indicator body set {type(body_set).__name__}")
+        ids = tuple(f"{source_id}:row:{i}" for i in range(len(rows)))
+        cert = PreconditionCertificate(
+            "fixed-indicator-active",
+            {"indicator_index": indicator_index, "fixed_value": int(indicator_lower), "active_value": active_value},
+        )
+        step = TransformationStep(
+            step_id=f"{source_id}:indicator-fixed-active",
+            bridge_id="solverpilot.bridge.indicator.fixed",
+            bridge_version="1.0",
+            source_entity_ids=(source_id,),
+            generated_target_ids=ids,
+            exactness=ExactnessClass.EXACT_EQUIVALENT,
+            preconditions=(cert,),
+            primal_mapping=MappingAvailability.IDENTITY,
+            dual_mapping=MappingAvailability.UNAVAILABLE,
+            certificate_mapping=MappingAvailability.UNAVAILABLE,
+            mutation_compatibility=("parameter_values",),
+            size_delta={"variables": 0, "constraints": len(rows) - 1},
+            numerical_risk={"class": "none", "reason": "fixed premise materializes original affine body"},
+        )
+        return IndicatorLowering(tuple(rows), tuple(lo), tuple(hi), step)
+
+    if not policy.permits(ExactnessClass.EXACT_EQUIVALENT):
+        raise BridgeUnavailable("bridge policy rejects exact indicator lowering")
+    if policy.require_finite_certified_big_m is not True:
+        raise BridgeUnavailable("P4 safe mode requires finite certified Big-M")
+
+    from solverpilot.model.sets import EqualTo, GreaterThan, Interval, LessThan
+    body_min, body_max, bound_terms = _affine_range(body, variable_lower, variable_upper)
+    rows: list[dict[int, float]] = []
+    lo: list[float] = []
+    hi: list[float] = []
+    m_values: dict[str, float] = {}
+
+    def add_upper(rhs: float, label: str) -> None:
+        M = max(0.0, body_max - float(rhs))
+        row, l, u = _upper_row(body, rhs=float(rhs), z_index=indicator_index, active_value=active_value, M=M)
+        rows.append(row); lo.append(l); hi.append(u); m_values[label] = M
+
+    def add_lower(rhs: float, label: str) -> None:
+        M = max(0.0, float(rhs) - body_min)
+        row, l, u = _lower_row(body, rhs=float(rhs), z_index=indicator_index, active_value=active_value, M=M)
+        rows.append(row); lo.append(l); hi.append(u); m_values[label] = M
+
+    if isinstance(body_set, LessThan):
+        add_upper(body_set.upper, "upper")
+    elif isinstance(body_set, GreaterThan):
+        add_lower(body_set.lower, "lower")
+    elif isinstance(body_set, EqualTo):
+        add_lower(body_set.value, "lower"); add_upper(body_set.value, "upper")
+    elif isinstance(body_set, Interval):
+        add_lower(body_set.lower, "lower"); add_upper(body_set.upper, "upper")
+    else:
+        raise BridgeUnavailable(f"unsupported indicator body set {type(body_set).__name__}")
+
+    cert = PreconditionCertificate(
+        "certified-affine-big-m",
+        {
+            "source_id": source_id,
+            "indicator_index": indicator_index,
+            "active_value": active_value,
+            "body_min": body_min,
+            "body_max": body_max,
+            "m_values": m_values,
+            "bound_terms": bound_terms,
+            "parameter_dependencies": list(parameter_dependencies),
+        },
+    )
+    generated = tuple(f"{source_id}:bigm:{i}" for i in range(len(rows)))
+    step = TransformationStep(
+        step_id=f"{source_id}:indicator-bigm",
+        bridge_id="solverpilot.bridge.indicator.certified-big-m",
+        bridge_version="1.0",
+        source_entity_ids=(source_id,),
+        generated_target_ids=generated,
+        exactness=ExactnessClass.EXACT_EQUIVALENT,
+        preconditions=(cert,),
+        primal_mapping=MappingAvailability.IDENTITY,
+        dual_mapping=MappingAvailability.UNAVAILABLE,
+        certificate_mapping=MappingAvailability.UNAVAILABLE,
+        mutation_compatibility=("parameter_values_revalidate_certificate",),
+        size_delta={"variables": 0, "constraints": len(rows) - 1},
+        numerical_risk={
+            "class": "bound_derived_big_m",
+            "max_abs_M": max((abs(v) for v in m_values.values()), default=0.0),
+            "all_M_finite": all(math.isfinite(v) for v in m_values.values()),
+        },
+        notes=("Big-M values are derived from current finite variable bounds; no guessed constant is allowed",),
+    )
+    return IndicatorLowering(tuple(rows), tuple(lo), tuple(hi), step)

solverpilot/bridges/registry.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Callable
+
+from .types import BridgePolicy, ExactnessClass
+
+
+@dataclass(frozen=True, slots=True)
+class BridgeSpec:
+    bridge_id: str
+    bridge_version: str
+    source_kind: str
+    exactness: ExactnessClass
+    priority: int
+    description: str
+
+
+@dataclass(frozen=True, slots=True)
+class BridgeCandidate:
+    spec: BridgeSpec
+    applicable: bool
+    reason: str
+
+
+class BridgeRegistry:
+    """Small deterministic registry for P4 reformulation candidates.
+
+    The registry is intentionally evidence-free: it orders safe semantic paths by a
+    deterministic structural priority. Runtime performance evidence remains Track M's
+    responsibility and is not smuggled into P4 compilation decisions.
+    """
+
+    def __init__(self) -> None:
+        self._specs: dict[str, BridgeSpec] = {}
+
+    def register(self, spec: BridgeSpec) -> None:
+        key = f"{spec.bridge_id}@{spec.bridge_version}"
+        if key in self._specs:
+            raise ValueError(f"duplicate bridge registration {key}")
+        self._specs[key] = spec
+
+    def candidates(self, source_kind: str, *, policy: BridgePolicy) -> tuple[BridgeSpec, ...]:
+        items = [s for s in self._specs.values() if s.source_kind == source_kind and policy.permits(s.exactness)]
+        return tuple(sorted(items, key=lambda s: (s.priority, s.bridge_id, s.bridge_version)))
+
+    @property
+    def specs(self) -> tuple[BridgeSpec, ...]:
+        return tuple(sorted(self._specs.values(), key=lambda s: (s.source_kind, s.priority, s.bridge_id, s.bridge_version)))
+
+
+def default_bridge_registry() -> BridgeRegistry:
+    reg = BridgeRegistry()
+    reg.register(BridgeSpec(
+        bridge_id="solverpilot.bridge.indicator.native",
+        bridge_version="1.0",
+        source_kind="indicator",
+        exactness=ExactnessClass.EXACT_EQUIVALENT,
+        priority=0,
+        description="Preserve a native indicator constraint when both backend capability and execution transport are verified.",
+    ))
+    reg.register(BridgeSpec(
+        bridge_id="solverpilot.bridge.indicator.fixed",
+        bridge_version="1.0",
+        source_kind="indicator",
+        exactness=ExactnessClass.EXACT_EQUIVALENT,
+        priority=10,
+        description="Eliminate or materialize an indicator whose premise is fixed by certified binary bounds.",
+    ))
+    reg.register(BridgeSpec(
+        bridge_id="solverpilot.bridge.indicator.certified-big-m",
+        bridge_version="1.0",
+        source_kind="indicator",
+        exactness=ExactnessClass.EXACT_EQUIVALENT,
+        priority=20,
+        description="Lower an affine indicator with finite box-bound-derived Big-M certificates.",
+    ))
+    return reg

solverpilot/bridges/transformation-tape.schema.json

@@ -0,0 +1,53 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://solverpilot.local/schemas/transformation-tape-p4-v1.json",
+  "title": "SolverPilot P4 Transformation Tape",
+  "type": "object",
+  "required": ["schema_version", "steps"],
+  "properties": {
+    "schema_version": {"const": "solverpilot.transformation-tape.p4.v1"},
+    "steps": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "required": [
+          "step_id", "bridge_id", "bridge_version", "source_entity_ids",
+          "generated_target_ids", "exactness", "preconditions", "primal_mapping",
+          "dual_mapping", "certificate_mapping", "mutation_compatibility",
+          "size_delta", "numerical_risk", "notes"
+        ],
+        "properties": {
+          "step_id": {"type": "string", "minLength": 1},
+          "bridge_id": {"type": "string", "minLength": 1},
+          "bridge_version": {"type": "string", "minLength": 1},
+          "source_entity_ids": {"type": "array", "items": {"type": "string"}},
+          "generated_target_ids": {"type": "array", "items": {"type": "string"}},
+          "exactness": {"enum": ["exact_equivalent", "certified_relaxation", "heuristic"]},
+          "preconditions": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "required": ["kind", "payload", "certificate_version", "sha256"],
+              "properties": {
+                "kind": {"type": "string"},
+                "payload": {"type": "object"},
+                "certificate_version": {"type": "string"},
+                "sha256": {"type": "string", "pattern": "^[0-9a-f]{64}$"}
+              },
+              "additionalProperties": false
+            }
+          },
+          "primal_mapping": {"enum": ["identity", "available", "unavailable"]},
+          "dual_mapping": {"enum": ["identity", "available", "unavailable"]},
+          "certificate_mapping": {"enum": ["identity", "available", "unavailable"]},
+          "mutation_compatibility": {"type": "array", "items": {"type": "string"}},
+          "size_delta": {"type": "object", "additionalProperties": {"type": "integer"}},
+          "numerical_risk": {"type": "object"},
+          "notes": {"type": "array", "items": {"type": "string"}}
+        },
+        "additionalProperties": false
+      }
+    }
+  },
+  "additionalProperties": false
+}