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 for definitions). This can be done using the function .

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.

Construction of crossed products
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 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 &ZZ;_n, the ring of integers modulo n, on &QQ; (\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 &QQ; (i)=GaussianRationals. One realizes the cyclic group of order 2 as the group of units of &ZZ; / 4 &ZZ; and one uses the natural isomorphism &ZZ; / 4 &ZZ; \rightarrow Gal( &QQ; (i)/ &QQ; ) 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

&QQ; (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 LeftActingDomain for the coefficient ring.

* UnderlyingMagma UnderlyingMagma for the underlying group.

* ActionForCrossedProduct ActionForCrossedProduct for the action.

* TwistingForCrossedProduct 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 () 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 to produce generalized quaternion algebras. Note that one can construct quaternion algebras using the &GAP; function QuaternionAlgebra. Quaternion algebra

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 ] ]
Crossed product elements and their properties
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 ZeroCoefficient of the crossed product element.

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

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

Also note from the example below and several other examples in this chapter that instead of ElementOfCrossedProduct one can use Embedding 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))