anchor.diff:  b.addEdge('next',c)
   c.addEdge('next',d)
   d.addEdge('next',e)
  -g.withSack(0).V().repeat(both().simplePath()).emit().path().        <1>
  -  group().by(project("a","b").by(limit(local, 1)).                  <2>
  +g.withSack(0).V().store("x").repeat(both().simplePath()).emit().path(). <1>
  +  group().by(project("a","b").by(limit(local, 1)).                      <2>
                                 by(tail(local, 1))).
  -          by(order().by(count(local))).                             <3>
  -          select(values).as("shortestPaths").                       <4>
  -          V().as("v").map(select("shortestPaths").unfold().         <5>
  -                          filter(unfold().where(eq("v"))).count()).
  -              sack(sum).barrier(normSack).sack().as("betweeness").  <6>
  +          by(order().by(count(local))).                                 <3>
  +          select(values).as("shortestPaths").                           <4>
  +          select("x").unfold().as("v").                                 <5>
  +          select("shortestPaths").                                      <6>
  +            map(unfold().filter(unfold().where(eq("v"))).count()).      <7>
  +            sack(sum).sack().as("betweeness").        <8>
             select("v","betweeness")
   ----
   
  
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: 
  [gremlin-groovy,modern]
  ----
  g.V().repeat(groupCount('m').out()).times(30).cap('m')
  ----
  
  The traversal iterates through each vertex in the graph and for each one repeatedly group counts each vertex that
  