anchor.diff:  `PartitionStrategy` is a `SubgraphStrategy` which creates logical subgraphs through the use of designated properties.  When each element is written to the `Graph`, it is marked with a property value indicating the current write-partition.  As elements are read from the graph, they are matched against the current set of read-partitions.  The read-partitions thereby define the union of a set of vertices and edges. For example:
   
   [source,groovy]
  -----
   gremlin> g = TinkerGraph.open()
   ==>tinkergraph[vertices:0 edges:0]
  -gremlin> strategy = new PartitionStrategy("com.example.partition", "A")
  -==>PartitionStrategy
  -gremlin> sg = new StrategyGraph(g)
  -==>strategywrappedgraph[tinkergraph[vertices:0 edges:0]]
  -gremlin> sg.setStrategy(strategy)
  -==>null
  -----
  +gremlin> partitionStrategy = new PartitionStrategy("com.example.partition", "A")
  +==>partitionstrategy
  +gremlin> sg = g.strategy(partitionStrategy)
  +==>partitionstrategy[tinkergraph[vertices:0 edges:0]]
   
   Add vertices and edges first in one partition, then another:
   
   [source,groovy]
  -----
   gremlin> v1 = sg.addVertex("name", "one")
   ==>v[0]*
   gremlin> v2 = sg.addVertex("name", "two")
   ==>v[3]*
   gremlin> v1.addEdge("knows", v2)
   ==>e[6][0-knows->3]*
  -gremlin> strategy.setWritePartition("B")
  +gremlin> partitionStrategy.setWritePartition("B")
   ==>null
   gremlin> v3 = sg.addVertex("name", "three")
   ==>v[7]*
   gremlin> v1.addEdge("knows", v3)
   ==>e[10][0-knows->7]*
  -gremlin> 
  -----
   
   Define sets of partitions which provide access to different subgraphs, or slices of the data:
   
   [source,groovy]
  -----
   gremlin> "in A: " + sg.V().count().next() + ", " + sg.E().count().next()
   ==>in A: 2, 1
   gremlin> strategy.addReadPartition("B")
  
positive.code: `ReadOnlyStrategy` was demonstrated at the start of the `GraphStrategy` section.  It simply prevents write operations that would otherwise mutate the `Graph`.
  
  [source,groovy]
  ----
  gremlin> conf = new BaseConfiguration()
  ==>org.apache.commons.configuration.BaseConfiguration@5b40ceb
  gremlin> conf.setProperty("gremlin.graph","com.tinkerpop.gremlin.tinkergraph.structure.TinkerGraph")
  ==>null
  gremlin> g = GraphFactory.open(conf, new ReadOnlyStrategy())
  ==>readonlygraphstrategy[tinkergraph[vertices:0 edges:0]]
  gremlin> g.addVertex('name','stephen')
  Graph uses class com.tinkerpop.gremlin.structure.strategy.ReadOnlyStrategy and is therefore unmodifiable
  ----
  
  SequenceStrategy
  ~~~~~~~~~~~~~~~~
  
  `SequenceStrategy` provides a way to string together a set of `GraphStrategy` implementations, such that they are executed in order from first to last.  The `GraphFactory` provides a straightforward way to invisibly use `SequenceStrategy`:
  
  [source,groovy]
  gremlin> conf = new BaseConfiguration()
  ==>org.apache.commons.configuration.BaseConfiguration@6048e26a
  gremlin> conf.setProperty("gremlin.graph",TinkerGraph.class.getName())
  ==>null
  gremlin> g = GraphFactory.open(conf, new ReadOnlyStrategy(), new PartitionStrategy("partition","A"))
  ==>sequencegraphstrategy[tinkergraph[vertices:0 edges:0]]
  
  The above code demonstrates a `Graph` that uses a `SequenceStrategy` composed of `ReadOnlyStrategy` and `PartitionhStrategy`.  When the `SequenceStrategy` is invoked, it will first apply the `ReadOnlyStrategy` and then apply the `PartitionStrategy`.  It is important to consider the ordering of the `GraphStrategy` objects when choosing to use `SequenceStrategy` as it makes no attempts to determine if strategies will be in conflict with one another.  Be aware of the nature of the strategies and ensure that applying them in the order assigned will produce the desirable outcome.
  
  SubgraphStrategy
  ~~~~~~~~~~~~~~~~
  
negative.code: 
  NOTE: TinkerPop2 had the notion of "Graph Wrappers" which decorated standard `Graph` implementations with additional features.  A Graph strategy is generally analogous to that capability.
  
  To use a `GraphStrategy` instance, use the `Graph.strategy()` method to instantiate the `StrategyGraph` as follows:
  
  [source,groovy]
  ----
  gremlin> g = TinkerFactory.createModern()
  ==>tinkergraph[vertices:6 edges:6]
  gremlin> sg = g.strategy(IdentityStrategy.instance())
  ==>identitystrategy[tinkergraph[vertices:6 edges:6]]
  ----
  
  The above code specifies the creation of a `TinkerGraph` with the use of `IdentityStrategy`.  Note that the `strategy` method returns a `StrategyGraph`, which implements the `Graph` interface. It can be used in the same manner as `TinkerGraph` or any other implementation.  At any point, the `GraphStrategy` can be bypassed by getting the underlying `TinkerGraph`.
  
  [source,groovy]
  ----
  gremlin> sg.getBaseGraph()
  ==>tinkergraph[vertices:6 edges:6]
  ----
  
  IdStrategy
  ~~~~~~~~~~
  