Notes for Magma users

There is no interface between Magma and OSCAR, so this page is only about translating what you know from Magma to OSCAR. Many of the number theoretic functions in OSCAR live in the package Hecke, whose function names often are the snake_case versions of the Magma names.

Differences in syntax

• Assignment is := in Magma and = in Julia. The comparison operators eq, ne, lt, le, gt, ge are ==, !=, <, <=, >, >= in Julia, and and, or, not are &&, ||, !.

• Every Magma statement ends with ;. In an interactive Julia session, a trailing ; suppresses the output of the value, see Semicolons and output.

• Magma's if ... then ... elif ... else ... end if; is if ... elseif ... else ... end in Julia, and for x in L do ... end for; is for x in L ... end. The same holds for while loops. There are no then and do keywords.

• Functions are defined with function f(x) ... end in Julia; one-liners can be written as f(x) = .... Procedures that modify their arguments (~x in Magma) are ordinary functions in Julia, by convention their names end with !.

• The cardinality #S of a set, sequence, or group is length(S) for collections and order(G) for groups.

• Sequence and set constructors translate to comprehensions: [ f(x) : x in L | c(x) ] is [f(x) for x in L if c(x)], and { ... } is Set(...) applied to a comprehension. The reductions &+L and &*L are sum(L) and prod(L), &cat L is reduce(vcat, L). forall{ x : x in L | c(x) } and exists{ ... } are all(c, L) and any(c, L).

• Coercion K!x is K(x) in OSCAR.

• Strings are concatenated with * instead of cat.

• Comments start with # instead of //; multi-line comments are #= ... =# instead of /* ... */.

• time f(x); is @time f(x), and load "file"; is include("file.jl"). assigned x is @isdefined x.

• Magma's ? help syntax is available in Julia as ?name.

• Many Magma constructors use angle brackets: sub<G | a, b>, quo<G | N>, hom<G -> H | a, b, ... >, ideal<R | f, g>, R<x, y> := PolynomialRing(K, 2). The OSCAR counterparts are ordinary functions: sub(G, [a, b]), quo(G, N), hom(G, H, [a, b, ...]), ideal(R, [f, g]), and R, (x, y) = polynomial_ring(K, [:x, :y]).

Differences in semantics

• Integer literals are machine integers. In Magma, 2^100 is computed exactly and 3/4 is a rational number. In Julia, 2^100 evaluates to 0 and 3/4 to 0.75. Write ZZ(2)^100 instead, and 3//4 or QQ(3, 4) for the rational number; the former is a Julia Rational, the latter an OSCAR rational number, see Integers and rational numbers.

• Multiple return values are tuples. Both Magma and Julia allow functions to return several values, but in Julia these form a tuple that is printed as a whole, and there are no "optional" return values that are silently dropped. Where a Magma predicate returns a witness as a second value, OSCAR has a separate function whose name says so:

  julia> is_square(ZZ(16))
  true
  
  julia> is_square_with_sqrt(ZZ(16))
  (true, 4)

  For example, H, f := sub<G | ...> returns the subgroup together with its embedding, and H := sub<G | ...> silently drops the embedding. OSCAR's sub always returns both, see Many constructors return more than one object.

• The order of dihedral groups. Magma's DihedralGroup(n) is the dihedral group of order $2n$, OSCAR's dihedral_group(n) is the dihedral group of order $n$, following GAP.

• The default monomial ordering differs. PolynomialRing(K, n) in Magma uses the lexicographical ordering, and Gröbner bases are computed w.r.t. it. In OSCAR, groebner_basis computes with respect to the degree reverse lexicographical ordering by default, the one returned by default_ordering(R), and takes the ordering as a keyword argument.

  julia> R, (x, y) = polynomial_ring(QQ, [:x, :y]);
  
  julia> I = ideal(R, [x^2 + y^2 - 1, x - y]);
  
  julia> groebner_basis(I; ordering = lex(R))
  Gröbner basis with elements
    1: 2*y^2 - 1
    2: x - y
  with respect to the ordering
    lex([x, y])

• div rounds differently. Magma's a div b rounds towards $-\infty$, like Julia's fld. Julia's div rounds towards zero, so it agrees with Magma's div only when both operands have the same sign. Magma's a mod b and Julia's mod(a, b) do agree.

• Argument order of ChangeRing. Magma's ChangeRing(M, R) is change_base_ring(R, M) in OSCAR; the ring comes first, as in matrix(R, ...).

• Types are not intrinsics. Magma's Type(x) is typeof(x) in Julia, Parent(x) is parent(x). There is no Category. The signatures of a function f are listed by methods(f).

Common Magma functions and their OSCAR counterparts

Sequences and sets

Integers and rational numbers

Groups

Polynomials and ideals

Number fields

Matrices