| """Build content-addressed state certificates. |
| |
| The certificate is deliberately derived only from immutable inputs: the source |
| and transformed worlds, typed program, deterministic executor results, and two |
| byte-identical renderer passes. A model response is never accepted as a label. |
| """ |
|
|
| from __future__ import annotations |
|
|
| from collections.abc import Mapping, Sequence |
| from dataclasses import dataclass |
| from functools import lru_cache |
| from typing import Any, Literal |
|
|
| from ..dsl.ast import Program, ast_node_from_dict |
| from ..executors.base import ExecutionResult |
| from ..hashing import canonical_json_hash |
| from ..paths import repo_root |
| from ..renderers.base import RenderedAssets |
| from ..schema_io import load_schema, validate |
| from ..sources.base import World |
| from ..sources.world_ops import world_sha256 |
|
|
| State = Literal["FULL", "A_SAME", "A_CHANGED", "U_MISSING", "U_INVALID"] |
|
|
|
|
| class CertificateError(ValueError): |
| """A certificate cannot be proven from the supplied artifacts.""" |
|
|
|
|
| @dataclass(frozen=True) |
| class MissingProofInputs: |
| completion_a_world_sha256: str |
| completion_b_world_sha256: str |
| completion_a_answer: str | int | bool |
| completion_b_answer: str | int | bool |
| observed_render_a_sha256: str |
| observed_render_b_sha256: str |
|
|
|
|
| def certificate_id(certificate: Mapping[str, Any]) -> str: |
| """Recompute the content address, excluding the address field itself.""" |
| payload = dict(certificate) |
| payload.pop("certificate_id", None) |
| return canonical_json_hash(payload) |
|
|
|
|
| @lru_cache(maxsize=1) |
| def _certificate_schema() -> dict[str, Any]: |
| return load_schema(repo_root() / "schemas" / "intervention_certificate.schema.json") |
|
|
|
|
| def program_from_dict(data: Mapping[str, Any]) -> Program: |
| """Rebuild a :class:`Program` from its P2 envelope.""" |
| selector = data.get("referent_selector") |
| return Program( |
| dsl=str(data["dsl"]), |
| program=ast_node_from_dict(data["program"]), |
| base_id=str(data["base_id"]), |
| question_sha256=str(data["question_sha256"]), |
| choices_sha256=str(data["choices_sha256"]), |
| compile_status=str(data["compile_status"]), |
| referent_selector=ast_node_from_dict(selector) if isinstance(selector, Mapping) else None, |
| required_referent_cardinality=data.get("required_referent_cardinality"), |
| referenced_node_ids=tuple(str(v) for v in data.get("referenced_node_ids", [])), |
| canonical_program_sha256=str(data.get("canonical_program_sha256") or ""), |
| reason_code=str(data["reason_code"]) if data.get("reason_code") is not None else None, |
| constraint_channels=tuple((str(k), str(v)) for k, v in data.get("constraint_channels", [])), |
| ) |
|
|
|
|
| def _status(value: str) -> str: |
| mapping = { |
| "UNIQUE": "unique_answer", |
| "MISSING_INFORMATION": "missing_information", |
| "INVALID_REFERENT": "invalid_referent", |
| } |
| try: |
| return mapping[value] |
| except KeyError: |
| raise CertificateError(f"executor status {value!r} cannot certify a label") from None |
|
|
|
|
| def _assert_render_replay(first: RenderedAssets, replay: RenderedAssets) -> None: |
| if first.rgba_png != replay.rgba_png: |
| raise CertificateError("RGBA render replay differs") |
| if first.node_map_png != replay.node_map_png: |
| raise CertificateError("node-map render replay differs") |
| if first.render_manifest != replay.render_manifest: |
| raise CertificateError("render manifest replay differs") |
| if first.text_manifest != replay.text_manifest: |
| raise CertificateError("text manifest replay differs") |
|
|
|
|
| def _proof( |
| state: State, |
| before: ExecutionResult, |
| after: ExecutionResult, |
| *, |
| missing: MissingProofInputs | None, |
| ) -> dict[str, Any]: |
| if state == "FULL": |
| if not before.is_unique or after.answer_canonical != before.answer_canonical: |
| raise CertificateError("FULL requires the same unique before/after answer") |
| return {"state": state, "answer": before.answer_canonical} |
| if state == "A_SAME": |
| if not before.is_unique or not after.is_unique: |
| raise CertificateError("A_SAME requires two unique answers") |
| if after.answer_canonical != before.answer_canonical: |
| raise CertificateError("A_SAME answers differ") |
| return { |
| "state": state, |
| "before_answer": before.answer_canonical, |
| "after_answer": after.answer_canonical, |
| "equality_asserted": True, |
| } |
| if state == "A_CHANGED": |
| if not before.is_unique or not after.is_unique: |
| raise CertificateError("A_CHANGED requires two unique answers") |
| if after.answer_canonical == before.answer_canonical: |
| raise CertificateError("A_CHANGED answers are equal") |
| return { |
| "state": state, |
| "before_answer": before.answer_canonical, |
| "after_answer": after.answer_canonical, |
| "inequality_asserted": True, |
| } |
| if state == "U_MISSING": |
| if after.status != "MISSING_INFORMATION": |
| raise CertificateError("U_MISSING requires MISSING_INFORMATION after execution") |
| if missing is None: |
| raise CertificateError("U_MISSING requires two completion witnesses") |
| if missing.completion_a_answer == missing.completion_b_answer: |
| raise CertificateError("U_MISSING completion answers must differ") |
| if missing.observed_render_a_sha256 != missing.observed_render_b_sha256: |
| raise CertificateError("U_MISSING completion observations must be identical") |
| return { |
| "state": state, |
| "completion_a_world_sha256": missing.completion_a_world_sha256, |
| "completion_b_world_sha256": missing.completion_b_world_sha256, |
| "completion_a_answer": missing.completion_a_answer, |
| "completion_b_answer": missing.completion_b_answer, |
| "answers_differ": True, |
| "observed_render_a_sha256": missing.observed_render_a_sha256, |
| "observed_render_b_sha256": missing.observed_render_b_sha256, |
| "observed_renders_identical": True, |
| } |
| if state == "U_INVALID": |
| if after.status != "INVALID_REFERENT": |
| raise CertificateError("U_INVALID requires INVALID_REFERENT after execution") |
| if before.referent_cardinality != 1 or after.referent_cardinality == 1: |
| raise CertificateError("U_INVALID selector cardinalities do not prove failure") |
| return { |
| "state": state, |
| "selector_cardinality_before": 1, |
| "selector_cardinality_after": int(after.referent_cardinality or 0), |
| "required_cardinality": 1, |
| "precondition_failed": True, |
| } |
| raise CertificateError(f"unknown state {state!r}") |
|
|
|
|
| def build_certificate( |
| *, |
| tier: Literal["C1_SOURCE_NATIVE", "C2_DUAL_COMPILED"], |
| base_id: str, |
| view_id: str, |
| question_sha256: str, |
| choices_sha256: str, |
| world_before: World, |
| world_after: World, |
| program: Program, |
| before_result: ExecutionResult, |
| after_result: ExecutionResult, |
| renderer_id: str, |
| renderer_version: str, |
| renderer_seed: int, |
| first_render: RenderedAssets, |
| replay_render: RenderedAssets, |
| changed_node_ids: Sequence[str], |
| diff_mask_sha256: str, |
| state: State, |
| missing_proof: MissingProofInputs | None = None, |
| reference_result: ExecutionResult | None = None, |
| c2_compilation: Mapping[str, Any] | None = None, |
| ) -> dict[str, Any]: |
| """Build and schema-validate one content-addressed certificate.""" |
| if program.compile_status != "compiled": |
| raise CertificateError("an unsupported program cannot be certified") |
| if program.base_id != base_id: |
| raise CertificateError("program/base ID mismatch") |
| if program.question_sha256 != question_sha256 or program.choices_sha256 != choices_sha256: |
| raise CertificateError("program question/choices hash mismatch") |
| if not before_result.is_unique: |
| raise CertificateError("FULL execution is not unique") |
| _assert_render_replay(first_render, replay_render) |
|
|
| selector_sha = ( |
| canonical_json_hash(program.referent_selector.to_ast_node_dict()) |
| if program.referent_selector is not None |
| else None |
| ) |
| proof = _proof(state, before_result, after_result, missing=missing_proof) |
| certificate: dict[str, Any] = { |
| "schema_version": 1, |
| "tier": tier, |
| "base_id": base_id, |
| "view_id": view_id, |
| "question_sha256": question_sha256, |
| "choices_sha256": choices_sha256, |
| "world_before_sha256": world_sha256(world_before), |
| "world_after_sha256": world_sha256(world_after), |
| "program": { |
| "language": program.dsl, |
| "canonical_ast_sha256": program.canonical_program_sha256, |
| "dependency_node_ids": list(before_result.dependency_node_ids), |
| "referent_selector_sha256": selector_sha, |
| }, |
| "executor": { |
| "name": before_result.executor_name, |
| "version": before_result.executor_version, |
| "deterministic": True, |
| "before_trace_sha256": before_result.trace_sha256, |
| "after_trace_sha256": after_result.trace_sha256, |
| "before_answer_canonical": before_result.answer_canonical, |
| "after_answer_canonical": after_result.answer_canonical, |
| "after_status": _status(after_result.status), |
| }, |
| "reference_executor": None, |
| "renderer": { |
| "name": renderer_id, |
| "version": renderer_version, |
| "seed": renderer_seed, |
| "render_manifest_sha256": canonical_json_hash(first_render.render_manifest), |
| "first_render_sha256": first_render.rgba_sha256, |
| "replay_render_sha256": replay_render.rgba_sha256, |
| "replay_exact_match": True, |
| "changed_node_ids": sorted(set(changed_node_ids)), |
| "diff_mask_sha256": diff_mask_sha256, |
| }, |
| "proof": proof, |
| "c2_compilation": dict(c2_compilation) if c2_compilation is not None else None, |
| "checks": { |
| "question_choices_unchanged": True, |
| "source_full_answer_reproduced": True, |
| "fresh_structured_render": True, |
| "pixel_scope_audit_passed": True, |
| "choice_uniqueness_passed": True, |
| "certificate_replayed": True, |
| }, |
| } |
| if reference_result is not None: |
| agrees = ( |
| reference_result.status == after_result.status |
| and reference_result.answer_canonical == after_result.answer_canonical |
| ) |
| if not agrees: |
| raise CertificateError("reference executor disagrees with primary") |
| certificate["reference_executor"] = { |
| "name": reference_result.executor_name, |
| "version": reference_result.executor_version, |
| "after_status": _status(reference_result.status), |
| "after_answer_canonical": reference_result.answer_canonical, |
| "trace_sha256": reference_result.trace_sha256, |
| "agrees_with_primary": True, |
| } |
| certificate["certificate_id"] = certificate_id(certificate) |
| errors = validate(certificate, _certificate_schema()) |
| if errors: |
| raise CertificateError("certificate schema validation failed: " + "; ".join(errors)) |
| return certificate |
|
|
