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