Begin work on the rearrangement cone.

Replace _rho with _restrict_to_space in cone/tests.py.

Update discrete_complementarity_set() docs.

Rename _rho to _restrict_to_space and make it work on subspaces instead.

Slightly simplify LL() code.

Update some comments for lyapunov_rank().

Move some excessive tests into a new module, cone.tests.

Update max_ambient_dim parameter name for random_cone().

Update docs for cone.discrete_complementarity_set().

mjo/interpolation.py: fix typo.

Make basically_the_same() and rho() functions private.
Add examples/tests for basically_the_same().
Add linear isomorphism test for lyapunov_rank().

Add a new test for a theorem in the improper paper.

Remove the lineality() and codim() functions (now depends on branch u/mjo/ticket/18701).

Finish test cleanup, notation updates, and dead code removal.

Revert "Remove unused codim() function."

This reverts commit 4418c497a443fb1f5cb068ced5a2ddd5a9a0ad05.

In the middle of mangling things.

Aaaand the test that was using that "unused" function.

Remove unused unrestrict_span() function.

Remove unused codim() function.

Add back the drop_dependent() function.

It turns out that it doesn't matter if our basis is orthogonal, so we
don't need to do Gram-Schmidt. Since this will be relied upon in the
paper, we go back to using (a subset of) the rays of the cone as our
basis.

Begin to clear up the mysteries of why the restriction doesn't work.

Everything's still a mess, but at least the tests are passing. No more
do we check for exact equality between K_W and K_star_W_star; instead
we just check that many properties agree. In the paper we have an
isomorphism, and equality holds. However, my isomorphism isn't an
isomorphism when using a coordinate system -- and we have to use a
non-normal one in Sage because we can't normalize vectors over
QQ. Huh.

Use built-in Gram-Schmidt to make things a little better.

Commit a big fucking mess while I refactor the span restriction.

Update existing tests to use the codim() function.

Add the cone codim() function.

Switch existing tests to use the lineality() method.

Add a cone lineality function.

Remove unused code and implement the improved Lyapunov rank algorithm.

Add the project_span() function.

Add some more reduction theorem test cases.

Remove the broken isomorphism tests leaving the reduction test working.

Try the span_iso approach to fix my isomorphism tests.

Commit the good (?) version of cone.py.

Commit the busted version of cone.py.

Add a few tests for LL(K).

Fix the LL(K) code.
Implement lyapunov_rank(K) in terms of LL(K).

First attempt at implementing LL(K); it doesn't work.

Add citations for Lyapunov rank examples/tests.
Stub out LL(K).

Remove is_full_space() and random_cone(); see Sage trac #18454.

Factor out the is_full_space() function.

Don't count on 2*dim(V) rays generating V.

Ensure that we generate min_rays generators; add more cone tests.

Simplify the random_cone() code by defaulting to lower bounds of zero.

Factor out the discrete_complementarity_set() function.

Add a random_cone() function and use it in two tests.

Add basic Lyapunov rank implementation for polyhedral cones.

Add the matrix_of_transformation function to matrix_vector.py.

Import mjo.cone.* by default.

Add random_doubly_nonnegative() and random_extreme_doubly_nonnegative() functions.

Add is_admissible_extreme_rank() and use it to implement has_admissible_extreme_rank().

Add the random_psd() function.

Implement the is(_extreme)_completely_positive functions.

Implement the is_extreme_doubly_nonnegative() function, first shot.

Add the E() basis matrix function.

Convert "n" to an integer explicitly in has_admissible_extreme_rank().

Add the matrix_vector module with only the isomorphism() function for now.

Comment/whitespace cleanup.

doubly_nonnegative.py: Begin implementing the extreme vector algorithms.

Whitespace fix.

Whitespace fix.

Refactor symmetric_pds/doubly_nonnegative.
Ensure that we're working over an amenable base ring in factor_psd.
New module: completely_positive (cone).

Add __init__.py for mjo.cone.

New module: cone.doubly_nonnegative.

New module: cone.symmetric_psd.

Disable terminal colors in init.sage.

Add the matrix_simplify_full() function to symbolic.py.

Update SymbolSequence to use underscores.

Fix a comment.

Add a note to the README about `sage -t` not loading init.sage.

Fix a (harmless) doctest failure in mjo.interpolation.

Use ~/src/sage.d as library path.

Add the matrix_subs_expr function.

Override list_plot (in addition to the already-overriden plot()).

Don't override matplotlib's LaTeX installation.

Remove medium_simplify() now that simplify_radical() was removed from full_simplify().

Add doctests for set_simplification_domain().

Define product = prod, which is provided by Sage.

Add a test for the empty product.
Add some backticks.

Use SR.var() instead of var() everywhere.

Add the lagrange_interpolate() function, which lets you avoid evaluating your function (if you have one) before calling lagrange_polynomial().

Add an example of a least squares problem.

Fix legendre_p for finite field elements.

Add more tests and examples.
Fix the orthogonality test.

Add a few tests for the shifted Legendre polynomials.

Combine the standard/general Legendre polynomial functions.

Add the orthogonal_polynomials module with the Legendre functions.

Remove the __call__() code and refactor everything into subcalls of __getitem__().

Update all doctests to use index[] notation instead of __call__.

Allow tuples to be passed in square brackets.

Clean up a little bit of the interpolation code.

Add the SymbolSequence class; eventually headed upstream.

Add the lagrange_psi function.

Add the Hermite functions to interpolation.py.

Make the divided_difference() function rely on divided_difference_coefficients().
Make divided_difference() and newton_polynomial() take a list of function values instead of the function itself.

Add the divided_difference_coefficients() function.

Update the lagrange_polynomial() function to take a list of y-values instead of a function.

Add a makefile with a 'clean' target.

Replace the load() call in interpolation.py with an import, which works in the daytime.

Add the divided_difference() and newton_polynomial() functions to interpolation.py.

Add the 'product' function to misc.py.
Add interpolation.py with two Lagrange polynomial functions.