def test_act_using_probabilistic_single_qubit_channel():
class ProbabilisticSorX(cirq.Gate):
def num_qubits(self) -> int:
return 1
def _kraus_(self):
return [
cirq.unitary(cirq.S) * np.sqrt(1 / 3),
cirq.unitary(cirq.X) * np.sqrt(2 / 3)
]
initial_state = cirq.testing.random_superposition(dim=16).reshape(
(2, ) * 4)
mock_prng = mock.Mock()
mock_prng.random.return_value = 1 / 3 + 1e-6
args = cirq.StateVectorSimulationState(
available_buffer=np.empty_like(initial_state),
qubits=cirq.LineQubit.range(4),
prng=mock_prng,
initial_state=np.copy(initial_state),
dtype=initial_state.dtype,
)
cirq.act_on(ProbabilisticSorX(), args, [cirq.LineQubit(2)])
np.testing.assert_allclose(
args.target_tensor.reshape(16),
cirq.final_state_vector(
cirq.X(cirq.LineQubit(2))**-1,
initial_state=initial_state,
qubit_order=cirq.LineQubit.range(4),
),
atol=1e-8,
)
mock_prng.random.return_value = 1 / 3 - 1e-6
args = cirq.StateVectorSimulationState(
available_buffer=np.empty_like(initial_state),
qubits=cirq.LineQubit.range(4),
prng=mock_prng,
initial_state=np.copy(initial_state),
dtype=initial_state.dtype,
)
cirq.act_on(ProbabilisticSorX(), args, [cirq.LineQubit(2)])
np.testing.assert_allclose(
args.target_tensor.reshape(16),
cirq.final_state_vector(
cirq.S(cirq.LineQubit(2)),
initial_state=initial_state,
qubit_order=cirq.LineQubit.range(4),
),
atol=1e-8,
)
def test_pretty_print():
final_simulator_state = cirq.StateVectorSimulationState(
available_buffer=np.array([1]),
prng=np.random.RandomState(0),
qubits=[],
initial_state=np.array([1], dtype=np.complex64),
dtype=np.complex64,
)
result = cirq.StateVectorTrialResult(cirq.ParamResolver(), {}, final_simulator_state)
# Test Jupyter console output from
class FakePrinter:
def __init__(self):
self.text_pretty = ''
def text(self, to_print):
self.text_pretty += to_print
p = FakePrinter()
result._repr_pretty_(p, False)
assert p.text_pretty == 'measurements: (no measurements)\n\nphase:\noutput vector: |⟩'
# Test cycle handling
p = FakePrinter()
result._repr_pretty_(p, True)
assert p.text_pretty == 'StateVectorTrialResult(...)'
def test_state_vector_trial_result_repr():
q0 = cirq.NamedQubit('a')
final_simulator_state = cirq.StateVectorSimulationState(
available_buffer=np.array([0, 1], dtype=np.complex64),
prng=np.random.RandomState(0),
qubits=[q0],
initial_state=np.array([0, 1], dtype=np.complex64),
dtype=np.complex64,
)
trial_result = cirq.StateVectorTrialResult(
params=cirq.ParamResolver({'s': 1}),
measurements={'m': np.array([[1]], dtype=np.int32)},
final_simulator_state=final_simulator_state,
)
expected_repr = (
"cirq.StateVectorTrialResult("
"params=cirq.ParamResolver({'s': 1}), "
"measurements={'m': np.array([[1]], dtype=np.int32)}, "
"final_simulator_state=cirq.StateVectorSimulationState("
"initial_state=np.array([0j, (1+0j)], dtype=np.complex64), "
"qubits=(cirq.NamedQubit('a'),), "
"classical_data=cirq.ClassicalDataDictionaryStore()))"
)
assert repr(trial_result) == expected_repr
assert eval(expected_repr) == trial_result
def test_reset_act_on():
with pytest.raises(TypeError, match="Failed to act"):
cirq.act_on(cirq.ResetChannel(), DummySimulationState(), qubits=())
args = cirq.StateVectorSimulationState(
available_buffer=np.empty(shape=(2, 2, 2, 2, 2), dtype=np.complex64),
qubits=cirq.LineQubit.range(5),
prng=np.random.RandomState(),
initial_state=cirq.one_hot(index=(1, 1, 1, 1, 1),
shape=(2, 2, 2, 2, 2),
dtype=np.complex64),
dtype=np.complex64,
)
cirq.act_on(cirq.ResetChannel(), args, [cirq.LineQubit(1)])
assert args.log_of_measurement_results == {}
np.testing.assert_allclose(
args.target_tensor,
cirq.one_hot(index=(1, 0, 1, 1, 1),
shape=(2, 2, 2, 2, 2),
dtype=np.complex64),
)
cirq.act_on(cirq.ResetChannel(), args, [cirq.LineQubit(1)])
assert args.log_of_measurement_results == {}
np.testing.assert_allclose(
args.target_tensor,
cirq.one_hot(index=(1, 0, 1, 1, 1),
shape=(2, 2, 2, 2, 2),
dtype=np.complex64),
)
def test_act_on_state_vector():
a, b = [cirq.LineQubit(3), cirq.LineQubit(1)]
m = cirq.measure(a,
b,
key='out',
invert_mask=(True, ),
confusion_map={(1, ): np.array([[0, 1], [1, 0]])})
args = cirq.StateVectorSimulationState(
available_buffer=np.empty(shape=(2, 2, 2, 2, 2)),
qubits=cirq.LineQubit.range(5),
prng=np.random.RandomState(),
initial_state=cirq.one_hot(shape=(2, 2, 2, 2, 2), dtype=np.complex64),
dtype=np.complex64,
)
cirq.act_on(m, args)
assert args.log_of_measurement_results == {'out': [1, 1]}
args = cirq.StateVectorSimulationState(
available_buffer=np.empty(shape=(2, 2, 2, 2, 2)),
qubits=cirq.LineQubit.range(5),
prng=np.random.RandomState(),
initial_state=cirq.one_hot(index=(0, 1, 0, 0, 0),
shape=(2, 2, 2, 2, 2),
dtype=np.complex64),
dtype=np.complex64,
)
cirq.act_on(m, args)
assert args.log_of_measurement_results == {'out': [1, 0]}
args = cirq.StateVectorSimulationState(
available_buffer=np.empty(shape=(2, 2, 2, 2, 2)),
qubits=cirq.LineQubit.range(5),
prng=np.random.RandomState(),
initial_state=cirq.one_hot(index=(0, 1, 0, 1, 0),
shape=(2, 2, 2, 2, 2),
dtype=np.complex64),
dtype=np.complex64,
)
cirq.act_on(m, args)
datastore = cast(cirq.ClassicalDataDictionaryStore, args.classical_data)
out = cirq.MeasurementKey('out')
assert args.log_of_measurement_results == {'out': [0, 0]}
assert datastore.records[out] == [(0, 0)]
cirq.act_on(m, args)
assert args.log_of_measurement_results == {'out': [0, 0]}
assert datastore.records[out] == [(0, 0), (0, 0)]
def test_deprecated_methods():
args = cirq.StateVectorSimulationState(qubits=[cirq.LineQubit(0)])
with cirq.testing.assert_deprecated('unintentionally made public',
deadline='v0.16'):
args.subspace_index([0], 0)
with cirq.testing.assert_deprecated('unintentionally made public',
deadline='v0.16'):
args.swap_target_tensor_for(np.array([]))
def test_act_on_qutrit():
a, b = [cirq.LineQid(3, dimension=3), cirq.LineQid(1, dimension=3)]
m = cirq.measure(
a,
b,
key='out',
invert_mask=(True, ),
confusion_map={(1, ): np.array([[0, 1, 0], [0, 0, 1], [1, 0, 0]])},
)
args = cirq.StateVectorSimulationState(
available_buffer=np.empty(shape=(3, 3, 3, 3, 3)),
qubits=cirq.LineQid.range(5, dimension=3),
prng=np.random.RandomState(),
initial_state=cirq.one_hot(index=(0, 2, 0, 2, 0),
shape=(3, 3, 3, 3, 3),
dtype=np.complex64),
dtype=np.complex64,
)
cirq.act_on(m, args)
assert args.log_of_measurement_results == {'out': [2, 0]}
args = cirq.StateVectorSimulationState(
available_buffer=np.empty(shape=(3, 3, 3, 3, 3)),
qubits=cirq.LineQid.range(5, dimension=3),
prng=np.random.RandomState(),
initial_state=cirq.one_hot(index=(0, 1, 0, 2, 0),
shape=(3, 3, 3, 3, 3),
dtype=np.complex64),
dtype=np.complex64,
)
cirq.act_on(m, args)
assert args.log_of_measurement_results == {'out': [2, 2]}
args = cirq.StateVectorSimulationState(
available_buffer=np.empty(shape=(3, 3, 3, 3, 3)),
qubits=cirq.LineQid.range(5, dimension=3),
prng=np.random.RandomState(),
initial_state=cirq.one_hot(index=(0, 2, 0, 1, 0),
shape=(3, 3, 3, 3, 3),
dtype=np.complex64),
dtype=np.complex64,
)
cirq.act_on(m, args)
assert args.log_of_measurement_results == {'out': [0, 0]}
def test_state_vector_trial_state_vector_is_copy():
final_state_vector = np.array([0, 1], dtype=np.complex64)
qubit_map = {cirq.NamedQubit('a'): 0}
final_simulator_state = cirq.StateVectorSimulationState(
qubits=list(qubit_map), initial_state=final_state_vector
)
trial_result = cirq.StateVectorTrialResult(
params=cirq.ParamResolver({}), measurements={}, final_simulator_state=final_simulator_state
)
assert trial_result.state_vector() is not final_simulator_state.target_tensor
def test_state_vector_trial_result_qid_shape():
final_simulator_state = cirq.StateVectorSimulationState(
qubits=[cirq.NamedQubit('a')], initial_state=np.array([0, 1]))
trial_result = cirq.StateVectorTrialResult(
params=cirq.ParamResolver({'s': 1}),
measurements={'m': np.array([[1]])},
final_simulator_state=final_simulator_state,
)
assert cirq.qid_shape(trial_result) == (2, )
final_simulator_state = cirq.StateVectorSimulationState(
qubits=cirq.LineQid.for_qid_shape((3, 2)),
initial_state=np.array([0, 0, 0, 0, 1, 0]))
trial_result = cirq.StateVectorTrialResult(
params=cirq.ParamResolver({'s': 1}),
measurements={'m': np.array([[2, 0]])},
final_simulator_state=final_simulator_state,
)
assert cirq.qid_shape(trial_result) == (3, 2)
def test_str_big():
qs = cirq.LineQubit.range(10)
final_simulator_state = cirq.StateVectorSimulationState(
prng=np.random.RandomState(0),
qubits=qs,
initial_state=np.array([1] * 2**10, dtype=np.complex64) * 0.03125,
dtype=np.complex64,
)
result = cirq.StateVectorTrialResult(cirq.ParamResolver(), {}, final_simulator_state)
assert 'output vector: [0.03125+0.j 0.03125+0.j 0.03125+0.j ..' in str(result)
def get_result(state: np.ndarray, sample: float):
mock_prng.random.return_value = sample
args = cirq.StateVectorSimulationState(
available_buffer=np.empty_like(state),
qubits=cirq.LineQubit.range(4),
prng=mock_prng,
initial_state=np.copy(state),
dtype=cast(Type[np.complexfloating], state.dtype),
)
cirq.act_on(Decay11(), args, [cirq.LineQubit(1), cirq.LineQubit(3)])
return args.target_tensor
def test_infer_target_tensor():
dtype = np.complex64
args = cirq.StateVectorSimulationState(
qubits=cirq.LineQubit.range(2),
initial_state=np.array([1.0, 0.0, 0.0, 0.0], dtype=dtype),
dtype=dtype,
)
np.testing.assert_almost_equal(
args.target_tensor,
np.array([[1.0 + 0.0j, 0.0 + 0.0j], [0.0 + 0.0j, 0.0 + 0.0j]],
dtype=dtype),
)
args = cirq.StateVectorSimulationState(qubits=cirq.LineQubit.range(2),
initial_state=0,
dtype=dtype)
np.testing.assert_almost_equal(
args.target_tensor,
np.array([[1.0 + 0.0j, 0.0 + 0.0j], [0.0 + 0.0j, 0.0 + 0.0j]],
dtype=dtype),
)
def test_default_parameter():
dtype = np.complex64
tensor = cirq.one_hot(shape=(2, 2, 2), dtype=np.complex64)
qubits = cirq.LineQubit.range(3)
args = cirq.StateVectorSimulationState(qubits=qubits,
initial_state=tensor,
dtype=dtype)
qid_shape = cirq.protocols.qid_shape(qubits)
tensor = np.reshape(tensor, qid_shape)
np.testing.assert_almost_equal(args.target_tensor, tensor)
assert args.available_buffer.shape == tensor.shape
assert args.available_buffer.dtype == tensor.dtype
def test_implicit_copy_deprecated():
final_state_vector = np.array([0, 1], dtype=np.complex64)
qubit_map = {cirq.NamedQubit('a'): 0}
final_simulator_state = cirq.StateVectorSimulationState(
qubits=list(qubit_map), initial_state=final_state_vector)
trial_result = cirq.StateVectorTrialResult(
params=cirq.ParamResolver({}),
measurements={},
final_simulator_state=final_simulator_state)
with cirq.testing.assert_deprecated(
"state_vector will not copy the state by default",
deadline="v0.16"):
_ = trial_result.state_vector()
def test_cannot_act():
class NoDetails:
pass
args = cirq.StateVectorSimulationState(
available_buffer=np.empty((2, 2, 2), dtype=np.complex64),
qubits=cirq.LineQubit.range(3),
prng=np.random.RandomState(),
initial_state=cirq.one_hot(shape=(2, 2, 2), dtype=np.complex64),
dtype=np.complex64,
)
with pytest.raises(TypeError, match="Can't simulate operations"):
cirq.act_on(NoDetails(), args, qubits=())
def test_with_qubits():
original = cirq.StateVectorSimulationState(qubits=cirq.LineQubit.range(2),
initial_state=1,
dtype=np.complex64)
extened = original.with_qubits(cirq.LineQubit.range(2, 4))
np.testing.assert_almost_equal(
extened.target_tensor,
cirq.state_vector_kronecker_product(
np.array([[0.0 + 0.0j, 1.0 + 0.0j], [0.0 + 0.0j, 0.0 + 0.0j]],
dtype=np.complex64),
np.array([[1.0 + 0.0j, 0.0 + 0.0j], [0.0 + 0.0j, 0.0 + 0.0j]],
dtype=np.complex64),
),
)
def test_state_vector_trial_result_equality():
eq = cirq.testing.EqualsTester()
final_simulator_state = cirq.StateVectorSimulationState(initial_state=np.array([]))
eq.add_equality_group(
cirq.StateVectorTrialResult(
params=cirq.ParamResolver({}),
measurements={},
final_simulator_state=final_simulator_state,
),
cirq.StateVectorTrialResult(
params=cirq.ParamResolver({}),
measurements={},
final_simulator_state=final_simulator_state,
),
)
eq.add_equality_group(
cirq.StateVectorTrialResult(
params=cirq.ParamResolver({'s': 1}),
measurements={},
final_simulator_state=final_simulator_state,
)
)
eq.add_equality_group(
cirq.StateVectorTrialResult(
params=cirq.ParamResolver({'s': 1}),
measurements={'m': np.array([[1]])},
final_simulator_state=final_simulator_state,
)
)
final_simulator_state = cirq.StateVectorSimulationState(initial_state=np.array([1]))
eq.add_equality_group(
cirq.StateVectorTrialResult(
params=cirq.ParamResolver({'s': 1}),
measurements={'m': np.array([[1]])},
final_simulator_state=final_simulator_state,
)
)
def test_state_vector_trial_result_state_mixin():
qubits = cirq.LineQubit.range(2)
final_simulator_state = cirq.StateVectorSimulationState(
qubits=qubits, initial_state=np.array([0, 1, 0, 0])
)
result = cirq.StateVectorTrialResult(
params=cirq.ParamResolver({'a': 2}),
measurements={'m': np.array([1, 2])},
final_simulator_state=final_simulator_state,
)
rho = np.array([[0, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]])
np.testing.assert_array_almost_equal(rho, result.density_matrix_of(qubits))
bloch = np.array([0, 0, -1])
np.testing.assert_array_almost_equal(bloch, result.bloch_vector_of(qubits[1]))
assert result.dirac_notation() == '|01⟩'
def test_decomposed_fallback():
class Composite(cirq.Gate):
def num_qubits(self) -> int:
return 1
def _decompose_(self, qubits):
yield cirq.X(*qubits)
args = cirq.StateVectorSimulationState(
available_buffer=np.empty((2, 2, 2), dtype=np.complex64),
qubits=cirq.LineQubit.range(3),
prng=np.random.RandomState(),
initial_state=cirq.one_hot(shape=(2, 2, 2), dtype=np.complex64),
dtype=np.complex64,
)
cirq.act_on(Composite(), args, [cirq.LineQubit(1)])
np.testing.assert_allclose(
args.target_tensor,
cirq.one_hot(index=(0, 1, 0), shape=(2, 2, 2), dtype=np.complex64))
def test_probability_comes_up_short_results_in_fallback():
class Short(cirq.Gate):
def num_qubits(self) -> int:
return 1
def _kraus_(self):
return [cirq.unitary(cirq.X) * np.sqrt(0.999), np.eye(2) * 0]
mock_prng = mock.Mock()
mock_prng.random.return_value = 0.9999
args = cirq.StateVectorSimulationState(
available_buffer=np.empty(2, dtype=np.complex64),
qubits=cirq.LineQubit.range(1),
prng=mock_prng,
initial_state=np.array([1, 0], dtype=np.complex64),
dtype=np.complex64,
)
cirq.act_on(Short(), args, cirq.LineQubit.range(1))
np.testing.assert_allclose(args.target_tensor, np.array([0, 1]))
def test_shallow_copy_buffers():
args = cirq.StateVectorSimulationState(qubits=cirq.LineQubit.range(1),
initial_state=0)
copy = args.copy(deep_copy_buffers=False)
assert copy.available_buffer is args.available_buffer
