Creating Sequences

Square brackets are used for the definition of enumerated sequences; formal sequences are delimited by the composite brackets [! and !].

Certain expressions appearing below (possibly with subscripts) have the standard interpretation:

U
the universe: any Magma structure;
E
the range set for enumerated sequences: any enumerated structure (it must be possible to loop over its elements -- see the Introduction to this Part);
F
the range set for formal sequences: any structure for which membership testing using in is defined -- see the Introduction to this Part);
x
a free variable which successively takes the elements of E (or F in the formal case) as its values;
P
a Boolean expression that usually involves the variable(s) x, x1, ..., xk;
e
an expression that also usually involves the variable(s) x, x1, ..., xk.

Contents

The Formal Sequence Constructor

The formal sequence constructor has the following fixed format (the expressions appearing in the construct are defined above):

[! x in F | P(x) !]
Create the formal sequence consisting of the subsequence of elements x of F for which P(x) is true. If P(x) is true for every element of F, the sequence constructor may be abbreviated to [! x in F !]

The Enumerated Sequence Constructor

Sequences can be constructed by expressions enclosed in square brackets, provided that the values of all expressions can be automatically coerced into some common structure, as outlined in the Introduction. All general constructors have the universe U optionally up front, which allows the user to specify into which structure all terms of the sequences should be coerced.

[ ] : Null -> ESeqEnum
The null sequence (empty, and no universe specified).
[ U | ] : Str -> SeqEnum
The empty sequence with universe U.
[ e1, e2, ..., en ] : Elt, ..., Elt -> SeqEnum
Given a list of expressions e1, ..., en, defining elements a1, a2, ..., an all belonging to (or automatically coercible into) a single algebraic structure U, create the sequence Q = [ a1, a2, ..., an ] of elements of U.

As for multisets, one may use the expression x^^ n to specify the object x with multiplicity n: this is simply interpreted to mean x repeated n times (i.e., no internal compaction of the repetition is done).

[ U | e1, e2, ..., em ] : Str, Elt, ..., Elt -> SeqEnum
Given a list of expressions e1, ..., em, which define elements a1, a2, ..., an that are all coercible into U, create the sequence Q = [ a1, a2, ..., an ] of elements of U.

[ e(x) : x in E | P(x) ]
Form the sequence of elements e(x), all belonging to some common structure, for those x ∈E with the property that the predicate P(x) is true. The expressions appearing in this construct have the interpretation given at the beginning of this section.

If P(x) is true for every element of E, the sequence constructor may be abbreviated to [ e(x) : x in E ] .

[ U | e(x) : x in E | P(x) ]
Form the sequence of elements of U consisting of the values e(x) for those x∈E for which the predicate P(x) is true (an error results if not all e(x) are coercible into U). The expressions appearing in this construct have the same interpretation as above.
[ e(x1,...,xk) : x1 in E1, ..., xkin Ek | P(x1, ..., xk) ]
The sequence consisting of those elements e(x1, ..., xk), in some common structure, for which x1, ..., xk in E1, ..., Ek have the property that P(x1, ..., xk) is true.

The expressions appearing in this construct have the interpretation given at the beginning of this section.

Note that if two successive ranges Ei and Ei + 1 are identical, then the specification of the ranges for xi and xi + 1 may be abbreviated to xi, xi + 1 in Ei.

Also, if P(x1, ..., xk) is always true, it may be omitted.

[ U | e(x1,...,xk) : x1 in E1, ...,xk in Ek | P(x1, ..., xk) ]
As in the previous entry, the sequence consisting of those elements e(x1, ..., xk) for which P(x1, ..., xk) is true is formed, as a sequence of elements of U (an error occurs if not all e(x1, ..., xk) are coercible into U).

The Arithmetic Progression Constructors

Since enumerated sequences of integers arise so often, there are a few special constructors to create and handle them efficiently in case the entries are in arithmetic progression. The universe must be the ring of integers. Some effort is made to preserve the special way of storing arithmetic progressions under sequence operations.

[ i..j ] : RngIntElt, RngIntElt -> SeqEnum
[ U | i..j ] : Str, RngIntElt, RngIntElt -> SeqEnum
The enumerated sequence of integers whose elements form the arithmetic progression i, i + 1, i + 2, ..., j, where i and j are (expressions defining) arbitrary integers. If j is less than i then the empty sequence of integers will be created.

The universe U, if it is specified, has to be the ring of integers; any other universe will lead to an error.

[ i .. j by k ] : RngIntElt, RngIntElt, RngIntElt -> SeqEnum
[ U | i .. j by k ] : Str, RngIntElt, RngIntElt, RngIntElt -> SeqEnum
The enumerated sequence consisting of the integers forming the arithmetic progression i, i + k, i + 2 * k, ..., j, where i, j and k are (expressions defining) arbitrary integers (but k≠0).

If k is positive then the last element in the progression will be the greatest integer of the form i + n * k that is less than or equal to j; if j is less than i, the empty sequence of integers will be constructed.

If k is negative then the last element in the progression will be the least integer of the form i + n * k that is greater than or equal to j; if j is greater than i, the empty sequence of integers will be constructed.

The universe U, if it is specified, has to be the ring of integers; any other universe will lead to an error.

Example Seq_Progression (H11E1)

As in the case of sets, it is possible to use the arithmetic progression constructors to save some typing in the creation of sequences of elements of rings other than the ring of integers, but the result will not be treated especially efficiently. 
> s := [ IntegerRing(200) | x : x in [ 25..125 ] ];

Literal Sequences

A literal sequence is an enumerated sequence all of whose terms are from the same structure and all of these are `typed in' literally. The sole purpose of literal sequences is to load certain enumerated sequences very fast and very space-efficiently; this is only useful when reading in very large sequences (all of whose elements must have been specified literally, that is, not as some expression other than a literal), but then it may save a lot of time. The result will be an enumerated sequence, that is, not distinguished in any way from other such sequences.

At present, only literal sequences of integers are supported.

\[ m1, ..., mn ] : RngIntElt, ..., RngIntElt -> [ RngIntElt ]
Given a succession of literal integers m1, ..., mn, build the enumerated sequence [m1, ..., mn], in a time and space efficient way.
V2.28, 13 July 2023