Code Generation

Consider the ladder class graph from the paper with Ravi and Jeff. 
Consider a strategy which selects 
a subset of all assignments. (d for diamond = wild card symbol) 

Strategy must be deterministic. See section 5 of paper.

S A1 d*( A2n d* A3 d* A4n | A2 d* A3 d* A4) T 
S A1n d* A2 d* A3n d* A4 T 

=========== Code for A3 (code internal to the class):
if came through A2, A4n is ok
if came through A2n, A4 is ok

Two options:
One method per class: check relevant parts of history in each method
or
Multiple methods per class: encode paths in generated code.

The number of methods generated in the second option is the same as the size
of the intersection.

But there is another way to generate code
that is proportional to the state complexity of the strategy:

We have code for strategy classes and noise classes.
Generate allowed successors. For each field check:
if it exists and in allowed successor, go down.

This creates fewer methods  but does a check for each field.

=========== Code for any class from outside the class: (generic)
Go to successors that RR allows.
=
Go to successors that intersection allows.
Uses reflection and automaton look-up.
Look-up ranges are smaller for intersection but
automaton has fewer states.