def test_sample_density_matrix_no_repetitions():
matrix = cirq.to_valid_density_matrix(0, 3)
np.testing.assert_almost_equal(
cirq.sample_density_matrix(matrix, [1], repetitions=0),
np.zeros(shape=(0, 1)))
np.testing.assert_almost_equal(
cirq.sample_density_matrix(matrix, [0, 1], repetitions=0),
np.zeros(shape=(0, 2)))
def test_sample_density_matrix_seed():
density_matrix = 0.5 * np.eye(2)
samples = cirq.sample_density_matrix(density_matrix, [0],
repetitions=10,
seed=1234)
assert np.array_equal(samples, [[False], [True], [False], [True], [True],
[False], [False], [True], [True], [True]])
samples = cirq.sample_density_matrix(density_matrix, [0],
repetitions=10,
seed=np.random.RandomState(1234))
assert np.array_equal(samples, [[False], [True], [False], [True], [True],
[False], [False], [True], [True], [True]])
def test_sample_density_matrix():
state = np.zeros(8, dtype=np.complex64)
state[0] = 1 / np.sqrt(2)
state[2] = 1 / np.sqrt(2)
matrix = cirq.to_valid_density_matrix(state, num_qubits=3)
for _ in range(10):
sample = cirq.sample_density_matrix(matrix, [2, 1, 0])
assert np.array_equal(sample, [[False, False, False]]) or np.array_equal(
sample, [[False, True, False]]
)
# Partial sample is correct.
for _ in range(10):
np.testing.assert_equal(cirq.sample_density_matrix(matrix, [2]), [[False]])
np.testing.assert_equal(cirq.sample_density_matrix(matrix, [0]), [[False]])
def test_sample_density_matrix_partial_indices():
for index in range(3):
for x in range(8):
matrix = cirq.to_valid_density_matrix(x, 3)
np.testing.assert_equal(
cirq.sample_density_matrix(matrix, [index]),
[[bool(1 & (x >> (2 - index)))]])
def test_sample_density_matrix_partial_indices_all_orders():
for perm in itertools.permutations([0, 1, 2]):
for x in range(8):
matrix = cirq.to_valid_density_matrix(x, 3)
expected = [[bool(1 & (x >> (2 - p))) for p in perm]]
np.testing.assert_equal(cirq.sample_density_matrix(matrix, perm),
expected)
def test_sample_density_matrix_validate_qid_shape():
matrix = cirq.to_valid_density_matrix(0, 3)
cirq.sample_density_matrix(matrix, [], qid_shape=(2, 2, 2))
with pytest.raises(ValueError, match='Matrix size does not match qid shape'):
cirq.sample_density_matrix(matrix, [], qid_shape=(2, 2, 1))
matrix2 = cirq.to_valid_density_matrix(0, qid_shape=(1, 2, 3))
cirq.sample_density_matrix(matrix2, [], qid_shape=(1, 2, 3))
with pytest.raises(ValueError, match='Matrix size does not match qid shape'):
cirq.sample_density_matrix(matrix2, [], qid_shape=(2, 2, 2))
def test_sample_density_matrix_repetitions():
for perm in itertools.permutations([0, 1, 2]):
for x in range(8):
matrix = cirq.to_valid_density_matrix(x, 3)
expected = [[bool(1 & (x >> (2 - p))) for p in perm]] * 3
result = cirq.sample_density_matrix(matrix, perm, repetitions=3)
np.testing.assert_equal(result, expected)
def test_sample_density_matrix_big_endian():
results = []
for x in range(8):
matrix = cirq.to_valid_density_matrix(x, 3)
sample = cirq.sample_density_matrix(matrix, [2, 1, 0])
results.append(sample)
expecteds = [[list(reversed(x))] for x in list(itertools.product([False, True], repeat=3))]
for result, expected in zip(results, expecteds):
np.testing.assert_equal(result, expected)
def _sample_helper(sim, state, n_qubits, n_samples):
if isinstance(sim, cirq.sim.sparse_simulator.Simulator):
return cirq.sample_state_vector(state.final_state,
list(range(n_qubits)),
repetitions=n_samples)
if isinstance(sim, cirq.DensityMatrixSimulator):
return cirq.sample_density_matrix(state.final_density_matrix,
list(range(n_qubits)),
repetitions=n_samples)
return NotImplemented
def test_sample_density_matrix_negative_repetitions():
matrix = cirq.to_valid_density_matrix(0, 3)
with pytest.raises(ValueError, match='-1'):
cirq.sample_density_matrix(matrix, [1], repetitions=-1)
def test_sample_density_matrix_partial_indices_oder():
for x in range(8):
matrix = cirq.to_valid_density_matrix(x, 3)
expected = [[bool(1 & (x >> 0)), bool(1 & (x >> 1))]]
np.testing.assert_equal(cirq.sample_density_matrix(matrix, [2, 1]),
expected)
def test_sample_density_matrix_no_indices():
matrix = cirq.to_valid_density_matrix(0, 3)
bits = cirq.sample_density_matrix(matrix, [])
np.testing.assert_almost_equal(bits, np.zeros(shape=(1, 0)))
def test_sample_density_matrix_out_of_range():
matrix = cirq.to_valid_density_matrix(0, 3)
with pytest.raises(IndexError, match='-2'):
cirq.sample_density_matrix(matrix, [-2])
with pytest.raises(IndexError, match='3'):
cirq.sample_density_matrix(matrix, [3])
def test_sample_density_matrix_higher_powers_of_two():
with pytest.raises(ValueError, match='powers of two'):
cirq.sample_density_matrix(np.ones((2, 4, 2, 4)) / 8, [1])
def test_sample_density_matrix_not_power_of_two():
with pytest.raises(ValueError, match='power of two'):
cirq.sample_density_matrix(np.ones((3, 3)) / 3, [1])
with pytest.raises(ValueError, match='power of two'):
cirq.sample_density_matrix(np.ones((2, 3, 2, 3)) / 6, [1])
def test_sample_density_matrix_not_square():
with pytest.raises(ValueError, match='not square'):
cirq.sample_density_matrix(np.array([1, 0, 0]), [1])
def batch_sample(circuits, param_resolvers, n_samples, simulator):
"""Sample from circuits using parallel processing.
Returns a `np.ndarray` containing n_samples samples from all the circuits in
circuits given that the corresponding `cirq.ParamResolver` in
`param_resolvers` was used to resolve any symbols. Specifically the
returned array at index `i,j` will correspond to a `np.ndarray` of
booleans representing bitstring `j` that was sampled from `circuits[i]`.
Samples are drawn using the provided simulator object (Currently supported
are `cirq.DensityMatrixSimulator` and `cirq.Simulator`).
Note: In order to keep numpy shape consistent, smaller circuits will
have sample bitstrings padded with -2 on "qubits that don't exist
in the circuit".
Args:
circuits: Python `list` of `cirq.Circuit`s.
param_resolvers: Python `list` of `cirq.ParamResolver`s, where
`param_resolvers[i]` is the resolver to be used with `circuits[i]`.
n_samples: `int` describing number of samples to draw from each
circuit.
simulator: Simulator object. Currently
supported are `cirq.DensityMatrixSimulator` and `cirq.Simulator`.
Returns:
`np.ndarray` containing the samples with invalid qubits blanked out.
It's shape is
[len(circuits), n_samples, <# qubits in largest circuit>].
circuits that are smaller than #qubits in largest circuit have null
qubits in bitstrings mapped to -2.
"""
_validate_inputs(circuits, param_resolvers, simulator, 'sample')
if _check_empty(circuits):
return np.zeros((0, 0, 0), dtype=np.int32)
if not isinstance(n_samples, int):
raise TypeError('n_samples must be an int.'
'Given: {}'.format(type(n_samples)))
if n_samples <= 0:
raise ValueError('n_samples must be > 0.')
biggest_circuit = max(len(circuit.all_qubits()) for circuit in circuits)
return_mem_shape = (len(circuits), n_samples, biggest_circuit)
shared_array = _make_simple_view(return_mem_shape, -2, np.int32, 'i')
if isinstance(simulator, cirq.DensityMatrixSimulator):
post_process = lambda state, size, n_samples: \
cirq.sample_density_matrix(
state.final_density_matrix, [i for i in range(size)],
repetitions=n_samples)
elif isinstance(simulator, cirq.Simulator):
post_process = lambda state, size, n_samples: cirq.sample_state_vector(
state.final_state_vector, list(range(size)), repetitions=n_samples)
else:
raise TypeError(
'Simulator {} is not supported by batch_sample.'.format(
type(simulator)))
input_args = list(
_prep_pool_input_args(range(len(circuits)), circuits, param_resolvers,
[n_samples] * len(circuits)))
with ProcessPool(processes=None,
initializer=_setup_dict,
initargs=(shared_array, return_mem_shape, simulator,
post_process)) as pool:
pool.starmap(_sample_worker_func, input_args)
return _convert_simple_view_to_result(shared_array, np.int32,
return_mem_shape)
def test_sample_empty_density_matrix():
matrix = np.zeros(shape=())
np.testing.assert_almost_equal(cirq.sample_density_matrix(matrix, []),
[[]])
