AbstractAlgebra.jl is a pure Julia library providing generic abstract algebra structures and algorithms. It serves as the foundational computational algebra layer for the Oscar/Nemocas ecosystem, used by downstream packages Nemo.jl, Hecke.jl, and Singular.jl. The library implements a comprehensive type hierarchy for rings, fields, modules, matrices, polynomials (univariate, multivariate, Laurent, Puiseux, power series), and groups, along with generic algorithms for arithmetic, GCD, factorization, linear algebra (LU, HNF, SNF, Popov forms), Gröbner bases, and more. It is designed for extensibility: any ring implementing the fundamental interface (parent, elem_type, zero, one, +, *, etc.) can use the generic implementations. The codebase is well-tested with conformance tests that verify algebraic axioms for each type, and includes sophisticated infrastructure for attribute caching, map caching, pretty printing, and random element generation. While primarily a library for symbolic computation and research mathematics, it is not a data science or ETL tool.
Hecke.jl is a Julia package for computational algebraic number theory, forming a core component of the OSCAR computer algebra system. It provides a comprehensive suite of algorithms for number fields (absolute, relative, simple, non-simple), orders and ideals, class groups, unit groups, elliptic curves (including isogenies, heights, pairings), quadratic and Hermitian forms, local fields, function fields, associative algebras, and Riemann surfaces. The architecture is modular, with separate source files for each algebraic structure, extensive use of caching via attributes, and integration with GAP and Polymake for group-theoretic and polyhedral computations. The library is designed for research mathematicians and relies on the Nemo/AbstractAlgebra ecosystem for base ring infrastructure. The codebase is large (875 files) and well-tested, with a dedicated test suite covering most modules. It includes reusable components such as sparse matrix types, AVL trees, generic map infrastructure, and factored element representations. The package is actively maintained, with recent commits, CI pipelines, and a changelog documenting ongoing development. While some parts are experimental or contain commented-out code, the core algorithms are production-grade and used in research publications. Hecke.jl is primarily a library (application) rather than a data pipeline, though it includes example scripts and benchmarks that demonstrate research workflows. Its primary purpose is to provide efficient, rigorous implementations of number-theoretic algorithms for use by mathematicians and computer algebra systems.
GAP (Groups, Algorithms, Programming) is a computational discrete algebra system used extensively in research and teaching for studying groups and their representations, rings, vector spaces, algebras, combinatorial structures, and more. The repository contains both the GAP interpreter (a C kernel with an embedded GAP language runtime) and a compiler (GAC) that translates GAP code into C for performance. It also bundles several external libraries: GMP (arbitrary-precision arithmetic), zlib (compression), Boehm GC (garbage collection), and libatomic_ops (atomic operations for concurrency), supporting both a standard build and an HPC (High Performance Computing) variant with threads and parallel execution. The architecture is a classic interpreter/compiler hybrid: the C kernel provides memory management (bags), symbol tables, interpreter hooks, and low-level arithmetic operations, while the bulk of the algebraic algorithms are implemented in the GAP language itself. Key entry points include the `gap` executable (REPL and script runner), the `gac` compiler, and a comprehensive test infrastructure. Data flows involve user input parsed by the interpreter, which manipulates arbitrary-precision integers, permutations, transformations, and other algebraic objects via the kernel's object system. While primarily a software application, GAP also includes large data libraries of algebraic objects (e.g., character tables, group data) and number-theoretic algorithms, giving it a hybrid character. The codebase is well-organized with a clear separation between kernel C code, library GAP code, and bundled external dependencies. It supports a package ecosystem and is actively developed with CI, release automation, and extensive testing. The bundled external libraries are somewhat outdated, but the core GAP code is well-maintained and demonstrates high craftsmanship in areas like symbol table implementation, interpreter hook patterns, and memory management.
SymEngine.jl is a Julia wrapper for the SymEngine C++ symbolic mathematics library. It provides symbolic types (`Basic`), algebraic operations, calculus (differentiation, series expansion), substitution, numeric evaluation, and matrix operations (LU decomposition, determinants). The package uses C library calls via Julia's `ccall` and `SymEngine_jll` binaries, managing memory with finalizers. It extends Julia's generic interfaces (`+`, `*`, `diff`, etc.) for symbolic expressions and offers macros (`@vars`, `@funs`) for convenient variable and function declarations. The extension module for `TermInterface` allows integration with generic symbolic manipulation frameworks. The codebase is well-structured, with separate files for types, math operations, simplification, display, and dense matrix handling. It is production-ready, with CI testing across Julia versions and platforms, and is actively maintained with regular dependency updates via Dependabot. The primary use case is as a library for symbolic mathematics in Julia, suitable for research, education, and applications requiring algebraic manipulation.
Algebrite is a symbolic mathematics library (Computer Algebra System) written in TypeScript. It provides a comprehensive set of operations including symbolic differentiation, integration, polynomial factorization, root finding, matrix/tensor algebra, arbitrary-precision arithmetic, and expression simplification. Internally, it uses an S-expression representation (Cons cells) and a recursive-descent parser to convert string expressions into algebraic trees. The library exposes both a string-based `run()` API for evaluating expressions and direct method calls (e.g., `Algebrite.factor`). It was originally forked from EigenMath and retains some CoffeeScript legacy in test files and debug logging. The codebase is large and monolithic, with many modules tightly coupled through shared global state (the `defs` object). Despite this, the implementation is functional and covers a wide range of mathematical operations, making it suitable for embedding in interactive notebooks or computational tools.