Fast Algorithm for K-Truss Discovery on Public-Private Graphs

TL;DR

This paper introduces an efficient incremental algorithm for discovering k-truss dense subgraphs in public-private graphs, addressing privacy concerns and improving computational performance.

Contribution

It proposes a novel node insertion update algorithm and a hybrid strategy for incremental k-truss computation in public-private graphs.

Findings

Outperforms existing methods on real-world datasets

Efficiently updates k-truss with node insertions

Validates effectiveness through extensive experiments

Abstract

In public-private graphs, users share one public graph and have their own private graphs. A private graph consists of personal private contacts that only can be visible to its owner, e.g., hidden friend lists on Facebook and secret following on Sina Weibo. However, existing public-private analytic algorithms have not yet investigated the dense subgraph discovery of k-truss, where each edge is contained in at least k-2 triangles. This paper aims at finding k-truss efficiently in public-private graphs. The core of our solution is a novel algorithm to update k-truss with node insertions. We develop a classification-based hybrid strategy of node insertions and edge insertions to incrementally compute k-truss in public-private graphs. Extensive experiments validate the superiority of our proposed algorithms against state-of-the-art methods on real-world datasets.

Tables

Table 1. Table 1 : Network Statistics of Real-world Public-Private Graphs

Name	$\left|V\right|$	$\left|E\right|$	$\left|V_{private}\right|$	$\left|E_{private}\right|$
PP-DBLP-2013	1,791,688	5,187,025	804,121	3,166,863
PP-DBLP-2014	1,791,688	5,893,083	669,138	2,491,847
PP-DBLP-2015	1,791,688	6,605,428	502,654	1,719,794
PP-DBLP-2016	1,791,688	7,378,090	257,129	719,204

Table 2. Table 2 : Comparison of Node-insertion and Edge-insertion methods in terms of efficiency, by inserting V t subscript 𝑉 𝑡 V_{t} randomly selected nodes on real-world graphs. Here K = 10 3 K superscript 10 3 \textbf{K}=10^{3} and M = 10 6 M superscript 10 6 \textbf{M}=10^{6} .

Name	$\left|V\right|$	$\left|E\right|$	$\left|V_t\right|$	Avg. time per node (s)		Speedup
				Node-ins.	Edge-ins.
DBLP	334K	925K	940	0.05	0.15	3.20
AstroPh	18K	396K	750	0.08	0.67	7.99
EmailEuAll	265K	420K	292	0.38	4.20	10.96
Wikivote	7K	103K	534	0.73	28.53	39.10
EmailEnron	36K	367K	485	0.83	24.10	29.03
Gowalla	196K	1.9M	156	2.99	102.39	34.27
WikiTalk	2.4M	5M	191	40.54	2017.26	49.76
Flickr	80K	11.8M	697	96.30	2195.57	22.80
Digg	771K	7.3M	471	142.82	5741.43	40.20
LiveJournal	4M	34.7M	377	142.63	5515.66	38.67

Table 3. Table 3 : Accuracy of different classifiers on PP-DBLP 2013-2016.

Classifier	Accuracy on PP-DBLP				Training
	2013	2014	2015	2016	time (s)
Random Forest	84.4%	87.0%	86.5%	87.8%	1
Decision Tree	84.3%	84.6%	84.7%	87.4%	1
SVM	84.1%	84.5%	85.5%	85.2%	1140
k-NN	76.0%	79.6%	78.2%	72.7%	1
Degree Baseline	69.5%	69.2%	71.8%	67.2%	1

Equations

$${\tau }_H(e)=\underset{H^{\prime }\subseteq H,e\in E(H^{\prime })}{\max }\tau (H^{\prime }).$$

$${\mathrm{k}}_{\mathrm{low}}(e)=\max \{k:w\in G_v^{k,k-2}\}$$

$${\mathrm{k}}_{\mathrm{up}}(e)=\max \{k:w\in G_v^{k-1,k-2}\}.$$

Full text

1 Introduction

Online social networks (e.g., Facebook, Twitter, Instagram, and Sina Weibo) have become vital platforms for connecting users to share information, post daily life events, and spread influence Kempe et al. (2003); Wilder et al. (2018); Zhang et al. (2017, 2018b). Due to privacy concerns, users tend to hide their connections, leading such private relationships not visible to other users in public but only themselves. For instance, Facebook users are likely to conceal their friend-list Dey et al. (2012); Weibo users may prefer using the secret following feature, which hides their interested followees. Public-private graphs are developed to model this kind of social networks Chierichetti et al. (2015). A public-private network contains a public graph which is visible and accessible to everyone; in addition, each vertex has a personal private graph only visible to its owner. Therefore, in the view of each user, the social network is a union of the public graph and its own private graph which can be significantly different for distinct users. Recently, many graph analytic tasks have been investigated on public-private networks, such as all-pairs shortest path distances, node similarities, and correlation clustering.

Dense subgraph discovery is a fundamental problem of many network analysis tasks. Numerous definitions of dense subgraphs have been proposed and investigated, e.g., clique, quasi-clique Pei et al. (2005), $n$-clan Mokken (1979), $n$-club Mokken (1979), and $k$-plex Xiao et al. (2017). Recently, a popular notion of dense subgraphs that has been studied is $k$-truss. A $k$-truss is the largest subgraph of a graph such that each edge is contained in at least $k-2$ triangles within this subgraph. Finding $k$-trusses has many useful applications such as community search Jiang et al. (2018), complex network visualization Zhao and Tung (2012), and task-driven team formation Huang et al. (2016). To the best of our knowledge, finding $k$-truss over public-private networks has not yet been studied in the literature. In this paper, we formulate the problem of finding public-private $k$-truss as follows. Given a query vertex and parameter $k$, the problem is to find $k$-truss in the public-private graph owned by this query vertex.

Efficient extraction of public-private $k$-truss raises significant challenges. A straightforward approach is to ignore users’ private edges, which can lead to inaccurate results. Another approach is to apply truss decomposition on the public-private graph of the query vertex to extract the $k$-truss with the given parameter $k$. However, this method computes $k$-truss from scratch, which is particularly inefficient for large-scale networks. To tackle these challenges, we develop an index-based computational paradigm to efficiently update a truss index on a public graph using the edges in a private graph, with a minimal amount of recomputation on the public graph.

To summarize, we make the following contributions:

• $\bullet$

We formulate a new problem of finding $k$-truss over public-private graphs, that is finding $k$-truss in public-private graph owned by a given query vertex (Section 3).

• $\bullet$

We analyze the structural properties of $k$-truss on public-private networks. Based on the observations, we develop $k$-truss updating algorithm using a hybrid strategy of node/edge insertions/deletions (Section 4).

• $\bullet$

We validate the efficiency of our proposed methods through extensive experiments on real-world datasets of public-private networks (Section 5).

2 Related Work

Public-private graph processing. Several essential problems of graph analysis on public-private graphs have been studied in Chierichetti et al. (2015); Archer et al. (2017), such as the size of reachability tree Cohen and Kaplan (2007), all-pairs shortest paths Das Sarma et al. (2010), pairwise node similarities Haveliwala (2002), correlation clustering Bansal et al. (2004). Moreover, the public-private model of data summarization has been investigated and solved by a fast distributed algorithm Mirzasoleiman et al. (2016).

K-truss mining. Recently, several studies on $k$-truss mining have been investigated Cohen (2008); Zhang et al. (2018a). Equivalent concepts of $k$-truss termed as different names include triangle $k$-core Zhang and Parthasarathy (2012), $k$-dense community Saito et al. (2008); Gregori et al. (2011), and $k$-mutual-friend subgraph Zhao and Tung (2012). Truss decomposition is to find the non-empty $k$-truss for all possible $k$ values in a graph. Algorithms of truss decomposition have also been studied in different types of graphs (e.g., directed graphs Takaguchi and Yoshida (2016), uncertain graphs Zou and Zhu (2017), and dynamic graphs Zhang and Parthasarathy (2012); Huang et al. (2014)).

In contrast to the above studies, finding $k$-truss over public-private networks is studied for the first time in this paper.

3 Preliminary

We consider a simple and undirected graph $G=(V,E)$ where $V$ and $E$ are the vertex set and edge set respectively. We define $N(v)=\{u\in V:(v,u)\in E\}$ as the set of neighbors of a vertex $v$, and $d(v)=|N(v)|$ as the degree of $v$ in $G$. For a set of vertices $S\subseteq V$, the induced subgraph of $G$ by $S$ is denoted by $G[S]$, where the vertex set is $S$ and the edge set is $E(G[S])=\{(v,u)\in E:v,u\in S\}$.

3.1 Public-Private Graphs

We first introduce a model of public-private graph $\mathcal{G}$ Chierichetti et al. (2015). A public-private graph $\mathcal{G}$ consists of one public graph and multiple private graphs. Given a public graph $G=(V,E)$, the vertex set $V$ represents users, and the edge set $E$ represents connections between users. For each vertex $u$ in the public graph $G$, $u$ has an associated private graph $G_{u}=(V_{u},E_{u})$, where $V_{u}\subseteq V$ are the users from public graph and the edge set $E_{u}$ satisfies $E_{u}\cap E=\emptyset$. The public graph $G$ is visible to everyone, and the private graph $G_{u}$ is only visible to user $u$. Thus, in the view of user $u$, she/he can see and access the structure of graph that is the union of public graph $G$ and its own private graph $G_{u}$, i.e., $G\cup G_{u}=(V,E\cup E_{u})$ Huang et al. (2018). The personalized public-private graph (a.k.a. pp-graph in short) owned by a vertex $u$ is defined as follows.

Definition 1** (Personalized PP-Graph).**

Given a public-private graph $\mathcal{G}$ and a vertex $u$, the personalized pp-graph of $u$ is denoted by $g_{u}$, where $g_{u}=G\cup G_{u}=(V,E\cup E_{u})$. Here, $E_{u}$ are the private edges only visible to $u$, and $E\cap E_{u}=\emptyset$.

3.2 K-Truss

A triangle is a cycle of length 3 in graphs. Given three vertices $u,v,w\in V$, the triangle formed by $u,v,w$ is denoted by $\triangle_{uvw}$. The support of an edge is defined as follows.

Definition 2** (Support).**

Given a subgraph $H\subseteq G$, the support of an edge $e=(u,v)$, denoted by $\sup_{H}(e)$, is defined as the number of triangles containing edge $e$ in $H$, i.e., $\sup_{H}(e)=|\{\triangle_{uvw}:(u,v),(u,w),(v,w)\in E(H)\}|$.

We drop the subscript and denote the support as $\sup(e)$, when the context is obvious. Based on the support, we give a definition of $k$-truss Wang and Cheng (2012) as follows.

Definition 3** (K-Truss).**

A $k$-truss $H$ of graph $G$ is defined as the largest subgraph of $G$ such that every edge $e$ has support of at least $k-2$ in this subgraph, i.e., $\sup_{H}(e)\geq k-2$.

3.3 Problem Statement

The problem of public-private $k$-truss discovery studied in this paper is formulated as follows.

Problem formulation: Given a public-private graph $\mathcal{G}$, a vertex $u\in V$, and an integer $k\geq 2$, the problem is to find the $k$-truss in the personalized pp-graph $g_{u}$ where $g_{u}=G\cup G_{u}$.

Example 1**.**

Consider the public-private graph $\mathcal{G}$ in Figure 1, a query vertex $v_{5}$, and $k=5$. Black edges are public. Blue edges are private to $v_{5}$. The answer of $5$-truss in personalized pp-graph $g_{v_{5}}$ is the subgraph depicted in the gray region.

4 Proposed Algorithms

This section introduces our algorithms for finding $k$-truss in personalized pp-graph $g_{u}$, w.r.t. a query vertex $u$. We first give an overview of our ideas in Section 4.1, and then present a well thorough description of technical details afterward.

4.1 Overview of Algorithmic Framework

We consider two different ideas.

Solution 1: online search algorithm. One intuitive approach is to apply truss decomposition on pp-graph $g_{u}$ to iteratively remove edges with less than $k-2$ triangles and output the remaining graph as answers. However, such computing $k$-truss from scratch on $g_{u}$ for each query vertex $u$ is obviously inefficient for big graphs with a large number of vertices.

Solution 2: index-based search algorithm. Recall that personalized pp-graph $g_{u}=G\cup G_{u}$ has a public graph $G$ and a private graph $G_{u}$ only available to $u$. The public graph $G$ is available to everyone, and the structure of $G$ is identical to each query vertex $u$. The idea of index-based search algorithms is to construct a structural index of public graph $G$ offline, and then online find $k$-truss based on the precomputed index of $G$ and additional graph $G_{u}$. In the following, we introduce a concept of trussness, which is useful for constructing the truss-index for $k$-truss discovery.

Definition 4** (Trussness).**

Given a subgraph $H\subseteq G$, the trussness of $H$ denoted by $\tau(H)$ is defined as the minimum support of edges in $H$ plus 2, i.e., $\tau(H)=\min_{e\in E(H)}$ $\{\sup_{H}(e)+2\}$. The trussness of an edge $e\in H$ denoted by $\tau_{H}(e)$ is defined as the largest number $k$ such that there exists a connected $k$-truss $H^{\prime}$ containing $e$, i.e.,

[TABLE]

We drop the subscript and denote $\tau_{G}(e)$ as $\tau(e)$ when the context is obvious. According to Def. 4, $k$-truss of $G$ is the union of all edges $e$ with $\tau(e)=k$. The truss-index of public graph $G$ keeps the trussness of all edges in $G$. Given a truss-index of $G$, the remaining issue is how to update the truss-index for pp-graph $G\cup G_{u}$, w.r.t. the additional $G_{u}$.

Updating truss-index using edge insertions. A simple approach is to add edges of $G_{u}$ one-by-one into $G$ and update the truss-index accordingly, by using an existing edge-insertion algorithm Huang et al. (2014). However, when the number of private edges $E_{u}$ is large, the adaptation of edge-insertion may be inefficient. For example, consider the example graph $\mathcal{G}$ in Figure 1 and query vertex $v_{5}$ with 4 private edges. It invokes the edge-insertion algorithm for 4 times.

Our approach. To address the above issue, we propose a batch-update algorithm using node-insertion. The idea is to simultaneously insert a new node $u$ with all its incident edges into graph $G$ at the same time, and call node-insertion algorithm only once. In the above example, it needs only one node-insertion of the isolated node $v_{5}$ and all of its private edges. To handle the truss-index update with node insertions efficiently, the key is to identify the affected region in the graph precisely. We provide a theoretical analysis to define the affected scope in Section 4.2, and the detailed algorithm of node-insertion in Section 4.3. However, when $u$ has both public and private edges, we can first remove $u$ with its public edges, and re-insert it with both public and private edges incident to $u$ using node-insertion. This method has significant advantages outperforming edge-insertion when private edges of $u$ are much larger than public edges of $u$. On other cases, edge-insertion method may perform better. Therefore, we construct a classifier to determine which algorithms of node-insertion and edge-insertion should be applied. This classification-based hybrid approach is developed to fast find $k$-truss in pp-graph $g_{u}$, which is presented in Section 4.4.

4.2 Theoretical Analysis

In this section, we present useful rules for truss-index updating with node insertion/deletion. Consider a vertex $v$ and the set of edges incident to $v$ as $E(v)$. In the case of node insertion, we insert a new vertex $v$ and its incident edges $E(v)$ into $G$, where $E(v)\cap E(G)=\emptyset$; in the case of node deletion, we delete vertex $v$ and all its incident edges $E(v)$ from $G$, where $E(v)\subseteq E(G)$. We use $\operatorname{\tau}(e)$ and $\operatorname{\hat{\tau}}(e)$ to denote trussness of edge $e$ before and after updating operation. Motivated by Huang et al. (2014), the following three updating rules hold.

Rule 1: If new node $v$ is inserted into graph $G$ with $\operatorname{\hat{\tau}}(v)=\max_{e\in E(v)}\operatorname{\hat{\tau}}(e)=l$, then $\forall e\in E(G)$ with $\operatorname{\tau}(e)\geq l$, $\operatorname{\hat{\tau}}(e)=\operatorname{\tau}(e)$ holds.

Rule 2: If node $v$ is deleted from graph $G$ with $\operatorname{\tau}(v)=\max_{e\in E(v)}\operatorname{\tau}(e)=l$, then $\forall e\in E(G)\setminus E(v)$ with $\operatorname{\tau}(e)>l$, $\operatorname{\hat{\tau}}(e)=\operatorname{\tau}(e)$ holds.

Rule 3: $\forall e\in E(G)\setminus E(v)$, $|\operatorname{\hat{\tau}}(e)-\operatorname{\tau}(e)|\leq 1$ holds.

Rules 1 and 2 hold because node $v$ is not present at any $(l+1)$-truss subgraph. Rule 3 holds because for each edge, at most one triangle will be formed/deformed after one node insertion/deletion, hence $\sup(e)$ will change at most by one.

In the following, we focus on node insertions. In order to apply Rule 1 for pruning, the value of $\operatorname{\hat{\tau}}(v)$ is required. However, an exact computation of $\operatorname{\hat{\tau}}(v)$ is costly expensive. Instead, we develop another rule based on an upper bound of $\operatorname{\hat{\tau}}(v)$ below.

Rule 1’: If node $v$ is inserted into graph $G$ and $\overline{\operatorname{\hat{\tau}}(v)}\geq\operatorname{\hat{\tau}}(v)$, then $\forall e\in E(G)$ with $\operatorname{\tau}(e)\geq\overline{\operatorname{\hat{\tau}}(v)}$, $\operatorname{\hat{\tau}}(e)=\operatorname{\tau}(e)$ holds.

To desire an upper bound of $\operatorname{\hat{\tau}}(e)$, we need a new definition of $(k,d)$-neighborhood as follows.

Definition 5** ($(k,d)$-neighborhood).**

Given a graph $G$, $(k,d)$-neighborhood of vertex $v$, denoted by $G^{k,d}_{v}$, is the maximal subgraph $H\subseteq G[N(v)]$ holding

$\operatorname{\tau}_{G}(e)\geq k,\forall e\in E(H)$* and* 2. 2.

$d_{H}(u)\geq d,\forall u\in V(H)$.

Lemma 1**.**

Consider a new node $v$ and its incident edges $E(v)=\{(v,w):w\in N(v)\}$ are inserted into graph $G$. For each new edge $e=(v,w)$ in the new graph $G_{new}$, the trussness of $e$, $\operatorname{\hat{\tau}}(e)$, satisfies $\operatorname{k_{low}}(e)\leq\operatorname{\hat{\tau}}(e)\leq\operatorname{k_{up}}(e)$ where

[TABLE]

and

[TABLE]

Moreover, $|\operatorname{k_{up}}(e)-\operatorname{k_{low}}(e)|\leq 1$ holds.

Proof.

We consider an edge $e^{*}=(v,w^{*})$ in $G_{new}$. For simplification, we denote by $\operatorname{k_{low}}(e^{*})=k_{l}$ and $\operatorname{k_{up}}(e^{*})=k_{u}$.

First, we prove $\operatorname{\hat{\tau}}(e^{*})\geq\operatorname{k_{low}}(e^{*})=k_{l}$. To prove it, we show that there exists a $k_{l}$-truss $H^{*}$ of $G_{new}$ containing $e^{*}$. By the definition of $\operatorname{k_{low}}(e)$, there exists a $k_{l}$-truss $H$ of $G$, i.e., $\forall e\in E(H)$, $\sup_{H}(e)\geq k_{l}-2$. Let $H^{*}=(V(H)\cup\{v\},E(H)\cup\{(w,v)\mid w\in G^{k_{l},k_{l}-2}_{v}\})$, which adds vertex $v$ and $v$’s incident edges $(w,v)$ with $\operatorname{k_{low}}((w,v))\geq k_{l}$ into $H$. For each edge $(w,v)\in E(H^{*})\setminus E(H)$, $w$ and $v$ have at least $k_{l}-2$ common neighbors in $H^{*}$ by the second condition of Def. 5, indicating $\sup_{H^{*}}((w,v))\geq k_{l}-2$; moreover, for each edge {\color[rgb]{0,0,0}\definecolor[named]{pgfstrokecolor}{rgb}{0,0,0}\pgfsys@color@gray@stroke{0}\pgfsys@color@gray@fill{0}{e}}\in E(H^{*})\cap E(H) , $\sup_{H^{*}}(e)\geq\sup_{H}(e)\geq k_{l}-2$. As a result, $H^{*}$ is a $k_{l}$-truss, and $\operatorname{\hat{\tau}}(e^{*})\geq\tau_{H^{*}}(e^{*})\geq k_{l}$.

Second, we prove $\operatorname{\hat{\tau}}(e^{*})\leq\operatorname{k_{up}}(e^{*})=k_{u}$ by contradiction. Assume that $\operatorname{\hat{\tau}}(e^{*})\geq k_{u}+1$, there exists a $(k_{u}+1)$-truss $H$ containing $e^{*}$ in $G_{new}$. We delete the node $v$ and all its incident edges $(v,w)$ from $H$, which leads to a new graph $H^{*}$. By Rule 3, the trussness of each edge $e$ in $H^{*}$ decreases by at most 1 after the node deletion of $v$, i.e., $\tau_{H^{*}}(e)\geq k_{u}$. Let the vertex set $S=V(H)\cap N(v)$. Obviously, $H^{*}[S]$ = $H[S]$. For each edge $e$ in $H^{*}[S]$, $\tau_{G}(e)\geq\tau_{H^{*}}(e)\geq k_{u}$; for each vertex $w$ in $H[S]$, the edge $(v,w)$ belongs to $(k_{u}+1)$-truss $H$, indicating $w$ has at least $k_{u}-1$ neighbors in $H$ and also in $H[S]$, i.e., $d_{H^{*}[S]}(w)=d_{H[S]}(w)$ $\geq k_{u}-1$. By Def. 5, $H^{*}[S]$ is a $(k_{u},k_{u}-1)$-neighborhood as $G_{v}^{k_{u},k_{u}-1}$ in $G$. Thus, $\max\{k:w\in G^{k-1,k-2}_{v}\}\geq k_{u}+1$. However, by the definition of $\operatorname{k_{up}}(e)$, $k_{u}=\max\{k:w\in G^{k-1,k-2}_{v}\}$ and $k_{u}\geq k_{u}+1$, which is a contradiction.

Third, we prove $|k_{u}-k_{l}|\leq 1$. Obviously, $k_{l}\leq k_{u}$ and $k_{l}\leq k_{u}+1$. We next prove $k_{u}\leq k_{l}+1$. According to the definition of $\operatorname{k_{up}}(e)$, we have $k_{u}=$ $\max\{k:w\in G^{k-1,k-2}_{v}\}$ $\leq$ $\max\{k:w\in G^{k-1,k-3}_{v}\}$. Moreover, $\max\{k:w\in G^{k-1,k-3}_{v}\}=$ $\max\{k:w\in G^{k,k-2}_{v}\}+1$ $=k_{l}+1$ by the definition of $\operatorname{k_{low}}(e)$, and we derive $k_{u}\leq k_{l}+1$. As a result, $|k_{u}-k_{l}|\leq 1$. ∎

Scope of Affected Edges. Let $\overline{\operatorname{\hat{\tau}}(v)}=\max\{\operatorname{k_{up}}(e):e\in E(v)\}$ be an upper bound of $\operatorname{\hat{\tau}}(v)$, and the weight of a triangle be the minimum trussness of edges within this triangle.

Node Insertion. Edge $e=(x,y)\in E(G)\cup E(v)$ with $\tau(e)<\overline{\operatorname{\hat{\tau}}(v)}$, may have trussness increment if $(v,x,y)$ form a triangle of weight $\tau(e)$, or $e$ is connected to $v$ through a series number of adjacent triangles each with weight of $\tau(e)$. 2. 2.

Node Deletion. Edge $e=(x,y)\in E(G)-E(v)$ with $\tau(e)\leq\max\{\tau(e):e\in E(v)\}$ may have trussness decrement if $(v,x,y)$ form a triangle of weight $\tau(e)$ or $e$ is connected to $v$ through a series number of adjacent triangles each with weight of $\tau(e)$.

4.3 Node-Insertion Updating Algorithm

In this section, we propose a algorithm to update the truss-index with node insertions.

Node-insertion Algorithm. Algorithm 1 updates the truss-index with inserting node $v$ and its incident edges $E(v)$ to $G$. Lower and upper bounds of each edge can be computed by calling Algorithm 2 (line 2). According to the scope of affected edges, first, trussness of newly added edges is set to $\operatorname{k_{low}}(e)$, and then candidate edges for updating are found through lines 3-10. Newly added edges with $\operatorname{k_{low}}(e)+1=\operatorname{k_{up}}(e)$ might have trussness increase which are found in lines 3-6. Furthermore, any edge in $G[N(v)]$ that might get affected is found through lines 7-9. According to Rule 1’, $k_{max}$ is set to maximum of the upper bounds which results in pruning all unaffected edges which have trussness of at least $k_{max}$. The procedure of level-by-level updating truss-index (line 12) follows the edge-insertion algorithm Huang et al. (2014).

Computing $\operatorname{k_{up}}(e)$ and $\operatorname{k_{low}}(e)$. Algorithm 2 computes the upper bound $\operatorname{k_{up}}(e)$ and lower bound $\operatorname{k_{low}}(e)$ in Lemma 1. Computing lower bounds and upper bounds are almost the same, and the same code can be used with passing a parameter $type\in\{\text{low},\text{up}\}$ to indicate which bound to compute. Consider the case where $type$ is low and lower bound is required. Algorithm starts with an induced subgraph $G[N(v)]$ as $H$, which is $G^{2,0}_{v}$. In each iteration refines $H$ to reach $G^{k,k-2}_{v}$ from $G^{k-1,k-3}_{v}$. Assume the $(k-1)$-th step has correctly stored $G^{k-1,k-3}_{v}$ in $H$. Algorithm first removes edges with trussness less than $k$ (lines 3-4), and then removes vertices with degree less than $k-2$ (lines 5-7). All removals have been necessary and obtained $H$ is $G^{k,k-2}_{v}$. Each node removed in this iteration is member of $G^{k-1,k-3}_{v}$ but not $G^{k,k-2}_{v}$; therefore the bound $k-1$ finally found by the algorithm is the maximum possible value.

4.4 A Classification-based Hybrid Algorithm for Finding K-Truss in Public-Private Graphs

This section introduces a classification-based algorithm of updating truss-index from public graph $G$ to personalized pp-graph $G\cup G_{u}$. The algorithm is outlined in Algorithm 3, which uses a hybrid strategy of updating with node/edge insertions/deletions. Specifically, we have two following strategies to update truss-index.

• $\bullet$

Edge-PP. Add private edges of $E(G_{u})$ one by one into $G$ using edge-insertion algorithm Huang et al. (2014).

• $\bullet$

Vertex-PP. Remove vertex $u$ with its public edges by node-deletion algorithm, then add back $u$ with all incident edges to obtain $G\cup G_{u}$ using node-insertion algorithm in Algorithm 1.

Note that $\mathsf{Vertex}$-$\mathsf{PP}$ can not directly add $u$’s private edges into $G$, as Lemma 1 holds only for the insertion of a completely new vertex. Both algorithms update the truss-index correctly; however, the optimal choice between $\mathsf{Edge}$-$\mathsf{PP}$ and $\mathsf{Vertex}$-$\mathsf{PP}$ is not straightforwardly clear, because multiple aspects affect efficiency. Determining efficiency performance requires a global knowledge of the whole graph structure. Local topological properties is not sufficient to decide which algorithm works faster. For example, Figure 2 shows the distribution of cases in which $\mathsf{Vertex}$-$\mathsf{PP}$ or $\mathsf{Edge}$-$\mathsf{PP}$ perform at least two times faster than the other algorithm; it consists of 1367 randomly selected nodes w.r.t their public and private degrees sampled from PP-DBLP-2013 dataset Huang et al. (2018). It is clear by Figure 2 that the simple distinction of degree is not sufficient to make good decision upon which algorithm to use. Thus, we formulate and tackle the problem of using $\mathsf{Edge}$-$\mathsf{PP}$ and $\mathsf{Vertex}$-$\mathsf{PP}$ as a classification task.

Algorithm 3 predicts which updating method between $\mathsf{Vertex}$-$\mathsf{PP}$ and $\mathsf{Edge}$-$\mathsf{PP}$ works faster in terms of the given query, and runs that algorithm to answer the query. There are two classes $C_{V}$ and $C_{E}$ that each node $u\in V$ is in class $C_{V}$ if $\mathsf{Vertex}$-$\mathsf{PP}$ works faster than $\mathsf{Edge}$-$\mathsf{PP}$ to update index from public graph $G$ to $G\cup G_{u}$ and the similar for $C_{E}$. We present each node $u$ using the following features: 1) public degree of $u$; 2) private degree of $u$; 3) the number of triangles containing $u$ respectively in public graph $G$, private graph $G_{u}$, and pp-graph $g_{u}$; 4) the trussness sum of public edges; 5) the maximum trussness of public edges; and 6) the summation and maximum over lower and upper bounds calculated by Algorithm 2. Let $D$ denote the vector space consisted of features described above, and $feature:V\rightarrow D$ the mapping function from vertices to feature space $D$.

5 Experiments

Datasets: We used four public-private graphs from real-world DBLP records called PP-DBLP Huang et al. (2018).111https://github.com/samjjx/pp-data Published articles make the public network, and ongoing collaborations form the private networks which are only known by partial authors. Network statistics of PP-DBLP are given in Table 1. We also used 10 real-world graphs available from SNAP Leskovec and Krevl (2014) shown in Table 2.

Compared Methods and Evaluated Metrics: To evaluate the efficiency of improved strategies proposed in this paper, we tested and compared four algorithms as follows.

• $\bullet$

$\mathsf{Truss}$-$\mathsf{Decompostion}$: an online search approach using truss decomposition for computing $k$-truss index from scratch Wang and Cheng (2012).

• $\bullet$

$\mathsf{Edge}$-$\mathsf{PP}$: an approach using the edge-insertion algorithm for updating truss index Huang et al. (2014).

• $\bullet$

$\mathsf{Vertex}$-$\mathsf{PP}$: our approach using the node-deletion and node-insertion for updating truss-index in Algorithm 1.

• $\bullet$

$\mathsf{Hybrid}$-$\mathsf{PP}$: our hybrid approach using both $\mathsf{Edge}$-$\mathsf{PP}$ and $\mathsf{Vertex}$-$\mathsf{PP}$ for updating truss-index in Algorithm 3.

After updating the index, all of the four methods mentioned above use the same query method. We compare them by reporting the running time in seconds. The less the running time is, the better the efficiency performance is. We set the parameter $k=7$ by default. We also evaluate the methods by varying parameters $k$ in $\{5,7,9,11,13,15\}$.

5.1 Efficiency Evaluation on SNAP Networks

To evaluate the efficiency of the Node-insertion algorithm, we conducted experiments on 10 SNAP graph datasets in Table 2. Due to no available private information in these networks, we randomly generated private edges as follows. We divided nodes into 40 bins by their degree and took 50 randomly selected nodes from each bin. Bin set was defined as $\{B_{1},B_{2},\ldots B_{40}\}$ where $B_{i}=\{v:{i-1\over 40}<{d(v)\over\Delta}\leq{i\over 40}\}$ with $\Delta=\max_{v\in V}\{d(v)\}$. Some bins had less than 50 nodes, and in this case, all nodes of that bin were selected. Let $G=(V,E)$ denote the initial graph, and $V_{t}$ the set of sampled vertices. All edges with at least one end in $V_{t}$ was considered to be private. We ran $\mathsf{Truss}$-$\mathsf{Decompostion}$ on the induced subgraph of vertex set $V^{\prime}=V\setminus V_{t}$, then added each node $v\in V_{t}$ using Algorithm 1, and compared the running time with adding edges one by one using edge-insertion algorithm. Experiment results and running time of both algorithms are available in Table 2. Obviously, our node-insertion algorithm significantly outperformed the edge-insertion method which achieved 38.67 times speedup on LiveJournal.

5.2 Classification Evaluation

In order to choose the proper classification method to incorporate into $\mathsf{Hybrid}$-$\mathsf{PP}$, we tested and compared five classifiers in terms of classification accuracy and training time, as shown in Table 3. Due to the low training time, high classification accuracy, and fast query time, Random Forest was finally used as the classifier of $\mathsf{Hybrid}$-$\mathsf{PP}$.

5.3 Efficiency Evaluation on PP-DBLP Networks

In this section, we conducted experiments on real-world public-private datasets of PP-DBLP. We compare the efficiency of four different methods $\mathsf{Truss}$-$\mathsf{Decompostion}$, $\mathsf{Edge}$-$\mathsf{PP}$, $\mathsf{Vertex}$-$\mathsf{PP}$, and $\mathsf{Hybrid}$-$\mathsf{PP}$. $\mathsf{Hybrid}$-$\mathsf{PP}$ adopted a Random Forest with 51 estimators and a maximum depth of 11 to construct a classifier. The $\mathsf{Hybrid}$-$\mathsf{PP}$ used to answer queries on each PP-DBLP dataset was trained based on runtimes of $\mathsf{Vertex}$-$\mathsf{PP}$ and $\mathsf{Edge}$-$\mathsf{PP}$ on sampled nodes from the other three datasets. We first divided all nodes into $100\times 100$ bins by their public and private degrees, and then randomly took four nodes from each bin. Bin set was $\{B_{i,j}:1\leq i,j\leq 100\}$ each bin defined as $B_{i,j}=\{v:{i-1\over 100}<{d(v)\over\Delta}\leq{i\over 100},{j-1\over 100}<{d_{p}(v)\over\Delta_{p}}\leq{j\over 100}\}$ where $\Delta$ is the maximum public degree, $\Delta_{p}$ is the maximum private degree, and $d_{p}(v)$ is the private degree of node $v$. In total $1836\pm 58$ nodes were selected on each PP-DBLP datasets.

Vary Node Degree. We fixed the parameter $k=7$ and ran the four proposed algorithms on sampled nodes. For better visualization and comparison, sampled nodes were divided into five equally sized groups by node degrees in their pp-graphs, each group taking $20\%$ of sampled nodes, and the average query time of algorithms on each group is reported in Figure 3. As we can see, the performance of $\mathsf{Edge}$-$\mathsf{PP}$ is better than $\mathsf{Vertex}$-$\mathsf{PP}$ in lower degree nodes, and the $\mathsf{Hybrid}$-$\mathsf{PP}$ is the fastest as it takes the quicker algorithm between $\mathsf{Edge}$-$\mathsf{PP}$ and $\mathsf{Vertex}$-$\mathsf{PP}$ in most cases. On higher degree nodes, $\mathsf{Edge}$-$\mathsf{PP}$ takes much longer than $\mathsf{Vertex}$-$\mathsf{PP}$, becomes less useful for $\mathsf{Hybrid}$-$\mathsf{PP}$; hence the gap between $\mathsf{Hybrid}$-$\mathsf{PP}$ and $\mathsf{Vertex}$-$\mathsf{PP}$ decreases as $\mathsf{Vertex}$-$\mathsf{PP}$ becomes the optimal choice for the classifier on higher degree nodes.

Vary Parameter $k$. The average query time varied by $k$ is reported in Figure 4. $\mathsf{Hybrid}$-$\mathsf{PP}$ and $\mathsf{Vertex}$-$\mathsf{PP}$ perform much better than $\mathsf{Edge}$-$\mathsf{PP}$ and $\mathsf{Truss}$-$\mathsf{Decompostion}$ for all $k$ values and datasets. $\mathsf{Hybrid}$-$\mathsf{PP}$ is the fastest due to using $\mathsf{Edge}$-$\mathsf{PP}$ in cases where $\mathsf{Vertex}$-$\mathsf{PP}$ works worse than $\mathsf{Edge}$-$\mathsf{PP}$.

6 Conclusions

This paper studies the problem of finding k-truss on public-private graphs. We develop a novel hybrid algorithm of k-truss updating with node/edge insertions/deletions, which can incrementally compute k-truss on public-private networks. This work opens up several interesting problems. First, developing further efficient and clever algorithms for finding $k$-truss in pp-graphs is important, instead of deleting and re-inserting nodes as $\mathsf{Vertex}$-$\mathsf{PP}$. Second, finding other kinds of dense subgraphs on public-private graph is also wide open.