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.

eja: add a SETUP block to fix an existing doctest.

eja: add multiplication_table() for EJAs.

eja: move away from using matrices as our "multiplication table."

Instead of passing around a bunch of matrices that can be applied to
vectors to figure out how multiplication works, it's simpler (and
probably faster) to use a two-dimensional array whose (i,j)th entry
contains the answer to "how do we multiply basis elements i and j?"

When we feed these arrays into the EJA constructor, they must contain
vectors: there's no algebra yet, so it's not like we have any algebra
elements to pass in. However, in the long run, it's much more
convenient to have the multiplication table *stored* in terms of
algebra elements; that way we don't have to convert back and forth
every time we want to multiply two algebra elements. The algebra
constructor now performs this conversion and stores a table containing
algebra elements. This makes product_on_basis() a simple table lookup.

eja: remove an unused import.

eja: fix the multiplication table in subalgebras.

eja: fix some more super/subalgebra back and forth.

This fixes all of the outright crashes in the test suite, but the
multiplication table in the subalgebra is still broken (it isn't
associative).

eja: move the element constructor into the parent algebra class.

Instead of using the element's __init__(), we're now using the
algebra's _element_constructor_() method that only gets called
after the parent tries to coerce the argument and fails. This
is somewhat cleaner because we don't have to handle the "usual"
case.

eja: update some more test output for the new basis orderings.

eja: use from_vector() instead of call magic in two more places.

eja: use from_vector() instead of relying on call magic in one spot.

eja: fix degree() -> dimension() in a few tests.

eja: fix construction of subalgebra elements from superalgebra ones.

eja: adjust some test output for the new basis ordering.

Now that we're using span_of_basis() everywhere instead of accepting
whatever reordering span() gives us, this output has changed (harmlessly).

WIP: switch away from the algebra base class and use CombinatorialFreeModule.

eja: compute the unit element of the algebra ourselves.

This brings us one step closer to eliminating the dependency
on the FiniteDimensionalAlgebra class.

eja: compute a natural basis for subalgebras.

eja: use non-clashing generator names in subalgebras.

eja: implement subalgebra_generated_by() in terms of the new class.

eja: begin moving the associative subalgebra stuff into its own class.

eja: fix the test for regularity of the zero element.

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.