mjo: replace xrange() with range() for python-3.x compatibility.

eja: use zip() instead of izip(), which doesn't exist in python-3.x.

symbol_sequence.py: make a docstring raw.

eja: rename is_minimal_idempotent() to is_primitive_idempotent().

The term "primitive" is more common in optimization, anyway. Also the
word "minimal" is a bit overloaded. Oh, and I added two more tests to
preclude zero from being primitive.

eja: use peirce_decomposition() method to get the Peirce decomposition.

eja: add another TODO before I forget.

eja: fix the Peirce decomposition and add docs/tests for it.

eja: allow subalgebra_idempotent() to work in trivial EJAs.

Every element is nilpotent in a trivial EJA, but we also know the only
idempotent element in such an algebra: its sole occupant. So return it.

eja: add another non-element subalgebra example.

eja: make two subalgebra tests more general.

All of the subalgebra tests are element-subalgebra tests, because I
copied them from the element-subalgebra class. I'll slowly make them
more robust.

eja: remove redundant subalgebra stuff out of element subalgebras.

These were simply remnants of a copy/paste refactoring.

eja: don't wait for a non-nilpotent element in trivial algebras.

eja: remove broken one() implementation in subalgebras.

The one() implementetion for the algebra generated by an element is
not, in general, correct for a subalgebra. Subalgebras can have
different identities than superalgebras -- take the Peirce
decomposition, for example.

eja: remove a TODO that is done in theory.

eja: start experimenting with single-element Peirce decomposition.

eja: refactor the element subalgebra stuff into generic subalgebra.

A messy job, but I got the tests passing. They certainly need some
cleanup, and we should test non-element subalgebras too.

eja: move eja_subalgebra to eja_element_subalgebra.

The plan is to cut/paste out all the stuff that works for a generic subalgebra.

eja: add a priority TODO.

eja: drop custom gram_schmidt() routine that isn't noticeably faster.

Using Gram-Schmidt in SageMath is a bit of a pain, since you have to
put your vector space elements into a matrix, which means you have to
convert them to vectors first. And then you wind up transposing the
matrix twice, and then you have to convert everything back to vectors
and then back to algebra elements, dropping the zero vectors/elements
in the process. Sounds slow, right?

Well, testing shows that jumping through all those hoops and using the
default implementation isn't much slower than the custom routine I
wrote. So, for now, let's delete it.

Beware that this breaks the construction of subalgebras when the field
is not exact because SageMath won't orthonormalize over an inexact
field.

eja: add is_minimal_idempotent() for elements.

eja: update the TODO.

eja: add a new TrivialEJA class and some tests for it.

eja: define the trace of an element in a trivial algebra.

eja: simplify the algebra charpoly method a bit.

eja: fix a rank test to work on trivial algebras.

eja: make some element tests work in trivial algebras.

eja: make two operator tests work in trivial algebras.

eja: add the unique spectral_decomposition() for elements.

eja: define subalgebra_generated_by() to contain the identity.

eja: remove obsolete workaround for SageMath trac ticket #28327.

eja: add TODO for the TrivialEJA class.

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).