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.
  
    Code  
    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
  
    Code  
        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.
  
    Code  
    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
  
    Code  
        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.
  
    Code  
    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
  
    Code  
        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.
  
    Code  
    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
  
    Code  
        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.
  
    Code  
    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
  
    Code  
        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.
  
    Code  
    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
  
    Code  
        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.
  
    Code  
    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
  
    Code  
        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.
  
    Code  
    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
  
    Code  
        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.
  
    Code  
    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
  
    Code  
        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.
  
    Code  
    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
  
    Code  
        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.
  
    Code  
    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
  
    Code  
        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.
  
    Code  
    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
  
    Code  
        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.
  
    Code  
    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
  
    Code  
        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.
  
    Code  
    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
  
    Code  
        ReducedSyzygiesGeneratorsOfColumns := "\n\
    proc ReducedSyzygiesGeneratorsOfColumns (matrix M)\n\
    {\n\
      return(Involution(ReducedSyzForHomalg(Involution(M))));\n\
    }\n\n",