|
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
The following functions perform fundamental operations on modules.
For binary operations, the modules must be compatible.
Morphism(M, N) : ModMPol, ModMPol -> ModMPolHom
Given modules M and N, return the morphism matrix map from M to N.
If M is a submodule of N, then this matrix map gives the explicit embedding
of M into N, while if N is quotient of M, then this matrix map gives
the explicit epimorphism of M onto N.
Given a module M, return whether M is the zero module.
Given compatible modules M and N, return whether M is a submodule of N.
Given compatible modules M and N, return whether M equals N.
Given compatible modules M and N, return the sum of M and N.
Given compatible modules M and N, return the intersection of M and N.
Given compatible modules M and N, return the quotient module M/N.
This has the same effect as using the quo constructor.
Given R-modules M and N, return the direct sum D = M direct-sum N
and two sequences of corresponding homomorphisms giving the injections
into and projections from D, respectively.
DirectSum(S) : [* ModMPol *] -> ModMPol, [ModMPolHom], [ModMPolHom]
A sequence or list L of R-modules, return their direct sum D and
two sequences of corresponding homomorphisms giving the injections into
and projections from D, respectively.
M * f : ModMPol, RngElt -> ModMPol
Given an R-module M and an element f∈R, return the
submodule of M generated by { f.v: v ∈M }
or { v.f: v ∈M }, respectively.
M * I : ModMPol, RngMPol -> ModMPol
Given an R-module M and an ideal I of R, return the
submodule of M generated by { f.v: f ∈I, v ∈M }
or { v.f: f ∈I, v ∈M }, respectively.
Given an R-module M, return a minimal basis B of M.
If M is graded, or if R is a local ring, then the cardinality
of B (the rank) is guaranteed to be unique (so is the
absolutely minimal number of elements needed to generate M).
Otherwise the cardinality of B is not unique: B will only satisfy
the rule that the i-th element of B is not in the submodule
generated by elements 1 to i - 1 of B.
MinimalBasis(S) : { ModMPolElt } -> [ ModMPolElt ]
Given a set or sequence S of homogeneous module elements from a module
M, return a minimal basis of the submodule of M generated by S.
Rank(M) : ModMPol -> RngIntElt
Given an R-module M, return the rank of M. This is simply
defined to be the cardinality of the minimal basis of M, returned
by the function MinimalBasis. Thus if M is graded, or if
R is a local ring, then the rank is guaranteed to be unique (and
is the absolutely minimal number of elements needed to generate M).
Otherwise the result is not an invariant of M, but simply reflects the
minimum as found by the MinimalBasis algorithm.
Given an R-module M, return whether M is free. M is free
iff M is isomorphic to the module Rk for some k. Such a k need
not equal the degree of M but will equal the rank of M if M is free.
Given an R-module M and an ideal J of R, return the
colon module M:J which is the submodule of the ambient module A of M
consisting of all f∈A such that f.g∈M for all g∈J.
Given an R-modules M and N which are both submodules of a common
supermodule, return the colon ideal M:N, which is the ideal of R
consisting of all f∈R such that f.N ⊂M.
Given an R-module M, return the annihilator ideal of M.
This is the ideal I of R consisting of all f∈R such
that f.M = 0 (which can be seen to equal the ideal 0M : M,
where 0M is the zero submodule of M).
Given an R-module M of degree r and an integer i≥0, return the i-th
Fitting ideal of M, which is the ideal of R generated by
the (r - i)-th minors of the presentation matrix of M, where r
is the degree of M. See [CLO98, p.229] or
[Eis95, Sec. 20.2].
Given an R-module M of degree r, return the Fitting ideals (for
from 0 to r) as a sequence of ideals of R.
Given a module M, and an integer t, return the twisted module M(d)
and an isomorphism f:M -> M(d). The twisted module is simply
an isomorphic copy of M, but with the grading twisted by d (so
d is subtracted from each weight of M).
Given a module M, return the syzygy module S of M. If the basis B of
M has length k, the syzygy module S has degree k and elements of
S express a syzygy amongst the k elements of the basis B. Note that
the degree of the resulting module thus depends on the current basis of M.
Given a homogeneous module M, return the syzygy module S of the
minimal basis of M. If the minimal basis B of
M has length k, the syzygy module S has degree k and elements of
S express a syzygy amongst the k elements of the minimal basis B.
We construct simple submodules and quotient modules of
an embedded module and demonstrate the operations on them.
> R<x, y, z> := PolynomialRing(RationalField(), 3);
> M := EModule(R, 3);
> S := sub<M | [1, x, x^2+y], [z, y, x*y^2+1],
> [y, z, x+z]>;
> Groebner(S);
> S;
Embedded Submodule of R^3
Order: Module TOP: Lexicographical
Groebner basis:
[ -x*z + y^2 + y, x*y^2 - x*y + z, y^3 + z],
[ x*y - y*z - 1, x*z - x - z^2, -y - z^2],
[ y, z, x + z],
[ y^3 - z, y^2*z - y, y^2*z - 1]
> a := M ! [y, z, x+z];
> a;
[y, z, x + z]
> a in S;
true
> BasisElement(S, 1);
[-x*z + y^2 + y, x*y^2 - x*y + z, y^3 + z]
> Q := quo<M | [x, y, z]>;
> Q;
Embedded Module R^3/<relations>
Order: Module TOP: Lexicographical
Relations (Groebner basis):
[x, y, z]
> a := Q![x, y, 0];
> b := Q![0, 0, z];
> a;
[0, 0, -z]
> b;
[0, 0, z]
> a+b;
[0, 0, 0]
> Q ! [x,y,z];
[0, 0, 0]
> QQ := quo<Q | [x^2, 0, y+z]>;
> QQ;
Embedded Module R^3/<relations>
Order: Module TOP: Lexicographical
Relations (Groebner basis):
[ 0, x*y, x*z - y - z],
[ x, y, z]
> SL := Localization(S);
> SL;
Embedded Submodule of R^3 (local)
Order: Module TOP: Local Lexicographical
Basis:
[ 1, x, x^2 + y],
[ z, y, 1 + x*y^2],
[ y, z, x + z]
We construct simple submodules and quotient modules of a reduced module
and demonstrate the operations on them.
> R<x,y,z> := PolynomialRing(RationalField(), 3);
> M := RModule(R, 3);
> S := sub<M | [1, x, x^2+y], [z, y, x*y^2+1]>;
> M;
Free Reduced Module R^3
> S;
Reduced Module R^2/<relations>
> Morphism(S, M);
Module homomorphism (2 by 3)
Ambient matrix:
[ 1 x x^2 + y]
[ z y x*y^2 + 1]
> RelationMatrix(S);
Matrix with 0 rows and 2 columns
> S;
Free Reduced Module R^2
> M.1;
[1, 0, 0]
> M!S.1;
[1, x, x^2 + y]
> M!S.2;
[z, y, x*y^2 + 1]
> M.1 in S;
false
> Q := quo<M | [1, x^2, y]>;
> Q;
Free Reduced Module R^2
> RelationMatrix(Q);
Matrix with 0 rows and 2 columns
> Morphism(M, Q);
Module homomorphism (3 by 2)
Ambient matrix:
[-x^2 -y]
[ 1 0]
[ 0 1]
> Morphism(S, Q);
Module homomorphism (2 by 2)
Ambient matrix:
[ -x^2 + x x^2]
[ -x^2*z + y x*y^2 - y*z + 1]
> Q!M.1;
[-x^2, -y]
> M!Q.1;
[0, 1, 0]
> M!Q.2;
[0, 0, 1]
> Q!M!Q.2;
[0, 1]
In this example we note that a certain module M has rank 3
(equal to its degree 3), since no generator is redundant. If
we move to the localization of M, then (1 + x - z) becomes a unit,
so the first generator becomes redundant.
> R<x,y,z> := PolynomialRing(RationalField(), 3, "grevlex");
> F := RModule(R, 3);
> M := quo<F | [x + 1, y, z], [z, y, 0]>;
> M;
Reduced Module R^3/<relations>
Relations:
[x + 1, y, z],
[ z, y, 0]
> Degree(M);
3
> Rank(M);
3
> ML := Localization(M);
> ML;
Reduced Module R^3/<relations> (local)
Relations:
[1 + x - z, 0, z],
[ z, y, 0]
> Rank(ML);
2
> MinimalBasis(ML);
[
[0, 1, 0],
[0, 0, 1]
]
[Next][Prev] [Right] [Left] [Up] [Index] [Root]
|
