Nemo.jl

Nemo is a high-performance Julia library designed for fast basic arithmetic in various commonly used rings. It is primarily used for tasks in:

• Commutative Algebra
• Number Theory
• Group Theory

Nemo achieves its performance by providing wrappers for the specialized C library FLINT and leverages AbstractAlgebra.jl to provide generic mathematical constructions over the basic rings provided by the underlying packages.

Nemo is a computer algebra package for the Julia programming language. It is designed to provide computational tools for commutative algebra, number theory, and group theory.

Nemo achieves this by providing:

1. Re-exports of AbstractAlgebra.jl: It provides generic implementations for polynomial rings, matrix spaces, fraction fields, residue rings, power series, finite fields, p-adics, integers, rationals, permutations and characters, and number fields.
2. FLINT Wrappers: It includes wrappers for the FLINT library, which incorporates functionality from the Arb, Antic, and Calcium projects.

The default QQBarFieldElem uses minimal polynomials for canonical representation. While good for individual numbers, it is not optimized for fast field arithmetic.

For high-performance calculations in $\overline{\mathbb{Q}}$, use CalciumField. Alternatively, if you are working within a specific subfield $\mathbb{Q}(a)$, construct a dedicated number field instead.

Nemo uses a parent/element model to manage mathematical objects. In this model, mathematical structures (like sets, groups, rings, fields, or modules) are represented by parent objects rather than just types. The objects belonging to these structures are called elements.

For example, a polynomial is an element, and the polynomial ring it belongs to is its parent.

To interact with this model:

• Use parent(a) to retrieve the parent object of an element a.
• Use base_ring(S) to obtain the base ring of a ring S.

This model allows for parameterised structures, such as a quotient ring being parameterised by a specific ideal object.

parent(a) # Returns the parent of element a
base_ring(S) # Returns the base ring of ring S

The default integer type in Nemo is provided by FLINT. The integer ring is represented by the constant parent object ZZ.

Elements of this ring are of type ZZRingElem. For compatibility with standard Julia code, Nemo defines IntegerUnion = Union{Integer, ZZRingElem}, allowing functions to accept both standard Julia integers and Nemo's specialized integer elements.

Key types:

• Parent: ZZRing (represented by ZZ)
• Elements: ZZRingElem

using Nemo
a = ZZ(12)
# a is a ZZRingElem

Because some Nemo objects are immutable, unsafe operators must be used with a specific assignment pattern to ensure correctness.

When an unsafe operator is called on an immutable object, it cannot mutate the original; instead, it returns a new object representing the result. To ensure the variable holds the updated value, you must always assign the return value back to the original variable.

Correct Pattern:

a = add!(a, b)

If a is mutable, the function modifies a in place and the assignment a = ... is effectively a no-op. If a is immutable, the assignment is required to update the variable a with the new object returned by the operator.

Gaussian integers are provided by a pair of FLINT integers. You can access the ring and its fraction field using:

• Nemo.GaussianIntegers(): The ring of Gaussian integers.
• Nemo.GaussianRationals(): The field of Gaussian rationals.

Elements can be constructed using ZZ(a, b) for $a + bi$ or by multiplying a ZZ element by im.

ZZi = Nemo.GaussianIntegers()
a = ZZi(3, 4) # 3 + 4*im
b = ZZ(5)*im

factor(a) # Returns prime factorization

Nemo represents a finite field $K$ as a simple extension $K = k(\alpha) = k[x]/(f)$, where $k$ is the base field, $\alpha$ is the generator, and $f$ is the defining polynomial.

There are two types of finite fields in Nemo:

1. Absolute finite fields: The base field $k$ is a prime field $\mathbf{F}_p$.
2. Relative finite fields: The base field $k$ is an arbitrary finite field.

Note that field-theoretic properties such as basis, degree, or trace are defined relative to the base field. Methods prefixed with absolute_ return properties relative to the prime field $\mathbf{F}_p$.