mjo/cone/decomposition.py: remove that NOTE

I found an example where PPL does not remove the lineal components of
the remaining generators. It is now included as a doctest.

mjo/cone/decomposition.py: add a NOTE

I'm becoming more and more convinced that PPL will do the
lineality-space decomposition on its own.

mjo/cone/decomposition.py: new pointed-linspace decomposition

Begin a new experiment with the pointed-linspace decomposition. We
know how to do this with orthogonal projections, but in Sage we must
work over the rationals (and arithmetic is much faster there anyway).
I sketched a quick proof of concept showing that this can be done, and
it's very likely that PPL does exactly the same thing when it
minimizes the generators in Cone().

But just in case, here's an implementation that definitely does what I
think it does.

mjo/cone/decomposition.py: fix the vertices in irreducible_factors()

This bug is fixed in the upstream SageMath branch (with additional
tests), but let's fix it here too until it hits "develop".

mjo/clan: factor out up_hat, down_hat, etc. for matrix clans

mjo/clan: move matrix-clan methods to an intermediate class

mjo/matrix_algebra.py: alllow from_list() to take one long list

This makes its behavior more consistent with that of MatrixSpace.

mjo/matrix_algebra.py: whitespace

mjo/clan: move one() into the NormalDecomposition class

We know this in terms of the idempotents, whatever they are.

mjo/clan: initial implementation of the Hermitian complex matrix clan

mjo/clan: new diag() method for elements, everything now index-agnostic

With idempotent() and diag() helpers, the element code now does not
need to know what the indexing scheme is.

mjo/clan: add idempotent() method for normal decompositions

Just a helper to get the idempotent (diagonal) elements without
having to care what the basis indices are.

mjo/hurwitz.py: add matrix transpose() method

Sometimes you just need to transpose a complex matrix, you know?

mjo/matrix_algebra.py: support the original __getitem__ syntax

To support submodules, we need __getitem__() to support its original
behavior of returning coordinates when given all three indices.

mjo/clan: complete the migration to three coordinates

Three coordinates are needed to identify a basis element in general:
(i,j) to identify the component, and then "k" for the basis within
the (i,j)th component.

This should allow us to define HnClan, which has 2d off-diagonal
components.

mjo/clan: WIP conversion to three coordinates

mjo/clan/unital_clan.py: remove unused local variable

mjo/clan: add x.D(k) and x.chi(k) methods

These are the homogeneous polynomials and diagonals-squared of the
triangular factorization of x, as in the Ishi / Gindikin papers.

mjo/clan: factor out NormalDecomposition to its own class

Some methods require knowledge of the normal decomposition
coordinates.

mjo/clan: get inner products working; implement one() for SnClan

mjo/clan: begin implementing the clan on S^n

clan: eliminate the user basis stuff from the new clan module

I think we'll be able to get away with just using the "real" basis
elements as keys to the CFM. This makes it easy to reconstruct the
"user" coordinates from CFM elements.

mjo: move eja.eja_utils to mjo.misc

These functions are useful outside of Euclidean Jordan algebras.
It's looking in particular like the _all2list() gimmick may be
a useful general construct for algebras with a user basis.

mjo/clan/unital_clan.py: begin clan implementation

mjo/cone/decomposition.py: rearrangement examples for is_reducible()

mjo/cone/decomposition.py: handle trivial cones correctly

mjo/cone/decomposition.py: add new is_reducible() function

mjo/cone/decomposition.py: add missing colon

mjo/cone/decomposition.py: add tests, fix the edges of the edges

A miscellaneous selection:

  * The vertex numbering was off because pivots() renumbers them.
  * Updated the docs to fix some incorrect claims.
  * Added lots of new tests.
  * Special case for irreducible cones to return K itself.
  * Use subspace_with_basis() instead of span() to preserve
    our user basis.

Tests now pass, and the documentation is converging upon the truth.

mjo/cone/decomposition.py: support non-solid cones

mjo/cone/all.py: add mjo/cone/decomposition.py

mjo/cone/decomposition.py: rename "decomposition" to "factors"

mjo/cone: rename irreducible_decomposition.py -> decomposition.py

mjo/cone/irreducible_decomposition.py: get it working, roughly

mjo/cone: begin working on the irreducible decomposition

mjo.eja.eja_operator: fix exponentiation

Using exponentiation was allowing us to skip the domain/codomain check
for operator composition when their dimensions agreed. To fix that, we
reimplement powers directly in terms of multiplication.

This also sheds light on a buggy test that needed to be fixed:
isomorphisms can't necessarily be composed.

mjo/cone/isomorphism.py: delete

A better version of this is pending upstream at,

  https://github.com/sagemath/sage/pull/40367

mjo/eja/eja_operator.py: use upstream stuff for random unitary matrices

mjo/random.py: delete, random_unitary_matrix() is upstream

mjo/cone: more linear ismorphism tests

mjo/cone/isomorphism.py: fix RST citation format

mjo/cone/isomorphism.py: cite Gowda/Trott for the l1-cone

mjo/cone: improve isomorphism testing & docs, tests pass now

mjo/cone/isomorphism.py: update docs/names, add is-isomorphic method

Rename the isomorphism generator to linear_isomorphisms(), since
"linear isomorphism" is as good of a distinguishing name as I can
think of. Then add the is_linearly_isomorphic() function to check
that at least one isomorphism exists.

mjo/cone/isomorphism.py: new module for (rational) cone isomorphism

The is_isomorphic() method for convex cones in Sage kind of does what
I want, but the fact that it does is considered a bug by the author
since it does not capture the notion of isomorphism useful for toric
varieties. Some day that method will be fixed and it will be much less
useful for testing isomorphism in the usual linear-algebraic sense,
which is what I usually want to check.

This commit adds a new module with the beginnings of an isomorphism
test over the rationals. It should work for all convex cones (not just
pointed cones) though it isn't very smart or fast and probably has a
lot of bugs in it at the moment.

mjo/eja/eja_operator.py: randomize the permuted factors test

mjo/eja/eja_operator.py: add some "long time" labels

mjo/eja/eja_operator.py: fix test when spin algebra is trivial

mjo/eja/eja_operator.py: permutation test for is_isomorphism()

mjo/eja/eja_operator.py: improved is_isomorphism() tests

For random testing we can use rationals; but only certain small
examples complete fast enough over the algebraics.

mjo/eja/eja_operator.py: add complex hermitian EJA tests for is_isomorphism()

mjo/eja/eja_operator.py: speed up is_isometry() and is_homomorphism()

Both of these are symmetric, so we can skip about half of the checks.

mjo/eja/eja_operator.py: simplify an is_isomorphism() test

mjo/eja/eja_operator.py: is_isomorphism() tests for the two easiest EJAs

mjo/matrix_algebra.py: move a comment

mjo/eja/eja_operator.py: add is_isomorphism() for operators

mjo/eja/eja_operator.py: add is_homomorphism() for operators

mjo/eja/eja_operator.py: add a comment about something non-obvious

mjo/eja/eja_operator.py: add is_isometry() method

makefile: bypass the "sage" script when testing

mjo/hurwitz.py: quaternion gens are a tuple now

mjo/**/*.py: update table rendering

Sage's tables are rendered using unicode characters for the borders
now.

mjo/eja/eja_algebra.py: block-scoped "long time" tags

mjo/eja/eja_subalgebra.py: block-scoped "long time" tags

mjo/eja/eja_element.py: block-scoped "long time" tags

mjo/cone/symmetric_psd.py: don't import from sage.all

mjo/cone/symmetric_pd.py: don't import from sage.all

mjo/cone/cone.py: remove

I don't feel like documenting these properly, and they aren't used
anywhere else.

mjo/cone/permutation_invariant.py: don't import from sage.all

mjo/cone/doubly_nonnegative.py: don't import from sage.all

mjo/cone/cone.py: don't import from sage.all

mjo/cone/completely_positive.py: don't import from sage.all

mjo/cone/faces.py: don't import from sage.all

mjo/symbol_sequence.py: don't import from sage.all

mjo/polynomial.py: don't import from sage.all

mjo/orthogonal_polynomials.py: don't import from sage.all

mjo/basis_repr.py: don't import from sage.all

mjo/interpolation.py: don't import sage.all in global scope

mjo/misc.py: don't import sage.all

mjo/basis_repr.py: replace deprecated is_MatrixSpace()

mjo/eja/eja_utils.py: replace deprecated is_Matrix()

mjo/cone/faces.py: add another reducibility test

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.