aqora / Tensor Network Simulation Challenge

Public
Dataset
Discussions

About dataset version

Tensor Network Challenge Circuits

This dataset packages the Tensor Network Challenge benchmarking suite into a single Parquet artifact for Aqora. The original challenge asks classical simulators to reproduce mirror-fidelity experiments on families of realistic circuits. Each row of the Parquet file now embeds both the descriptive attributes and the circuit payloads necessary to run those experiments—there is no separate metadata file to fetch.

Families and hardness labels

  • condensed_matter – Trotterised Hamiltonian simulations of 2D lattices supplied by the condensed-matter team.
  • chemistry_uccsd – UCCSD ansatz state-preparation circuits for molecules such as CO₂, H₂SO₄, and C₄H₈; parameters originate from unconverged CCSD (50 iterations) with Pauli exponential layers generated via InQuanto.
  • mvsp – Multivariate state-preparation (Gaussian, Cauchy, Ricker) workloads used in the MVSP benchmark.
  • qmci – Quantum Monte Carlo Integration circuits that approximate interaction integrals (see challenge paper references).
  • qec_non_ft – Quantum error-correction gadgets using up to ~30 physical qubits per block; different codes trade off rate vs. distance, but preparation is not fault tolerant and no syndrome extraction is performed so the inverses remain readily available for mirror fidelity.
Hardness labels (easy, medium, hard, unreasonable) mirror the release authors’ empirical assessment of classical simulation difficulty. Qubit counts span 28–280, and gate-count columns summarize the operator mix per circuit. (The challenge instructions also mention “bonus_qec” circuits featuring mid-circuit magic-state injections, but that family is not present in the bundled Parquet artifact.)

Circuit representations

Each benchmark circuit appears in three formats, plus their dagger counterparts used for mirror-fidelity calculations (Section 3 of the instructions):
  • pytket_orig: pytket JSON retaining the original n-qubit gates (sometimes n > 2).
  • pytket_decomp: pytket JSON where wide gates are decomposed into a standard 1–2 qubit gateset.
  • qasm: OpenQASM 2.0 text derived from the decomposed circuit (qelib1.inc).
All six circuit columns store the exact UTF‑8 payload from the upstream archive so you can feed them directly into pytket, Qiskit, or other tooling. No additional files are needed once you load the Parquet.

Contents

  • Rows: 94 circuits (one per upstream benchmark)
  • Columns: Metadata + circuit payloads (see schema below)

Schema

Below is the schema of the data. Each row represents one circuit.
ColumnTypeDescription
circuit_nameStringCanonical identifier; matches the upstream filenames.
familyStringCircuit family label (see list above).
hardnessStringUpstream hardness estimate (easy, medium, hard, unreasonable).
qubitsIntegerNumber of qubits in the circuit.
Rz, Rx, ZZPhase, XXPhase, CX, H, S, Sdg, T, CnX, PauliExpBox, MeasureIntegerGate counts reported in the original release.
suite_pytket_origStringpytket JSON text for the “forward” circuit (original gateset).
suite_pytket_decompStringpytket JSON after gate decomposition.
suite_qasmStringOpenQASM 2.0 text generated from the decomposed circuit.
dagger_pytket_origStringDagger circuit (original gateset).
dagger_pytket_decompStringDagger circuit (decomposed).
dagger_qasmStringDagger circuit (OpenQASM 2.0).
Circuit columns are UTF-8 strings exactly matching the upstream files, enabling lossless round-tripping to simulator toolchains.

Missing upstream files

The release archive omits a handful of artifacts, so their Parquet columns are null. This includes seven pytket_orig circuits (e.g., TFIM_square_obc_Jz=1.0_hx=8.0_dt=0.3_n_trotter_steps=20_Lx=8_Ly=7.json, uccsd_sto3g_CO2.json, several mvsp_*_d*_n*.json) and all dagger representations of t_injections_{balanced,high_distance,colour,steane,high_rate}. All other entries are present verbatim.

Loading examples

Polars

import polars as pl
from aqora_cli.pyarrow import dataset

df = pl.scan_pyarrow_dataset(dataset("aqora/tensor-network-simulation-challenge", "v0.0.0")).collect()
summary = (
    df.groupby(["family", "hardness"])
      .agg([
          pl.count().alias("num_circuits"),
          pl.col("qubits").mean().round(2).alias("avg_qubits"),
      ])
      .sort(["family", "hardness"])
)
print(summary)

Pandas

import pandas as pd

df = pd.read_parquet("aqora://aqora/tensor-network-simulation-challenge/v0.0.0")
print(df.head())

Extracting a circuit for simulation

import polars as pl
from aqora_cli.pyarrow import dataset

df = (
    pl.scan_pyarrow_dataset(dataset("aqora/tensor-network-simulation-challenge", "v0.0.0"))
    .filter(pl.col("circuit_name") == "circ_8_mean_dict")
    .select(["suite_qasm"])
    .collect()
)

qasm_source = df.item(0, "suite_qasm")
with open("circ_8_mean_dict.qasm", "w", encoding="utf-8") as f:
    f.write(qasm_source)

Suggested explorations

  • Plot gate histograms (pl.col("Rz"), pl.col("XXPhase"), etc.) to compare hardness classes.
  • Parse pytket JSON payloads to benchmark simulators or compute mirror fidelities using the dagger columns.
  • Filter family == "mvsp" to revisit the Gaussian/Cauchy/Ricker workloads described in the challenge.