This vignette introduces *threshold graphs*, a class of graphs with a unique centrality ranking and relevant functions from the `netrankr`

package to work with this class of graphs.

A threshold graph is a graph, where all nodes are pairwise comparable by neighborhood inclusion. Formally, \[ \forall u,v \in V: N(u) \subseteq N[v] \; \lor \; N(v) \subseteq N[u]. \]

According to this vignette, it is thus clear that all centrality indices induce the same ranking on a threshold graph. More technical details on threshold graphs and results related to centrality can be found in

Schoch, David & Valente, Thomas W., & Brandes, Ulrik. (2017). Correlations among centrality indices and a class of uniquely ranked graphs.

Social Networks,50, 46-54.(link)

`netrankr`

Package```
library(netrankr)
library(igraph)
set.seed(1886) #for reproducibility
```

Threshold graphs on \(n\) vertices can be constructed iteratively with a sequence of \(0\)’s and \(1\)’s. For each \(0\), an isolated vertex is inserted and for each \(1\) a vertex that connects to all previously inserted one’s. This iterative process is implemented in the `threshold_graph`

function. The parameter `n`

is used to set the desired number of vertices. The parameter `p`

is the probability that a dominated vertex is inserted in each step. This parameter roughly equates to the density of the network.

```
<- threshold_graph(500,0.4)
g1 <- threshold_graph(500,0.05)
g2
c(round(graph.density(g1),2), round(graph.density(g2),2))
```

`## [1] 0.41 0.03`

The class of threshold graphs includes various well-known graphs, for instance star shaped and complete networks. This graphs can be constructed with `p=0`

and `p=1`

respectively.

```
<- threshold_graph(6,0)
star <- threshold_graph(6,1)
complete plot(star,vertex.label=NA,vertex.color="black")
plot(complete,vertex.label=NA,vertex.color="black")
```

To check that all pairs are comparable by neighborhood inclusion, we can use the function `comparable_pairs`

. The function computes the density of the underlying undirected graph induced by the neighborhood-inclusion relation.

```
<- threshold_graph(10,0.4)
g <- neighborhood_inclusion(g)
P comparable_pairs(P)
```

`## [1] 1`

We construct a random threshold graph and calculate some standard measures of centrality that are included in the `igraph`

package.

```
<- threshold_graph(100,0.1)
g
<- data.frame(
cent.df degree=degree(g),
betweenness=betweenness(g),
closeness=closeness(g),
eigenvector=round(eigen_centrality(g)$vector,8),
subgraph=subgraph_centrality(g)
)
```

We expect, that all indices are perfectly rank correlated since all pairs of nodes are comparable by neighborhood-inclusion.

```
<- cor(round(cent.df,8),method="kendall")
cor.mat <- round(cor.mat,2)
cor.mat cor.mat
```

```
## degree betweenness closeness eigenvector subgraph
## degree 1.00 0.52 1.00 1.00 0.96
## betweenness 0.52 1.00 0.52 0.52 0.50
## closeness 1.00 0.52 1.00 1.00 0.96
## eigenvector 1.00 0.52 1.00 1.00 0.96
## subgraph 0.96 0.50 0.96 0.96 1.00
```

We, however, obtain correlations that are not equal to one. This is due to the definition of Kendall’s (tie corrected) \(\tau\). Before going into detail, consider the following cases which can arise when comparing two scores of indices `x`

and `y`

.

- concordant:
`x[i]>x[j] & y[i]>y[j]`

or`x[i]<x[j] & y[i]<y[j]`

- discordant:
`x[i]>x[j] & y[i]<y[j]`

or`x[i]>x[j] & y[i]<y[j]`

- tied:
`x[i]=x[j] & y[i]=y[j]`

- left/right ties:
`x[i]=x[j] & y[i]!=y[j]`

or`x[i]!=x[j] & y[i]=y[j]`

Kendall’s \(\tau\) considers left and right ties as correlation reducing. That is if two vertices are tied in one ranking, but not the other, the correlations is weakened. Left and right ties are, however, not forbidden according to the neighborhood inclusion property. The only forbidden case are discordant pairs. That is, \(N(u)\subseteq N[v]\) can not result in \(c(u)>c(v)\) but it may result in \(c(u)=c(v)\). Also, one can argue that left and right ties distinguish between fine/coarse grained indices.

`netrankr`

comes with a function called `compare_ranks`

which calculates all occurrences of the above cases. Simply counting the cases instead of aggregating them will help circumvent the problem of possibly misinterpreting correlation measures.

```
<- compare_ranks(cent.df$degree,cent.df$betweenness)
comp unlist(comp)
```

```
## concordant discordant ties left right
## 1209 0 464 0 3277
```

Notice that there is a high number of right ties which influences the correlation if measured with Kendall’s \(\tau\). However, there do not exist any discordant pairs for any pair of indices.

```
<- matrix(0,5,5)
dis.pairs 1,] <- apply(cent.df,2,
dis.pairs[function(x)compare_ranks(cent.df$degree,x)$discordant)
2,] <- apply(cent.df,2,
dis.pairs[function(x)compare_ranks(cent.df$betweenness,x)$discordant)
3,] <- apply(cent.df,2,
dis.pairs[function(x)compare_ranks(cent.df$closeness,x)$discordant)
4,] <- apply(cent.df,2,
dis.pairs[function(x)compare_ranks(cent.df$eigenvector,x)$discordant)
5,] <- apply(cent.df,2,
dis.pairs[function(x)compare_ranks(cent.df$subgraph,x)$discordant)
dis.pairs
```

```
## [,1] [,2] [,3] [,4] [,5]
## [1,] 0 0 0 0 0
## [2,] 0 0 0 0 0
## [3,] 0 0 0 0 0
## [4,] 0 0 0 0 0
## [5,] 0 0 0 0 0
```

Although Kendall’s \(\tau\) suggests that the correlations among indices can be low, we see that there do not exist any discordant pairs on threshold graphs.

As it is always the case with artificial graph structures, it is rather unlikely to encounter threshold graphs in the wild. The best we can hope for is to be *close* to a threshold graph. This is based on the intuition that the closer a graph is to be a threshold graph, the more of its properties resemble one. The closer we are, the more correlated we assume centrality indices to be. The further away we are, the more disagreement we will find among indices. The problematic point is: how do we define *being close to a threshold graph*. An in depth discussion of possible measures can be found in the paper mentioned at the beginning of this vignette.

`netrankr`

implements one function that can be used to assess the distance of arbitrary graphs to threshold graphs. The so called *majorization gap* operates solely on the degree sequence and determines the number of entries that have to be changed in order to obtain the degree sequence of a threshold graph. Changing can, however, not be done arbitrarily. The only allowed operation is to lower the degree of one vertex and simultaneously increase the degree of another. For threshold graphs, this measure is obviously zero.

```
<- threshold_graph(200,0.2)
tg majorization_gap(g)
```

`## [1] 0`

By default, `majorization_gap`

is normalized by the number of edges.

```
data("dbces11")
<- dbces11
g
majorization_gap(g)
```

`## [1] 0.3529412`

In this example, around 35% of all entries have to be changed in order to obtain a threshold graph. The normalization is done to compare the majorization gap across networks with different sizes. To obtain the raw number of changes, set `norm=FALSE`

.

`majorization_gap(g,norm = FALSE)`

`## [1] 6`

The majorization gap serves as an indicator for how much variance we can expect in the rankings of different centrality indices. The lower it is, the closer we are to a threshold graph where only one ranking is possible. The further away we are, the more degrees of freedom exist to rank nodes differently and we will generally observe lower correlations. For more details, again, refer to the mentioned paper at the beginning.