Constructive Interference at the Edge of Quantum Ergodic Dynamics

aqora / Constructive Interference at the Edge of Quantum Ergodic Dynamics

Public

About dataset version

Comprehensive dataset of quantum circuits and measurements from Out-of-Time-Ordered Correlator (OTOC) experiments, demonstrating constructive interference at the edge of quantum ergodic dynamics.

Dataset Overview

This dataset contains 1,450 quantum circuit measurements from 5 OTOC experiments performed on Google's Sycamore quantum processor, corresponding to Figures 3d, 3e, 4a, 4b, and 4c from the paper.

Key Features

1,450 measurement entries with complete circuit information
350 unique quantum circuits (50 per experiment × 7 experiments)
18-65 qubit circuits with 110-188 quantum moments
Serialized Cirq circuits for exact reproducibility

File Statistics

Format: Apache Parquet with Snappy compression
Size: 32.5 MB
Rows: 1,450
Columns: 13

Quick Start

Installation

pip install polars pyarrow aqora-cli cirq pandas

Loading the Dataset

import polars as pl
from aqora_cli.pyarrow import dataset
# Load dataset
df = pl.scan_pyarrow_dataset(
    dataset("aqora/constructive-interference-at-the-edge-of-quantum-ergodic-dynamics", "v1.0.0")
).collect()
print(f"Loaded {len(df)} measurements from {df['experiment'].n_unique()} experiments")

Loading Quantum Circuits

import pickle
import cirq
# Load a specific circuit
row = df.filter(
    (pl.col("experiment") == "fig3d_otoc1_40q27c") & 
    (pl.col("circuit_index") == 0)
).row(0, named=True)
# Deserialize the circuit
circuit = pickle.loads(row['circuit_pickle'])
print(f"Circuit has {len(circuit.all_qubits())} qubits")
print(f"Circuit has {len(circuit)} moments")
# Generate QASM if needed
qasm = circuit.to_qasm()
print(f"QASM length: {len(qasm)} characters")

Schema

Column	Type	Description
`experiment`	String	Full experiment identifier (e.g., `fig3d_otoc1_40q27c`)
`otoc_type`	String	OTOC type: `OTOC1` or `OTOC2`
`num_qubits`	Int64	Number of qubits in the system
`num_cycles`	Int64	Number of cycles/depth
`measurement_type`	String	Measurement category (e.g., `otoc1`, `qubits_36`)
`circuit_index`	Int64	Index of the circuit (0-49 per measurement type)
`measured_value`	Float64	OTOC measurement result
`circuit_num_qubits`	Int64	Actual qubits in the circuit
`circuit_moments`	Int64	Number of moments in the circuit
`circuit_operations`	Int64	Total quantum operations
`two_qubit_gates`	Int64	Number of two-qubit gates
`measurement_qubit`	String	Target measurement qubit (e.g., `q(7, 11)`)
`circuit_pickle`	Binary	Serialized Cirq circuit object

Experiments

This dataset contains measurements from 5 distinct experiments, each exploring different aspects of OTOC behavior in quantum systems.

Figure 3d: OTOC1 with 40 Qubits, 27 Cycles

System: 40 qubits, 27 cycles
Measurements: 50 independent circuit instances
Data: OTOC^(1) values showing quantum correlation behavior
Circuit Index: 0-49 (each index represents a different random circuit realization)

Figure 3e: OTOC2 with 40 Qubits, 22 Cycles

System: 40 qubits, 22 cycles
Measurements: 50 independent circuit instances
Data: OTOC^(2) precomputed values (off-diagonal component)
Circuit Index: 0-49 (different circuit realizations)

Figure 4a: OTOC2 with 65 Qubits, 23 Cycles

System: 65 qubits, 23 cycles (1020 iSWAP gates)
Measurements: 50 independent circuit instances
Data: OTOC^(2) experimental values (largest system in dataset)
Circuit Index: 0-49 (different circuit realizations)

Figure 4b: Multi-Qubit OTOC2 Scaling (Precomputed)

Systems: 18, 23, 27, 31, 36 qubits (5 different system sizes)
Cycles: 14, 16, 17, 18, 20 (respectively)
Measurements: 650 values total (50 per system size, except 27q and 36q with 250 each)
Data: Precomputed OTOC^(2) values for scaling analysis
Circuit Index: 0-49 for each system size (or 0-249 for 27q and 36q)

Figure 4c: Multi-Qubit OTOC2 Scaling (Experimental)

Systems: 18, 23, 27, 31, 36 qubits (5 different system sizes)
Cycles: 14, 16, 17, 18, 20 (respectively)
Measurements: 650 values total (50 per system size, except 27q and 36q with 250 each)
Data: Experimental OTOC^(2) values for scaling analysis
Circuit Index: 0-49 for each system size (or 0-249 for 27q and 36q) Note: Circuit indices represent different random circuit realizations, not time evolution or sequential measurements.

Understanding the Data

What is a "circuit instance"?

Each circuit instance (circuit_index) represents a different random quantum circuit with the same parameters (qubit count, cycles). The randomness comes from:

Random single-qubit gate angles
Random placement of iSWAP-like gates
Different Pauli string insertions (for OTOC^(2)) This ensemble of random circuits is used to study average quantum behavior and extract robust statistical signals.

Why multiple circuit instances?

OTOCs are ensemble-averaged quantities. By measuring many random circuit realizations, we can:

Compute statistical averages and confidence intervals
Distinguish signal from noise
Extract universal quantum behavior independent of specific circuit details

OTOC^(1) vs OTOC^(2):

OTOC^(1): Simpler two-point correlation (operator spreading)
OTOC^(2): More complex four-point correlation with "off-diagonal" components that capture interference effects in quantum dynamics

Visualizing the Data

Note: The visualizations below provide useful representations of the dataset that match the intent and context of the paper's figures. However, they do not exactly reproduce the original paper plots, which include additional data series (exact simulations, Monte Carlo comparisons), specific error models, and specialized formatting. These plots are designed as a best-effort starting point for data exploration and analysis.

Figure 3d: OTOC1 (40 qubits, 27 cycles)

import polars as pl
import matplotlib.pyplot as plt
fig3d = df.filter(pl.col("experiment") == "fig3d_otoc1_40q27c")
plt.figure(figsize=(10, 6))
plt.plot(fig3d['circuit_index'], fig3d['measured_value'], 'o-', 
         label='OTOC1', linewidth=2, markersize=6, alpha=0.7)
plt.xlabel('Circuit Index', fontsize=12)
plt.ylabel('OTOC Value', fontsize=12)
plt.title('Figure 3d: OTOC1 (40 qubits, 27 cycles)', fontsize=14, fontweight='bold')
plt.grid(True, alpha=0.3)
plt.legend(fontsize=11)
plt.tight_layout()
plt.savefig('fig3d_reproduction.png', dpi=150, bbox_inches='tight')
plt.show()

Figure 3e: OTOC2 (40 qubits, 22 cycles)

fig3e = df.filter(pl.col("experiment") == "fig3e_otoc2_40q22c")
plt.figure(figsize=(10, 6))
plt.plot(fig3e['circuit_index'], fig3e['measured_value'], 'o-', 
         label='OTOC2 Precomputed', linewidth=2, markersize=6, 
         alpha=0.7, color='#2ca02c')
plt.xlabel('Circuit Index', fontsize=12)
plt.ylabel('OTOC2 Value', fontsize=12)
plt.title('Figure 3e: OTOC2 (40 qubits, 22 cycles)', fontsize=14, fontweight='bold')
plt.grid(True, alpha=0.3)
plt.legend(fontsize=11)
plt.tight_layout()
plt.savefig('fig3e_reproduction.png', dpi=150, bbox_inches='tight')
plt.show()

Figure 4a: Large-Scale OTOC2 (65 qubits)

fig4a = df.filter(pl.col("experiment") == "fig4a_otoc2_65q23c")
plt.figure(figsize=(10, 6))
plt.plot(fig4a['circuit_index'], fig4a['measured_value'], 'o-', 
         label='OTOC2 Experiment (65q)', linewidth=2, markersize=6, 
         alpha=0.7, color='#d62728')
plt.xlabel('Circuit Index', fontsize=12)
plt.ylabel('OTOC2 Value', fontsize=12)
plt.title('Figure 4a: OTOC2 (65 qubits, 23 cycles, 1020 iSWAPs)', 
          fontsize=14, fontweight='bold')
plt.grid(True, alpha=0.3)
plt.legend(fontsize=11)
plt.tight_layout()
plt.savefig('fig4a_reproduction.png', dpi=150, bbox_inches='tight')
plt.show()

Figure 4b: Multi-Qubit Scaling (Precomputed)

import numpy as np
fig4b = df.filter(pl.col("experiment") == "fig4b_otoc2_18q_23q_27q_31q_36q")
qubit_counts = [18, 23, 27, 31, 36]
colors = plt.cm.viridis(np.linspace(0, 1, len(qubit_counts)))
plt.figure(figsize=(12, 6))
for i, qubits in enumerate(qubit_counts):
    data = fig4b.filter(pl.col("num_qubits") == qubits)
    plt.plot(data['circuit_index'][:50], data['measured_value'][:50],
             'o-', color=colors[i], label=f'{qubits} qubits',
             alpha=0.7, linewidth=2, markersize=5)
plt.xlabel('Circuit Index', fontsize=12)
plt.ylabel('OTOC2 Value', fontsize=12)
plt.title('Figure 4b: OTOC2 Scaling (Precomputed)', fontsize=14, fontweight='bold')
plt.grid(True, alpha=0.3)
plt.legend(fontsize=10, loc='best')
plt.tight_layout()
plt.savefig('fig4b_reproduction.png', dpi=150, bbox_inches='tight')
plt.show()

Figure 4c: Multi-Qubit Scaling (Experimental)

fig4c = df.filter(pl.col("experiment") == "fig4c_otoc2_18q_23q_27q_31q_36q")
plt.figure(figsize=(12, 6))
for i, qubits in enumerate(qubit_counts):
    data = fig4c.filter(pl.col("num_qubits") == qubits)
    plt.plot(data['circuit_index'][:50], data['measured_value'][:50],
             'o-', color=colors[i], label=f'{qubits} qubits',
             alpha=0.7, linewidth=2, markersize=5)
plt.xlabel('Circuit Index', fontsize=12)
plt.ylabel('OTOC2 Value', fontsize=12)
plt.title('Figure 4c: OTOC2 Scaling (Experimental)', fontsize=14, fontweight='bold')
plt.grid(True, alpha=0.3)
plt.legend(fontsize=10, loc='best')
plt.tight_layout()
plt.savefig('fig4c_reproduction.png', dpi=150, bbox_inches='tight')
plt.show()

Scaling Analysis: Mean OTOC vs System Size

means_4b = []
stds_4b = []
for qubits in qubit_counts:
    data = fig4b.filter(pl.col("num_qubits") == qubits)
    means_4b.append(data['measured_value'].mean())
    stds_4b.append(data['measured_value'].std())
plt.figure(figsize=(10, 6))
plt.errorbar(qubit_counts, means_4b, yerr=stds_4b, 
             fmt='o-', linewidth=2, markersize=8, capsize=5,
             label='OTOC2 Precomputed')
plt.xlabel('Number of Qubits', fontsize=12)
plt.ylabel('Mean OTOC2 Value', fontsize=12)
plt.title('System Size Scaling', fontsize=14, fontweight='bold')
plt.grid(True, alpha=0.3)
plt.legend(fontsize=11)
plt.tight_layout()
plt.savefig('fig4b_scaling.png', dpi=150, bbox_inches='tight')
plt.show()

Statistical Analysis

# Summary statistics per experiment
summary = df.group_by("experiment").agg([
    pl.col("measured_value").mean().alias("mean_otoc"),
    pl.col("measured_value").std().alias("std_otoc"),
    pl.col("measured_value").min().alias("min_otoc"),
    pl.col("measured_value").max().alias("max_otoc"),
    pl.col("circuit_index").count().alias("n_measurements"),
]).sort("experiment")
print(summary)

Advanced Usage

Filter by System Size

# Get specific qubit count from multi-qubit experiments
fig4c_27q = df.filter(
    (pl.col("experiment") == "fig4c_otoc2_18q_23q_27q_31q_36q") &
    (pl.col("num_qubits") == 27)
)
# Get all OTOC1 vs OTOC2 experiments
otoc1_data = df.filter(pl.col("otoc_type") == "OTOC1")
otoc2_data = df.filter(pl.col("otoc_type") == "OTOC2")

Analyze Circuit Properties

# Circuit complexity by experiment
circuit_stats = df.group_by("experiment").agg([
    pl.col("circuit_num_qubits").mean().alias("avg_qubits"),
    pl.col("circuit_moments").mean().alias("avg_moments"),
    pl.col("two_qubit_gates").mean().alias("avg_2q_gates"),
])
print(circuit_stats)

Export Circuits to QASM

import pickle
# Export first circuit from Figure 3d
row = df.filter(
    (pl.col("experiment") == "fig3d_otoc1_40q27c") & 
    (pl.col("circuit_index") == 0)
).row(0, named=True)
circuit = pickle.loads(row['circuit_pickle'])
qasm = circuit.to_qasm()
with open("fig3d_circuit_0.qasm", 'w') as f:
    f.write(qasm)

Data Validation

# Verify circuit integrity
def validate_circuit(circuit_pickle):
    try:
        circuit = pickle.loads(circuit_pickle)
        return len(circuit.all_qubits()) > 0
    except:
        return False
valid_circuits = df.select(
    pl.col("circuit_pickle").map_elements(validate_circuit).alias("is_valid")
)
print(f"Valid circuits: {valid_circuits['is_valid'].sum()} / {len(df)}")

Expected Results:

1,450/1,450 circuits successfully deserializable
0 NULL values across all columns
All circuit properties match metadata

Dataset Statistics

Experiment	Entries	Qubits	Cycles	OTOC Type
fig3d_otoc1_40q27c	50	40	27	OTOC1
fig3e_otoc2_40q22c	50	40	22	OTOC2
fig4a_otoc2_65q23c	50	65	23	OTOC2
fig4b (18q)	50	18	14	OTOC2
fig4b (23q)	50	23	16	OTOC2
fig4b (27q)	250	27	17	OTOC2
fig4b (31q)	50	31	18	OTOC2
fig4b (36q)	250	36	20	OTOC2
fig4c (18q)	50	18	14	OTOC2
fig4c (23q)	50	23	16	OTOC2
fig4c (27q)	250	27	17	OTOC2
fig4c (31q)	50	31	18	OTOC2
fig4c (36q)	250	36	20	OTOC2
Note: Some system sizes (27q, 36q) have 250 entries instead of 50, providing additional statistical samples for these intermediate-scale systems.

Technical Details

Circuit Serialization

Circuits are stored as pickled Cirq objects:

import pickle
import cirq
# Deserialize
circuit = pickle.loads(circuit_pickle_bytes)
# Serialize (if needed)
circuit_bytes = pickle.dumps(circuit)

Data Quality

Completeness: 100% (no NULL values)
Reproducibility: Exact Cirq circuits from paper experiments
Compression: Parquet with Snappy compression (32.5 MB for 1,450 circuits)

Contributing

This dataset is provided by Aqora based on the published dataset by the authors. For questions or issues:

Data Issues: Open a topic in the discussion section
Paper Questions: Contact the original authors

Paper: arXiv:2506.10191
Cirq Documentation: https://quantumai.google/cirq
Polars Documentation: https://pola.rs/
OTOC Theory: Out-of-Time-Ordered Correlators in quantum chaos studies

About dataset version