Code example (marginal distribution)#
Computing tensor network state marginal distribution tensor#
The following code example illustrates how to define a tensor network state and then compute the tensor network state marginal distribution tensor. The full code can be found in the NVIDIA/cuQuantum repository (here).
Headers and error handling#
7#include <cstdlib>
8#include <cstdio>
9#include <cassert>
10#include <complex>
11#include <vector>
12#include <bitset>
13#include <iostream>
14
15#include <cuda_runtime.h>
16#include <cutensornet.h>
17
18
19#define HANDLE_CUDA_ERROR(x) \
20{ const auto err = x; \
21 if( err != cudaSuccess ) \
22 { printf("CUDA error %s in line %d\n", cudaGetErrorString(err), __LINE__); fflush(stdout); std::abort(); } \
23};
24
25#define HANDLE_CUTN_ERROR(x) \
26{ const auto err = x; \
27 if( err != CUTENSORNET_STATUS_SUCCESS ) \
28 { printf("cuTensorNet error %s in line %d\n", cutensornetGetErrorString(err), __LINE__); fflush(stdout); std::abort(); } \
29};
30
31
32int main()
33{
34 static_assert(sizeof(size_t) == sizeof(int64_t), "Please build this sample on a 64-bit architecture!");
35
36 constexpr std::size_t fp64size = sizeof(double);
Define the tensor network state and the desired marginal distribution tensor#
Let’s define a tensor network state corresponding to a 16-qubit quantum circuit and request the marginal distribution tensor for qubits 0 and 1.
40 // Quantum state configuration
41 constexpr int32_t numQubits = 16; // number of qubits
42 const std::vector<int64_t> qubitDims(numQubits,2); // qubit dimensions
43 const std::vector<int32_t> marginalModes({0,1}); // open qubits defining the marginal (must be in acsending order)
44 const int32_t numMarginalModes = marginalModes.size(); // rank of the marginal (reduced density matrix)
45 std::cout << "Quantum circuit: " << numQubits << " qubits\n";
Initialize the cuTensorNet library handle#
49 // Initialize the cuTensorNet library
50 HANDLE_CUDA_ERROR(cudaSetDevice(0));
51 cutensornetHandle_t cutnHandle;
52 HANDLE_CUTN_ERROR(cutensornetCreate(&cutnHandle));
53 std::cout << "Initialized cuTensorNet library on GPU 0\n";
Define quantum gates on GPU#
57 // Define necessary quantum gate tensors in Host memory
58 const double invsq2 = 1.0 / std::sqrt(2.0);
59 // Hadamard gate
60 const std::vector<std::complex<double>> h_gateH {{invsq2, 0.0}, {invsq2, 0.0},
61 {invsq2, 0.0}, {-invsq2, 0.0}};
62 // CX gate
63 const std::vector<std::complex<double>> h_gateCX {{1.0, 0.0}, {0.0, 0.0}, {0.0, 0.0}, {0.0, 0.0},
64 {0.0, 0.0}, {1.0, 0.0}, {0.0, 0.0}, {0.0, 0.0},
65 {0.0, 0.0}, {0.0, 0.0}, {0.0, 0.0}, {1.0, 0.0},
66 {0.0, 0.0}, {0.0, 0.0}, {1.0, 0.0}, {0.0, 0.0}};
67
68 // Copy quantum gates to Device memory
69 void *d_gateH{nullptr}, *d_gateCX{nullptr};
70 HANDLE_CUDA_ERROR(cudaMalloc(&d_gateH, 4 * (2 * fp64size)));
71 HANDLE_CUDA_ERROR(cudaMalloc(&d_gateCX, 16 * (2 * fp64size)));
72 std::cout << "Allocated quantum gate memory on GPU\n";
73 HANDLE_CUDA_ERROR(cudaMemcpy(d_gateH, h_gateH.data(), 4 * (2 * fp64size), cudaMemcpyHostToDevice));
74 HANDLE_CUDA_ERROR(cudaMemcpy(d_gateCX, h_gateCX.data(), 16 * (2 * fp64size), cudaMemcpyHostToDevice));
75 std::cout << "Copied quantum gates to GPU memory\n";
Allocate the marginal distribution tensor on GPU#
Here we allocate the marginal distribution tensor, that is, the reduced density matrix for qubits 0 and 1 on GPU.
79 // Allocate Device memory for the specified quantum circuit reduced density matrix (marginal)
80 void *d_rdm{nullptr};
81 std::size_t rdmDim = 1;
82 for(const auto & mode: marginalModes) rdmDim *= qubitDims[mode];
83 const std::size_t rdmSize = rdmDim * rdmDim;
84 HANDLE_CUDA_ERROR(cudaMalloc(&d_rdm, rdmSize * (2 * fp64size)));
85 std::cout << "Allocated memory for the specified quantum circuit reduced density matrix (marginal) of size "
86 << rdmSize << " elements\n";
Allocate the scratch buffer on GPU#
90 // Query the free memory on Device
91 std::size_t freeSize{0}, totalSize{0};
92 HANDLE_CUDA_ERROR(cudaMemGetInfo(&freeSize, &totalSize));
93 const std::size_t scratchSize = (freeSize - (freeSize % 4096)) / 2; // use half of available memory with alignment
94 void *d_scratch{nullptr};
95 void *h_scratch{nullptr}; // host scratch workspace buffer (attached if the prepare call reports a need)
96 int64_t hostWorksize{0};
97 HANDLE_CUDA_ERROR(cudaMalloc(&d_scratch, scratchSize));
98 std::cout << "Allocated " << scratchSize << " bytes of scratch memory on GPU\n";
Create a pure tensor network state#
Now let’s create a pure tensor network state for a 16-qubit quantum circuit.
102 // Create the initial quantum state
103 cutensornetState_t quantumState;
104 HANDLE_CUTN_ERROR(cutensornetCreateState(cutnHandle, CUTENSORNET_STATE_PURITY_PURE, numQubits, qubitDims.data(),
105 CUDA_C_64F, &quantumState));
106 std::cout << "Created the initial quantum state\n";
Apply quantum gates#
Let’s construct the GHZ quantum circuit by applying the corresponding quantum gates.
110 // Construct the final quantum circuit state (apply quantum gates) for the GHZ circuit
111 int64_t id;
112 HANDLE_CUTN_ERROR(cutensornetStateApplyTensorOperator(cutnHandle, quantumState, 1, std::vector<int32_t>{{0}}.data(),
113 d_gateH, nullptr, 1, 0, 1, &id));
114 for(int32_t i = 1; i < numQubits; ++i) {
115 HANDLE_CUTN_ERROR(cutensornetStateApplyTensorOperator(cutnHandle, quantumState, 2, std::vector<int32_t>{{i-1,i}}.data(),
116 d_gateCX, nullptr, 1, 0, 1, &id));
117 }
118 std::cout << "Applied quantum gates\n";
Create the marginal distribution object#
Once the quantum circuit has been constructed, let’s create the marginal distribution object that will compute the marginal distribution tensor (reduced density matrix) for qubits 0 and 1.
122 // Specify the quantum circuit reduced density matrix (marginal)
123 cutensornetStateMarginal_t marginal;
124 HANDLE_CUTN_ERROR(cutensornetCreateMarginal(cutnHandle, quantumState, numMarginalModes, marginalModes.data(),
125 0, nullptr, std::vector<int64_t>{{1,2,4,8}}.data(), &marginal)); // using explicit strides
126 std::cout << "Created the specified quantum circuit reduced densitry matrix (marginal)\n";
Configure the marginal distribution object#
Now we can configure the marginal distribution object by setting the number of hyper-samples to be used by the tensor network contraction path finder.
130 // Configure the computation of the specified quantum circuit reduced density matrix (marginal)
131 const int32_t numHyperSamples = 8; // desired number of hyper samples used in the tensor network contraction path finder
132 HANDLE_CUTN_ERROR(cutensornetMarginalConfigure(cutnHandle, marginal,
133 CUTENSORNET_MARGINAL_CONFIG_NUM_HYPER_SAMPLES, &numHyperSamples, sizeof(numHyperSamples)));
Prepare the computation of the marginal distribution tensor#
Let’s create a workspace descriptor and prepare the computation of the marginal distribution tensor.
137 // Prepare the computation of the specified quantum circuit reduced densitry matrix (marginal)
138 cutensornetWorkspaceDescriptor_t workDesc;
139 HANDLE_CUTN_ERROR(cutensornetCreateWorkspaceDescriptor(cutnHandle, &workDesc));
140 std::cout << "Created the workspace descriptor\n";
141 HANDLE_CUTN_ERROR(cutensornetMarginalPrepare(cutnHandle, marginal, scratchSize, workDesc, 0x0));
142 std::cout << "Prepared the computation of the specified quantum circuit reduced density matrix (marginal)\n";
143 double flops {0.0};
144 HANDLE_CUTN_ERROR(cutensornetMarginalGetInfo(cutnHandle, marginal,
145 CUTENSORNET_MARGINAL_INFO_FLOPS, &flops, sizeof(flops)));
146 std::cout << "Total flop count = " << (flops/1e9) << " GFlop\n";
Set up the workspace#
Now we can set up the required workspace buffer.
150 // Attach the workspace buffer
151 int64_t worksize {0};
152 HANDLE_CUTN_ERROR(cutensornetWorkspaceGetMemorySize(cutnHandle,
153 workDesc,
154 CUTENSORNET_WORKSIZE_PREF_RECOMMENDED,
155 CUTENSORNET_MEMSPACE_DEVICE,
156 CUTENSORNET_WORKSPACE_SCRATCH,
157 &worksize));
158 std::cout << "Required scratch GPU workspace size (bytes) = " << worksize << std::endl;
159 if(worksize <= scratchSize) {
160 HANDLE_CUTN_ERROR(cutensornetWorkspaceSetMemory(cutnHandle, workDesc, CUTENSORNET_MEMSPACE_DEVICE,
161 CUTENSORNET_WORKSPACE_SCRATCH, d_scratch, worksize));
162 }else{
163 std::cout << "ERROR: Insufficient workspace size on Device!\n";
164 std::abort();
165 }
166
167 // Query the host scratch workspace size and attach a host scratch buffer if one is required
168 HANDLE_CUTN_ERROR(cutensornetWorkspaceGetMemorySize(cutnHandle, workDesc, CUTENSORNET_WORKSIZE_PREF_RECOMMENDED,
169 CUTENSORNET_MEMSPACE_HOST, CUTENSORNET_WORKSPACE_SCRATCH, &hostWorksize));
170 std::cout << "Scratch Host workspace size (bytes) = " << hostWorksize << std::endl;
171 if(hostWorksize > 0) {
172 h_scratch = std::realloc(h_scratch, hostWorksize);
173 if(h_scratch == nullptr) { std::cout << "ERROR: Host scratch allocation failed!\n"; std::abort(); }
174 HANDLE_CUTN_ERROR(cutensornetWorkspaceSetMemory(cutnHandle, workDesc, CUTENSORNET_MEMSPACE_HOST,
175 CUTENSORNET_WORKSPACE_SCRATCH, h_scratch, hostWorksize));
176 }
177 std::cout << "Set the workspace buffer\n";
Compute the marginal distribution tensor#
Once everything has been set up, we compute the requested marginal distribution tensor (reduced density matrix) for qubits 0 and 1, copy it back to Host memory, and print it.
181 // Compute the specified quantum circuit reduced densitry matrix (marginal)
182 HANDLE_CUTN_ERROR(cutensornetMarginalCompute(cutnHandle, marginal, nullptr, workDesc, d_rdm, 0x0));
183 std::cout << "Computed the specified quantum circuit reduced density matrix (marginal)\n";
184 std::vector<std::complex<double>> h_rdm(rdmSize);
185 HANDLE_CUDA_ERROR(cudaMemcpy(h_rdm.data(), d_rdm, rdmSize * (2 * fp64size), cudaMemcpyDeviceToHost));
186 std::cout << "Reduced density matrix for " << numMarginalModes << " qubits:\n";
187 for(std::size_t i = 0; i < rdmDim; ++i) {
188 for(std::size_t j = 0; j < rdmDim; ++j) {
189 std::cout << " " << h_rdm[i + j * rdmDim];
190 }
191 std::cout << std::endl;
192 }
Free resources#
196 // Destroy the workspace descriptor
197 HANDLE_CUTN_ERROR(cutensornetDestroyWorkspaceDescriptor(workDesc));
198 std::cout << "Destroyed the workspace descriptor\n";
199
200 // Destroy the quantum circuit reduced density matrix
201 HANDLE_CUTN_ERROR(cutensornetDestroyMarginal(marginal));
202 std::cout << "Destroyed the quantum circuit state reduced density matrix (marginal)\n";
203
204 // Destroy the quantum circuit state
205 HANDLE_CUTN_ERROR(cutensornetDestroyState(quantumState));
206 std::cout << "Destroyed the quantum circuit state\n";
207
208 std::free(h_scratch);
209 HANDLE_CUDA_ERROR(cudaFree(d_scratch));
210 HANDLE_CUDA_ERROR(cudaFree(d_rdm));
211 HANDLE_CUDA_ERROR(cudaFree(d_gateCX));
212 HANDLE_CUDA_ERROR(cudaFree(d_gateH));
213 std::cout << "Freed memory on GPU\n";
214
215 // Finalize the cuTensorNet library
216 HANDLE_CUTN_ERROR(cutensornetDestroy(cutnHandle));
217 std::cout << "Finalized the cuTensorNet library\n";
218
219 return 0;
220}