| products/Sources/formale Sprachen/GAP/pkg/wedderga/doc/chap5.html |
 |
<?xml version= "1.0" encoding= "UTF-8"?>
<! DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
< html xmlns= "http://www.w3.org/1999/xhtml" xml:lang= "en">
< head>
< title>GAP (Wedderga) - Chapter 5: Crossed products and their elements</ title>
< meta http-equiv= "content-type" content= "text/html; charset=UTF-8" />
< meta name= "generator" content= "GAPDoc2HTML" />
< link rel= "stylesheet" type= "text/css" href= "manual.css" />
< script src= "manual.js" type= "text/javascript"></ script>
< script type= "text/javascript">overwriteStyle();</ script>
</ head>
< body class= "chap5" onload= "jscontent()">
< div class= "chlinktop">< span class= "chlink1">Goto Chapter: </ span>< a href= "chap0.html">Top</ a> < a href="chap1.html">1</a> <a href="chap2.html">2</a> <a href="chap3.html">3</a> <a href="chap4.html">4</a> <a href="chap5.html">5</a> <a href="chap6.html">6</a> <a href="chap7.html">7</a> <a href="chap8.html">8</a> <a href="chap9.html">9</a> <a href="chapBib.html">Bib</a> <a href="chapInd.html">Ind</a> </div>
<div class="chlinkprevnexttop"> <a href="chap0.html">[Top of Book]</a> <a href="chap0.html#contents">[Contents]</a> <a href="chap4.html">[Previous Chapter]</a> <a href="chap6.html">[Next Chapter]</a> </div>
<p id="mathjaxlink" class="pcenter"><a href="chap5_mj.html">[MathJax on]</a></p>
<p><a id="X812A5A097EADEB5E" name="X812A5A097EADEB5E"></a></p>
<div class="ChapSects"><a href="chap5.html#X812A5A097EADEB5E">5 <span class="Heading">Crossed products and their elements</span></a>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap5.html#X79122C7F877430A7">5.1 <span class="Heading">Construction of crossed products</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X797F31EF7B51A4DF">5.1-1 CrossedProduct</a></span>
</div></div>
<div class="ContSect"><span class="tocline"><span class="nocss"> </span><a href="chap5.html#X8560A2F37B608A9F">5.2 <span class="Heading">Crossed product elements and their properties</span></a>
</span>
<div class="ContSSBlock">
<span class="ContSS"><br /><span class="nocss"> </span><a href="chap5.html#X7D2313AA82F1D5CC">5.2-1 ElementOfCrossedProduct</a></span>
</div></div>
</div>
<h3>5 <span class="Heading">Crossed products and their elements</span></h3>
<p>The package <strong class="pkg">Wedderga</strong> 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 <a href="chap9.html#X7FB21779832CE1CB"><span class="RefLink">9.6</span></a> for definitions). This can be done using the function <code class="func">CrossedProduct</code> (<a href="chap5.html#X797F31EF7B51A4DF"><span class="RefLink">5.1-1</span></a>).</p>
<p>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 <strong class="pkg">Wedderga</strong> 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.</p>
<p><a id="X79122C7F877430A7" name="X79122C7F877430A7"></a></p>
<h4>5.1 <span class="Heading">Construction of crossed products</span></h4>
<p><a id="X797F31EF7B51A4DF" name="X797F31EF7B51A4DF"></a></p>
<h5>5.1-1 CrossedProduct</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">an style='color: green'>8227; CrossedProduct</code>( <var class="Arg">R</var>, <var class="Arg">G</var>, <var class="Arg">act</var>, <var class="Arg">twist</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: Ring in the category <code class="code">IsCrossedProduct</code>.</p>
<p>The input should be formed by:</p>
<ul>
<li><p>an associative ring <var class="Arg">R</var>,</p>
</li>
<li><p>a group <var class="Arg">G</var>,</p>
</li>
<li><p>a function <var class="Arg">act(RG,g)</var> of two arguments: the crossed product <var class="Arg">RG</var> and an element <var class="Arg">g</var> in <span class="SimpleMath">G</span>. It must return a mapping from <var class="Arg">R</var> to <var class="Arg">R</var> which can be applied via the "<code class="code">\^</code>" operation, and</p>
</li>
<li><p>a function <var class="Arg">twist(RG,g,h)</var> of three arguments: the crossed product <var class="Arg">RG</var> and a pair of elements of <var class="Arg">G</var>. It must return an invertible element of <var class="Arg">R</var>.</p>
</li>
</ul>
<p>Returns the crossed product of <var class="Arg">G</var> over the ring <var class="Arg">R</var> with action <var class="Arg">act</var> and twisting <var class="Arg">twist</var>.</p>
<p>The resulting crossed product belongs to the category <code class="code">IsCrossedProduct</code>, which is defined as a subcategory of <code class="code">IsFLMLORWithOne</code>.</p>
<p>An example of the trivial action:</p>
<div class="example"><pre>
act := function(RG,a)
return IdentityMapping( LeftActingDomain( RG ) );
end;
</pre></div>
<p>and the trivial twisting:</p>
<div class="example"><pre>
twist := function( RG , g, h )
return One( LeftActingDomain( RG ) );
end;
</pre></div>
<p>Let <span class="SimpleMath">n</span> be a positive integer and <span class="SimpleMath">ξ_n</span> an <span class="SimpleMath">n</span>-th complex primitive root of unity. The natural action of the group of units of <span class="SimpleMath">ℤ_n</span>, the ring of integers modulo <span class="SimpleMath">n</span>, on <span class="SimpleMath">ℚ (ξ_n)</span> can be defined as follows:</p>
<div class="example"><pre>
act := function(RG,a)
return ANFAutomorhism( LeftActingDomain( RG ) , Int( a ) );
end;
</pre></div>
<p>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 <span class="SimpleMath">ℚ (i)=GaussianRationals</span>. One realizes the cyclic group of order 2 as the group of units of <span class="SimpleMath">ℤ / 4 ℤ</span> and one uses the natural isomorphism <span class="SimpleMath">ℤ / 4 ℤ → Gal( ℚ (i)/ ℚ )</span> to describe the action.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">R := GaussianRationals;</span>
GaussianRationals
<span class="GAPprompt">gap></span> <span class="GAPinput">G := Units( ZmodnZ(4) );; Size( G );</span>
2
<span class="GAPprompt">gap></span> <span class="GAPinput">act := function(RG,g)</span>
<span class="GAPprompt">></span> <span class="GAPinput">return ANFAutomorphism( LeftActingDomain(RG), Int(g) );</span>
<span class="GAPprompt">></span> <span class="GAPinput">end;</span>
function( RG, g ) ... end
<span class="GAPprompt">gap></span> <span class="GAPinput">twist1 := function( RG, g, h )</span>
<span class="GAPprompt">></span> <span class="GAPinput">if IsOne(g) or IsOne(h) then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return One(LeftActingDomain(RG));</span>
<span class="GAPprompt">></span> <span class="GAPinput">else</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return -One(LeftActingDomain(RG));</span>
<span class="GAPprompt">></span> <span class="GAPinput">fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput">end;</span>
function( RG, g, h ) ... end
<span class="GAPprompt">gap></span> <span class="GAPinput">RG := CrossedProduct( R, G, act, twist1 );</span>
<crossed product over GaussianRationals of a group of size 2>
<span class="GAPprompt">gap></span> <span class="GAPinput">i := E(4) * One(G)^Embedding(G,RG); </span>
(ZmodnZObj( 1, 4 ))*(E(4))
<span class="GAPprompt">gap></span> <span class="GAPinput">j := ZmodnZObj(3,4)^Embedding(G,RG); </span>
(ZmodnZObj( 3, 4 ))*(1)
<span class="GAPprompt">gap></span> <span class="GAPinput">i^2;</span>
(ZmodnZObj( 1, 4 ))*(-1)
<span class="GAPprompt">gap></span> <span class="GAPinput">j^2;</span>
(ZmodnZObj( 1, 4 ))*(-1)
<span class="GAPprompt">gap></span> <span class="GAPinput">i*j+j*i; </span>
<zero> of ...
</pre></div>
<p>One can construct the following generalized quaternion algebra with the same action and a different twisting</p>
<p class="pcenter">
ℚ (i,j|i^2=-1,j^2=-3,ji=-ij)
</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">twist2:=function(RG,g,h)</span>
<span class="GAPprompt">></span> <span class="GAPinput">if IsOne(g) or IsOne(h) then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return One(LeftActingDomain( RG ));</span>
<span class="GAPprompt">></span> <span class="GAPinput">else</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return -3*One(LeftActingDomain( RG ));</span>
<span class="GAPprompt">></span> <span class="GAPinput">fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput">end;</span>
function( RG, g, h ) ... end
<span class="GAPprompt">gap></span> <span class="GAPinput">RG := CrossedProduct( R, G, act, twist2 ); </span>
<crossed product over GaussianRationals of a group of size 2>
<span class="GAPprompt">gap></span> <span class="GAPinput">i := E(4) * One(G)^Embedding(G,RG); </span>
(ZmodnZObj( 1, 4 ))*(E(4))
<span class="GAPprompt">gap></span> <span class="GAPinput">j := ZmodnZObj(3,4)^Embedding(G,RG); </span>
(ZmodnZObj( 3, 4 ))*(1)
<span class="GAPprompt">gap></span> <span class="GAPinput">i^2; </span>
(ZmodnZObj( 1, 4 ))*(-1)
<span class="GAPprompt">gap></span> <span class="GAPinput">j^2; </span>
(ZmodnZObj( 1, 4 ))*(-3)
<span class="GAPprompt">gap></span> <span class="GAPinput">i*j+j*i; </span>
<zero> of ...
</pre></div>
<p>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.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">C2 := CyclicGroup(2);;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := DirectProduct(C2,C2);</span>
<pc group of size 4 with 2 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">act := function(RG,a)</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return IdentityMapping( LeftActingDomain(RG));</span>
<span class="GAPprompt">></span> <span class="GAPinput">end;</span>
function( RG, a ) ... end
<span class="GAPprompt">gap></span> <span class="GAPinput">twist := function( RG, g , h )</span>
<span class="GAPprompt">></span> <span class="GAPinput">local one,g1,g2,h1,h2,G;</span>
<span class="GAPprompt">></span> <span class="GAPinput">G := UnderlyingMagma( RG );</span>
<span class="GAPprompt">></span> <span class="GAPinput">one := One( C2 );</span>
<span class="GAPprompt">></span> <span class="GAPinput">g1 := Image( Projection(G,1), g );</span>
<span class="GAPprompt">></span> <span class="GAPinput">g2 := Image( Projection(G,2), g );</span>
<span class="GAPprompt">></span> <span class="GAPinput">h1 := Image( Projection(G,1), h );</span>
<span class="GAPprompt">></span> <span class="GAPinput">h2 := Image( Projection(G,2), h );</span>
<span class="GAPprompt">></span> <span class="GAPinput">if g = One( G ) or h = One( G ) then return 1;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> elif IsOne(g1) and not IsOne(g2) and not IsOne(h1) and not IsOne(h2)</span>
<span class="GAPprompt">></span> <span class="GAPinput"> then return 1;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> elif not IsOne(g1) and IsOne(g2) and IsOne(h1) and not IsOne(h2)</span>
<span class="GAPprompt">></span> <span class="GAPinput"> then return 1;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> elif not IsOne(g1) and not IsOne(g2) and not IsOne(h1) and IsOne(h2)</span>
<span class="GAPprompt">></span> <span class="GAPinput"> then return 1;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> else return -1;</span>
<span class="GAPprompt">></span> <span class="GAPinput">fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput">end;</span>
function( RG, g, h ) ... end
<span class="GAPprompt">gap></span> <span class="GAPinput">HQ := CrossedProduct( Rationals, G, act, twist );</span>
<crossed product over Rationals of a group of size 4>
</pre></div>
<p>Changing the rationals by the integers as coefficient ring one can construct the Hamiltonian quaternion ring.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">HZ := CrossedProduct( Integers, G, act, twist );</span>
<crossed product over Integers of a group of size 4>
<span class="GAPprompt">gap></span> <span class="GAPinput">i := GeneratorsOfGroup(G)[1]^Embedding(G,HZ); </span>
(f1)*(1)
<span class="GAPprompt">gap></span> <span class="GAPinput">j := GeneratorsOfGroup(G)[2]^Embedding(G,HZ);</span>
(f2)*(1)
<span class="GAPprompt">gap></span> <span class="GAPinput">i^2;</span>
(<identity> of ...)*(-1)
<span class="GAPprompt">gap></span> <span class="GAPinput">j^2; </span>
(<identity> of ...)*(-1)
<span class="GAPprompt">gap></span> <span class="GAPinput">i*j+j*i; </span>
<zero> of ...
</pre></div>
<p>One can extract the arguments used for the construction of the crossed product using the following attributes:</p>
<p>* <code class="code">LeftActingDomain</code> for the coefficient ring.</p>
<p>* <code class="code">UnderlyingMagma</code> for the underlying group.</p>
<p>* <code class="code">ActionForCrossedProduct</code> for the action.</p>
<p>* <code class="code">TwistingForCrossedProduct</code> for the twisting.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">LeftActingDomain(HZ);</span>
Integers
<span class="GAPprompt">gap></span> <span class="GAPinput">G:=UnderlyingMagma(HZ);</span>
<pc group of size 4 with 2 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">ac := ActionForCrossedProduct(HZ);</span>
function( RG, a ) ... end
<span class="GAPprompt">gap></span> <span class="GAPinput">List( G , x -> ac( HZ, x ) );</span>
[ IdentityMapping( Integers ), IdentityMapping( Integers ),
IdentityMapping( Integers ), IdentityMapping( Integers ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">tw := TwistingForCrossedProduct( HZ );</span>
function( RG, g, h ) ... end
<span class="GAPprompt">gap></span> <span class="GAPinput">List( G, x -> List( G , y -> tw( HZ, x, y ) ) );</span>
[ [ 1, 1, 1, 1 ], [ 1, -1, -1, 1 ], [ 1, 1, -1, -1 ], [ 1, -1, 1, -1 ] ]
</pre></div>
<p>Some more examples of crossed products arise from the <em>Wedderburn decomposition</em> (<a href="chap9.html#X84BB4A6081EAE905"><span class="RefLink">9.3</span></a>) of group algebras.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := SmallGroup(32,50);</span>
<pc group of size 32 with 5 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">A := SimpleAlgebraByCharacter( GroupRing(Rationals,G), Irr(G)[17]) ;</span>
( <crossed product with center Rationals over GaussianRationals of a group of \
size 2>^[ 2, 2 ] )
<span class="GAPprompt">gap></span> <span class="GAPinput">SimpleAlgebraByCharacterInfo( GroupRing(Rationals,G), Irr(G)[17]) ;</span>
[ 2, Rationals, 4, [ 2, 3, 2 ] ]
<span class="GAPprompt">gap></span> <span class="GAPinput">B := LeftActingDomain(A);</span>
<crossed product with center Rationals over GaussianRationals of a group of si\
ze 2>
<span class="GAPprompt">gap></span> <span class="GAPinput">L := LeftActingDomain(B);</span>
GaussianRationals
<span class="GAPprompt">gap></span> <span class="GAPinput">H := UnderlyingMagma( B );</span>
<group of size 2 with 2 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">Elements(H);</span>
[ ZmodnZObj( 1, 4 ), ZmodnZObj( 3, 4 ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">i := E(4) * One(H)^Embedding(H,B);</span>
(ZmodnZObj( 1, 4 ))*(E(4))
<span class="GAPprompt">gap></span> <span class="GAPinput">j := ZmodnZObj(3,4)^Embedding(H,B);</span>
(ZmodnZObj( 3, 4 ))*(1)
<span class="GAPprompt">gap></span> <span class="GAPinput">i^2;</span>
(ZmodnZObj( 1, 4 ))*(-1)
<span class="GAPprompt">gap></span> <span class="GAPinput">j^2;</span>
(ZmodnZObj( 1, 4 ))*(-1)
<span class="GAPprompt">gap></span> <span class="GAPinput">i*j+j*i;</span>
<zero> of ...
<span class="GAPprompt">gap></span> <span class="GAPinput">ac := ActionForCrossedProduct( B );</span>
function( RG, a ) ... end
<span class="GAPprompt">gap></span> <span class="GAPinput">tw := TwistingForCrossedProduct( B );</span>
function( RG, a, b ) ... end
<span class="GAPprompt">gap></span> <span class="GAPinput">List( H , x -> ac( B, x ) );</span>
[ IdentityMapping( GaussianRationals ), ANFAutomorphism( GaussianRationals,
3 ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">List( H , x -> List( H , y -> tw( B, x, y ) ) );</span>
[ [ 1, 1 ], [ 1, -1 ] ]
</pre></div>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">QG:=GroupRing( Rationals, SmallGroup(24,3) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">WedderburnDecomposition(QG);</span>
[ 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> ]
<span class="GAPprompt">gap></span> <span class="GAPinput">R:=WedderburnDecomposition( QG )[4];</span>
<crossed product with center Rationals over GaussianRationals of a group of si\
ze 2>
<span class="GAPprompt">gap></span> <span class="GAPinput">IsCrossedProduct(R);</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">IsAlgebra(R);</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">IsRing(R); </span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">LeftActingDomain( R );</span>
GaussianRationals
<span class="GAPprompt">gap></span> <span class="GAPinput">AsList( UnderlyingMagma( R ) );</span>
[ ZmodnZObj( 1, 4 ), ZmodnZObj( 3, 4 ) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">Print( ActionForCrossedProduct( R ) ); Print("\n");</span>
function ( RG, a )
local cond, redu;
cond := OperationRecord( RG ).cond;
redu := OperationRecord( RG ).redu;
return
ANFAutomorphism( CF( cond ), Int( PreImagesRepresentativeNC( redu, a ) ) );
end
<span class="GAPprompt">gap></span> <span class="GAPinput">Print( TwistingForCrossedProduct( R ) ); Print("\n"); </span>
function ( RG, a, b )
local orderroot, cocycle;
orderroot := OperationRecord( RG ).orderroot;
cocycle := OperationRecord( RG ).cocycle;
return E( orderroot ) ^ Int( cocycle( a, b ) );
end
<span class="GAPprompt">gap></span> <span class="GAPinput">IsAssociative(R);</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">IsFinite(R); </span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">IsFiniteDimensional(R);</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">AsList(Basis(R));</span>
[ (ZmodnZObj( 1, 4 ))*(1), (ZmodnZObj( 3, 4 ))*(1) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">GeneratorsOfLeftOperatorRingWithOne(R);</span>
[ (ZmodnZObj( 1, 4 ))*(1), (ZmodnZObj( 3, 4 ))*(1) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">One(R);</span>
(ZmodnZObj( 1, 4 ))*(1)
<span class="GAPprompt">gap></span> <span class="GAPinput">Zero(R);</span>
<zero> of ...
<span class="GAPprompt">gap></span> <span class="GAPinput">Characteristic(R);</span>
0
<span class="GAPprompt">gap></span> <span class="GAPinput">CenterOfCrossedProduct(R);</span>
Rationals
</pre></div>
<p>The next example shows how one can use <code class="func">CrossedProduct</code> to produce generalized quaternion algebras. Note that one can construct quaternion algebras using the <strong class="pkg">GAP</strong> function <code class="code">QuaternionAlgebra</code>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">Quat := function(R,a,b)</span>
<span class="GAPprompt">></span> <span class="GAPinput">local G,act,twist;</span>
<span class="GAPprompt">></span> <span class="GAPinput">if not(a in R and b in R and a <> Zero(R) and b <> Zero(R) ) then</span>
<span class="GAPprompt">></span> <span class="GAPinput">Error("<a> and <b> must be non zero elements of <R>!!!");</span>
<span class="GAPprompt">></span> <span class="GAPinput">fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput">G := SmallGroup(4,2);</span>
<span class="GAPprompt">></span> <span class="GAPinput">act := function(RG,a)</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return IdentityMapping( LeftActingDomain(RG));</span>
<span class="GAPprompt">></span> <span class="GAPinput">end;</span>
<span class="GAPprompt">></span> <span class="GAPinput">twist := function( RG, g , h )</span>
<span class="GAPprompt">></span> <span class="GAPinput">local one,g1,g2;</span>
<span class="GAPprompt">></span> <span class="GAPinput">one := One(G);</span>
<span class="GAPprompt">></span> <span class="GAPinput">g1 := G.1;</span>
<span class="GAPprompt">></span> <span class="GAPinput">g2 := G.2;</span>
<span class="GAPprompt">></span> <span class="GAPinput">if g = one or h = one then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return One(R);</span>
<span class="GAPprompt">></span> <span class="GAPinput">elif g = g1 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if h = g2 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return One(R);</span>
<span class="GAPprompt">></span> <span class="GAPinput"> else</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return a;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput">elif g = g2 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if h = g1 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return -One(R);</span>
<span class="GAPprompt">></span> <span class="GAPinput"> elif h=g2 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return b;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> else</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return -b;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput">else</span>
<span class="GAPprompt">></span> <span class="GAPinput"> if h = g1 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return -b;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> elif h=g2 then</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return b;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> else</span>
<span class="GAPprompt">></span> <span class="GAPinput"> return -a*b;</span>
<span class="GAPprompt">></span> <span class="GAPinput"> fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput">fi;</span>
<span class="GAPprompt">></span> <span class="GAPinput">end;</span>
<span class="GAPprompt">></span> <span class="GAPinput">return CrossedProduct(R,G,act,twist);</span>
<span class="GAPprompt">></span> <span class="GAPinput">end;</span>
function( R, a, b ) ... end
<span class="GAPprompt">gap></span> <span class="GAPinput">HQ := Quat(Rationals,2,3);</span>
<crossed product over Rationals of a group of size 4>
<span class="GAPprompt">gap></span> <span class="GAPinput">G := UnderlyingMagma(HQ);</span>
<pc group of size 4 with 2 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">tw := TwistingForCrossedProduct( HQ );</span>
function( RG, g, h ) ... end
<span class="GAPprompt">gap></span> <span class="GAPinput">List( G, x -> List( G, y -> tw( HQ, x, y ) ) );</span>
[ [ 1, 1, 1, 1 ], [ 1, 3, -1, -3 ], [ 1, 1, 2, 2 ], [ 1, 3, -3, -6 ] ]
</pre></div>
<p><a id="X8560A2F37B608A9F" name="X8560A2F37B608A9F"></a></p>
<h4>5.2 <span class="Heading">Crossed product elements and their properties</span></h4>
<p><a id="X7D2313AA82F1D5CC" name="X7D2313AA82F1D5CC"></a></p>
<h5>5.2-1 ElementOfCrossedProduct</h5>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">an style='color: green'>8227; ElementOfCrossedProduct</code>( <var class="Arg">Fam</var>, <var class="Arg">zerocoeff</var>, <var class="Arg">coeffs</var>, <var class="Arg">elts</var> )</td><td class="tdright">( property )</td></tr></table></div>
<p>Returns the element <span class="SimpleMath">m_1*c_1 + ... + m_n*c_n</span> of a crossed product, where <var class="Arg">elts</var> <span class="SimpleMath">= [ m_1, m_2, ..., m_n ]</span> is a list of magma elements, <var class="Arg">coeffs</var> <span class="SimpleMath">= [ c_1, c_2, ..., c_n ]</span> is a list of coefficients. The output belongs to the crossed product whose elements lie in the family <var class="Arg">Fam</var>. The second argument <var class="Arg">zerocoeff</var> must be the zero element of the coefficient ring containing coefficients <span class="SimpleMath">c_i</span>, and will be stored in the attribute <code class="code">ZeroCoefficient</code> of the crossed product element.</p>
<p>The output will be in the category <code class="code">IsElementOfCrossedProduct</code>, which is a subcategory of <code class="code">IsRingElementWithInverse</code>. It will have the presentation <code class="code">IsCrossedProductObjDefaultRep</code>.</p>
<p>Similarly to magma rings, one can obtain the list of coefficients and elements with <code class="code">CoefficientsAndMagmaElements</code> .</p>
<p>Also note from the example below and several other examples in this chapter that instead of <code class="code">ElementOfCrossedProduct</code> one can use <code class="code">Embedding</code> to embed elements of the coefficient ring and of the underlying magma into the crossed product.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">QG := GroupRing( Rationals, SmallGroup(24,3) );</span>
<algebra-with-one over Rationals, with 4 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">R := WedderburnDecomposition( QG )[4];</span>
<crossed product with center Rationals over GaussianRationals of a group of si\
ze 2>
<span class="GAPprompt">gap></span> <span class="GAPinput">H := UnderlyingMagma( R );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">fam := ElementsFamily( FamilyObj( R ) );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">g := ElementOfCrossedProduct( fam, 0, [ 1, E(4) ], AsList(H) );</span>
(ZmodnZObj( 1, 4 ))*(1)+(ZmodnZObj( 3, 4 ))*(E(4))
<span class="GAPprompt">gap></span> <span class="GAPinput">CoefficientsAndMagmaElements( g ); </span>
[ ZmodnZObj( 1, 4 ), 1, ZmodnZObj( 3, 4 ), E(4) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">t := List( H, x -> x^Embedding( H, R ) );</span>
[ (ZmodnZObj( 1, 4 ))*(1), (ZmodnZObj( 3, 4 ))*(1) ]
<span class="GAPprompt">gap></span> <span class="GAPinput">t[1] + t[2]*E(4); </span>
(ZmodnZObj( 1, 4 ))*(1)+(ZmodnZObj( 3, 4 ))*(E(4))
<span class="GAPprompt">gap></span> <span class="GAPinput">g = t[1] + E(4)*t[2];</span>
false
<span class="GAPprompt">gap></span> <span class="GAPinput">g = t[1] + t[2]*E(4);</span>
true
<span class="GAPprompt">gap></span> <span class="GAPinput">h := ElementOfCrossedProduct( fam, 0, [ E(4), 1 ], AsList(H) ); </span>
(ZmodnZObj( 1, 4 ))*(E(4))+(ZmodnZObj( 3, 4 ))*(1)
<span class="GAPprompt">gap></span> <span class="GAPinput">g+h;</span>
(ZmodnZObj( 1, 4 ))*(1+E(4))+(ZmodnZObj( 3, 4 ))*(1+E(4))
<span class="GAPprompt">gap></span> <span class="GAPinput">g*E(4);</span>
(ZmodnZObj( 1, 4 ))*(E(4))+(ZmodnZObj( 3, 4 ))*(-1)
<span class="GAPprompt">gap></span> <span class="GAPinput">E(4)*g; </span>
(ZmodnZObj( 1, 4 ))*(E(4))+(ZmodnZObj( 3, 4 ))*(1)
<span class="GAPprompt">gap></span> <span class="GAPinput">g*h;</span>
(ZmodnZObj( 1, 4 ))*(2*E(4))
</pre></div>
<div class="chlinkprevnextbot"> <a href="chap0.html">[Top of Book]</a> <a href="chap0.html#contents">[Contents]</a> <a href="chap4.html">[Previous Chapter]</a> <a href="chap6.html">[Next Chapter]</a> </div>
<div class="chlinkbot"><span class="chlink1">Goto Chapter: </span><a href="chap0.html">Top</a> <a href="chap1.html">1</a> <a href="chap2.html">2</a> <a href="chap3.html">3</a> <a href="chap4.html">4</a> <a href="chap5.html">5</a> <a href="chap6.html">6</a> <a href="chap7.html">7</a> <a href="chap8.html">8</a> <a href="chap9.html">9</a> <a href="chapBib.html">Bib</a> <a href="chapInd.html">Ind</a> </div>
<hr />
<p class="foot">generated by <a href="https://www.math.rwth-aachen.de/~Frank.Luebeck/GAPDoc">GAPDoc2HTML</a></p>
</body>
</html>
¤ Dauer der Verarbeitung: 0.112 Sekunden
¤
*© Formatika GbR, Deutschland
|
|