anchor.diff:  
   [gremlin-groovy,modern]
   ----
  -g.V().bothE().group().by(otherV()).by(count())      <1>
  -g.V().inE().group().by(inV()).by(count())           <2>
  -g.V().outE().group().by(outV()).by(count())         <3>
  -g.V().group().by().by(outE().count())               <4>
  +g.V().bothE().group().by(otherV()).by(count())        <1>
  +g.V().inE().group().by(inV()).by(count())             <2>
  +g.V().outE().group().by(outV()).by(count())           <3>
  +g.V().group().by().by(outE().count())                 <4>
  +g.V().project("v","degree").by().by(bothE().count())  <5>
  +g.V().project("v","degree").by().by(bothE().count()). <6>
  +  order().by(select("degree"), decr).
  +  limit(4)
   ----
   
   <1> Calculation of degree centrality which counts all incident edges on each vertex to include those that are both
  
positive.code: 
  [gremlin-groovy,modern]
  ----
  g.V().as("a").repeat(both().simplePath()).emit().as("b").
    dedup().by(select("a","b")).
    path().
    group().by(limit(local, 1)).
            by(count(local).map {1/it.get()}.sum())
  ----
  
  The traversal starts by iterating over all vertices to find all paths that don't <<cycle-detection,cycle>>. It labels
  the start vertex as "a" and the ending vertex being emitted as "b". To perform this calculation, the measurement
  only requires the <<shortest-path,shortest path>> between each vertex pair, so the first occurrence of "a" and "b"
  as denoted in the `dedup().by(select("a","b"))` will be that shortest distance.
  
  To this point, the traversal has the unique list of shortest paths between each vertex pair and it is time to
  operate on that `path()`. To get the output displaying each start vertex with the centrality calculation, the `Path`
  objects can be grouped. In this case, `group()` takes two `by()` modulators. The first `by()` specifies the key for
  grouping and simply extracts the first vertex in the `Path` with `limit(local, 1)`. The second `by()` produces the
  value for the grouping and in this case:
  
  . `(count(local)` - counts the length of each path to produce the __distance__
  . `map {1/it.get()}` - uses a closure to divide the __distance__ by "1"
  . `sum()` - sums those values to produce the centrality score for that vertex
  
  [[eigenvector-centrality]]
  Eigenvector Centrality
  
negative.code: <2> Calculation of in-degree centrality which only counts incoming edges to a vertex.
  <3> Calculation of out-degree centrality which only counts outgoing edges from a vertex.
  <4> Same calculation as the previous traversal, but includes all vertices, even those with a zero
  <5> The previous examples all produce a single `Map` as their output. While that is a desireable output, producing a
  stream of `Map` objects can allow some greater flexibility.
  <6> For example, use of a stream enables use of an ordered limit that can be executed in a distributed fashion in
  OLAP traversals.
  
  [[betweeness-centrality]]
  Betweeness Centrality
  