<p>A <strong class="pkg">homalg</strong> module is a data structure for a finitely presented module. A presentation is given by a set of generators and a set of relations among these generators. The data structure for modules in <strong class="pkg">homalg</strong> has two novel features:</p>
<ul>
<li><p>The data structure allows several presentations linked with so-called transition matrices. One of the presentations is marked as the default presentation, which is usually the last added one. A new presentation can always be added provided it is linked to the default presentation by a transition matrix. If needed, the user can reset the default presentation by choosing one of the other presentations saved in the data structure of the <strong class="pkg">homalg</strong> module. Effectively, a module is then given by <q>all</q> its presentations (as <q>coordinates</q>) together with isomorphisms between them (as <q>coordinate changes</q>). Being able to <q>change coordinates</q> makes the realization of a module in <strong class="pkg">homalg</strong> <em>intrinsic</em> (or <q>coordinate free</q>).</p>
</li>
<li><p>To present a left/right module it suffices to take a matrix <var class="Arg">M</var> and interpret its rows/columns as relations among <span class="SimpleMath">\(n\)</span> <em>abstract</em> generators, where <span class="SimpleMath">\(n\)</span> is the number of columns/rows of <var class="Arg">M</var>. Only that these abstract generators are useless when it comes to specific modules like modules of homomorphisms, where one expects the generators to be maps between modules. For this reason a presentation of a module in <strong class="pkg">homalg</strong> is not merely a matrix of relations, but together with a set of generators.</p>
<p>The <strong class="pkg">GAP</strong> category of <strong class="pkg">homalg</strong> modules.</p>
<p>(It is a subcategory of the <strong class="pkg">GAP</strong> categories <code class="code">IsHomalgRingOrModule</code> and <code class="code">IsHomalgStaticObject</code>.)</p>
<div class="example"><pre>
DeclareCategory( "IsHomalgModule",
IsHomalgRingOrModule and
IsHomalgModuleOrMap and
IsHomalgStaticObject );
</pre></div>
<p>The <strong class="pkg">GAP</strong> representation of finitley presented <strong class="pkg">homalg</strong> modules or submodules.</p>
<p>(It is a representation of the <strong class="pkg">GAP</strong> category <code class="func">IsHomalgModule</code> (<a href="chap7_mj.html#X8429977B7FD30F32"><span class="RefLink">7.1-1</span></a>), which is a subrepresentation of the <strong class="pkg">GAP</strong> representations <code class="code">IsStaticFinitelyPresentedObjectOrSubobjectRep</code>.)</p>
<p>The <strong class="pkg">GAP</strong> representation of finitley presented <strong class="pkg">homalg</strong> modules.</p>
<p>(It is a representation of the <strong class="pkg">GAP</strong> category <code class="func">IsHomalgModule</code> (<a href="chap7_mj.html#X8429977B7FD30F32"><span class="RefLink">7.1-1</span></a>), which is a subrepresentation of the <strong class="pkg">GAP</strong> representations <code class="code">IsFinitelyPresentedModuleOrSubmoduleRep</code>, <code class="code">IsStaticFinitelyPresentedObjectRep</code>, and <code class="code">IsHomalgRingOrFinitelyPresentedModuleRep</code>.)</p>
<div class="example"><pre>
DeclareRepresentation( "IsFinitelyPresentedModuleRep",
IsFinitelyPresentedModuleOrSubmoduleRep and
IsStaticFinitelyPresentedObjectRep and
IsHomalgRingOrFinitelyPresentedModuleRep,
[ "SetsOfGenerators", "SetsOfRelations", "PresentationMorphisms", "Resolutions", "TransitionMatrices", "PositionOfTheDefaultPresentation" ] );
</pre></div>
<p>The <strong class="pkg">GAP</strong> representation of finitley generated <strong class="pkg">homalg</strong> submodules.</p>
<p>(It is a representation of the <strong class="pkg">GAP</strong> category <code class="func">IsHomalgModule</code> (<a href="chap7_mj.html#X8429977B7FD30F32"><span class="RefLink">7.1-1</span></a>), which is a subrepresentation of the <strong class="pkg">GAP</strong> representations <code class="code">IsFinitelyPresentedModuleOrSubmoduleRep</code>, <code class="code">IsStaticFinitelyPresentedSubobjectRep</code>, and <code class="code">IsHomalgRingOrFinitelyPresentedModuleRep</code>.)</p>
<div class="example"><pre>
DeclareRepresentation( "IsFinitelyPresentedSubmoduleRep",
IsFinitelyPresentedModuleOrSubmoduleRep and
IsStaticFinitelyPresentedSubobjectRep and
IsHomalgRingOrFinitelyPresentedModuleRep,
[ "map_having_subobject_as_its_image" ] );
</pre></div>
<p>This constructor returns the finitely presented left module with relations given by the rows of the <strong class="pkg">homalg</strong> matrix <var class="Arg">mat</var>.</p>
currently represented by the above matrix
<span class="GAPprompt">gap></span> <span class="GAPinput">ByASmallerPresentation( M );</span>
<A rank 1 left module presented by 1 relation for 2 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">Display( last );</span>
Z/< 3 > + Z^(1 x 1)
</pre></div>
<p>This constructor returns the finitely presented right module with relations given by the columns of the <strong class="pkg">homalg</strong> matrix <var class="Arg">mat</var>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">zz := HomalgRingOfIntegers( );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">M := HomalgMatrix( "[ \
<span class="GAPprompt">></span> <span class="GAPinput">2, 3, 4, \</span>
<span class="GAPprompt">></span> <span class="GAPinput">5, 6, 7 \</span>
<span class="GAPprompt">></span> <span class="GAPinput">]", 2, 3, zz );
<A 2 x 3 matrix over an internal ring>
<span class="GAPprompt">gap></span> <span class="GAPinput">M := RightPresentation( M );</span>
<A right module on 2 generators satisfying 3 relations>
<span class="GAPprompt">gap></span> <span class="GAPinput">ByASmallerPresentation( M );</span>
<A cyclic torsion right module on a cyclic generator satisfying 1 relation>
<span class="GAPprompt">gap></span> <span class="GAPinput">Display( last );</span>
Z/< 3 >
</pre></div>
<p>This constructor returns a free left module of rank <var class="Arg">r</var> over the <strong class="pkg">homalg</strong> ring <var class="Arg">R</var>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">zz := HomalgRingOfIntegers( );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">F := HomalgFreeLeftModule( 1, zz );</span>
<A free left module of rank 1 on a free generator>
<span class="GAPprompt">gap></span> <span class="GAPinput">1 * zz;</span>
<The free left module of rank 1 on a free generator>
<span class="GAPprompt">gap></span> <span class="GAPinput">F := HomalgFreeLeftModule( 2, zz );</span>
<A free left module of rank 2 on free generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">2 * zz;</span>
<A free left module of rank 2 on free generators>
</pre></div>
<p>This constructor returns a free right module of rank <var class="Arg">r</var> over the <strong class="pkg">homalg</strong> ring <var class="Arg">R</var>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">zz := HomalgRingOfIntegers( );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">F := HomalgFreeRightModule( 1, zz );</span>
<A free right module of rank 1 on a free generator>
<span class="GAPprompt">gap></span> <span class="GAPinput">zz * 1;</span>
<The free right module of rank 1 on a free generator>
<span class="GAPprompt">gap></span> <span class="GAPinput">F := HomalgFreeRightModule( 2, zz );</span>
<A free right module of rank 2 on free generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">zz * 2;</span>
<A free right module of rank 2 on free generators>
</pre></div>
<p>This constructor returns a zero left module of rank <var class="Arg">r</var> over the <strong class="pkg">homalg</strong> ring <var class="Arg">R</var>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">zz := HomalgRingOfIntegers( );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">F := HomalgZeroLeftModule( zz );</span>
<A zero left module>
<span class="GAPprompt">gap></span> <span class="GAPinput">0 * zz;</span>
<The zero left module>
</pre></div>
<p>This constructor returns a zero right module of rank <var class="Arg">r</var> over the <strong class="pkg">homalg</strong> ring <var class="Arg">R</var>.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">zz := HomalgRingOfIntegers( );;</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">F := HomalgZeroRightModule( zz );</span>
<A zero right module>
<span class="GAPprompt">gap></span> <span class="GAPinput">zz * 0;</span>
<The zero right module>
</pre></div>
<p>Transfers the <span class="SimpleMath">\(S\)</span>-module <var class="Arg">M</var> over the <strong class="pkg">homalg</strong> ring <var class="Arg">R</var>. This works only in three cases:</p>
<ol>
<li><p><span class="SimpleMath">\(S\)</span> is a subring of <var class="Arg">R</var>.</p>
</li>
<li><p><var class="Arg">R</var> is a residue class ring of <span class="SimpleMath">\(S\)</span> constructed using <code class="code">/</code>.</p>
</li>
<li><p><var class="Arg">R</var> is a subring of <span class="SimpleMath">\(S\)</span> and the entries of the current matrix of <span class="SimpleMath">\(S\)</span>-relations of <var class="Arg">M</var> lie in <var class="Arg">R</var>.</p>
</li>
</ol>
<p>CAUTION: So it is not suited for general base change.</p>
<div class="example"><pre>
<span class="GAPprompt">gap></span> <span class="GAPinput">zz := HomalgRingOfIntegers( );</span>
Z
<span class="GAPprompt">gap></span> <span class="GAPinput">Display( zz );</span>
<An internal ring>
<span class="GAPprompt">gap></span> <span class="GAPinput">Z4 := zz / 4;</span>
Z/( 4 )
<span class="GAPprompt">gap></span> <span class="GAPinput">Display( Z4 );</span>
<A residue class ring>
<span class="GAPprompt">gap></span> <span class="GAPinput">M := HomalgDiagonalMatrix( [ 2 .. 4 ], zz );</span>
<An unevaluated diagonal 3 x 3 matrix over an internal ring>
<span class="GAPprompt">gap></span> <span class="GAPinput">M := LeftPresentation( M );</span>
<A torsion left module presented by 3 relations for 3 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">Display( M );</span>
Z/< 2 > + Z/< 3 > + Z/< 4 >
<span class="GAPprompt">gap></span> <span class="GAPinput">M;</span>
<A torsion left module presented by 3 relations for 3 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">N := Z4 * M; ## or N := M * Z4;</span>
<A non-torsion left module presented by 2 relations for 3 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">ByASmallerPresentation( N );</span>
<A non-torsion left module presented by 1 relation for 2 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">Display( N );</span>
Z/( 4 )/< |[ 2 ]| > + Z/( 4 )^(1 x 1)
<span class="GAPprompt">gap></span> <span class="GAPinput">N;</span>
<A non-torsion left module presented by 1 relation for 2 generators>
</pre></div>
currently represented by the above matrix
<span class="GAPprompt">gap></span> <span class="GAPinput">d := Resolution( 2, M4 );</span>
<A right acyclic complex containing 2 morphisms of left modules at degrees
[ 0 .. 2 ]>
<span class="GAPprompt">gap></span> <span class="GAPinput">dd := Hom( d, Z4 );</span>
<A cocomplex containing 2 morphisms of right modules at degrees [ 0 .. 2 ]>
<span class="GAPprompt">gap></span> <span class="GAPinput">DD := Resolution( 2, dd );</span>
<A cocomplex containing 2 morphisms of right complexes at degrees [ 0 .. 2 ]>
<span class="GAPprompt">gap></span> <span class="GAPinput">D := Hom( DD, Z4 );</span>
<A complex containing 2 morphisms of left cocomplexes at degrees [ 0 .. 2 ]>
<span class="GAPprompt">gap></span> <span class="GAPinput">C := zz * D;</span>
<A "complex" containing 2 morphisms of left cocomplexes at degrees [ 0 .. 2 ]>
<span class="GAPprompt">gap></span> <span class="GAPinput">LowestDegreeObject( C );</span>
<A "cocomplex" containing 2 morphisms of left modules at degrees [ 0 .. 2 ]>
<span class="GAPprompt">gap></span> <span class="GAPinput">Display( last );</span>
-------------------------
at cohomology degree: 2
0
------------^------------
(an empty 1 x 0 matrix)
the map is currently represented by the above 1 x 0 matrix
-------------------------
at cohomology degree: 1
Z/< 4 >
------------^------------
[ [ 0 ],
[ 1 ],
[ 2 ],
[ 1 ] ]
the map is currently represented by the above 4 x 1 matrix
-------------------------
at cohomology degree: 0
Z/< 4 > + Z/< 4 > + Z/< 4 > + Z/< 4 >
-------------------------
</pre></div>
<p>This constructor returns the finitely generated left/right submodule of the <strong class="pkg">homalg</strong> module <var class="Arg">M</var> with generators given by the rows/columns of the <strong class="pkg">homalg</strong> matrix <var class="Arg">mat</var>.</p>
<p>This constructor returns the finitely generated left/right submodule of the <strong class="pkg">homalg</strong> cyclic left/right module <var class="Arg">M</var> with generators given by the entries of the list <var class="Arg">gens</var>.</p>
<p>This constructor returns the finitely generated left submodule with generators given by the rows of the <strong class="pkg">homalg</strong> matrix <var class="Arg">mat</var>.</p>
<p>This constructor returns the finitely generated right submodule with generators given by the columns of the <strong class="pkg">homalg</strong> matrix <var class="Arg">mat</var>.</p>
<p>Check if the <strong class="pkg">homalg</strong> submodule <var class="Arg">J</var> is a prime ideal. The ring has to be commutative. <br /> (no method installed)</p>
<p>In case <var class="Arg">J</var> was defined as a (left/right) ideal of the ring <span class="SimpleMath">\(R\)</span> the residue class ring <span class="SimpleMath">\(R/\)</span><var class="Arg">J</var> is returned.</p>
<p>The module of Kaehler differentials of the (residue class ring) <var class="Arg">R</var>. <br /> (method installed in package <strong class="pkg">GradedModules</strong>)</p>
<div class="func"><table class="func" width="100%"><tr><td class="tdleft"><code class="func">‣ ElementaryDivisors</code>( <var class="Arg">M</var> )</td><td class="tdright">( attribute )</td></tr></table></div>
<p>Returns: a list of ring elements</p>
<p>The list of elementary divisors of the <strong class="pkg">homalg</strong> module <var class="Arg">M</var>, in case they exist. <br /> (no method installed)</p>
<p>Use different strategies to reduce the presentation of the given <strong class="pkg">homalg</strong> module <var class="Arg">M</var>. This method performs side effects on its argument <var class="Arg">M</var> and returns it.</p>
currently represented by the above matrix
<span class="GAPprompt">gap></span> <span class="GAPinput">ByASmallerPresentation( M );</span>
<A rank 1 left module presented by 1 relation for 2 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">Display( last );</span>
Z/< 3 > + Z^(1 x 1)
<span class="GAPprompt">gap></span> <span class="GAPinput">SetsOfGenerators( M );</span>
<A set containing 2 sets of generators of a homalg module>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetsOfRelations( M );</span>
<A set containing 2 sets of relations of a homalg module>
<span class="GAPprompt">gap></span> <span class="GAPinput">M;</span>
<A rank 1 left module presented by 1 relation for 2 generators>
<span class="GAPprompt">gap></span> <span class="GAPinput">SetPositionOfTheDefaultPresentation( M, 1 );</span>
<span class="GAPprompt">gap></span> <span class="GAPinput">M;</span>
<A rank 1 left module presented by 2 relations for 3 generators>
</pre></div>
<p>Compute the submodule <var class="Arg">J</var><var class="Arg">M</var> (resp. <var class="Arg">M</var><var class="Arg">J</var>) of the given left (resp. right) <span class="SimpleMath">\(R\)</span>-module <var class="Arg">M</var>, where <var class="Arg">J</var> is a left (resp. right) ideal in <span class="SimpleMath">\(R\)</span>.</p>
<p>Compute the submodule quotient ideal <span class="SimpleMath">\(\textit{K}:\textit{J}\)</span> of the submodules <var class="Arg">K</var> and <var class="Arg">J</var> of a common <span class="SimpleMath">\(R\)</span>-module <span class="SimpleMath">\(M\)</span>.</p>
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung ist noch experimentell.
