def test_wave_function_trial_result_equality():
eq = cirq.testing.EqualsTester()
eq.add_equality_group(
cirq.WaveFunctionTrialResult(
params=cirq.ParamResolver({}),
measurements={},
final_simulator_state=cirq.WaveFunctionSimulatorState(np.array([]),
{})),
cirq.WaveFunctionTrialResult(
params=cirq.ParamResolver({}),
measurements={},
final_simulator_state=cirq.WaveFunctionSimulatorState(np.array([]),
{})))
eq.add_equality_group(
cirq.WaveFunctionTrialResult(
params=cirq.ParamResolver({'s': 1}),
measurements={},
final_simulator_state=cirq.WaveFunctionSimulatorState(np.array([]),
{})))
eq.add_equality_group(
cirq.WaveFunctionTrialResult(
params=cirq.ParamResolver({'s': 1}),
measurements={'m': np.array([[1]])},
final_simulator_state=cirq.WaveFunctionSimulatorState(np.array([]),
{})))
eq.add_equality_group(
cirq.WaveFunctionTrialResult(
params=cirq.ParamResolver({'s': 1}),
measurements={'m': np.array([[1]])},
final_simulator_state=cirq.WaveFunctionSimulatorState(np.array([1]),
{})))
def test_simulate_moment_steps_empty_circuit(dtype):
circuit = cirq.Circuit()
simulator = cirq.Simulator(dtype=dtype)
step = None
for step in simulator.simulate_moment_steps(circuit):
pass
assert step.simulator_state() == cirq.WaveFunctionSimulatorState(
state_vector=np.array([1]), qubit_map={})
def test_str_big():
qs = cirq.LineQubit.range(20)
result = cirq.WaveFunctionTrialResult(
cirq.ParamResolver(), {},
cirq.WaveFunctionSimulatorState(np.array([1] * 2**10),
{q: q.x for q in qs}))
assert str(result).startswith('measurements: (no measurements)\n'
'output vector: [1 1 1 ..')
def test_wave_function_trial_result_qid_shape():
final_simulator_state = cirq.WaveFunctionSimulatorState(
qubit_map={cirq.NamedQubit('a'): 0}, state_vector=np.array([0, 1]))
trial_result = cirq.WaveFunctionTrialResult(
params=cirq.ParamResolver({'s': 1}),
measurements={'m': np.array([[1]])},
final_simulator_state=final_simulator_state)
assert cirq.qid_shape(final_simulator_state) == (2,)
assert cirq.qid_shape(trial_result) == (2,)
q0, q1 = cirq.LineQid.for_qid_shape((2, 3))
final_simulator_state = cirq.WaveFunctionSimulatorState(
qubit_map={
q0: 1,
q1: 0
}, state_vector=np.array([0, 0, 0, 0, 1, 0]))
trial_result = cirq.WaveFunctionTrialResult(
params=cirq.ParamResolver({'s': 1}),
measurements={'m': np.array([[2, 0]])},
final_simulator_state=final_simulator_state)
assert cirq.qid_shape(final_simulator_state) == (3, 2)
assert cirq.qid_shape(trial_result) == (3, 2)
def test_wave_function_trial_result_repr():
final_simulator_state = cirq.WaveFunctionSimulatorState(
qubit_map={cirq.NamedQubit('a'): 0}, state_vector=np.array([0, 1]))
trial_result = cirq.WaveFunctionTrialResult(
params=cirq.ParamResolver({'s': 1}),
measurements={'m': np.array([[1]])},
final_simulator_state=final_simulator_state)
assert repr(trial_result) == (
"cirq.WaveFunctionTrialResult("
"params=cirq.ParamResolver({'s': 1}), "
"measurements={'m': array([[1]])}, "
"final_simulator_state=cirq.WaveFunctionSimulatorState("
"state_vector=np.array([0, 1]), "
"qubit_map={cirq.NamedQubit('a'): 0}))")
def test_wave_function_trial_result_state_mixin():
qubits = cirq.LineQubit.range(2)
qubit_map = {qubits[i]: i for i in range(2)}
result = cirq.WaveFunctionTrialResult(
params=cirq.ParamResolver({'a': 2}),
measurements={'m': np.array([1, 2])},
final_simulator_state=cirq.WaveFunctionSimulatorState(
qubit_map=qubit_map, state_vector=np.array([0, 1, 0, 0])))
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_pretty_print():
result = cirq.WaveFunctionTrialResult(
cirq.ParamResolver(), {},
cirq.WaveFunctionSimulatorState(np.array([1]), {}))
# 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)\noutput vector: |⟩'
# Test cycle handling
p = FakePrinter()
result._repr_pretty_(p, True)
assert p.text_pretty == 'WaveFunctionTrialResult(...)'
def test_wave_function_simulator_state_repr():
final_simulator_state = cirq.WaveFunctionSimulatorState(
qubit_map={cirq.NamedQubit('a'): 0}, state_vector=np.array([0, 1]))
cirq.testing.assert_equivalent_repr(final_simulator_state)
