A generic abelian group can be defined over any domain (universe) or aggregate. The user may define the identity, the composition and the inverse functions. It is possible to determine if the elements of the group will be represented (internally) as a linear combination of the generators. To aid in the computation of the group, it is also possible to set the order and the generators of the group. This is made explicit below.
Creating a generic abelian group does not imply that the group structure will be computed, unless this is explicitly requested. In general, structure computation will be achieved through an extra step (see Section Structure Computation). However structure computation will be automatically triggered when this is required by the nature of the access functions relative to the generic group created. Typically one reason for not computing the structure of the group is that it may be expensive to do so and may actually not be required for further operations (like finding the order or the discrete logarithm of an element of the group).
As it will be seen, there are two possible ways of computing the structure of the group. The first requires that the order of the abelian group is known, or that it can be computed; this then allows to construct each of the p-Sylow subgroups of the group. The second method does not require the knowledge of the order of the group: the structure is computed from a set of generators as given by the user.
IdIntrinsic: MonStg Default: not set
AddIntrinsic: MonStg Default: not set
InverseIntrinsic: MonStg Default: not set
UseRepresentation: Bool Default: FALSE
Order: RngInt Default: not set
UserGenerators: SetEnum Default: not set
ProperSubset: Bool Default: FALSE
RandomIntrinsic: MonStg Default: not set
ComputeStructure: Bool Default: FALSE
Construct the generic abelian group A over the domain U. The domain U can be an aggregate (set, indexed set or sequence) of elements or it can be `anything', for example, an elliptic curve, a jacobian, a magma of quadratic forms.
If the parameters IdIntrinsic, AddIntrinsic and InverseIntrinsic are not set, then the identity, the composition and the inverse function of A are taken to be the identity, the composition and the inverse function of U or of Universe(U) if U is an aggregate. If the parameters IdIntrinsic, AddIntrinsic and InverseIntrinsic are set, they define the identity, the composition and the inverse function of A.
The parameter IdIntrinsic must be a function name whose sole argument is U or Universe(U) if U is an aggregate. AddIntrinsic must be a function name whose only two arguments are elements of U or of Universe(U) if U is an aggregate. InverseIntrinsic must be a function name whose only two arguments are elements of U or of Universe(U) if U is an aggregate. Yes, here we require that InverseIntrinsic be a binary operation (see the example below where InverseIntrinsic := "/" is indeed binary). Defining either of the three above parameters implies that the other two must be defined as well.
Setting the parameter UseRepresentation to true implies that all elements of A will be internally represented as linear combinations of the generators of A obtained while computing A' structure. One must remember that this can be a costly procedure, since such a representation is akin to solving the discrete logarithm problem. The advantage of such a representation is that arithmetic for elements of A as well as computing the order of elements of A are then essentially trivial operations.
The parameter Order can be set to the order of the group, if it is known. This may be useful as it saves the need to compute the order of the group, should this be required by some group structure computation, or to solve the discrete logarithm problem. More importantly, if A is a proper subset of U, or of Universe(U) if U is an aggregate, then Order must be set -- unless the parameter UserGenerators is set.
One can set UserGenerators to some set of elements of U, or of Universe(U) if U is an aggregate, which generate the group A. This can be useful when A is a subset of U (Universe(U)), or more generally when the computation of the group structure of A is made from a set of generators. Finally, setting UserGenerators may be an alternative to setting RandomIntrinsic. More on this in Section Structure Computation.
The parameter ProperSubset must be set when A is a proper subset of U (Universe(U)).
The parameter RandomIntrinsic indicates the random function to use. If it is not set, the random function (if it is required) is taken to be the random function applying to U (Universe(U)).
The parameter RandomIntrinsic must be the name of a function taking as its sole argument U (Universe(U)) and returning an element of U (Universe(U)) which is also an element of the group A (this is important when A is a proper subset of U (Universe(U)). Therefore, if A is a proper subset of U (Universe(U)), then RandomIntrinsic must be set, unless the parameter UserGenerators is set. More on this in Section Structure Computation.
The parameter ComputeStructure enables the user to request that the computation of the group structure be performed at the time of creation. If this parameter is set then the user may also want to set the following four parameters:
UseUserGenerators: Bool Default: FALSE
PollardRhoRParam: RngInt Default: 20
PollardRhoTParam: RngInt Default: 8
PollardRhoVParam: RngInt Default: 3
Their meaning is detailed in Section Structure Computation. the Computation section.
> m := 34384;
> Zm := Integers(m);
> U := {@ x : x in Zm | GCD(x, m) eq 1 @};
> GA_Zm := GenericAbelianGroup(U : > IdIntrinsic := "Id",
> AddIntrinsic := "*",
> InverseIntrinsic := "/");
> GA_Zm;
Generic Abelian Group over
Residue class ring of integers modulo 34384
create the generic abelian group GA_(Zm) as the abelian group U.
Note that here U is an indexed set.
The next statements
> n := 6;
> Dk := -4*(10^n + 1);
> Q := QuadraticForms(Dk);
>
> p := 2;
> S := {};
> while #S lt 10 do
> if KroneckerSymbol(Dk,p) eq 1 then
> I := Reduction(PrimeForm(Q,p));
> Include( S, I);
> end if;
> p := NextPrime(p);
> end while;
>
> GA_qf := GenericAbelianGroup(Q : UserGenerators := S,
> ComputeStructure := true,
> UseUserGenerators := true);
> GA_qf;
Generic Abelian Group over
Binary quadratic forms of discriminant -4000004
Abelian Group isomorphic to Z/2 + Z/516
Defined on 2 generators
Relations:
2*$.1 = 0
516*$.2 = 0
create and compute the structure of
the generic abelian group GA_(qf) as the abelian group Q.