README.rst: don't mention my custom Octonions

mjo/hurwitz.py: delete custom Octonions implementation

Everything has been updated to use the Sage OctonionAlgebra.

mjo/hurwitz.py: update tests to use Sage's octonions

mjo/matrix_algebra.py: use Sage's octonions in all tests

mjo/misc.py: special case for Sage's octonions in _all2list()

These have vector(), not to_vector().

mjo/eja: update to use Sage's octonions

mjo/matrix_algebra.py: support Vector "rows" in from_list()

Something in Sage changed and now we're getting Vector "rows" in what
used to be a list-of-lists resulting from a block matrix. Tweak the
test to support anything with a __len__ method inside, rather than
just list or tuple.

mjo/hurwitz.py: update examples to use Sage's octonions

Use OctonionAlgebra rather than my custom Octonions. Tests pass
within huritz.py and matrix_algebra.py, but the EJA modules are
certainly broken.

mjo/hurwitz.py: fix entry_algebra_gens() in HurwitzMatrixAlgebra

Just like we did for MatrixAlgebra, add a special case for the
octonions in entry_algebra_gens(). The OctonionAlgebra uses gens()
for the multiplicative generators, so we only get five of them.

mjo/matrix_algebra.py: support OctonionAlgebra in entry_algebra_gens()

We need a special case for algebras that have a basis(), since that's
really what we want, and "generators" is technically incorrect when
multiplication is involved.

mjo/matrix_algebra.py: special case for OctonionAlgebra

Eventually I will switch mjo.hurwitz to use Sage's (new)
OctonionAlgebra class. In preparation, add a special case to deal with
the fact that they have a vector() method but no to_vector().

mjo/clan/normal_decomposition.py: another principal decomp test

There was a bug in the previous test, since we are using the Ishi
convention that gives us a lower-triangular normal decomposition: a
subclan is obtained by "deleting" the first idempotent rather than the
last. After fixing that, we add another test to show that this does
actually produce a subalgebra (the new test finds the bug).

mjo/clan/normal_decomposition.py: add test for principal decomp

We get a principal decomposition of a non-unital clan if we "delete"
the r'th idempotent from the normal decomposition of a unital clan,
but this isn't obvious. Let's test it.

mjo/clan/clan_element.py: add norm methods

For convenience, define norm() and norm_vinberg() in terms of the
corresponding inner product methods. This will usually involve a
sqrt(), and I have not thought very hard about how to handle that
intelligently.

mjo/clan/vinberg_clan.py: cite references

mjo/clan/t_algebra_clan.py: speed up ComplexHermitianClan

To speed up ComplexHermitianClan, we use a quadratic field extension
for the entries of the ambient matrix space rather than (basically)
assuming QQ and QQbar. But before we can do that, we need to adjust
from_matrix() to reject mismatched entry algebras. We also need to
special case several real/complex field pairs, because the quadratic
extension procedure does not always give us something usable -- our
Hurwitz matrix algebras are finicky.

mjo/clan: add tests for zero-dimensional clans

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.