Construction of Directed 2K Graphs

TL;DR

This paper introduces a method for constructing synthetic directed graphs that accurately replicate real-world degree correlations, using a novel directed 2K framework and an efficient algorithm.

Contribution

It defines the directed 2K construction problem, provides realizability conditions, and develops an algorithm that outperforms existing methods in generating realistic synthetic graphs.

Findings

The algorithm successfully creates synthetic graphs matching real-world degree correlations.

It outperforms state-of-the-art approaches in realism and efficiency.

Application to Twitter data demonstrates practical effectiveness.

Abstract

We study the problem of constructing synthetic graphs that resemble real-world directed graphs in terms of their degree correlations. We define the problem of directed 2K construction (D2K) that takes as input the directed degree sequence (DDS) and a joint degree and attribute matrix (JDAM) so as to capture degree correlation specifically in directed graphs. We provide necessary and sufficient conditions to decide whether a target D2K is realizable, and we design an efficient algorithm that creates realizations with that target D2K. We evaluate our algorithm in creating synthetic graphs that target real-world directed graphs (such as Twitter) and we show that it brings significant benefits compared to state-of-the-art approaches.

Figures

Tables

Table 1. Table 1. Graphs

Name	#Nodes	#Edges
p2p-Gnutella08	6,301	20,777
Wiki-Vote	7,115	103,689
AS-Caida	26,475	57,582
Twitter	81,306	1,768,135

Table 2. Table 2. Summary of results: showing improvements by fixing more properties. Labels: ”.” - no improvement, ”-” - decreased accuracy, ”+” - increased accuracy, ”Exact” - matched by definition.

Property	UMAN$\to$D1K	D1K$\to$D2K	D2K$\to$D2Km
Degree Distribution	Exact	Exact	Exact
Degree Correlation	+	Exact	Exact
Dyad Census	-	+	+
Triad Census	+	+	+
Betweenness Centrality	+	.	.
Shortest Path Distribution	+	+	+
Eigenvalues	+	+	+
DSP	+	+	+
Expansion	+	+	+
Avg. Neighbor degrees	+	+	Exact
S. Connected Components	.	.	.
K-Core Distribution	+	.	+

Equations

$$JDM(i,j)=\sum _{u\in V_i}\sum _{v\in V_j}{1}_{\{(u,v)\in E\}}$$

$$JDAM(\{i,p\},\{j,q\})=\sum _{u\in V_{\{i,p\}}}\sum _{v\in V_{\{j,q\}}}{1}_{\{(u,v)\in E\}}$$

Full text

Directed graphs, graph realizations, construction algorithms

††copyright: none††ccs: Mathematics of computing Graph algorithms

1. Introduction

It is often desirable to generate synthetic graphs that resemble real-world networks w.r.t. certain properties of interest. For example, researchers often want to simulate a process on a realistic network topology, and they may not have access to a real-world network, or they may want to generate several different realizations of the graphs of interest. In this paper, we focus specifically on directed graphs that appear in many application scenarios including, but not limited to, online social networks such as Twitter (e.g., referring to the follower relations or to actual communication among users).

There is a large body of work, both classic ((Erdős and Gallai, 1960),(Havel, 1955),(Hakimi, 1962),(Taylor, 1980)) and recent (dK-series (Mahadevan et al., 2006),(Orsini et al., 2015), PAM (Erdős et al., 2015)) that has studied the problem of constructing realizations of undirected graphs that exhibit exactly some target structural properties such as a given degree distribution or a given joint degree matrix. In this paper, we adopt the dK-series framework (Mahadevan et al., 2006),(Orsini et al., 2015), which provides an elegant way to trade accuracy (in terms of graph properties) for complexity (in generating graph realizations). Construction of dK-graphs is well understood (i.e., efficient algorithms and realizability conditions are known) for 1K (graphs with a given degree distribution) and 2K ( graphs with a given joint degree matrix). For $d>2$ (which is necessary for capturing the clustering exhibited in social networks), we recently proved that the problem is NP-hard (Devanny et al., 2016) but we also developed efficient heuristics (Gjoka et al., 2015). In contrast, construction is not well-understood for directed graphs: results are known for construction of graphs with a target directed degree sequence (Gale et al., 1957), (Fulkerson et al., 1960), but there is no notion of directed degree correlation or directed dK-series for $d\geq 2$.

In this paper, we address this problem. We define two notions of degree correlation in directed 2K graphs, namely directed 2K (D2K), and its special case D2Km. D2K includes the notion of directed degree sequence and builds on an old trick (mapping directed graphs to bipartite undirected graphs) to also express degree-correlation via a joint degree-attribute matrix (JDAM) for the bipartite graph. This problem definition lends itself naturally to techniques we previously developed for undirected 2K (Gjoka et al., 2015), an observation that we exploit to develop (i) necessary and sufficient realizability conditions and (ii) an efficient algorithm that constructs D2K realizations. Our D2K approach advances the state-of-the-art in modeling and simulating realistic directed graphs, especially in the context of online social networks.

The outline of the rest of the paper is as follows. Section 2 summarizes related work. Section 3 defines the Directed 2K problem (D2K and its special case D2Km). Section 4 provides realizability conditions for D2K and an efficient algorithm for constructing such realizations. Section 5 applies the algorithm to construct Directed 2K graphs that resemble real world graphs, and demonstrates the advantages of our approach compared to state-of-the-art approaches. Section 6 concludes the paper.

2. Related work

We adopt the systematic framework of dK-series (Mahadevan et al., 2006), which characterizes the properties of a graph using a series of probability distributions specifying all degree correlations within d-sized, simple, and connected subgraphs of a given graph G. In this framework, higher values of $d$ capture progressively more properties of G at the cost of more complex representation of the probability distribution. The dK-series exhibit two desired properties: inclusion (a dK distribution includes all properties defined by any $d^{\prime}$K distribution, $\forall d^{\prime}<d$ and convergence ($n$K, where $n=|V|$ specifies the entire graph, within isomorphism).

We focus on graph construction approaches that produce simple graphs with prescribed target distributions, unlike the stochastic approach presented by (Dorogovtsev, 2003) or the configuration model in (Aiello et al., 2000). Algorithms of known time complexity exist for $d\leq 2$, and Monte Carlo Markov Chain (MCMC) approaches are used for $d>2$.

0K Construction. 0K describes graphs with prescribed number of nodes and edges. This notion translates to simple Erdős-Rényi (ER) graphs with fixed number of edges. There is a simple extension of ER graphs to generate not just undirected but directed graphs as well, which we will use in our evaluation.

1K Construction. Degree sequences are equivalent to 1K as defined in the dK-series. Because degree sequences have been studied since the 1950s, we only focus on the most relevant results. The realizability conditions for degree sequences were given by the Erdős-Gallai theorem (Erdős and Gallai, 1960), and first algorithm to produce a single realization by Havel-Hakimi (Havel, 1955),(Hakimi, 1962). More recently, importance sampling algorithms were proposed in (Blitzstein and Diaconis, 2011) and (Del Genio et al., 2010).

2K Construction. Joint Degree Matrix (JDM) is given by the number of edges between nodes of degree $i$ ($V_{i}$) and $j$ ($V_{j}$) as in (Amanatidis et al., 2015):

[TABLE]

Realizability conditions were given by (Amanatidis et al., 2015) and several other algorithms to produce single realizations for given JDM (Czabarka et al., 2015), (Gjoka et al., 2015) and (Stanton and Pinar, 2012). The algorithms presented in (Amanatidis et al., 2015) and (Stanton and Pinar, 2012) are designed to only produce more restricted realizations with a property called Balanced Degree Invariant, while in (Czabarka et al., 2015) and (Gjoka et al., 2015), the algorithms have non-zero probability to produce any realization of a 2K distribution. An importance sampling algorithm was introduced by Bassler et. al. (Bassler et al., 2015).

Similarly an extension of JDM, Joint Degree and Attribute Matrix (JDAM) is given in graph with a single node attribute by the number of edges between nodes of degree $i$, attribute value $p$ ($V_{\{i,p\}}$) and degree $j$, attribute value $q$ ($V_{\{i,q\}}$) as in (Gjoka et al., 2015). Known results can be easily applied from the JDM problem including sampling.

[TABLE]

dK, $d>2$ Construction. While several attempts were made to find polynomial time algorithms to produce 3K graphs (Mahadevan et al., 2006) or 2K realization with prescribed (degree-dependent) clustering coefficient in (Gjoka et al., 2013),(Gjoka et al., 2015) and (Orsini et al., 2015), it was recently proved that even the realizability check for these inputs is NP-Complete in (Devanny et al., 2016).

Annotated graph construction was proposed in (Dimitropoulos et al., 2009) that considered degree correlations, however the proposed construction method will generate graphs with self-loops or multi-edges initially. An additional step removes these extra edges to make the graph simple and finally the largest connected component of the graph is returned as the constructed realization.

The space of simple realizations of 1K distributions is connected over double edge swaps preserving degrees (Taylor, 1980) and a similar result was shown in (Czabarka et al., 2015) or (Amanatidis et al., 2015) for 2K with double edge swaps that preserve degrees and the joint degree matrix. These swaps allow the use of MCMC to generate approximate probability samples for 1K and 2K. However, fast mixing for the MCMC has not been proved in general, only for special classes of realizations (Erdős et al., 2016) (Erdos et al., 2015).

We highlight related work for bipartite and directed degree sequences in details in the following section as part of our description of directed dK-series.

3. Directed 2K Problem Definition

We are able to define analogous distributions for the dK-series to capture directed graphs with given properties.

Directed 0K. As mentioned in Section 2, it is trivial to extend ER model for directed graphs. In addition, we consider another model called UMAN (Holland and Leinhardt, 1976), that captures the number of mutual, asymmetric, and null dyads in a graph. We can think about UMAN as 0K distribution with fixed numbers of mutual and unreciprocated edges.

Directed 1K. In an undirected graph $G$, a node $v$ has degree $d(v)$, and the degree sequence is simply $DS=\{d_{1},d_{2},...d_{|V|}\}$. In a directed graph, a node $v$ has both in and out degree and the directed degree sequence is $DDS=\{(d^{in}_{v},d^{out}_{v}),v\in V\}$; an example is shown on Fig. 1-top left.

It is well known from Gale’s work (Gale et al., 1957), that any directed graph can be 1-1 mapped to an undirected bipartite graph, where each node $v$ of the directed graph is split in two nodes $v_{in}$ and $v_{out}$, and the undirected edges across the two (in and out) partitions of the bipartite graph correspond to the directed edges in the directed graph. A self loop $(v,v)$ in the directed graph corresponds to a “non-chord”$(v_{in},v_{out})$ in the bipartite graph, and is shown in dashed line on Fig. 1-left-bottom.

Construction algorithms are known for a bipartite degree sequence with (Gale et al., 1957), or without non-chords, and therefore of the corresponding directed graphs with or without (Fulkerson et al., 1960) self loops, respectively. More recently, an importance sampling algorithm was shown in (Kim et al., 2012).

Directed 2K. Our goal in this paper is to go beyond directed degree sequence and capture degree correlation, and there are two ways to go about it.

D2Km: Joint (Directed) Degree Matrix $JDM((d^{in}_{i},d^{out}_{i}),(d^{in}_{j},d^{out}_{j}))$.

One way is to work directly with the directed graph, see Fig. 1-top row. We can partition nodes by both their in and out degrees $(d^{in}_{v},d^{out}_{v})$, and we can define the joint degree matrix to capture the number of edges $JDM((d^{in}_{i},d^{out}_{i}),(d^{in}_{j},d^{out}_{j}))$, between nodes with $(d^{in}_{i},d^{out}_{i})$ and $(d^{in}_{j},d^{out}_{j})$. This is shown on the top of Fig. 1. This is a natural extension of the JDM in the undirected case, and expresses a restrictive notion of degree correlation. However, there is no known algorithm that can provably generate this target JDM. For example our own 2K construction algorithm for undirected graphs (Gjoka et al., 2015) does not work all the time, although it is still a good heuristic for sparse graphs.

D2K: Joint Degree-Attribute Matrix $JDAM(degree,$ $in$ $or$ $out)$

An alternative approach is to work with the equivalent representation as an undirected bipartite graph without non-chords (Fig. 1-bottom left), and define degree correlation there. We partition in and out nodes by their degree, essentially considering that nodes in the bipartite graph can have an attribute that takes two values, “in” or “out.” We can now define degree correlation using the Joint Degree-Attribute Matrix (JDAM, which we first defined in (Gjoka et al., 2015)), as shown on Fig. 1- bottom right. This leads to a JDAM with two attribute values, such that $\forall i,j=1,...,d_{max}$ degrees and $p\in\{in,out\}$ attribute values $JDAM(\{i,p\},\{j,p\})=0$, i.e., because the bipartite graph has no edges between two “in” or ”‘out” nodes. Furthermore, the number of non-chords will be noted as $f(\{i,p\},\{j,q\})$, where $i,j\ \in\{1,...,d_{max}\}$ and $p\neq q\in\{in,out\}$; $f$ can be computed by passing through the directed degree sequence once and counting the number entries with in-degree $i$ and out-degree $j$.

This notion of $bipartite$ $JDAM$ has all the properties known for $JDM$ and $JDAM$, since it is a special case of $JDAM$ that we first defined in (Gjoka et al., 2015). This includes sufficient and necessary conditions for realizability, construction algorithms, existence of Balanced Degree Invariant realizations, importance sampling algorithm extensions from $JDM$, connectivity of space of realizations over $JDAM$ preserving double-edge swaps and MCMC properties. However, we have to show for D2K, that the non-chords described by the directed degree sequence can be added as well.

Relation of the two problems. An overview of the problems of interest is provided on Fig. 1. One difference between the two 2K problems is that D2Km provides a more restrictive notion of degree correlation than D2K since it partitions nodes by two numbers $(d^{in},d^{out})$) vs. one number $d^{in}_{v}$ or $d^{out}_{v}$. D2Km can essentially be obtained as a special case of D2K by further partitioning nodes with the same $d^{in}$ by their out degree as well. Therefore, D2Km can be solved by the same algorithm that solves D2K. For the rest of the paper, we will consider the D2K problem.

Directed 2K (D2K) Problems: Given targets JDAM and DDS:

• •

Realizability: Decide whether this D2K is realizable, i.e., whether there exist graphs with these properties.

• •

Construction: Design an algorithm that constructs at least one such realization.

• •

Sampling: Sample from the space of all graph realizations with the target D2K.

4. Realizability and Algorithm

In this section, we take as input the two target properties, namely the target $\textrm{\small{JDAM}}(\{i,p\},\{j,q\})^{\odot}$ with two attribute values and the $\textrm{DDS}^{\odot}$, and construct a directed 2K-graph with $N$ nodes that exhibits exactly these target properties. In this section, we use the bipartite representation of directed graphs as in Figure 1; this enables us to simplify our algorithm description, loose directionality of the edges and only handle a partition with non-chords.

Recall that in the D2K definition, nodes are partitioned into $K$ parts $V_{k},k=1...K$, according to the distinct $d^{in}=i$ or $d^{out}=j$ they exhibit and $\textrm{\small{JDAM}}(\{i,p\},\{j,q\})$ is indexed accordingly. For example, on Fig. 1 bottom-right, each node belongs to one of four parts $V_{\{0,in\}}=\{v\in V:d^{in}=0\}$, $V_{\{1,out\}}=\{v\in V:d^{out}=1\}$, $V_{\{1,in\}}=\{v\in V:d^{in}=1\}$, $V_{\{2,in\}}=\{v\in V:d^{in}=2\}$, and the JDAM is 3x3 (by removing rows and columns corresponding to any $V_{\{0,p\}}$, since there are no edges using these parts of any partition).

4.1. Realizability

Not all target properties are realizable (or “graphical”): there does not always exist at least one simple directed graph with those exact properties. Necessary and sufficient conditions for a target D2K, i.e., $\textrm{\small{JDAM}}(\{i,p\},\{j,q\})^{\odot}$ and $\textrm{DDS}^{\odot}$, to be realizable are the following.

• I

$\forall i,j,p:JDAM(\{i,p\},\{j,p\})=0$

• II

$\forall i,j,p,q$, if $JDAM(\{i,p\},\{j,q\})>0$, $JDAM(\{i,p\},\{j,q\})$ $+f(\{i,p\},\{j,q\})\leq|V_{k}|\cdot|V_{l}|$

• III

$\forall i,p:|V_{\{i,p\}}|=\sum_{\{j,q\}}\frac{JDAM(\{i,p\},\{j,q\})}{i}=$ number of times $i$ appears in $DDS$ as $p$ and it is an integer.

These are generalizations of the conditions for an undirected JDM, JDAM to be realizable, and they are clearly necessary. The first condition states that the target JDAM is bipartite, i.e., there should be no edges between two nodes both in “in” or “out” parts. The second condition considers edges between two (“in” and “out” ) parts and states that the number of edges defined by the $JDAM(\{i,p\},\{j,p\})$ plus the number of non-chords should not exceed the total number of edges possible in a complete bipartite graph across the two parts. The last condition ensures that the target JDAM and the target DDS are consistent: the number of nodes with in (or out) degree $i$ should be the same whether computed using the JDAM or the DDS. The conditions are shown to be sufficient via the constructive proof of the algorithm. Necessity of these conditions for simple graph construction are trivial.

4.2. Algorithm

Algorithm 1

Input: $DDS^{\odot}$, $JDAM^{\odot}$

Initialization:

a: Create nodes, partition, stubs using $DDS^{\odot}$

b: Add non-chords to G using $DDS^{\odot}$

Add Edges:

1: **for **every pair $(\{i,p\},\{j,q\})$ of partition:

2:      while $JDAM(\{i,p\},\{j,q\})<JDAM^{\odot}(\{i,p\},\{j,q\})$

3:           Pick any nodes $u$ (from $V\{i,p\}$), $v$ (from $V\{j,q\}$)

s.t. $(u,v)$ is not a non-chord or existing edge

4:           if $u$ does not have free stubs:

5:                $u^{\prime}$: node in $V\{i,p\}$ with free stubs

6:                neighbor switch for $u$ using $u^{\prime}$

**if **neighbor switch fails, $u:=u^{\prime}$

7:           if $v$ does not have free stubs:

8:                $v^{\prime}$: node in $V\{j,q\}$ with free stubs

9:                neighbor switch for $v$ using $v^{\prime}$

**if **neighbor switch fails, $v:=v^{\prime}$

10:           add edge between ($u$, $v$)

11:           $JDAM(\{i,p\},\{j,q\})$ ++; $JDAM(\{j,q\},\{i,p\})$ ++;

12: Transform bipartite G to directed graph

Output: simple directed graph G

First, we create a set of nodes $V$, where $|V|=2\cdot|\textrm{DDS}|$, we assign stubs to each node and partition nodes, as specified in the target directed degree sequence $\textrm{DDS}^{\odot}$. The stubs are originally free, i.e., they are only connected to one node. We also initialize all entries of JDAM to 0 and the non-chords between nodes according to $\textrm{DDS}^{\odot}$. Then the algorithm proceeds by connecting two nodes (one from “in” and one from “out” side), thus adding one edge $(u,v)$ at a time, that (i) are not previously connected to each other (ii) do not have a non-chord between them (to avoid self loops) and (iii) for whom the corresponding entry in the JDAM has not reached its target. The challenge lies in showing that the algorithm will always be able to make progress, by adding one edge at a time, until all entries of the JDAM reach their target, when the algorithm terminates. Indeed, there may be cases (2-5 in Fig.2), where $u$, $v$ or both do not have free stubs. Even in those cases, however, we will be able to perform JDAM-preserving edge rewirings (called neighbor switch (Gjoka et al., 2015): remove a neighbor $t$ of $v$ such that $t$ is not a neighbor of $v^{\prime}$ and add edge $(t,v^{\prime})$) to free stubs and then add the edge $(u,v)$ (cases 2-3); or we will be able to add another edge $(u^{\prime},v^{\prime})$ (cases 4-5a). Next, we prove that this is indeed always the case.

Proof.

$\{$Here, we follow the style of proof from Gjoka et. al. (Gjoka et al., 2015). However, we would like to point out that other similar results for JDM construction could be extended for directed 2K as well, such as the proof in (Czabarka et al., 2015).$\}$

Condition II. guarantees that two nodes can be always chosen to add an edge and Condition III. ensures that at least one node exist in every part of the partition as long as $JDAM(i,j)<JDAM^{\odot}(i,j)$111For more details please read Lemma 2. and 3. in (Gjoka et al., 2015).. Now, we simply show that every iteration can proceed by adding a new edge to the graph:

Case 1. Add a new edge between two nodes w/free stubs, no local rewiring needed.

Case 2. Add a new edge between a node $v$ w/out free stubs and a node $u$ w/free stubs where neighbor switch is possible for $v$ without using any non-chords.

Case 3. Add a new edge between two nodes w/out free stubs where neighbor switches are possible for both nodes without using any non-chords.

Case 4. Add a new edge between a node $v$ w/out free stubs and a node $u$ w/free stubs (or w/out free stubs where neighbor switch is possible) where neighbor switch is not possible for $v$ using $v^{\prime}$ without using any non-chords. In this case $v^{\prime}$ has the same neighbors as $v$ except the one for which it has an assigned non-chord. In this case $v^{\prime}$ is not connected to $u$ and it is possible to add $\{v^{\prime},u\}$ edge ($\{v^{\prime},u\}$ is clearly not an edge since then $u$ would be also connected to $v$ or $v$ could have done a neighbor switch).

Case 5. Add a new edge between two nodes ($u,v$) w/out free stubs, where neither can do a neighbor switch with $u^{\prime}$ and $v^{\prime}$ respectively. We have to break this case into two subcases, based on whether two nodes $u^{\prime},v^{\prime}$ w/out free stubs form a non-chord or not.

Case 5a. $u^{\prime},v^{\prime}$ is not a non-chord. This means that we can add a new edge between $u^{\prime},v^{\prime}$. It is easy to see that $u^{\prime},v^{\prime}$ edge is not already present, because otherwise $u$ and $v$ could have performed a neighbor switch.

Case 5b. $u^{\prime},v^{\prime}$ is a non-chord. This case is not possible when $u,v$ are not able to perform neighbor switches at the same time. Without loss of generality, let’s say that $u$ connects to all the neighbors of $u^{\prime}$ and node $v^{\prime}$. This means that no neighbor switch is available for $u$. Now, if we want to construct $v$ such that it can’t perform a neighbor switch with $v^{\prime}$, we need $v$ to connect all of the neighbors of $v^{\prime}$; however, this would include $u$ as well, and clearly that edge doesn’t exist. Contradiction.

This concludes our proof and shows that the algorithm will terminate and generate a bipartite graph after adding $\sum{JDAM^{\odot}(i,j)}/2=|E|$ edges. ∎

Running Time. The time complexity of the above algorithm is $O(|E|\cdot d_{max})$. In each iteration of the while loop, one edge is always added, until we add all $|E|$ edges. However, we have to consider how much time it takes to pick such nodes. There could be neighbor switches that remove previously added edges or add edges between the two parts. If we naively looked up node pairs, it would become an issue for dense graphs. A simple solution is to keep track of $JDAM^{\odot}(\{i,p\},\{j,q\})-JDAM(\{i,p\},\{j,q\})$ many node pairs where edges can be added in a set $P$. For every pair of $\{i,p\},\{j,q\}$, it is possible to initialize $P$ by passing through $O(JDAM^{\odot}(\{i,p\},\{j,q\})+f(\{i,p\},\{j,q\}))$ node pairs. A new $(u,v)$ node pair can simply be picked as a random element from $P$. If a neighbor switch for $u\in V_{\{i,p\}}$ (and similarly to $v$), rewires a neighbor $t\in V_{\{j,q\}}$, then $P=P\setminus\{u^{\prime},t\}\cup\{u,t\}$ maintains available node pairs in $P$. Note: $\{u^{\prime},t\}$ might not be in $P$. This ensures that $|P|\geq JDAM(\{i,p\},\{j,q\})-JDAM^{\prime}(\{i,p\},\{j,q\})$. These simple set operations can be done in constant time, and building $P$ takes $O(E+V)$ time over all partition class pairs. Finally we remove $(u,v)$ from $P$, which could be different from the starting pair if Case 4 or 5a occurs.

It is also possible to keep track of nodes with free stubs in a queue for each part of the partition. Once a node has no free stubs, it will remain so, except during neighbor switches. This allows selection of candidates for neighbor switches, or new edges when neighbor switches are not possible, in constant time. However, it still takes $O(d_{max})$ to check whether a node with free stubs is a good candidate for neighbor switch, because the sets of neighbors can be almost the same length, which takes linear time in the size of sets. In the worst case, there is a possibility for at most two neighbor switches per new edge, hence the running time is $O(|E|\cdot d_{max})$.

The directed graph can be constructed from the bipartite representation by collapsing nodes with non-chords and assigning directions to edges appropriately, this takes $O(E+V)$ time.

4.3. Space of Realizations

The order in which the algorithm adds edges is unspecified. The algorithm can produce any realization of a realizable D2K, with a non-zero probability. Considering all possible edge permutations as the order in which to add the edges, the ones where no neighbor switch is required correspond to all the possible realizations. Unfortunately, the remaining orderings are difficult to quantify, thus the current algorithm cannot sample uniformly from all realizations with a target D2K during construction.

Another way to sample from the space of graph realizations with a given D2K is by edge rewiring. This method is typically used by MCMC approaches that transform one realization to another by rewiring edges so as to present the target properties. On the positive side, D2K is a special case of an undirected JDAM, and thus inherits the property that JDAM realizations are connected via 2K-preserving double-edge swaps (Czabarka et al., 2015),(Amanatidis et al., 2015) if non-chords are allowed (equivalently, self-loops in directed graphs). On the negative side, we cannot use the known swaps to sample from the space of simple directed graphs.

The space of simple realizations of directed degree sequences is connected over double edge swaps, that preserve (in and out) degrees, and triangular $C_{6}$ swaps. Triangular $C_{6}$ swaps are necessary in some cases where the difference between two realization is the orientation of a directed three-cycle: in this case, the orientation of the cycle has to be reversed in a single step. The sufficiency of only these two types of swap was shown in (Erdős et al., 2013). The necessity of these swaps also carries over to (simple) directed 2K realizations. However, Fig. 3 shows a counterexample (a directed 4-cycle) where the classic swaps are not sufficient to transform one realization to the other, thus requiring a more complex swap. We leave it as an open question whether tight upper bounds can be derived on the swap size for Directed 2K realizations. 222There are possibly other cases where swaps must be more complex and include more edges at once, for example larger directed cycles with specific in/out degree order. In this paper, we do not provide tight upper bounds on the number of self-loops or the size of swaps required, but we do emphasize that no multi-edges are required and the number of self-loops are of course bounded by $|N|$.

5. Evaluation on Real-World Graphs

5.1. Datasets

We have used examples of directed graphs for our experiments from SNAP (Leskovec and Krevl, 2014): p2p-Gnutella08, Wiki-Vote, AS-Caida, Twitter. We have chosen these networks in order to represent several different sizes and generating processes for directed graphs.

We have removed any present self-loops or multi-edges from these graphs, since our goal is to produce simple graphs and this step ensures that the measured inputs from these graphs will be realizable using different directed graph construction methods (0K, UMAN, 1K, 2K, 2Km).

AS-Caida has edge labels according to the relationship between two ASes (peer, sibling, provider, customer), however provider and customer edges describe the same relation from the opposite point of view. We have modified the AS-Caida network by removing customer relations between ASes. The affect of the mutual edges - which would be present using both provider and customer relations - will be visited again in our discussion. In (Dimitropoulos et al., 2009), this graph was also considered with the relations included, however during our construction, we only use directed dK-series as described before in Section 3.

An overview of the final graphs used in our experiments is shown in Table 1.

5.2. Properties

In our results, we are going to evaluate the performance of graph generators in terms of properties associated with directed graphs. While the size of the generated graphs are maintained (number of nodes and edges), there are many other properties one could investigate.

To evaluate correctness of our implementation of D2K, first we use Degree Distributions and Degree Correlations. These are the ones expected to be exactly matched by definition.

In addition, we consider additional properties such as shortest paths, spectrum, strongly connected components, betweenness centrality, and k-core distribution. Finally, to measure how some of the local structures are preserved, we use dyad and triad censuses, dyad-wise shared partners, average neighbor degree, and expansion.

The dyad census counts the different configurations for every pair of nodes: ”mutual” - edges in both direction, ”asymmetric” - edge only in one direction and ”null” - no edge present. The triad census counts the non-isomorphic configuration for every triplet of nodes. A complete list of configurations and naming conventions can be found in (Holland and Leinhardt, 1976). Configurations are identified by three numbers (mutual, asymmetric, and null counts) and a letter in case of different non-isomorphic configuration with the same number of edges. For example ”003” is a triplet of nodes where none of the edges are present, ”030C” is a directed 3-cycle and ”300” is a triplet of nodes where all directed edges are present.

Shared partners for pairs of nodes can be defined in three ways for directed graphs: using independent two-paths, using shared outgoing neighbors or using shared incoming neighbors between pairs of nodes (Snijders et al., 2006). Dyad-wise shared partners (DSP) count node pairs by the number of shared partners appearing in a network.

Average neighbor degree captures the average degree of a nodes’ neighbors, and we split this property for in - and out degrees. Similarly, we refer to expansion for directed graphs as the ratio of the first hop and second hop neighborhoods’ sizes going out, or coming in to a node. These properties capture similar aspects of a network, but expansion excludes any mutual edges or edges between nodes in the first hop neighbors.

Some of above properties are also used by Orsini et. al. (Orsini et al., 2015) to study the convergence of dK-series over different types of undirected networks. However, we have included a few properties more natural to discuss for directed graphs, such as the triad census.

5.3. Implementation

While our current code is not available online, the undirected version of our algorithm is available in NetworkX (Hagberg et al., 2008) and easy to modify for D2K or D2Km using the description in Section 4. We plan to release our code for D2K and D2Km as part of the NetworkX library in the near future. Until then, please contact the first author for the implementation.

The implementation of the used graph properties is available as part of NetworkX or trivial to implement using the above description.

5.4. Results

We compare realizations generated by Directed ER (D0K), UMAN, Directed Degree Sequence (D1K), Directed 2K, Directed 2Km with the corresponding target properties captured on input graph (G). We use 20 random instances for every construction method and then average our results for each specific property.

Due to space constraints, we provide detailed results only for the Twitter graph in Figure 4, 5 and 6 and a brief overview of our observations over different input graphs.

First, we can observe in Figure 4 that Directed Degree Distributions and Degree Correlations are captured by D2K, D2Km as expected by definition. This shows that our implementation is correct. On the other hand, D0K, D1K and UMAN capture Degree Correlations poorly, thus D2K graphs have a possibility to capture other properties more accurately than D0K or D1K.

Dyad Census is not well captured for Twitter, as we can see in Figure 5. However, there are order of magnitude improvements in the number of mutual edges between D2Km (123,040.4) and D2K (3,628.7), D1K (2,155.95) or D0K (233.05). Of course, UMAN preserves this property by definition.

Triad Census is surprisingly well captured by UMAN, the reason being the exact match for the Dyad Census in the previous point. On the other hand, a convergence can be seen between dK-series generators with significant improvements in dense triadic structures from D1K to D2K and from D2K to D2Km.

Betweenness Centrality CDF has no significant improvements after matching degree distributions with D1K in Twitter; other examples reached target closer with D1K. Interestingly UMAN performs almost identically to D0K, even though the number of mutual edges is significantly different.

Shortest Path Distribution has slow convergence to target across different methods, but the average shortest path is shorter than the observed in $G$.

Strongly Connected Components (SCC) are not well captured by any of the dK-series generators and they tend to produce realizations with a single giant SCC and many one-node components without any intermediate sizes of SCCs.

K-Core Distribution is best captured by D2Km, and there is a small improvement from D1K to D2K using Twitter. However, the dense core using D1K or D2K is almost an order of magnitude lower core index.

Eigenvalues of Twitter is again best targeted by D2Km. There is a difference between leading eigenvalues in graph realizations of the other methods but starting at the second eigenvalue the difference between D1K and D2K quickly decreases.

Dyad-wise Shared Partners follow similar trends to other properties, such that D2Km is significantly more accurate than D1K and D2K. D2K improves over D1K in terms of ”outgoing shared partners” but that improvement decreases at ”independent two-paths” and disappears at ”incoming shared partners”.

Expansion property is again best approximated by D2Km and D2Km even matches Average Neighbor Degree exactly if marginalized by degrees as in Figure 6. D2K also follows the general shape of these distributions but includes larger error, while D1K has systematic difference compared to $G$.

Table 2 gives an overview of how network properties are affected by the different dK graph construction methods for the other remaining networks. The Twitter network showcased most of our general findings, but individually some of these networks have characteristics that makes them different from Twitter, e.g. p2p-Gnutella08 does not contain any mutual edges. The most interesting question is whether D2K or D2Km capture network properties more accurately. The answer is yes in most cases, but it might not be a significant improvement in targeting certain properties.

Local structures are generally better captured by D2K and even more precisely for D2Km, but global properties might not be significantly affected depending on the original network. However, this result is not surprising, since one of the main assumptions of the dK-series is that it is not necessary to target high $d$ values for every graph (Orsini et al., 2015).

5.5. Discussion

We have used several construction algorithms to generate random graphs and we have observed convergence for most properties in the directed dK-series. However, certain properties are not well captured by these methods, such as the Strongly Connected Components. This shows that further extensions or heuristics would be practical to extend the directed dK-series.

For some networks D1K could be a good choice, since it captures many network properties. However, we have shown that even in those cases properties related to first hop neighbors are not expected to be captured.

While for most metrics the degree labeled construction performs reasonably well -starting from D1K- it is important to notice that these methods create a low number of mutual edges. On one side, UMAN generates graphs with prescribed number of mutual edges and otherwise ER random graph-like structures. On the other hand, for larger (sparse) networks the degree labeled construction only achieves a fraction of the target number of mutual edges. A solution to this problem would be to generate D2K graphs with a number of mutual edges. It is possible to design heuristics for this problem but exact solutions might be difficult to achieve. In addition, we could consider for D2Km two matrices: one describing asymmetric and another for mutual edges between nodes with given (in, out) degrees.

We have also shown that further partitioning of nodes can help to better describe graphs by their mixing. D2Km is a very specific partition, that preserves average neighbor degrees for directed graphs, which is a property that is given by 2K in the undirected case. In the limit of the possible partitions the graphs could be exactly fixed; however, in our example this is not the case. While there are parts of the partition with only a single node in them, most of their edges go to other parts of the partition with multiple nodes. This results in a chance to construct distinct realizations with minimum number of fixed edges across different realizations. It is an interesting question, how different partitions would affect the number of realizations. We leave it as future work for both undirected and directed cases.

The limitations of degree labeled construction for undirected graphs have been shown recently, such that the realizability problem of undirected 2K with fixed number of triangles, 3K (Devanny et al., 2016), and second order degree sequences (degree and number of two hop neighbors) (Erdős and Miklós, 2016) are NP-Complete and a relaxation of JDM partitions called PAM (Erdős et al., 2015) is believed to be NP-Complete and only solved for special cases. We can say with good confidence that more restrictive models are likely to lead to NP-Complete problems; however, different partitions can be solved as long as they produce a valid JDAM for the D2K problem.

6. Conclusion

We have shown a new approach for directed graph construction by considering in and out degree correlations in addition to directed degree sequences. This extension enabled us to build a framework for directed graphs similar to the dK-series, using bipartite graphs. We solve the problem of generating bipartite graphs with prescribed degree correlations using the Joint Degree and Attribute Matrix construction algorithms. Following in the footsteps of classic work, we use this property of the JDAM problem and defined directed 2K as the combination of JDAM and a directed degree sequence. To solve our proposed problem, we provide the necessary and sufficient conditions for realizability of such inputs and a simple, efficient algorithm to generate simple realizations (without self-loops) as well. The uniform sampling from the space of these realizations is not trivial, as we have shown an example for a necessary complex edge swap in section 4.3. However, we see an opportunity for further research in edge swaps for an MCMC approach or a variant of the importance sampling algorithm from (Bassler et al., 2015).

In addition to directed 2K, we have defined D2Km, a special case using additional node attributes. D2Km provides a more restricted notion of directed 2K, that exactly captures average neighbor degree of nodes marginalized by degree. In our experiments, we have shown convergence for degree labeled directed graph construction similar to the undirected case (Orsini et al., 2015). This result is similar to (Orsini et al., 2015) in nature but it shows that degree correlations capture more information about graph structure and enables us to generate graphs which more closely resemble real-life networks.

We have identified that directed dK-series can benefit directly by prescribing the number of mutual edges. We consider this extension the most straightforward step to improve directed dK-series. However, even this problem could turn out to be NP-Complete.