Is there prior work on "swiveling" convolution tensors I could study? I am new to the field of neural networks.  I started reading up on the field after AlphaGo's victories over Lee Sedol 9p in March 2016 inspired me to take another crack at programming a Go AI.  I have read through http://neuralnetworksanddeeplearning.com/ and some other sources, so I get the basic concepts while not being familiar with the all the field's jargon or literature.  This is making it hard to research what are probably basic questions since I do not know how to "put" them for a search engine to help me.
In https://storage.googleapis.com/deepmind-media/alphago/AlphaGoNaturePaper.pdf , Silver et al wrote that they handled assymetries by rotating/reflecting (I call it "swiveling" for lack of a better word) the board into its eight positions and averaging the DCNN's results on all its variants.  This seems strange to me, since I expect that the features learned by assymetrical convolution tensors would still be stuck on the board's orientation.  If we have two assymetrical features A and B that can activate a third assymetrical feature C if they are next to each other, but the orientation of these features on the board is such that A is found in one orientation and B is found in another, then the DCNN may not discover C even if a human might.  Does it not make more sense to borrow the idea of max pooling by swiveling the convolution tensors - not the input - into eight orientations, then returning the max result of those eight?  It seems that all that would be needed to support backpropagation is saving which orientation was used in addition to the activation and output values so that one can associate the errors to the appropriate weights.
I doubt that I am the first person to think of this, so I expect that there is prior work on the subject.  What are "swiveling" convolution tensors called in the literature?  What findings are there on its performance (accuracy and speed)?  Is there a reason that such an idea was not used in AlphaGo?
Also, as a bonus question, is there a free, open-source API I could use to try to program these myself without having to teach myself GPU programming?
 A: Naturally, I find an answer after posting the question.  Wu et al published a paper in 2015 titled "Flip-Rotate-Pooling Convolution and Split Dropout on Convolution Neural Networks for Image Classification" (https://arxiv.org/abs/1507.08754 has the PDF) that uses an approach very similar to what I described.  They use the term "Rotate-Pooling Convolution" (RPC) to describe rotating the weights of a convolution tensor (which gives 4 variants when using 90-degree rotation increments as opposed to their 45-degree rotation increments) and the term "Flip-Rotate-Pooling Convolution" (FRPC) to describe flipping the weights.  They use a stochastic approach in which they randomly select some weights to rotate and others to flip.  I have not read the paper thoroughly yet, so I do not know whether they allow flipped filters to also be rotated.
It is worth noting that their approach to handling flipping will try at most one flip (left-right or up-down) randomly for some features and then pool its results from the original orientation.  What I proposed above simultaneously combines four 90-degree rotations with the four states of reflection (none, left-right, up-down, left-right-and-up-down) to create eight rotationally and reflexively invariant filters.  Plus, they found that randomly selecting 25% of the final convolution layer's filters for rotating or flipping provided the best results (when combined with their sDropout training policy) as opposed to using this behavior in "lower" filters.  This seems to make some sense for image detection where eliminating data from a large input space is vital, but may not be as important for the much smaller 19x19xCHANNELS domain of Go.
They also note that they were able to use Theano to code their RPC and FRPC modifications.
