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.

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.