{"id":110677,"date":"2025-12-16T10:00:00","date_gmt":"2025-12-16T18:00:00","guid":{"rendered":"https:\/\/2.zoppoz.workers.dev:443\/https\/developer.nvidia.com\/blog\/?p=110677"},"modified":"2026-01-08T11:40:46","modified_gmt":"2026-01-08T19:40:46","slug":"advanced-large-scale-quantum-simulation-techniques-in-cuquantum-sdk-v25-11","status":"publish","type":"post","link":"https:\/\/2.zoppoz.workers.dev:443\/https\/developer.nvidia.com\/blog\/advanced-large-scale-quantum-simulation-techniques-in-cuquantum-sdk-v25-11\/","title":{"rendered":"Advanced Large-Scale Quantum Simulation Techniques in cuQuantum SDK v25.11"},"content":{"rendered":"\n

Simulating large-scale quantum computers<\/a> has become more difficult as the quality of quantum processing units (QPUs)<\/a> improves. Validating the results is key to ensure that after the devices scale beyond what is classically simulable, we can still trust the outputs. <\/p>\n\n\n\n

Similarly, when generating large-scale datasets for various AI models that aim to aid in the operation of quantum processors, we see the need to offer useful training data at all scales and abstractions accelerated by GPUs. Examples include AI quantum error correction decoders, AI compilers, AI agents for calibration and control, and models to generate new device designs.<\/p>\n\n\n\n

cuQuantum SDK is a set of high-performance libraries and tools for accelerating quantum computing simulations at both the circuit and device levels by orders of magnitude. The latest version cuQuantum SDK, v25.11<\/a> introduces components that accelerate two new workloads: Pauli propagation and stabilizer simulations. Each of these is critical for simulating large scale quantum computers. <\/p>\n\n\n\n

This post dives into how you can start running Pauli propagation simulations and accelerate sampling from your stabilizer simulations to solve these problems with GPU-accelerated supercomputers.<\/p>\n\n\n\n

cuQuantum cuPauliProp<\/i><\/a><\/h2>\n\n\n\n

Pauli propagation is a relatively new method for efficiently simulating the observables of large-scale quantum circuits, which can include noise models of real quantum processors. By expressing states and observables as weighted sums of Pauli tensor products, circuit simulation can dynamically discard terms which contribute insignificantly to a sought expectation value. This permits estimation of experimental quantities which are otherwise intractable for exact simulation. <\/p>\n\n\n\n

Many relevant quantum computing applications are centered around computation of expectation values, for example VQE and quantum simulation of physical dynamics. Various exact and approximate classical simulation techniques enable calculating such observables for large circuits, though they become prohibitively expensive in differing settings. For example, the Matrix Product State technique, a very popular approximate tensor network state method for circuit simulation, is typically ill-suited for large circuits which encode the dynamics of  two or three dimensional physical systems.

Pauli propagation is a complementary and useful addition to the approximate circuit simulation toolbox, for both pure and noisy circuits. Beyond being provably efficient for simulating near-Clifford and\/or very noisy circuits, Pauli propagation has shown impressive performance when simulating circuits which Trotterize the evolution of certain quantum spin systems. This includes some \u201cutility circuits\u201d named in reference to their use in IBM\u2019s utility experiment involving a 127 qubit device as detailed in Evidence for the Utility of Quantum Computing Before Fault Tolerance<\/a>. Characterizing which circuits can be efficiently simulated with Pauli propagation is an ongoing research effort, as significant as refinement of the algorithmic details of the method itself.

cuQuantum 25.11 offers primitives to accelerate Pauli propagation or derivative methods on NVIDIA GPUs with the release of this new cuQuantum library, enabling developers and researchers to advance the frontier of classical circuit simulation. Core functions are described in the following sections.<\/p>\n\n\n\n

Library initialization<\/i><\/a><\/h3>\n\n\n\n

Initialize the library handle and workspace descriptor required for operations:<\/p>\n\n\n

\nimport cupy as cp\nfrom cuquantum.bindings import cupauliprop\nfrom cuquantum import cudaDataType\n\n# Create library handle and workspace descriptor\nhandle = cupauliprop.create()\nworkspace = cupauliprop.create_workspace_descriptor(handle)\n\n# Assign GPU memory to workspace\nws_size = 1024 * 1024 * 64  # Example: 64 MiB\nd_ws = cp.cuda.alloc(ws_size)\ncupauliprop.workspace_set_memory(\n    handle, workspace, cupauliprop.Memspace.DEVICE,\n    cupauliprop.WorkspaceKind.WORKSPACE_SCRATCH, d_ws.ptr, ws_size\n)\n<\/pre><\/div>\n\n\n
Define an observable<\/i><\/a><\/h3>\n\n\n\n
To start the simulation, allocate device memory for the Pauli expansions (sums of products of Pauli operators expressed as a set of unsigned integers as well as their coefficients) and initialize the input expansion with an observable (for example, \\(Z_{62}\\)).<\/p>\n\n\n
\n# Helper to encode Pauli string into packed integers (2 bits per qubit: X and Z masks)\ndef encode_pauli(num_qubits, paulis, qubits):\n    num_ints = cupauliprop.get_num_packed_integers(num_qubits)\n    # Packed integer format: [X_ints..., Z_ints...]\n    packed = np.zeros(num_ints * 2, dtype=np.uint64)\n    x_mask, z_mask = packed[:num_ints], packed[num_ints:]\n    for p, q in zip(paulis, qubits):\n        idx, bit = divmod(q, 64)\n        if p in (cupauliprop.PauliKind.PAULI_X, cupauliprop.PauliKind.PAULI_Y):\n            x_mask[idx] |= (1 << bit)\n        if p in (cupauliprop.PauliKind.PAULI_Z, cupauliprop.PauliKind.PAULI_Y):\n            z_mask[idx] |= (1 << bit)\n    return packed\n\n# 1. Allocate Device Buffers\n# Define capacity (max number of Pauli strings) and allocate buffers\nmax_terms = 10000 \nnum_packed_ints = cupauliprop.get_num_packed_integers(num_qubits)\nd_pauli = cp.zeros((max_terms, 2 * num_packed_ints), dtype=cp.uint64, order="C")\nd_coef = cp.zeros(max_terms, dtype=cp.float64, order="C")\n\n# 2. Populate Initial Observable (Z_62)\nencoded_pauli = encode_pauli(num_qubits, [cupauliprop.PauliKind.PAULI_Z], [62])\n\n# Assign the first term\nd_pauli[0] = cp.array(encoded_pauli)\nd_coef[0] = 1.0\n\n# 3. Create Pauli Expansions\n# Input expansion: pre-populated with our observable\nexpansion_in = cupauliprop.create_pauli_expansion(\n    handle, num_qubits,\n    d_pauli.data.ptr, d_pauli.nbytes,\n    d_coef.data.ptr, d_coef.nbytes,\n    cudaDataType.CUDA_R_64F,\n    1, 1, 1  # num_terms=1, is_sorted=True, is_unique=True\n)\n\n# Output expansion: empty initially (num_terms=0), needs its own buffers\nd_pauli_out = cp.zeros_like(d_pauli)\nd_coef_out = cp.zeros_like(d_coef)\n\nexpansion_out = cupauliprop.create_pauli_expansion(\n    handle, num_qubits,\n    d_pauli_out.data.ptr, d_pauli_out.nbytes,\n    d_coef_out.data.ptr, d_coef_out.nbytes,\n    cudaDataType.CUDA_R_64F,\n    0, 0, 0\n)\n<\/pre><\/div>\n\n\n
Operator creation<\/i><\/a><\/h3>\n\n\n\n
Define quantum gates or operators, such as a Pauli rotation \\(e^{-i \\frac{\\theta}{2} P}\\).<\/p>\n\n\n
\n# Create a Z-rotation gate on qubit 0\npaulis = [cupauliprop.PauliKind.PAULI_Z]\nqubits = [0]\ngate = cupauliprop.create_pauli_rotation_gate_operator(\n    handle, theta, 1, qubits, paulis\n)\n<\/pre><\/div>\n\n\n
Operator application<\/i><\/a><\/h3>\n\n\n\n
Apply an operator (a gate or noise-channel) to the expansion, evolving the system. Note that most applications work in the so-called Heisenberg picture<\/em>, which means that the gates in the circuit are applied in reverse order to the observable. This also requires passing the adjoint<\/code> argument as True<\/code> when applying the operator.<\/p>\n\n\n
\n# Get a view of the current terms in the input expansion\nnum_terms = cupauliprop.pauli_expansion_get_num_terms(handle, expansion_out)\nview = cupauliprop.pauli_expansion_get_contiguous_range(\n    handle, expansion_in, 0, num_terms)\n\n# Apply gate: in_expansion -> gate -> out_expansion\ncupauliprop.pauli_expansion_view_compute_operator_application(\n    handle, view, expansion_out, gate,\n    True,         # adjoint?\n    False, False,  # make_sorted?, keep_duplicates?\n    0, None,       # Truncation strategies (optional)\n    workspace\n)\n<\/pre><\/div>\n\n\n
Expectation values<\/i><\/a><\/h3>\n\n\n\n
Compute the expectation value (trace with the zero state \\(\\langle 0 | O | 0 \\rangle\\)).<\/p>\n\n\n
\nimport numpy as np\nresult = np.zeros(1, dtype=np.float64)\n\n# Compute trace\ncupauliprop.pauli_expansion_view_compute_trace_with_zero_state(\n    handle, view, result.ctypes.data, workspace\n)\n<\/pre><\/div>\n\n\n
Combining these methods shows that NVIDIA DGX B200<\/a> GPUs offer significant speedups over CPU based codes. For small coefficient cutoffs, multiple order of magnitude speedups are observed over single-threaded Qiskit Pauli-Prop on the most recent dual-socket data center CPUs.<\/p>\n\n\n
\n
\"Bar\n\t\t\t\n\t\t\t\t\n\t\t\t<\/svg>\n\t\t<\/button>
Figure 1. cuQuantum GPU simulations for pi\/4 rotations of the 127 qubit IBM utility circuit show multiple orders of magnitude speedups for a range of truncation schemes on NVIDIA DGX B200 compared to Qiskit PauliProp on an Intel Xeon Platinum 8570 CPU<\/em><\/figcaption><\/figure>\n<\/div>\n\n\n
cuQuantum cuStabilizer <\/i><\/a><\/h2>\n\n\n\n
Stabilizer simulations arise from the Gottesman-Knill theorem, which states that gates within the Clifford group (normalizer of the qubit Pauli group) can be efficiently simulated classically in polynomial time. This Clifford group is made up of CNOT, Hadamard and Phase gates (S). For this reason, stabilizer simulations have been critical for resource estimation and testing quantum error correcting codes at large scales. <\/p>\n\n\n\n
There are a few different approaches to building stabilizer simulators, from tableau simulators to frame simulators. cuStabilizer currently addresses improving the throughput for sampling rates in a frame simulator. <\/p>\n\n\n\n
Frame simulation only focuses on effects of quantum noise on the quantum state. As the quantum devices are imperfect, it\u2019s possible to model the imperfections in circuit execution by inserting random \u201cnoisy\u201d gates in it. If the noise-free result is known, getting the noisy result requires only to track the difference, or how the noisy gates change the circuit output. <\/p>\n\n\n\n
It turns out that this effect is much easier to compute compared to full circuit simulation. The number of possible combinations of how noisy gates can be inserted grows very fast with the size of the circuit, which means that in order to reliably model the error correcting algorithm a large number of shots is required.<\/p>\n\n\n\n
For users interested in developing quantum error correcting codes, testing new decoders, or generating data for AI decoders, frame simulation is ideal. APIs are available to improve sampling and accelerate any frame simulation on NVIDIA GPUs. The cuQuantum SDK cuStabilizer library exposes C API<\/a> and Python API<\/a>. While the C API will provide better performance, the Python API is best for getting started, as it is more flexible and handles memory allocation for the user.<\/p>\n\n\n\n
Create a circuit and apply frame simulation<\/i><\/a><\/h3>\n\n\n\n
cuStabilizer has two main classes involved in the simulation: Circuit<\/code><\/a> and FrameSimulator<\/code><\/a>. The circuit can accept a string that contains circuit instructions, similar to the format used in the Stim<\/a> CPU simulator. To create a FrameSimulator<\/code> you need to specify information about the circuit, to allocate enough resources.<\/p>\n\n\n
\nimport cuquantum.stabilizer as cust\n# Circuit information\nnum_qubits = 5\nnum_shots = 10_000\nnum_measurements = 2\n\n# Create a circuit on GPU\ncirc = cust.Circuit("""\nH 0 1\nX_ERROR(0.1) 1 2\nDEPOLARIZE2(0.5) 2 3\nCX 0 1 2 3\nM 0 3\n"""\n\nsim = cust.FrameSimulator(\n      num_qubits,\n      num_shots,\n      num_measurements\n)\nsim.apply(circ)\n<\/pre><\/div>\n\n\n
You can reuse a simulator between different circuits, as long as your simulator has enough qubits available. The following code will apply a circuit to a state modified by the first circuit circ<\/code>. <\/p>\n\n\n
\ncirc2 = cust.Circuit("""\nZ_ERROR(0.01) 1 4 \n""")\nsim.apply(circ2)\n<\/pre><\/div>\n\n\n
Read simulation results<\/i><\/a><\/h3>\n\n\n\n
The state of simulator consists of three bit-tables: <\/p>\n\n\n\n
    \n
  1. x_bits<\/li>\n\n\n\n
  2. z_bits<\/li>\n\n\n\n
  3. measurement_bits<\/li>\n<\/ol>\n\n\n\n
    The first two tables store the Pauli Frame (similar to the cuPauliProp Pauli Expansion, but in a different layout and without the weights). The third stores the difference between noise-free measurement and the noisy measurements in each shot.<\/p>\n\n\n\n
    The most efficient way to store the bits is to encode them in an integer value. This is referred to as \u201cbit-packed\u201d format, where each byte in memory stores eight significant bits. While this format is most efficient, manipulating individual bits requires extra steps in your program. The bit-packed format is not easily integrated with the common notion of \u201carray,\u201d as those are considered to contain values of several bytes, such as int32. <\/p>\n\n\n\n
    To provide an easy representation in numpy, cuStabilizer supports the bit_packed<\/code> argument, which can toggle between different formats. If bit_packed=False<\/code>, each bit is encoded in one uint8 value, thus using 8x more memory. When specifying input bit tables, the format is also important for performance, as described in the cuQuantum documentation<\/a>.<\/p>\n\n\n
    \n# Get measurement flips\nm_table = sim.get_measurement_bits(bit_packed=False)\nprint(m_table.dtype)\n# uint8\nprint(m_table.shape)\n# (2, 10000)\nprint(m_table)\n# [[0 0 0 ... 0 0 0]\n#  [1 0 0 ... 0 1 1]]\n\nx_table, z_table = sim.get_pauli_xz_bits(bit_packed=True)\nprint(x_table.dtype)\n# uint8\nprint(x_table.shape)\n# (5, 1252)\n<\/pre><\/div>\n\n\n
    For easy access to the underlying Pauli frames, cuStabilizer provides a PauliTable<\/code><\/a> class, which can be indexed by the shot index:<\/p>\n\n\n
    \n# Get pauli table\npauli_table = sim.get_pauli_table()\nnum_frames_print = 5\nfor i in range(num_frames_print):\n    print(pauli_table[i])\n# ...XZ\n# ZXX..\n# ...Z.\n# .....\n# ...Z.\n<\/pre><\/div>\n\n\n
    When leveraging the sampling API we see that we can drastically improve the throughput when compared to Google Stim, state of the art code on the latest data center CPUs. <\/p>\n\n\n\n
    Surface code simulation<\/i><\/a><\/h3>\n\n\n\n
    cuStabilizer can accept Stim circuits as input, and you can use it to simulate surface code circuits:<\/p>\n\n\n
    \nimport stim\n\np = 0.001\ncirc_stim = stim.Circuit.generated(\n    "surface_code:rotated_memory_z",\n    distance=5,\n    rounds=5,\n    after_clifford_depolarization=p,\n    after_reset_flip_probability=p,\n    before_measure_flip_probability=p,\n    before_round_data_depolarization=p,\n)\ncirc = cust.Circuit(circ_stim)\nsim = cust.FrameSimulator(\n    circ_stim.num_qubits,\n    num_shots,\n    circ_stim.num_measurements,\n    num_detectors=circ_stim.num_detectors,\n)\nsim.apply(circ)\n\npauli_table = sim.get_pauli_table()\nfor i in range(num_frames_print):\n    print(pauli_table[i])\n<\/pre><\/div>\n\n\n
    Note that the most efficient simulation is achieved for a large number of samples and number of qubits. Furthermore, the best performance is achieved when the resulting bit tables are kept on GPU, as when using the cupy<\/code> package.<\/p>\n\n\n\n
    Figure 2 demonstrates the best use of cuStabilizer and expected performance on the NVIDIA B200 GPU and Intel Xeon Platinum 8570 CPU. It shows that the optimal performance for a code distance 31 is achieved at about a million shots. Users can get a 1,060x speedup for large code distances.<\/p>\n\n\n
    \n
    \"When\n\t\t\t\n\t\t\t\t\n\t\t\t<\/svg>\n\t\t<\/button>
    Figure 2. Runtime performance on surface code of different distances and 1 million shots, comparing stim plus cuStabilizer on an NVIDIA DGX B200 GPU with stim on an Intel Xeon Platinum 8570 CPU<\/em><\/figcaption><\/figure>\n<\/div>\n\n\n
    Get started with new cuQuantum libraries<\/i><\/a><\/h2>\n\n\n\n
    The latest functionalities in cuQuantum continue to push the bounds of what is possible with GPU based quantum computer emulations enabling two new major classes of workloads. These workloads are critical for quantum error correction, verification and validation, and algorithm engineering for intermediate to large scale quantum devices. <\/p>\n\n\n\n
    Get started with cuQuantum cuPauliProp using pip install cupauliprop-cu13<\/code>. To learn more, review the cuPauliProp documentation<\/a>. 
    Get started with cuQuantum cuStabilizer using pip install custabilizer-cu13<\/code>. To learn more, review the     cuStabilizer documentation<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"
    Simulating large-scale quantum computers has become more difficult as the quality of quantum processing units (QPUs) improves. Validating the results is key to ensure that after the devices scale beyond what is classically simulable, we can still trust the outputs.  Similarly, when generating large-scale datasets for various AI models that aim to aid in the … Continued<\/a><\/p>\n","protected":false},"author":1548,"featured_media":110689,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"publish_to_discourse":"","publish_post_category":"","wpdc_auto_publish_overridden":"1","wpdc_topic_tags":"","wpdc_pin_topic":"","wpdc_pin_until":"","discourse_post_id":"","discourse_permalink":"","wpdc_publishing_response":"","wpdc_publishing_error":"Embed url has already been taken","nv_subtitle":"","ai_post_summary":"","footnotes":"","_links_to":"","_links_to_target":""},"categories":[852,4146,503],"tags":[2734,453,61,2735],"coauthors":[3047,4678,4940,4941,4679],"class_list":["post-110677","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-data-center-cloud","category-development","category-simulation-modeling-design","tag-cuquantum","tag-featured","tag-python","tag-quantum-computing","tagify_workload-data-science","tagify_workload-simulation-modeling-design","tagify_workload-cybersecurity"],"acf":{"post_industry":["HPC \/ Scientific Computing"],"post_products":["cuQuantum","DGX"],"post_learning_levels":["Intermediate Technical","Advanced Technical"],"post_content_types":["Tutorial"],"post_collections":""},"jetpack_featured_media_url":"https:\/\/2.zoppoz.workers.dev:443\/https\/developer-blogs.nvidia.com\/wp-content\/uploads\/2025\/12\/decision-tree-diagram-1.png","primary_category":{"category":"Simulation \/ Modeling \/ Design","link":"https:\/\/2.zoppoz.workers.dev:443\/https\/developer.nvidia.com\/blog\/category\/simulation-modeling-design\/","id":503,"data_source":""},"nv_translations":[{"language":"zh_CN","title":"cuQuantum SDK v25.11 \u4e2d\u7684\u5148\u8fdb\u5927\u89c4\u6a21\u91cf\u5b50\u6a21\u62df\u6280\u672f","post_id":16221}],"jetpack_shortlink":"https:\/\/2.zoppoz.workers.dev:443\/https\/wp.me\/pcCQAL-sN7","jetpack_likes_enabled":true,"jetpack_sharing_enabled":true,"_links":{"self":[{"href":"https:\/\/2.zoppoz.workers.dev:443\/https\/developer-blogs.nvidia.com\/wp-json\/wp\/v2\/posts\/110677","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/2.zoppoz.workers.dev:443\/https\/developer-blogs.nvidia.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/2.zoppoz.workers.dev:443\/https\/developer-blogs.nvidia.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/2.zoppoz.workers.dev:443\/https\/developer-blogs.nvidia.com\/wp-json\/wp\/v2\/users\/1548"}],"replies":[{"embeddable":true,"href":"https:\/\/2.zoppoz.workers.dev:443\/https\/developer-blogs.nvidia.com\/wp-json\/wp\/v2\/comments?post=110677"}],"version-history":[{"count":17,"href":"https:\/\/2.zoppoz.workers.dev:443\/https\/developer-blogs.nvidia.com\/wp-json\/wp\/v2\/posts\/110677\/revisions"}],"predecessor-version":[{"id":110773,"href":"https:\/\/2.zoppoz.workers.dev:443\/https\/developer-blogs.nvidia.com\/wp-json\/wp\/v2\/posts\/110677\/revisions\/110773"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/2.zoppoz.workers.dev:443\/https\/developer-blogs.nvidia.com\/wp-json\/wp\/v2\/media\/110689"}],"wp:attachment":[{"href":"https:\/\/2.zoppoz.workers.dev:443\/https\/developer-blogs.nvidia.com\/wp-json\/wp\/v2\/media?parent=110677"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/2.zoppoz.workers.dev:443\/https\/developer-blogs.nvidia.com\/wp-json\/wp\/v2\/categories?post=110677"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/2.zoppoz.workers.dev:443\/https\/developer-blogs.nvidia.com\/wp-json\/wp\/v2\/tags?post=110677"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/2.zoppoz.workers.dev:443\/https\/developer-blogs.nvidia.com\/wp-json\/wp\/v2\/coauthors?post=110677"}],"curies":[{"name":"wp","href":"https:\/\/2.zoppoz.workers.dev:443\/https\/api.w.org\/{rel}","templated":true}]}}