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:
  
  ---------------------------  Example  ----------------------------
    act := function(RG,a)
        return IdentityMapping( LeftActingDomain( RG ) );
    end;
  ------------------------------------------------------------------
  
  and the trivial twisting:
  
  ---------------------------  Example  ----------------------------
    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:
  
  ---------------------------  Example  ----------------------------
    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.
  
  ---------------------------  Example  ----------------------------
    
    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)
  
  
  ---------------------------  Example  ----------------------------
    
    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.
  
  ---------------------------  Example  ----------------------------
    
    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.
  
  ---------------------------  Example  ----------------------------
    
    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.
  
  ---------------------------  Example  ----------------------------
      
    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.
  
  ---------------------------  Example  ----------------------------
    
    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 ] ]
    
  ------------------------------------------------------------------
  
  ---------------------------  Example  ----------------------------
    
    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.
  
  ---------------------------  Example  ----------------------------
    
    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.
  
  ---------------------------  Example  ----------------------------
    
    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))
    
  ------------------------------------------------------------------