Datasets:

SQuADDS
/

SQuADDS_Layout_Embeddings

#!/usr/bin/env python
"""Expanded capacitance-transfer study using the Tutorial 24/25 corpora.
The study joins the 45k-layout v4 study library to all available capacitance
labels: 20,062 Generalized IDC records across exports/exp7/exp8, 894 CapN Tee
records, and 1,933 unique Transmon records from the full v3/v4 release.  It also
audits the 16,379 raw exp8 per-pass matrices and measures support for the
unlabeled asymmetric IDC, concentric, star, and Firas campaigns.
"""

from __future__ import annotations

import argparse
import csv
import hashlib
import json
import math
import platform
import sys
from dataclasses import dataclass
from pathlib import Path
from typing import Any, Iterable

import numpy as np
import pandas as pd
from huggingface_hub import hf_hub_download
from scipy.optimize import minimize_scalar
from scipy.spatial import cKDTree
from scipy.stats import spearmanr

from squadds.layouts import canonical_design_id


SEED = 20261001
CAP_FLOOR_FF = 0.01
HUBER_DELTA = 0.05
TAU_LOG = 0.10
GIDC = "GeneralizedCapNInterdigital"
CAPN = "CapNInterdigitalTee"
TRANSMON = "TransmonCross"
TOPOLOGY_FAMILIES = (GIDC, CAPN, TRANSMON)
LABELED_GIDC_CAMPAIGNS = ("exports", "exp7_exports", "exp8_exports")
UNLABELED_CAMPAIGNS = (
    "exp9_exports",
    "exp10_exports",
    "exp11_exports",
    "firas_sims_exp1",
    "firas_sims_exp2",
)
RAW_SPECS = {
    GIDC: {
        "file": "coupler-GeneralizedCapNInterdigital-cap_matrix.json",
        "a": "north",
        "b": "south",
    },
    CAPN: {
        "file": "coupler-CapNInterdigitalTee-cap_matrix.json",
        "a": "top",
        "b": "bottom",
    },
    TRANSMON: {
        "file": "qubit-TransmonCross-cap_matrix.json",
        "a": "cross",
        "b": "claw",
    },
}


def sha256(path: Path) -> str:
    digest = hashlib.sha256()
    with path.open("rb") as stream:
        for block in iter(lambda: stream.read(1024 * 1024), b""):
            digest.update(block)
    return digest.hexdigest()


def stack(series: pd.Series) -> np.ndarray:
    matrix = np.vstack(series.map(np.asarray).to_numpy()).astype(np.float64)
    if not np.isfinite(matrix).all():
        raise ValueError("Non-finite representation values found.")
    return matrix


def huber(error: np.ndarray, delta: float = HUBER_DELTA) -> np.ndarray:
    absolute = np.abs(error)
    return np.where(absolute <= delta, 0.5 * error**2, delta * (absolute - 0.5 * delta))


def group_balanced_weights(groups: np.ndarray) -> np.ndarray:
    groups = np.asarray(groups)
    result = np.zeros(len(groups), dtype=np.float64)
    unique = np.unique(groups)
    for group in unique:
        mask = groups == group
        result[mask] = 1.0 / (len(unique) * mask.sum())
    return result * len(result)


def fit_offset(
    observed: np.ndarray,
    base: np.ndarray,
    groups: np.ndarray | None = None,
) -> float:
    weights = np.ones(len(observed)) if groups is None else group_balanced_weights(groups)
    weights = weights / weights.sum()
    objective = lambda value: float(
        np.sum(weights * huber(observed - (base + float(value))))
    )
    return float(minimize_scalar(objective, bounds=(-10.0, 10.0), method="bounded").x)


@dataclass
class RandomFeatureRidge:
    seed: int
    features: int = 96
    alpha: float = 1.0

    def fit(
        self,
        matrix: np.ndarray,
        target: np.ndarray,
        sample_weight: np.ndarray | None = None,
    ) -> "RandomFeatureRidge":
        matrix = np.asarray(matrix, dtype=np.float64)
        target = np.asarray(target, dtype=np.float64)
        weights = np.ones(len(matrix), dtype=np.float64) if sample_weight is None else np.asarray(sample_weight)
        weights = weights * (len(weights) / weights.sum())
        self.mean_ = np.average(matrix, axis=0, weights=weights)
        centered = matrix - self.mean_
        self.scale_ = np.sqrt(np.average(centered**2, axis=0, weights=weights))
        self.scale_ = np.where(self.scale_ > 1e-8, self.scale_, 1.0)
        standardized = np.clip(centered / self.scale_, -8.0, 8.0)
        rng = np.random.default_rng(self.seed)
        self.weights_ = rng.normal(
            0.0,
            1.0 / math.sqrt(max(matrix.shape[1], 1)),
            (matrix.shape[1], self.features),
        )
        self.phase_ = rng.uniform(0.0, 2.0 * np.pi, self.features)
        design = self._design(standardized)
        weighted_design = design * np.sqrt(weights)[:, None]
        weighted_target = target * np.sqrt(weights)[:, None] if target.ndim == 2 else target * np.sqrt(weights)
        penalty = np.eye(design.shape[1]) * self.alpha
        penalty[0, 0] = 0.0
        self.coefficients_ = np.linalg.solve(
            weighted_design.T @ weighted_design + penalty,
            weighted_design.T @ weighted_target,
        )
        return self

    def _design(self, standardized: np.ndarray) -> np.ndarray:
        nonlinear = np.sqrt(2.0 / self.features) * np.cos(
            standardized @ self.weights_ + self.phase_
        )
        return np.column_stack([np.ones(len(standardized)), nonlinear])

    def predict(self, matrix: np.ndarray) -> np.ndarray:
        standardized = np.clip((np.asarray(matrix) - self.mean_) / self.scale_, -8.0, 8.0)
        return self._design(standardized) @ self.coefficients_


def load_raw_databases(local_only: bool):
    labels: dict[str, dict[str, dict[str, Any]]] = {}
    paths: dict[str, Path] = {}
    summaries: list[dict[str, Any]] = []
    for family, spec in RAW_SPECS.items():
        path = Path(
            hf_hub_download(
                "SQuADDS/SQuADDS_DB",
                spec["file"],
                repo_type="dataset",
                local_files_only=local_only,
            )
        )
        paths[family] = path
        a, b = spec["a"], spec["b"]
        buckets: dict[str, list[dict[str, Any]]] = {}
        for row in json.loads(path.read_text(encoding="utf-8")):
            result = row["sim_results"]
            design_id = canonical_design_id(family, row["design"]["design_options"])
            record: dict[str, Any] = {
                "design_id": design_id,
                "mutual_fF": abs(float(result[f"{a}_to_{b}"])),
                "ground_a_fF": abs(float(result[f"{a}_to_ground"])),
                "ground_b_fF": abs(float(result[f"{b}_to_ground"])),
                "diag_a_fF": abs(float(result[f"{a}_to_{a}"])),
                "diag_b_fF": abs(float(result[f"{b}_to_{b}"])),
                "diag_ground_fF": abs(float(result["ground_to_ground"])),
            }
            record["ground_sum_fF"] = record["ground_a_fF"] + record["ground_b_fF"]
            matrix = result.get("maxwell_matrix")
            if matrix:
                letters = (a[0].upper(), b[0].upper(), "G")
                value = np.asarray(
                    [[float(matrix[f"C_{first}_{second}"]) for second in letters] for first in letters],
                    dtype=np.float64,
                )
                eigenvalues = np.linalg.eigvalsh((value + value.T) / 2.0)
                record["matrix_json"] = json.dumps(value.tolist())
                for index, eigenvalue in enumerate(eigenvalues):
                    record[f"matrix_eigen_{index}_fF"] = float(eigenvalue)
            buckets.setdefault(design_id, []).append(record)
        family_labels: dict[str, dict[str, Any]] = {}
        duplicate_spreads = []
        for design_id, records in buckets.items():
            record = dict(records[0])
            numeric = [
                key
                for key in record
                if key != "design_id" and isinstance(record[key], (float, int))
            ]
            for key in numeric:
                values = np.asarray([item[key] for item in records], dtype=np.float64)
                record[key] = float(values.mean())
                if len(values) > 1:
                    duplicate_spreads.append(
                        float((values.max() - values.min()) / max(abs(values.mean()), CAP_FLOOR_FF))
                    )
            if len(records) > 1 and all("matrix_json" in item for item in records):
                matrices = np.stack([np.asarray(json.loads(item["matrix_json"])) for item in records])
                matrix = matrices.mean(axis=0)
                record["matrix_json"] = json.dumps(matrix.tolist())
                for index, eigenvalue in enumerate(np.linalg.eigvalsh((matrix + matrix.T) / 2.0)):
                    record[f"matrix_eigen_{index}_fF"] = float(eigenvalue)
            record["duplicate_label_count"] = len(records)
            family_labels[design_id] = record
        summaries.append(
            {
                "family": family,
                "database_rows": sum(len(items) for items in buckets.values()),
                "unique_designs": len(buckets),
                "duplicate_rows": sum(len(items) - 1 for items in buckets.values()),
                "maximum_duplicate_relative_spread": max(duplicate_spreads, default=0.0),
                "full_matrix_designs": sum("matrix_json" in item for item in family_labels.values()),
            }
        )
        labels[family] = family_labels
    return labels, paths, pd.DataFrame(summaries)


def proxy_values(value: str) -> tuple[float, float, float, list[float]]:
    matrix = np.asarray(json.loads(value), dtype=np.float64)
    if matrix.shape != (3, 3):
        raise ValueError(f"Expected a 3x3 proxy matrix, found {matrix.shape}.")
    mutual = abs(float(matrix[0, 1]))
    ground_a = abs(float(matrix[0, 2]))
    ground_b = abs(float(matrix[1, 2]))
    eigenvalues = np.maximum(np.linalg.eigvalsh((matrix + matrix.T) / 2.0), 0.0)
    return mutual, ground_a + ground_b, abs(ground_a - ground_b), eigenvalues.tolist()


def proxy_values_from_embedding(value: Any) -> tuple[float, float, float, list[float]]:
    """Recover the v4 two-terminal proxy branches from the pooled layout view."""
    embedding = np.asarray(value, dtype=np.float64)
    if embedding.shape != (544,):
        raise ValueError(f"Expected a 544-D v4 layout view, found {embedding.shape}.")
    # Indices 82 and 146 pool log1p(node-to-ground proxy) over the two nodes.
    mean_ground_log = float(embedding[82])
    std_ground_log = abs(float(embedding[146]))
    ground_a, ground_b = np.expm1(
        [mean_ground_log + std_ground_log, mean_ground_log - std_ground_log]
    )
    ground_a, ground_b = max(float(ground_a), 0.0), max(float(ground_b), 0.0)
    # Global index 55 is log1p of the sum of all unordered proxy branches.
    total_branches = max(float(np.expm1(embedding[55])), 0.0)
    mutual = max(total_branches - ground_a - ground_b, 0.0)
    matrix = np.asarray(
        [
            [mutual + ground_a, -mutual, -ground_a],
            [-mutual, mutual + ground_b, -ground_b],
            [-ground_a, -ground_b, ground_a + ground_b],
        ]
    )
    eigenvalues = np.maximum(np.linalg.eigvalsh(matrix), 0.0)
    return mutual, ground_a + ground_b, abs(ground_a - ground_b), eigenvalues.tolist()


def configuration_path(source_path: str) -> Path:
    path = Path(source_path)
    return path.parent.parent / "json" / f"{path.stem}.json"


def frame_record(
    row: Any,
    label: dict[str, Any],
    domain: str,
    source_id: str,
) -> dict[str, Any]:
    proxy_mutual, proxy_ground, proxy_imbalance, proxy_eigen = proxy_values_from_embedding(
        row.embedding_v4_layout
    )
    return {
        "row_id": f"{domain}:{source_id}",
        "family": row.component_name,
        "domain": domain,
        "source_id": source_id,
        "design_id": label.get("design_id", ""),
        "physical_geometry_sha256": row.physical_geometry_sha256,
        "mutual_fF": label["mutual_fF"],
        "ground_a_fF": label.get("ground_a_fF", np.nan),
        "ground_b_fF": label.get("ground_b_fF", np.nan),
        "ground_sum_fF": label["ground_sum_fF"],
        "proxy_mutual_fF": proxy_mutual,
        "proxy_ground_sum_fF": proxy_ground,
        "proxy_ground_imbalance_fF": proxy_imbalance,
        "proxy_eigen_0_fF": proxy_eigen[0],
        "proxy_eigen_1_fF": proxy_eigen[1],
        "proxy_eigen_2_fF": proxy_eigen[2],
        "matrix_eigen_0_fF": label.get("matrix_eigen_0_fF", np.nan),
        "matrix_eigen_1_fF": label.get("matrix_eigen_1_fF", np.nan),
        "matrix_eigen_2_fF": label.get("matrix_eigen_2_fF", np.nan),
        "matrix_json": label.get("matrix_json"),
        "embedding": row.embedding_v4_layout,
    }


def frame_release_record(row: Any, label: dict[str, Any]) -> dict[str, Any]:
    proxy_mutual, proxy_ground, proxy_imbalance, proxy_eigen = proxy_values_from_embedding(
        row.embedding
    )
    source_id = str(row.source_id)
    return {
        "row_id": f"release:{source_id}",
        "family": row.component_name,
        "domain": f"release_{row.component_name}",
        "source_id": source_id,
        "design_id": row.design_id,
        "physical_geometry_sha256": row.gds_sha256,
        "mutual_fF": label["mutual_fF"],
        "ground_a_fF": label["ground_a_fF"],
        "ground_b_fF": label["ground_b_fF"],
        "ground_sum_fF": label["ground_sum_fF"],
        "proxy_mutual_fF": proxy_mutual,
        "proxy_ground_sum_fF": proxy_ground,
        "proxy_ground_imbalance_fF": proxy_imbalance,
        "proxy_eigen_0_fF": proxy_eigen[0],
        "proxy_eigen_1_fF": proxy_eigen[1],
        "proxy_eigen_2_fF": proxy_eigen[2],
        "matrix_eigen_0_fF": label.get("matrix_eigen_0_fF", np.nan),
        "matrix_eigen_1_fF": label.get("matrix_eigen_1_fF", np.nan),
        "matrix_eigen_2_fF": label.get("matrix_eigen_2_fF", np.nan),
        "matrix_json": label.get("matrix_json"),
        "embedding": row.embedding,
    }


def load_expanded_corpus(
    library_path: Path,
    old_balanced_path: Path,
    release_v4_path: Path,
    local_only: bool,
):
    library = pd.read_parquet(library_path)
    release = pd.read_parquet(release_v4_path)
    raw, raw_paths, raw_summary = load_raw_databases(local_only)
    coverage: list[dict[str, Any]] = []
    expanded_records: list[dict[str, Any]] = []

    custom = library[
        (library.component_name == GIDC)
        & (library.collection == "custom_sweeps")
        & library.campaign.isin(LABELED_GIDC_CAMPAIGNS)
    ]
    for row in custom.itertuples():
        config = configuration_path(row.source_path)
        options = json.loads(config.read_text(encoding="utf-8"))["cap_options"]
        design_id = canonical_design_id(GIDC, options)
        label = raw[GIDC].get(design_id)
        short_source = str(row.source_id).split("/")[-1]
        coverage.append(
            {
                "family": GIDC,
                "domain": row.campaign,
                "source_id": short_source,
                "design_id": design_id,
                "label_available": label is not None,
                "matrix_available": bool(label and "matrix_json" in label),
            }
        )
        if label:
            expanded_records.append(frame_record(row, label, row.campaign, short_source))

    representation_rows = []
    gidc_release = release[release.component_name == GIDC]
    gidc_expanded = pd.DataFrame(expanded_records)
    release_by_design = gidc_release.set_index("design_id")
    common = gidc_expanded[gidc_expanded.design_id.isin(release_by_design.index)]
    differences = []
    for row in common.itertuples():
        released = np.asarray(release_by_design.loc[row.design_id].embedding, dtype=np.float64)
        differences.append(float(np.max(np.abs(np.asarray(row.embedding) - released))))
    representation_rows.append(
        {
            "family": GIDC,
            "release_rows": len(gidc_release),
            "release_unique_layouts": gidc_release.layout_id.nunique(),
            "selected_labeled_rows": len(gidc_expanded),
            "overlap_designs": len(common),
            "maximum_overlap_embedding_difference": max(differences, default=np.nan),
        }
    )

    for family in (CAPN, TRANSMON):
        family_release = (
            release[release.component_name == family]
            .sort_values("source_id", kind="stable")
            .drop_duplicates("layout_id", keep="first")
        )
        missing = family_release[~family_release.design_id.isin(raw[family])]
        if len(missing):
            raise RuntimeError(f"{family} release has {len(missing)} layouts without labels.")
        for row in family_release.itertuples():
            label = raw[family][row.design_id]
            expanded_records.append(frame_release_record(row, label))
            coverage.append(
                {
                    "family": family,
                    "domain": f"release_{family}",
                    "source_id": row.source_id,
                    "design_id": row.design_id,
                    "label_available": True,
                    "matrix_available": "matrix_json" in label,
                }
            )
        representation_rows.append(
            {
                "family": family,
                "release_rows": int((release.component_name == family).sum()),
                "release_unique_layouts": family_release.layout_id.nunique(),
                "selected_labeled_rows": len(family_release),
                "overlap_designs": len(family_release),
                "maximum_overlap_embedding_difference": 0.0,
            }
        )

    old = pd.read_parquet(old_balanced_path)
    old_lookup = old.set_index(["component_name", "source_id"])
    historical_records: list[dict[str, Any]] = []
    historical = library[
        (library.campaign == "tutorial24_balanced")
        & library.component_name.isin(TOPOLOGY_FAMILIES)
    ]
    for row in historical.itertuples():
        matched = old_lookup.loc[(row.component_name, row.source_id)]
        label = {
            "mutual_fF": float(matched.mutual_fF),
            "ground_sum_fF": float(matched.ground_sum_fF),
        }
        record = frame_record(
            row,
            label,
            f"historical_{row.component_name}",
            str(row.source_id),
        )
        historical_records.append(record)

    expanded = pd.DataFrame(expanded_records).sort_values(
        ["family", "domain", "source_id"], kind="stable"
    ).reset_index(drop=True)
    historical_frame = pd.DataFrame(historical_records).sort_values(
        ["family", "source_id"], kind="stable"
    ).reset_index(drop=True)
    if expanded.physical_geometry_sha256.duplicated().any():
        raise RuntimeError("Expanded labeled corpus contains duplicate physical geometries.")
    return (
        expanded,
        historical_frame,
        library,
        pd.DataFrame(coverage),
        raw_paths,
        raw_summary,
        pd.DataFrame(representation_rows),
    )


def audit_exp8_matrices(
    results_root: Path,
    expanded: pd.DataFrame,
) -> pd.DataFrame:
    expected = expanded[expanded.domain == "exp8_exports"].set_index("source_id")
    rows = []
    matrix_paths = sorted(results_root.glob("q3d_cap_*/cap_matrix.csv"))
    for path in matrix_paths:
        source_id = path.parent.name.removeprefix("q3d_")
        with path.open(newline="", encoding="utf-8") as stream:
            passes = list(csv.DictReader(stream))
        final = passes[-1]
        previous = passes[-2] if len(passes) > 1 else final
        keys = {
            "mutual": "C(N,S) [pF]",
            "ground_a": "C(N,G) [pF]",
            "ground_b": "C(S,G) [pF]",
        }
        values = {name: abs(float(final[key])) * 1000.0 for name, key in keys.items()}
        previous_values = {name: abs(float(previous[key])) * 1000.0 for name, key in keys.items()}
        reciprocal = (
            ("C(N,S) [pF]", "C(S,N) [pF]"),
            ("C(N,G) [pF]", "C(G,N) [pF]"),
            ("C(S,G) [pF]", "C(G,S) [pF]"),
        )
        asymmetry = max(abs(float(final[left]) - float(final[right])) for left, right in reciprocal) * 1000.0
        relative_asymmetry = max(
            abs(float(final[left]) - float(final[right]))
            / max(0.5 * (abs(float(final[left])) + abs(float(final[right]))), CAP_FLOOR_FF / 1000.0)
            for left, right in reciprocal
        )
        matrix = np.asarray(
            [
                [float(final["C(N,N) [pF]"]), float(final["C(N,S) [pF]"]), float(final["C(N,G) [pF]"])],
                [float(final["C(S,N) [pF]"]), float(final["C(S,S) [pF]"]), float(final["C(S,G) [pF]"])],
                [float(final["C(G,N) [pF]"]), float(final["C(G,S) [pF]"]), float(final["C(G,G) [pF]"])],
            ]
        ) * 1000.0
        row_sum_fraction = np.max(np.abs(matrix.sum(axis=1)) / np.maximum(np.abs(np.diag(matrix)), CAP_FLOOR_FF))
        off_diagonal = matrix[~np.eye(3, dtype=bool)]
        eigenvalues = np.linalg.eigvalsh((matrix + matrix.T) / 2.0)
        reference = expected.loc[source_id]
        reference_matrix = np.asarray(json.loads(reference.matrix_json), dtype=np.float64)
        database_difference = float(np.max(np.abs(matrix - reference_matrix)))
        rows.append(
            {
                "source_id": source_id,
                "csv_sha256": sha256(path),
                "passes": len(passes),
                "final_pass": int(float(final["Pass []"])),
                "mutual_fF": values["mutual"],
                "ground_a_fF": values["ground_a"],
                "ground_b_fF": values["ground_b"],
                "maximum_reciprocal_asymmetry_fF": asymmetry,
                "maximum_reciprocal_relative_asymmetry": relative_asymmetry,
                "positive_off_diagonal_entries": int(np.sum(off_diagonal > 1e-12)),
                "minimum_eigenvalue_fF": float(eigenvalues.min()),
                "maximum_final_pass_relative_drift": max(
                    abs(values[name] - previous_values[name]) / max(values[name], CAP_FLOOR_FF)
                    for name in keys
                ),
                "maximum_row_sum_fraction": row_sum_fraction,
                "maximum_database_difference_fF": database_difference,
            }
        )
    return pd.DataFrame(rows).sort_values("source_id")


def database_matrix_audit(expanded: pd.DataFrame) -> pd.DataFrame:
    rows = []
    for row in expanded[expanded.matrix_json.notna()].itertuples():
        matrix = np.asarray(json.loads(row.matrix_json), dtype=np.float64)
        reciprocal = np.abs(matrix - matrix.T)
        scale = np.maximum(0.5 * (np.abs(matrix) + np.abs(matrix.T)), CAP_FLOOR_FF)
        off_diagonal = matrix[~np.eye(3, dtype=bool)]
        eigenvalues = np.linalg.eigvalsh((matrix + matrix.T) / 2.0)
        rows.append(
            {
                "domain": row.domain,
                "source_id": row.source_id,
                "maximum_reciprocal_relative_asymmetry": float(np.max(reciprocal / scale)),
                "positive_off_diagonal_entries": int(np.sum(off_diagonal > 1e-12)),
                "maximum_row_sum_fraction": float(
                    np.max(
                        np.abs(matrix.sum(axis=1))
                        / np.maximum(np.abs(np.diag(matrix)), CAP_FLOOR_FF)
                    )
                ),
                "minimum_eigenvalue_fF": float(eigenvalues.min()),
            }
        )
    return pd.DataFrame(rows)


def target_arrays(frame: pd.DataFrame, target: str) -> tuple[np.ndarray, np.ndarray]:
    if target == "mutual":
        observed = frame.mutual_fF.to_numpy(float)
        proxy = frame.proxy_mutual_fF.to_numpy(float)
    elif target == "ground_sum":
        observed = frame.ground_sum_fF.to_numpy(float)
        proxy = frame.proxy_ground_sum_fF.to_numpy(float)
    else:
        raise ValueError(target)
    return np.log(np.maximum(observed, CAP_FLOOR_FF)), np.log(np.maximum(proxy, CAP_FLOOR_FF))


def regression_metrics(observed_log: np.ndarray, predicted_log: np.ndarray) -> dict[str, float]:
    error = np.asarray(predicted_log) - np.asarray(observed_log)
    relative = np.abs(np.exp(np.clip(error, -20.0, 20.0)) - 1.0)
    observed = np.exp(observed_log)
    predicted = np.exp(np.clip(predicted_log, -20.0, 20.0))
    denominator = float(np.sum((observed_log - observed_log.mean()) ** 2))
    return {
        "n_test": len(observed_log),
        "median_relative_error": float(np.median(relative)),
        "p90_relative_error": float(np.quantile(relative, 0.90)),
        "p95_relative_error": float(np.quantile(relative, 0.95)),
        "bias_log": float(np.mean(error)),
        "slope_log": float(np.polyfit(observed_log, predicted_log, 1)[0]),
        "r2_log": float(1.0 - np.sum(error**2) / denominator) if denominator > 0 else float("nan"),
        "medae_fF": float(np.median(np.abs(predicted - observed))),
        "rmse_fF": float(np.sqrt(np.mean((predicted - observed) ** 2))),
    }


def exact_stratified_split(proxy_log: np.ndarray, test_fraction: float, seed: int):
    ranks = pd.Series(proxy_log).rank(method="first")
    bins = pd.qcut(ranks, 10, labels=False, duplicates="drop").to_numpy()
    rng = np.random.default_rng(seed)
    desired = int(round(len(proxy_log) * test_fraction))
    members = {int(value): rng.permutation(np.flatnonzero(bins == value)) for value in np.unique(bins)}
    raw = {key: len(value) * test_fraction for key, value in members.items()}
    counts = {key: int(math.floor(value)) for key, value in raw.items()}
    remainder = desired - sum(counts.values())
    order = sorted(members, key=lambda key: (raw[key] - counts[key], -key), reverse=True)
    for key in order[:remainder]:
        counts[key] += 1
    test, train = [], []
    for key, values in members.items():
        test.extend(values[: counts[key]])
        train.extend(values[counts[key] :])
    return np.asarray(sorted(train)), np.asarray(sorted(test))


def fit_predict_methods(
    train: pd.DataFrame,
    test: pd.DataFrame,
    target: str,
    seeds: Iterable[int],
    weight_groups: bool = False,
):
    train_x, test_x = stack(train.embedding), stack(test.embedding)
    train_y, train_proxy = target_arrays(train, target)
    test_y, test_proxy = target_arrays(test, target)
    groups = train.family.to_numpy(str) if weight_groups else None
    sample_weight = group_balanced_weights(groups) if groups is not None else None
    offset = fit_offset(train_y, train_proxy, groups)
    output = [
        ("P0_raw_proxy", -1, test_proxy, float("nan")),
        ("P1_source_offset", -1, test_proxy + offset, offset),
    ]
    for seed in seeds:
        direct = RandomFeatureRidge(seed).fit(train_x, train_y, sample_weight)
        residual = RandomFeatureRidge(seed).fit(
            train_x, train_y - (train_proxy + offset), sample_weight
        )
        output.extend(
            [
                ("RFF_v4_layout_direct", seed, direct.predict(test_x), offset),
                (
                    "RFF_v4_layout_proxy_residual",
                    seed,
                    test_proxy + offset + residual.predict(test_x),
                    offset,
                ),
            ]
        )
    return test_y, output


def within_domain_study(expanded: pd.DataFrame, seeds: Iterable[int]) -> pd.DataFrame:
    rows = []
    for domain, frame in expanded.groupby("domain", sort=True):
        frame = frame.reset_index(drop=True)
        _, proxy = target_arrays(frame, "mutual")
        train_index, test_index = exact_stratified_split(proxy, 0.2, SEED + len(rows))
        train, test = frame.iloc[train_index], frame.iloc[test_index]
        for target in ("mutual", "ground_sum"):
            observed, predictions = fit_predict_methods(train, test, target, seeds)
            for method, seed, predicted, offset in predictions:
                rows.append(
                    {
                        "domain": domain,
                        "family": frame.family.iloc[0],
                        "target": target,
                        "method": method,
                        "seed": seed,
                        "source_offset": offset,
                        **regression_metrics(observed, predicted),
                    }
                )
    return pd.DataFrame(rows)


def cross_campaign_study(expanded: pd.DataFrame, seeds: Iterable[int]) -> pd.DataFrame:
    gidc = expanded[expanded.family == GIDC]
    rows = []
    for held in LABELED_GIDC_CAMPAIGNS:
        train = gidc[gidc.domain != held]
        test = gidc[gidc.domain == held]
        for target in ("mutual", "ground_sum"):
            observed, predictions = fit_predict_methods(train, test, target, seeds)
            for method, seed, predicted, offset in predictions:
                rows.append(
                    {
                        "held_campaign": held,
                        "target": target,
                        "method": method,
                        "seed": seed,
                        "source_offset": offset,
                        **regression_metrics(observed, predicted),
                    }
                )
    return pd.DataFrame(rows)


def topology_sources(
    expanded: pd.DataFrame,
    historical: pd.DataFrame,
    held_family: str,
):
    old = historical[historical.family != held_family].copy()
    expanded_source = expanded[expanded.family != held_family].copy()
    return {
        "old_balanced_2682": (old, False),
        "expanded_unweighted": (expanded_source, False),
        "expanded_family_balanced": (expanded_source, True),
    }


def topology_zero_shot(
    expanded: pd.DataFrame,
    historical: pd.DataFrame,
    seeds: Iterable[int],
) -> pd.DataFrame:
    rows = []
    for held in (CAPN, TRANSMON):
        test = expanded[expanded.family == held]
        for protocol, (train, weighted) in topology_sources(expanded, historical, held).items():
            for target in ("mutual", "ground_sum"):
                observed, predictions = fit_predict_methods(
                    train, test, target, seeds, weight_groups=weighted
                )
                for method, seed, predicted, offset in predictions:
                    rows.append(
                        {
                            "held_family": held,
                            "source_protocol": protocol,
                            "target": target,
                            "method": method,
                            "seed": seed,
                            "source_rows": len(train),
                            "source_offset": offset,
                            **regression_metrics(observed, predicted),
                        }
                    )
    return pd.DataFrame(rows)


def low_shot_topology(
    expanded: pd.DataFrame,
    historical: pd.DataFrame,
    seeds: Iterable[int],
    draws: int,
    budgets: Iterable[int],
):
    rows, assignments = [], []
    budgets = tuple(sorted(budgets))
    for held_index, held in enumerate((CAPN, TRANSMON)):
        target_frame = expanded[expanded.family == held].reset_index(drop=True)
        _, proxy = target_arrays(target_frame, "mutual")
        pool_index, test_index = exact_stratified_split(proxy, 0.5, SEED + held_index)
        pool, test = target_frame.iloc[pool_index], target_frame.iloc[test_index]
        for partition, part in (("shot_pool", pool), ("test", test)):
            for row_id in part.row_id:
                assignments.append(
                    {"held_family": held, "row_id": row_id, "partition": partition}
                )
        orders = [
            np.random.default_rng(SEED + 1000 * held_index + draw).permutation(len(pool))
            for draw in range(draws)
        ]
        for target in ("mutual", "ground_sum"):
            test_y, _ = target_arrays(test, target)
            pool_y, _ = target_arrays(pool, target)
            test_x, pool_x = stack(test.embedding), stack(pool.embedding)
            for protocol, (source, weighted) in topology_sources(expanded, historical, held).items():
                source_x = stack(source.embedding)
                source_y, _ = target_arrays(source, target)
                weights = group_balanced_weights(source.family.to_numpy(str)) if weighted else None
                for seed in seeds:
                    model = RandomFeatureRidge(seed).fit(source_x, source_y, weights)
                    base_test = model.predict(test_x)
                    base_pool = model.predict(pool_x)
                    rows.append(
                        {
                            "held_family": held,
                            "target": target,
                            "source_protocol": protocol,
                            "budget": 0,
                            "draw": 0,
                            "seed": seed,
                            "method": "source_zero_shot",
                            **regression_metrics(test_y, base_test),
                        }
                    )
                    residual_scale = max(float(np.std(source_y - model.predict(source_x), ddof=1)), 1e-3)
                    for draw, order in enumerate(orders):
                        for budget in budgets:
                            selected = order[:budget]
                            residual = pool_y[selected] - base_pool[selected]
                            shift = float(
                                residual.sum() / (budget + (residual_scale / TAU_LOG) ** 2)
                            )
                            rows.append(
                                {
                                    "held_family": held,
                                    "target": target,
                                    "source_protocol": protocol,
                                    "budget": budget,
                                    "draw": draw,
                                    "seed": seed,
                                    "method": "source_K_offset",
                                    **regression_metrics(test_y, base_test + shift),
                                }
                            )
            for seed in seeds:
                for draw, order in enumerate(orders):
                    for budget in budgets:
                        selected = order[:budget]
                        model = RandomFeatureRidge(seed).fit(pool_x[selected], pool_y[selected])
                        rows.append(
                            {
                                "held_family": held,
                                "target": target,
                                "source_protocol": "target_only",
                                "budget": budget,
                                "draw": draw,
                                "seed": seed,
                                "method": "target_only",
                                **regression_metrics(test_y, model.predict(test_x)),
                            }
                        )
    return pd.DataFrame(rows), pd.DataFrame(assignments)


def low_shot_campaign(
    expanded: pd.DataFrame,
    seeds: Iterable[int],
    draws: int,
    budgets: Iterable[int],
) -> pd.DataFrame:
    rows = []
    gidc = expanded[expanded.family == GIDC]
    budgets = tuple(sorted(budgets))
    for held_index, held in enumerate(LABELED_GIDC_CAMPAIGNS):
        target = gidc[gidc.domain == held].reset_index(drop=True)
        source = gidc[gidc.domain != held]
        target_y, proxy = target_arrays(target, "mutual")
        pool_index, test_index = exact_stratified_split(proxy, 0.5, SEED + 200 + held_index)
        pool_x, test_x = stack(target.embedding.iloc[pool_index]), stack(target.embedding.iloc[test_index])
        pool_y, test_y = target_y[pool_index], target_y[test_index]
        source_x, source_y = stack(source.embedding), target_arrays(source, "mutual")[0]
        orders = [
            np.random.default_rng(SEED + 3000 * held_index + draw).permutation(len(pool_index))
            for draw in range(draws)
        ]
        for seed in seeds:
            model = RandomFeatureRidge(seed).fit(source_x, source_y)
            base_test, base_pool = model.predict(test_x), model.predict(pool_x)
            residual_scale = max(float(np.std(source_y - model.predict(source_x), ddof=1)), 1e-3)
            rows.append(
                {
                    "held_campaign": held,
                    "budget": 0,
                    "draw": 0,
                    "seed": seed,
                    "method": "cross_campaign_zero_shot",
                    **regression_metrics(test_y, base_test),
                }
            )
            for draw, order in enumerate(orders):
                for budget in budgets:
                    selected = order[:budget]
                    residual = pool_y[selected] - base_pool[selected]
                    shift = float(
                        residual.sum() / (budget + (residual_scale / TAU_LOG) ** 2)
                    )
                    rows.append(
                        {
                            "held_campaign": held,
                            "budget": budget,
                            "draw": draw,
                            "seed": seed,
                            "method": "cross_campaign_K_offset",
                            **regression_metrics(test_y, base_test + shift),
                        }
                    )
                    target_model = RandomFeatureRidge(seed).fit(pool_x[selected], pool_y[selected])
                    rows.append(
                        {
                            "held_campaign": held,
                            "budget": budget,
                            "draw": draw,
                            "seed": seed,
                            "method": "target_only",
                            **regression_metrics(test_y, target_model.predict(test_x)),
                        }
                    )
    return pd.DataFrame(rows)


def summarize_metrics(
    rows: pd.DataFrame,
    keys: list[str],
) -> pd.DataFrame:
    metrics = (
        "median_relative_error",
        "p90_relative_error",
        "bias_log",
        "slope_log",
        "r2_log",
        "medae_fF",
        "rmse_fF",
    )
    aggregations: dict[str, tuple[str, str]] = {}
    for metric in metrics:
        aggregations[f"{metric}_mean"] = (metric, "mean")
        aggregations[f"{metric}_std"] = (metric, "std")
    return rows.groupby(keys, as_index=False).agg(**aggregations).sort_values(keys)


def paired_topology_comparisons(low: pd.DataFrame, bootstrap: int = 10000) -> pd.DataFrame:
    nonzero = low[low.budget > 0].copy()
    nonzero["label"] = nonzero.source_protocol + ":" + nonzero.method
    index = ["held_family", "target", "budget", "draw", "seed"]
    wide = nonzero.pivot_table(
        index=index,
        columns="label",
        values="median_relative_error",
        aggfunc="first",
    ).reset_index()
    comparisons = {
        "expanded_balanced_vs_old": (
            "expanded_family_balanced:source_K_offset",
            "old_balanced_2682:source_K_offset",
        ),
        "expanded_unweighted_vs_old": (
            "expanded_unweighted:source_K_offset",
            "old_balanced_2682:source_K_offset",
        ),
        "expanded_balanced_vs_target_only": (
            "expanded_family_balanced:source_K_offset",
            "target_only:target_only",
        ),
    }
    rng = np.random.default_rng(SEED + 909)
    output = []
    for keys, group in wide.groupby(["held_family", "target", "budget"]):
        for name, (left, right) in comparisons.items():
            paired = group[["draw", left, right]].copy()
            paired["difference"] = paired[left] - paired[right]
            draw_values = paired.groupby("draw").difference.mean().to_numpy(float)
            samples = rng.choice(draw_values, (bootstrap, len(draw_values)), replace=True).mean(axis=1)
            output.append(
                {
                    "held_family": keys[0],
                    "target": keys[1],
                    "budget": keys[2],
                    "comparison": name,
                    "mean_paired_difference": float(draw_values.mean()),
                    "ci95_low": float(np.quantile(samples, 0.025)),
                    "ci95_high": float(np.quantile(samples, 0.975)),
                    "fraction_draws_left_better": float(np.mean(draw_values < 0)),
                }
            )
    return pd.DataFrame(output)


def robust_scale(matrix: np.ndarray):
    center = np.median(matrix, axis=0)
    spread = np.quantile(matrix, 0.75, axis=0) - np.quantile(matrix, 0.25, axis=0)
    active = spread > 1e-9
    return center, spread, active


def apply_scale(matrix: np.ndarray, center: np.ndarray, spread: np.ndarray, active: np.ndarray):
    return np.clip((matrix[:, active] - center[active]) / spread[active], -8.0, 8.0)


def sampled_pairs(left: np.ndarray, right: np.ndarray, count: int, seed: int, same: bool):
    rng = np.random.default_rng(seed)
    first = rng.choice(left, count, replace=True)
    second = rng.choice(right, count, replace=True)
    if same:
        collision = first == second
        while collision.any():
            second[collision] = rng.choice(right, int(collision.sum()), replace=True)
            collision = first == second
    return first, second


def similarity_study(expanded: pd.DataFrame, pairs: int) -> pd.DataFrame:
    balanced = pd.concat(
        [
            group.sample(min(len(group), 894), random_state=SEED)
            for _, group in expanded.groupby("domain", sort=True)
        ],
        ignore_index=True,
    )
    center, spread, active = robust_scale(stack(balanced.embedding))
    scaled = apply_scale(stack(expanded.embedding), center, spread, active)
    mutual, proxy_mutual = target_arrays(expanded, "mutual")
    ground, proxy_ground = target_arrays(expanded, "ground_sum")
    domains = expanded.domain.to_numpy(str)
    strata = [("within", domain, domain) for domain in sorted(expanded.domain.unique())]
    strata.extend(
        ("cross_campaign", first, second)
        for index, first in enumerate(LABELED_GIDC_CAMPAIGNS)
        for second in LABELED_GIDC_CAMPAIGNS[index + 1 :]
    )
    strata.extend(
        [
            ("cross_topology", "exp8_exports", f"release_{CAPN}"),
            ("cross_topology", "exp8_exports", f"release_{TRANSMON}"),
            ("cross_topology", f"release_{CAPN}", f"release_{TRANSMON}"),
        ]
    )
    rows = []
    for stratum_index, (kind, left_domain, right_domain) in enumerate(strata):
        left = np.flatnonzero(domains == left_domain)
        right = np.flatnonzero(domains == right_domain)
        first, second = sampled_pairs(
            left, right, pairs, SEED + stratum_index, left_domain == right_domain
        )
        embedding_distance = np.linalg.norm(scaled[first] - scaled[second], axis=1) / math.sqrt(active.sum())
        deltas = {
            "absolute_log_mutual_difference": np.abs(mutual[first] - mutual[second]),
            "absolute_log_ground_sum_difference": np.abs(ground[first] - ground[second]),
            "joint_log_response_distance": np.sqrt(
                (mutual[first] - mutual[second]) ** 2 + (ground[first] - ground[second]) ** 2
            ),
        }
        for outcome, delta in deltas.items():
            rows.append(
                {
                    "stratum": kind,
                    "domain_a": left_domain,
                    "domain_b": right_domain,
                    "relation": "v4_layout_distance",
                    "outcome": outcome,
                    "pairs": pairs,
                    "spearman_rho": float(spearmanr(embedding_distance, delta).statistic),
                }
            )
        for name, proxy, target in (
            ("proxy_mutual_delta", proxy_mutual, mutual),
            ("proxy_ground_delta", proxy_ground, ground),
        ):
            rows.append(
                {
                    "stratum": kind,
                    "domain_a": left_domain,
                    "domain_b": right_domain,
                    "relation": name,
                    "outcome": "matching_target_delta",
                    "pairs": pairs,
                    "spearman_rho": float(
                        spearmanr(
                            np.abs(proxy[first] - proxy[second]),
                            np.abs(target[first] - target[second]),
                        ).statistic
                    ),
                }
            )
    return pd.DataFrame(rows)


def ood_support_study(
    expanded: pd.DataFrame,
    library: pd.DataFrame,
    dimensions: int = 32,
):
    balanced = pd.concat(
        [
            group.sample(min(len(group), 894), random_state=SEED)
            for _, group in expanded.groupby("domain", sort=True)
        ],
        ignore_index=True,
    )
    support_x = stack(expanded.embedding)
    center, spread, active = robust_scale(stack(balanced.embedding))
    support_scaled = apply_scale(support_x, center, spread, active)
    rng = np.random.default_rng(SEED)
    fit_index = rng.choice(len(support_scaled), min(4000, len(support_scaled)), replace=False)
    pca_center = support_scaled[fit_index].mean(axis=0)
    _, _, axes = np.linalg.svd(support_scaled[fit_index] - pca_center, full_matrices=False)
    axes = axes[:dimensions]
    support_projected = (support_scaled - pca_center) @ axes.T
    tree = cKDTree(support_projected)

    rows = []
    for row in library[library.campaign.isin(UNLABELED_CAMPAIGNS)].itertuples():
        vector = np.asarray(row.embedding_v4_layout, dtype=np.float64)[None, :]
        projected = (apply_scale(vector, center, spread, active) - pca_center) @ axes.T
        distance, neighbor = tree.query(projected[0], k=1)
        proxy_mutual, proxy_ground, _, _ = proxy_values(row.proxy_matrix_json)
        rows.append(
            {
                "campaign": row.campaign,
                "family": row.component_name,
                "source_id": row.source_id,
                "nearest_labeled_distance_32d": float(distance / math.sqrt(dimensions)),
                "nearest_labeled_family": expanded.family.iloc[int(neighbor)],
                "nearest_labeled_domain": expanded.domain.iloc[int(neighbor)],
                "proxy_mutual_fF": proxy_mutual,
                "proxy_ground_sum_fF": proxy_ground,
            }
        )
    row_frame = pd.DataFrame(rows)
    summary = (
        row_frame.groupby(["campaign", "family"], as_index=False)
        .agg(
            rows=("source_id", "size"),
            median_nearest_distance=("nearest_labeled_distance_32d", "median"),
            p90_nearest_distance=("nearest_labeled_distance_32d", lambda x: x.quantile(0.90)),
            p95_nearest_distance=("nearest_labeled_distance_32d", lambda x: x.quantile(0.95)),
            median_proxy_mutual_fF=("proxy_mutual_fF", "median"),
            median_proxy_ground_sum_fF=("proxy_ground_sum_fF", "median"),
        )
        .sort_values("median_nearest_distance")
    )
    neighbor_mix = (
        row_frame.groupby(["campaign", "nearest_labeled_family", "nearest_labeled_domain"], as_index=False)
        .size()
        .rename(columns={"size": "rows"})
    )
    return row_frame, summary, neighbor_mix


def matrix_spectrum_study(
    expanded: pd.DataFrame,
    seeds: Iterable[int],
    cross_campaign: bool,
) -> pd.DataFrame:
    target_columns = [f"matrix_eigen_{index}_fF" for index in range(3)]
    rows = []
    gidc = expanded[(expanded.family == GIDC) & expanded.matrix_json.notna()]
    for held_index, domain in enumerate(LABELED_GIDC_CAMPAIGNS):
        frame = gidc[gidc.domain == domain].reset_index(drop=True)
        if frame[target_columns].isna().any().any():
            raise ValueError(f"The {domain} matrix spectrum is incomplete.")
        observed = np.log(np.maximum(frame[target_columns].to_numpy(float), CAP_FLOOR_FF))
        if cross_campaign:
            train = gidc[gidc.domain != domain]
            train_x = stack(train.embedding)
            train_y = np.log(np.maximum(train[target_columns].to_numpy(float), CAP_FLOOR_FF))
            test_x, test_y = stack(frame.embedding), observed
        else:
            _, proxy = target_arrays(frame, "mutual")
            train_index, test_index = exact_stratified_split(proxy, 0.2, SEED + 808 + held_index)
            train_x, test_x = stack(frame.embedding.iloc[train_index]), stack(frame.embedding.iloc[test_index])
            train_y, test_y = observed[train_index], observed[test_index]
        for seed in seeds:
            model = RandomFeatureRidge(seed).fit(train_x, train_y)
            prediction = model.predict(test_x)
            for index in range(3):
                rows.append(
                    {
                        "held_campaign": domain,
                        "protocol": "cross_campaign" if cross_campaign else "within_campaign",
                        "eigenmode": index,
                        "seed": seed,
                        **regression_metrics(test_y[:, index], prediction[:, index]),
                    }
                )
    return pd.DataFrame(rows)


def dataset_summary(expanded: pd.DataFrame) -> pd.DataFrame:
    return (
        expanded.groupby(["family", "domain"], as_index=False)
        .agg(
            rows=("row_id", "size"),
            unique_geometries=("physical_geometry_sha256", "nunique"),
            mutual_median_fF=("mutual_fF", "median"),
            ground_sum_median_fF=("ground_sum_fF", "median"),
            proxy_mutual_median_fF=("proxy_mutual_fF", "median"),
        )
        .sort_values(["family", "domain"])
    )


def parser() -> argparse.ArgumentParser:
    result = argparse.ArgumentParser(description=__doc__)
    result.add_argument(
        "--library",
        type=Path,
        default=Path("tutorials/runtime/study-library/study-library-v4.parquet"),
    )
    result.add_argument(
        "--old-balanced",
        type=Path,
        default=Path("tutorials/runtime/tutorial24/planar-terminal-graph-v4-balanced.parquet"),
    )
    result.add_argument(
        "--release-v4",
        type=Path,
        default=Path("../SQuADDS-hf-v34-release/metadata/planar-terminal-graph-v4.parquet"),
    )
    result.add_argument(
        "--exp8-results",
        type=Path,
        default=Path.home() / "Downloads/squadds_data/exports/squadds",
    )
    result.add_argument(
        "--output",
        type=Path,
        default=Path("tutorials/runtime/expanded-capacitance-transfer-v2"),
    )
    result.add_argument("--draws", type=int, default=20)
    result.add_argument("--seeds", type=int, default=5)
    result.add_argument("--pairs", type=int, default=5000)
    result.add_argument("--allow-downloads", action="store_true")
    return result


def main() -> None:
    args = parser().parse_args()
    args.output.mkdir(parents=True, exist_ok=True)
    seeds = tuple(SEED + 100 * index for index in range(args.seeds))
    (
        expanded,
        historical,
        library,
        coverage,
        raw_paths,
        raw_summary,
        representation_summary,
    ) = load_expanded_corpus(
        args.library, args.old_balanced, args.release_v4, not args.allow_downloads
    )
    dataset_summary(expanded).to_csv(args.output / "dataset_summary.csv", index=False)
    coverage.to_csv(args.output / "label_coverage.csv", index=False)
    raw_summary.to_csv(args.output / "raw_database_summary.csv", index=False)
    representation_summary.to_csv(args.output / "representation_coverage.csv", index=False)

    matrix_audit = audit_exp8_matrices(args.exp8_results, expanded)
    matrix_audit.to_csv(args.output / "exp8_matrix_audit.csv", index=False)
    matrix_summary = matrix_audit.describe(percentiles=[0.5, 0.9, 0.95, 0.99]).T
    matrix_summary.to_csv(args.output / "exp8_matrix_audit_summary.csv")
    database_audit = database_matrix_audit(expanded)
    database_audit.to_csv(args.output / "database_matrix_audit_rows.csv", index=False)
    database_audit.groupby("domain").agg(
        rows=("source_id", "size"),
        maximum_reciprocal_relative_asymmetry=("maximum_reciprocal_relative_asymmetry", "max"),
        positive_off_diagonal_entries=("positive_off_diagonal_entries", "sum"),
        median_row_sum_fraction=("maximum_row_sum_fraction", "median"),
        p95_row_sum_fraction=("maximum_row_sum_fraction", lambda values: values.quantile(0.95)),
        minimum_eigenvalue_fF=("minimum_eigenvalue_fF", "min"),
    ).reset_index().to_csv(args.output / "database_matrix_audit_summary.csv", index=False)

    within = within_domain_study(expanded, seeds)
    within.to_csv(args.output / "within_domain_predictive.csv", index=False)
    cross_campaign = cross_campaign_study(expanded, seeds)
    cross_campaign.to_csv(args.output / "cross_campaign_zero_shot.csv", index=False)
    topology = topology_zero_shot(expanded, historical, seeds)
    topology.to_csv(args.output / "topology_zero_shot.csv", index=False)

    low, assignments = low_shot_topology(
        expanded, historical, seeds, args.draws, (1, 3, 10, 30, 100)
    )
    low.to_csv(args.output / "topology_low_shot_metrics.csv", index=False)
    summarize_metrics(
        low,
        ["held_family", "target", "source_protocol", "budget", "method"],
    ).to_csv(args.output / "topology_low_shot_summary.csv", index=False)
    paired_topology_comparisons(low).to_csv(
        args.output / "topology_paired_comparisons.csv", index=False
    )
    assignments.to_csv(args.output / "topology_split_assignments.csv", index=False)

    campaign_low = low_shot_campaign(
        expanded, seeds, args.draws, (1, 3, 10, 30, 100)
    )
    campaign_low.to_csv(args.output / "campaign_low_shot_metrics.csv", index=False)
    summarize_metrics(
        campaign_low,
        ["held_campaign", "budget", "method"],
    ).to_csv(args.output / "campaign_low_shot_summary.csv", index=False)

    similarity_study(expanded, args.pairs).to_csv(
        args.output / "similarity_correlations.csv", index=False
    )
    ood_rows, ood_summary, neighbor_mix = ood_support_study(expanded, library)
    ood_rows.to_csv(args.output / "unlabeled_ood_support_rows.csv", index=False)
    ood_summary.to_csv(args.output / "unlabeled_ood_support_summary.csv", index=False)
    neighbor_mix.to_csv(args.output / "unlabeled_nearest_domain_mix.csv", index=False)

    matrix_spectrum_study(expanded, seeds, False).to_csv(
        args.output / "gidc_matrix_spectrum_within.csv", index=False
    )
    matrix_spectrum_study(expanded, seeds, True).to_csv(
        args.output / "gidc_matrix_spectrum_cross_campaign.csv", index=False
    )

    manifest = {
        "study": "expanded-capacitance-transfer-v2",
        "seed": SEED,
        "labeled_rows": len(expanded),
        "labeled_rows_by_domain": expanded.domain.value_counts().sort_index().to_dict(),
        "historical_comparator_rows": len(historical),
        "study_library_rows": len(library),
        "exp8_raw_matrices": len(matrix_audit),
        "exp8_raw_matrix_set_sha256": hashlib.sha256(
            "\n".join(
                f"{row.source_id}:{row.csv_sha256}" for row in matrix_audit.itertuples()
            ).encode("utf-8")
        ).hexdigest(),
        "protocol": {
            "targets": ["ln(mutual_fF)", "ln(ground_a_fF + ground_b_fF)"],
            "representation": "planar-terminal-graph-v4 permutation-invariant 544-D layout view",
            "canonical_proxy": "v4 graph proxy matrix stored per layout",
            "topology_targets": [CAPN, TRANSMON],
            "labeled_gidc_campaigns": list(LABELED_GIDC_CAMPAIGNS),
            "unlabeled_ood_campaigns": list(UNLABELED_CAMPAIGNS),
            "budgets": [0, 1, 3, 10, 30, 100],
            "draws": args.draws,
            "model_seeds": list(seeds),
            "held_target_test_fraction": 0.5,
            "within_domain_test_fraction": 0.2,
        },
        "input_sha256": {
            str(args.library): sha256(args.library),
            str(args.old_balanced): sha256(args.old_balanced),
            str(args.release_v4): sha256(args.release_v4),
            **{str(path): sha256(path) for path in raw_paths.values()},
        },
        "implementation_sha256": sha256(Path(__file__)),
        "runtime": {
            "python": sys.version,
            "platform": platform.platform(),
            "numpy": np.__version__,
            "pandas": pd.__version__,
        },
        "limitations": [
            "Concentric, star, exp9, and Firas campaigns have v4 geometry/proxy data but no joined high-fidelity labels.",
            "Only two non-GIDC labeled topology families are available for strict topology transfer.",
            "The three historical topology families influenced representation development; topology LOFO remains exploratory.",
            "RFF ridge is a controlled nonlinear probe, not the proposed final graph neural network.",
        ],
    }
    (args.output / "manifest.json").write_text(json.dumps(manifest, indent=2), encoding="utf-8")
    print(
        json.dumps(
            {
                "output": str(args.output),
                "labeled_rows": len(expanded),
                "exp8_matrices": len(matrix_audit),
                "files": len(list(args.output.iterdir())),
            },
            indent=2,
        )
    )


if __name__ == "__main__":
    main()