def test_construct_complement_qwc_adj_matrix_for_trivial_operators(
            self, observables):
        """Constructing the complement of QWC graph's adjacency matrix for a list of identity
        operations and various symmetric binary relations"""

        qwc_complement_adjacency_matrix = np.array([[0, 0, 0], [0, 0, 0],
                                                    [0, 0, 0]])

        grouping_instance = PauliGroupingStrategy(observables, "qwc")
        assert (grouping_instance.complement_adj_matrix_for_operator() ==
                qwc_complement_adjacency_matrix).all()
    def test_construct_commuting_complement_adj_matrix_for_operators(self):
        """Constructing the complement graph adjacency matrix for a list of Pauli words according
        to general commutativity."""

        observables = [PauliY(0), PauliZ(0) @ PauliZ(1), PauliY(0) @ PauliX(1)]
        commuting_complement_adjacency_matrix = np.array([[0, 1, 0], [1, 0, 0],
                                                          [0, 0, 0]])

        grouping_instance = PauliGroupingStrategy(observables, "commuting")
        assert (grouping_instance.complement_adj_matrix_for_operator() ==
                commuting_complement_adjacency_matrix).all()
Ejemplo n.º 3
0
    def test_construct_complement_anticommuting_adj_matrix_for_trivial_operators(self, observables):
        """Constructing the complement of anticommutativity graph's adjacency matrix for a list of
        identity operations and various symmetric binary relations"""

        anticommuting_complement_adjacency_matrix = np.array([[0, 1, 1], [1, 0, 1], [1, 1, 0]])

        grouping_instance = PauliGroupingStrategy(observables, "anticommuting")
        assert (
            grouping_instance.obtain_complement_adj_matrix_for_operator()
            == anticommuting_complement_adjacency_matrix
        ).all()
    def test_binary_repr_custom_wire_map(self):
        """Tests that the ``binary_repr`` method sets a custom
        wire map correctly."""

        observables = [Identity("alice"), Identity("bob"), Identity("charlie")]
        grouping_instance = PauliGroupingStrategy(observables, "anticommuting")

        n_qubits = 3
        wire_map = {"alice": 1, "bob": 0, "charlie": 2}
        _ = grouping_instance.binary_repr(n_qubits, wire_map)

        assert grouping_instance._wire_map == wire_map