Notes for GAP users

OSCAR uses GAP for most of its group theory, via the Julia package GAP.jl. This page describes differences between GAP and OSCAR, and lists GAP functions together with their OSCAR counterparts.

Only a part of GAP's functionality has a counterpart in OSCAR. If you need something that OSCAR does not provide, you can call the GAP function directly, see Using GAP from OSCAR; in that case please also open an issue, so that we can add a proper OSCAR interface for it.

Differences in syntax

• In GAP, equality of two objects is checked with =, and one assigns a value to a variable with :=. In Julia, equality is checked with ==, and = denotes assignment. Similarly, inequality of objects is checked with <> in GAP and with != in Julia.

• In GAP, the operator not is used to negate boolean expressions, whereas ! is used in Julia. The operators and and or are && and || in Julia.

• The GAP object fail has no counterpart in Julia. The idea behind fail is to indicate situations when an operation could not be performed for the given arguments. Such cases are handled differently in Julia.

  • nothing can be used as a return value. For example the Julia analogue of GAP's Position( list, elm ) is findfirst(==(elm), list), which returns nothing if elm does not occur in the list list.

  • The Julia function in question may have two return values, the first being a boolean that expresses whether the operation was successful, and the second being the requested result if the first return value is true. For example, GAP's PreImagesRepresentative( mapp, elm ) returns fail if elm is in the image of the mapping mapp. The corresponding OSCAR function has_preimage_with_preimage(mapp, elm) returns (true, pre) if elm is in the image of mapp, and then pre is one of the preimages; if elm has no preimages then (false, obj) is returned, where obj is some element in domain(mapp).

• In GAP, object identity is checked with the function IsIdenticalObj, whereas the infix operator === (with negation !==) is used in Julia.

• In GAP, if statements have the form

  if condition1 then
    statements1
  elif condition2 then
    statements2
  else
    statements3
  fi;

  whereas the Julia syntax is

  if condition1
    statements1
  elseif condition2
    statements2
  else
    statements3
  end

  Similarly, GAP's for loops have the form

  for var in list do
    statements
  od;

  whereas the Julia syntax is

  for var in list
    statements
  end

  (The situation with while loops is analogous.)

• GAP functions are defined as f := function(x) ... end;, the Julia equivalents are function f(x) ... end and, for one-liners, f(x) = .... Anonymous functions look the same in both languages: x -> x^2.

• GAP's G.1 for the first generator of a group is G[1] in OSCAR.

• The ; at the end of a statement is mandatory in GAP, and two semicolons suppress the output of the value. In Julia, no semicolon is needed, and a trailing ; suppresses the output of the value in an interactive session, see Semicolons and output. So in both languages, an extra semicolon suppresses output.

Differences in semantics

• Integer literals are machine integers. In GAP, all integers are arbitrary precision integers. In Julia, 2^100 evaluates to 0, see Integers and rational numbers.

• The sum of a matrix and a scalar is different. In GAP, the sum of a matrix (a list of lists) and a scalar is defined recursively as the pointwise sum.

  gap> [ [ 1, 2 ], [ 3, 4 ] ] + 2;
  [ [ 3, 4 ], [ 5, 6 ] ]

  In OSCAR, the sum of a matrix and a scalar is defined as the sum of the given matrix and the multiple of the identity matrix that is given by the scalar.

  julia> matrix(ZZ, [1 2; 3 4]) + 2
  [3   2]
  [3   6]

• There are no natural embeddings. GAP provides natural embeddings of many algebraic structures. For example, two finite fields of the same characteristic are embedded into each other whenever this makes sense, and the elements of the smaller field are regarded also as elements of the larger field. Analogously, subfields of cyclotomic fields are naturally embedded into each other, and in fact their elements are internally represented w.r.t. the smallest possible cyclotomic field.

  In OSCAR, this is not the case. Each element of an algebraic structure has a parent, and operations involving several elements (such as arithmetic operations) are usually restricted to the situation that their parents coincide. One has to explicitly coerce a given element into a different parent if necessary, see Every object has a parent.

• Permutations belong to a symmetric group of fixed degree. This is a consequence of the previous point. cperm([1, 2, 3]) creates the permutation (1,2,3) as an element of the symmetric group of degree 3, and it cannot be multiplied with an element of the symmetric group of degree 4. Create permutations as elements of the group G you want to work in, for example with cperm(G, [1, 2, 3]) or perm(G, [2, 3, 1]).

  Similarly, each permutation group in OSCAR has a fixed degree, and the function is_transitive checks whether its argument is transitive on the points from 1 to the degree. In GAP, however, the function IsTransitive, called with a permutation group, checks whether this group is transitive on the points which are moved by it. Thus the group generated by the permutation (1, 2, 4) is regarded as transitive in GAP but as intransitive in OSCAR.

  For the same reason, transitive_group in OSCAR supports degree 1, where the trivial group is the unique transitive group, whereas GAP's library of transitive groups starts at degree 2.

• Subgroups come together with embeddings. Functions that return a subgroup, such as sub, center, derived_subgroup, sylow_subgroup, stabilizer, and kernel, return a tuple consisting of the subgroup and its embedding into the given group, and quo returns the quotient group together with the natural projection, see Many constructors return more than one object.

• The argument order of subset tests is reversed. GAP's IsSubset(G, H) and IsSubgroup(G, H) put the larger object first. OSCAR follows the Julia convention that the arguments of issubset, is_subset, is_subgroup, and is_normal_subgroup appear in the same order as in the mathematical notation $H \subseteq G$, that is, is_subset(H, G) and is_subgroup(H, G).

• Size has several counterparts. Depending on the object, GAP's Size corresponds to order(G) for a group, length(l) for a list or another collection, and number_of_rows(M) for a matrix. Julia's size(M) returns the tuple of dimensions of a matrix.

• Global variables are not protected. Global OSCAR variables are not write protected, contrary to most global GAP variables. Thus there is always the danger that assignments overwrite Julia functions. For example, it is tempting to use gens, hom, and map as names for variables, but Julia or OSCAR define them already.

  (Also copying some lines of code from an OSCAR function into a Julia session can be dangerous in this sense, because some names of local variables of the function may coincide with the names of global variables.)

Interactive sessions

When an error occurs or when the user hits ctrl-C in a GAP session, usually a break loop is entered, from which one can either try to continue the computations, by entering return, or return to the GAP prompt, by entering quit; in the latter case, some objects may be corrupted afterwards.

In a Julia session, one gets automatically back to the Julia prompt when an error occurs or when the user hits ctrl-C, and again some objects may be corrupted afterwards.

Names of functions and variables

Variable names in GAP and Julia are recommended to be written in camel case and snake case, respectively, see Naming conventions. For example, the GAP function SylowSubgroup corresponds to OSCAR's sylow_subgroup. Guessing the OSCAR name this way works surprisingly often. The tables below list common GAP functions with their OSCAR counterparts, among them those that cannot be guessed.

The GAP rule that the names of user variables should start with a lowercase letter, in order to avoid clashes with system variables, does not make sense in Julia.

Common GAP functions and their OSCAR counterparts

Lists and functional programming

Integers

Groups

Permutations

Rings, fields, and polynomials

Matrices