scikit-network 0.28.3__cp39-cp39-macosx_12_0_arm64.whl

sknetwork/topology/kcore.pyx

@@ -0,0 +1,120 @@
+# distutils: language = c++
+# cython: language_level=3
+# cython: linetrace=True
+# distutils: define_macros=CYTHON_TRACE_NOGIL=1
+"""
+Created on Jun 3, 2020
+@author: Julien Simonnet <julien.simonnet@etu.upmc.fr>
+@author: Yohann Robert <yohann.robert@etu.upmc.fr>
+"""
+cimport cython
+
+import numpy as np
+cimport numpy as np
+
+from scipy import sparse
+
+from sknetwork.utils.base import Algorithm
+from sknetwork.utils.minheap cimport MinHeap
+
+
+@cython.boundscheck(False)
+@cython.wraparound(False)
+cdef fit_core(int[:] indptr, int[:] indices):
+    """Compute the core value of each node.
+
+    Parameters
+    ----------
+    indptr :
+        CSR format index array of the normalized adjacency matrix.
+    indices :
+        CSR format index pointer array of the normalized adjacency matrix.
+
+    Returns
+    -------
+    labels :
+        Core value of each node.
+    """
+    cdef int n = indptr.shape[0] - 1
+    cdef int core_value	= 0	# current/max core value of the graph
+    cdef int min_node		# current node of minimum degree
+    cdef int i, j, k
+    cdef int[:] degrees = np.asarray(indptr)[1:] - np.asarray(indptr)[:n]
+    cdef np.ndarray[int, ndim=1] labels = np.empty((n,), dtype=np.int32)
+    cdef MinHeap mh = MinHeap.__new__(MinHeap, n)	# minimum heap with an update system
+
+    # inserts all nodes in the heap
+    for i in range(n):
+        mh.insert_key(i, degrees)
+
+    i = n - 1		# index of the rear of the list/array
+    while not mh.empty():		# until the heap is emptied
+        min_node = mh.pop_min(degrees)
+        core_value = max(core_value, degrees[min_node])
+
+        # decreases the degree of each neighbors of min_node to simulate its deletion
+        for k in range(indptr[min_node], indptr[min_node+1]):
+            j = indices[k]
+            degrees[j] -= 1
+            mh.decrease_key(j, degrees)		# updates the heap to take into account the new degrees
+
+        labels[min_node] = core_value
+        i -= 1
+
+    return np.asarray(labels)
+
+
+class CoreDecomposition(Algorithm):
+    """K-core decomposition algorithm.
+
+    * Graphs
+
+    Attributes
+    ----------
+    labels_ : np.ndarray
+        Core value of each node.
+    core_value_ : int
+        Maximum core value of the graph
+
+    Example
+    -------
+    >>> from sknetwork.topology import CoreDecomposition
+    >>> from sknetwork.data import karate_club
+    >>> kcore = CoreDecomposition()
+    >>> adjacency = karate_club()
+    >>> kcore.fit(adjacency)
+    >>> kcore.core_value_
+    4
+    """
+    def __init__(self):
+        super(CoreDecomposition, self).__init__()
+        self.labels_ = None
+        self.core_value_ = None
+
+    def fit(self, adjacency: sparse.csr_matrix) -> 'CoreDecomposition':
+        """K-core decomposition.
+
+        Parameters
+        ----------
+        adjacency :
+            Adjacency matrix of the graph.
+
+        Returns
+        -------
+         self: :class:`CoreDecomposition`
+        """
+        labels = fit_core(adjacency.indptr, adjacency.indices)
+        self.labels_ = labels
+        self.core_value_ = labels.max()
+        return self
+
+    def fit_transform(self, adjacency: sparse.csr_matrix):
+        """Fit algorithm to the data and return the core value of each node. Same parameters as the ``fit`` method.
+
+        Returns
+        -------
+        labels :
+            Core value of the nodes.
+        """
+        self.fit(adjacency)
+        return self.labels_

sknetwork/topology/structure.py

@@ -0,0 +1,234 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on July 24, 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
+
+import numpy as np
+from scipy import sparse
+
+from sknetwork.utils.check import is_symmetric, check_format
+from sknetwork.utils.format import get_adjacency
+
+
+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
+
+
+def is_acyclic(adjacency: sparse.csr_matrix, directed: Optional[bool] = None) -> bool:
+    """Check whether a graph has no cycle.
+
+    Parameters
+    ----------
+    adjacency:
+        Adjacency matrix of the graph.
+    directed:
+        Whether to consider the graph as directed (inferred if not specified).
+    Returns
+    -------
+    is_acyclic : bool
+        A boolean with value True if the graph has no cycle and False otherwise.
+
+    Example
+    -------
+    >>> from sknetwork.topology import is_acyclic
+    >>> from sknetwork.data import star, grid
+    >>> is_acyclic(star())
+    True
+    >>> is_acyclic(grid())
+    False
+    """
+    if directed is False:
+        # the graph must be undirected
+        if not is_symmetric(adjacency):
+            raise ValueError("The adjacency matrix is not symmetric. The parameter 'directed' must be True.")
+    elif directed is None:
+        # if not specified, infer from the graph
+        directed = not is_symmetric(adjacency)
+    has_loops = (adjacency.diagonal() > 0).any()
+    if has_loops:
+        return False
+    else:
+        n_cc = sparse.csgraph.connected_components(adjacency, directed, connection='strong', return_labels=False)
+        n_nodes = adjacency.shape[0]
+        if directed:
+            return n_cc == n_nodes
+        else:
+            n_edges = adjacency.nnz // 2
+            return n_cc == n_nodes - n_edges

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 k-cliques count"""
+import unittest
+
+from scipy.special import comb
+
+from sknetwork.data.test_graphs import *
+from sknetwork.topology import Cliques
+
+
+class TestCliqueListing(unittest.TestCase):
+
+    def test_empty(self):
+        adjacency = test_graph_empty()
+        self.assertEqual(Cliques(2).fit_transform(adjacency), 0)
+        cliques = Cliques(1)
+        self.assertRaises(ValueError, cliques.fit_transform, adjacency)
+
+    def test_disconnected(self):
+        adjacency = test_graph_disconnect()
+        self.assertEqual(Cliques(3).fit_transform(adjacency), 1)
+
+    def test_cliques(self):
+        adjacency = test_graph_clique()
+        n = adjacency.shape[0]
+        self.assertEqual(Cliques(3).fit_transform(adjacency), comb(n, 3, exact=True))
+        self.assertEqual(Cliques(4).fit_transform(adjacency), comb(n, 4, exact=True))

sknetwork/topology/tests/test_cores.py

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

sknetwork/topology/tests/test_dag.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+""""tests for dag.py"""
+import unittest
+
+import numpy as np
+
+from sknetwork.data import house
+from sknetwork.topology import DAG
+
+
+class TestDAG(unittest.TestCase):
+
+    def test_options(self):
+        adjacency = house()
+        dag = DAG()
+        dag.fit(adjacency)
+        self.assertEqual(dag.indptr_.shape[0], adjacency.shape[0]+1)
+        self.assertEqual(dag.indices_.shape[0], 6)
+
+        with self.assertRaises(ValueError):
+            dag.fit(adjacency, sorted_nodes=np.arange(3))
+
+        with self.assertRaises(ValueError):
+            dag = DAG(ordering='toto')
+            dag.fit(adjacency)

sknetwork/topology/tests/test_structure.py

@@ -0,0 +1,99 @@
+#!/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, cyclic_digraph, linear_digraph, linear_graph
+from sknetwork.topology import get_connected_components, get_largest_connected_component
+from sknetwork.topology import is_connected, is_bipartite, is_acyclic
+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)
+
+    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))

sknetwork/topology/tests/test_triangles.py

@@ -0,0 +1,42 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for label propagation"""
+
+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 import Triangles
+
+
+class TestTriangleListing(unittest.TestCase):
+
+    def test_empty(self):
+        adjacency = test_graph_empty()
+        self.assertEqual(Triangles().fit_transform(adjacency), 0)
+
+    def test_disconnected(self):
+        adjacency = test_graph_disconnect()
+        self.assertEqual(Triangles().fit_transform(adjacency), 1)
+
+    def test_cliques(self):
+        adjacency = test_graph_clique()
+        n = adjacency.shape[0]
+        nb = Triangles().fit_transform(adjacency)
+        self.assertEqual(nb, 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)
+
+        triangles = Triangles().fit(adjacency)
+        self.assertEqual(0.75, triangles.clustering_coef_)
+
+    def test_options(self):
+        adjacency = karate_club()
+
+        self.assertEqual(Triangles(parallelize=False).fit_transform(adjacency), 45)
+        self.assertEqual(Triangles(parallelize=True).fit_transform(adjacency), 45)

sknetwork/topology/tests/test_wl_coloring.py

@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for Weisfeiler-Lehman coloring"""
+import unittest
+
+from sknetwork.data import house, bow_tie
+from sknetwork.data.test_graphs import *
+from sknetwork.topology import WeisfeilerLehman
+
+
+class TestWLColoring(unittest.TestCase):
+
+    def test_empty(self):
+        adjacency = test_graph_empty()
+        labels = WeisfeilerLehman().fit_transform(adjacency)
+        self.assertTrue((labels == np.zeros(10)).all())
+
+    def test_cliques(self):
+        adjacency = test_graph_clique()
+        labels = WeisfeilerLehman().fit_transform(adjacency)
+        self.assertTrue((labels == np.zeros(10)).all())
+
+    def test_house(self):
+        adjacency = house()
+        labels = WeisfeilerLehman().fit_transform(adjacency)
+        self.assertTrue((labels == np.array([0, 2, 1, 1, 2])).all())
+
+    def test_bow_tie(self):
+        adjacency = bow_tie()
+        labels = WeisfeilerLehman().fit_transform(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 = WeisfeilerLehman().fit_transform(adjacency)
+        l2 = WeisfeilerLehman().fit_transform(adjacency2)
+        l1.sort()
+        l2.sort()
+        self.assertTrue((l1 == l2).all())
+
+    def test_early_stop(self):
+        adjacency = house()
+        wl = WeisfeilerLehman(max_iter=1)
+        labels = wl.fit_transform(adjacency)
+        self.assertTrue((labels == np.array([0, 1, 0, 0, 1])).all())

sknetwork/topology/tests/test_wl_kernel.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""Tests for Weisfeiler-Lehman kernels"""
+import unittest
+
+import numpy as np
+
+from sknetwork.data import house, bow_tie, linear_graph
+from sknetwork.topology import 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))