hongyehu / pyclifford Goto Github PK

Some function depends on PauliMonomial. However, we can discuss whether we want to roll back PauliMonomial or we can use a single-term PauliPolynomial as a PauliMonomial.

Given a batch of stabilizer states and a Pauli operator, one needs to implement the evaluation of their expectation values in parallel. One potential solution is vectorization like torchclifford.

There are a couple of arithmetic issues with TorchClifford, likely where the removal of PauliMonomial was incomplete. See PauliAlg doc for two examples.

The constructor for one state is wrong.

The probability outcome from measurement is log_2 probability, and the bit-string probability is true probability. The convention should be fixed, and the convention will be log_2 probability for all the probability output.

The task for this bounty is to implement a class representing a "generalized stabilizer state" using the generalized stabilizer frame (GSF). In principle, GSF can represent any pure state in the Hilbert space. So this new class will support Clifford circuits and non-Clifford gates.
References, notes, and 1-on-1 meetings can be provided upon request.

Hi, I want to simulate noisy Clifford circuits. Does PyClifford have some defined api to support noisy channels, like dephasing, and depolarizing? It would be helpful if you could give some examples. Thanks.

When I try to install the PyClifford package with command pip install git+https://github.com/hongyehu/PyClifford.git, I got an error message with

ERROR: More than one .egg-info directory found in /tmp/pip-pip-egg-info-y9wxrh4l.

This error is also found when try to load the package in Colab. Can you figure out how to fix this error? Thanks.

Empty PauliPolynomial should be treated as zero, but not it is not treated correctly in .add method. For this reason, the circuit.SBRG is currently patched with if len(prod) != 0: condition to avoid zero Pauli polynomial. But this matter should be treated more systematically.

Here is something that I'm seeing with the get_prob method of stabilizer states. My understanding of the method is that it takes bitstring as input where bitstring is an array of the Pauli z operators (0 is +1 and 1 is -1) that you would measure and it returns to probability of that stabilizer state returning that measurement. Assuming this is correct, here's some weird behavior:

nqubits = 3
pauli_vals = [2, 0, 1]
a = clifford_rotation_map(pauli_vals)

pauli_op = np.kron(y, np.kron(iden, x))
U_a = scipy.linalg.expm((1j*np.pi/4)*pauli_op)
state = np.zeros((2**nqubits, 1))
state[0, 0] = 1

print('Probability to sample the bitstring [0, 0, 0]')
print(a.to_state().get_prob(np.array([0, 0, 0])))
print()
print('Actual state prepared')
print(np.matmul(U_a, state))

So U_a is unitary defined by the Clifford Map a. We see that it prepares a state with amplitude 1/sqrt(2) in the state |000> . But, if I understand the method correctly, the get_prob method gives us a zero percent change of measuring +++ for a string of 3 Pauli z operators.

To close this issue, one needs to design an intermediate representation of quantum circuit with pyclifford language. Users can use it to define quantum error correction code (repetition code, for example) and apply measurements and detectors (see stim for definition) for quantum error correction. Then this intermediate representation is transferred to stim's language and be able to use stim as a backend for simulation.

The task of this bounty is to implement a function p_trace(state, positions) to return a partial trace (potentially a mixed state) of the stabilizer state, and the positions are the qubits that are not being traced out. References and preliminary code can be provided upon request.
A successful solution should include testing results

In the current implementation, there is an attribute called the rank of the stabilizer state state.r. If state.r=0, then the state is a pure stabilizer state, and all the stabilizers are used to stabilize the state. If state.r>0, then there are state.r null stabilizers, and the state is a mixed state.
In the PyClifford, there is a function called entropy that can calculate the subsystem entropy of the state. When the state is pure, this calculation is tested. The task for this bounty is to benchmark the correctness of the entropy calculation for mixed state.
A successful solution includes 1. testing result and 2. correct entropy implementation if needed

Implement mixed state quantum evolution, measurement, and expectation values. In the current implementation, the stabilizer state class has an attribute stabilizer_state.r which labels how many stabilizer generators are used to describe the state. For example, for a N qubit stabilizer state, in the gs matrix, the first N rows denote the stabilizer generators in binary vectors, and the second N rows denote the destabilizer generators in binary vectors. And the stabilizer generators used are from stabilizer_state.r to N, while destabilizer generators used are from stabilizer_state.r+N to 2N.

Therefore, if stabilizer_state.r=0, the state is fully stabilized by the first N generators, and the state is pure. And one need to change the evolution, measurement, calculation of expectation functions accordingly to general 0<stabilizer_state.r<=N for the mixed states.

Implement mixed state quantum evolution, measurement, and expectation values. In the current implementation, the stabilizer state class has an attribute stabilizer_state.r which labels how many stabilizer generators are used to describe the state. For example, for a N qubit stabilizer state, in the gs matrix, the first N rows denote the stabilizer generators in binary vectors, and the second N rows denote the destabilizer generators in binary vectors. And the stabilizer generators used are from stabilizer_state.r to N, while destabilizer generators used are from stabilizer_state.r+N to 2N.

Therefore, if stabilizer_state.r=0, the state is fully stabilized by the first N generators, and the state is pure. And one need to change the evolution, measurement, calculation of expectation functions accordingly to general 0<stabilizer_state.r<=N for the mixed states.

To close this issue, one needs to profile the speed of pyclifford, and torchclifford to point out the bottleneck for the speed and potentially solutions. Currently, all the underlying mathematical functions are implemented in utils.py file, and JIT compiled with Numba.
Still, there is room for optimization. Successfully solution needs to be able to pinpoint the the bottleneck and provide potential solutions (a partial implementation and show the implementation will speed up pyclifford)