GAP (MatricesForHomalg) - Appendix C: Logic Subpackages

Goto Chapter: Top 1 2 3 4 5 6 A B C D E F Bib Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

[MathJax off]

C Logic Subpackages
C.1 LIRNG: Logical Implications for Rings
C.2 LIMAP: Logical Implications for Ring Maps
C.3 LIMAT: Logical Implications for Matrices
C.4 COLEM: Clever Operations for Lazy Evaluated Matrices
C.4-1 Eval
C.4-2 Eval
C.4-3 Eval
C.4-4 Eval
C.4-5 Eval
C.4-6 Eval
C.4-7 Eval
C.4-8 Eval
C.4-9 Eval
C.4-10 Eval
C.4-11 Eval
C.4-12 Eval
C.4-13 Eval
C.4-14 Eval
C.4-15 Eval
C.4-16 Eval
C.4-17 Eval
C.4-18 Eval
C.4-19 Eval
C.4-20 Eval
C.4-21 Eval

### C Logic Subpackages

#### C.1 LIRNG: Logical Implications for Rings

#### C.2 LIMAP: Logical Implications for Ring Maps

#### C.3 LIMAT: Logical Implications for Matrices

#### C.4 COLEM: Clever Operations for Lazy Evaluated Matrices

Most of the matrix tool operations listed in Appendix B.1 which return a new matrix are lazy evaluated. The value of a homalg matrix is stored in the attribute `Eval`. Below is the list of the installed methods for the attribute `Eval`.

##### C.4-1 Eval

`‣ Eval`( C ) | ( method )

Returns: the `Eval` value of a homalg matrix C

In case the matrix C was created using `HomalgInitialMatrix` (5.2-1) then the filter `IsInitialMatrix` for C is set to true and the `homalgTable` function (--> `InitialMatrix` (B.1-1)) will be used to set the attribute `Eval` and resets the filter `IsInitialMatrix`.

    InstallMethod( Eval,
            "for homalg matrices (IsInitialMatrix)",
            [ IsHomalgMatrix and IsInitialMatrix and
              HasNrRows and HasNrColumns ],

      function( C )
        local R, RP, z, zz;

        R := HomalgRing( C );

        RP := homalgTable( R );

        if IsBound( RP!.InitialMatrix ) then
            ResetFilterObj( C, IsInitialMatrix );
            SetEval( C, RP!.InitialMatrix( C ) );
            return Eval( C );
        fi;

        if not IsHomalgInternalMatrixRep( C ) then
            Error( "could not find a procedure called InitialMatrix in the ",
                   "homalgTable to evaluate a non-internal initial matrix\n" );
        fi;

        #=====# can only work for homalg internal matrices #=====#

        z := Zero( HomalgRing( C ) );

        ResetFilterObj( C, IsInitialMatrix );

        zz := ListWithIdenticalEntries( NrColumns( C ), z );

        SetEval( C, homalgInternalMatrixHull( List( [ 1 .. NrRows( C ) ], i -> ShallowCopy( zz ) ) ) );

        return Eval( C );

    end );

##### C.4-2 Eval

`‣ Eval`( C ) | ( method )

Returns: the `Eval` value of a homalg matrix C

In case the matrix C was created using `HomalgInitialIdentityMatrix` (5.2-2) then the filter `IsInitialIdentityMatrix` for C is set to true and the `homalgTable` function (--> `InitialIdentityMatrix` (B.1-2)) will be used to set the attribute `Eval` and resets the filter `IsInitialIdentityMatrix`.

    InstallMethod( Eval,
            "for homalg matrices (IsInitialIdentityMatrix)",
            [ IsHomalgMatrix and IsInitialIdentityMatrix and
              HasNrRows and HasNrColumns ],

      function( C )
        local R, RP, o, z, zz, id;

        R := HomalgRing( C );

        RP := homalgTable( R );

        if IsBound( RP!.InitialIdentityMatrix ) then
            ResetFilterObj( C, IsInitialIdentityMatrix );
            SetEval( C, RP!.InitialIdentityMatrix( C ) );
            return Eval( C );
        fi;

        if not IsHomalgInternalMatrixRep( C ) then
            Error( "could not find a procedure called InitialIdentityMatrix in the ",
                   "homalgTable to evaluate a non-internal initial identity matrix\n" );
        fi;

        #=====# can only work for homalg internal matrices #=====#

        z := Zero( HomalgRing( C ) );
        o := One( HomalgRing( C ) );

        ResetFilterObj( C, IsInitialIdentityMatrix );

        zz := ListWithIdenticalEntries( NrColumns( C ), z );

        id := List( [ 1 .. NrRows( C ) ],
                    function(i)
                      local z;
                      z := ShallowCopy( zz ); z[i] := o; return z;
                    end );

        SetEval( C, homalgInternalMatrixHull( id ) );

        return Eval( C );

    end );

##### C.4-3 Eval

`‣ Eval`( C ) | ( method )

Returns: the `Eval` value of a homalg matrix C

In case the matrix C was created using `HomalgZeroMatrix` (5.2-3) then the filter `IsZeroMatrix` for C is set to true and the `homalgTable` function (--> `ZeroMatrix` (B.1-3)) will be used to set the attribute `Eval`.

    InstallMethod( Eval,
            "for homalg matrices (IsZero)",
            [ IsHomalgMatrix and IsZero and HasNrRows and HasNrColumns ], 40,

      function( C )
        local R, RP, z;

        R := HomalgRing( C );

        RP := homalgTable( R );

        if ( NrRows( C ) = 0 or NrColumns( C ) = 0 ) and
           not ( IsBound( R!.SafeToEvaluateEmptyMatrices ) and
                 R!.SafeToEvaluateEmptyMatrices = true ) then
            Info( InfoWarning, 1, "\033[01m\033[5;31;47m",
                  "an empty matrix is about to get evaluated!",
                  "\033[0m" );
        fi;

        if IsBound( RP!.ZeroMatrix ) then
            return RP!.ZeroMatrix( C );
        fi;

        if not IsHomalgInternalMatrixRep( C ) then
            Error( "could not find a procedure called ZeroMatrix ",
                   "homalgTable to evaluate a non-internal zero matrix\n" );
        fi;

        #=====# can only work for homalg internal matrices #=====#

        z := Zero( HomalgRing( C ) );

        ## copying the rows saves memory;
        ## we assume that the entries are never modified!!!
        return homalgInternalMatrixHull(
                       ListWithIdenticalEntries( NrRows( C ),
                               ListWithIdenticalEntries( NrColumns( C ), z ) ) );

    end );

##### C.4-4 Eval

`‣ Eval`( C ) | ( method )

Returns: the `Eval` value of a homalg matrix C

In case the matrix C was created using `HomalgIdentityMatrix` (5.2-4) then the filter `IsOne` for C is set to true and the `homalgTable` function (--> `IdentityMatrix` (B.1-4)) will be used to set the attribute `Eval`.

    InstallMethod( Eval,
            "for homalg matrices (IsOne)",
            [ IsHomalgMatrix and IsOne and HasNrRows and HasNrColumns ], 10,

      function( C )
        local R, id, RP, o, z, zz;

        R := HomalgRing( C );

        if IsBound( R!.IdentityMatrices ) then
            id := ElmWPObj( R!.IdentityMatrices!.weak_pointers, NrColumns( C ) );
            if id <> fail then
                R!.IdentityMatrices!.cache_hits := R!.IdentityMatrices!.cache_hits + 1;
                return id;
            fi;
            ## we do not count cache_misses as it is equivalent to counter
        fi;

        RP := homalgTable( R );

        if IsBound( RP!.IdentityMatrix ) then
            id := RP!.IdentityMatrix( C );
            SetElmWPObj( R!.IdentityMatrices!.weak_pointers, NrColumns( C ), id );
            R!.IdentityMatrices!.counter := R!.IdentityMatrices!.counter + 1;
            return id;
        fi;

        if not IsHomalgInternalMatrixRep( C ) then
            Error( "could not find a procedure called IdentityMatrix ",
                   "homalgTable to evaluate a non-internal identity matrix\n" );
        fi;

        #=====# can only work for homalg internal matrices #=====#

        z := Zero( HomalgRing( C ) );
        o := One( HomalgRing( C ) );

        zz := ListWithIdenticalEntries( NrColumns( C ), z );

        id := List( [ 1 .. NrRows( C ) ],
                    function(i)
                      local z;
                      z := ShallowCopy( zz ); z[i] := o; return z;
                    end );

        id := homalgInternalMatrixHull( id );

        SetElmWPObj( R!.IdentityMatrices!.weak_pointers, NrColumns( C ), id );

        return id;

    end );

##### C.4-5 Eval

`‣ Eval`( LI ) | ( method )

Returns: see below

In case the matrix LI was created using `LeftInverseLazy` (5.5-4) then the filter `HasEvalLeftInverse` for LI is set to true and the method listed below will be used to set the attribute `Eval`. (--> `LeftInverse` (5.5-2))

    InstallMethod( Eval,
            "for homalg matrices",
            [ IsHomalgMatrix and HasEvalLeftInverse ],

      function( LI )
        local left_inv;

        left_inv := LeftInverse( EvalLeftInverse( LI ) );

        if IsBool( left_inv ) then
            return false;
        fi;

        return Eval( left_inv );

    end );

##### C.4-6 Eval

`‣ Eval`( RI ) | ( method )

Returns: see below

In case the matrix RI was created using `RightInverseLazy` (5.5-5) then the filter `HasEvalRightInverse` for RI is set to true and the method listed below will be used to set the attribute `Eval`. (--> `RightInverse` (5.5-3))

    InstallMethod( Eval,
            "for homalg matrices",
            [ IsHomalgMatrix and HasEvalRightInverse ],

      function( RI )
        local right_inv;

        right_inv := RightInverse( EvalRightInverse( RI ) );

        if IsBool( right_inv ) then
            return false;
        fi;

        return Eval( right_inv );

    end );

##### C.4-7 Eval

`‣ Eval`( C ) | ( method )

Returns: the `Eval` value of a homalg matrix C

In case the matrix was created using `Involution` (5.5-6) then the filter `HasEvalInvolution` for C is set to true and the `homalgTable` function `Involution` (B.1-5) will be used to set the attribute `Eval`.

    InstallMethod( Eval,
            "for homalg matrices (HasEvalInvolution)",
            [ IsHomalgMatrix and HasEvalInvolution ],

      function( C )
        local R, RP, M;

        R := HomalgRing( C );

        RP := homalgTable( R );

        M :=  EvalInvolution( C );

        if IsBound(RP!.Involution) then
            return RP!.Involution( M );
        fi;

        if not IsHomalgInternalMatrixRep( C ) then
            Error( "could not find a procedure called Involution ",
                   "in the homalgTable of the non-internal ring\n" );
        fi;

        #=====# can only work for homalg internal matrices #=====#

        return homalgInternalMatrixHull( TransposedMat( Eval( M )!.matrix ) );

    end );

##### C.4-8 Eval

`‣ Eval`( C ) | ( method )

Returns: the `Eval` value of a homalg matrix C

In case the matrix was created using `TransposedMatrix` (5.5-7) then the filter `HasEvalTransposedMatrix` for C is set to true and the `homalgTable` function `TransposedMatrix` (B.1-6) will be used to set the attribute `Eval`.

    InstallMethod( Eval,
            "for homalg matrices (HasEvalTransposedMatrix)",
            [ IsHomalgMatrix and HasEvalTransposedMatrix ],

      function( C )
        local R, RP, M;

        R := HomalgRing( C );

        RP := homalgTable( R );

        M :=  EvalTransposedMatrix( C );

        if IsBound(RP!.TransposedMatrix) then
            return RP!.TransposedMatrix( M );
        fi;

        if not IsHomalgInternalMatrixRep( C ) then
            Error( "could not find a procedure called TransposedMatrix ",
                   "in the homalgTable of the non-internal ring\n" );
        fi;

        #=====# can only work for homalg internal matrices #=====#

        return homalgInternalMatrixHull( TransposedMat( Eval( M )!.matrix ) );

    end );

##### C.4-9 Eval

`‣ Eval`( C ) | ( method )

Returns: the `Eval` value of a homalg matrix C

In case the matrix was created using `CoercedMatrix` (5.2-12) then the filter `HasEvalCoercedMatrix` for C is set to true and the `Eval` value of a copy of `EvalCoercedMatrix(`C`)` in `HomalgRing(`C`)` will be used to set the attribute `Eval`.

    InstallMethod( Eval,
            "for homalg matrices (HasEvalCoercedMatrix)",
            [ IsHomalgMatrix and HasEvalCoercedMatrix ],

      function( C )
        local R, RP, m;

        R := HomalgRing( C );

        RP := homalgTable( R );

        m := EvalCoercedMatrix( C );

        # delegate to the non-lazy coercening
        return Eval( R * m );

    end );

##### C.4-10 Eval

`‣ Eval`( C ) | ( method )

Returns: the `Eval` value of a homalg matrix C

In case the matrix was created using `CertainRows` (5.5-8) then the filter `HasEvalCertainRows` for C is set to true and the `homalgTable` function `CertainRows` (B.1-7) will be used to set the attribute `Eval`.

    InstallMethod( Eval,
            "for homalg matrices (HasEvalCertainRows)",
            [ IsHomalgMatrix and HasEvalCertainRows ],

      function( C )
        local R, RP, e, M, plist;

        R := HomalgRing( C );

        RP := homalgTable( R );

        e :=  EvalCertainRows( C );

        M := e[1];
        plist := e[2];

        ResetFilterObj( C, HasEvalCertainRows );

        ## delete the component which was left over by GAP
        Unbind( C!.EvalCertainRows );

        if IsBound(RP!.CertainRows) then
            return RP!.CertainRows( M, plist );
        fi;

        if not IsHomalgInternalMatrixRep( C ) then
            Error( "could not find a procedure called CertainRows ",
                   "in the homalgTable of the non-internal ring\n" );
        fi;

        #=====# can only work for homalg internal matrices #=====#

        return homalgInternalMatrixHull( Eval( M )!.matrix{ plist } );

    end );

##### C.4-11 Eval

`‣ Eval`( C ) | ( method )

Returns: the `Eval` value of a homalg matrix C

In case the matrix was created using `CertainColumns` (5.5-9) then the filter `HasEvalCertainColumns` for C is set to true and the `homalgTable` function `CertainColumns` (B.1-8) will be used to set the attribute `Eval`.

    InstallMethod( Eval,
            "for homalg matrices (HasEvalCertainColumns)",
            [ IsHomalgMatrix and HasEvalCertainColumns ],

      function( C )
        local R, RP, e, M, plist;

        R := HomalgRing( C );

        RP := homalgTable( R );

        e :=  EvalCertainColumns( C );

        M := e[1];
        plist := e[2];

        ResetFilterObj( C, HasEvalCertainColumns );

        ## delete the component which was left over by GAP
        Unbind( C!.EvalCertainColumns );

        if IsBound(RP!.CertainColumns) then
            return RP!.CertainColumns( M, plist );
        fi;

        if not IsHomalgInternalMatrixRep( C ) then
            Error( "could not find a procedure called CertainColumns ",
                   "in the homalgTable of the non-internal ring\n" );
        fi;

        #=====# can only work for homalg internal matrices #=====#

        return homalgInternalMatrixHull(
                       Eval( M )!.matrix{[ 1 .. NrRows( M ) ]}{plist} );

    end );

##### C.4-12 Eval

`‣ Eval`( C ) | ( method )

Returns: the `Eval` value of a homalg matrix C

In case the matrix was created using `UnionOfRows` (5.5-10) then the filter `HasEvalUnionOfRows` for C is set to true and the `homalgTable` function `UnionOfRows` (B.1-9) or the `homalgTable` function `UnionOfRowsPair` (B.1-10) will be used to set the attribute `Eval`.

    InstallMethod( Eval,
            "for homalg matrices (HasEvalUnionOfRows)",
            [ IsHomalgMatrix and HasEvalUnionOfRows ],

      function( C )
        local R, RP, e, i, combine;

        R := HomalgRing( C );

        RP := homalgTable( R );

        # Make it mutable
        e := ShallowCopy( EvalUnionOfRows( C ) );

        # In case of nested UnionOfRows, we try to avoid
        # recursion, since the gap stack is rather small
        # additionally unpack PreEvals
        i := 1;
        while i <= Length( e ) do

            if HasPreEval( e[i] ) and not HasEval( e[i] ) then

                e[i] := PreEval( e[i] );

            elif HasEvalUnionOfRows( e[i] ) and not HasEval( e[i] ) then

                e := Concatenation( e{[ 1 .. (i-1) ]}, EvalUnionOfRows( e[i] ), e{[ (i+1) .. Length( e ) ]}  );

            else

                i := i + 1;

            fi;

        od;

        # Combine zero matrices
        i := 1;
        while i + 1 <= Length( e ) do

            if HasIsZero( e[i] ) and IsZero( e[i] ) and HasIsZero( e[i+1] ) and IsZero( e[i+1] ) then

                e[i] := HomalgZeroMatrix( NrRows( e[i] ) + NrRows( e[i+1] ), NrColumns( e[i] ), HomalgRing( e[i] ) );

                Remove( e, i + 1 );

            else

                i := i + 1;

            fi;

        od;

        # After combining zero matrices only a single one might be left
        if Length( e ) = 1 then

            return e[1];

        fi;

        # Use RP!.UnionOfRows if available
        if IsBound(RP!.UnionOfRows) then

            return RP!.UnionOfRows( e );

        fi;

        # Fall back to RP!.UnionOfRowsPair or manual fallback for internal matrices
        # Combine the matrices
        # Use a balanced binary tree to keep the sizes small (heuristically)
        # to avoid a huge memory footprint

        if not IsBound(RP!.UnionOfRowsPair) and not IsHomalgInternalMatrixRep( C ) then
            Error( "could neither find a procedure called UnionOfRows ",
                   "nor a procedure called UnionOfRowsPair ",
                   "in the homalgTable of the non-internal ring\n" );
        fi;

        combine := function( A, B )
          local result, U;

            if IsBound(RP!.UnionOfRowsPair) then

                result := RP!.UnionOfRowsPair( A, B );

            else

                #=====# can only work for homalg internal matrices #=====#

                U := ShallowCopy( Eval( A )!.matrix );

                U{ [ NrRows( A ) + 1 .. NrRows( A ) + NrRows( B ) ] } := Eval( B )!.matrix;

                result := homalgInternalMatrixHull( U );

            fi;

            return HomalgMatrixWithAttributes( [
                        Eval, result,
                        EvalUnionOfRows, [ A, B ],
                        NrRows, NrRows( A ) + NrRows( B ),
                        NrColumns, NrColumns( A ),
                        ], R );

        end;

        while Length( e ) > 1 do

            for i in [ 1 .. Int( Length( e ) / 2 ) ] do

                e[ 2 * i - 1 ] := combine( e[ 2 * i - 1 ], e[ 2 * i ] );
                Unbind( e[ 2 * i ] );

            od;

            e := Compacted( e );

        od;

        return Eval( e[1] );

    end );

##### C.4-13 Eval

`‣ Eval`( C ) | ( method )

Returns: the `Eval` value of a homalg matrix C

In case the matrix was created using `UnionOfColumns` (5.5-11) then the filter `HasEvalUnionOfColumns` for C is set to true and the `homalgTable` function `UnionOfColumns` (B.1-11) or the `homalgTable` function `UnionOfColumnsPair` (B.1-12) will be used to set the attribute `Eval`.

    InstallMethod( Eval,
            "for homalg matrices (HasEvalUnionOfColumns)",
            [ IsHomalgMatrix and HasEvalUnionOfColumns ],

      function( C )
        local R, RP, e, i, combine;

        R := HomalgRing( C );

        RP := homalgTable( R );

        # Make it mutable
        e := ShallowCopy( EvalUnionOfColumns( C ) );

        # In case of nested UnionOfColumns, we try to avoid
        # recursion, since the gap stack is rather small
        # additionally unpack PreEvals
        i := 1;
        while i <= Length( e ) do

            if HasPreEval( e[i] ) and not HasEval( e[i] ) then

                e[i] := PreEval( e[i] );

            elif HasEvalUnionOfColumns( e[i] ) and not HasEval( e[i] ) then

                e := Concatenation( e{[ 1 .. (i-1) ]}, EvalUnionOfColumns( e[i] ), e{[ (i+1) .. Length( e ) ]}  );

            else

                i := i + 1;

            fi;

        od;

        # Combine zero matrices
        i := 1;
        while i + 1 <= Length( e ) do

            if HasIsZero( e[i] ) and IsZero( e[i] ) and HasIsZero( e[i+1] ) and IsZero( e[i+1] ) then

                e[i] := HomalgZeroMatrix( NrRows( e[i] ), NrColumns( e[i] ) + NrColumns( e[i+1] ), HomalgRing( e[i] ) );

                Remove( e, i + 1 );

            else

                i := i + 1;

            fi;

        od;

        # After combining zero matrices only a single one might be left
        if Length( e ) = 1 then

            return e[1];

        fi;

        # Use RP!.UnionOfColumns if available
        if IsBound(RP!.UnionOfColumns) then

            return RP!.UnionOfColumns( e );

        fi;

        # Fall back to RP!.UnionOfColumnsPair or manual fallback for internal matrices
        # Combine the matrices
        # Use a balanced binary tree to keep the sizes small (heuristically)
        # to avoid a huge memory footprint

        if not IsBound(RP!.UnionOfColumnsPair) and not IsHomalgInternalMatrixRep( C ) then
            Error( "could neither find a procedure called UnionOfColumns ",
                   "nor a procedure called UnionOfColumnsPair ",
                   "in the homalgTable of the non-internal ring\n" );
        fi;

        combine := function( A, B )
          local result, U;

            if IsBound(RP!.UnionOfColumnsPair) then

                result := RP!.UnionOfColumnsPair( A, B );

            else

                #=====# can only work for homalg internal matrices #=====#

                U := List( Eval( A )!.matrix, ShallowCopy );

                U{ [ 1 .. NrRows( A ) ] }
                  { [ NrColumns( A ) + 1 .. NrColumns( A ) + NrColumns( B ) ] }
                  := Eval( B )!.matrix;

                result := homalgInternalMatrixHull( U );

            fi;

            return HomalgMatrixWithAttributes( [
                        Eval, result,
                        EvalUnionOfColumns, [ A, B ],
                        NrRows, NrRows( A ),
                        NrColumns, NrColumns( A ) + NrColumns( B )
                        ], R );

        end;

        while Length( e ) > 1 do

            for i in [ 1 .. Int( Length( e ) / 2 ) ] do

                e[ 2 * i - 1 ] := combine( e[ 2 * i - 1 ], e[ 2 * i ] );
                Unbind( e[ 2 * i ] );

            od;

            e := Compacted( e );

        od;

        return Eval( e[1] );

    end );

##### C.4-14 Eval

`‣ Eval`( C ) | ( method )

Returns: the `Eval` value of a homalg matrix C

In case the matrix was created using `DiagMat` (5.5-16) then the filter `HasEvalDiagMat` for C is set to true and the `homalgTable` function `DiagMat` (B.1-13) will be used to set the attribute `Eval`.

    InstallMethod( Eval,
            "for homalg matrices (HasEvalDiagMat)",
            [ IsHomalgMatrix and HasEvalDiagMat ],

      function( C )
        local R, RP, e, l, z, m, n, diag, mat;

        R := HomalgRing( C );

        RP := homalgTable( R );

        e :=  EvalDiagMat( C );

        if IsBound(RP!.DiagMat) then
            return RP!.DiagMat( e );
        fi;

        l := Length( e );

        if not IsHomalgInternalMatrixRep( C ) then
            return UnionOfRows(
                           List( [ 1 .. l ],
                                 i -> UnionOfColumns(
                                         List( [ 1 .. l ],
                                               function( j )
                                                 if i = j then
                                                     return e[i];
                                                 fi;
                                                 return HomalgZeroMatrix( NrRows( e[i] ), NrColumns( e[j] ), R );
                                               end )
                                         )
                                 )
                           );
        fi;

        #=====# can only work for homalg internal matrices #=====#

        z := Zero( R );

        m := Sum( List( e, NrRows ) );
        n := Sum( List( e, NrColumns ) );

        diag := List( [ 1 .. m ], a -> List( [ 1 .. n ], b -> z ) );

        m := 0;
        n := 0;

        for mat in e do
            diag{ [ m + 1 .. m + NrRows( mat ) ] }{ [ n + 1 .. n + NrColumns( mat ) ] }
              := Eval( mat )!.matrix;

            m := m + NrRows( mat );
            n := n + NrColumns( mat );
        od;

        return homalgInternalMatrixHull( diag );

    end );

##### C.4-15 Eval

`‣ Eval`( C ) | ( method )

Returns: the `Eval` value of a homalg matrix C

In case the matrix was created using `KroneckerMat` (5.5-17) then the filter `HasEvalKroneckerMat` for C is set to true and the `homalgTable` function `KroneckerMat` (B.1-14) will be used to set the attribute `Eval`.

    InstallMethod( Eval,
            "for homalg matrices (HasEvalKroneckerMat)",
            [ IsHomalgMatrix and HasEvalKroneckerMat ],

      function( C )
        local R, RP, A, B;

        R := HomalgRing( C );

        if ( HasIsCommutative( R ) and not IsCommutative( R ) ) and
           ( HasIsSuperCommutative( R ) and not IsSuperCommutative( R ) ) then
            Info( InfoWarning, 1, "\033[01m\033[5;31;47m",
                  "the Kronecker product is only defined for (super) commutative rings!",
                  "\033[0m" );
        fi;

        RP := homalgTable( R );

        A :=  EvalKroneckerMat( C )[1];
        B :=  EvalKroneckerMat( C )[2];

        if IsBound(RP!.KroneckerMat) then
            return RP!.KroneckerMat( A, B );
        fi;

        if not IsHomalgInternalMatrixRep( C ) then
            Error( "could not find a procedure called KroneckerMat ",
                   "in the homalgTable of the non-internal ring\n" );
        fi;

        #=====# can only work for homalg internal matrices #=====#

        return homalgInternalMatrixHull(
                       KroneckerProduct( Eval( A )!.matrix, Eval( B )!.matrix ) );
        ## this was easy, thanks GAP :)

    end );

##### C.4-16 Eval

`‣ Eval`( C ) | ( method )

Returns: the `Eval` value of a homalg matrix C

In case the matrix was created using `DualKroneckerMat` (5.5-18) then the filter `HasEvalDualKroneckerMat` for C is set to true and the `homalgTable` function `DualKroneckerMat` (B.1-15) will be used to set the attribute `Eval`.

    InstallMethod( Eval,
            "for homalg matrices (HasEvalDualKroneckerMat)",
            [ IsHomalgMatrix and HasEvalDualKroneckerMat ],

      function( C )
        local R, RP, A, B;

        R := HomalgRing( C );

        if ( HasIsCommutative( R ) and not IsCommutative( R ) ) and
           ( HasIsSuperCommutative( R ) and not IsSuperCommutative( R ) ) then
            Info( InfoWarning, 1, "\033[01m\033[5;31;47m",
                  "the dual Kronecker product is only defined for (super) commutative rings!",
                  "\033[0m" );
        fi;

        RP := homalgTable( R );

        A :=  EvalDualKroneckerMat( C )[1];
        B :=  EvalDualKroneckerMat( C )[2];

        # work around errors in Singular when taking the opposite ring of a ring with ordering lp
        # https://github.com/Singular/Singular/issues/1011
        # fixed in version 4.2.0
        if IsBound(RP!.DualKroneckerMat) and not (
            IsBound( R!.ring ) and
            IsBound( R!.ring!.stream ) and
            IsBound( R!.ring!.stream.cas ) and R!.ring!.stream.cas = "singular" and
            ( not IsBound( R!.ring!.stream.version ) or R!.ring!.stream.version < 4200 ) and
            IsBound( R!.order ) and IsString( R!.order ) and StartsWith( R!.order, "lex" )
        ) then

            return RP!.DualKroneckerMat( A, B );

        fi;

        if HasIsCommutative( R ) and IsCommutative( R ) then

            return Eval( KroneckerMat( B, A ) );

        else

            return Eval(
                TransposedMatrix( Involution(
                    KroneckerMat( TransposedMatrix( Involution( B ) ), TransposedMatrix( Involution( A ) ) )
                ) )
            );

        fi;

    end );

##### C.4-17 Eval

`‣ Eval`( C ) | ( method )

Returns: the `Eval` value of a homalg matrix C

In case the matrix was created using `\*` (5.5-19) then the filter `HasEvalMulMat` for C is set to true and the `homalgTable` function `MulMat` (B.1-16) will be used to set the attribute `Eval`.

    InstallMethod( Eval,
            "for homalg matrices (HasEvalMulMat)",
            [ IsHomalgMatrix and HasEvalMulMat ],

      function( C )
        local R, RP, e, a, A;

        R := HomalgRing( C );

        RP := homalgTable( R );

        e :=  EvalMulMat( C );

        a := e[1];
        A := e[2];

        if IsBound(RP!.MulMat) then
            return RP!.MulMat( a, A );
        fi;

        if not IsHomalgInternalMatrixRep( C ) then
            Error( "could not find a procedure called MulMat ",
                   "in the homalgTable of the non-internal ring\n" );
        fi;

        #=====# can only work for homalg internal matrices #=====#

        return a * Eval( A );

    end );

    InstallMethod( Eval,
            "for homalg matrices (HasEvalMulMatRight)",
            [ IsHomalgMatrix and HasEvalMulMatRight ],

      function( C )
        local R, RP, e, A, a;

        R := HomalgRing( C );

        RP := homalgTable( R );

        e :=  EvalMulMatRight( C );

        A := e[1];
        a := e[2];

        if IsBound(RP!.MulMatRight) then
            return RP!.MulMatRight( A, a );
        fi;

        if not IsHomalgInternalMatrixRep( C ) then
            Error( "could not find a procedure called MulMatRight ",
                   "in the homalgTable of the non-internal ring\n" );
        fi;

        #=====# can only work for homalg internal matrices #=====#

        return Eval( A ) * a;

    end );

##### C.4-18 Eval

`‣ Eval`( C ) | ( method )

Returns: the `Eval` value of a homalg matrix C

In case the matrix was created using `\+` (5.5-20) then the filter `HasEvalAddMat` for C is set to true and the `homalgTable` function `AddMat` (B.1-17) will be used to set the attribute `Eval`.

    InstallMethod( Eval,
            "for homalg matrices (HasEvalAddMat)",
            [ IsHomalgMatrix and HasEvalAddMat ],

      function( C )
        local R, RP, e, A, B;

        R := HomalgRing( C );

        RP := homalgTable( R );

        e :=  EvalAddMat( C );

        A := e[1];
        B := e[2];

        ResetFilterObj( C, HasEvalAddMat );

        ## delete the component which was left over by GAP
        Unbind( C!.EvalAddMat );

        if IsBound(RP!.AddMat) then
            return RP!.AddMat( A, B );
        fi;

        if not IsHomalgInternalMatrixRep( C ) then
            Error( "could not find a procedure called AddMat ",
                   "in the homalgTable of the non-internal ring\n" );
        fi;

        #=====# can only work for homalg internal matrices #=====#

        return Eval( A ) + Eval( B );

    end );

##### C.4-19 Eval

`‣ Eval`( C ) | ( method )

Returns: the `Eval` value of a homalg matrix C

In case the matrix was created using `\-` (5.5-21) then the filter `HasEvalSubMat` for C is set to true and the `homalgTable` function `SubMat` (B.1-18) will be used to set the attribute `Eval`.

    InstallMethod( Eval,
            "for homalg matrices (HasEvalSubMat)",
            [ IsHomalgMatrix and HasEvalSubMat ],

      function( C )
        local R, RP, e, A, B;

        R := HomalgRing( C );

        RP := homalgTable( R );

        e :=  EvalSubMat( C );

        A := e[1];
        B := e[2];

        ResetFilterObj( C, HasEvalSubMat );

        ## delete the component which was left over by GAP
        Unbind( C!.EvalSubMat );

        if IsBound(RP!.SubMat) then
            return RP!.SubMat( A, B );
        fi;

        if not IsHomalgInternalMatrixRep( C ) then
            Error( "could not find a procedure called SubMat ",
                   "in the homalgTable of the non-internal ring\n" );
        fi;

        #=====# can only work for homalg internal matrices #=====#

        return Eval( A ) - Eval( B );

    end );

##### C.4-20 Eval

`‣ Eval`( C ) | ( method )

Returns: the `Eval` value of a homalg matrix C

In case the matrix was created using `\*` (5.5-22) then the filter `HasEvalCompose` for C is set to true and the `homalgTable` function `Compose` (B.1-19) will be used to set the attribute `Eval`.

    InstallMethod( Eval,
            "for homalg matrices (HasEvalCompose)",
            [ IsHomalgMatrix and HasEvalCompose ],

      function( C )
        local R, RP, e, A, B;

        R := HomalgRing( C );

        RP := homalgTable( R );

        e :=  EvalCompose( C );

        A := e[1];
        B := e[2];

        ResetFilterObj( C, HasEvalCompose );

        ## delete the component which was left over by GAP
        Unbind( C!.EvalCompose );

        if IsBound(RP!.Compose) then
            return RP!.Compose( A, B );
        fi;

        if not IsHomalgInternalMatrixRep( C ) then
            Error( "could not find a procedure called Compose ",
                   "in the homalgTable of the non-internal ring\n" );
        fi;

        #=====# can only work for homalg internal matrices #=====#

        return Eval( A ) * Eval( B );

    end );

##### C.4-21 Eval

`‣ Eval`( C ) | ( method )

Returns: the `Eval` value of a homalg matrix C

In case the matrix was created using `CoefficientsWithGivenMonomials` (5.5-60) then the filter `HasEvalCoefficientsWithGivenMonomials` for C is set to true and the `homalgTable` function `CoefficientsWithGivenMonomials` (B.1-24) will be used to set the attribute `Eval`.

    InstallMethod( Eval,
            "for homalg matrices (HasEvalCoefficientsWithGivenMonomials)",
            [ IsHomalgMatrix and HasEvalCoefficientsWithGivenMonomials ],

      function( C )
        local R, RP, pair, M, monomials;

        R := HomalgRing( C );

        RP := homalgTable( R );

        pair := EvalCoefficientsWithGivenMonomials( C );

        M := pair[1];
        monomials := pair[2];

        if IsBound( RP!.CoefficientsWithGivenMonomials ) then

            return RP!.CoefficientsWithGivenMonomials( M, monomials );

        fi;

        Error( "could not find a procedure called CoefficientsWithGivenMonomials ",
                "in the homalgTable of the ring\n" );

    end );

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 3 4 5 6 A B C D E F Bib Ind

generated by GAPDoc2HTML