FIX: Tests

Author: martin-carrasco

modules/transforms/liftings/graph2simplicial/neighborhood_complex_lifting.py

@@ -49,15 +49,15 @@ def lift_topology(self, data: Data) -> dict:
             i: f for i, f in enumerate(data["x"])
         }
 
-
         simplicial_complex.set_simplex_attributes(feature_dict, name="features")
 
         return self._get_lifted_topology(simplicial_complex, graph)
 
     def _get_lifted_topology(self, simplicial_complex: SimplicialComplex, graph: nx.Graph) -> dict:
         data = super()._get_lifted_topology(simplicial_complex, graph)
 
-        for r in range(simplicial_complex.dim):
+
+        for r in range(simplicial_complex.dim+1):
             data[f"x_idx_{r}"] = torch.tensor(simplicial_complex.skeleton(r))
 
         return data

test/transforms/liftings/graph2simplicial/test_neighborhood_complex_lifting.py

@@ -1,5 +1,6 @@
 import networkx as nx
 import torch
+from typing import Tuple, Set, List
 from torch_geometric.utils.convert import from_networkx
 
 from modules.data.utils.utils import load_manual_graph
@@ -18,51 +19,72 @@ def setup_method(self):
         # Initialize the NeighborhoodComplexLifting class for dim=3
         self.lifting_signed = NeighborhoodComplexLifting(complex_dim=3, signed=True)
         self.lifting_unsigned = NeighborhoodComplexLifting(complex_dim=3, signed=False)
+        self.lifting_high = NeighborhoodComplexLifting(complex_dim=7, signed=False)
 
         # Intialize an empty graph for testing purpouses
         self.empty_graph = nx.empty_graph(10)
         self.empty_data = from_networkx(self.empty_graph)
         self.empty_data["x"] = torch.rand((10, 10))
 
+        # Intialize a start graph for testing
+        self.star_graph = nx.star_graph(5)
+        self.star_data = from_networkx(self.star_graph)
+        self.star_data["x"] = torch.rand((6, 1))
+
         # Intialize a random graph for testing purpouses
-        self.random_graph = nx.fast_gnp_random_graph(10, 0.5)
+        self.random_graph = nx.fast_gnp_random_graph(5, 0.5)
         self.random_data = from_networkx(self.random_graph)
-        self.random_data["x"] = torch.rand((10, 10))
+        self.random_data["x"] = torch.rand((5, 1))
+
+
+    def has_neighbour(self, simplex_points: List[Set]) -> Tuple[bool, Set[int]]:
+        """ Verifies that the maximal simplices
+            of Data representation of a simplicial complex
+            share a neighbour.
+        """
+        for simplex_point_a in simplex_points:
+            for simplex_point_b in simplex_points:
+                # Same point
+                if simplex_point_a == simplex_point_b:
+                    continue
+                # Search all nodes to check if they are c such that a and b share c as a neighbour
+                for node in self.random_graph.nodes:
+                    # They share a neighbour
+                    if self.random_graph.has_edge(simplex_point_a.item(), node) and self.random_graph.has_edge(simplex_point_b.item(), node):
+                        return True
+        return False
 
     def test_lift_topology_random_graph(self):
         """ Verifies that the lifting procedure works on
-        random graphs, that is, checks that the simplices
+        a random graph, that is, checks that the simplices
         generated share a neighbour.
         """
-        lifted_data = self.lifting_unsigned.forward(self.random_data)
+        lifted_data = self.lifting_high.forward(self.random_data)
         # For each set of simplices
-        for r in range(1, self.lifting_unsigned.complex_dim):
-            idx_str = f"x_idx_{r}"
+        r = max(int(key.split('_')[-1]) for key in list(lifted_data.keys()) if 'x_idx_' in key)
+        idx_str = f"x_idx_{r}"
+
+        # Go over each (max_dim)-simplex 
+        for simplex_points in lifted_data[idx_str]:
+            share_neighbour = self.has_neighbour(simplex_points)
+            assert share_neighbour, f"The simplex {simplex_points} does not have a common neighbour with all the nodes."
+
+    def test_lift_topology_star_graph(self):
+        """ Verifies that the lifting procedure works on
+        a small star graph, that is, checks that the simplices
+        generated share a neighbour.
+        """
+        lifted_data = self.lifting_high.forward(self.star_data)
+        # For each set of simplices
+        r = max(int(key.split('_')[-1]) for key in list(lifted_data.keys()) if 'x_idx_' in key)
+        idx_str = f"x_idx_{r}"
+
+        # Go over each (max_dim)-simplex 
+        for simplex_points in lifted_data[idx_str]:
+            share_neighbour = self.has_neighbour(simplex_points)
+            assert share_neighbour, f"The simplex {simplex_points} does not have a common neighbour with all the nodes."
 
-            # Found maximum dimension
-            if idx_str not in lifted_data:
-                break
 
-            # Iterate over the composing nodes of each simplex
-            for simplex_points in lifted_data[idx_str]:
-                share_neighbour = True
-                # For each node in the graph
-                for node in self.random_graph.nodes:
-                    # Not checking the nodes themselves
-                    if node in simplex_points:
-                        continue
-                    share_neighbour = True
-                    # For each node in the simplex
-                    for simplex_point in simplex_points:
-                        # If the node does not have a common neighbour
-                        if not self.random_graph.has_edge(node, simplex_point):
-                            share_neighbour = False
-                            break
-                    # There is at least 1 node that has a common neighbour
-                    # with the nodes in the simplex
-                    if share_neighbour:
-                        break
-                assert share_neighbour, f"The simplex {simplex_points} does not have a common neighbour with all the nodes."
 
     def test_lift_topology_empty_graph(self):
         """ Test the lift_topology method with an empty graph.

tutorials/graph2simplicial/neighborhood_complex_lifting.ipynb

@@ -189,21 +189,7 @@
     "In this section we instantiate the lifting technique. For this particular case we are using the *neighbourhood complex* lifting. Given a graph $G = (V, E)$ we denote the vertex of $G$ as $V(G)$. Then the *neighbourhood complex* (a simplicial complex) $N(G)$ has as vertex the set $V(G)$ and as simplices the subsets of $V(G)$ that have a common neighbour.\n",
     "Consequently, this lifts a graph to a simplicial complex of rank $k$ where the is the maximum amount of nodes with which it shares a neighbour. This definition follow from [[1]](https://www.sciencedirect.com/science/article/pii/0097316578900225). \n",
     "\n",
-    "The maximum rank $r$ of the simplicial complex (denoting the simplex with highest cardinality) will be of the highest neighbourhood which will in turn, given the definition of a simplex include all of it's subsets as simples. Say, given a simplex $\\sigma$, then $\\forall \\tau \\prec \\sigma$  \n",
-    "\n",
-    "$$\n",
-    "\\exists v,u \\in \\tau :  v \\neq u \\; \\wedge \\; \\exists w: (v, w) \\in E(G) \\wedge (u, w) \\in E(G)\n",
-    "$$\n",
-    "\n",
-    "The proof that this holds is simple. Given any simplex in $N(G)$ denoted by\n",
-    " \n",
-    "$$\n",
-    "\\sigma_v = \\{u \\; | \\; \\exists w: (v, w) \\in E(G) \\wedge (u, w) \\in E(G)\\} \\cup \\{v\\}\n",
-    "$$\n",
-    "\n",
-    "Take any subset $S$ of the combinatorial representation of $\\sigma_v$ with $|S| > 1$. By the above definition, we know that if we take any arbitrairy $u', v' \\in S$ then there is at least one $w'$ such that $(u', w') \\in E(G)$ and $(v', w') \\in E(G)$. This follows from the fact that the choice of $v$ is arbitraty, so if $x$ shares a neighbour with $y$ and $z$ then $y$ shares a neighbour with $z$.\n",
-    "\n",
-    "The algorithm to compute this will inspect all nodes, all of it's neighbours and then check which nodes share this neighbours. This naive implementation's complexity is $\\mathcal{O}(|V|^3)$, where the worst case is for complete graphs.\n",
+    "The maximum rank $r$ of the simplicial complex (denoting the simplex with highest cardinality) will be of the highest neighbourhood. The algorithm to compute this will inspect all nodes, all of it's neighbours and then check which nodes share this neighbours. This naive implementation's complexity is $\\mathcal{O}(|V|^3)$, where the worst case is for complete graphs.\n",
     "\n",
     "\n",
     "Note that we can set the parameter `complex_dim` as high as we like to limit the size of the neighbourhood that is taken into account since for well connected graphs this will explode exponentially for the number of simplices created. \n",