scikit-network 0.33.3__cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

sknetwork/topology/minheap.pxd

@@ -0,0 +1,20 @@
+# distutils: language = c++
+# cython: language_level=3
+"""
+Created in June 2020
+@author: Julien Simonnet <julien.simonnet@etu.upmc.fr>
+@author: Yohann Robert <yohann.robert@etu.upmc.fr>
+"""
+from libcpp.vector cimport vector
+
+cdef class MinHeap:
+
+    cdef vector[int] val, pos
+    cdef int size
+
+    cdef int pop_min(self, int[:] scores)
+    cdef bint empty(self)
+    cdef void swap(self, int x, int y)
+    cdef void insert_key(self, int k, int[:] scores)
+    cdef void decrease_key(self, int i, int[:] scores)
+    cdef void min_heapify(self, int i, int[:] scores)

sknetwork/topology/minheap.pyx

@@ -0,0 +1,109 @@
+# distutils: language = c++
+# cython: language_level=3
+"""
+Created in June 2020
+@author: Julien Simonnet <julien.simonnet@etu.upmc.fr>
+@author: Yohann Robert <yohann.robert@etu.upmc.fr>
+"""
+cimport cython
+
+
+cdef inline int parent(int i):
+    """Index of the parent node of i in the tree."""
+    return (i - 1) // 2
+
+cdef inline int left(int i):
+    """Index of the left child of i in the tree."""
+    return 2 * i + 1
+
+cdef inline int right(int i):
+    """Index of the right child of i in the tree."""
+    return 2 * i + 2
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cdef class MinHeap:
+    """Min heap data structure."""
+    def __cinit__(self, int n):
+        self.val.reserve(n)		# reserves the necessary space in the vector
+        self.pos.reserve(n)		# reserves the necessary space in the other vector
+        self.size = 0
+
+    cdef bint empty(self):
+        """Check if the heap is empty."""
+        return self.size == 0
+
+    cdef inline void swap(self, int x, int y):
+        """Exchange two elements in the heap."""
+        cdef int tmp
+        tmp = self.val[x]
+        self.val[x] = self.val[y]
+        self.val[y] = tmp
+
+        # updates the position of the corresponding elements
+        self.pos[self.val[x]] = x
+        self.pos[self.val[y]] = y
+
+    # Inserts a new key k
+    cdef void insert_key(self, int k, int[:] scores):
+        """Insert new element into the heap"""
+        # First insert the new key at the end
+        self.val[self.size] = k
+        self.pos[k] = self.size
+        cdef int i = self.size
+        self.size += 1
+
+        cdef int p = parent(i)
+        while (p >= 0) and (scores[self.val[p]] > scores[self.val[i]]) :
+            self.swap(i, p)
+            i = p
+            p = parent(i)
+
+
+    cdef void decrease_key(self, int i, int[:] scores):
+        """Decrease value of key at index 'i' to new_val.
+        It is assumed that the new value is smaller than the old one.
+        """
+        cdef int pos, p
+        pos = self.pos[i]
+        if pos < self.size:
+            p = parent(pos)
+
+            while (pos != 0) and (scores[self.val[p]] > scores[self.val[pos]]):
+                self.swap(pos, p)
+                pos = p
+                p = parent(pos)
+
+    cdef int pop_min(self, int[:] scores):
+        """Remove and return the minimum element (or root) from the heap."""
+        if self.size == 1:
+            self.size = 0
+            return self.val[0]
+
+        # Store the minimum value, and remove it from heap
+        cdef int root = self.val[0]
+        self.val[0] = self.val[self.size-1]
+        self.pos[self.val[0]] = 0
+        self.size -= 1
+        self.min_heapify(0, scores)
+
+        return root
+
+    cdef void min_heapify(self, int i, int[:] scores):
+        """A recursive method to heapify a subtree with the root at given index
+        This function assumes that the subtrees are already heapified.
+        """
+        cdef int l, r, smallest
+        l = left(i)
+        r = right(i)
+        smallest = i
+        if (l < self.size) and (scores[self.val[l]] < scores[self.val[i]]):
+            smallest = l
+
+        if (r < self.size) and (scores[self.val[r]] < scores[self.val[smallest]]):
+            smallest = r
+
+        if smallest != i:
+            self.swap(i, smallest)
+            self.min_heapify(smallest, scores)

sknetwork/topology/structure.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created in July 2019
+@author: Nathan de Lara <nathan.delara@polytechnique.org>
+@author: Quentin Lutz <qlutz@enst.fr>
+@author: Thomas Bonald <tbonald@enst.fr>
+"""
+from typing import Tuple, Optional, Union, List
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.utils.check import is_symmetric, check_format
+from sknetwork.utils.format import get_adjacency
+from sknetwork.path import get_distances
+
+
+def get_connected_components(input_matrix: sparse.csr_matrix, connection: str = 'weak', force_bipartite: bool = False) \
+        -> np.ndarray:
+    """Extract the connected components of a graph.
+
+    Parameters
+    ----------
+    input_matrix :
+        Input matrix (either the adjacency matrix or the biadjacency matrix of the graph).
+    connection :
+        Must be ``'weak'`` (default) or ``'strong'``. The type of connection to use for directed graphs.
+    force_bipartite : bool
+        If ``True``, consider the input matrix as the biadjacency matrix of a bipartite graph.
+
+    Returns
+    -------
+    labels :
+        Connected component of each node.
+        For bipartite graphs, rows and columns are concatenated (rows first).
+
+    Example
+    -------
+    >>> from sknetwork.topology import get_connected_components
+    >>> from sknetwork.data import house
+    >>> get_connected_components(house())
+    array([0, 0, 0, 0, 0], dtype=int32)
+    """
+    input_matrix = check_format(input_matrix)
+    if len(input_matrix.data) == 0:
+        raise ValueError('The graph is empty (no edge).')
+    adjacency, _ = get_adjacency(input_matrix, force_bipartite=force_bipartite)
+    labels = sparse.csgraph.connected_components(adjacency, connection=connection, return_labels=True)[1]
+    return labels
+
+
+def is_connected(input_matrix: sparse.csr_matrix, connection: str = 'weak', force_bipartite: bool = False) -> bool:
+    """Check whether the graph is connected.
+
+    Parameters
+    ----------
+    input_matrix :
+        Input matrix (either the adjacency matrix or the biadjacency matrix of the graph).
+    connection :
+        Must be ``'weak'`` (default) or ``'strong'``. The type of connection to use for directed graphs.
+    force_bipartite : bool
+        If ``True``, consider the input matrix as the biadjacency matrix of a bipartite graph.
+
+    Example
+    -------
+    >>> from sknetwork.topology import is_connected
+    >>> from sknetwork.data import house
+    >>> is_connected(house())
+    True
+    """
+    return len(set(get_connected_components(input_matrix, connection, force_bipartite))) == 1
+
+
+def get_largest_connected_component(input_matrix: sparse.csr_matrix, connection: str = "weak",
+                                    force_bipartite: bool = False, return_index: bool = False) \
+        -> Union[sparse.csr_matrix, Tuple[sparse.csr_matrix, np.ndarray]]:
+    """Extract the largest connected component of a graph. Bipartite graphs are treated as undirected.
+
+    Parameters
+    ----------
+    input_matrix :
+        Adjacency matrix or biadjacency matrix of the graph.
+    connection :
+        Must be ``'weak'`` (default) or ``'strong'``. The type of connection to use for directed graphs.
+    force_bipartite : bool
+        If ``True``, consider the input matrix as the biadjacency matrix of a bipartite graph.
+    return_index : bool
+        Whether to return the index of the nodes of the largest connected component in the original graph.
+
+    Returns
+    -------
+    output_matrix : sparse.csr_matrix
+        Adjacency matrix or biadjacency matrix of the largest connected component.
+    index : array
+        Indices of the nodes in the original graph.
+        For bipartite graphs, rows and columns are concatenated (rows first).
+
+    Example
+    -------
+    >>> from sknetwork.topology import get_largest_connected_component
+    >>> from sknetwork.data import house
+    >>> get_largest_connected_component(house()).shape
+    (5, 5)
+    """
+    input_matrix = check_format(input_matrix)
+    adjacency, bipartite = get_adjacency(input_matrix, force_bipartite=force_bipartite)
+    labels = get_connected_components(adjacency, connection=connection)
+    unique_labels, counts = np.unique(labels, return_counts=True)
+    largest_component_label = unique_labels[np.argmax(counts)]
+
+    if bipartite:
+        n_row, n_col = input_matrix.shape
+        index_row = np.argwhere(labels[:n_row] == largest_component_label).ravel()
+        index_col = np.argwhere(labels[n_row:] == largest_component_label).ravel()
+        index = np.hstack((index_row, index_col))
+        output_matrix = input_matrix[index_row, :]
+        output_matrix = (output_matrix.tocsc()[:, index_col]).tocsr()
+    else:
+        index = np.argwhere(labels == largest_component_label).ravel()
+        output_matrix = input_matrix[index, :]
+        output_matrix = (output_matrix.tocsc()[:, index]).tocsr()
+    if return_index:
+        return output_matrix, index
+    else:
+        return output_matrix
+
+
+def is_bipartite(adjacency: sparse.csr_matrix, return_biadjacency: bool = False) \
+        -> Union[bool, Tuple[bool, Optional[sparse.csr_matrix], Optional[np.ndarray], Optional[np.ndarray]]]:
+    """Check whether a graph is bipartite.
+
+    Parameters
+    ----------
+    adjacency :
+       Adjacency matrix of the graph (symmetric).
+    return_biadjacency :
+        If ``True``, return a biadjacency matrix of the graph if bipartite.
+
+    Returns
+    -------
+    is_bipartite : bool
+        A boolean denoting if the graph is bipartite.
+    biadjacency : sparse.csr_matrix
+        A biadjacency matrix of the graph if bipartite (optional).
+    rows : np.ndarray
+        Index of rows in the original graph (optional).
+    cols : np.ndarray
+        Index of columns in the original graph (optional).
+
+    Example
+    -------
+    >>> from sknetwork.topology import is_bipartite
+    >>> from sknetwork.data import cyclic_graph
+    >>> is_bipartite(cyclic_graph(4))
+    True
+    >>> is_bipartite(cyclic_graph(3))
+    False
+    """
+    if not is_symmetric(adjacency):
+        raise ValueError('The graph must be undirected.')
+    if adjacency.diagonal().any():
+        if return_biadjacency:
+            return False, None, None, None
+        else:
+            return False
+    n = adjacency.indptr.shape[0] - 1
+    coloring = np.full(n, -1, dtype=int)
+    exists_remaining = n
+    while exists_remaining:
+        src = np.argwhere(coloring == -1)[0, 0]
+        next_nodes = [src]
+        coloring[src] = 0
+        exists_remaining -= 1
+        while next_nodes:
+            node = next_nodes.pop()
+            for neighbor in adjacency.indices[adjacency.indptr[node]:adjacency.indptr[node + 1]]:
+                if coloring[neighbor] == -1:
+                    coloring[neighbor] = 1 - coloring[node]
+                    next_nodes.append(neighbor)
+                    exists_remaining -= 1
+                elif coloring[neighbor] == coloring[node]:
+                    if return_biadjacency:
+                        return False, None, None, None
+                    else:
+                        return False
+    if return_biadjacency:
+        rows = np.argwhere(coloring == 0).ravel()
+        cols = np.argwhere(coloring == 1).ravel()
+        return True, adjacency[rows, :][:, cols], rows, cols
+    else:
+        return True
+
+

sknetwork/topology/tests/__init__.py

@@ -0,0 +1 @@
+"""tests for topology"""

sknetwork/topology/tests/test_cliques.py

@@ -0,0 +1,28 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for cliques"""
+import unittest
+
+from scipy.special import comb
+
+from sknetwork.data.test_graphs import *
+from sknetwork.topology.cliques import count_cliques
+
+
+class TestClique(unittest.TestCase):
+
+    def test_empty(self):
+        adjacency = test_graph_empty()
+        self.assertEqual(count_cliques(adjacency), 0)
+        with self.assertRaises(ValueError):
+            count_cliques(adjacency, 1)
+
+    def test_disconnected(self):
+        adjacency = test_disconnected_graph()
+        self.assertEqual(count_cliques(adjacency), 1)
+
+    def test_cliques(self):
+        adjacency = test_clique()
+        n = adjacency.shape[0]
+        self.assertEqual(count_cliques(adjacency), comb(n, 3, exact=True))
+        self.assertEqual(count_cliques(adjacency, 4), comb(n, 4, exact=True))

sknetwork/topology/tests/test_core.py

@@ -0,0 +1,19 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for k-core decomposition"""
+import unittest
+
+from sknetwork.data.test_graphs import *
+from sknetwork.topology.core import get_core_decomposition
+
+
+class TestCoreDecomposition(unittest.TestCase):
+
+    def test_empty(self):
+        adjacency = test_graph_empty()
+        self.assertEqual(max(get_core_decomposition(adjacency)), 0)
+
+    def test_cliques(self):
+        adjacency = test_clique()
+        n = adjacency.shape[0]
+        self.assertEqual(max(get_core_decomposition(adjacency)), n - 1)

sknetwork/topology/tests/test_cycles.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+""""tests for cycles.py"""
+import unittest
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.data import star_wars, house, cyclic_digraph, cyclic_graph, linear_digraph, linear_graph
+from sknetwork.topology import is_connected, is_acyclic, get_cycles, break_cycles
+from sknetwork.utils.format import bipartite2undirected, directed2undirected
+
+
+class TestCycle(unittest.TestCase):
+
+    def test_is_acyclic(self):
+        adjacency_with_self_loops = sparse.identity(2, format='csr')
+        self.assertFalse(is_acyclic(adjacency_with_self_loops))
+        self.assertFalse(is_acyclic(adjacency_with_self_loops, directed=True))
+        directed_cycle = cyclic_digraph(3)
+        self.assertFalse(is_acyclic(directed_cycle))
+        with self.assertRaises(ValueError):
+            is_acyclic(directed_cycle, directed=False)
+        undirected_line = linear_graph(2)
+        self.assertTrue(is_acyclic(undirected_line))
+        self.assertFalse(is_acyclic(undirected_line, directed=True))
+        acyclic_graph = linear_digraph(2)
+        self.assertTrue(is_acyclic(acyclic_graph))
+
+    def test_get_cycles(self):
+        adjacency_with_self_loops = sparse.identity(2, format='csr')
+        node_cycles = get_cycles(adjacency_with_self_loops, directed=True)
+        self.assertEqual(node_cycles, [[0], [1]])
+
+        cycle_adjacency = cyclic_digraph(4)
+        node_cycles = get_cycles(cycle_adjacency, directed=True)
+        self.assertEqual(sorted(node_cycles[0]), [0, 1, 2, 3])
+        adjacency_with_subcycles = cycle_adjacency + sparse.csr_matrix(([1], ([1], [3])), shape=cycle_adjacency.shape)
+        node_cycles = get_cycles(adjacency_with_subcycles, directed=True)
+        self.assertEqual(node_cycles, [[0, 1, 3], [0, 1, 2, 3]])
+
+        undirected_cycle = cyclic_graph(4)
+        node_cycles = get_cycles(undirected_cycle, directed=False)
+        self.assertEqual(sorted(node_cycles[0]), [0, 1, 2, 3])
+
+        disconnected_cycles = sparse.csr_matrix(([1, 1, 1], ([1, 2, 3], [2, 3, 1])), shape=(4, 4))
+        node_cycles = get_cycles(disconnected_cycles, directed=True)
+        self.assertEqual(sorted(node_cycles[0]), [1, 2, 3])
+
+    def test_break_cycles(self):
+        cycle_adjacency = cyclic_digraph(4)
+        acyclic_graph = break_cycles(cycle_adjacency, root=0, directed=True)
+        self.assertTrue(is_acyclic(acyclic_graph))
+        adjacency_with_subcycles = cycle_adjacency + sparse.csr_matrix(([1], ([1], [0])), shape=cycle_adjacency.shape)
+        acyclic_graph = break_cycles(adjacency_with_subcycles, root=0, directed=True)
+        self.assertTrue(is_acyclic(acyclic_graph))
+
+        undirected_cycle = house(metadata=False)
+        acyclic_graph = break_cycles(undirected_cycle, root=0, directed=False)
+        self.assertTrue(is_acyclic(acyclic_graph))
+
+        disconnected_cycles = sparse.csr_matrix(([1, 1, 1, 1, 1], ([0, 1, 2, 3, 4], [1, 0, 3, 4, 2])), shape=(5, 5))
+        self.assertFalse(is_connected(disconnected_cycles))
+        acyclic_graph = break_cycles(disconnected_cycles, root=[0, 2], directed=True)
+        self.assertTrue(is_acyclic(acyclic_graph))

sknetwork/topology/tests/test_structure.py

@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+""""tests for structure.py"""
+import unittest
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.data import star_wars, house, cyclic_digraph, cyclic_graph, linear_digraph, linear_graph
+from sknetwork.topology import get_connected_components, get_largest_connected_component
+from sknetwork.topology import is_connected, is_bipartite
+from sknetwork.utils.format import bipartite2undirected, directed2undirected
+
+
+class TestStructure(unittest.TestCase):
+
+    def test_cc(self):
+        adjacency = linear_digraph(3)
+        labels = get_connected_components(adjacency, connection='weak')
+        self.assertEqual(len(set(labels)), 1)
+        adjacency = linear_digraph(3)
+        labels = get_connected_components(adjacency, connection='weak', force_bipartite=True)
+        self.assertEqual(len(set(labels)), 4)
+        biadjacency = sparse.csr_matrix(([1, 1, 1, 1], [[1, 2, 3, 3], [1, 2, 2, 3]]))
+        labels = get_connected_components(biadjacency)
+        self.assertEqual(len(set(labels)), 3)
+
+    def test_connected(self):
+        adjacency = cyclic_digraph(3)
+        self.assertEqual(is_connected(adjacency), True)
+        adjacency = linear_digraph(3)
+        self.assertEqual(is_connected(adjacency, connection='strong'), False)
+        biadjacency = star_wars()
+        self.assertEqual(is_connected(biadjacency), True)
+
+    def test_largest_cc(self):
+        adjacency = cyclic_digraph(3)
+        adjacency += adjacency.T
+        largest_cc, index = get_largest_connected_component(adjacency, return_index=True)
+
+        self.assertAlmostEqual(np.linalg.norm(largest_cc.toarray() - np.array([[0, 1, 1], [1, 0, 1], [1, 1, 0]])), 0)
+        self.assertEqual(np.linalg.norm(index - np.array([0, 1, 2])), 0)
+
+        biadjacency = star_wars(metadata=False)
+        largest_cc, index = get_largest_connected_component(biadjacency, return_index=True)
+        self.assertAlmostEqual(np.linalg.norm(largest_cc.toarray() - np.array([[1, 0, 1],
+                                                                               [1, 0, 0],
+                                                                               [1, 1, 1],
+                                                                               [0, 1, 1]])), 0)
+        self.assertEqual(np.linalg.norm(index - np.array([0, 1, 2, 3, 0, 1, 2])), 0)
+
+        biadjacency = sparse.csr_matrix(([1, 1, 1, 1], [[1, 2, 3, 3], [1, 2, 2, 3]]))
+        largest_cc, index = get_largest_connected_component(biadjacency, force_bipartite=True, return_index=True)
+        self.assertEqual(largest_cc.shape[0], 2)
+        self.assertEqual(len(index), 4)
+
+        self.assertTrue(isinstance(get_largest_connected_component(adjacency, return_index=False), sparse.csr_matrix))
+
+    def test_is_bipartite(self):
+        biadjacency = star_wars(metadata=False)
+        adjacency = bipartite2undirected(biadjacency)
+        self.assertTrue(is_bipartite(adjacency))
+
+        bipartite, biadjacency_pred, _, _ = is_bipartite(adjacency, return_biadjacency=True)
+        self.assertEqual(bipartite, True)
+        self.assertEqual(np.all(biadjacency.data == biadjacency_pred.data), True)
+
+        adjacency = sparse.identity(2, format='csr')
+        bipartite, biadjacency, _, _ = is_bipartite(adjacency, return_biadjacency=True)
+        self.assertEqual(bipartite, False)
+        self.assertIsNone(biadjacency)
+
+        adjacency = directed2undirected(cyclic_digraph(3))
+        bipartite, biadjacency, _, _ = is_bipartite(adjacency, return_biadjacency=True)
+        self.assertEqual(bipartite, False)
+        self.assertIsNone(biadjacency)
+
+        with self.assertRaises(ValueError):
+            is_bipartite(cyclic_digraph(3))
+
+        self.assertFalse(is_bipartite(sparse.eye(3)))
+
+        adjacency = directed2undirected(cyclic_digraph(3))
+        bipartite = is_bipartite(adjacency, return_biadjacency=False)
+        self.assertEqual(bipartite, False)

sknetwork/topology/tests/test_triangles.py

@@ -0,0 +1,38 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for triangle counting"""
+
+import unittest
+
+from scipy.special import comb
+
+from sknetwork.data import karate_club
+from sknetwork.data.parse import from_edge_list
+from sknetwork.data.test_graphs import *
+from sknetwork.topology.triangles import count_triangles, get_clustering_coefficient
+
+
+class TestTriangle(unittest.TestCase):
+
+    def test_empty(self):
+        adjacency = test_graph_empty()
+        self.assertEqual(count_triangles(adjacency), 0)
+
+    def test_disconnected(self):
+        adjacency = test_disconnected_graph()
+        self.assertEqual(count_triangles(adjacency), 1)
+
+    def test_cliques(self):
+        adjacency = test_clique()
+        n = adjacency.shape[0]
+        self.assertEqual(count_triangles(adjacency), comb(n, 3, exact=True))
+
+    def test_clustering_coefficient(self):
+        edges = [(0, 1), (1, 2), (2, 3), (3, 0), (0, 2)]
+        adjacency = from_edge_list(edges, directed=False, matrix_only=True)
+        self.assertEqual(0.75, get_clustering_coefficient(adjacency))
+
+    def test_options(self):
+        adjacency = karate_club()
+        self.assertEqual(count_triangles(adjacency, parallelize=False), 45)
+        self.assertEqual(count_triangles(adjacency, parallelize=True), 45)

sknetwork/topology/tests/test_wl.py

@@ -0,0 +1,72 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for Weisfeiler-Lehman"""
+import unittest
+
+import numpy as np
+
+from sknetwork.data import house, bow_tie, linear_graph
+from sknetwork.data.test_graphs import *
+from sknetwork.topology import color_weisfeiler_lehman, are_isomorphic
+
+
+class TestWLKernel(unittest.TestCase):
+
+    def test_isomorphism(self):
+        ref = house()
+        n = ref.shape[0]
+
+        adjacency = house()
+        reorder = list(range(n))
+        np.random.shuffle(reorder)
+        adjacency = adjacency[reorder][:, reorder]
+        self.assertTrue(are_isomorphic(ref, adjacency))
+
+        adjacency = bow_tie()
+        self.assertFalse(are_isomorphic(ref, adjacency))
+
+        adjacency = linear_graph(n)
+        self.assertFalse(are_isomorphic(ref, adjacency))
+
+        adjacency = linear_graph(n + 1)
+        self.assertFalse(are_isomorphic(ref, adjacency))
+
+
+class TestWLColoring(unittest.TestCase):
+
+    def test_empty(self):
+        adjacency = test_graph_empty()
+        labels = color_weisfeiler_lehman(adjacency)
+        self.assertTrue((labels == np.zeros(10)).all())
+
+    def test_cliques(self):
+        adjacency = test_clique()
+        labels = color_weisfeiler_lehman(adjacency)
+        self.assertTrue((labels == np.zeros(10)).all())
+
+    def test_house(self):
+        adjacency = house()
+        labels = color_weisfeiler_lehman(adjacency)
+        self.assertTrue((labels == np.array([0, 2, 1, 1, 2])).all())
+
+    def test_bow_tie(self):
+        adjacency = bow_tie()
+        labels = color_weisfeiler_lehman(adjacency)
+        self.assertTrue((labels == np.array([1, 0, 0, 0, 0])).all())
+
+    def test_iso(self):
+        adjacency = house()
+        n = adjacency.indptr.shape[0] - 1
+        reorder = list(range(n))
+        np.random.shuffle(reorder)
+        adjacency2 = adjacency[reorder][:, reorder]
+        l1 = color_weisfeiler_lehman(adjacency)
+        l2 = color_weisfeiler_lehman(adjacency2)
+        l1.sort()
+        l2.sort()
+        self.assertTrue((l1 == l2).all())
+
+    def test_early_stop(self):
+        adjacency = house()
+        labels = color_weisfeiler_lehman(adjacency, max_iter=1)
+        self.assertTrue((labels == np.array([0, 1, 0, 0, 1])).all())