@vela-science/canopus 0.7.0 → 0.8.0

package/schemas/{run.v1.json → run.v2.json}

@@ -1,29 +1,28 @@
 {
   "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://vela.science/schemas/canopus/run.v1.json",
-  "title": "Canopus completed run v1",
-  "description": "A non-authoritative completed-run record with worker observations, mechanical verifier observations, and caveats that remain standing after verification.",
+  "$id": "https://vela.science/schemas/canopus/run.v2.json",
+  "title": "Canopus nonmutating Run v2",
   "type": "object",
   "additionalProperties": false,
   "required": [
     "schema",
     "run_id",
     "status",
+    "effect",
     "authority",
     "external_gate_credit",
     "mission",
     "candidate",
-    "observations",
     "verifier",
-    "landing",
-    "final_roots",
+    "submission",
     "reproduction",
     "budget"
   ],
   "properties": {
-    "schema": { "const": "canopus.run.v1" },
+    "schema": { "const": "canopus.run.v2" },
     "run_id": { "type": "string", "minLength": 5, "maxLength": 128 },
     "status": { "const": "completed" },
+    "effect": { "const": "none" },
     "authority": { "const": "non_authoritative" },
     "external_gate_credit": { "const": false },
     "mission": {
@@ -47,30 +46,62 @@
         "claim": { "type": "string", "minLength": 1, "maxLength": 8192 },
         "artifacts": {
           "type": "array",
+          "minItems": 1,
           "maxItems": 10,
-          "items": {
-            "type": "object",
-            "additionalProperties": false,
-            "required": ["path", "kind", "digest", "bytes"],
-            "properties": {
-              "path": { "$ref": "#/$defs/relativePath" },
-              "kind": { "type": "string", "minLength": 1, "maxLength": 128 },
-              "digest": { "$ref": "#/$defs/sha256" },
-              "bytes": { "type": "integer", "minimum": 0, "maximum": 1073741824 }
-            }
-          }
+          "items": { "$ref": "#/$defs/artifact" }
         },
-        "caveats": { "$ref": "#/$defs/caveats" }
+        "caveats": {
+          "type": "array",
+          "minItems": 1,
+          "maxItems": 10,
+          "items": { "type": "string", "minLength": 1, "maxLength": 4096 }
+        }
       }
     },
-    "observations": {
+    "verifier": { "$ref": "#/$defs/verifier" },
+    "submission": { "type": "null" },
+    "reproduction": {
       "type": "object",
       "additionalProperties": false,
-      "required": ["worker_observations", "verifier_observations", "standing_caveats"],
+      "required": ["matched", "roots", "verifier_status", "stdout_digest", "stderr_digest"],
       "properties": {
-        "worker_observations": { "$ref": "#/$defs/observations" },
-        "verifier_observations": { "$ref": "#/$defs/observations" },
-        "standing_caveats": { "$ref": "#/$defs/observations" }
+        "matched": { "const": true },
+        "roots": { "$ref": "#/$defs/roots" },
+        "verifier_status": { "const": "passed" },
+        "stdout_digest": { "$ref": "#/$defs/sha256" },
+        "stderr_digest": { "$ref": "#/$defs/sha256" }
+      }
+    },
+    "budget": { "$ref": "#/$defs/budget" }
+  },
+  "$defs": {
+    "sha256": { "type": "string", "pattern": "^sha256:[0-9a-f]{64}$" },
+    "gitObject": { "type": "string", "pattern": "^[0-9a-f]{40,64}$" },
+    "relativePath": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 4096,
+      "pattern": "^(?!/)(?!.*(?:^|/)\\.\\.(?:/|$)).+$"
+    },
+    "roots": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["git_commit", "git_tree", "vela_repository"],
+      "properties": {
+        "git_commit": { "$ref": "#/$defs/gitObject" },
+        "git_tree": { "$ref": "#/$defs/gitObject" },
+        "vela_repository": { "$ref": "#/$defs/sha256" }
+      }
+    },
+    "artifact": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["path", "kind", "digest", "bytes"],
+      "properties": {
+        "path": { "$ref": "#/$defs/relativePath" },
+        "kind": { "type": "string", "minLength": 1, "maxLength": 128 },
+        "digest": { "$ref": "#/$defs/sha256" },
+        "bytes": { "type": "integer", "minimum": 1, "maximum": 1073741824 }
       }
     },
     "verifier": {
@@ -78,19 +109,12 @@
       "additionalProperties": false,
       "required": ["status", "sandbox", "record"],
       "properties": {
-        "status": { "enum": ["passed", "failed", "error"] },
+        "status": { "const": "passed" },
         "sandbox": { "enum": ["macos_sandbox", "container_network_denied"] },
         "record": {
           "type": "object",
           "additionalProperties": false,
-          "required": [
-            "argv",
-            "executable_digest",
-            "exit_code",
-            "stdout_digest",
-            "stderr_digest",
-            "duration_ms"
-          ],
+          "required": ["argv", "executable_digest", "exit_code", "stdout_digest", "stderr_digest", "duration_ms"],
           "properties": {
             "argv": {
               "type": "array",
@@ -99,7 +123,7 @@
               "items": { "type": "string", "maxLength": 4096 }
             },
             "executable_digest": { "$ref": "#/$defs/sha256" },
-            "exit_code": { "type": "integer", "minimum": -1, "maximum": 255 },
+            "exit_code": { "const": 0 },
             "stdout_digest": { "$ref": "#/$defs/sha256" },
             "stderr_digest": { "$ref": "#/$defs/sha256" },
             "duration_ms": { "type": "integer", "minimum": 0, "maximum": 3600000 }
@@ -107,51 +131,6 @@
         }
       }
     },
-    "landing": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": [
-        "operation_id",
-        "receipt_root",
-        "proposal_id",
-        "route",
-        "original_route",
-        "accepted_event_delta",
-        "publication_state"
-      ],
-      "properties": {
-        "operation_id": { "type": "string", "minLength": 1, "maxLength": 256 },
-        "receipt_root": { "$ref": "#/$defs/sha256" },
-        "proposal_id": { "type": "string", "minLength": 1, "maxLength": 256 },
-        "route": { "enum": ["permit", "defer", "exact_retry"] },
-        "original_route": {
-          "oneOf": [
-            { "enum": ["permit", "defer"] },
-            { "type": "null" }
-          ]
-        },
-        "accepted_event_delta": {
-          "oneOf": [
-            { "type": "integer", "minimum": 0 },
-            { "type": "null" }
-          ]
-        },
-        "publication_state": { "type": "string", "minLength": 1, "maxLength": 4096 }
-      }
-    },
-    "final_roots": { "$ref": "#/$defs/roots" },
-    "reproduction": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["matched", "roots", "verifier_status", "stdout_digest", "stderr_digest"],
-      "properties": {
-        "matched": { "const": true },
-        "roots": { "$ref": "#/$defs/roots" },
-        "verifier_status": { "enum": ["passed", "failed", "error"] },
-        "stdout_digest": { "$ref": "#/$defs/sha256" },
-        "stderr_digest": { "$ref": "#/$defs/sha256" }
-      }
-    },
     "budget": {
       "type": "object",
       "additionalProperties": false,
@@ -173,43 +152,6 @@
         "attempts": { "$ref": "#/$defs/nonnegativeInteger" },
         "observed_tokens": { "$ref": "#/$defs/nonnegativeInteger" }
       }
-    }
-  },
-  "$defs": {
-    "sha256": {
-      "type": "string",
-      "pattern": "^sha256:[0-9a-f]{64}$"
-    },
-    "gitObject": {
-      "type": "string",
-      "pattern": "^[0-9a-f]{40,64}$"
-    },
-    "relativePath": {
-      "type": "string",
-      "minLength": 1,
-      "maxLength": 4096,
-      "pattern": "^(?!/)(?!.*(?:^|/)\\.\\.(?:/|$)).+$"
-    },
-    "roots": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["git_commit", "git_tree", "vela_event_log", "vela_snapshot"],
-      "properties": {
-        "git_commit": { "$ref": "#/$defs/gitObject" },
-        "git_tree": { "$ref": "#/$defs/gitObject" },
-        "vela_event_log": { "$ref": "#/$defs/sha256" },
-        "vela_snapshot": { "$ref": "#/$defs/sha256" }
-      }
-    },
-    "observations": {
-      "type": "array",
-      "maxItems": 16,
-      "items": { "type": "string", "minLength": 1, "maxLength": 4096 }
-    },
-    "caveats": {
-      "type": "array",
-      "maxItems": 10,
-      "items": { "type": "string", "minLength": 1, "maxLength": 4096 }
     },
     "nonnegativeInteger": {
       "type": "integer",

package/schemas/submission-bundle.v1.json

@@ -0,0 +1,63 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://vela.science/schemas/canopus/submission-bundle.v1.json",
+  "title": "Canopus portable Submission bundle v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": [
+    "schema",
+    "run_id",
+    "run_root",
+    "source",
+    "producer",
+    "submission_id",
+    "submission_root",
+    "identity_binding_id",
+    "artifacts"
+  ],
+  "properties": {
+    "schema": { "const": "canopus.submission-bundle.v1" },
+    "run_id": { "type": "string", "minLength": 5, "maxLength": 128 },
+    "run_root": { "$ref": "#/$defs/sha256" },
+    "source": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["git_commit", "git_tree", "vela_version", "vela_sha256"],
+      "properties": {
+        "git_commit": { "type": "string", "pattern": "^[0-9a-f]{40,64}$" },
+        "git_tree": { "type": "string", "pattern": "^[0-9a-f]{40,64}$" },
+        "vela_version": { "type": "string", "minLength": 1 },
+        "vela_sha256": { "$ref": "#/$defs/sha256" }
+      }
+    },
+    "producer": { "type": "string", "pattern": "^agent:.+$" },
+    "submission_id": { "type": "string", "pattern": "^vsb_[0-9a-f]{16}$" },
+    "submission_root": { "$ref": "#/$defs/sha256" },
+    "identity_binding_id": { "type": "string", "pattern": "^vib_[0-9a-f]{16}$" },
+    "artifacts": {
+      "type": "array",
+      "minItems": 1,
+      "maxItems": 10,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["source", "frontier_path", "digest", "bytes"],
+        "properties": {
+          "source": { "$ref": "#/$defs/relativePath" },
+          "frontier_path": { "$ref": "#/$defs/relativePath" },
+          "digest": { "$ref": "#/$defs/sha256" },
+          "bytes": { "type": "integer", "minimum": 1, "maximum": 1073741824 }
+        }
+      }
+    }
+  },
+  "$defs": {
+    "sha256": { "type": "string", "pattern": "^sha256:[0-9a-f]{64}$" },
+    "relativePath": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 4096,
+      "pattern": "^(?!/)(?!.*\\\\)(?!.*(?:^|/)\\.\\.(?:/|$)).+$"
+    }
+  }
+}

package/toolchain.lock.json

@@ -0,0 +1,31 @@
+{
+  "schema": "canopus.toolchain-lock.v1",
+  "vela": {
+    "version": "0.940.9",
+    "tag": "v0.940.9",
+    "source_commit": "4de04a553f139911b3c061883f60d9734f73c0f2",
+    "release_base_url": "https://github.com/vela-science/vela/releases/download/v0.940.9",
+    "assets": {
+      "darwin-arm64": {
+        "archive": "vela-macos-aarch64.zip",
+        "archive_sha256": "0d9c139552e0d12cbb0f2e387897d3135652ec72757f8b9bf3ba8ae2fa2ca20f",
+        "binary_sha256": "8d5b8745efaa176d980371d7a6fad633ac53c1c5245e5feb7c4f98a12bc2c02f"
+      },
+      "linux-x64": {
+        "archive": "vela-linux-x86_64.tar.gz",
+        "archive_sha256": "fc21a58e10d2d6dc9b0b066250d864ecfa055ca044046194fe47d035931d5585",
+        "binary_sha256": "232b4c96b79014e6220a3557ef161b81616a911f6794be09dcea42299716509a"
+      },
+      "win32-x64": {
+        "archive": "vela-windows-x86_64.zip",
+        "archive_sha256": "cd2cec3815234aabf17d7466a63588b079aa404d5f0d6f491403d094331c8a32",
+        "binary_sha256": "47c85b5af0178ae3a49cf98b832048533bf7c404799c951f6725f03ed69eca5a"
+      }
+    }
+  },
+  "codex": {
+    "version": "0.145.0",
+    "linux_x64_tarball_sha256": "11239480f8e3efd1430f23bbe91c1a397856b8bbe6185ccbaee2382d25e03df2",
+    "linux_x64_binary_sha256": "a2a05dafaa1acb002a45eaec0a462de5b13694fcfcd7bc43305f14781ce7be14"
+  }
+}

package/capsules/formal-erdos-505-test-dim-one/verifier

@@ -1,105 +0,0 @@
-#!/bin/sh
-set -eu
-
-if [ "$#" -ne 1 ]; then
-  echo "usage: verifier <proof-term>" >&2
-  exit 2
-fi
-
-proof=$1
-if [ ! -f "$proof" ] || [ -L "$proof" ]; then
-  echo "proof artifact must be one regular file" >&2
-  exit 2
-fi
-
-size=$(wc -c < "$proof" | tr -d ' ')
-if [ "$size" -eq 0 ] || [ "$size" -gt 131072 ]; then
-  echo "proof artifact must contain 1..131072 bytes" >&2
-  exit 2
-fi
-
-if [ "$(head -c 2 "$proof")" != "by" ]; then
-  echo "proof artifact must begin with a Lean 'by' term" >&2
-  exit 2
-fi
-
-if LC_ALL=C grep -Eq '(^|[^A-Za-z0-9_])(sorry|admit|axiom|unsafe)([^A-Za-z0-9_]|$)' "$proof"; then
-  echo "proof artifact contains a forbidden trust-bypassing token" >&2
-  exit 2
-fi
-
-toolchain=/home/lean/.elan/toolchains/leanprover--lean4---v4.27.0/bin
-project=/home/lean/mathlib
-if [ ! -x "$toolchain/lean" ]; then
-  echo "frozen Lean 4.27.0 toolchain is unavailable" >&2
-  exit 3
-fi
-if [ ! -f "$project/.lake/build/lib/lean/Mathlib/Analysis/InnerProductSpace/PiL2.olean" ] \
-    || [ ! -f "$project/.lake/build/lib/lean/Mathlib/Topology/MetricSpace/Bounded.olean" ]; then
-  echo "frozen minimal Mathlib modules are unavailable" >&2
-  exit 3
-fi
-
-export PATH="$toolchain:/usr/local/bin:/usr/bin:/bin"
-export LC_ALL=C
-LEAN_PATH=$(
-  find "$project" -type d -path '*/.lake/build/lib/lean' -print \
-    | LC_ALL=C sort \
-    | paste -sd ':' -
-)
-if [ -z "$LEAN_PATH" ]; then
-  echo "frozen Mathlib module path is unavailable" >&2
-  exit 3
-fi
-export LEAN_PATH
-cd "$project"
-
-set +e
-output=$(
-  {
-    printf '%s\n' \
-      'import Mathlib.Analysis.InnerProductSpace.PiL2' \
-      'import Mathlib.Topology.MetricSpace.Bounded' \
-      '/-! # Frozen Canopus verification for Erdos 505, dimension one -/' \
-      'open Metric Set Classical' \
-      'namespace CanopusFormalErdos505' \
-      'theorem test_dim_one' \
-      '    (S : Set (EuclideanSpace ℝ (Fin 1)))' \
-      '    (hS : Bornology.IsBounded S) (hd : 0 < diam S) :' \
-      '    ∃ (F : Fin 2 → Set (EuclideanSpace ℝ (Fin 1))),' \
-      '      S ⊆ ⋃ i, F i ∧ ∀ i, diam (F i) < diam S :='
-    cat "$proof"
-    printf '%s\n' \
-      '#print axioms CanopusFormalErdos505.test_dim_one' \
-      'end CanopusFormalErdos505'
-  } | "$toolchain/lean" --stdin 2>&1
-)
-status=$?
-set -e
-
-printf '%s\n' "$output"
-if [ "$status" -ne 0 ]; then
-  exit "$status"
-fi
-if printf '%s\n' "$output" | grep -Fq 'sorryAx'; then
-  echo "kernel declaration depends on sorryAx" >&2
-  exit 4
-fi
-
-axiom_line=$(printf '%s\n' "$output" | sed -n "s/^'CanopusFormalErdos505.test_dim_one' depends on axioms: \[\(.*\)\]$/\1/p")
-if [ -n "$axiom_line" ]; then
-  for axiom in $(printf '%s' "$axiom_line" | tr ',' ' '); do
-    case "$axiom" in
-      propext|Classical.choice|Quot.sound) ;;
-      *)
-        echo "kernel declaration depends on forbidden axiom: $axiom" >&2
-        exit 4
-        ;;
-    esac
-  done
-elif ! printf '%s\n' "$output" | grep -Fq "'CanopusFormalErdos505.test_dim_one' does not depend on any axioms"; then
-  echo "axiom audit output was missing or malformed" >&2
-  exit 4
-fi
-
-echo "verified formal:erdos-505-test-dim-one with Lean 4.27.0"

package/capsules/quantum-10-1-4/verifier.py

@@ -1,152 +0,0 @@
-#!/usr/bin/env python3
-"""Verify one explicit [[10,1,d>=4]] stabilizer witness."""
-
-from __future__ import annotations
-
-import itertools
-import json
-import pathlib
-import sys
-
-SCHEMA = "canopus.quantum-stabilizer-witness.v1"
-TARGET = "quantum:[[10,1,4]]"
-N = 10
-K = 1
-EXPECTED_KEYS = {"schema", "target", "n", "k", "generators"}
-
-
-def fail(message: str) -> "NoReturn":
-    print(f"quantum verifier: {message}", file=sys.stderr)
-    raise SystemExit(1)
-
-
-def pauli_vector(pauli: str) -> int:
-    if len(pauli) != N or any(symbol not in "IXYZ" for symbol in pauli):
-        fail("each generator must be a length-10 string over I, X, Y, Z")
-    vector = 0
-    for qubit, symbol in enumerate(pauli):
-        if symbol in "XY":
-            vector |= 1 << qubit
-        if symbol in "ZY":
-            vector |= 1 << (N + qubit)
-    return vector
-
-
-def symplectic(left: int, right: int) -> int:
-    mask = (1 << N) - 1
-    left_x, left_z = left & mask, left >> N
-    right_x, right_z = right & mask, right >> N
-    return ((left_x & right_z).bit_count() + (left_z & right_x).bit_count()) & 1
-
-
-def binary_rank(rows: list[int]) -> int:
-    basis: dict[int, int] = {}
-    for original in rows:
-        row = original
-        while row:
-            pivot = row.bit_length() - 1
-            if pivot in basis:
-                row ^= basis[pivot]
-            else:
-                basis[pivot] = row
-                break
-    return len(basis)
-
-
-def stabilizer_span(generators: list[int]) -> set[int]:
-    span = {0}
-    for generator in generators:
-        span.update(value ^ generator for value in tuple(span))
-    return span
-
-
-def error_vector(positions: tuple[int, ...], symbols: tuple[str, ...]) -> int:
-    vector = 0
-    for qubit, symbol in zip(positions, symbols, strict=True):
-        if symbol in "XY":
-            vector |= 1 << qubit
-        if symbol in "ZY":
-            vector |= 1 << (N + qubit)
-    return vector
-
-
-def main() -> None:
-    if len(sys.argv) != 2:
-        fail("usage: verifier.py WITNESS.json")
-    witness_path = pathlib.Path(sys.argv[1])
-    metadata = witness_path.lstat()
-    if not witness_path.is_file() or witness_path.is_symlink() or metadata.st_size > 65_536:
-        fail("witness must be one bounded regular file")
-    with witness_path.open("rb") as source:
-        raw = source.read(65_537)
-    if len(raw) > 65_536:
-        fail("witness exceeds 65536 bytes")
-    try:
-        witness = json.loads(raw)
-    except (UnicodeDecodeError, json.JSONDecodeError) as error:
-        fail(f"witness is not valid UTF-8 JSON: {error}")
-    if not isinstance(witness, dict) or set(witness) != EXPECTED_KEYS:
-        fail("witness fields must be exactly schema, target, n, k, generators")
-    if witness["schema"] != SCHEMA or witness["target"] != TARGET:
-        fail("witness schema or target is wrong")
-    if type(witness["n"]) is not int or type(witness["k"]) is not int:
-        fail("n and k must be integers")
-    if witness["n"] != N or witness["k"] != K:
-        fail("witness must declare n=10 and k=1")
-    declared = witness["generators"]
-    if not isinstance(declared, list) or len(declared) != N - K:
-        fail("witness must contain exactly nine generators")
-    if any(not isinstance(generator, str) for generator in declared):
-        fail("every generator must be a string")
-    if len(set(declared)) != len(declared):
-        fail("generators must be distinct")
-    generators = [pauli_vector(generator) for generator in declared]
-    if any(generator == 0 for generator in generators):
-        fail("identity is not a generator")
-    for left, right in itertools.combinations(generators, 2):
-        if symplectic(left, right) != 0:
-            fail("generators do not commute")
-    rank = binary_rank(generators)
-    if rank != N - K:
-        fail(f"generator rank is {rank}, expected nine")
-    span = stabilizer_span(generators)
-    if len(span) != 1 << (N - K):
-        fail("stabilizer span has the wrong cardinality")
-
-    tested = 0
-    degenerate = 0
-    for weight in range(1, 4):
-        for positions in itertools.combinations(range(N), weight):
-            for symbols in itertools.product("XYZ", repeat=weight):
-                tested += 1
-                error = error_vector(positions, symbols)
-                if all(symplectic(error, generator) == 0 for generator in generators):
-                    if error not in span:
-                        fail(
-                            "found an undetectable non-stabilizer Pauli below weight four: "
-                            f"positions={positions}, symbols={''.join(symbols)}"
-                        )
-                    degenerate += 1
-    if tested != 3_675:
-        fail(f"internal enumeration count is {tested}, expected 3675")
-    print(
-        json.dumps(
-            {
-                "schema": "canopus.quantum-stabilizer-verification.v1",
-                "target": TARGET,
-                "n": N,
-                "k": K,
-                "rank": rank,
-                "stabilizer_size": len(span),
-                "errors_weight_1_to_3_tested": tested,
-                "low_weight_stabilizers": degenerate,
-                "distance_at_least": 4,
-            },
-            sort_keys=True,
-            separators=(",", ":"),
-        )
-    )
-
-
-if __name__ == "__main__":
-    main()

package/dist/src/engines/codex-exec.d.ts

@@ -1,17 +0,0 @@
-import { type CommandRunner } from "../util/command.js";
-import type { Engine, EngineContext, EngineResult } from "./engine.js";
-export interface CodexEngineOptions {
-    binary: string;
-    expectedSha256: string;
-    expectedVersion: string;
-    model: string;
-    authHome: string;
-    outputSchema: string;
-    runner?: CommandRunner;
-}
-export declare class CodexExecEngine implements Engine {
-    #private;
-    readonly name = "codex-exec";
-    constructor(options: CodexEngineOptions);
-    run(context: EngineContext): Promise<EngineResult>;
-}