mjo/cone/faces.py: use simpler dual face formula

mjo/cone/permutation_invariant.py: use cones.foo() from sage

README: rewrite it, it was rather out-of-date

makefile: timeout overrides should no longer be necessary

mjo/cone/rearrangement.py: bye, use sage's cones.rearrangement() instead

mjo/cone/trivial_cone.py: bye, use sage's cones.trivial() instead

mjo/cone/nonnegative_orthant.py: bye, use cones.nonnegative_orthant() instead

mjo/cone/schur.py: bye, use sage's cones.schur() instead

COPYING,LICENSE: add (AGPL-3.0+)

eja: rename operator_inner_product -> operator_trace inner_product.

...and add an operator_trace_norm() method, for elements. It would
have been weird to have it called operator_norm(), wouldn't it?

TODO: add another one.

eja: add another test case for the Albert EJA determinant.

eja: drop "FiniteDimensional" prefix everywhere.

eja: special subalgebra handling for Cartesian product EJAs.

The matrix representation of an element in a Cartesian product EJA
will be an ordered tupe of matrices. When we move into a subalgebra,
the same element (considered as an element of the subalgebra) no
longer lives in a "Cartesian product EJA," since we give the
subalgebra its own basis. However, if we ever want to convert back,
then we need to know that the element originally came from a Cartesian
product EJA, because scalar fucking scaling doesn't fucking work on
ordered pairs!

TODO: drop "FiniteDimensional" everywhere.

eja: don't pointlessly orthonormalize in subalgebra_idempotent().

mjo/random.py: new module for random_unitary_matrix().

eja: write the ALGORITHM block for the degree of an element.

eja: add the trace (matrix) operator inner product.

eja: drop a superfluous semicolon.

eja: use QQ for another potentially slow doctest.

eja: remove an "expected algebra failure" that now somehow passes.

hurwitz.py: speed up conjugate() and conjugate_transpose().

...by staying as close to the underlying monomial dict as possible.

mjo/hurwitz.py: speed up is_hermitian() and is_skew_symmetric().

We only need to test these above and on the diagonal.

matrix_algebra.py: speed up __getitem__() and trace().

eja: use orthonormalize=False for all subalgebra_generated_by() tests.

Orthonormalizing a high-degree element over AA takes roughly forever.
Better that we test *something* than the nothing that gets tested if
I Ctrl-C the process.

eja: change a misleading comment.

eja: fix parent of empty sum in element inverse().

eja: add an "r" to a docstring.

eja: mention the new EJA in the docs.

eja: add more "# long time" markers.

eja: add "# long time" to two potentially slow tests.

eja: test the nonnegativity of trace() for squares.

eja: revert random_element() to old fast behavior.

eja: typo fix in TODO.

eja: fix a copy/paste error in the docs.

eja: cache one() for the new EJA.

eja: use the correct definition for the new algebra.

hurwitz.py: swap is_sker_hermitian() for is_skew_symmetric().

It turns out I've been working with the wrong concept for the past two
days. Welp.

eja: begin work on the ComplexSkewHermitianEJA.

hurwitz.py: add conjugate() method for matrices.

hurwitz.py: add is_skew_hermitian() method.

eja: rename MatrixEJA to HermitianMatrixEJA.

There are also algebras of skew-Hermitian matrices, so the name was
not great.

mjo/**/*.py: drop obsolete set_random_seed().

We use a random random seed by default now finally.

makefile: drop obsolete --memlimit flag to sage -t.

mjo/cone: drop is_symmetric_p{s,}d() methods.

These are now redundant since the sage is_positive_definite() and
is_positive_semidefinite() methods exist and work on inexact rings.

eja: factor out the operator polynomial-matrix construction.

mjo/cone/symmetric_pd.py: add a missing set_random_seed().

mjo/cone/symmetric_pd.py: drop inverse_symmetric_pd().

This function is now available in SageMath:

  sage: A = matrix.identity(QQ,2)
  sage: A.inverse_positive_definite()
  [1 0]
  [0 1]

eja: update the DESIGN doc.

eja: further micro-optimize gram_schmidt().

eja: try to speed up gram_schmidt(), but all my sages are broken.

eja: remove unused variable in gram_schmidt.

eja: renumber coordinate variables from zero.

eja: add more TODOs, which are thankfully getting easier.

eja: speed up det() for Cartesian product elements.

eja: add another TODO item.

eja: append to an existing TODO.

eja: fix cartesian_factors() for EJA elements.

eja: drop obsolete _vec2mat and _mat2vec helpers.

eja: remove unused import.

eja: remove redundant kwargs mangling from MatrixEJA subclasses.

eja: don't allow creation of invalid RationalBasisEJAs.

Prior to this, a Cartesian product taken in the "wrong order" could
result in a subclass of RationalBasisEJA that did not actually have
a corresponding rational algebra.

eja: remove an impossible TODO.

We can't use the _rational_algebra to get minimal polynomials like we
do with characteristic ones. The secret with the charpolys is that the
(irrational) coordinates of the element are hidden behind polynomial
variables. With the minimal polynomial, we'd need to operate on them
directly... but we can't, in a rational algebra.

eja: remove two completed TODOs.

eja: speed up _all2list().

eja: delete obsolete method override.

eja: skip FDEJA constructor in CartesianProductEJA.

eja: add a TODO for tomorrow.

eja: factor a few things out of the FDEJA constructor.

eja: add a TODO.

eja: fix trivial subalgebra element constructor.

Some recent performance improvemenets necessitate a special case
for trivial subalgebras.

eja: fix recent hasattr() commit.

eja: use hasattr() to avoid a try/except.

eja: allow subalgebra elemenents to be coerced into the superalgebra.

eja: add superalgebra_embedding() for subalgebras.

eja: add another performance TODO.

eja: cache the span of the matrix basis when written out as long vectors.

This GREATLY improves the speed of the _element_constructor_(), and
therefore of Cartesian products.

eja: fix random_eja() dimension bounds, for real.

eja: delete an unused statement.

eja: add missing transpose() to deortho matrix.

eja: fix a deorthonormalization bug.

eja: add a performance TODO for Cartesian products with trivial factors.

eja: add randomness to a test.

eja: update the TODO with a bug example.

eja: add more introductory documentation.

eja: remove more completed TODO items.

eja: fix tests for new random_eja() structure.

eja: rework the random_eja() bounds in terms of dimension.

eja: more cached charpoly coefficients.

eja: fix missing test import.

eja: more charpoly coefficient caching.

eja: cache the charpoly coefficients for the AlbertEJA.

eja: remove the cached product_on_basis() TODO.

Storing the multiplication table in a list is actually faster than the
@cached_method dict lookup. I tried it. In general, l[i][j] is about
twice as fast as d[(i,j)] for a nested list "l" and dict "d".

eja: factor out MatrixEJA initialization.

eja: remove a completed TODO.

eja: optionally pass matrix space into FDEJA instead of guessing it.

matrix_algebra: use "[]" for trivial matrices and fix a test.

eja: fix representation of "zero" in MatrixAlgebra.

eja: fix some tests, speed improvements.