Correlated samples after apply_unitary_tensor_channel

[zhiihan]

Hi, I'm not sure if this issue has been raised. I'm running this example here, and I find that my samples are generally correlated. Given that the example has the following diagram, I would expect that the samples are not correlated. Please let me know if I'm doing something wrong.

Contraction-based tensor network simulation of a noisy quantum state with unitary tensor channels.
The custom state is constructed by iteratively applying tensor operators and unitary bitflip tensor channels with the following topology:

Vacuum:                         A   B   C   D   E   F
                                |   |   |   |   |   |
one body op                     O   O   O   O   O   O
                                |   |   |   |   |   |
bit flip unitary channel        U   U   U   U   U   U
                                |   |   |   |   |   |
two body op                     GGGGG   GGGGG   GGGGG
                                |   |   |   |   |   |
two body op                     |   GGGGG   GGGGG   |
                                |   |   |   |   |   |

from cuquantum.cutensornet.experimental import NetworkState, NetworkOperator
import cupy as cp

state = NetworkState((2, 2), dtype='complex128')
bitflip_channel = [
    cp.eye(2, dtype='complex128'), # I
    cp.asarray([[0, 1], [1, 0]], dtype='complex128') # X
]
bitflip_probabilities = [0.5, 0.5] # 5% for bitflip

# apply one body tensor operators & unitary channels to the tensor network state
for i in range(len(state.state_mode_extents)):
    modes_one_body = (i, )
    channel_id = state.apply_unitary_tensor_channel(modes_one_body, bitflip_channel, bitflip_probabilities)

state.compute_sampling(nshots=1000, release_workspace=True)

Expected output:

{'00': 250,
'01': 250,
'10': 250,
'11': 250}

Actual:
{'00': 1000} or {'01': 1000} or {'10': 1000} or {'11': 1000}

[yangcal]

Hello,

What you observed is expected. When unitary tensor channels exist in the system, each time NetworkState.compute_xxxx (xxxx being a target property, e.g, sampling, expectation, etc) is called, a particular state of all potential state will be sampled, and then the property will be computed on top of that sampled state.

In your case with 2 bitflip channels, the final state may collapse into 4 potential state, each with a probability of 25% and the returned sample will correspond to one of the potential state as you see.

If you want to sample all states, one more external loop is needed, e.g,

n_states_to_sample = 100
n_shots_per_sample = 1000
all_samples = {}
for i in range(n_n_states_to_sample):
    samples = state.compute_samples(n_shots_per_sample)
    all_samples.update(samples)
print(all_samples)

Please note that n_states_to_samples generally depends on the probability distribution of all potential final state, e.g, 25% for all states in your case. n_shots_per_sample depends on the distribution of each state, and in your particular case, each target state amounts to a simple computational product state and therefore n_shots_per_sample=1 is equivalent to any other number.

[zhiihan]

Thank you so much for your answer. Let me see if I understand it correctly.

1. NetworkState is first "collapsing" the unitary channels into deterministic gates, in this case one of {II, XI, IX, XX} with 25% probability.
2. Perform the contractions and simulate the circuit.
3. Then, we collapse the state.

This is why, out of 1000 shots all 1000 will be the same.

To test this, I ran a small experiment, this time with the H-flip channel. If n_samples = 1, and nshots = 1000, then running the same code will produce different results:

25%: {00: 1000}
25%: {01: 500, 00: 500}
25%: {10: 500, 00: 500}
25%: {11: 250, 00: 250, 01: 250, 10: 250}

which is the case. If we have nsamples = 1000, nshots=1, we should see:

100%: {00: ~5625, 11: ~625, 01: 1825, 10: 1825}

A question I have is, is there a situation where we should prefer the first case (n_samples = 1, and nshots = 1000) over the second case?

state = NetworkState((2, 2), dtype='complex128')
bitflip_channel = [
    cp.eye(2, dtype='complex128'), # I
    cp.asarray([[1, 1], [1, -1]], dtype='complex128')/cp.sqrt(2) # H
]
bitflip_probabilities = [0.5, 0.5] # 50% chance of applying H

# apply one body tensor operators & unitary channels to the tensor network state
for i in range(len(state.state_mode_extents)):
    modes_one_body = (i, )
    channel_id = state.apply_unitary_tensor_channel(modes_one_body, bitflip_channel, bitflip_probabilities)


results = {}
n_samples = 1000
for i in range(n_samples):
    r = state.compute_sampling(nshots=1, release_workspace=True)
    results = {key: results.get(key, 0) + r.get(key, 0) for key in set(r) | set(results)}
results

Again, thank you so much.

[yangcal]

Your understanding is correct. n_samples=1 will only give sampling results for one set of deterministic gates that get collapsed into. Therefore, when unitary channels exist in the system, you should always use n_samples>1. Unless you know beforehand that one particular set of gates will come with high probability, e.g, 99.999% and then n_samples=1 will likely give you a good representation of the full noisy state.

The choice of nshots is a different story and should be generally large enough to cover the sampling space for each potential set of deterministic gates. Just like how you would set this number if the unitary channel is a regular deterministic operator.