This library is cool and I may end up cribbing some of its design. It's unfortunate that they did not include semirings directly, which have many interesting algebraic uses. [0]

[0] http://stedolan.net/research/semirings.pdf

> It's unfortunate that they did not include [...]

I'm so looking forward to a language type system expressive enough to do a pushout lattice of <types,operators,laws> theories. So semiring, and everything else, can simply and uniquely exist. Instead of the pervasive "It's unfortunate that they did not include"... so very much. Instantly instantiatable platonic forms, instead of years of proposals, endless discussions, and standardization committee meetings. Dancing math, instead of slathering api glue.

Within the Julia ecosystem, you might be interested in Catlab (https://github.com/epatters/Catlab.jl), as we are actively working to build something very much along these lines. We already have in place a system for describing generalized algebraic theories (GATs) in Julia and generating symbolic expressions for them. In the future, we intend to implement pushouts of GATs as an algebraic approach to theory fusion. We are currently in the planning stage of this part of the project and hope to get something working this year.

Nifty. Perhaps add a copy of the documentation link[1] to the top of the README? Friction minimization...

[1] https://epatters.github.io/Catlab.jl/latest/

Is this something dependent types could do? Genuinely curious, this sounds interesting.

They could help, but dealing with them well is still an active research area...

How to put this... The potential design space is larger than is often appreciated?

Suppose I tell you, "here's a programming thing, with api/behavior that's described by some category-theory category... a category over presets". Now preset[1] means you don't get equality testing - you can't even test "set" membership. Making it hard to prove or check much. You just have to take my word for it that I've given you a thing of that category. Which makes mathematicians sad. But as a programmer... that's a better spec than I often get! ;) So there's this design space, where what you can describe, use, check, or prove, with what costs and tradeoffs, is richly varied and intertwined. And historically, it seems we've not been exploring it with great speed or coverage.

[1] https://ncatlab.org/nlab/show/preset

Have you looked at Axiom, a computer algebra system?

If so, not in many years.

http://www.axiom-developer.org/ There's docs at the bottom of http://www.axiom-developer.org/axiom-website/documentation.h... , but http://www.axiom-developer.org/axiom-website/hyperdoc/axbook... is perhaps easier.

This sounds nice. As a quantum optics programmer, I really like the idea of a generic polynomial and matrix library that is careful not to assume products are commutative.

Also, the manual seems finished, which is unusual for a Julia package.

Also for F#: https://github.com/allisterb/Sylvester/tree/master/src/Math/...

Contains both rigorous definitions and theories for use by the Sylph prover.

Given the name, I expected more focus on stuff like lattices, instead it seems mostly numerical stuff.

Still neat, though!

This is the feature list from the link:

    - Use of Julia multiprecision integers and rationals
    - Finite fields (prime order, naive implementation only)
    - Number fields (naive implementation only)
    - Univariate polynomials
    - Multivariate polynomials
    - Relative and absolute power series
    - Laurent series
    - Fraction fields
    - Residue rings, including Z/nZ
    - Matrices and linear algebra

What exactly do you consider "numerical" here? AFAIU those are all standard constructions from abstract algebra and number theory.

You're mostly right, with one (or two) exception: > Matrices and linear algebra. This isn't abstract algebra. It's used in abstract algebra, but that's true for linear algebra in almost any branch of mathematics. Also, depending on what exactly they implemented for Univariate polynomials, this part may also be numerical.

Did you look at the documentation? The matrices implemented have their elements in arbitrary commutative rings (well, not arbitrary, somebody has to implement them in Julia, of course, but they have a bunch). I think its fair to call that abstract algebra; I wouldn't it numeric. In my university, that's how we teach linear algebra to math majors but not to engineers, for example.

I'm more interested in applications to abstract interpretation, so number theory stuff does not interest me.