Goto Chapter: Top 1 2 3 4 5 6 7 Bib Ind
Top of Book Previous Chapter Next Chapter

5 Crossed products
5.1 Construction of crossed products
5.1-1 CrossedProduct
5.2 Crossed product elements and their properties
5.2-1 ElementOfCrossedProduct

### 5 Crossed products

The package Wedderga provides functions to construct crossed products over a group with coefficients in an associative ring with identity, and with the multiplication determined by a given action and twisting (see 7.6 for definitions). This can be done using the function `CrossedProduct` (5.1-1).

Note that this function does not check the associativity conditions, so in fact it is the NC-version of itself, and its output will be always assumed to be associative. For all crossed products that appear in Wedderga algorithms the associativity follows from theoretical arguments, so the usage of the NC-method in the package is safe. If the user will try to construct a crossed product with his own action and twisting, he/she should check the associativity conditions himself/herself to make sure that the result is correct.

#### 5.1 Construction of crossed products

##### 5.1-1 CrossedProduct

`> CrossedProduct`( R, G, act, twist ) | ( attribute )

Returns: Ring in the category `IsCrossedProduct`.

The input should be formed by:

* an associative ring R,

* a group G,

* a function act(RG,g) of two arguments: the crossed product RG and an element g in G. It must return a mapping from R to R which can be applied via the "`\^`" operation, and

* a function twist(RG,g,h) of three arguments: the crossed product RG and a pair of elements of G. It must return an invertible element of R.

Returns the crossed product of G over the ring R with action act and twisting twist.

The resulting crossed product belongs to the category `IsCrossedProduct`, which is defined as a subcategory of `IsFLMLORWithOne`.

An example of the trivial action:

    act := function(RG,a)
        return IdentityMapping( LeftActingDomain( RG ) );
    end;

and the trivial twisting:

    twist := function( RG , g, h )
        return One( LeftActingDomain( RG ) );
    end;

Let n be a positive integer and xi_n an n-th complex primitive root of unity. The natural action of the group of units of ℤ_n, the ring of integers modulo n, on ℚ (xi_n) can be defined as follows:

    act := function(RG,a)
        return ANFAutomorhism( LeftActingDomain( RG ) , Int( a ) );
    end;

In the following example one constructs the Hamiltonian quaternion algebra over the rationals as a crossed product of the group of units of the cyclic group of order 2 over ℚ (i)=GaussianRationals. One realizes the cyclic group of order 2 as the group of units of ℤ / 4 ℤ and one uses the natural isomorphism ℤ / 4 ℤ -> Gal( ℚ (i)/ ℚ ) to describe the action.

    gap> R := GaussianRationals;
    GaussianRationals
    gap> G := Units( ZmodnZ(4) );
    <group with 1 generators>
    gap> act := function(RG,g)
    > return ANFAutomorphism( LeftActingDomain(RG), Int(g) );
    > end;
    function( RG, g ) ... end
    gap> twist1 := function( RG, g, h )
    > if IsOne(g) or IsOne(h) then
    >    return One(LeftActingDomain(RG));
    > else
    >    return -One(LeftActingDomain(RG));
    > fi;
    > end;
    function( RG, g, h ) ... end
    gap> RG := CrossedProduct( R, G, act, twist1 );
    <crossed product over GaussianRationals of a group of size 2>
    gap> i := E(4) * One(G)^Embedding(G,RG);
    (ZmodnZObj( 1, 4 ))*(E(4))
    gap> j := ZmodnZObj(3,4)^Embedding(G,RG);
    (ZmodnZObj( 3, 4 ))*(1)
    gap> i^2;
    (ZmodnZObj( 1, 4 ))*(-1)
    gap> j^2;
    (ZmodnZObj( 1, 4 ))*(-1)
    gap> i*j+j*i;
    <zero> of ...

One can construct the following generalized quaternion algebra with the same action and a different twisting

ℚ (i,j|i^2=-1,j^2=-3,ji=-ij)

    gap> twist2:=function(RG,g,h)
    > if IsOne(g) or IsOne(h) then
    >     return One(LeftActingDomain( RG ));
    > else
    >     return -3*One(LeftActingDomain( RG ));
    > fi;
    > end;
    function( RG, g, h ) ... end
    gap> RG := CrossedProduct( R, G, act, twist2 );
    <crossed product over GaussianRationals of a group of size 2>
    gap> i := E(4) * One(G)^Embedding(G,RG);
    (ZmodnZObj( 1, 4 ))*(E(4))
    gap> j := ZmodnZObj(3,4)^Embedding(G,RG);
    (ZmodnZObj( 3, 4 ))*(1)
    gap> i^2;
    (ZmodnZObj( 1, 4 ))*(-1)
    gap> j^2;
    (ZmodnZObj( 1, 4 ))*(-3)
    gap> i*j+j*i;
    <zero> of ...

The following example shows how to construct the Hamiltonian quaternion algebra over the rationals using the rationals as coefficient ring and the Klein group as the underlying group.

    gap> C2 := CyclicGroup(2);
    <pc group of size 2 with 1 generators>
    gap> G := DirectProduct(C2,C2);
    <pc group of size 4 with 2 generators>
    gap> act := function(RG,a)
    >     return IdentityMapping( LeftActingDomain(RG));
    > end;
    function( RG, a ) ... end
    gap> twist := function( RG, g , h )
    > local one,g1,g2,h1,h2,G;
    > G := UnderlyingMagma( RG );
    > one := One( C2 );
    > g1 := Image( Projection(G,1), g );
    > g2 := Image( Projection(G,2), g );
    > h1 := Image( Projection(G,1), h );
    > h2 := Image( Projection(G,2), h );
    > if g = One( G ) or h = One( G ) then return 1;
    >   elif IsOne(g1) and not IsOne(g2) and not IsOne(h1) and not IsOne(h2)
    >     then return 1;
    >   elif not IsOne(g1) and IsOne(g2) and IsOne(h1) and not IsOne(h2)
    >     then return 1;
    >   elif not IsOne(g1) and not IsOne(g2) and not IsOne(h1) and IsOne(h2)
    >     then return 1;
    >   else return -1;
    > fi;
    > end;
    function( RG, g, h ) ... end
    gap> HQ := CrossedProduct( Rationals, G, act, twist );
    <crossed product over Rationals of a group of size 4>

Changing the rationals by the integers as coefficient ring one can construct the Hamiltonian quaternion ring.

    gap> HZ := CrossedProduct( Integers, G, act, twist );
    <crossed product over Integers of a group of size 4>
    gap> i := GeneratorsOfGroup(G)[1]^Embedding(G,HZ);
    (f1)*(1)
    gap> j := GeneratorsOfGroup(G)[2]^Embedding(G,HZ);
    (f2)*(1)
    gap> i^2;
    (<identity> of ...)*(-1)
    gap> j^2;
    (<identity> of ...)*(-1)
    gap> i*j+j*i;
    <zero> of ...

One can extract the arguments used for the construction of the crossed product using the following attributes:

* `LeftActingDomain` for the coefficient ring.

* `UnderlyingMagma` for the underlying group.

* `ActionForCrossedProduct` for the action.

* `TwistingForCrossedProduct` for the twisting.

    gap> LeftActingDomain(HZ);
    Integers
    gap> G:=UnderlyingMagma(HZ);
    <pc group of size 4 with 2 generators>
    gap> ac := ActionForCrossedProduct(HZ);
    function( RG, a ) ... end
    gap> List( G , x -> ac( HZ, x ) );
    [ IdentityMapping( Integers ), IdentityMapping( Integers ),
      IdentityMapping( Integers ), IdentityMapping( Integers ) ]
    gap> tw := TwistingForCrossedProduct( HZ );
    function( RG, g, h ) ... end
    gap> List( G, x -> List( G , y -> tw( HZ, x, y ) ) );
    [ [ 1, 1, 1, 1 ], [ 1, -1, -1, 1 ], [ 1, 1, -1, -1 ], [ 1, -1, 1, -1 ] ]

Some more examples of crossed products arise from the Wedderburn decomposition (7.3) of group algebras.

    gap> G := SmallGroup(32,50);
    <pc group of size 32 with 5 generators>
    gap> A := SimpleAlgebraByCharacter( GroupRing(Rationals,G), Irr(G)[17]) ;
    ( <crossed product with center Rationals over GaussianRationals of a group of \
    size 2>^[ 2, 2 ] )
    gap> SimpleAlgebraByCharacterInfo( GroupRing(Rationals,G), Irr(G)[17]) ;
    [ 2, Rationals, 4, [ 2, 3, 2 ] ]
    gap> B := LeftActingDomain(A);
    <crossed product with center Rationals over GaussianRationals of a group of si\
    ze 2>
    gap> L := LeftActingDomain(B);
    GaussianRationals
    gap> H := UnderlyingMagma( B );
    <group of size 2 with 2 generators>
    gap> Elements(H);
    [ ZmodnZObj( 1, 4 ), ZmodnZObj( 3, 4 ) ]
    gap> i := E(4) * One(H)^Embedding(H,B);
    (ZmodnZObj( 1, 4 ))*(E(4))
    gap> j := ZmodnZObj(3,4)^Embedding(H,B);
    (ZmodnZObj( 3, 4 ))*(1)
    gap> i^2;
    (ZmodnZObj( 1, 4 ))*(-1)
    gap> j^2;
    (ZmodnZObj( 1, 4 ))*(-1)
    gap> i*j+j*i;
    <zero> of ...
    gap> ac := ActionForCrossedProduct( B );
    function( RG, a ) ... end
    gap> tw := TwistingForCrossedProduct( B );
    function( RG, a, b ) ... end
    gap> List( H , x -> ac( B, x ) );
    [ IdentityMapping( GaussianRationals ), ANFAutomorphism( GaussianRationals,
        3 ) ]
    gap> List( H , x -> List( H , y -> tw( B, x, y ) ) );
    [ [ 1, 1 ], [ 1, -1 ] ]

    gap> QG:=GroupRing( Rationals, SmallGroup(24,3) );;
    gap> WedderburnDecomposition(QG);
    [ Rationals, CF(3), ( Rationals^[ 3, 3 ] ),
      <crossed product with center Rationals over GaussianRationals of a group of \
    size 2>, <crossed product with center CF(3) over AsField( CF(3), CF(
        12) ) of a group of size 2> ]
    gap> R:=WedderburnDecomposition( QG )[4];
    <crossed product with center Rationals over GaussianRationals of a group of si\
    ze 2>
    gap> IsCrossedProduct(R);
    true
    gap> IsAlgebra(R);
    true
    gap> IsRing(R);
    true
    gap> LeftActingDomain( R );
    GaussianRationals
    gap> AsList( UnderlyingMagma( R ) );
    [ ZmodnZObj( 1, 4 ), ZmodnZObj( 3, 4 ) ]
    gap> Print( ActionForCrossedProduct( R ) ); Print("\n");
    function ( RG, a )
        local  cond, redu;
        cond := OperationRecord( RG ).cond;
        redu := OperationRecord( RG ).redu;
        return
         ANFAutomorphism( CF( cond ), Int( PreImagesRepresentative( redu, a ) ) );
    end
    gap> Print( TwistingForCrossedProduct( R ) ); Print("\n");
    function ( RG, a, b )
        local  orderroot, cocycle;
        orderroot := OperationRecord( RG ).orderroot;
        cocycle := OperationRecord( RG ).cocycle;
        return E( orderroot ) ^ Int( cocycle( a, b ) );
    end
    gap> IsAssociative(R);
    true
    gap> IsFinite(R);
    false
    gap> IsFiniteDimensional(R);
    true
    gap> AsList(Basis(R));
    [ (ZmodnZObj( 1, 4 ))*(1), (ZmodnZObj( 3, 4 ))*(1) ]
    gap> GeneratorsOfLeftOperatorRingWithOne(R);
    [ (ZmodnZObj( 1, 4 ))*(1), (ZmodnZObj( 3, 4 ))*(1) ]
    gap> One(R);
    (ZmodnZObj( 1, 4 ))*(1)
    gap> Zero(R);
    <zero> of ...
    gap> Characteristic(R);
    0
    gap> CenterOfCrossedProduct(R);
    Rationals

The next example shows how one can use `CrossedProduct` to produce generalized quaternion algebras. Note that one can construct quaternion algebras using the GAP function `QuaternionAlgebra`.

    gap> Quat := function(R,a,b)
    >
    > local G,act,twist;
    >
    > if not(a in R and b in R and a <> Zero(R) and b <> Zero(R) ) then
    > Error("<a>  and <b> must be non zero elements of <R>!!!");
    > fi;
    >
    > G := SmallGroup(4,2);
    >
    > act := function(RG,a)
    >     return IdentityMapping( LeftActingDomain(RG));
    > end;
    >
    > twist := function( RG, g , h )
    > local one,g1,g2;
    > one := One(G);
    > g1 := G.1;
    > g2 := G.2;
    > if   g = one or h = one then
    >   return One(R);
    > elif g = g1 then
    >   if h = g2 then
    >     return One(R);
    >   else
    >     return a;
    >   fi;
    > elif g = g2 then
    >   if h = g1 then
    >     return -One(R);
    >   elif h=g2 then
    >     return b;
    >   else
    >     return -b;
    >   fi;
    > else
    >   if h = g1 then
    >     return -b;
    >   elif h=g2 then
    >     return b;
    >   else
    >     return -a*b;
    >   fi;
    > fi;
    > end;
    > return CrossedProduct(R,G,act,twist);
    > end;
    function( R, a, b ) ... end
    gap> HQ := Quat(Rationals,2,3);
    <crossed product over Rationals of a group of size 4>
    gap> G := UnderlyingMagma(HQ);
    <pc group of size 4 with 2 generators>
    gap> tw := TwistingForCrossedProduct( HQ );
    function( RG, g, h ) ... end
    gap> List( G, x -> List( G, y -> tw( HQ, x, y ) ) );
    [ [ 1, 1, 1, 1 ], [ 1, 3, -1, -3 ], [ 1, 1, 2, 2 ], [ 1, 3, -3, -6 ] ]

#### 5.2 Crossed product elements and their properties

##### 5.2-1 ElementOfCrossedProduct

`> ElementOfCrossedProduct`( Fam, zerocoeff, coeffs, elts ) | ( property )

Returns the element m_1*c_1 + ... + m_n*c_n of a crossed product, where elts = [ m_1, m_2, ..., m_n ] is a list of magma elements, coeffs = [ c_1, c_2, ..., c_n ] is a list of coefficients. The output belongs to the crossed product whose elements lie in the family Fam. The second argument zerocoeff must be the zero element of the coefficient ring containing coefficients c_i, and will be stored in the attribute `ZeroCoefficient` of the crossed product element.

The output will be in the category `IsElementOfCrossedProduct`, which is a subcategory of `IsRingElementWithInverse`. It will have the presentation `IsCrossedProductObjDefaultRep`.

Similarly to magma rings, one can obtain the list of coefficients and elements with `CoefficientsAndMagmaElements` .

Also note from the example below and several other examples in this chapter that instead of `ElementOfCrossedProduct` one can use `Embedding` to embed elements of the coefficient ring and of the underlying magma into the crossed product.

    gap> QG := GroupRing( Rationals, SmallGroup(24,3) );
    <algebra-with-one over Rationals, with 4 generators>
    gap> R := WedderburnDecomposition( QG )[4];
    <crossed product with center Rationals over GaussianRationals of a group of si\
    ze 2>
    gap> H := UnderlyingMagma( R );;
    gap> fam := ElementsFamily( FamilyObj( R ) );;
    gap> g := ElementOfCrossedProduct( fam, 0, [ 1, E(4) ], AsList(H) );
    (ZmodnZObj( 1, 4 ))*(1)+(ZmodnZObj( 3, 4 ))*(E(4))
    gap> CoefficientsAndMagmaElements( g );
    [ ZmodnZObj( 1, 4 ), 1, ZmodnZObj( 3, 4 ), E(4) ]
    gap> t := List( H, x -> x^Embedding( H, R ) );
    [ (ZmodnZObj( 1, 4 ))*(1), (ZmodnZObj( 3, 4 ))*(1) ]
    gap> t[1] + t[2]*E(4);
    (ZmodnZObj( 1, 4 ))*(1)+(ZmodnZObj( 3, 4 ))*(E(4))
    gap> g = t[1] + E(4)*t[2];
    false
    gap> g = t[1] + t[2]*E(4);
    true
    gap> h := ElementOfCrossedProduct( fam, 0, [ E(4), 1 ], AsList(H) );
    (ZmodnZObj( 1, 4 ))*(E(4))+(ZmodnZObj( 3, 4 ))*(1)
    gap> g+h;
    (ZmodnZObj( 1, 4 ))*(1+E(4))+(ZmodnZObj( 3, 4 ))*(1+E(4))
    gap> g*E(4);
    (ZmodnZObj( 1, 4 ))*(E(4))+(ZmodnZObj( 3, 4 ))*(-1)
    gap> E(4)*g;
    (ZmodnZObj( 1, 4 ))*(E(4))+(ZmodnZObj( 3, 4 ))*(1)
    gap> g*h;
    (ZmodnZObj( 1, 4 ))*(2*E(4))

Top of Book Previous Chapter Next Chapter
Goto Chapter: Top 1 2 3 4 5 6 7 Bib Ind

generated by GAPDoc2HTML