def test_act_on_stabilizer_ch_form():
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]])})
# The below assertion does not fail since it ignores non-unitary operations
cirq.testing.assert_all_implemented_act_on_effects_match_unitary(m)
args = cirq.StabilizerChFormSimulationState(qubits=cirq.LineQubit.range(5),
prng=np.random.RandomState(),
initial_state=0)
cirq.act_on(m, args)
assert args.log_of_measurement_results == {'out': [1, 1]}
args = cirq.StabilizerChFormSimulationState(qubits=cirq.LineQubit.range(5),
prng=np.random.RandomState(),
initial_state=8)
cirq.act_on(m, args)
assert args.log_of_measurement_results == {'out': [1, 0]}
args = cirq.StabilizerChFormSimulationState(qubits=cirq.LineQubit.range(5),
prng=np.random.RandomState(),
initial_state=10)
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_unitary_fallback_h():
class UnitaryHGate(cirq.Gate):
def num_qubits(self) -> int:
return 1
def _unitary_(self):
return np.array([[1, 1], [1, -1]]) / (2**0.5)
args = cirq.StabilizerChFormSimulationState(qubits=cirq.LineQubit.range(3),
prng=np.random.RandomState())
cirq.act_on(UnitaryHGate(), args, [cirq.LineQubit(1)])
expected_args = cirq.StabilizerChFormSimulationState(
qubits=cirq.LineQubit.range(3), prng=np.random.RandomState())
cirq.act_on(cirq.H, expected_args, [cirq.LineQubit(1)])
np.testing.assert_allclose(args.state.state_vector(),
expected_args.state.state_vector())
def test_act_on_ch_form(input_gate_sequence, outcome):
original_state = cirq.StabilizerStateChForm(num_qubits=5, initial_state=31)
num_qubits = cirq.num_qubits(input_gate_sequence[0])
if num_qubits == 1:
qubits = [cirq.LineQubit(1)]
else:
assert num_qubits == 2
qubits = cirq.LineQubit.range(2)
state = cirq.StabilizerChFormSimulationState(
qubits=cirq.LineQubit.range(2),
prng=np.random.RandomState(),
initial_state=original_state.copy(),
)
flipped_state = cirq.StabilizerStateChForm(num_qubits=5, initial_state=23)
if outcome == 'Error':
with pytest.raises(TypeError, match="Failed to act action on state"):
for input_gate in input_gate_sequence:
cirq.act_on(input_gate, state, qubits)
return
for input_gate in input_gate_sequence:
cirq.act_on(input_gate, state, qubits)
if outcome == 'Original':
np.testing.assert_allclose(state.state.state_vector(),
original_state.state_vector())
if outcome == 'Flipped':
np.testing.assert_allclose(state.state.state_vector(),
flipped_state.state_vector())
def test_act_on_ch_form(phase):
state = cirq.StabilizerStateChForm(0)
args = cirq.StabilizerChFormSimulationState(
qubits=[], prng=np.random.RandomState(), initial_state=state
)
cirq.act_on(cirq.global_phase_operation(phase), args, allow_decompose=False)
assert state.state_vector() == [[phase]]
def test_cannot_act():
class NoDetails(cirq.testing.SingleQubitGate):
pass
args = cirq.StabilizerChFormSimulationState(qubits=[],
prng=np.random.RandomState())
with pytest.raises(TypeError, match="Failed to act"):
cirq.act_on(NoDetails(), args, qubits=())
def test_clifford_trial_result_str():
q0 = cirq.LineQubit(0)
final_simulator_state = cirq.StabilizerChFormSimulationState(qubits=[q0])
assert (str(
cirq.CliffordTrialResult(
params=cirq.ParamResolver({}),
measurements={'m': np.array([[1]])},
final_simulator_state=final_simulator_state,
)) == "measurements: m=1\n"
"output state: |0⟩")
def test_clifford_trial_result_repr_pretty():
q0 = cirq.LineQubit(0)
final_simulator_state = cirq.StabilizerChFormSimulationState(qubits=[q0])
result = cirq.CliffordTrialResult(
params=cirq.ParamResolver({}),
measurements={'m': np.array([[1]])},
final_simulator_state=final_simulator_state,
)
cirq.testing.assert_repr_pretty(result, "measurements: m=1\n" "output state: |0⟩")
cirq.testing.assert_repr_pretty(result, "cirq.CliffordTrialResult(...)", cycle=True)
def test_clifford_gate_act_on_ch_form():
# Although we don't support CH_form from the _act_on_, it will fall back
# to the decomposititon method and apply it through decomposed ops.
# Here we run it for the coverage only.
args = cirq.StabilizerChFormSimulationState(
initial_state=cirq.StabilizerStateChForm(num_qubits=2, initial_state=1),
qubits=cirq.LineQubit.range(2),
prng=np.random.RandomState(),
)
cirq.act_on(cirq.CliffordGate.X, args, qubits=cirq.LineQubit.range(1))
np.testing.assert_allclose(args.state.state_vector(), np.array([0, 0, 0, 1]))
def test_copy():
args = cirq.StabilizerChFormSimulationState(qubits=cirq.LineQubit.range(3),
prng=np.random.RandomState())
args1 = args.copy()
assert isinstance(args1, cirq.StabilizerChFormSimulationState)
assert args is not args1
assert args.state is not args1.state
np.testing.assert_equal(args.state.state_vector(),
args1.state.state_vector())
assert args.qubits == args1.qubits
assert args.prng is args1.prng
assert args.log_of_measurement_results is not args1.log_of_measurement_results
assert args.log_of_measurement_results == args1.log_of_measurement_results
def test_clifford_trial_result_repr():
q0 = cirq.LineQubit(0)
final_simulator_state = cirq.StabilizerChFormSimulationState(qubits=[q0])
assert (repr(
cirq.CliffordTrialResult(
params=cirq.ParamResolver({}),
measurements={'m': np.array([[1]])},
final_simulator_state=final_simulator_state,
)) == "cirq.SimulationTrialResult(params=cirq.ParamResolver({}), "
"measurements={'m': array([[1]])}, "
"final_simulator_state=cirq.StabilizerChFormSimulationState("
"initial_state=StabilizerStateChForm(num_qubits=1), "
"qubits=(cirq.LineQubit(0),), "
"classical_data=cirq.ClassicalDataDictionaryStore()))")
def test_gate_with_act_on():
class CustomGate(cirq.testing.SingleQubitGate):
def _act_on_(self, sim_state, qubits):
if isinstance(sim_state, cirq.StabilizerChFormSimulationState):
qubit = sim_state.qubit_map[qubits[0]]
sim_state.state.gamma[qubit] += 1
return True
state = cirq.StabilizerStateChForm(num_qubits=3)
args = cirq.StabilizerChFormSimulationState(qubits=cirq.LineQubit.range(3),
prng=np.random.RandomState(),
initial_state=state)
cirq.act_on(CustomGate(), args, [cirq.LineQubit(1)])
np.testing.assert_allclose(state.gamma, [0, 1, 0])
def test_run():
(q0, q1, q2) = (cirq.LineQubit(0), cirq.LineQubit(1), cirq.LineQubit(2))
"""
0: ───H───@───────────────X───M───────────
│
1: ───────X───@───────X───────────X───M───
│ │
2: ───────────X───M───────────────@───────
After the third moment, before the measurement, the state is |000> + |111>.
After measurement of q2, q0 and q1 both get a bit flip, so the q0
measurement always yields opposite of the q2 measurement. q1 has an
additional controlled not from q2, making it yield 1 always when measured.
If there were no measurements in the circuit, the final state would be
|110> + |011>.
"""
circuit = cirq.Circuit(
cirq.H(q0),
cirq.CNOT(q0, q1),
cirq.CNOT(q1, q2),
cirq.measure(q2),
cirq.X(q1),
cirq.X(q0),
cirq.measure(q0),
cirq.CNOT(q2, q1),
cirq.measure(q1),
strategy=cirq.InsertStrategy.NEW,
)
for _ in range(10):
state = cirq.StabilizerStateChForm(num_qubits=3)
classical_data = cirq.ClassicalDataDictionaryStore()
for op in circuit.all_operations():
args = cirq.StabilizerChFormSimulationState(
qubits=list(circuit.all_qubits()),
prng=np.random.RandomState(),
classical_data=classical_data,
initial_state=state,
)
cirq.act_on(op, args)
measurements = {
str(k): list(v[-1])
for k, v in classical_data.records.items()
}
assert measurements['q(1)'] == [1]
assert measurements['q(0)'] != measurements['q(2)']
def test_init_state():
args = cirq.StabilizerChFormSimulationState(qubits=cirq.LineQubit.range(1),
initial_state=1)
np.testing.assert_allclose(args.state.state_vector(), [0, 1])
with pytest.raises(ValueError, match='Must specify qubits'):
_ = cirq.StabilizerChFormSimulationState(initial_state=1)