[MathJax off]
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",
      HOMALG_IO.Pictograms.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",
      HOMALG_IO.Pictograms.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.
DecideZeroRows :=
  function( A, B )
    local N;
    
    N := HomalgVoidMatrix(
      NrRows( A ),
      NrColumns( A ),
      HomalgRing( A )
    );
    
    homalgSendBlocking( 
      [ "matrix ", N, " = DecideZeroRows(", A, B, ")" ],
      "need_command",
      HOMALG_IO.Pictograms.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.
DecideZeroColumns :=
  function( A, B )
    local N;
    
    N := HomalgVoidMatrix(
      NrRows( A ),
      NrColumns( A ),
      HomalgRing( A )
    );
    
    homalgSendBlocking(
      [ "matrix ", N, " = DecideZeroColumns(", A, B, ")" ],
      "need_command",
      HOMALG_IO.Pictograms.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",
      HOMALG_IO.Pictograms.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",
      HOMALG_IO.Pictograms.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(
      [
        "list ", v, "l=BasisOfRowsCoeff(", M, "); ",
        "matrix ", N, " = ", v, "l[1]; ",
        "matrix ", T, " = ", v, "l[2]"
      ],
      "need_command",
      HOMALG_IO.Pictograms.BasisCoeff
    );
    
    return N;
    
  end,
3.1-14 BasisOfRowsCoeff
| ‣ BasisOfRowsCoeff( M, T ) | ( function ) | 
    BasisOfRowsCoeff := "\n\
proc BasisOfRowsCoeff (matrix M)\n\
{\n\
  matrix B = BasisOfRowModule(M);\n\
  matrix T = lift(M,B);\n\
  list l = B,T;\n\
  return(l)\n\
}\n\n",
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( 
      [
        "list ", v, "l=BasisOfColumnsCoeff(", M, "); ",
        "matrix ", N, " = ", v, "l[1]; ",
        "matrix ", T, " = ", v, "l[2]"
      ],
      "need_command",
      HOMALG_IO.Pictograms.BasisCoeff
    );
    
    return N;
    
  end,
3.1-16 BasisOfColumnsCoeff
| ‣ BasisOfColumnsCoeff( M, T ) | ( function ) | 
    BasisOfColumnsCoeff := "\n\
proc BasisOfColumnsCoeff (matrix M)\n\
{\n\
  list l = BasisOfRowsCoeff(Involution(M));\n\
  matrix B = l[1];\n\
  matrix T = l[2];\n\
  l = Involution(B),Involution(T);\n\
  return(l);\n\
}\n\n",
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.
DecideZeroRowsEffectively :=
  function( A, B, T )
    local v, N;
    
    v := homalgStream( HomalgRing( A ) )!.variable_name;
    
    N := HomalgVoidMatrix(
      NrRows( A ),
      NrColumns( A ),
      HomalgRing( A )
    );
    
    homalgSendBlocking(
      [
        "list ", v, "l=DecideZeroRowsEffectively(", A, B, "); ",
        "matrix ", N, " = ", v, "l[1]; ",
        "matrix ", T, " = ", v, "l[2]"
      ],
      "need_command",
      HOMALG_IO.Pictograms.DecideZeroEffectively
    );
    
    return N;
    
  end,
3.1-18 DecideZeroRowsEffectively
| ‣ DecideZeroRowsEffectively( A, B, T ) | ( function ) | 
    DecideZeroRowsEffectively := "\n\
proc DecideZeroRowsEffectively (matrix A, module B)\n\
{\n\
  attrib(B,\"isSB\",1);\n\
  matrix M = reduce(A,B);\n\
  matrix T = lift(B,M-A);\n\
  list l = M,T;\n\
  return(l);\n\
}\n\n",
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.
DecideZeroColumnsEffectively :=
  function( A, B, T )
    local v, N;
    
    v := homalgStream( HomalgRing( A ) )!.variable_name;
    
    N := HomalgVoidMatrix(
      NrRows( A ),
      NrColumns( A ),
      HomalgRing( A )
    );
    
    homalgSendBlocking(
      [
        "list ", v, "l=DecideZeroColumnsEffectively(", A, B, "); ",
        "matrix ", N, " = ", v, "l[1]; ",
        "matrix ", T, " = ", v, "l[2]"
      ],
      "need_command",
      HOMALG_IO.Pictograms.DecideZeroEffectively
    );
    
    return N;
    
  end,
3.1-20 DecideZeroColumnsEffectively
| ‣ DecideZeroColumnsEffectively( A, B, T ) | ( function ) | 
    DecideZeroColumnsEffectively := "\n\
proc DecideZeroColumnsEffectively (matrix A, matrix B)\n\
{\n\
  list l = DecideZeroRowsEffectively(Involution(A),Involution(B));\n\
  matrix B = l[1];\n\
  matrix T = l[2];\n\
  l = Involution(B),Involution(T);\n\
  return(l);\n\
}\n\n",
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",
      HOMALG_IO.Pictograms.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",
      HOMALG_IO.Pictograms.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",
      HOMALG_IO.Pictograms.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",
      HOMALG_IO.Pictograms.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",