R: Find a Matrix of Distances Between Positions Based on Regular...

redist {sna} | R Documentation

## 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 buttsc@uci.edu

### 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!

[Package sna version 2.6 Index]