<< Chapter < Page Chapter >> Page >

Complexity

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

A clique for which k = 4

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 ( n k ) , where n is the number of nodes in the graph, then:
    • We could find cores of all k in, at most, O ( n × n k ) = O ( n k + 1 ) 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

k-Assembly enumeration on a reduced set of k-cores.

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.

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

Get Jobilize Job Search Mobile App in your pocket Now!

Get it on Google Play Download on the App Store Now




Source:  OpenStax, The art of the pfug. OpenStax CNX. Jun 05, 2013 Download for free at http://cnx.org/content/col10523/1.34
Google Play and the Google Play logo are trademarks of Google Inc.

Notification Switch

Would you like to follow the 'The art of the pfug' conversation and receive update notifications?

Ask
Jugnu Khan
Start Quiz
Madison Christian
Start Quiz