def test_unequal(terms_1, terms_2):
linear_dict_1 = cirq.LinearDict(terms_1)
linear_dict_2 = cirq.LinearDict(terms_2)
assert linear_dict_1 != linear_dict_2
assert linear_dict_2 != linear_dict_1
assert not linear_dict_1 == linear_dict_2
assert not linear_dict_2 == linear_dict_1
def test_paulisum_validation():
q = cirq.LineQubit.range(2)
pstr1 = cirq.X(q[0]) * cirq.X(q[1])
pstr2 = cirq.Y(q[0]) * cirq.Y(q[1])
with pytest.raises(ValueError) as e:
cirq.PauliSum([pstr1, pstr2])
assert e.match("Consider using")
with pytest.raises(ValueError):
ld = cirq.LinearDict({pstr1: 2.0})
cirq.PauliSum(ld)
with pytest.raises(ValueError):
key = frozenset([('q0', cirq.X)])
ld = cirq.LinearDict({key: 2.0})
cirq.PauliSum(ld)
with pytest.raises(ValueError):
key = frozenset([(q[0], cirq.H)])
ld = cirq.LinearDict({key: 2.0})
cirq.PauliSum(ld)
key = frozenset([(q[0], cirq.X)])
ld = cirq.LinearDict({key: 2.0})
assert (cirq.PauliSum(ld) == cirq.PauliSum.from_pauli_strings(
[2 * cirq.X(q[0])]))
def test_multiplication_in_iteration():
linear_dict = cirq.LinearDict({'u': 2, 'v': 1, 'w': -1})
for v, c in linear_dict.items():
if c > 0:
linear_dict[v] *= 0
assert linear_dict == cirq.LinearDict({'u': 0, 'v': 0, 'w': -1})
assert linear_dict == cirq.LinearDict({'w': -1})
def test_addition_in_iteration():
linear_dict = cirq.LinearDict({'a': 2, 'b': 1, 'c': 0, 'd': -1, 'e': -2})
for v in linear_dict:
linear_dict[v] += 1
assert linear_dict == cirq.LinearDict(
{'a': 3, 'b': 2, 'c': 0, 'd': 0, 'e': -1})
assert linear_dict == cirq.LinearDict({'a': 3, 'b': 2, 'e': -1})
def test_update(terms_1, terms_2, terms_expected):
linear_dict_1 = cirq.LinearDict(terms_1)
linear_dict_2 = cirq.LinearDict(terms_2)
linear_dict_1.update(linear_dict_2)
expected = cirq.LinearDict(terms_expected)
assert linear_dict_1 == expected
assert expected == linear_dict_1
def test_scalar_multiplication(scalar, terms, terms_expected):
linear_dict = cirq.LinearDict(terms)
actual_1 = scalar * linear_dict
actual_2 = linear_dict * scalar
expected = cirq.LinearDict(terms_expected)
assert actual_1 == expected
assert actual_2 == expected
assert actual_1 == actual_2
def test_vector_subtraction(terms_1, terms_2, terms_expected):
linear_dict_1 = cirq.LinearDict(terms_1)
linear_dict_2 = cirq.LinearDict(terms_2)
actual_1 = linear_dict_1 - linear_dict_2
actual_2 = linear_dict_1
actual_2 -= linear_dict_2
expected = cirq.LinearDict(terms_expected)
assert actual_1 == expected
assert actual_2 == expected
assert actual_1 == actual_2
def test_invalid_vectors_are_rejected(terms, valid_vectors, invalid_vectors):
linear_dict = cirq.LinearDict(terms, validator=lambda v: v in valid_vectors)
with pytest.raises(ValueError):
linear_dict += cirq.LinearDict.fromkeys(invalid_vectors, 1)
assert linear_dict == cirq.LinearDict(terms)
for vector in invalid_vectors:
with pytest.raises(ValueError):
linear_dict[vector] += 1
assert linear_dict == cirq.LinearDict(terms)
with pytest.raises(ValueError):
linear_dict.update(cirq.LinearDict.fromkeys(invalid_vectors, 1))
assert linear_dict == cirq.LinearDict(terms)
def __init__(self, ideal: QPROGRAM, basis_expansion: Dict[NoisyOperation,
float]) -> None:
"""Initializes an OperationRepresentation.
Args:
ideal: The ideal operation desired to be implemented.
basis_expansion: Representation of the ideal operation in a basis
of `NoisyOperation`s.
Raises:
TypeError: If all keys of `basis_expansion` are not instances of
`NoisyOperation`s.
"""
self._native_ideal = ideal
self._ideal, self._native_type = convert_to_mitiq(ideal)
if not all(
isinstance(op, NoisyOperation)
for op in basis_expansion.keys()):
raise TypeError("All keys of `basis_expansion` must be "
"of type `NoisyOperation`.")
self._basis_expansion = cirq.LinearDict(basis_expansion)
self._norm = sum(abs(coeff) for coeff in self.coeffs)
self._distribution = np.array(list(map(abs, self.coeffs))) / self.norm
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 test_repr_pretty(terms):
printer = FakePrinter()
linear_dict = cirq.LinearDict(terms)
linear_dict._repr_pretty_(printer, False)
assert printer.buffer.replace(' ', '') == str(linear_dict).replace(' ', '')
printer.reset()
linear_dict._repr_pretty_(printer, True)
assert printer.buffer == 'LinearDict(...)'
def test_copy(terms):
original = cirq.LinearDict(terms)
copy = original.copy()
assert type(copy) == cirq.LinearDict
assert copy == original
assert original == copy
original['a'] = 1
assert copy != original
assert original != copy
assert 'a' in original
assert 'a' not in copy
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 _pauli_expansion_(self) -> cirq.LinearDict[str]:
if self._is_parameterized_():
return NotImplemented
phase_angle = np.pi * self.phase_exponent / 2
angle = np.pi * self.exponent / 2
global_phase = np.exp(1j * angle)
return cirq.LinearDict({
'I': global_phase * np.cos(angle),
'X': -1j * global_phase * np.sin(angle) * np.cos(2 * phase_angle),
'Y': -1j * global_phase * np.sin(angle) * np.sin(2 * phase_angle),
})
def test_valid_vectors_are_accepted(terms, valid_vectors):
linear_dict = cirq.LinearDict(terms, validator=lambda v: v in valid_vectors)
original_dict = linear_dict.copy()
delta_dict = cirq.LinearDict.fromkeys(valid_vectors, 1)
linear_dict += cirq.LinearDict.fromkeys(valid_vectors, 1)
assert linear_dict == original_dict + delta_dict
for vector in valid_vectors:
linear_dict[vector] += 1
assert linear_dict == original_dict + 2 * delta_dict
linear_dict.update(cirq.LinearDict.fromkeys(valid_vectors, 1))
assert linear_dict == delta_dict
def test_getitem(terms, vector, expected_coefficient):
linear_dict = cirq.LinearDict(terms)
actual_coefficient = linear_dict[vector]
assert actual_coefficient == expected_coefficient
def test_setitem(terms, vector, coefficient, terms_expected):
linear_dict = cirq.LinearDict(terms)
linear_dict[vector] = coefficient
expected = cirq.LinearDict(terms_expected)
assert linear_dict == expected
assert expected == linear_dict
HasQuditUnitary(),
123,
np.eye(2),
object(),
cirq,
))
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)
@pytest.mark.parametrize('val, expected_expansion', (
(ReturnsExpansion(cirq.LinearDict({
'X': 1,
'Y': 2,
'Z': 3
})), cirq.LinearDict({
'X': 1,
'Y': 2,
'Z': 3
})),
(HasUnitary(np.eye(2)), cirq.LinearDict({'I': 1})),
(HasUnitary(np.array([[1, -1j], [1j, -1]
])), cirq.LinearDict({
'Y': 1,
'Z': 1
})),
(HasUnitary(np.array([[0., 1.], [0., 0.]
])), cirq.LinearDict({
'X': 0.5,
def _pauli_expansion_(self):
return cirq.LinearDict({'X': 0.5})
def test_delitem(terms, vector, terms_expected):
linear_dict = cirq.LinearDict(terms)
del linear_dict[vector]
expected = cirq.LinearDict(terms_expected)
assert linear_dict == expected
assert expected == linear_dict
def test_str(terms, string):
linear_dict = cirq.LinearDict(terms)
assert str(linear_dict).replace(' ', '') == string.replace(' ', '')
def test_vector_negation(terms, terms_expected):
linear_dict = cirq.LinearDict(terms)
actual = -linear_dict
expected = cirq.LinearDict(terms_expected)
assert actual == expected
assert expected == actual
def test_format(terms, fmt, expected_string):
linear_dict = cirq.LinearDict(terms)
actual_string = fmt.format(linear_dict)
assert actual_string.replace(' ', '') == expected_string.replace(' ', '')
def test_approximately_equal(terms_1, terms_2):
linear_dict_1 = cirq.LinearDict(terms_1)
linear_dict_2 = cirq.LinearDict(terms_2)
assert cirq.approx_eq(linear_dict_1, linear_dict_2)
assert cirq.approx_eq(linear_dict_2, linear_dict_1)
def test_len(terms, expected_length):
linear_dict = cirq.LinearDict(terms)
assert len(linear_dict) == expected_length
def test_bool(terms, bool_value):
linear_dict = cirq.LinearDict(terms)
assert bool(linear_dict) == bool_value
def test_scalar_division(scalar, terms, terms_expected):
linear_dict = cirq.LinearDict(terms)
actual = linear_dict / scalar
expected = cirq.LinearDict(terms_expected)
assert actual == expected
assert expected == actual
def test_repr(terms):
original = cirq.LinearDict(terms)
recovered = eval(repr(original))
assert original == recovered
assert recovered == original
def _pauli_expansion_(self) -> cirq.LinearDict[str]:
return cirq.LinearDict({'I': 10})
def test_fromkeys(keys, coefficient, terms_expected):
actual = cirq.LinearDict.fromkeys(keys, coefficient)
expected = cirq.LinearDict(terms_expected)
assert actual == expected
assert expected == actual
