8.5 Cell assembly enumeration in random graphs  (Page 3/4)

Complexity

The algorithm described above runs in approximately exponential $\left(O\right(n!\left)\right)$ time, which is to be expected since it solves an NP-hard problem.

The enumeration of k-cores reduces to the NP complete clique problem [link] as follows:

• A clique is a k-core for which the number of vertices in the core is equal to $k+1$ ( [link] ).
• The clique problem is: determine whether an arbitrary graph contains a clique of at least size $n.$
• If we could accomplish k-core enumeration in polynomial time, say $O\left(n^k\right),$ where $n$ is the number of nodes in the graph, then:
  • We could find cores of all $k$ in, at most, $O(n\times n^k)=O\left(n^{k+1}\right)$ time, because there is no $k$ core in a given graph for which $k$ exceeds $n.$
  • Without increasing fundamental run-time, we could flag each of those k-cores which is a clique. In doing so, we find all cliques.
  • By simply finding the largest of this group of cliques, we have solved the clique problem in polynomial time.

Consequently, k-core enumeration belongs to the class of NP-hard problems, meaning that it is not clear whether an algorithm that runs significantly faster than exponential time can be devised.

That is not to say, however, that the algorithm cannot be improved upon at all. For instance, one of our implementations takes advantage of the fact that, if we form an induced subgraph $H$ by removing some vertex $v$ from a graph $G,$ if $v$ is not in a k-core, then the graph $I$ resulting from removing any of $v$ 's neighbors that are not in a k-core from $G$ will have the same maximum k-core as $H.$ Also, our algorithm takes care not to revisit previously enumerated branches. Different approaches can certainly speed up an algorithm to solve the problem, but it is not clear that any approach will make the algorithm run in sub-exponential time.

Assembly enumeration

Upon enumerating all k-cores, every unique closure of a k-core is analyzed to determine whether any one of the k-cores that closes to that closure is tight ( [link] ). Checking tightness involves nothing more clever than simply verifying the above definition of tight. If at least one of the cores that closes to a given closure is tight, then that closure is a collected into the set of k-assemblies, otherwise, it is ignored.

Experimentation

After devising an algorithm to find every k-assembly, we attempted to discover attributes about k-assemblies through, first, generating random graphs, and then, enumerating the assemblies contained in those graphs.

Random graph generation

We employed two primary types of random graphs.

1. The classical Bernoulli random graph ( [link] ):
   • Pick some probability $p,$ and a number of vertices, $n.$ Create a graph $G,$ for which $V\left(G\right)=1,2,...n.$
   • For all pairs of vertices, $(i,j),$ where $i\ne j$ and $0<i,j\le n,\exists$ an edge $ij\in E\left(G\right)$ with probability $p.$
2. The scale-free Cooper-Frieze random graph ( [link] ) [link] . As we implement it:
   • pick some positive integer $T$ ; $\alpha ,\beta ,\gamma ,\delta \in [0,1]$ ; $P,Q,$ which are 1-indexed lists. $P=(p_1,p_2,...,p_n),$ where ${\displaystyle \sum _{i=1}^{n}p=1,}$ and $p_i\in [0,1]\forall i\in \{1,2,...,n\}.$ $Q=(q_1,q_2,...,q_m),$ where ${\displaystyle \sum _{i=1}^{m}q=1,}$ and $p_i\in [0,1]\forall i\in \{1,2,...,m\}.$
   • Begin with a graph $G,$ where $V\left(G\right)=\left\{1\right\},$ and $E\left(G\right)=\left\{11\right\}.$ (That is, G is a graph with a single vertex which has a single edge connected to itself).
   • $\forall t\in \{0,1,2,...,T\}:$
     • Do the "Old" procedure with probability $\alpha ,$ otherwise, do the procedure "New."
     • Do the procedure "Add Edges."
   • Old:
     • with probability $\delta ,$ choose the vertex $\mathit{start}$ from among the set of vertices in $V\left(G\right)$ randomly, giving each vertex an even chance. Otherwise, choose $\mathit{start}$ with the probability for each vertex proportional to the the degree of that vertex with respect to G.
     • with probability $\gamma$ set the boolean variable $\mathit{terminateUniformly}$ to $\mathit{true}.$ Otherwise, set the variable to $\mathit{false}.$
     • choose an index of $Q$ so that the index $i$ has a probability $q_i$ of being chosen. Set the integer variable $\mathit{numberOfEdges}$ to this chosen index.
   • New:
     • Add a new vertex $v$ to $V\left(G\right).$ Call that vertex $\mathit{start}.$
     • With probability $\beta$ set the boolean variable $\mathit{terminateUniformly}$ to $\mathit{true}.$ Otherwise, set the variable to $\mathit{false}.$
     • choose an index of $P$ so that the index $i$ has a probability $p_i$ of being chosen. Set the integer variable $\mathit{numberOfEdges}$ to this chosen index.
   • Add Edges:
     • Create the set $\mathit{END}$ by choosing $\mathit{numberOfEdges}$ vertices from $G.$ The vertices are chosen randomly, either with uniform probability if $\mathit{terminateUniformly}$ is $\mathit{true},$ or in proportion to degree otherwise.
     • $\forall$ vertices $e\in \mathit{END},$ add to $G$ an edge directed from $\mathit{start}$ to $e.$