eja: factor out the EJA element class into its own module.

eja: add more regularity and degree tests.

eja: simplify and justify the implementation of is_nilpotent() for elements.

eja: add and update a few docstrings and tests.

eja: require the rank argument for an EJA, because we can't compute it.

eja: update some docstrings.

eja: clean up imports.

eja: update changed module name in all.py.

eja: separate out the operator class and rename both files.

Let's start organizing. It's also time to get the test suite
working. I've added stupid SETUP blocks to each docstring to load the
stuff being tested.

eja: add algebra constructors to the global namespace.

eja: whitespace fix.

eja: add minimal_polynomial() for operators.

eja: replace element operator_matrix() entirely.

eja: use FreeModules() category for operators instead of VectorSpaces().

This allows our characteristic polynomial algorithm to use real
operators and not matrices.

eja: convert another operator_matrix() test to operator().

eja: suggest operator().matrix() to replace element matrix().

eja: move a bunch of operator_matrix() tests to operator().

eja: implement element powers in terms of operator().

eja: implement operator_commutes_with() in terms of operator().

eja: rewrite the operator class again to eliminate VectorSpaceMorphisms.

Wherever possible, I'd like to eliminate row-vector APIs from sneaking
into userland. There's no reason for us to subclass VectorSpaceMorphism,
because left-multiplication by a scalar doesn't work anyway. So, just
drop it, and keep our own matrix variable around instead.

eja: replace the Hom stuff with a custom EJA operator class.

Implementing homsets as linear operators was always a hack, since
linear operators will in general not be algebra homomorphisms. We
wound up re-implementing addition, subtraction, etc. of operators
anyway, so in hindsight, there is no extra difficulty in creating our
own EJA operator class as a subclass of VectorSpaceMorphism.

This commit throws out the EJA morphism stuff, and replaces it with
an equivalent EJA operator class to remain mathematically sound.

eja: add vector_space() method for EJAs to get the ambient space.

eja: fix a busted operator inverse test.

eja: fix an erroneous test case.

eja: fix powers of zero for operators.

When you raise a morphism to the power of zero, it returns an object
(the identity morphism) in a much more general and useless space. We
need to be able to add/subtract these things. So now we have our own
one() method for the Homset, and our own __pow__ for morphisms.

eja: fix the element inverse() implementation and some failing tests.

eja: finally get scalar-morphism multiplication working with the new homsets.

eja: create our own Homset class for EJAs (ugh).

eja: use single-underscore method names for morphisms.

eja: use sexier FiniteDimensionalAlgebrasWithBasis category.

eja: rework the quadratic representation tests in terms of morphisms.

Just saving this WIP, because I'm starting to suspect that my
implementation of morphisms might be stupid.

eja: add negation/subtraction for morphisms.

eja: add composition (multiplication) for morphisms.

The whatever-superclass composition of morphisms returned a formal
composition, which can't be treated like a morphism itself. Since all
of our morphisms are represented by matrices, we can simply perform
the composition ourself via matrix multiplication to return something
useful.

eja: add __invert__ method for morphisms.

eja: improve tests for morphism addition.

eja: allow addition of EJA morphisms.

eja: add new operator() method for elements that returns a morphism.

eja: new class FiniteDimensionalEuclideanJordanAlgebraMorphism.

This is the first step towards implementing left-multiplication
operators and quadratic-representations properly.

eja: improve a comment.

eja: use an insane hack to hide the (left_)matrix methods for elements.

eja: use the quadratic representation for the element inverse.

eja: add tests for more quadratic representation properties.

eja: randomize and fix a bug in the subalgebra_idempotent() test.

eja: ensure that the element inverse() always lives back in the EJA.

eja: add back the charpoly basis trickery needed for the theory.

eja: add an implementation warning for characteristic_polynomial().

eja: finally enable tests for the trace inner product.

eja: use charpoly coefficients to implement det() for elements.

eja: implement element trace in terms of charpoly coefficients.

eja: refactor the charpoly implementation... it's magically faster?

eja: use the @cached_method decorator for characteristic_polynomial().

eja: use the standard basis in characteristic_polynomial().

I couldn't see a reason why we needed to do a change-of-basis in the
characteristic_polynomial() function (a la Faraut and Koranyi), so I
tried it with the standard basis. And, everything seems to work? Cool.

eja: switch to the "real" element characteristic_polynomial() implementation.

eja: get the characteristic_polynomial() for EJAs working.

eja: add apply_univariate_polynomial() for elements and use it in a test.

eja: use different bounds for "n" in the random_eja() function.

eja: use 't' for the minimal polynomial variable name.

eja: begin to stub out a characteristic_polynomial() for EJAs.

eja: store the EJA multiplication table as a temporary hack.

eja: do an extra ambient_vector_space() in one method in case its a module.

eja: simplify (and cite) the minimal_polynomial() implementation.

eja: simplify is_invertible() for elements.

eja: turn the eja_rn() constructor into a class too.

This fixes the inner product issue I created in the previous commit.
We can always get rid of this class when real Cartesian products are
supported.

eja: drop the inner_product argument to the EJA constructor.

Beware, this will make the test suite fail if we ever get R^n as our
EJA and try to take a (default trace) inner product involving an
irregular element.

eja: turn the other simple EJA constructors into classes.

eja: rename JordanSpinAlgebra to JordanSpinEJA.

eja: turn the spin algebra constructor into a subclass.

eja: test that complex/quaternion embeddings are homomorphisms.

eja: get the quaternions working.

eja: add two more tests to ensure the Jordan product is correct.

eja: add quaternion -> real matrix embedding.

eja: fix complex-unembedding with respect to 5537f4534.

eja: make the complex embedding agree with the docs.

eja: text the inner product axiom of an EJA.

eja: support conversion of naturally-represented elements into an EJA.

This lets us convert e.g. a symmetric 3x3 matrix to an EJA element
without having to mess with the basis/coordinates ourselves.

eja: factor out mat2vec() and vec2mat() helper functions.

eja: add matrix inner products, and factor out the two used in R^n.

eja: replace nonexistent ArgumentError class.

eja: finally give Euclidean Jordan algebras an inner product.

eja: fix alphabetical ordering of element methods.

eja: add natural_representation() for elements.

eja: maintain a "natural basis" for EJAs.

This will eventually let us see the "usual" representation of an EJA
element. In other words, we don't want to see (1,0,1) to indicate the
identity element of the 2-by-2 symmetric matrices.

eja: rename matrix() to operator_matrix().

This leaves the dangerous parent class matrix() method there, but
whatever. The tests pass.

eja: define operator_matrix() to eventually replace matrix().

eja: add operator_commutes_with() for elements.

eja: add a test for power-operator-commutativity.

eja: remove pointless abs() calls.

eja: add polarization-identity and power-associativity tests.

eja: add an inverse() example.

eja: add element inverse() and is_invertible().

eja: add more quadratic representation tests.

eja: fix the dimension of the complex Hermitian simple EJA.

eja: add a test for the degree of Sn.

eja: replace eja_ln() and eja_sn() with their new names.

eja: add ComplexHermitianSimpleEJA to random_eja().

eja: begin implementing the complex hermitian simple EJA.

eja: pass a dimension to a matrix() constructor for an extra sanity check.

eja: fix screwup introduced in 5d147bd962.

eja: add a function to embed complex matrices in (bigger) real ones.

eja: add placeholder constructors for all simple EJAs.