Goto Chapter: Top 1 2 3 Bib Ind

### 3 The Ring Table

#### 3.1 An Example for a Ring Table - Singular

todo: introductory text, mention: transposed matrices, the macros, refer to the philosophy

##### 3.1-1 BasisOfRowModule
 ‣ BasisOfRowModule( M ) ( function )

This is the entry of the homalg table, which calls the corresponding macro BasisOfRowModule (3.1-2) inside the computer algebra system.

BasisOfRowModule :=
function( M )
local N;

N := HomalgVoidMatrix(
"unknown_number_of_rows",
NrColumns( M ),
HomalgRing( M )
);

homalgSendBlocking(
[ "matrix ", N, " = BasisOfRowModule(", M, ")" ],
"need_command",
"BasisOfModule"
);

return N;

end,


##### 3.1-2 BasisOfRowModule
 ‣ BasisOfRowModule( M ) ( function )
    BasisOfRowModule := "\n\
proc BasisOfRowModule (matrix M)\n\
{\n\
return(std(M));\n\
}\n\n",


##### 3.1-3 BasisOfColumnModule
 ‣ BasisOfColumnModule( M ) ( function )

This is the entry of the homalg table, which calls the corresponding macro BasisOfColumnModule (3.1-4) inside the computer algebra system.

BasisOfColumnModule :=
function( M )
local N;

N := HomalgVoidMatrix(
NrRows( M ),
"unknown_number_of_columns",
HomalgRing( M )
);

homalgSendBlocking(
[ "matrix ", N, " = BasisOfColumnModule(", M, ")" ],
"need_command",
"BasisOfModule"
);

return N;

end,


##### 3.1-4 BasisOfColumnModule
 ‣ BasisOfColumnModule( M ) ( function )
    BasisOfColumnModule := "\n\
proc BasisOfColumnModule (matrix M)\n\
{\n\
return(Involution(BasisOfRowModule(Involution(M))));\n\
}\n\n",


##### 3.1-5 DecideZeroRows
 ‣ DecideZeroRows( A, B ) ( function )

This is the entry of the homalg table, which calls the corresponding macro DecideZeroRows (3.1-6) inside the computer algebra system. The rows of B must form a basis (see BasisOfRowModule (3.1-1)).

DecideZeroRows :=
function( A, B )
local N;

N := HomalgVoidMatrix(
NrRows( A ),
NrColumns( A ),
HomalgRing( A )
);

homalgSendBlocking(
[ "matrix ", N, " = DecideZeroRows(", A, B, ")" ],
"need_command",
"DecideZero"
);

return N;

end,


##### 3.1-6 DecideZeroRows
 ‣ DecideZeroRows( A, B ) ( function )
    DecideZeroRows := "\n\
proc DecideZeroRows (matrix A, module B)\n\
{\n\
attrib(B,\"isSB\",1);\n\
return(reduce(A,B));\n\
}\n\n",


##### 3.1-7 DecideZeroColumns
 ‣ DecideZeroColumns( A, B ) ( function )

This is the entry of the homalg table, which calls the corresponding macro DecideZeroColumns (3.1-8) inside the computer algebra system. The columns of B must form a basis (see BasisOfColumnModule (3.1-3)).

DecideZeroColumns :=
function( A, B )
local N;

N := HomalgVoidMatrix(
NrRows( A ),
NrColumns( A ),
HomalgRing( A )
);

homalgSendBlocking(
[ "matrix ", N, " = DecideZeroColumns(", A, B, ")" ],
"need_command",
"DecideZero"
);

return N;

end,


##### 3.1-8 DecideZeroColumns
 ‣ DecideZeroColumns( A, B ) ( function )
    DecideZeroColumns := "\n\
proc DecideZeroColumns (matrix A, matrix B)\n\
{\n\
return(Involution(DecideZeroRows(Involution(A),Involution(B))));\n\
}\n\n",


##### 3.1-9 SyzygiesGeneratorsOfRows
 ‣ SyzygiesGeneratorsOfRows( M ) ( function )

This is the entry of the homalg table, which calls the corresponding macro SyzygiesGeneratorsOfRows (3.1-10) inside the computer algebra system.

SyzygiesGeneratorsOfRows :=
function( M )
local N;

N := HomalgVoidMatrix(
"unknown_number_of_rows",
NrRows( M ),
HomalgRing( M )
);

homalgSendBlocking(
[ "matrix ", N, " = SyzygiesGeneratorsOfRows(", M, ")" ],
"need_command",
"SyzygiesGenerators"
);

return N;

end,


##### 3.1-10 SyzygiesGeneratorsOfRows
 ‣ SyzygiesGeneratorsOfRows( M ) ( function )
    SyzygiesGeneratorsOfRows := "\n\
proc SyzygiesGeneratorsOfRows (matrix M)\n\
{\n\
return(SyzForHomalg(M));\n\
}\n\n",


##### 3.1-11 SyzygiesGeneratorsOfColumns
 ‣ SyzygiesGeneratorsOfColumns( M ) ( function )

This is the entry of the homalg table, which calls the corresponding macro SyzygiesGeneratorsOfColumns (3.1-12) inside the computer algebra system.

SyzygiesGeneratorsOfColumns :=
function( M )
local N;

N := HomalgVoidMatrix(
NrColumns( M ),
"unknown_number_of_columns",
HomalgRing( M )
);

homalgSendBlocking(
[ "matrix ", N, " = SyzygiesGeneratorsOfColumns(", M, ")" ],
"need_command",
"SyzygiesGenerators"
);

return N;

end,


##### 3.1-12 SyzygiesGeneratorsOfColumns
 ‣ SyzygiesGeneratorsOfColumns( M ) ( function )
    SyzygiesGeneratorsOfColumns := "\n\
proc SyzygiesGeneratorsOfColumns (matrix M)\n\
{\n\
return(Involution(SyzForHomalg(Involution(M))));\n\
}\n\n",


##### 3.1-13 BasisOfRowsCoeff
 ‣ BasisOfRowsCoeff( M, T ) ( function )

This is the entry of the homalg table, which calls the corresponding macro BasisOfRowsCoeff (3.1-14) inside the computer algebra system.

BasisOfRowsCoeff :=
function( M, T )
local v, N;

v := homalgStream( HomalgRing( M ) )!.variable_name;

N := HomalgVoidMatrix(
"unknown_number_of_rows",
NrColumns( M ),
HomalgRing( M )
);

homalgSendBlocking(
[ "matrix ", N, T, " = BasisOfRowsCoeff(", M, ")" ],
"need_command",
"BasisCoeff"
);

return N;

end,


##### 3.1-14 BasisOfRowsCoeff
 ‣ BasisOfRowsCoeff( M, T ) ( function )
    BasisOfRowsCoeff := """
proc BasisOfRowsCoeff (matrix M)
{
matrix B = BasisOfRowModule(M);
option(noredSB);
matrix T = lift(M,B);
option(redSB);
return(B,T);
}

""",


##### 3.1-15 BasisOfColumnsCoeff
 ‣ BasisOfColumnsCoeff( M, T ) ( function )

This is the entry of the homalg table, which calls the corresponding macro BasisOfColumnsCoeff (3.1-16) inside the computer algebra system.

BasisOfColumnsCoeff :=
function( M, T )
local v, N;

v := homalgStream( HomalgRing( M ) )!.variable_name;

N := HomalgVoidMatrix(
NrRows( M ),
"unknown_number_of_columns",
HomalgRing( M )
);

homalgSendBlocking(
[ "matrix ", N, T, " = BasisOfColumnsCoeff(", M, ")" ],
"need_command",
"BasisCoeff"
);

return N;

end,


##### 3.1-16 BasisOfColumnsCoeff
 ‣ BasisOfColumnsCoeff( M, T ) ( function )
    BasisOfColumnsCoeff := """
proc BasisOfColumnsCoeff (matrix M)
{
matrix B,T = BasisOfRowsCoeff(Involution(M));
return(Involution(B),Involution(T));
}

""",


##### 3.1-17 DecideZeroRowsEffectively
 ‣ DecideZeroRowsEffectively( A, B, T ) ( function )

This is the entry of the homalg table, which calls the corresponding macro DecideZeroRowsEffectively (3.1-18) inside the computer algebra system. The rows of B must form a basis (see BasisOfRowModule (3.1-1)).

DecideZeroRowsEffectively :=
function( A, B, T )
local v, N;

v := homalgStream( HomalgRing( A ) )!.variable_name;

N := HomalgVoidMatrix(
NrRows( A ),
NrColumns( A ),
HomalgRing( A )
);

homalgSendBlocking(
[ "matrix ", N, T, " = DecideZeroRowsEffectively(", A, B, ")" ],
"need_command",
"DecideZeroEffectively"
);

return N;

end,


##### 3.1-18 DecideZeroRowsEffectively
 ‣ DecideZeroRowsEffectively( A, B, T ) ( function )
    DecideZeroRowsEffectively := """
proc DecideZeroRowsEffectively (matrix A, module B)
{
attrib(B,"isSB",1);
matrix M = reduce(A,B);
matrix T = lift(B,M-A);
return(M,T);
}

""",


##### 3.1-19 DecideZeroColumnsEffectively
 ‣ DecideZeroColumnsEffectively( A, B, T ) ( function )

This is the entry of the homalg table, which calls the corresponding macro DecideZeroColumnsEffectively (3.1-20) inside the computer algebra system. The columns of B must form a basis (see BasisOfColumnModule (3.1-3)).

DecideZeroColumnsEffectively :=
function( A, B, T )
local v, N;

v := homalgStream( HomalgRing( A ) )!.variable_name;

N := HomalgVoidMatrix(
NrRows( A ),
NrColumns( A ),
HomalgRing( A )
);

homalgSendBlocking(
[ "matrix ", N, T, " = DecideZeroColumnsEffectively(", A, B, ")" ],
"need_command",
"DecideZeroEffectively"
);

return N;

end,


##### 3.1-20 DecideZeroColumnsEffectively
 ‣ DecideZeroColumnsEffectively( A, B, T ) ( function )
    DecideZeroColumnsEffectively := """
proc DecideZeroColumnsEffectively (matrix A, matrix B)
{
matrix M,T = DecideZeroRowsEffectively(Involution(A),Involution(B));
return(Involution(M),Involution(T));
}

""",


##### 3.1-21 RelativeSyzygiesGeneratorsOfRows
 ‣ RelativeSyzygiesGeneratorsOfRows( M, M2 ) ( function )

This is the entry of the homalg table, which calls the corresponding macro RelativeSyzygiesGeneratorsOfRows (3.1-22) inside the computer algebra system.

RelativeSyzygiesGeneratorsOfRows :=
function( M, M2 )
local N;

N := HomalgVoidMatrix(
"unknown_number_of_rows",
NrRows( M ),
HomalgRing( M )
);

homalgSendBlocking(
[ "matrix ", N, " = RelativeSyzygiesGeneratorsOfRows(", M, M2, ")" ],
"need_command",
"SyzygiesGenerators"
);

return N;

end,


##### 3.1-22 RelativeSyzygiesGeneratorsOfRows
 ‣ RelativeSyzygiesGeneratorsOfRows( M, M2 ) ( function )
    RelativeSyzygiesGeneratorsOfRows := "\n\
proc RelativeSyzygiesGeneratorsOfRows (matrix M1, matrix M2)\n\
{\n\
return(BasisOfRowModule(modulo(M1, M2)));\n\
}\n\n",


##### 3.1-23 RelativeSyzygiesGeneratorsOfColumns
 ‣ RelativeSyzygiesGeneratorsOfColumns( M, M2 ) ( function )

This is the entry of the homalg table, which calls the corresponding macro RelativeSyzygiesGeneratorsOfColumns (3.1-24) inside the computer algebra system.

RelativeSyzygiesGeneratorsOfColumns :=
function( M, M2 )
local N;

N := HomalgVoidMatrix(
NrColumns( M ),
"unknown_number_of_columns",
HomalgRing( M )
);

homalgSendBlocking(
[ "matrix ", N, " = RelativeSyzygiesGeneratorsOfColumns(", M, M2, ")" ],
"need_command",
"SyzygiesGenerators"
);

return N;

end,


##### 3.1-24 RelativeSyzygiesGeneratorsOfColumns
 ‣ RelativeSyzygiesGeneratorsOfColumns( M, M2 ) ( function )
    RelativeSyzygiesGeneratorsOfColumns := "\n\
proc RelativeSyzygiesGeneratorsOfColumns (matrix M1, matrix M2)\n\
{\n\
return(Involution(RelativeSyzygiesGeneratorsOfRows(Involution(M1),Involution(M2))));\n\
}\n\n",


##### 3.1-25 ReducedSyzygiesGeneratorsOfRows
 ‣ ReducedSyzygiesGeneratorsOfRows( M ) ( function )

This is the entry of the homalg table, which calls the corresponding macro ReducedSyzygiesGeneratorsOfRows (3.1-26) inside the computer algebra system.

ReducedSyzygiesGeneratorsOfRows :=
function( M )
local N;

N := HomalgVoidMatrix(
"unknown_number_of_rows",
NrRows( M ),
HomalgRing( M )
);

homalgSendBlocking(
[ "matrix ", N, " = ReducedSyzygiesGeneratorsOfRows(", M, ")" ],
"need_command",
"SyzygiesGenerators"
);

return N;

end,


##### 3.1-26 ReducedSyzygiesGeneratorsOfRows
 ‣ ReducedSyzygiesGeneratorsOfRows( M ) ( function )
    ReducedSyzForHomalg := "\n\
proc ReducedSyzForHomalg (matrix M)\n\
{\n\
return(matrix(nres(M,2)[2]));\n\
}\n\n",
ReducedSyzygiesGeneratorsOfRows := "\n\
proc ReducedSyzygiesGeneratorsOfRows (matrix M)\n\
{\n\
return(ReducedSyzForHomalg(M));\n\
}\n\n",


##### 3.1-27 ReducedSyzygiesGeneratorsOfColumns
 ‣ ReducedSyzygiesGeneratorsOfColumns( M ) ( function )

This is the entry of the homalg table, which calls the corresponding macro ReducedSyzygiesGeneratorsOfColumns (3.1-28) inside the computer algebra system.

ReducedSyzygiesGeneratorsOfColumns :=
function( M )
local N;

N := HomalgVoidMatrix(
NrColumns( M ),
"unknown_number_of_columns",
HomalgRing( M )
);

homalgSendBlocking(
[ "matrix ", N, " = ReducedSyzygiesGeneratorsOfColumns(", M, ")" ],
"need_command",
"SyzygiesGenerators"
);

return N;

end,


##### 3.1-28 ReducedSyzygiesGeneratorsOfColumns
 ‣ ReducedSyzygiesGeneratorsOfColumns( M ) ( function )
    ReducedSyzygiesGeneratorsOfColumns := "\n\
proc ReducedSyzygiesGeneratorsOfColumns (matrix M)\n\
{\n\
return(Involution(ReducedSyzForHomalg(Involution(M))));\n\
}\n\n",

Goto Chapter: Top 1 2 3 Bib Ind

generated by GAPDoc2HTML