GAP (RingsForHomalg) - Chapter 3: The Ring Table

Goto Chapter: Top 1 2 3 Bib Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

[MathJax off]

3 The Ring Table
3.1 An Example for a Ring Table - Singular
3.1-1 BasisOfRowModule
3.1-2 BasisOfRowModule
3.1-3 BasisOfColumnModule
3.1-4 BasisOfColumnModule
3.1-5 DecideZeroRows
3.1-6 DecideZeroRows
3.1-7 DecideZeroColumns
3.1-8 DecideZeroColumns
3.1-9 SyzygiesGeneratorsOfRows
3.1-10 SyzygiesGeneratorsOfRows
3.1-11 SyzygiesGeneratorsOfColumns
3.1-12 SyzygiesGeneratorsOfColumns
3.1-13 BasisOfRowsCoeff
3.1-14 BasisOfRowsCoeff
3.1-15 BasisOfColumnsCoeff
3.1-16 BasisOfColumnsCoeff
3.1-17 DecideZeroRowsEffectively
3.1-18 DecideZeroRowsEffectively
3.1-19 DecideZeroColumnsEffectively
3.1-20 DecideZeroColumnsEffectively
3.1-21 RelativeSyzygiesGeneratorsOfRows
3.1-22 RelativeSyzygiesGeneratorsOfRows
3.1-23 RelativeSyzygiesGeneratorsOfColumns
3.1-24 RelativeSyzygiesGeneratorsOfColumns
3.1-25 ReducedSyzygiesGeneratorsOfRows
3.1-26 ReducedSyzygiesGeneratorsOfRows
3.1-27 ReducedSyzygiesGeneratorsOfColumns
3.1-28 ReducedSyzygiesGeneratorsOfColumns

### 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",

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 3 Bib Ind

generated by GAPDoc2HTML