Accelerating Quantum Tensor Network Simulations with Unified Path Variations and Non-Degenerate Batched Sampling

1. Problem Statement

Simulating noisy quantum systems is computationally prohibitive. While ideal quantum systems can be represented by statevectors ($2^n$ entries), noisy systems require density matrices ($2^{2n}$ entries), making exact simulation intractable for large $n$.

• Current Solution: Quantum trajectory methods approximate noisy systems by sampling an ensemble of $m$ statevectors ($2^n$) instead of one density matrix.
• The Bottleneck: Recent advancements in Pre-Trajectory Sampling with Batched Execution (PTSBE) have accelerated statevector simulations by up to $10^6\times$. However, applying PTSBE to Tensor Network (TN) simulations yielded only a modest $\sim15\times$ speedup.
• Root Causes of Inefficiency:
  1. Contraction Path Recalculation: Traditional TN methods recompute the optimal contraction path for every distinct error set ($K_i$) and often for every shot, which is a costly CPU-bound operation.
  2. Sequential Sampling: Shots are collected one by one, preventing the reuse of intermediate contraction results.
  3. Inflexible Hyperparameters: Existing implementations use fixed, suboptimal batch sizes for tensor contractions, failing to optimize for specific circuit depths or hardware constraints.

2. Methodology

The authors propose an optimized Tensor Network PTSBE framework that addresses the three bottlenecks above through three core innovations:

A. Unified Path Variations (UPV)

• Concept: Instead of finding a unique contraction path for every error set $K_i$, UPV assumes that errors occur adjacent to gates of the same size and location.
• Mechanism: The algorithm constructs a single "noiseless" tensor network topology ($D$). For each error set $K_i$, the error operators are tensor merged (contracted) into the nearest coherent gate tensors.
• Result: This operation preserves the network's topology (shape, rank, and operand count). Consequently, a single, pre-computed contraction path ($P_j$) can be reused for all error sets and all shots. This eliminates the need for repeated, expensive CPU-based path finding.

B. Non-Degenerate Batched Sampling (NBS)

• Concept: Moves away from sequential, single-shot sampling to batched processing of intermediate bitstrings.
• Mechanism:
  • Proportional Sampling: Preserves quantum statistics. It samples $m_i$ shots from the conditional marginal distribution at each batch. Crucially, it reuses partial contraction results for shared bitstring prefixes $(s_1, ..., s_{j-1})$, avoiding redundant contractions.
  • Non-Proportional Sampling: Designed for Machine Learning data collection. It extracts massive amounts of data from the final batch ($B_f$). Since the final batch does not require subsequent contractions, the system can perform exhaustive sampling (extracting all high-probability entries) or direct sampling from the population vector, generating millions of shots with negligible additional cost.

C. Flexible Interface and Optimization

• Concept: The authors developed a simulation interface that allows users to define custom batch sizes ($b_j$) for each contraction step, rather than relying on a single fixed default.
• Mechanism: This flexibility enables the optimization of hyperparameters to find the batch size that minimizes contraction time per qubit. The study found that smaller batch sizes (e.g., $b=10$) are often significantly more efficient than the standard defaults (e.g., $b=24$) used in libraries like CUDA-Q.

3. Key Contributions

1. Unified Path Variations (UPV): A framework that decouples contraction path finding from error sampling, allowing a single path to serve thousands to millions of trajectory simulations.
2. Non-Degenerate Batched Sampling (NBS): A sampling strategy that eliminates degenerate (repeated) contractions by batching intermediate results and exploiting the final batch for high-volume data extraction.
3. Optimized Sampling Interface: A flexible framework that exposes batch-size hyperparameters, enabling users to tune performance for specific circuit topologies and hardware.
4. Implementation: The methods were implemented using NVIDIA's cuQuantum cuTensorNet, CuPy, and Qiskit (for IR generation), running on NVIDIA H100 GPUs.

4. Results

The authors benchmarked their optimized TN PTSBE against the traditional CUDA-Q tensor network simulator across random quantum circuits with $n \in \{50, 75, 100, 150, 200\}$ qubits and varying gate counts.

• Non-Proportional Sampling (ML/Data Collection):

  • Achieved a data collection speedup of $>10^8\times$ compared to traditional trajectory methods.
  • The speedup scales with circuit depth ($g$) and qubit count ($n$), as deeper circuits populate more states in the final batch, allowing NBS to harvest more unique shots.
  • Increasing the final batch size ($b_f$) from 24 to 28 qubits further increased throughput, as the final batch size bounds the maximum extractable unique shots ($\propto 2^{b_f}$).

• Proportional Sampling (Statistical Accuracy):

  • Achieved a speedup of $\sim1000\times$ while strictly adhering to quantum statistics.
  • The speedup is largely independent of the number of shots ($m_i$) but highly dependent on circuit parameters.
  • Key Driver: The elimination of path-finding overhead (UPV) and the optimization of batch sizes (e.g., using $b=10$ instead of $b=24$ reduced contraction time per qubit from ~90ms to ~3.5ms).

• Overhead Analysis:

  • In unoptimized methods, path-finding time often exceeded contraction time by orders of magnitude (e.g., hundreds of seconds vs. <1 second).
  • With UPV, path-finding becomes negligible, shifting the bottleneck entirely to GPU-accelerated contractions.

5. Significance

• Scalability: This work removes the primary computational barriers to simulating noisy quantum systems at scales relevant for near-term quantum device design and error correction.
• AI Integration: The massive speedup in non-proportional sampling ($10^8\times$) makes it feasible to generate the large, high-quality datasets required to train AI models for quantum error correction and device optimization.
• General Applicability: While optimized for non-proportional sampling, the techniques (UPV and flexible batching) provide a general acceleration framework for any tensor network trajectory simulation, including those requiring strict statistical fidelity.
• Hardware Efficiency: By leveraging the massive parallelism of GPUs and eliminating CPU-bound path finding, the method maximizes the utilization of modern HPC infrastructure (e.g., NVIDIA H100 clusters).

In conclusion, the paper demonstrates that by unifying contraction paths and optimizing sampling strategies, tensor network simulations can be accelerated by orders of magnitude, bridging the gap between theoretical quantum simulation and practical, data-driven quantum engineering.