redist {sna}

Find a Matrix of Distances Between Positions Based on Regular Equivalence

Description

redist uses the graphs indicated by g in dat to assess the extent to which each vertex is regularly equivalent; method determines the measure of approximate equivalence which is used (currently, only CATREGE).

Usage

redist(dat, g = NULL, method = c("catrege"), mode = "digraph", 
    diag = FALSE, seed.partition = NULL, code.diss = TRUE, ...)

Arguments

dat

a graph or set thereof.

g

a vector indicating which elements of dat should be examined (by default, all are used).

method

method to use when assessing regular equivalence (currently, only "catrege").

mode

"digraph" for directed data, otherwise "graph".

diag

logical; should diagonal entries (loops) should be treated as meaningful data?

seed.partition

optionally, an initial equivalence partition to “seed” the CATREGE algorithm.

code.diss

logical; return as dissimilarities (rather than similarities)?

...

additional parameters (currently ignored).

Details

redist provides a basic tool for assessing the (approximate) regular equivalence of actors. Two vertices i and j are said to be regularly equivalent with respect to role assignment r if \{r(u): u\in N^+(i)\}=\{r(u): u\in N^+(j)\} and \{r(u): u\in N^-(i)\}=\{r(u): u\in N^-(j)\}, where N^+ and N^- denote out- and in-neighborhoods (respectively). RE similarity/difference scores are computed by method, currently Borgatti and Everett's CATREGE algorithm (which is based on the multiplex maximal regular equivalence on G and its transpose). The “distance” between positions in this case is the inverse of the number of iterative refinements of the initial equivalence (i.e., role) structure required to allocate the positions to regularly equivalent roles (with 0 indicating positions which ultimately belong in the same role). By default, the initial equivalence structure is one in which all vertices are treated as occupying the same role; the seed.partition option can be used to impose alternative constraints. From this initial structure, vertices within the same role having non-identical mixes of neighbor types are re-allocated to different roles (where “neighbor type” is initially due to the pattern of (possibly valued) in- and out-ties, cross-classified by current alter type). This procedure is then iterated until no further division of roles is necessary to satisfy the regularity condition.

Once the similarities/differences are calculated, the results can be used with a clustering routine (such as equiv.clust) or an MDS (such as cmdscale) to identify the underlying role structure.

Value

A matrix of similarity/difference scores.

Note

The maximal regular equivalence is often very uninteresting (i.e., degenerate) for unvalued, undirected graphs. An exogenous constraint (e.g., via the seed.partition) may be required to uncover a more useful refinement of the unconstrained maximal equivalence.

Author(s)

Carter T. Butts [e-mail]

References

Borgatti, S.P. and Everett, M.G. (1993). “Two Algorithms for Computing Regular Equivalence.” Social Networks, 15, 361-376.

See Also

sedist, equiv.clust

Examples

#Create a random graph with _some_ edge structure
g.p<-sapply(runif(20,0,1),rep,20)  #Create a matrix of edge 
                                   #probabilities
g<-rgraph(20,tprob=g.p)            #Draw from a Bernoulli graph 
                                   #distribution

#Get RE distances
g.re<-redist(g)

#Plot a metric MDS of vertex positions in two dimensions
plot(cmdscale(as.dist(g.re)))

#What if there were already something known to be different about
#the first five vertices?
sp<-rep(1:2,times=c(5,15))            #Create "seed" partition
g.spre<-redist(g,seed.partition=sp)   #Get new RE distances
g.spre
plot.sociomatrix(g.spre)              #Note the blocking!