def test_pauli_expansion():
a = cirq.NamedQubit('a')
b = cirq.NamedQubit('b')
assert cirq.pauli_expansion(cirq.X(a)) == cirq.LinearDict({'X': 1})
assert (cirq.pauli_expansion(cirq.CNOT(a, b)) == cirq.pauli_expansion(
cirq.CNOT))
def assert_linear_combinations_of_gates_are_equal(
actual: cirq.LinearCombinationOfGates,
expected: cirq.LinearCombinationOfGates) -> None:
actual_matrix = get_matrix(actual)
expected_matrix = get_matrix(expected)
assert np.allclose(actual_matrix, expected_matrix)
actual_expansion = cirq.pauli_expansion(actual)
expected_expansion = cirq.pauli_expansion(expected)
assert set(actual_expansion.keys()) == set(expected_expansion.keys())
for name in actual_expansion.keys():
assert abs(actual_expansion[name] - expected_expansion[name]) < 1e-12
def test_linear_combination_of_operations_has_correct_pauli_expansion(
terms, expected_expansion):
combination = cirq.LinearCombinationOfOperations(terms)
actual_expansion = cirq.pauli_expansion(combination)
assert set(actual_expansion.keys()) == set(expected_expansion.keys())
for name in actual_expansion.keys():
assert abs(actual_expansion[name] - expected_expansion[name]) < 1e-12
def test_pauli_expansion(val, expected_expansion):
actual_expansion = cirq.pauli_expansion(val)
assert cirq.approx_eq(actual_expansion, expected_expansion, atol=1e-12)
assert set(actual_expansion.keys()) == set(expected_expansion.keys())
for name in actual_expansion.keys():
assert np.abs(actual_expansion[name] -
expected_expansion[name]) < 1e-12
def pauli_expansion_for_any_matrix(matrix: np.ndarray) -> cirq.LinearDict[str]:
class _HasUnitary:
def __init__(self, matrix: np.ndarray):
self._matrix = matrix
def _unitary_(self) -> np.ndarray:
return self._matrix
return cirq.pauli_expansion(_HasUnitary(matrix))
def assert_linear_combinations_are_equal(
actual: Union[cirq.LinearCombinationOfGates, cirq.
LinearCombinationOfOperations],
expected: Union[cirq.LinearCombinationOfGates, cirq.
LinearCombinationOfOperations]) -> None:
if not actual and not expected:
assert len(actual) == 0
assert len(expected) == 0
return
actual_matrix = get_matrix(actual)
expected_matrix = get_matrix(expected)
assert np.allclose(actual_matrix, expected_matrix)
actual_expansion = cirq.pauli_expansion(actual)
expected_expansion = cirq.pauli_expansion(expected)
assert set(actual_expansion.keys()) == set(expected_expansion.keys())
for name in actual_expansion.keys():
assert abs(actual_expansion[name] - expected_expansion[name]) < 1e-12
def test_pauli_expansion():
a = cirq.NamedQubit('a')
b = cirq.NamedQubit('b')
assert cirq.pauli_expansion(cirq.X(a)) == cirq.LinearDict({'X': 1})
assert cirq.pauli_expansion(cirq.CNOT(a, b)) == cirq.pauli_expansion(cirq.CNOT)
class No(cirq.Gate):
def num_qubits(self) -> int:
return 1
class Yes(cirq.Gate):
def num_qubits(self) -> int:
return 1
def _pauli_expansion_(self):
return cirq.LinearDict({'X': 0.5})
assert cirq.pauli_expansion(No().on(a), default=None) is None
assert cirq.pauli_expansion(Yes().on(a)) == cirq.LinearDict({'X': 0.5})
def test_tagged_operation_forwards_protocols():
"""The results of all protocols applied to an operation with a tag should
be equivalent to the result without tags.
"""
q1 = cirq.GridQubit(1, 1)
q2 = cirq.GridQubit(1, 2)
h = cirq.H(q1)
tag = 'tag1'
tagged_h = cirq.H(q1).with_tags(tag)
np.testing.assert_equal(cirq.unitary(tagged_h), cirq.unitary(h))
assert cirq.has_unitary(tagged_h)
assert cirq.decompose(tagged_h) == cirq.decompose(h)
assert cirq.pauli_expansion(tagged_h) == cirq.pauli_expansion(h)
assert cirq.equal_up_to_global_phase(h, tagged_h)
assert np.isclose(cirq.channel(h), cirq.channel(tagged_h)).all()
assert cirq.measurement_key(cirq.measure(q1, key='blah').with_tags(tag)) == 'blah'
parameterized_op = cirq.XPowGate(exponent=sympy.Symbol('t'))(q1).with_tags(tag)
assert cirq.is_parameterized(parameterized_op)
resolver = cirq.study.ParamResolver({'t': 0.25})
assert cirq.resolve_parameters(parameterized_op, resolver) == cirq.XPowGate(exponent=0.25)(
q1
).with_tags(tag)
assert cirq.resolve_parameters_once(parameterized_op, resolver) == cirq.XPowGate(exponent=0.25)(
q1
).with_tags(tag)
y = cirq.Y(q1)
tagged_y = cirq.Y(q1).with_tags(tag)
assert tagged_y ** 0.5 == cirq.YPowGate(exponent=0.5)(q1)
assert tagged_y * 2 == (y * 2)
assert 3 * tagged_y == (3 * y)
assert cirq.phase_by(y, 0.125, 0) == cirq.phase_by(tagged_y, 0.125, 0)
controlled_y = tagged_y.controlled_by(q2)
assert controlled_y.qubits == (
q2,
q1,
)
assert isinstance(controlled_y, cirq.Operation)
assert not isinstance(controlled_y, cirq.TaggedOperation)
clifford_x = cirq.SingleQubitCliffordGate.X(q1)
tagged_x = cirq.SingleQubitCliffordGate.X(q1).with_tags(tag)
assert cirq.commutes(clifford_x, clifford_x)
assert cirq.commutes(tagged_x, clifford_x)
assert cirq.commutes(clifford_x, tagged_x)
assert cirq.commutes(tagged_x, tagged_x)
assert cirq.trace_distance_bound(y ** 0.001) == cirq.trace_distance_bound(
(y ** 0.001).with_tags(tag)
)
flip = cirq.bit_flip(0.5)(q1)
tagged_flip = cirq.bit_flip(0.5)(q1).with_tags(tag)
assert cirq.has_mixture(tagged_flip)
assert cirq.has_channel(tagged_flip)
flip_mixture = cirq.mixture(flip)
tagged_mixture = cirq.mixture(tagged_flip)
assert len(tagged_mixture) == 2
assert len(tagged_mixture[0]) == 2
assert len(tagged_mixture[1]) == 2
assert tagged_mixture[0][0] == flip_mixture[0][0]
assert np.isclose(tagged_mixture[0][1], flip_mixture[0][1]).all()
assert tagged_mixture[1][0] == flip_mixture[1][0]
assert np.isclose(tagged_mixture[1][1], flip_mixture[1][1]).all()
qubit_map = {q1: 'q1'}
qasm_args = cirq.QasmArgs(qubit_id_map=qubit_map)
assert cirq.qasm(h, args=qasm_args) == cirq.qasm(tagged_h, args=qasm_args)
cirq.testing.assert_has_consistent_apply_unitary(tagged_h)
def test_raises_no_pauli_expansion(val):
assert cirq.pauli_expansion(val, default=None) is None
with pytest.raises(TypeError, match='No Pauli expansion'):
cirq.pauli_expansion(val)
def test_pauli_expansion(terms, expected_expansion):
combination = cirq.LinearCombinationOfGates(terms)
actual_expansion = cirq.pauli_expansion(combination)
assert set(actual_expansion.keys()) == set(expected_expansion.keys())
for name in actual_expansion.keys():
assert abs(actual_expansion[name] - expected_expansion[name]) < 1e-12
