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.

eja: factor out the ugly bits of constructing simple matrix EJAs.

eja: add a TODO with some tests that fail for now.

eja: add non-working trace_inner_product() for EJA elements.

eja: add quadratic_representation() for elements.

eja: use random_eja() where applicable in tests.

eja: don't test for element matrix() symmetry (I don't think it holds).

eja: fix the basis order for Sn.

eja: add missing set_random_seed() call.

eja: add the random_eja() function.

eja: add a comment about row/column vectors to eja_sn().

eja: add the simple algebra S^n.

eja: add det() and trace() for regular elements.

eja: de-implement characteristic_polynomial for irregular elements.

eja: put element methods in alphabetical order.

eja: add is_regular() method on elements.

eja: fix element matrices.

The superclass matrix() method of elements sometimes computes the
right-matrix acting on row vectors. Nobody wants that shit. This
commit overrides it (to simply return the transpose of the superclass
matrix), and thus fixes the subalgebra_idempotent() method. Some tests
were added for the latter method, too.

eja: fix element powers.

We were using row-vector multiplication for powers (taken from the
superclass), but our vectors are column vectors. Oops. This broke
things when we assumed column vectors were being used, like when
we constructed a multiplication table. This commit fixes the powers
and adds/updates some tests.

eja: add doctest for a bug in subalgebra_generated_by().

eja: add currently-busted subalgebra_idempotent() method.

eja: use different generator names in subalgebras.

eja: add is_nilpotent() for elements.

eja: recurse more directly in minimal_polynomial().

eja: use the associativity of one-generator subalgebras.

eja: fix the rank of the spin factor algebra.

eja: remove symmetry test that don't work.

I don't know why, but the multiplication table of a commutative
algebra doesn't have to be symmetric. I'll think about this later.
In the meantime, don't crash about it.

Postscript (a month later): left-multiplication and right-multiplication
are the same in the EJA, but not necessarily for the matrices that represent
them. It was wrong to conflate the two concepts in the first place.

eja: rewrite the classcall/init process.

I'm not sure what I just did, but by copying the __classcall_private__
method from FiniteDimensionalAlgebra, I was able to make it take an
extra (optional) "rank" parameter while creating EJAs. This lets us
hard-code the rank for known EJAs, and put off figuring how we might
compute it otherwise.

eja: implement a working minimal_polynomial().

eja: add subalgebra_generated_by() method.

eja: add another test for degree().

eja: test that left-mult matrices are symmetric.

eja: add span_of_powers() method.

eja: remove an erroneous comment.

eja: begin implementing an element class.

eja: implement my own algebra subclass.

eja: fix field arguments, add comment.

eja: add eja_minimal_polynomial() function.

eja: add eja_ln() for the rank-two algebra.

eja: add examples for eja_rn.

eja: begin draft implementation of euclidean jordan algebras.

mjo/polynomial.py: remove a redundant line from a test.

mjo/polynomial.py: add another multidiv test based on an exercise.

Revert "mjo/polynomial.py: improve multidiv performance a bit."

This reverts commit 4e4efc9eff5c77a2ca19002b1dfa45598e974c54. Example
4 in the text doesn't work with this implementation, but it does with
my original one. Let's stick with slow and correct, for now.

mjo/polynomial.py: add a (failing!) test for Example 4 in the text.

mjo/polynomial.py: add two more examples from exercises in the text.

mjo/polynomial.py: improve multidiv performance a bit.

We don't need to re-check earlier "denominators" after division has
occurred, even though we *do* need to re-check the current one. This
makes the algorithm closer in practice to the one given in the text.

mjo/polynomial.py: improve tests for new multidiv function.

mjo/orthogonal_polynomials.py: fix doctests.

Add new mjo.polynomial module with the "multidiv" function.

This new module implements the generalized polynomial division
algorithm in Section 2.3 of Cox, Little, and O'Shea.

Revert "... add completely_positive_operators_gens()."

This reverts commit 3d6ec3f4f138a6278be4f393b491aa1ac2bbffa8. The new
function was mathematically wrong, and can't be fixed. Oops.

mjo/cone/completely_positive.py: add completely_positive_operators_gens().

Add a new function to return (as matrices) the generators of the
completely-positive cone of K, where K is some other given cone.