mjo/clan/jordan_spin_clan.py: fix n=0 case

mjo/clan: fix propagation of scalar fields

Non-default fields were getting lost in __init__. Now there are tests.

mjo/clan/trivial_clan.py: new TrivialClan class

Does exactly what you would expect: nothing.

mjo/clan/normal_decomposition.py: special case for rank zero

mjo/clan/all.py: put JordanSpinClan in the public namespace

mjo/clan/jordan_spin_clan.py: support n=1 (the real numbers)

mjo/clan/jordan_spin_clan.py: add a comment about the inner product

mjo/clan/jordan_spin_clan.py: fix the clan product

I forgot a "2", and now that it's there we can verify the homogeneous
polynomials D(0) and D(1).

mjo/clan/jordan_spin_clan.py: first steps towards an implementation

mjo/clan/vinberg_clan.py: eliminate top-level QQ import

mjo/cone/decomposition.py: use check=False at end of nonlineal_part()

I've sketched an argument that the generating sets must be minimal.

mjo/cone/decomposition.py: remove a junk example

Passing a non-minimal set of generators with check=False and
normalize=False invalidates anything else that might happen.

mjo/cone/decomposition.py: update a comment / open question

mjo/cone/decomposition.py: finish nonlineal_part() updates

This was remarkably close to working for something untested; only a
few minor tweaks and typos remained.

mjo/cone/decomposition.py: allow nonorthogonal nonlinea parts (WIP)

This is a work-in-progress that probably doesn't function and
definitely won't pass tests. I'm pushing the changes only because I
broke Sage on the machine I'm working on and need to sync.

README.rst: don't all-caps BASH

README.rst: add "export" to PYTHONPATH example

README: convert to reStructuredText, and rewrite

This will look nice on Codeberg, and in any case it's nice to have
some meaningful information in here.

makefile: remove PYTHONPATH hack from check target

Having eliminated the sitedir trickery from init.sage, one must now
have PYTHONPATH properly configured before anything will work.

init.sage: remove hard-coded repository paths

You'll just have to specify where the repository lives, as with all
other rogue python libraries.

mjo/clan: eliminate UnitalClan

We can add Unital() in NormalDecomposition anyway, because following
Vinberg we assume that they have one. But even if they didn't, the
unit element would be a property of each individual clan.

mjo/clan: more class hierarchy refactoring

Renamed MatrixAlgebra to TAlgebraClan, since in theory the up-hat and
down-hat work for any T-algebra. Separated that out along with the
NormalDecomposition class.

mjo/clan: factor out mjo.clan.normal_decomposition_element

mjo/clan/clan.py: fix the scalar field for NormalDecomposition

mjo/clan: factor out mjo.clan.vinberg_clan

mjo/clan: rename SnClan and HnClan for consistency with EJA names

mjo/clan/clan_operator.py: undo _is_clan() hack

And just like that, it starts working for no reason.

mjo/clan/clan_operator.py: de-alias FreeModules -> ModulesWithBasis

mjo/clan/clan.py: add SETUP:: blocks

These are now(?) necessary with the new all.py exports.

mjo/all.py,mjo/clan/all.py: export user-facing clan bits

mjo/clan/clan_operator.py: god-awful hack for category check

mjo/clan/clan.py: whitespace

mjo/clan/clan_operator.py: swap isinstance() for category check

Amazingly, this also fails, still ONLY while doctesting.

mjo/clan/clan.py: add a category for Clans

mjo/clan/clan.py: Vinberg cone automorphisms (WIP)

This proof-of-concept is mostly working, but the tests are crashing
for some reason.

mjo/clan/clan_operator.py: fix copy/pasted docstring

mjo/clan/clan_operator.py: prefer "C" for clan variables

mjo/clan/clan_operator.py: implement composition and related methods

mjo/clan: refactor the type hierarchy

Put the clan stuff in a top-level Clan class, and make UnitalClan a
wrapper around that. This complicates everything a bit, but makes me
feel better.

mjo/clan/clan_element.py: add the Vinberg inner product

mjo/clan/clan_operator.py: public matrix() method

This will be useful for the Vinberg inner product.

mjo/clan/unital_clan.py: add hand computations for the Vinberg clan

mjo/clan: start implementing clan operators

This is a moral prerequisite for the Vinberg inner product.

mjo/clan/clan_element.py: composite det example for the Vinberg clan

mjo/clan/unital_clan.py: fix VinbergClan element classes

When building elements from lists/matrices, be sure to construct
them in the clan and not just in the underlying vector space.

mjo/clan/unital_clan.py: add convenience constructors for Vinberg clans

Add the following methods to build an element of the Vinberg clan:

  * from_matrices
  * from_list
  * from_lists

mjo/clan/unital_clan.py: factor out (un)lift for the Vinberg clan

mjo/clan/unital_clan.py: VinbergClan inits and passes tests

mjo/clan/unital_clan.py: begin sorting out the Vinberg clan init

mjo/cone/decomposition.py: delete reducibility stuff

This will go upstream soon, and is only slowing the tests down.

mjo/clan/unital_clan.py: start working on the Vinberg clan

Just sketch the constructor. Nothing works, but I don't want to forget
about it.

mjo/cone/decomposition.py: add more nonlineal_part() tests

mjo/cone/decomposition.py: pointed/linspace -> nonlineal_part

Rework the pointed_linspace_decomposition() as nonlineal_part(),
returning only the pointed component. The lineality space is easy to
obtain, even as a cone, though generally that will be overkill.

We drop _orthogonalize() for now, since it appears that Sage/PPL
will implicitly orthogonalize the cone's lines().

mjo/cone/decomposition.py: add orthogonalization example over ZZ

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