eja: remove EJA tests from the operator spectral decomposition.

The operator spectral decomposition is the usual linear algebra one,
so it doesn't make sense to test EJA results there.

eja: add a test for the inverse via charpoly.

eja: declare a utf-8 encoding and use it to write Korányi.

eja: add another test for element inverses.

eja: add inverse() method for operators.

eja: add is_invertible() for operators.

eja: add more tests for the (now-working) spectral_decomposition().

eja: fix one() for subalgebras with orthonormal bases.

eja: allow random_eja() to take a "field" argument.

eja: get a rudimentary spectral decomposition for operators working.

eja: add "check" parameter to check if our field is real.

eja: ensure that we can construct quaternion matrices over AA and RR.

eja: fix ComplexHermitianEJA over AA and RR.

eja: simplify the way we do field extensions.

Add even more TODO items.

eja: ensure that we can construct RealSymmetricEJA over AA and RR.

eja: reword a comment.

eja: add some more TODO items.

Revert "eja: always use the rationals for denormalized bases."

This reverts commit 1e3bfabaac18a1118fc4afd632265d91d3d0ec6c.
It broke the tests, and next time I'll do it one step at a time
to keep them working.

eja: fix a copy/paste-o.

eja: insist that operator matrix base ring matches its domain's.

eja: fix some tests that broke with the gram-schmidt commit.

eja: ensure that we get a polynomial over the right ring in _charpoly_coeff().

eja: convert back the the starting field after quaternion embedding.

We already do this for the complex simple EJA, and this un-breaks using
other fields.

eja: always use the rationals for denormalized bases.

eja: add a WIP gram-schmidt for EJA elements.

This doesn't really work right now because we need a whole bunch of
algebraic numbers that we don't know a priori. I might need to suck
it up and just use AA instead of quadratic number fields.

eja: remove an unused is_Matrix import.

eja: fix incorrect usage of "Jordan axiom" -- I meant "associativity."

eja: introduce an intermediate class for "concrete" algebras.

There were two TODO items that are basically impossible: we can't
construct a "random" EJA from (say) an associative matrix algebra,
mainly because we don't know its rank. For that reason, it doesn't
make sense to have random_instance() defined in the parent class.
Now there's a subclass (KnownRankEJA) with those methods.

eja: refactor the matrix EJA hierarchy (mainly constructors) a bit.

eja: simplify two subclass docstrings.

eja: use izip() instead of zip() in a few places.

eja: use keywords to pass keyword args (makes constructor more robust).

eja: simplify "span of powers" computation in subalgebras.

eja: replace range() by xrange() in a few places.

eja: use precomputed operator in two tests.

eja: speed up the computation of element powers.

eja: fix a bug in the charpoly fast path for complex/quaternion matrices.

eja: refactor and fix the fast charpoly stuff that I broke recently.

eja: fix computation of the max test case sizes.

eja: make a test agree with its comment.

eja: add fast natural_inner_product() overrides for complex/quaternions.

eja: add the RealMatrixEuclideanJordanAlgebra class.

We already had analogues for complex and quaternion matrices. The real
one should have been there all along too.

eja: drop some very slow and very pointless rank() tests.

eja: replace RR with RLF in one test.

I guess we occasionally get fractions (in QQ) that aren't in RR due
to precision issues? Whatever, they're in RLF.

eja: add random_elements() method to get multiple random elements at once.

eja: remove some unused imports from eja_utils.

eja: delete redundant Jordan axiom tests.

eja: refactor the class hierarchy to separate the matrix EJAs.

eja: delete unused vec2mat() function.

eja: drop unused _matrix_ip function.

eja: add random_instance() method for algebras.

eja: move the max test case sizes into their respective classes.

eja: fix a comment to match its test case.

eja: remove pointless __class__ from static method invocations.

eja: combine several slow trace_inner_product() tests.

eja: enable normalization of the natural quaternion basis.

Add another TODO for later.

eja: don't change base rings when we don't have to.

eja: reword two existing tests.

eja: remove unused argument to _quaternion_hermitian_basis().

eja: add an ungodly hack to get fast charpolys back.

eja: refactor some of the basis and inner-product stuff.

This is movement towards eventually cheating on the charpoly
coefficients, which we should be able to compute in the "nice" basis
and then scale to the normalized one. The coefficients are polynomials
in "the coordinates of x", and those coordinates change only by a
scalar multiple when we normalize the basis.

eja: update a half-completed TODO.

eja: remove a redundant abs() on a nonnegative integer.

eja: add an optimization to the TODO.

eja: don't adjoin roots to the field if we're not normalizing the basis.

eja: add a test for basis-invariance of minimal polynomial.

eja: add "normalize" argument to matrix algebra constructors.

This is useful for two reasons:

  1. It's nice to be able to test that some things are invariant
     under changes of basis.

  2. The min/charpoly computations will be a lot faster if we
     can use the basis over QQ (i.e. if the properties that we're
     testing in the first item hold).

eja: use QuadraticField selectively to simplify tests.

eja: don't adjoin sqrt(2) to the field if it's already there.

eja: normalize the complex hermitian matrix basis, too.

eja: use NumberField instead of QuadraticField everywhere.

This will be more extensible when we need a field containing both
sqrt(2) and sqrt(-1). QuadraticField can't handle that, so we have to
use NumberField anyway at that point. Might as well get it out of the
way.

eja: normalize the real symmetric matrix basis.

This is necessary to ensure that the default basis representation is
an isometry. When it is not, the left-multiplication operator is
self-adjoint (by the Jordan axiom), but its matrix with respect to
that basis is not. The other two matrix algebras need similar fixing.

eja: fix doctests for matrix basis functions.

I broke these a bit ago when I made a parameter non-optional. Oops.

eja: add a TODO about factoring out the Jordan axiom / norm tests.

eja: use the basis space ring instead of the element's during construction.

Basically, when we're constructing an element, we're trying to fit
some given representation into a pre-existing space. Thus it makes
sense to build that space out of the pre-existing stuff, and not from
the element's base ring. This makes sense in general.

eja: add a test for the symmetry of the _real_symmetric_basis().

eja: require "field" argument for matrix basis functions.

eja: add norm() and trace_norm() methods for elements.

eja: add tests to ensure the Jordan axiom for inner products is satisfied.

eja: mention the octonions in the TODO.

eja: update the TODO list.

eja: add a new TODO list.

eja: fix the natural representation in trivial subalgebras.

The natural representation relies on knowing a matrix space, and in a
trivial subalgebra there ain't no matrices to have no spaces. To work
around that, the space is now computed/stored separately, in a new
natural_basis_space() method. This is then overridden in the subalgebra
class to do the right thing.

eja: fix the characteristic polynomial in subalgebras.

eja: add is_trivial() method and special cases for trivial algebras.

eja: override _a_regular_element() in subalgebras, since we know one.

eja: fix the subalgebra generated by zero.

eja: fix construction of subalgebra-subalgebras.

eja: choose subalgebra generator prefix smarter.

eja: pass keyword arguments through simple EJA constructors.

eja: rewrite the hacky process used for characteristic polynomials.

eja: use "dimension" instead of "degree" in EJA string representation.

eja: ensure that Sage doesn't think EJAs are associative.

It turns out that the FiniteDimensionalAlgebrasWithBasis category
somehow has both the legacy Algebras() category and the newer
MagmaticAlgebras() category as super-categories. Problem is, the
legacy one is associative! To fix that, we now use MagmaticAlgebras
directly.

Of course, we have to reimplement some of the stuff that was done for
us before... and we have to add a bunch of hacks for parts of Sage
that break when you don't have a ring.... and we can't use a matrix
for our multiplication table any more. But it was all doable.

Revert "eja: store the multiplication table as a matrix."

This reverts commit 98c3ab3a9df8c634a0fbb05ed6ad22abf41118f3. Will be
needed if we want to un-make our algebra a ring.

eja: don't waste time computing the unit element in subalgebras.

eja: use V.gen(i) instead of V.basis()[i] in a few places.

eja: store the multiplication table as a matrix.

This way, we don't need to either regenerate it when someone calls
multiplication_table(), or cache a second copy of it. Besides,
matrices are efficient and indexing one is probably faster than
indexing a list of lists.

eja: switch some index orderings to agree with row-then-column semantics.

This doesn't actually affect anything in these cases, but the row "i"
indices should be on the outside whenever we loop through a
two-dimensional array that corresponds to a matrix.