mathlib3

Sort of the official policy is that inside proofs (i.e., terms of types in Prop) constructibility doesn't matter, but inside definitions (i.e., terms of types in Type 0 and above) try to be constructive. For example, it is ok to define a function constructively but with a nonconstructive proof of termination. LEM is used everywhere because it's actually a theorem. It follows from functional extentionality and the existence of quotient types. https://github.com/leanprover/lean/blob/master/library/init/... The axiom of choice is an actual axiom, and it too ends up being used everywhere, but mostly to introduce decidable instances to permit things like double negation elimination inside proofs. An illustration: [1] introduces these instances to the file and [2] implicitly uses the instance. [1] https://github.com/leanprover-community/math

Kauffman has some papers with Buliga about graphical lambda calculus -- it seems like it's working with the string diagrams for a reflexive category, but with some extra goodies from an algebraic structure. I was about to say "oh, you found a quandle/rack in the lambda calculus," but it seems you're already aware of this, given some of the filenames in your repository :-) In the Buliga/Kauffman papers, there are sections about representations of knot crossings as lambda calculus, which presumably forms a quandle (actually, probably a rack). Could you direct me to how your @ operation works? This seems very interesting. I recently added quandles/racks to mathlib[1], the Lean standard math library. I think mathlib has some lambda calculus formalization, so it might be interesting adding a quandle instance for your operation. [1] https:/

I agree, although anecdotally, there seems to be an increasing amount of courses teaching Sage. Sometimes free books/lecture notes are published here: https://www.sagemath.org/library-publications.html#books Sage is a lot larger than Sympy (it's more than 1 million LOC AFAIK), but it still delegates to other libraries to do most types of underlying symbolic and numerical computations. I usually use sympy (or rather some wrapper of symengine these days) when I'm writing a pure python script, sage otherwise. For a lot of math and CS courses, I think having some knowledge of some sort of computer-assisted theorem proving. I think the most promising is maybe Lean these days (Coq still might take too long to learn): https://github.com/leanprover-community/mathlib