def test_non_induced_subgraph_isomorphic(self):
        g_a = retworkx.PyGraph()
        g_b = retworkx.PyGraph()

        nodes = g_a.add_nodes_from(["a_1", "a_2", "a_3"])
        g_a.add_edges_from([
            (nodes[0], nodes[1], "a_1"),
            (nodes[1], nodes[2], "a_2"),
            (nodes[2], nodes[0], "a_3"),
        ])

        nodes = g_b.add_nodes_from(["a_1", "a_2", "a_3"])
        g_b.add_edges_from([(nodes[0], nodes[1], "a_1"),
                            (nodes[1], nodes[2], "a_2")])
        for id_order in [False, True]:
            with self.subTest(id_order=id_order, induced=True):
                self.assertFalse(
                    retworkx.is_subgraph_isomorphic(g_a,
                                                    g_b,
                                                    id_order=id_order,
                                                    induced=True))
            with self.subTest(id_order=id_order, induced=False):
                self.assertTrue(
                    retworkx.is_subgraph_isomorphic(g_a,
                                                    g_b,
                                                    id_order=id_order,
                                                    induced=False))
 def test_non_induced_subgraph_isomorphic_parallel_edges(self):
     first = retworkx.PyGraph()
     first.extend_from_edge_list([(0, 1), (0, 1), (1, 2), (1, 2)])
     second = retworkx.PyGraph()
     second.extend_from_edge_list([(0, 1), (1, 2), (1, 2)])
     self.assertFalse(
         retworkx.is_subgraph_isomorphic(first, second, induced=True))
     self.assertTrue(
         retworkx.is_subgraph_isomorphic(first, second, induced=False))
    def test_non_induced_grid_subgraph_isomorphic(self):
        g_a = retworkx.generators.grid_graph(2, 2)
        g_b = retworkx.PyGraph()
        g_b.add_nodes_from([0, 1, 2, 3])
        g_b.add_edges_from_no_data([(0, 1), (2, 3)])

        self.assertFalse(
            retworkx.is_subgraph_isomorphic(g_a, g_b, induced=True))

        self.assertTrue(
            retworkx.is_subgraph_isomorphic(g_a, g_b, induced=False))
 def test_empty_subgraph_isomorphic_identical(self):
     g_a = retworkx.PyGraph()
     for id_order in [False, True]:
         with self.subTest(id_order=id_order):
             self.assertTrue(
                 retworkx.is_subgraph_isomorphic(g_a,
                                                 g_a,
                                                 id_order=id_order))
 def test_empty_subgraph_isomorphic_compare_nodes(self):
     g_a = retworkx.PyGraph()
     g_b = retworkx.PyGraph()
     for id_order in [False, True]:
         with self.subTest(id_order=id_order):
             self.assertTrue(
                 retworkx.is_subgraph_isomorphic(g_a,
                                                 g_b,
                                                 lambda x, y: x == y,
                                                 id_order=id_order))
Exemple #6
0
    def test_random_gnm_induced_subgraph_isomorphism(self):
        graph = retworkx.undirected_gnm_random_graph(50, 150)
        nodes = random.sample(range(50), 25)
        subgraph = graph.subgraph(nodes)

        self.assertTrue(
            retworkx.is_subgraph_isomorphic(graph,
                                            subgraph,
                                            id_order=True,
                                            induced=True))
 def test_subgraph_isomorphic_identical(self):
     g_a = retworkx.PyGraph()
     nodes = g_a.add_nodes_from(["a_1", "a_2", "a_3"])
     g_a.add_edges_from([(nodes[0], nodes[1], "a_1"),
                         (nodes[1], nodes[2], "a_2")])
     for id_order in [False, True]:
         with self.subTest(id_order=id_order):
             self.assertTrue(
                 retworkx.is_subgraph_isomorphic(g_a,
                                                 g_a,
                                                 id_order=id_order))
    def test_subgraph_isomorphic_edge_matcher(self):
        first = retworkx.PyGraph()
        first.extend_from_weighted_edge_list([(0, 1, "a"), (1, 2, "b"),
                                              (2, 0, "c")])
        second = retworkx.PyGraph()
        second.extend_from_weighted_edge_list([(0, 1, "a"), (1, 2, "b")])

        self.assertTrue(
            retworkx.is_subgraph_isomorphic(first,
                                            second,
                                            induced=False,
                                            edge_matcher=lambda x, y: x == y))
    def test_subgraph_isomorphic_mismatch_edge_data_parallel_edges(self):
        first = retworkx.PyGraph()
        first.extend_from_weighted_edge_list([(0, 1, "a"), (0, 1, "f"),
                                              (1, 2, "b"), (2, 0, "c")])
        second = retworkx.PyGraph()
        second.extend_from_weighted_edge_list([(0, 1, "a"), (0, 1, "a"),
                                               (1, 2, "b")])

        self.assertFalse(
            retworkx.is_subgraph_isomorphic(first,
                                            second,
                                            id_order=True,
                                            edge_matcher=lambda x, y: x == y))
Exemple #10
0
    def test_random_gnm_non_induced_subgraph_isomorphism(self):
        graph = retworkx.undirected_gnm_random_graph(50, 150)
        nodes = random.sample(range(50), 25)
        subgraph = graph.subgraph(nodes)

        indexes = list(subgraph.edge_indices())
        for idx in random.sample(indexes, len(indexes) // 2):
            subgraph.remove_edge_from_index(idx)

        self.assertTrue(
            retworkx.is_subgraph_isomorphic(graph,
                                            subgraph,
                                            id_order=True,
                                            induced=False))
    def test_subgraph_isomorphic_node_count_not_ge(self):
        g_a = retworkx.PyGraph()
        g_b = retworkx.PyGraph()

        nodes = g_a.add_nodes_from(["a_1", "a_2"])
        g_a.add_edges_from([(nodes[0], nodes[1], "a_1")])

        nodes = g_b.add_nodes_from(["a_0", "a_1", "a_3"])
        g_b.add_edges_from([(nodes[0], nodes[1], "a_1")])
        for id_order in [False, True]:
            with self.subTest(id_order=id_order):
                self.assertFalse(
                    retworkx.is_subgraph_isomorphic(g_a,
                                                    g_b,
                                                    id_order=id_order))
    def test_subgraph_isomorphic_mismatch_node_data(self):
        g_a = retworkx.PyGraph()
        g_b = retworkx.PyGraph()

        nodes = g_a.add_nodes_from(["a_1", "a_2", "a_3", "a_4"])
        g_a.add_edges_from([
            (nodes[0], nodes[1], "a_1"),
            (nodes[1], nodes[2], "a_2"),
            (nodes[0], nodes[3], "a_3"),
        ])

        nodes = g_b.add_nodes_from(["b_1", "b_2", "b_3"])
        g_b.add_edges_from([(nodes[0], nodes[1], "b_1"),
                            (nodes[1], nodes[2], "b_2")])
        for id_order in [False, True]:
            with self.subTest(id_order=id_order):
                self.assertTrue(
                    retworkx.is_subgraph_isomorphic(g_a,
                                                    g_b,
                                                    id_order=id_order))
    def test_subgraph_isomorphic_compare_nodes_identical(self):
        g_a = retworkx.PyDiGraph()
        g_b = retworkx.PyDiGraph()

        nodes = g_a.add_nodes_from(["a_1", "a_2", "a_3", "a_4"])
        g_a.add_edges_from([
            (nodes[0], nodes[1], "a_1"),
            (nodes[1], nodes[2], "a_2"),
            (nodes[0], nodes[3], "a_3"),
        ])

        nodes = g_b.add_nodes_from(["a_1", "a_2", "a_3"])
        g_b.add_edges_from([(nodes[0], nodes[1], "a_1"),
                            (nodes[1], nodes[2], "a_2")])
        for id_order in [False, True]:
            with self.subTest(id_order=id_order):
                self.assertTrue(
                    retworkx.is_subgraph_isomorphic(g_a,
                                                    g_b,
                                                    lambda x, y: x == y,
                                                    id_order=id_order))