mjo/ldlt.py: refactor the one-by-one block-LDLT pivot.

mjo/ldlt.py: start a naive Bunch-Kaufman block LDLT.

mjo/ldlt.py: various efficiency improvements to ldlt_fast().

mjo/ldlt.py: avoid some intermediate variables in ldlt_fast().

mjo/ldlt.py: add a vaguely correct non-recursive ldlt_fast().

mjo/ldlt.py: actually permute with the permutation matrix.

mjo/ldlt.py: add naive, pivoted LDLT matrix factorization.

makefile: delete mjo/__pycache__ with "make clean".

mjo: rename matrix_vector.py to basis_repr.py.

mjo/matrix_vector: rename basis_representation() to basis_repr().

mjo/matrix_vector: replace matrix_of_transformation with basis_repr_of_operator.

mjo/matrix_vector: fix phi_inv implementation in basis_representation().

mjo/matrix_vector: replace isomorphism with basis_representation().

init.sage: use readline-like tab completion.

init.sage: let the default LightBg colors apply.

I use a light terminal background now.

eja: implement JordanSpinEJA with BilinearFormEJA.

eja: make a BilinearFormEJA test do what it says.

eja: re-disable base ring to algebra coercion.

eja: new half-baked BilinearFormEJA class.

eja: fix the docs for the spin algebra multiplication.

eja: add another TODO.

mjo/cone: rawify some docstrings.

init.sage: add an alternate sitedir name.

mjo/eja/all.py: fix the name of an import.

eja: rename RealCartesianProductEJA -> HadamardEJA.

mjo/polynomial.py: add hacks for SageMath Trac #28855.

mjo/symbol_sequence.py: fix another backslash escaping issue.

eja: listify map/zip results for python-3.x compatibility.

mjo/cone/doubly_nonnegative.py: don't check rank validity of None.

mjo/interpolation.py: wrap map() calls in list() for python-3.x.

There's probably a better way to implement these functions for
python-3.x, but this fixes the tests for now.

cone/doubly_nonnegative.py: make two docstrings raw.

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.