Access state vector from kernel

[ej-psi]

Required prerequisites

• Search the issue tracker to check if your feature has already been mentioned or rejected in other issues.

Describe the feature

For some operations, it's useful to access the state vector directly from the kernel.

For example, when the user has an 8-qubit register, and wants to peek at the probability of that register having the value 100.

In our tools, this is done via my_qreg.peek_read_probability(100)

We provide this feature, and it's working, but for CUDA-Q simulation back-end it's slow and sometimes causes RAM errors. Currently, the way we're accessing the state vector is via numpy.array(cudaq.get_state(kernel)), which (if we're simulating a 34-qubit QPU) makes a 256 GB numpy array in CPU RAM, and then inspecting it takes some time.

Is there already a way to inspect the state vector in-place? If it already exists, any guidance is appreciated.

[sacpis]

Looking into it

[sacpis]

I think here we can use amplitude/s API. As it does not materialize the full state vector. Seems like the CuStateVec implements the getAmplitude (here) by doing a cudaMemCpy of just a single element at the index, rather than copying the entire state buffer.

Please refer to amplitude and/or amplitudes API in CUDA-Q docs here.

State data can be retrieved as a full state vector or as individual basis states' amplitudes.

Please refer to Python API and/or C++ API.

[ej-psi]

Thanks for this! I did see the amplitudes API... however I haven't been able to apply it yet, for the following reason:

• To assess the probability of a single qubit being 1, we need to inspect every amplitude in half of the state vector. For a 34-qubit state vector, there are 4 billion amplitudes (that's a 64 GiB state vector). If we made a list of the amplitudes we need, the list itself would be more than 100 GB.

• To assess the probability of an 8-qubit register having a specific value (like 100), we need to inspect every amplitude in one 16th of the state vector, which is still going to be many gigabytes.

Maybe there's a better way to accomplish this? Currently we pull the entire SV and just inspect it, but it would be much better to do this from the kernel, so we don't need to copy that much massive data...

I'm open to suggestions!

[sacpis]

I think here we can use cudaq.observe() with a Pauli decomposition of the projector. It will compute the probability entirely on the GPU (for GPU backends) without ever copying the state vector to CPU.

The projector onto a specific computational basis state can be decomposed into a sum of Pauli-Z strings:

• For qubit = 0
  P = (I + Z_i) / 2

• For qubit = 1
  P = (I - Z_i) / 2

For an 8-qubit register with a target value of 100, the probability is the expectation value of the tensor product of these single-qubit projectors (2^8 = 256 Pauli terms). Here cudaq.observe() will compute all of them in a single GPU pass without moving data to CPU.

Would you like to give it a try to compute the probability and see if it works for you?