Upload folder using huggingface_hub

Dockerfile

@@ -0,0 +1,81 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Multi-stage build using openenv-base
+# This Dockerfile is flexible and works for both:
+# - In-repo environments (with local OpenEnv sources)
+# - Standalone environments (with openenv from PyPI/Git)
+# The build script (openenv build) handles context detection and sets appropriate build args.
+
+ARG BASE_IMAGE=ghcr.io/meta-pytorch/openenv-base:latest
+FROM ${BASE_IMAGE} AS builder
+
+WORKDIR /app
+
+# Ensure git is available (required for installing dependencies from VCS)
+RUN apt-get update && \
+    apt-get install -y --no-install-recommends git && \
+    rm -rf /var/lib/apt/lists/*
+
+# Build argument to control whether we're building standalone or in-repo
+ARG BUILD_MODE=in-repo
+ARG ENV_NAME=stabilizer_forge
+
+# Copy environment code (always at root of build context)
+COPY . /app/env
+
+# For in-repo builds, openenv is already vendored in the build context
+# For standalone builds, openenv will be installed via pyproject.toml
+WORKDIR /app/env
+
+# Ensure uv is available (for local builds where base image lacks it)
+RUN if ! command -v uv >/dev/null 2>&1; then \
+        curl -LsSf https://astral.sh/uv/install.sh | sh && \
+        mv /root/.local/bin/uv /usr/local/bin/uv && \
+        mv /root/.local/bin/uvx /usr/local/bin/uvx; \
+    fi
+    
+# Install dependencies using uv sync
+# If uv.lock exists, use it; otherwise resolve on the fly
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-install-project --no-editable; \
+    else \
+        uv sync --no-install-project --no-editable; \
+    fi
+
+RUN --mount=type=cache,target=/root/.cache/uv \
+    if [ -f uv.lock ]; then \
+        uv sync --frozen --no-editable; \
+    else \
+        uv sync --no-editable; \
+    fi
+
+# Final runtime stage
+FROM ${BASE_IMAGE}
+
+WORKDIR /app
+
+# Copy the virtual environment from builder
+COPY --from=builder /app/env/.venv /app/.venv
+
+# Copy the environment code
+COPY --from=builder /app/env /app/env
+
+# Set PATH to use the virtual environment
+ENV PATH="/app/.venv/bin:$PATH"
+
+# Set PYTHONPATH so imports work correctly
+ENV PYTHONPATH="/app/env:$PYTHONPATH"
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:8000/health || exit 1
+
+# Run the FastAPI server
+# The module path is constructed to work with the /app/env structure
+ENV ENABLE_WEB_INTERFACE=true
+CMD ["sh", "-c", "cd /app/env && uvicorn server.app:app --host 0.0.0.0 --port 8000"]

README.md

@@ -1,10 +1,159 @@
 ---
-title: Stabilizer Forge
-emoji: 🌖
-colorFrom: purple
-colorTo: gray
+title: StabilizerForge — Quantum-Code Synthesis Environment
+emoji: ⚛️
+colorFrom: indigo
+colorTo: green
 sdk: docker
 pinned: false
+app_port: 8000
+base_path: /web
+tags:
+  - openenv
+  - quantum-error-correction
+  - stim
+  - stabilizer-codes
+  - rlvr
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# StabilizerForge — OpenEnv environment for Clifford circuit synthesis
+
+An RL environment that scores candidate Clifford encoding circuits against a target stabilizer code in **polynomial time** using [Stim](https://github.com/quantumlib/Stim)'s tableau simulator (Aaronson–Gottesman). Built for training small LLMs to do automated quantum-error-correction code synthesis with verifier-grounded rewards (RLVR).
+
+The environment ships with **29 training tasks + 10 held-out eval tasks** across three difficulty tiers — from Bell states (2 qubits, 2 gates) up to distance-5 surface, color, and Golay codes (≤25 qubits, 100+ gates).
+
+## Action / Observation / Reward
+
+**Action** — one Clifford gate per step (or `FINALIZE`):
+
+```python
+from stabilizer_forge import StabilizerAction
+StabilizerAction(op="H",  qubits=[0])      # Hadamard on qubit 0
+StabilizerAction(op="S",  qubits=[3])      # phase gate on qubit 3
+StabilizerAction(op="CX", qubits=[0, 1])   # CNOT 0 -> 1
+StabilizerAction(op="FINALIZE")            # end episode, deliver terminal reward
+```
+
+Pydantic validation; malformed actions get a format penalty and are treated as no-ops. After 5 consecutive format violations the episode terminates.
+
+**Observation** — full state for the current episode:
+
+| field | type | meaning |
+|-------|------|---------|
+| `task_id` | str | which task this episode is running |
+| `target_stabilizers` | `list[str]` | Pauli strings, e.g. `["XZZXI", "IXZZX", ...]` |
+| `n_qubits` | int | number of physical qubits |
+| `gates_so_far` | `list[str]` | Stim instructions applied this episode |
+| `current_circuit` | str | concatenated Stim text |
+| `current_match` | `list[bool]` | per-stabilizer preservation under the current circuit (live from Stim) |
+| `match_fraction` | float | fraction of target stabilizers preserved (0..1) |
+| `gates_emitted` | int | valid gates applied so far |
+| `cnot_count` | int | CX count |
+| `nonadj_cnot_count` | int | CXs across non-adjacent qubits |
+| `gate_budget` / `gate_budget_remaining` | int | hard cap (`2 × benchmark_optimum`) |
+| `benchmark_optimum` / `benchmark_optimum_2q` | int | reference encoder's gate counts |
+| `connectivity_edges` | `list[list[int]] \| None` | None = all-to-all |
+| `format_violations`, `consecutive_violations` | int | error tracking |
+| `last_action_valid`, `last_action_error` | bool, str | parser feedback |
+| `step_count`, `finalized` | | |
+
+**Reward** — delivered at `FINALIZE` plus dense per-step shaping:
+
+| component | weight | what it measures |
+|-----------|--------|------------------|
+| stabilizer-match fraction | **0.40** | primary correctness signal |
+| gate-count efficiency `max(0, 1 − gates / (1.5 × bench_opt))` | 0.20 | volume vs. reference |
+| two-qubit-gate efficiency | 0.20 | CXs are expensive on real hardware |
+| connectivity respect | 0.10 | −1 per CX across non-adjacent qubits |
+| format compliance | 0.10 | −1 per malformed action |
+| `0.05 × Δmatch_fraction` | per step | dense gradient before FINALIZE is learned |
+
+## Quick start (sync HTTP)
+
+```python
+from stabilizer_forge import StabilizerAction, StabilizerForgeEnv
+
+client = StabilizerForgeEnv(base_url="http://localhost:8000")
+with client.sync() as env:
+    r = env.reset(task_id="steane")          # pass any task_id from tasks.jsonl, or omit for random
+    print(r.observation.target_stabilizers)  # 6 Pauli strings on 7 qubits
+
+    for op, qs in [("H",[0]), ("CX",[0,1]), ("CX",[0,2]), ("CX",[0,3])]:
+        r = env.step(StabilizerAction(op=op, qubits=qs))
+        print(f"  match_fraction={r.observation.match_fraction:.2f}")
+
+    r = env.step(StabilizerAction(op="FINALIZE"))
+    print(f"terminal reward={r.reward:+.3f} done={r.done}")
+```
+
+To start the server locally:
+
+```bash
+python -m stabilizer_forge.server.app --port 8000
+```
+
+Or via Docker (see below).
+
+## Tasks
+
+The env loads tasks from `stabilizer_forge/tasks.jsonl` by default. Override with the `STABILIZER_FORGE_TASKS` environment variable. Each task carries:
+
+```json
+{
+  "task_id": "steane",
+  "source_code": "Steane [[7,1,3]]",
+  "n_qubits": 7,
+  "target_stabilizers": ["XXIIXXI", "XIXIXIX", "IIIXXXX", "ZZIIZZI", "ZIZIZIZ", "IIIZZZZ"],
+  "connectivity_edges": null,
+  "gate_budget": 78,
+  "benchmark_optimum": 26,
+  "benchmark_optimum_2q": 23,
+  "tier": 2
+}
+```
+
+Tier 1 (12 tasks): Bell, GHZ-3..8, [[4,2,2]] iceberg/detector, hypercube `l=1`, iceberg `m=4`.
+Tier 2 (12 tasks): Perfect [[5,1,3]], Steane, Shor, surface `d=3`, hex/square-octagon color `d=3`, GHZ-9..13, Carbon.
+Tier 3 (5 tasks): Tetrahedral, Hamming, surface `d=5`, hex/square-octagon color `d=5`.
+
+## Verifier
+
+The match-fraction comes from Stim's `TableauSimulator.peek_observable_expectation`. For each target stabilizer `S_i`, we apply the candidate circuit to `|0⟩^n`, then check whether the resulting state has `+1` eigenvalue under `S_i`. This is exact and polynomial — there's no false-positive risk and no statistical noise. Vendored from [uw-math-ai/quantum-ai/tools/check_stabilizers.py](https://github.com/uw-math-ai/quantum-ai/blob/main/tools/check_stabilizers.py).
+
+## Deploy
+
+```bash
+openenv push
+# requires `huggingface-cli login` first
+```
+
+The deployed Space exposes `/health`, `/reset`, `/step`, `/state`, `/schema` over HTTP, and `/ws` for low-latency persistent sessions. Use `StabilizerForgeEnv(base_url="https://<your-space>.hf.space")` to connect.
+
+## Building the Docker image manually
+
+```bash
+docker build -t stabilizer-forge-env:latest -f server/Dockerfile .
+docker run -p 8000:8000 stabilizer-forge-env:latest
+```
+
+## Files
+
+```
+stabilizer_forge/
+├── __init__.py
+├── client.py              # StabilizerForgeEnv (sync/async HTTP client)
+├── models.py              # StabilizerAction, StabilizerObservation
+├── tasks.jsonl            # 29 training tasks
+├── eval_tasks.jsonl       # 10 held-out eval tasks
+├── pyproject.toml
+├── openenv.yaml
+└── server/
+    ├── stabilizer_forge_environment.py   # core env (reward, termination, verifier wrap)
+    ├── verifier.py                       # Stim-based check_stabilizers, match_fraction
+    ├── app.py                            # FastAPI; max_concurrent_envs=64
+    └── Dockerfile
+```
+
+## Citation / credits
+
+- Verifier and benchmark catalog adapted from [uw-math-ai/quantum-ai](https://github.com/uw-math-ai/quantum-ai) (StabilizerBench, arXiv:2604.21287, April 2026).
+- Built on [OpenEnv](https://github.com/meta-pytorch/OpenEnv) and [Stim](https://github.com/quantumlib/Stim).

__init__.py

@@ -0,0 +1,10 @@
+"""StabilizerForge environment."""
+
+from .client import StabilizerForgeEnv
+from .models import StabilizerAction, StabilizerObservation
+
+__all__ = [
+    "StabilizerAction",
+    "StabilizerObservation",
+    "StabilizerForgeEnv",
+]

client.py

@@ -0,0 +1,47 @@
+"""StabilizerForge environment client (sync + async via openenv core)."""
+from __future__ import annotations
+
+from typing import Any
+
+from openenv.core import EnvClient
+from openenv.core.client_types import StepResult
+from openenv.core.env_server.types import State
+
+from .models import StabilizerAction, StabilizerObservation
+
+
+class StabilizerForgeEnv(EnvClient[StabilizerAction, StabilizerObservation, State]):
+    """Client for the StabilizerForge environment server.
+
+    Example:
+        with StabilizerForgeEnv(base_url="http://localhost:8000") as client:
+            result = client.reset(task_id="steane_7_1_3")
+            result = client.step(StabilizerAction(op="H", qubits=[0]))
+            ...
+            result = client.step(StabilizerAction(op="FINALIZE"))
+    """
+
+    def _step_payload(self, action: StabilizerAction) -> dict[str, Any]:
+        return {"op": action.op, "qubits": list(action.qubits)}
+
+    def _parse_result(
+        self, payload: dict[str, Any]
+    ) -> StepResult[StabilizerObservation]:
+        obs_data = payload.get("observation", {})
+        observation = StabilizerObservation(**obs_data) if obs_data else StabilizerObservation()
+        # Top-level done/reward override what's inside observation if present
+        if "done" in payload:
+            observation.done = bool(payload.get("done"))
+        if "reward" in payload:
+            observation.reward = payload.get("reward")
+        return StepResult(
+            observation=observation,
+            reward=payload.get("reward"),
+            done=payload.get("done", False),
+        )
+
+    def _parse_state(self, payload: dict[str, Any]) -> State:
+        return State(
+            episode_id=payload.get("episode_id"),
+            step_count=payload.get("step_count", 0),
+        )

eval_tasks.jsonl

@@ -0,0 +1,10 @@
+{"task_id": "ghz15", "source_code": "15-qubit GHZ", "n_qubits": 15, "target_stabilizers": ["XXXXXXXXXXXXXXX", "ZZIIIIIIIIIIIII", "IZZIIIIIIIIIIII", "IIZZIIIIIIIIIII", "IIIZZIIIIIIIIII", "IIIIZZIIIIIIIII", "IIIIIZZIIIIIIII", "IIIIIIZZIIIIIII", "IIIIIIIZZIIIIII", "IIIIIIIIZZIIIII", "IIIIIIIIIZZIIII", "IIIIIIIIIIZZIII", "IIIIIIIIIIIZZII", "IIIIIIIIIIIIZZI", "IIIIIIIIIIIIIZZ"], "connectivity_edges": null, "gate_budget": 60, "benchmark_optimum": 15, "benchmark_optimum_2q": 14, "tier": 2}
+{"task_id": "ghz17", "source_code": "17-qubit GHZ", "n_qubits": 17, "target_stabilizers": ["XXXXXXXXXXXXXXXXX", "ZZIIIIIIIIIIIIIII", "IZZIIIIIIIIIIIIII", "IIZZIIIIIIIIIIIII", "IIIZZIIIIIIIIIIII", "IIIIZZIIIIIIIIIII", "IIIIIZZIIIIIIIIII", "IIIIIIZZIIIIIIIII", "IIIIIIIZZIIIIIIII", "IIIIIIIIZZIIIIIII", "IIIIIIIIIZZIIIIII", "IIIIIIIIIIZZIIIII", "IIIIIIIIIIIZZIIII", "IIIIIIIIIIIIZZIII", "IIIIIIIIIIIIIZZII", "IIIIIIIIIIIIIIZZI", "IIIIIIIIIIIIIIIZZ"], "connectivity_edges": null, "gate_budget": 68, "benchmark_optimum": 17, "benchmark_optimum_2q": 16, "tier": 2}
+{"task_id": "ghz20", "source_code": "20-qubit GHZ", "n_qubits": 20, "target_stabilizers": ["XXXXXXXXXXXXXXXXXXXX", "ZZIIIIIIIIIIIIIIIIII", "IZZIIIIIIIIIIIIIIIII", "IIZZIIIIIIIIIIIIIIII", "IIIZZIIIIIIIIIIIIIII", "IIIIZZIIIIIIIIIIIIII", "IIIIIZZIIIIIIIIIIIII", "IIIIIIZZIIIIIIIIIIII", "IIIIIIIZZIIIIIIIIIII", "IIIIIIIIZZIIIIIIIIII", "IIIIIIIIIZZIIIIIIIII", "IIIIIIIIIIZZIIIIIIII", "IIIIIIIIIIIZZIIIIIII", "IIIIIIIIIIIIZZIIIIII", "IIIIIIIIIIIIIZZIIIII", "IIIIIIIIIIIIIIZZIIII", "IIIIIIIIIIIIIIIZZIII", "IIIIIIIIIIIIIIIIZZII", "IIIIIIIIIIIIIIIIIZZI", "IIIIIIIIIIIIIIIIIIZZ"], "connectivity_edges": null, "gate_budget": 80, "benchmark_optimum": 20, "benchmark_optimum_2q": 19, "tier": 3}
+{"task_id": "golay", "source_code": "Golay", "n_qubits": 23, "target_stabilizers": ["IXIIXIIXXXXXIIIIIIIIIIX", "XIIXIIXXXXXIIIIIIIIIIXI", "IXXIXXXIIIXXIIIIIIIIXII", "XXIXXXIIIXXIIIIIIIIXIII", "XXXXIIIXIIXXIIIIIIXIIII", "XIXIXIXXXIIXIIIIIXIIIII", "IIIXXXXIXXIXIIIIXIIIIII", "IIXXXXIXXIXIIIIXIIIIIII", "IXXXXIXXIXIIIIXIIIIIIII", "XXXXIXXIXIIIIXIIIIIIIII", "XIXIIXIIXXXXXIIIIIIIIII", "IZIIZIIZZZZZIIIIIIIIIIZ", "ZIIZIIZZZZZIIIIIIIIIIZI", "IZZIZZZIIIZZIIIIIIIIZII", "ZZIZZZIIIZZIIIIIIIIZIII", "ZZZZIIIZIIZZIIIIIIZIIII", "ZIZIZIZZZIIZIIIIIZIIIII", "IIIZZZZIZZIZIIIIZIIIIII", "IIZZZZIZZIZIIIIZIIIIIII", "IZZZZIZZIZIIIIZIIIIIIII", "ZZZZIZZIZIIIIZIIIIIIIII", "ZIZIIZIIZZZZZIIIIIIIIII"], "connectivity_edges": null, "gate_budget": 555, "benchmark_optimum": 185, "benchmark_optimum_2q": 174, "tier": 3}
+{"task_id": "iceberg_code_m_2_perfect_5-qubit_code", "source_code": "(Iceberg Code m=2) * (Perfect 5-Qubit Code)", "n_qubits": 20, "target_stabilizers": ["XZZXIIIIIIIIIIIIIIII", "IIIIIXZZXIIIIIIIIIII", "IIIIIIIIIIXZZXIIIIII", "IIIIIIIIIIIIIIIXZZXI", "IXZZXIIIIIIIIIIIIIII", "IIIIIIXZZXIIIIIIIIII", "IIIIIIIIIIIXZZXIIIII", "IIIIIIIIIIIIIIIIXZZX", "XIXZZIIIIIIIIIIIIIII", "IIIIIXIXZZIIIIIIIIII", "IIIIIIIIIIXIXZZIIIII", "IIIIIIIIIIIIIIIXIXZZ", "ZXIXZIIIIIIIIIIIIIII", "IIIIIZXIXZIIIIIIIIII", "IIIIIIIIIIZXIXZIIIII", "IIIIIIIIIIIIIIIZXIXZ", "XXXXXXXXXXXXXXXXXXXX", "ZZZZZZZZZZZZZZZZZZZZ"], "connectivity_edges": null, "gate_budget": 738, "benchmark_optimum": 246, "benchmark_optimum_2q": 135, "tier": 3}
+{"task_id": "4-qubit_detector_code_perfect_5-qubit_code", "source_code": "(4-Qubit Detector Code) * (Perfect 5-Qubit Code)", "n_qubits": 20, "target_stabilizers": ["XZZXIIIIIIIIIIIIIIII", "IIIIIXZZXIIIIIIIIIII", "IIIIIIIIIIXZZXIIIIII", "IIIIIIIIIIIIIIIXZZXI", "IXZZXIIIIIIIIIIIIIII", "IIIIIIXZZXIIIIIIIIII", "IIIIIIIIIIIXZZXIIIII", "IIIIIIIIIIIIIIIIXZZX", "XIXZZIIIIIIIIIIIIIII", "IIIIIXIXZZIIIIIIIIII", "IIIIIIIIIIXIXZZIIIII", "IIIIIIIIIIIIIIIXIXZZ", "ZXIXZIIIIIIIIIIIIIII", "IIIIIZXIXZIIIIIIIIII", "IIIIIIIIIIZXIXZIIIII", "IIIIIIIIIIIIIIIZXIXZ", "XXXXXXXXXXXXXXXXXXXX", "ZZZZZZZZZZZZZZZZZZZZ"], "connectivity_edges": null, "gate_budget": 738, "benchmark_optimum": 246, "benchmark_optimum_2q": 135, "tier": 3}
+{"task_id": "perfect_5-qubit_code_perfect_5-qubit_code", "source_code": "(Perfect 5-Qubit Code) * (Perfect 5-Qubit Code)", "n_qubits": 25, "target_stabilizers": ["XZZXIIIIIIIIIIIIIIIIIIIII", "IIIIIXZZXIIIIIIIIIIIIIIII", "IIIIIIIIIIXZZXIIIIIIIIIII", "IIIIIIIIIIIIIIIXZZXIIIIII", "IIIIIIIIIIIIIIIIIIIIXZZXI", "IXZZXIIIIIIIIIIIIIIIIIIII", "IIIIIIXZZXIIIIIIIIIIIIIII", "IIIIIIIIIIIXZZXIIIIIIIIII", "IIIIIIIIIIIIIIIIXZZXIIIII", "IIIIIIIIIIIIIIIIIIIIIXZZX", "XIXZZIIIIIIIIIIIIIIIIIIII", "IIIIIXIXZZIIIIIIIIIIIIIII", "IIIIIIIIIIXIXZZIIIIIIIIII", "IIIIIIIIIIIIIIIXIXZZIIIII", "IIIIIIIIIIIIIIIIIIIIXIXZZ", "ZXIXZIIIIIIIIIIIIIIIIIIII", "IIIIIZXIXZIIIIIIIIIIIIIII", "IIIIIIIIIIZXIXZIIIIIIIIII", "IIIIIIIIIIIIIIIZXIXZIIIII", "IIIIIIIIIIIIIIIIIIIIZXIXZ", "XXXXXZZZZZZZZZZXXXXXIIIII", "IIIIIXXXXXZZZZZZZZZZXXXXX", "XXXXXIIIIIXXXXXZZZZZZZZZZ", "ZZZZZXXXXXIIIIIXXXXXZZZZZ"], "connectivity_edges": null, "gate_budget": 1098, "benchmark_optimum": 366, "benchmark_optimum_2q": 192, "tier": 3}
+{"task_id": "rep5_logical_plus", "source_code": "5-qubit repetition (logical |+>)", "n_qubits": 5, "target_stabilizers": ["XXXXX", "ZZIII", "IZZII", "IIZZI", "IIIZZ"], "connectivity_edges": null, "gate_budget": 30, "benchmark_optimum": 5, "benchmark_optimum_2q": 4, "tier": 2}
+{"task_id": "ghz_pair", "source_code": "Pair of independent Bell states", "n_qubits": 4, "target_stabilizers": ["XXII", "ZZII", "IIXX", "IIZZ"], "connectivity_edges": null, "gate_budget": 20, "benchmark_optimum": 4, "benchmark_optimum_2q": 2, "tier": 1}
+{"task_id": "linear_cluster_4", "source_code": "4-qubit linear cluster state", "n_qubits": 4, "target_stabilizers": ["XZII", "ZXZI", "IZXZ", "IIZX"], "connectivity_edges": [[0, 1], [1, 2], [2, 3]], "gate_budget": 20, "benchmark_optimum": 7, "benchmark_optimum_2q": 3, "tier": 1}

models.py

@@ -0,0 +1,78 @@
+"""Data models for the StabilizerForge environment.
+
+Action: a single Clifford gate (H, S, CX) or FINALIZE.
+Observation: target stabilizers + circuit-so-far + current match fraction + bookkeeping.
+"""
+from __future__ import annotations
+
+from typing import Literal
+
+from openenv.core.env_server.types import Action, Observation
+from pydantic import Field
+
+
+class StabilizerAction(Action):
+    """One Clifford gate, or FINALIZE to end the episode."""
+
+    op: Literal["H", "S", "CX", "FINALIZE"] = Field(
+        ..., description="Gate to apply, or FINALIZE to end the episode."
+    )
+    qubits: list[int] = Field(
+        default_factory=list,
+        description="Target qubit indices. 1 for H/S, 2 for CX (control, target). Empty for FINALIZE.",
+    )
+
+
+class StabilizerObservation(Observation):
+    """Full per-step view of the episode."""
+
+    task_id: str = Field(default="", description="Active task identifier.")
+    target_stabilizers: list[str] = Field(
+        default_factory=list,
+        description="Target stabilizer generators as Pauli strings (e.g., 'XZZXI').",
+    )
+    n_qubits: int = Field(default=0, description="Number of physical qubits.")
+    connectivity_edges: list[list[int]] | None = Field(
+        default=None,
+        description="Adjacency edge list. None means all-to-all.",
+    )
+
+    gates_so_far: list[str] = Field(
+        default_factory=list,
+        description="Gates applied this episode, as Stim instruction strings.",
+    )
+    current_circuit: str = Field(
+        default="",
+        description="Concatenated Stim text of all gates emitted so far.",
+    )
+
+    current_match: list[bool] = Field(
+        default_factory=list,
+        description="Per-stabilizer preservation under current circuit.",
+    )
+    match_fraction: float = Field(
+        default=0.0, description="Fraction of target stabilizers preserved (0..1)."
+    )
+
+    gates_emitted: int = Field(default=0, description="Number of valid gates applied.")
+    cnot_count: int = Field(default=0, description="Number of CX gates applied.")
+    nonadj_cnot_count: int = Field(
+        default=0,
+        description="Number of CX gates applied across non-adjacent qubits.",
+    )
+    gate_budget: int = Field(default=0, description="Hard cap on total gates.")
+    gate_budget_remaining: int = Field(default=0)
+    benchmark_optimum: int = Field(
+        default=0, description="Reference encoding's gate count (volume-style)."
+    )
+    benchmark_optimum_2q: int = Field(
+        default=0, description="Reference encoding's two-qubit gate count."
+    )
+
+    format_violations: int = Field(default=0)
+    consecutive_violations: int = Field(default=0)
+    last_action_valid: bool = Field(default=True)
+    last_action_error: str = Field(default="")
+
+    step_count: int = Field(default=0)
+    finalized: bool = Field(default=False)

openenv.yaml

@@ -0,0 +1,7 @@
+spec_version: 1
+name: stabilizer_forge
+type: space
+runtime: fastapi
+app: server.app:app
+port: 8000
+

openenv_stabilizer_forge.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: openenv-stabilizer_forge
+Version: 0.1.0
+Summary: Stabilizer Forge environment for OpenEnv
+Requires-Python: >=3.10
+Requires-Dist: openenv-core[core]>=0.2.2
+Requires-Dist: stim>=1.13
+Requires-Dist: numpy>=1.24
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"

openenv_stabilizer_forge.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+./__init__.py
+./client.py
+./models.py
+openenv_stabilizer_forge.egg-info/PKG-INFO
+openenv_stabilizer_forge.egg-info/SOURCES.txt
+openenv_stabilizer_forge.egg-info/dependency_links.txt
+openenv_stabilizer_forge.egg-info/entry_points.txt
+openenv_stabilizer_forge.egg-info/requires.txt
+openenv_stabilizer_forge.egg-info/top_level.txt
+server/__init__.py
+server/app.py
+server/stabilizer_forge_environment.py
+server/verifier.py

openenv_stabilizer_forge.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

openenv_stabilizer_forge.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+server = stabilizer_forge.server.app:main

openenv_stabilizer_forge.egg-info/requires.txt

@@ -0,0 +1,7 @@
+openenv-core[core]>=0.2.2
+stim>=1.13
+numpy>=1.24
+
+[dev]
+pytest>=8.0.0
+pytest-cov>=4.0.0

openenv_stabilizer_forge.egg-info/top_level.txt

@@ -0,0 +1 @@
+stabilizer_forge

pyproject.toml

@@ -0,0 +1,40 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+[build-system]
+requires = ["setuptools>=45", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "openenv-stabilizer_forge"
+version = "0.1.0"
+description = "Stabilizer Forge environment for OpenEnv"
+requires-python = ">=3.10"
+dependencies = [
+    # Core OpenEnv runtime (provides FastAPI server + HTTP client types)
+    # install from github
+    # "openenv-core[core] @ git+https://github.com/meta-pytorch/OpenEnv.git",
+    "openenv-core[core]>=0.2.2",
+    # Environment-specific dependencies
+    "stim>=1.13",
+    "numpy>=1.24",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-cov>=4.0.0",
+]
+
+[project.scripts]
+# Server entry point - enables running via: uv run --project . server
+# or: python -m stabilizer_forge.server.app
+server = "stabilizer_forge.server.app:main"
+
+[tool.setuptools]
+include-package-data = true
+packages = ["stabilizer_forge", "stabilizer_forge.server"]
+package-dir = { "stabilizer_forge" = ".", "stabilizer_forge.server" = "server" }

server/__init__.py

@@ -0,0 +1,11 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""Stabilizer Forge environment server components."""
+
+from .stabilizer_forge_environment import StabilizerForgeEnvironment
+
+__all__ = ["StabilizerForgeEnvironment"]

server/app.py

@@ -0,0 +1,70 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+FastAPI application for the Stabilizer Forge Environment.
+
+This module creates an HTTP server that exposes the StabilizerForgeEnvironment
+over HTTP and WebSocket endpoints, compatible with EnvClient.
+
+Endpoints:
+    - POST /reset: Reset the environment
+    - POST /step: Execute an action
+    - GET /state: Get current environment state
+    - GET /schema: Get action/observation schemas
+    - WS /ws: WebSocket endpoint for persistent sessions
+
+Usage:
+    # Development (with auto-reload):
+    uvicorn server.app:app --reload --host 0.0.0.0 --port 8000
+
+    # Production:
+    uvicorn server.app:app --host 0.0.0.0 --port 8000 --workers 4
+
+    # Or run directly:
+    python -m server.app
+"""
+
+try:
+    from openenv.core.env_server.http_server import create_app
+except Exception as e:  # pragma: no cover
+    raise ImportError(
+        "openenv is required for the web interface. Install dependencies with '\n    uv sync\n'"
+    ) from e
+
+try:
+    from ..models import StabilizerAction, StabilizerObservation
+    from .stabilizer_forge_environment import StabilizerForgeEnvironment
+except ImportError:
+    from models import StabilizerAction, StabilizerObservation
+    from server.stabilizer_forge_environment import StabilizerForgeEnvironment
+
+
+# Create the app. max_concurrent_envs=64 is the TRL-OpenEnv-RFC gotcha:
+# the default of 1 silently kills GRPO parallelism (see RFC 004).
+app = create_app(
+    StabilizerForgeEnvironment,
+    StabilizerAction,
+    StabilizerObservation,
+    env_name="stabilizer_forge",
+    max_concurrent_envs=64,
+)
+
+
+def main():
+    """Entry point for direct execution via `uv run server` or `python -m stabilizer_forge.server.app`."""
+    import argparse
+    import uvicorn
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--host", default="0.0.0.0")
+    parser.add_argument("--port", type=int, default=8000)
+    args = parser.parse_args()
+    uvicorn.run(app, host=args.host, port=args.port)
+
+
+if __name__ == "__main__":
+    main()

server/requirements.txt

@@ -0,0 +1,5 @@
+openenv-core[core]>=0.2.2
+fastapi>=0.115.0
+uvicorn>=0.24.0
+stim>=1.13
+numpy>=1.24

server/stabilizer_forge_environment.py

@@ -0,0 +1,294 @@
+"""StabilizerForge environment.
+
+Episode loop:
+  reset(task_id?)        -> sample/load a task; emit initial observation
+  step(action)           -> apply one Clifford gate, or FINALIZE
+                            returns dense shaping reward per step,
+                            full terminal reward at FINALIZE.
+"""
+from __future__ import annotations
+
+import json
+import os
+import random
+from pathlib import Path
+from typing import Any
+from uuid import uuid4
+
+from openenv.core.env_server.interfaces import Environment
+from openenv.core.env_server.types import State
+
+try:
+    from ..models import StabilizerAction, StabilizerObservation
+    from .verifier import match_fraction
+except ImportError:  # pragma: no cover  (in-container imports without package context)
+    from models import StabilizerAction, StabilizerObservation
+    from server.verifier import match_fraction
+
+
+# Reward weights (keep aligned with README)
+W_MATCH = 0.4
+W_GATE_EFF = 0.2
+W_TWOQ_EFF = 0.2
+W_CONN = 0.1
+W_FORMAT = 0.1
+SHAPING_COEF = 0.05  # per-step Δmatch_fraction shaping
+MAX_CONSECUTIVE_VIOLATIONS = 5
+
+
+def _default_tasks_path() -> str:
+    """Resolve the default tasks file. Looks for env var, then sibling tasks.jsonl."""
+    env_path = os.environ.get("STABILIZER_FORGE_TASKS")
+    if env_path:
+        return env_path
+    here = Path(__file__).resolve().parent.parent  # stabilizer_forge/
+    candidate = here / "tasks.jsonl"
+    if candidate.exists():
+        return str(candidate)
+    # Fallback: project root
+    return str(here.parent / "tasks.jsonl")
+
+
+def _load_tasks(path: str) -> list[dict]:
+    p = Path(path)
+    if not p.exists():
+        return []
+    tasks: list[dict] = []
+    with p.open() as f:
+        for line in f:
+            line = line.strip()
+            if not line:
+                continue
+            tasks.append(json.loads(line))
+    return tasks
+
+
+def _gate_to_stim(action: StabilizerAction) -> str:
+    """Render a single action as one line of Stim text."""
+    if action.op in {"H", "S"}:
+        return f"{action.op} {action.qubits[0]}"
+    if action.op == "CX":
+        return f"CX {action.qubits[0]} {action.qubits[1]}"
+    raise ValueError(f"Cannot render gate: {action.op}")
+
+
+def _validate_action(
+    action: StabilizerAction, n_qubits: int
+) -> tuple[bool, str]:
+    """Schema/range validation. Returns (is_valid, error_msg)."""
+    if action.op == "FINALIZE":
+        if action.qubits:
+            return False, "FINALIZE takes no qubits."
+        return True, ""
+    if action.op in {"H", "S"}:
+        if len(action.qubits) != 1:
+            return False, f"{action.op} requires exactly 1 qubit, got {len(action.qubits)}."
+        q = action.qubits[0]
+        if not (0 <= q < n_qubits):
+            return False, f"qubit {q} out of range [0, {n_qubits})."
+        return True, ""
+    if action.op == "CX":
+        if len(action.qubits) != 2:
+            return False, f"CX requires exactly 2 qubits, got {len(action.qubits)}."
+        c, t = action.qubits
+        if c == t:
+            return False, "CX control and target must differ."
+        for q in (c, t):
+            if not (0 <= q < n_qubits):
+                return False, f"qubit {q} out of range [0, {n_qubits})."
+        return True, ""
+    return False, f"unknown op {action.op}"
+
+
+class StabilizerForgeEnvironment(Environment):
+    """Single-agent env: emit Clifford gates to encode a target stabilizer code."""
+
+    SUPPORTS_CONCURRENT_SESSIONS: bool = True
+
+    def __init__(self, tasks_path: str | None = None):
+        super().__init__()
+        self._tasks_path = tasks_path or _default_tasks_path()
+        self._tasks = _load_tasks(self._tasks_path)
+        self._task: dict[str, Any] | None = None
+        self._gates: list[str] = []
+        self._cnot_count = 0
+        self._nonadj_cnot_count = 0
+        self._format_violations = 0
+        self._consecutive_violations = 0
+        self._last_match_fraction = 0.0
+        self._last_match_results: list[bool] = []
+        self._finalized = False
+        self._rng = random.Random()
+        self._state = State(episode_id=str(uuid4()), step_count=0)
+
+    # ---------- Helpers ----------
+
+    def _circuit_text(self) -> str:
+        return "\n".join(self._gates)
+
+    def _is_adjacent(self, a: int, b: int) -> bool:
+        edges = self._task.get("connectivity_edges") if self._task else None
+        if edges is None:
+            return True  # all-to-all
+        edge_set = {tuple(sorted(e)) for e in edges}
+        return tuple(sorted((a, b))) in edge_set
+
+    def _compute_match(self) -> tuple[float, list[bool]]:
+        if not self._task:
+            return 0.0, []
+        text = self._circuit_text()
+        n = self._task["n_qubits"]
+        targets = self._task["target_stabilizers"]
+        frac, results_dict = match_fraction(text, targets, n)
+        ordered = [results_dict[s] for s in targets]
+        return frac, ordered
+
+    def _make_obs(
+        self,
+        *,
+        reward: float,
+        done: bool,
+        last_action_valid: bool = True,
+        last_action_error: str = "",
+    ) -> StabilizerObservation:
+        assert self._task is not None
+        bench = int(self._task.get("benchmark_optimum", 0) or 0)
+        return StabilizerObservation(
+            task_id=self._task["task_id"],
+            target_stabilizers=list(self._task["target_stabilizers"]),
+            n_qubits=int(self._task["n_qubits"]),
+            connectivity_edges=self._task.get("connectivity_edges"),
+            gates_so_far=list(self._gates),
+            current_circuit=self._circuit_text(),
+            current_match=list(self._last_match_results),
+            match_fraction=float(self._last_match_fraction),
+            gates_emitted=len(self._gates),
+            cnot_count=self._cnot_count,
+            nonadj_cnot_count=self._nonadj_cnot_count,
+            gate_budget=int(self._task.get("gate_budget", 2 * max(1, bench))),
+            gate_budget_remaining=max(
+                0,
+                int(self._task.get("gate_budget", 2 * max(1, bench))) - len(self._gates),
+            ),
+            benchmark_optimum=bench,
+            benchmark_optimum_2q=int(self._task.get("benchmark_optimum_2q", 0) or 0),
+            format_violations=self._format_violations,
+            consecutive_violations=self._consecutive_violations,
+            last_action_valid=last_action_valid,
+            last_action_error=last_action_error,
+            step_count=self._state.step_count,
+            finalized=self._finalized,
+            done=done,
+            reward=reward,
+        )
+
+    def _pick_task(self, task_id: str | None, seed: int | None) -> dict[str, Any]:
+        if task_id is not None:
+            for t in self._tasks:
+                if t.get("task_id") == task_id:
+                    return t
+            raise ValueError(f"task_id '{task_id}' not found in {self._tasks_path}")
+        if not self._tasks:
+            raise RuntimeError(
+                f"No tasks loaded from {self._tasks_path}. "
+                "Set STABILIZER_FORGE_TASKS or place tasks.jsonl next to the env."
+            )
+        rng = random.Random(seed) if seed is not None else self._rng
+        return rng.choice(self._tasks)
+
+    # ---------- Gym API ----------
+
+    def reset(
+        self,
+        seed: int | None = None,
+        episode_id: str | None = None,
+        task_id: str | None = None,
+        **kwargs: Any,
+    ) -> StabilizerObservation:
+        if seed is not None:
+            self._rng = random.Random(seed)
+        self._task = self._pick_task(task_id=task_id, seed=seed)
+
+        self._gates = []
+        self._cnot_count = 0
+        self._nonadj_cnot_count = 0
+        self._format_violations = 0
+        self._consecutive_violations = 0
+        self._finalized = False
+        self._state = State(
+            episode_id=episode_id or str(uuid4()), step_count=0
+        )
+
+        # Initial match (empty circuit on |0...0>)
+        self._last_match_fraction, self._last_match_results = self._compute_match()
+        return self._make_obs(reward=0.0, done=False)
+
+    def step(self, action: StabilizerAction, **kwargs: Any) -> StabilizerObservation:  # type: ignore[override]
+        if self._task is None:
+            raise RuntimeError("step() called before reset().")
+        self._state.step_count += 1
+
+        n_qubits = int(self._task["n_qubits"])
+        gate_budget = int(
+            self._task.get(
+                "gate_budget", 2 * max(1, int(self._task.get("benchmark_optimum", 1)))
+            )
+        )
+
+        # --- Validate ---
+        ok, err = _validate_action(action, n_qubits)
+        if not ok:
+            self._format_violations += 1
+            self._consecutive_violations += 1
+            done = (
+                self._consecutive_violations >= MAX_CONSECUTIVE_VIOLATIONS
+                or len(self._gates) >= gate_budget
+            )
+            return self._make_obs(
+                reward=W_FORMAT * -1.0,
+                done=done,
+                last_action_valid=False,
+                last_action_error=err,
+            )
+
+        self._consecutive_violations = 0
+
+        # --- FINALIZE: terminal reward ---
+        if action.op == "FINALIZE":
+            self._finalized = True
+            self._last_match_fraction, self._last_match_results = self._compute_match()
+            bench = max(1, int(self._task.get("benchmark_optimum", 1)))
+            bench_2q = max(1, int(self._task.get("benchmark_optimum_2q", bench)))
+            gate_eff = max(0.0, 1.0 - len(self._gates) / (1.5 * bench))
+            twoq_eff = max(0.0, 1.0 - self._cnot_count / (1.5 * bench_2q))
+            terminal = (
+                W_MATCH * self._last_match_fraction
+                + W_GATE_EFF * gate_eff
+                + W_TWOQ_EFF * twoq_eff
+            )
+            return self._make_obs(reward=terminal, done=True)
+
+        # --- Apply gate ---
+        gate_str = _gate_to_stim(action)
+        self._gates.append(gate_str)
+
+        conn_penalty = 0.0
+        if action.op == "CX":
+            self._cnot_count += 1
+            if not self._is_adjacent(action.qubits[0], action.qubits[1]):
+                self._nonadj_cnot_count += 1
+                conn_penalty = -1.0
+
+        prev_match = self._last_match_fraction
+        self._last_match_fraction, self._last_match_results = self._compute_match()
+        delta = self._last_match_fraction - prev_match
+
+        # Termination if we exceed budget without finalizing
+        done = len(self._gates) >= gate_budget
+
+        step_reward = SHAPING_COEF * delta + W_CONN * conn_penalty
+        return self._make_obs(reward=step_reward, done=done)
+
+    @property
+    def state(self) -> State:
+        return self._state

server/verifier.py

@@ -0,0 +1,64 @@
+"""Stim-based stabilizer verifier.
+
+Vendored / adapted from uw-math-ai/quantum-ai's tools/check_stabilizers.py.
+The core check uses Stim's TableauSimulator + peek_observable_expectation,
+which is exact and polynomial in the number of qubits for Clifford circuits.
+"""
+from __future__ import annotations
+
+import re
+
+import stim
+
+
+def preprocess_stim_text(raw: str) -> str:
+    if raw is None:
+        return ""
+    text = raw.strip().replace("\\n", "\n")
+    lines = []
+    for line in text.splitlines():
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue
+        line = re.sub(r"\s+", " ", line)
+        lines.append(line)
+    return "\n".join(lines) + ("\n" if lines else "")
+
+
+def check_stabilizers(
+    circuit_text: str, stabilizers: list[str], n_qubits: int | None = None
+) -> dict[str, bool]:
+    """Return {stabilizer: preserved?} for a circuit applied to |0...0>.
+
+    If n_qubits is provided, ensures the simulator has at least that many qubits
+    by prepending an I gate on qubit n-1. This matters because Stim's simulator
+    only allocates qubits that are touched by the circuit.
+    """
+    text = preprocess_stim_text(circuit_text)
+    if n_qubits is not None and n_qubits > 0:
+        text = f"I {n_qubits - 1}\n" + text
+    if not text:
+        text = "I 0\n"
+
+    circ = stim.Circuit(text)
+    sim = stim.TableauSimulator()
+    sim.do(circ)
+
+    width = max(circ.num_qubits, n_qubits or 0)
+    results: dict[str, bool] = {}
+    for stab in stabilizers:
+        padded = stab + "I" * max(0, width - len(stab))
+        pauli = stim.PauliString(padded)
+        expectation = sim.peek_observable_expectation(pauli)
+        results[stab] = expectation > 0
+    return results
+
+
+def match_fraction(
+    circuit_text: str, stabilizers: list[str], n_qubits: int
+) -> tuple[float, dict[str, bool]]:
+    res = check_stabilizers(circuit_text, stabilizers, n_qubits=n_qubits)
+    if not res:
+        return 0.0, res
+    frac = sum(1 for v in res.values() if v) / len(res)
+    return frac, res

tasks.jsonl

@@ -0,0 +1,29 @@
+{"task_id": "ghz2", "source_code": "Bell state", "n_qubits": 2, "target_stabilizers": ["XX", "ZZ"], "connectivity_edges": null, "gate_budget": 20, "benchmark_optimum": 2, "benchmark_optimum_2q": 1, "tier": 1}
+{"task_id": "ghz3", "source_code": "3-qubit GHZ", "n_qubits": 3, "target_stabilizers": ["XXX", "ZZI", "IZZ"], "connectivity_edges": null, "gate_budget": 20, "benchmark_optimum": 3, "benchmark_optimum_2q": 2, "tier": 1}
+{"task_id": "ghz4", "source_code": "4-qubit GHZ", "n_qubits": 4, "target_stabilizers": ["XXXX", "ZZII", "IZZI", "IIZZ"], "connectivity_edges": null, "gate_budget": 20, "benchmark_optimum": 4, "benchmark_optimum_2q": 3, "tier": 1}
+{"task_id": "ghz5", "source_code": "5-qubit GHZ", "n_qubits": 5, "target_stabilizers": ["XXXXX", "ZZIII", "IZZII", "IIZZI", "IIIZZ"], "connectivity_edges": null, "gate_budget": 20, "benchmark_optimum": 5, "benchmark_optimum_2q": 4, "tier": 1}
+{"task_id": "ghz6", "source_code": "6-qubit GHZ", "n_qubits": 6, "target_stabilizers": ["XXXXXX", "ZZIIII", "IZZIII", "IIZZII", "IIIZZI", "IIIIZZ"], "connectivity_edges": null, "gate_budget": 24, "benchmark_optimum": 6, "benchmark_optimum_2q": 5, "tier": 1}
+{"task_id": "ghz7", "source_code": "7-qubit GHZ", "n_qubits": 7, "target_stabilizers": ["XXXXXXX", "ZZIIIII", "IZZIIII", "IIZZIII", "IIIZZII", "IIIIZZI", "IIIIIZZ"], "connectivity_edges": null, "gate_budget": 28, "benchmark_optimum": 7, "benchmark_optimum_2q": 6, "tier": 1}
+{"task_id": "ghz8", "source_code": "8-qubit GHZ", "n_qubits": 8, "target_stabilizers": ["XXXXXXXX", "ZZIIIIII", "IZZIIIII", "IIZZIIII", "IIIZZIII", "IIIIZZII", "IIIIIZZI", "IIIIIIZZ"], "connectivity_edges": null, "gate_budget": 32, "benchmark_optimum": 8, "benchmark_optimum_2q": 7, "tier": 1}
+{"task_id": "ghz9", "source_code": "9-qubit GHZ", "n_qubits": 9, "target_stabilizers": ["XXXXXXXXX", "ZZIIIIIII", "IZZIIIIII", "IIZZIIIII", "IIIZZIIII", "IIIIZZIII", "IIIIIZZII", "IIIIIIZZI", "IIIIIIIZZ"], "connectivity_edges": null, "gate_budget": 36, "benchmark_optimum": 9, "benchmark_optimum_2q": 8, "tier": 2}
+{"task_id": "ghz10", "source_code": "10-qubit GHZ", "n_qubits": 10, "target_stabilizers": ["XXXXXXXXXX", "ZZIIIIIIII", "IZZIIIIIII", "IIZZIIIIII", "IIIZZIIIII", "IIIIZZIIII", "IIIIIZZIII", "IIIIIIZZII", "IIIIIIIZZI", "IIIIIIIIZZ"], "connectivity_edges": null, "gate_budget": 40, "benchmark_optimum": 10, "benchmark_optimum_2q": 9, "tier": 2}
+{"task_id": "ghz11", "source_code": "11-qubit GHZ", "n_qubits": 11, "target_stabilizers": ["XXXXXXXXXXX", "ZZIIIIIIIII", "IZZIIIIIIII", "IIZZIIIIIII", "IIIZZIIIIII", "IIIIZZIIIII", "IIIIIZZIIII", "IIIIIIZZIII", "IIIIIIIZZII", "IIIIIIIIZZI", "IIIIIIIIIZZ"], "connectivity_edges": null, "gate_budget": 44, "benchmark_optimum": 11, "benchmark_optimum_2q": 10, "tier": 2}
+{"task_id": "ghz12", "source_code": "12-qubit GHZ", "n_qubits": 12, "target_stabilizers": ["XXXXXXXXXXXX", "ZZIIIIIIIIII", "IZZIIIIIIIII", "IIZZIIIIIIII", "IIIZZIIIIIII", "IIIIZZIIIIII", "IIIIIZZIIIII", "IIIIIIZZIIII", "IIIIIIIZZIII", "IIIIIIIIZZII", "IIIIIIIIIZZI", "IIIIIIIIIIZZ"], "connectivity_edges": null, "gate_budget": 48, "benchmark_optimum": 12, "benchmark_optimum_2q": 11, "tier": 2}
+{"task_id": "ghz13", "source_code": "13-qubit GHZ", "n_qubits": 13, "target_stabilizers": ["XXXXXXXXXXXXX", "ZZIIIIIIIIIII", "IZZIIIIIIIIII", "IIZZIIIIIIIII", "IIIZZIIIIIIII", "IIIIZZIIIIIII", "IIIIIZZIIIIII", "IIIIIIZZIIIII", "IIIIIIIZZIIII", "IIIIIIIIZZIII", "IIIIIIIIIZZII", "IIIIIIIIIIZZI", "IIIIIIIIIIIZZ"], "connectivity_edges": null, "gate_budget": 52, "benchmark_optimum": 13, "benchmark_optimum_2q": 12, "tier": 2}
+{"task_id": "iceberg_code_m_2", "source_code": "Iceberg Code m=2", "n_qubits": 4, "target_stabilizers": ["XXXX", "ZZZZ"], "connectivity_edges": null, "gate_budget": 20, "benchmark_optimum": 6, "benchmark_optimum_2q": 5, "tier": 1}
+{"task_id": "4-qubit_detector_code", "source_code": "4-Qubit Detector Code", "n_qubits": 4, "target_stabilizers": ["XXXX", "ZZZZ"], "connectivity_edges": null, "gate_budget": 20, "benchmark_optimum": 6, "benchmark_optimum_2q": 5, "tier": 1}
+{"task_id": "iceberg_code_m_3", "source_code": "Iceberg Code m=3", "n_qubits": 6, "target_stabilizers": ["XXXXXX", "ZZZZZZ"], "connectivity_edges": null, "gate_budget": 30, "benchmark_optimum": 10, "benchmark_optimum_2q": 9, "tier": 1}
+{"task_id": "hypercube_code_l_1", "source_code": "Hypercube Code l=1", "n_qubits": 6, "target_stabilizers": ["XXXXXX", "ZZZZZZ"], "connectivity_edges": null, "gate_budget": 30, "benchmark_optimum": 10, "benchmark_optimum_2q": 9, "tier": 1}
+{"task_id": "iceberg_code_m_4", "source_code": "Iceberg Code m=4", "n_qubits": 8, "target_stabilizers": ["XXXXXXXX", "ZZZZZZZZ"], "connectivity_edges": null, "gate_budget": 42, "benchmark_optimum": 14, "benchmark_optimum_2q": 13, "tier": 1}
+{"task_id": "perfect_5-qubit_code", "source_code": "Perfect 5-Qubit Code", "n_qubits": 5, "target_stabilizers": ["XZZXI", "IXZZX", "XIXZZ", "ZXIXZ"], "connectivity_edges": null, "gate_budget": 114, "benchmark_optimum": 38, "benchmark_optimum_2q": 19, "tier": 2}
+{"task_id": "steane", "source_code": "Steane", "n_qubits": 7, "target_stabilizers": ["XXIIXXI", "XIXIXIX", "IIIXXXX", "ZZIIZZI", "ZIZIZIZ", "IIIZZZZ"], "connectivity_edges": null, "gate_budget": 78, "benchmark_optimum": 26, "benchmark_optimum_2q": 23, "tier": 2}
+{"task_id": "shor", "source_code": "Shor", "n_qubits": 9, "target_stabilizers": ["XXXXXXIII", "XXXIIIXXX", "ZZIIIIIII", "ZIZIIIIII", "IIIZZIIII", "IIIZIZIII", "IIIIIIZZI", "IIIIIIZIZ"], "connectivity_edges": null, "gate_budget": 75, "benchmark_optimum": 25, "benchmark_optimum_2q": 23, "tier": 2}
+{"task_id": "rotated_surface_code_d_3", "source_code": "Rotated Surface Code d=3", "n_qubits": 9, "target_stabilizers": ["XXIXXIIII", "IIIIXXIXX", "IIXIIXIII", "IIIXIIXII", "IIIZZIZZI", "IZZIZZIII", "ZZIIIIIII", "IIIIIIIZZ"], "connectivity_edges": null, "gate_budget": 69, "benchmark_optimum": 23, "benchmark_optimum_2q": 19, "tier": 2}
+{"task_id": "hex_color_code_d_3", "source_code": "Hex Color Code d=3", "n_qubits": 7, "target_stabilizers": ["XXXXIII", "XIXIXIX", "IIXXXXI", "ZZZZIII", "ZIZIZIZ", "IIZZZZI"], "connectivity_edges": null, "gate_budget": 60, "benchmark_optimum": 20, "benchmark_optimum_2q": 17, "tier": 2}
+{"task_id": "square_octagon_color_code_d_3", "source_code": "Square Octagon Color Code d=3", "n_qubits": 7, "target_stabilizers": ["IIXIXXX", "IXIXIXX", "XXXIIXI", "IIZIZZZ", "IZIZIZZ", "ZZZIIZI"], "connectivity_edges": null, "gate_budget": 66, "benchmark_optimum": 22, "benchmark_optimum_2q": 19, "tier": 2}
+{"task_id": "carbon", "source_code": "Carbon", "n_qubits": 12, "target_stabilizers": ["XXXIIIXXXIII", "IIXXXIIIXXXI", "XIIIXXXIIIXX", "XXXXXXIIIIII", "IIIIIIXXXXXX", "IIZZZZIZIZII", "ZIIIZIZZZIIZ", "ZZZIIZZIIIZI", "ZIIZZZIIZIZI", "IZZIIIZZIZIZ"], "connectivity_edges": null, "gate_budget": 201, "benchmark_optimum": 67, "benchmark_optimum_2q": 62, "tier": 2}
+{"task_id": "tetrahedral", "source_code": "Tetrahedral", "n_qubits": 15, "target_stabilizers": ["XXXXXXXXIIIIIII", "IXXIXXIIXXIXXII", "IIXXIXXIIXXXIXI", "IIIIXXXXIIIXXXX", "ZZZZIIIIIIIIIII", "IZZIZZIIIIIIIII", "IIZZIZZIIIIIIII", "IIIIZZZZIIIIIII", "IZIIZIIIZIIIZII", "IIZIIZIIIZIZIII", "IIZZIIIIIZZIIII", "IIIIZZIIIIIZZII", "IIIIIZZIIIIZIZI", "IIIIIIZZIIIIIZZ"], "connectivity_edges": null, "gate_budget": 168, "benchmark_optimum": 56, "benchmark_optimum_2q": 52, "tier": 3}
+{"task_id": "hamming", "source_code": "Hamming", "n_qubits": 15, "target_stabilizers": ["IIIIIIIXXXXXXXX", "IIIXXXXIIIIXXXX", "IXXIIXXIIXXIIXX", "XIXIXIXIXIXIXIX", "IIIIIIIZZZZZZZZ", "IIIZZZZIIIIZZZZ", "IZZIIZZIIZZIIZZ", "ZIZIZIZIZIZIZIZ"], "connectivity_edges": null, "gate_budget": 207, "benchmark_optimum": 69, "benchmark_optimum_2q": 65, "tier": 3}
+{"task_id": "square_octagon_color_code_d_5", "source_code": "Square Octagon Color Code d=5", "n_qubits": 17, "target_stabilizers": ["IIIIIXIIIXIXXIIII", "IIIIIIIIXIXIIXIXI", "IIIXIIIXIIIIIIXIX", "IIXIIIXIIIIIIIXIX", "IIIIXXXXXIXXIIIIX", "IXIIXIIIIIXIIXIII", "IIIIIIIIXXIXIIIXI", "XIXXIIIIIIIIIIXII", "IIIIIZIIIZIZZIIII", "IIIIIIIIZIZIIZIZI", "IIIZIIIZIIIIIIZIZ", "IIZIIIZIIIIIIIZIZ", "IIIIZZZZZIZZIIIIZ", "IZIIZIIIIIZIIZIII", "IIIIIIIIZZIZIIIZI", "ZIZZIIIIIIIIIIZII"], "connectivity_edges": null, "gate_budget": 288, "benchmark_optimum": 96, "benchmark_optimum_2q": 88, "tier": 3}
+{"task_id": "hex_color_code_d_5", "source_code": "Hex Color Code d=5", "n_qubits": 19, "target_stabilizers": ["IIXIIXIIXXIIIIIIIII", "IIIIIIIIIIXIXIIIIXX", "IIIIIIIIIIXXIXIIIIX", "XXIIIIIIIIIIIIXXIII", "XXIXXIXIIIIIIIIIXII", "IIXIXIIIXIIIIIIIXII", "IXIIIIXXIIIIIIIXIII", "IIIXIIXXIIXXXIIIIII", "IIIXXIIIXXIXIXIIIII", "IIZIIZIIZZIIIIIIIII", "IIIIIIIIIIZIZIIIIZZ", "IIIIIIIIIIZZIZIIIIZ", "ZZIIIIIIIIIIIIZZIII", "ZZIZZIZIIIIIIIIIZII", "IIZIZIIIZIIIIIIIZII", "IZIIIIZZIIIIIIIZIII", "IIIZIIZZIIZZZIIIIII", "IIIZZIIIZZIZIZIIIII"], "connectivity_edges": null, "gate_budget": 333, "benchmark_optimum": 111, "benchmark_optimum_2q": 102, "tier": 3}
+{"task_id": "rotated_surface_code_d_5", "source_code": "Rotated Surface Code d=5", "n_qubits": 25, "target_stabilizers": ["XXIIIXXIIIIIIIIIIIIIIIIII", "IIIIIIIIIIXXIIIXXIIIIIIII", "IIIIIIXXIIIXXIIIIIIIIIIII", "IIIIIIIIIIIIIIIIXXIIIXXII", "IIXXIIIXXIIIIIIIIIIIIIIII", "IIIIIIIIIIIIXXIIIXXIIIIII", "IIIIIIIIXXIIIXXIIIIIIIIII", "IIIIIIIIIIIIIIIIIIXXIIIXX", "IIIIXIIIIXIIIIIIIIIIIIIII", "IIIIIXIIIIXIIIIIIIIIIIIII", "IIIIIIIIIIIIIIXIIIIXIIIII", "IIIIIIIIIIIIIIIXIIIIXIIII", "IIIIIZZIIIZZIIIIIIIIIIIII", "IIIIIIIIIIIIIIIZZIIIZZIII", "IZZIIIZZIIIIIIIIIIIIIIIII", "IIIIIIIIIIIZZIIIZZIIIIIII", "IIIIIIIZZIIIZZIIIIIIIIIII", "IIIIIIIIIIIIIIIIIZZIIIZZI", "IIIZZIIIZZIIIIIIIIIIIIIII", "IIIIIIIIIIIIIZZIIIZZIIIII", "ZZIIIIIIIIIIIIIIIIIIIIIII", "IIIIIIIIIIIIIIIIIIIIIZZII", "IIZZIIIIIIIIIIIIIIIIIIIII", "IIIIIIIIIIIIIIIIIIIIIIIZZ"], "connectivity_edges": null, "gate_budget": 348, "benchmark_optimum": 116, "benchmark_optimum_2q": 104, "tier": 3}