scpn-studio-platform 0.1.0__py3-none-any.whl

scpn_studio_platform/__init__.py

@@ -0,0 +1,43 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Commercial license available
+# © Concepts 1996–2026 Miroslav Šotek. All rights reserved.
+# © Code 2020–2026 Miroslav Šotek. All rights reserved.
+# ORCID: 0009-0009-3560-0851
+# Contact: www.anulum.li | protoscience@anulum.li
+# SCPN Studio Platform — package root
+"""Domain-neutral SDK for the SCPN Studio ecosystem.
+
+The package implements the locked SCPN Studio v1 contract: studios build their
+domain verticals on this shared platform, and the federating Hub shell composes
+them. The platform is the open-core foundation; the managed multi-tenant Hub is
+the paid layer.
+
+Subpackages (the v1 §5 SDK surface)
+-----------------------------------
+evidence
+    The differentiator: the ``studio.*.v1`` provenance-first evidence bundle —
+    a PROV-O graph, RO-Crate-profiled, in-toto-signed, graded by an empirical
+    evidence level (0-3) and an orthogonal ``evidence_kind``
+    (measured / curated / formally-proven), with a seven-state claim-boundary
+    lattice, content-addressed cross-studio derivation, and reproducibility
+    metadata (regenerated_by + host).
+manifest
+    Content-addressed, language-agnostic, deterministic capability manifest —
+    how a studio advertises its verbs, evidence types, transport profile, and
+    federated UI module.
+verbs
+    The verb taxonomy and per-verb attribute contract (safety tier, fidelity,
+    timing, side-effect class, formal-proof block).
+identity
+    Tenant-aware opaque-identity and session primitives shared by the
+    local-first (free) and multi-tenant (paid) transport profiles.
+jobs
+    Bounded, fail-closed job and pipeline workers, with the timing/determinism
+    contract for real-time verbs.
+
+The contract this package implements is recorded internally; public API
+stability follows the era-versioned network contract plus SemVer on this package.
+"""
+
+__version__ = "0.1.0"
+__all__ = ["__version__"]

scpn_studio_platform/evidence/__init__.py

@@ -0,0 +1,64 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Commercial license available
+# © Concepts 1996–2026 Miroslav Šotek. All rights reserved.
+# © Code 2020–2026 Miroslav Šotek. All rights reserved.
+# ORCID: 0009-0009-3560-0851
+# Contact: www.anulum.li | protoscience@anulum.li
+# SCPN Studio Platform — evidence subpackage public API
+"""The provenance-first ``studio.*.v1`` evidence model (the differentiator).
+
+This subpackage implements schema B of the locked SCPN Studio v1 contract: the
+evidence bundle a studio emits for every claim, gradeable on two orthogonal axes,
+bounded by a seven-state lattice, numerically provenanced, optionally
+formally-certified, signed, and content-addressed for durable cross-studio
+derivation.
+"""
+
+from .bundle import CaseResult, EvidenceBundle
+from .claim_boundary import (
+    AdmissionDecision,
+    BlockedOn,
+    ClaimBoundary,
+    ClaimStatus,
+    FailClosedBoundary,
+)
+from .levels import EvidenceKind, EvidenceLevel, FormalCertificate
+from .numeric import Convergence, ConvergenceStatus, Exactness, NumericProvenance, ParityCheck
+from .provenance import (
+    Attestation,
+    DerivedEdge,
+    DerivedKind,
+    PhysicalContract,
+    ProvActivity,
+    ProvAgent,
+    ProvEntity,
+    RecomputeEnvironment,
+    VerifiedCitation,
+)
+
+__all__ = [
+    "AdmissionDecision",
+    "Attestation",
+    "BlockedOn",
+    "CaseResult",
+    "ClaimBoundary",
+    "ClaimStatus",
+    "Convergence",
+    "ConvergenceStatus",
+    "DerivedEdge",
+    "DerivedKind",
+    "EvidenceBundle",
+    "EvidenceKind",
+    "EvidenceLevel",
+    "Exactness",
+    "FailClosedBoundary",
+    "FormalCertificate",
+    "NumericProvenance",
+    "ParityCheck",
+    "PhysicalContract",
+    "ProvActivity",
+    "ProvAgent",
+    "ProvEntity",
+    "RecomputeEnvironment",
+    "VerifiedCitation",
+]

scpn_studio_platform/evidence/bundle.py

@@ -0,0 +1,221 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Commercial license available
+# © Concepts 1996–2026 Miroslav Šotek. All rights reserved.
+# © Code 2020–2026 Miroslav Šotek. All rights reserved.
+# ORCID: 0009-0009-3560-0851
+# Contact: www.anulum.li | protoscience@anulum.li
+# SCPN Studio Platform — the studio.*.v1 evidence bundle (schema B)
+"""The ``studio.*.v1`` evidence bundle — the aggregate result envelope.
+
+An :class:`EvidenceBundle` composes the PROV-O graph, the evidence grading (level
++ kind + optional formal certificates), the claim boundary, the numeric
+provenance, optional per-case results, the physical contract, the recompute
+environment, verified citations, the signed attestation, and content-addressed
+derivation edges.
+
+The aggregate enforces the cross-field honesty invariants of the v1 contract:
+formally-proven evidence must carry at least one certificate; a bundle is
+renderable as "validated" only when its claim boundary is admissible. The Hub
+relies on :meth:`EvidenceBundle.renders_as_validated` so a bounded, blocked,
+roadmap, or merely-attested number is never presented as validated.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+from .claim_boundary import ClaimBoundary
+from .levels import EvidenceKind, EvidenceLevel, FormalCertificate
+from .numeric import NumericProvenance
+from .provenance import (
+    Attestation,
+    DerivedEdge,
+    PhysicalContract,
+    ProvActivity,
+    ProvAgent,
+    ProvEntity,
+    RecomputeEnvironment,
+    VerifiedCitation,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class CaseResult:
+    """One row of a per-case coverage map.
+
+    A battery of probes (operation family x dimension) must not be flattened to a
+    single number; each case keeps its own status and error so the coverage map
+    survives into the bundle.
+
+    Parameters
+    ----------
+    operation_family
+        The operation family, e.g. ``"GS-solve"``.
+    dimension
+        The case dimension/size.
+    status
+        The per-case claim status value.
+    error
+        The per-case error, if applicable.
+    """
+
+    operation_family: str
+    dimension: int
+    status: str
+    error: float | None = None
+
+    def __post_init__(self) -> None:
+        """Validate the family name."""
+        if not self.operation_family.strip():
+            raise ValueError("CaseResult.operation_family must be non-empty")
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return the JSON-serialisable mapping."""
+        out: dict[str, Any] = {
+            "operation_family": self.operation_family,
+            "dimension": self.dimension,
+            "status": self.status,
+        }
+        if self.error is not None:
+            out["error"] = self.error
+        return out
+
+
+@dataclass(frozen=True, slots=True)
+class EvidenceBundle:
+    """A ``studio.*.v1`` evidence bundle (schema B).
+
+    Parameters
+    ----------
+    schema
+        The concrete schema name, e.g. ``"studio.transport-run.v1"``.
+    entity
+        The PROV entity (result + content digest).
+    activity
+        The PROV activity that produced it.
+    agent
+        The PROV agent responsible.
+    evidence_level
+        The empirical completeness level (0-3).
+    evidence_kind
+        The orthogonal modality (measured / curated / formally-proven).
+    claim_boundary
+        The claim's boundary on the seven-state lattice.
+    numeric_provenance
+        How the number was produced and checked, if numeric.
+    attestation
+        The signed in-toto attestation, if present.
+    formal_certificates
+        Machine-checked proof certificates; required when ``evidence_kind`` is
+        formally-proven, forbidden otherwise.
+    cases
+        Per-case coverage rows.
+    physical_contract
+        Units/grid/timestep for a physical result.
+    recompute_environment
+        External toolchain needed to recompute the result.
+    verified_citations
+        Verified-at-source citations.
+    derived_from
+        Content-addressed (and/or coordination) derivation edges.
+    ro_crate_profile
+        The RO-Crate profile the bundle conforms to.
+
+    Raises
+    ------
+    ValueError
+        If the schema is malformed, or the evidence-kind/certificate invariant is
+        violated.
+    """
+
+    schema: str
+    entity: ProvEntity
+    activity: ProvActivity
+    agent: ProvAgent
+    evidence_level: EvidenceLevel
+    evidence_kind: EvidenceKind
+    claim_boundary: ClaimBoundary
+    numeric_provenance: NumericProvenance | None = None
+    attestation: Attestation | None = None
+    formal_certificates: tuple[FormalCertificate, ...] = field(default_factory=tuple)
+    cases: tuple[CaseResult, ...] = field(default_factory=tuple)
+    physical_contract: PhysicalContract | None = None
+    recompute_environment: RecomputeEnvironment | None = None
+    verified_citations: tuple[VerifiedCitation, ...] = field(default_factory=tuple)
+    derived_from: tuple[DerivedEdge, ...] = field(default_factory=tuple)
+    ro_crate_profile: str = "scpn-studio/0.1"
+
+    def __post_init__(self) -> None:
+        """Validate the schema name and the evidence-kind/certificate invariant."""
+        if not self.schema.endswith(".v1"):
+            raise ValueError(f"schema must be a versioned 'studio.*.v1' name, got {self.schema!r}")
+        proven = self.evidence_kind is EvidenceKind.FORMALLY_PROVEN
+        if proven and not self.formal_certificates:
+            raise ValueError("evidence_kind formally-proven requires at least one formal_certificate")
+        if not proven and self.formal_certificates:
+            raise ValueError("formal_certificate is only valid when evidence_kind is formally-proven")
+
+    @property
+    def renders_as_validated(self) -> bool:
+        """Whether the Hub may present this bundle as a validated claim.
+
+        Returns
+        -------
+        bool
+            ``True`` only when the claim boundary is admissible. A bounded,
+            blocked, roadmap, or merely-attested bundle returns ``False`` — the
+            Hub renders its boundary verbatim instead.
+        """
+        return self.claim_boundary.is_admissible
+
+    def proof_voided_by(self, live_subject_digest: str) -> bool:
+        """Whether a formal proof is voided by drift of its subject.
+
+        Parameters
+        ----------
+        live_subject_digest
+            SHA-256 of the subject as it currently is.
+
+        Returns
+        -------
+        bool
+            ``True`` if the bundle is formally-proven and at least one certificate
+            no longer covers the live subject; ``False`` otherwise (including for
+            non-proven bundles).
+        """
+        if self.evidence_kind is not EvidenceKind.FORMALLY_PROVEN:
+            return False
+        return any(not cert.covers(live_subject_digest) for cert in self.formal_certificates)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return the full JSON-serialisable schema-B mapping."""
+        out: dict[str, Any] = {
+            "schema": self.schema,
+            "ro_crate_profile": self.ro_crate_profile,
+            "prov": {
+                "entity": self.entity.to_dict(),
+                "activity": self.activity.to_dict(),
+                "agent": self.agent.to_dict(),
+            },
+            "scpn_evidence_level": int(self.evidence_level),
+            "evidence_kind": self.evidence_kind.value,
+            "claim_boundary": self.claim_boundary.to_dict(),
+        }
+        if self.numeric_provenance is not None:
+            out["numeric_provenance"] = self.numeric_provenance.to_dict()
+        if self.formal_certificates:
+            out["formal_certificate"] = [c.to_dict() for c in self.formal_certificates]
+        if self.cases:
+            out["cases"] = [c.to_dict() for c in self.cases]
+        if self.physical_contract is not None:
+            out["physical_contract"] = self.physical_contract.to_dict()
+        if self.recompute_environment is not None:
+            out["recompute_environment"] = self.recompute_environment.to_dict()
+        if self.verified_citations:
+            out["verified_citations"] = [c.to_dict() for c in self.verified_citations]
+        if self.attestation is not None:
+            out["attestation"] = self.attestation.to_dict()
+        if self.derived_from:
+            out["derived_from"] = [d.to_dict() for d in self.derived_from]
+        return out

scpn_studio_platform/evidence/claim_boundary.py

@@ -0,0 +1,188 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Commercial license available
+# © Concepts 1996–2026 Miroslav Šotek. All rights reserved.
+# © Code 2020–2026 Miroslav Šotek. All rights reserved.
+# ORCID: 0009-0009-3560-0851
+# Contact: www.anulum.li | protoscience@anulum.li
+# SCPN Studio Platform — claim-boundary lattice (honesty-as-product)
+"""The seven-state claim-boundary lattice.
+
+A number can be fully tool-backed yet still not admissible as a facility-grade
+claim. The lattice makes that distinction first-class so the Hub renders a claim's
+boundary verbatim and never upgrades a bounded, blocked, roadmap, or gated number
+to "validated". This is the honesty-as-product surface.
+
+The seven states were contributed by the fleet teardown: the empirical four
+(reference-validated, bounded-model, validation-gap, external-dependency-blocked)
+plus ``bounded-support`` (fail-closed by design — not a defect),
+``roadmap`` (declared not-yet-built), and ``toolchain-gated`` (blocked on a
+checker/tool absent on this host). Only :data:`ClaimStatus.REFERENCE_VALIDATED`
+is admissible without qualification.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import StrEnum
+from typing import Any
+
+
+class ClaimStatus(StrEnum):
+    """The boundary state of a claim.
+
+    Attributes
+    ----------
+    REFERENCE_VALIDATED
+        Established against a trusted reference; admissible.
+    BOUNDED_MODEL
+        A reduced/approximate model within stated bounds; not facility-grade.
+    BOUNDED_SUPPORT
+        Fail-closed by design outside a supported domain (NOT a defect).
+    VALIDATION_GAP
+        Validation was attempted and is incomplete or failed.
+    EXTERNAL_DEPENDENCY_BLOCKED
+        Cannot be established because a declared external dependency is absent.
+    ROADMAP
+        Declared as planned but not yet built.
+    TOOLCHAIN_GATED
+        Blocked on a checker/tool unavailable on this host.
+    """
+
+    REFERENCE_VALIDATED = "reference-validated"
+    BOUNDED_MODEL = "bounded-model"
+    BOUNDED_SUPPORT = "bounded-support"
+    VALIDATION_GAP = "validation-gap"
+    EXTERNAL_DEPENDENCY_BLOCKED = "external-dependency-blocked"
+    ROADMAP = "roadmap"
+    TOOLCHAIN_GATED = "toolchain-gated"
+
+    @property
+    def is_admissible(self) -> bool:
+        """Whether a claim in this state may be presented as validated.
+
+        Returns
+        -------
+        bool
+            ``True`` only for :data:`REFERENCE_VALIDATED`. Every other state is a
+            boundary the Hub must render explicitly rather than upgrade.
+        """
+        return self is ClaimStatus.REFERENCE_VALIDATED
+
+
+class AdmissionDecision(StrEnum):
+    """Whether a claim was admitted by the runtime admission gate."""
+
+    ADMITTED = "admitted"
+    REJECTED = "rejected"
+
+
+@dataclass(frozen=True, slots=True)
+class BlockedOn:
+    """A single declared dependency a claim is blocked on.
+
+    Parameters
+    ----------
+    dependency
+        Name of the missing dependency, e.g. ``"TORAX-ref"``.
+    kind
+        Category of dependency, e.g. ``"dataset"``, ``"toolchain"``, ``"hardware"``.
+    """
+
+    dependency: str
+    kind: str
+
+    def __post_init__(self) -> None:
+        """Validate non-empty fields."""
+        if not self.dependency.strip() or not self.kind.strip():
+            raise ValueError("BlockedOn.dependency and .kind must be non-empty")
+
+    def to_dict(self) -> dict[str, str]:
+        """Return the JSON-serialisable mapping."""
+        return {"dependency": self.dependency, "kind": self.kind}
+
+
+@dataclass(frozen=True, slots=True)
+class FailClosedBoundary:
+    """A fail-closed-by-design support boundary for one operation family.
+
+    Parameters
+    ----------
+    family
+        The operation family, e.g. ``"native-det"``.
+    first_unsupported_size
+        The smallest problem size at which the family deliberately fail-closes.
+    """
+
+    family: str
+    first_unsupported_size: int
+
+    def __post_init__(self) -> None:
+        """Validate the family name and the size bound."""
+        if not self.family.strip():
+            raise ValueError("FailClosedBoundary.family must be non-empty")
+        if self.first_unsupported_size < 1:
+            raise ValueError("FailClosedBoundary.first_unsupported_size must be >= 1")
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return the JSON-serialisable mapping."""
+        return {"family": self.family, "first_unsupported_size": self.first_unsupported_size}
+
+
+@dataclass(frozen=True, slots=True)
+class ClaimBoundary:
+    """The boundary of a claim: its status plus the qualifiers that explain it.
+
+    Parameters
+    ----------
+    status
+        The :class:`ClaimStatus` lattice state.
+    admission
+        The runtime admission decision for the claim.
+    certificate_ref
+        Optional reference to a runtime safety certificate that admitted the claim.
+    fail_closed_boundaries
+        Support boundaries when ``status`` is :data:`ClaimStatus.BOUNDED_SUPPORT`.
+    blocked_on
+        Declared dependencies when ``status`` is
+        :data:`ClaimStatus.EXTERNAL_DEPENDENCY_BLOCKED` or
+        :data:`ClaimStatus.TOOLCHAIN_GATED`.
+
+    Raises
+    ------
+    ValueError
+        If the qualifiers are inconsistent with the status (e.g. a blocked status
+        without any ``blocked_on`` entry, or ``blocked_on`` on an unrelated status).
+    """
+
+    status: ClaimStatus
+    admission: AdmissionDecision
+    certificate_ref: str | None = None
+    fail_closed_boundaries: tuple[FailClosedBoundary, ...] = field(default_factory=tuple)
+    blocked_on: tuple[BlockedOn, ...] = field(default_factory=tuple)
+
+    _BLOCKED_STATES = (ClaimStatus.EXTERNAL_DEPENDENCY_BLOCKED, ClaimStatus.TOOLCHAIN_GATED)
+
+    def __post_init__(self) -> None:
+        """Validate qualifier/status consistency."""
+        if self.status in self._BLOCKED_STATES and not self.blocked_on:
+            raise ValueError(f"status {self.status} requires at least one blocked_on entry")
+        if self.blocked_on and self.status not in self._BLOCKED_STATES:
+            raise ValueError(f"blocked_on is only valid for {self._BLOCKED_STATES}, not {self.status}")
+        if self.fail_closed_boundaries and self.status is not ClaimStatus.BOUNDED_SUPPORT:
+            raise ValueError("fail_closed_boundaries is only valid for status bounded-support")
+
+    @property
+    def is_admissible(self) -> bool:
+        """Whether the claim may be presented as validated (status AND admission)."""
+        return self.status.is_admissible and self.admission is AdmissionDecision.ADMITTED
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return the JSON-serialisable mapping for this boundary."""
+        out: dict[str, Any] = {"status": self.status.value, "admission": self.admission.value}
+        if self.certificate_ref is not None:
+            out["certificate"] = self.certificate_ref
+        if self.fail_closed_boundaries:
+            out["fail_closed_boundaries"] = [b.to_dict() for b in self.fail_closed_boundaries]
+        if self.blocked_on:
+            out["blocked_on"] = [b.to_dict() for b in self.blocked_on]
+        return out

scpn_studio_platform/evidence/levels.py

@@ -0,0 +1,150 @@
+# SPDX-License-Identifier: AGPL-3.0-or-later
+# Commercial license available
+# © Concepts 1996–2026 Miroslav Šotek. All rights reserved.
+# © Code 2020–2026 Miroslav Šotek. All rights reserved.
+# ORCID: 0009-0009-3560-0851
+# Contact: www.anulum.li | protoscience@anulum.li
+# SCPN Studio Platform — evidence grading: empirical level + orthogonal modality
+"""Evidence grading along two orthogonal axes.
+
+The SCPN Studio v1 contract grades evidence on two independent axes, kept
+orthogonal so that a machine-checked proof is never rendered as if it were a
+high-confidence measurement:
+
+- :class:`EvidenceLevel` — the *empirical* completeness ladder (0-3), an
+  SLSA-analogue measuring how thoroughly a claim has been established by
+  observation/curation.
+- :class:`EvidenceKind` — the *modality* of the evidence (measured, curated,
+  formally-proven). A formal proof is a different kind of evidence, not a higher
+  rung of the empirical ladder.
+
+When :class:`EvidenceKind` is ``FORMALLY_PROVEN`` the bundle carries one or more
+:class:`FormalCertificate` records. Each binds the proof artifact
+(``proof_digest``) *and* the subject it was proven against (``subject_digest``),
+so the Hub voids the proof the moment the live subject drifts from the proven one.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import IntEnum, StrEnum
+from typing import Any
+
+
+class EvidenceLevel(IntEnum):
+    """Empirical completeness of a claim (orthogonal to :class:`EvidenceKind`).
+
+    The ladder measures how thoroughly a claim is established empirically; it does
+    not encode whether the evidence is measured, curated, or proven.
+
+    Attributes
+    ----------
+    EXISTS
+        The artifact exists but is uncharacterised (level 0).
+    TAXONOMY
+        Classified/typed but not scientifically curated (level 1).
+    SCIENTIFICALLY_CURATED
+        Curated against the literature with verified provenance (level 2).
+    ENGINEERING_VERIFIED
+        Reproduced end-to-end against a reference or golden trace (level 3).
+    """
+
+    EXISTS = 0
+    TAXONOMY = 1
+    SCIENTIFICALLY_CURATED = 2
+    ENGINEERING_VERIFIED = 3
+
+
+class EvidenceKind(StrEnum):
+    """Modality of evidence — the *kind*, orthogonal to :class:`EvidenceLevel`.
+
+    Attributes
+    ----------
+    MEASURED
+        Established by execution/observation against a reference or analytic value.
+    CURATED
+        Established by literature curation with verified-at-source citations.
+    FORMALLY_PROVEN
+        Established by a machine-checked formal proof; requires at least one
+        :class:`FormalCertificate`.
+    """
+
+    MEASURED = "measured"
+    CURATED = "curated"
+    FORMALLY_PROVEN = "formally-proven"
+
+
+@dataclass(frozen=True, slots=True)
+class FormalCertificate:
+    """A single machine-checked proof certificate.
+
+    One logical theorem may carry several certificates from independent checkers
+    (for example a SymbiYosys RTL proof and a Lean re-proof of the same
+    obligation); the bundle holds them as a list so parallel independent
+    attestations of one claim are representable.
+
+    Parameters
+    ----------
+    checker
+        The proof engine, e.g. ``"lean"``, ``"z3"``, ``"symbiyosys"``,
+        ``"prism"``, ``"tla+"``.
+    checker_version
+        Exact version string of the engine, for reproducibility.
+    theorem_id
+        Identifier of the proven property/theorem.
+    proof_digest
+        SHA-256 of the proof artifact itself.
+    subject_digest
+        SHA-256 of *what was proven* (e.g. the RTL/topology). The Hub voids the
+        certificate when the live subject's digest differs from this value — the
+        load-bearing field for safety-relevant proofs.
+    non_vacuous
+        Whether the proof was checked to be non-vacuous (a vacuous cover witness
+        is worthless). Defaults to ``False`` until explicitly established.
+
+    Raises
+    ------
+    ValueError
+        If any required string field is empty.
+    """
+
+    checker: str
+    checker_version: str
+    theorem_id: str
+    proof_digest: str
+    subject_digest: str
+    non_vacuous: bool = False
+
+    def __post_init__(self) -> None:
+        """Validate that the identifying fields are non-empty."""
+        for name in ("checker", "checker_version", "theorem_id", "proof_digest", "subject_digest"):
+            if not getattr(self, name).strip():
+                raise ValueError(f"FormalCertificate.{name} must be a non-empty string")
+
+    def covers(self, live_subject_digest: str) -> bool:
+        """Return whether this certificate is valid for a live subject.
+
+        Parameters
+        ----------
+        live_subject_digest
+            SHA-256 of the subject as it currently is.
+
+        Returns
+        -------
+        bool
+            ``True`` iff the live subject matches the proven subject. A ``False``
+            result means the proof is void and the Hub must not present the claim
+            as proven.
+        """
+        return live_subject_digest == self.subject_digest
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return the JSON-serialisable mapping for this certificate."""
+        return {
+            "checker": self.checker,
+            "checker_version": self.checker_version,
+            "theorem_id": self.theorem_id,
+            "proof_digest": self.proof_digest,
+            "subject_digest": self.subject_digest,
+            "non_vacuous": self.non_vacuous,
+        }