| ‣ BasisOfRowModule( M ) | ( function ) | 
Returns: a homalg matrix over the ambient ring
BasisOfRowModule :=
  function( M )
    local Mrel;
    
    Mrel := UnionOfRows( M );
    
    Mrel := HomalgResidueClassMatrix(
                    BasisOfRowModule( Mrel ), HomalgRing( M ) );
    
    return GetRidOfObsoleteRows( Mrel );
    
  end,
| ‣ BasisOfColumnModule( M ) | ( function ) | 
Returns: a homalg matrix over the ambient ring
BasisOfColumnModule :=
  function( M )
    local Mrel;
    
    Mrel := UnionOfColumns( M );
    
    Mrel := HomalgResidueClassMatrix(
                    BasisOfColumnModule( Mrel ), HomalgRing( M ) );
    
    return GetRidOfObsoleteColumns( Mrel );
    
  end,
| ‣ DecideZeroRows( A, B ) | ( function ) | 
Returns: a homalg matrix over the ambient ring
DecideZeroRows :=
  function( A, B )
    local Brel;
    
    Brel := UnionOfRows( B );
    
    Brel := BasisOfRowModule( Brel );
    
    return HomalgResidueClassMatrix(
                   DecideZeroRows( Eval( A ), Brel ), HomalgRing( A ) );
    
  end,
| ‣ DecideZeroColumns( A, B ) | ( function ) | 
Returns: a homalg matrix over the ambient ring
DecideZeroColumns :=
  function( A, B )
    local Brel;
    
    Brel := UnionOfColumns( B );
    
    Brel := BasisOfColumnModule( Brel );
    
    return HomalgResidueClassMatrix(
                   DecideZeroColumns( Eval( A ), Brel ), HomalgRing( A ) );
    
  end,
| ‣ SyzygiesGeneratorsOfRows( M ) | ( function ) | 
Returns: a homalg matrix over the ambient ring
SyzygiesGeneratorsOfRows :=
  function( M )
    local R, ring_rel, rel, S;
    
    R := HomalgRing( M );
    
    ring_rel := RingRelations( R );
    
    rel := MatrixOfRelations( ring_rel );
    
    if IsHomalgRingRelationsAsGeneratorsOfRightIdeal( ring_rel ) then
        rel := Involution( rel );
    fi;
    
    rel := DiagMat( ListWithIdenticalEntries( NrColumns( M ), rel ) );
    
    S := SyzygiesGeneratorsOfRows( Eval( M ), rel );
    
    S := HomalgResidueClassMatrix( S, R );
    
    S := GetRidOfObsoleteRows( S );
    
    if IsZero( S ) then
        
        SetIsLeftRegular( M, true );
        
    fi;
    
    return S;
    
  end,
| ‣ SyzygiesGeneratorsOfColumns( M ) | ( function ) | 
Returns: a homalg matrix over the ambient ring
SyzygiesGeneratorsOfColumns :=
  function( M )
    local R, ring_rel, rel, S;
    
    R := HomalgRing( M );
    
    ring_rel := RingRelations( R );
    
    rel := MatrixOfRelations( ring_rel );
    
    if IsHomalgRingRelationsAsGeneratorsOfLeftIdeal( ring_rel ) then
        rel := Involution( rel );
    fi;
    
    rel := DiagMat( ListWithIdenticalEntries( NrRows( M ), rel ) );
    
    S := SyzygiesGeneratorsOfColumns( Eval( M ), rel );
    
    S := HomalgResidueClassMatrix( S, R );
    
    S := GetRidOfObsoleteColumns( S );
    
    if IsZero( S ) then
        
        SetIsRightRegular( M, true );
        
    fi;
    
    return S;
    
  end,
| ‣ BasisOfRowsCoeff( M, T ) | ( function ) | 
Returns: a homalg matrix over the ambient ring
BasisOfRowsCoeff :=
  function( M, T )
    local Mrel, TT, bas, nz;
    
    Mrel := UnionOfRows( M );
    
    TT := HomalgVoidMatrix( HomalgRing( Mrel ) );
    
    bas := BasisOfRowsCoeff( Mrel, TT );
    
    bas := HomalgResidueClassMatrix( bas, HomalgRing( M ) );
    
    nz := NonZeroRows( bas );
    
    SetEval( T, CertainRows( CertainColumns( TT, [ 1 .. NrRows( M ) ] ), nz ) );
    
    ResetFilterObj( T, IsVoidMatrix );
    
    ## the generic BasisOfRowsCoeff will assume that
    ## ( NrRows( B ) = 0 ) = IsZero( B )
    return CertainRows( bas, nz );
    
  end,
| ‣ BasisOfColumnsCoeff( M, T ) | ( function ) | 
Returns: a homalg matrix over the ambient ring
BasisOfColumnsCoeff :=
  function( M, T )
    local Mrel, TT, bas, nz;
    
    Mrel := UnionOfColumns( M );
    
    TT := HomalgVoidMatrix( HomalgRing( Mrel ) );
    
    bas := BasisOfColumnsCoeff( Mrel, TT );
    
    bas := HomalgResidueClassMatrix( bas, HomalgRing( M ) );
    
    nz := NonZeroColumns( bas );
    
    SetEval( T, CertainColumns( CertainRows( TT, [ 1 .. NrColumns( M ) ] ), nz ) );
    
    ResetFilterObj( T, IsVoidMatrix );
    
    ## the generic BasisOfColumnsCoeff will assume that
    ## ( NrColumns( B ) = 0 ) = IsZero( B )
    return CertainColumns( bas, nz );
    
  end,
| ‣ DecideZeroRowsEffectively( A, B, T ) | ( function ) | 
Returns: a homalg matrix over the ambient ring
DecideZeroRowsEffectively :=
  function( A, B, T )
    local Brel, TT, red;
    
    Brel := UnionOfRows( B );
    
    TT := HomalgVoidMatrix( HomalgRing( Brel ) );
    
    red := DecideZeroRowsEffectively( Eval( A ), Brel, TT );
    
    SetEval( T, CertainColumns( TT, [ 1 .. NrRows( B ) ] ) );
    
    ResetFilterObj( T, IsVoidMatrix );
    
    return HomalgResidueClassMatrix( red, HomalgRing( A ) );
    
  end,
| ‣ DecideZeroColumnsEffectively( A, B, T ) | ( function ) | 
Returns: a homalg matrix over the ambient ring
DecideZeroColumnsEffectively :=
  function( A, B, T )
    local Brel, TT, red;
    
    Brel := UnionOfColumns( B );
    
    TT := HomalgVoidMatrix( HomalgRing( Brel ) );
    
    red := DecideZeroColumnsEffectively( Eval( A ), Brel, TT );
    
    SetEval( T, CertainRows( TT, [ 1 .. NrColumns( B ) ] ) );
    
    ResetFilterObj( T, IsVoidMatrix );
    
    return HomalgResidueClassMatrix( red, HomalgRing( A ) );
    
  end,
| ‣ RelativeSyzygiesGeneratorsOfRows( M, M2 ) | ( function ) | 
Returns: a homalg matrix over the ambient ring
RelativeSyzygiesGeneratorsOfRows :=
  function( M, M2 )
    local M2rel, S;
    
    M2rel := UnionOfRows( M2 );
    
    S := SyzygiesGeneratorsOfRows( Eval( M ), M2rel );
    
    S := HomalgResidueClassMatrix( S, HomalgRing( M ) );
    
    S := GetRidOfObsoleteRows( S );
    
    if IsZero( S ) then
        
        SetIsLeftRegular( M, true );
        
    fi;
    
    return S;
    
  end,
| ‣ RelativeSyzygiesGeneratorsOfColumns( M, M2 ) | ( function ) | 
Returns: a homalg matrix over the ambient ring
RelativeSyzygiesGeneratorsOfColumns :=
  function( M, M2 )
    local M2rel, S;
    
    M2rel := UnionOfColumns( M2 );
    
    S := SyzygiesGeneratorsOfColumns( Eval( M ), M2rel );
    
    S := HomalgResidueClassMatrix( S, HomalgRing( M ) );
    
    S := GetRidOfObsoleteColumns( S );
    
    if IsZero( S ) then
        
        SetIsRightRegular( M, true );
        
    fi;
    
    return S;
    
  end,
Here we list those matrix operations for which homalg provides no fallback method.
| ‣ InitialMatrix(  ) | ( function ) | 
Returns: a homalg matrix over the ambient ring
(--> InitialMatrix (B.1-1))
InitialMatrix := C -> HomalgInitialMatrix(
                      NrRows( C ), NrColumns( C ), AmbientRing( HomalgRing( C ) ) ),
| ‣ InitialIdentityMatrix(  ) | ( function ) | 
Returns: a homalg matrix over the ambient ring
(--> InitialIdentityMatrix (B.1-2))
InitialIdentityMatrix := C -> HomalgInitialIdentityMatrix(
        NrRows( C ), AmbientRing( HomalgRing( C ) ) ),
| ‣ ZeroMatrix(  ) | ( function ) | 
Returns: a homalg matrix over the ambient ring
(--> ZeroMatrix (B.1-3))
ZeroMatrix := C -> HomalgZeroMatrix(
                      NrRows( C ), NrColumns( C ), AmbientRing( HomalgRing( C ) ) ),
| ‣ IdentityMatrix(  ) | ( function ) | 
Returns: a homalg matrix over the ambient ring
(--> IdentityMatrix (B.1-4))
IdentityMatrix := C -> HomalgIdentityMatrix(
        NrRows( C ), AmbientRing( HomalgRing( C ) ) ),
| ‣ Involution(  ) | ( function ) | 
Returns: a homalg matrix over the ambient ring
(--> Involution (B.1-5))
Involution :=
  function( M )
    local N, R;
    
    N := Involution( Eval( M ) );
    
    R := HomalgRing( N );
    
    if not ( HasIsCommutative( R ) and IsCommutative( R ) and
             HasIsReducedModuloRingRelations( M ) and
             IsReducedModuloRingRelations( M ) ) then
        
        ## reduce the matrix N w.r.t. the ring relations
        N := DecideZero( N, HomalgRing( M ) );
    fi;
    
    return N;
    
  end,
| ‣ CertainRows(  ) | ( function ) | 
Returns: a homalg matrix over the ambient ring
(--> CertainRows (B.1-6))
CertainRows :=
  function( M, plist )
    local N;
    
    N := CertainRows( Eval( M ), plist );
    
    if not ( HasIsReducedModuloRingRelations( M ) and
             IsReducedModuloRingRelations( M ) ) then
        
        ## reduce the matrix N w.r.t. the ring relations
        N := DecideZero( N, HomalgRing( M ) );
    fi;
    
    return N;
    
  end,
| ‣ CertainColumns(  ) | ( function ) | 
Returns: a homalg matrix over the ambient ring
(--> CertainColumns (B.1-7))
CertainColumns :=
  function( M, plist )
    local N;
    
    N := CertainColumns( Eval( M ), plist );
    
    if not ( HasIsReducedModuloRingRelations( M ) and
             IsReducedModuloRingRelations( M ) ) then
        
        ## reduce the matrix N w.r.t. the ring relations
        N := DecideZero( N, HomalgRing( M ) );
    fi;
    
    return N;
    
  end,
| ‣ UnionOfRows(  ) | ( function ) | 
Returns: a homalg matrix over the ambient ring
(--> UnionOfRows (B.1-8))
UnionOfRows :=
  function( A, B )
    local N;
    
    N := UnionOfRows( Eval( A ), Eval( B ) );
    
    if not ForAll( [ A, B ], HasIsReducedModuloRingRelations and
               IsReducedModuloRingRelations ) then
        
        ## reduce the matrix N w.r.t. the ring relations
        N := DecideZero( N, HomalgRing( A ) );
    fi;
    
    return N;
    
  end,
| ‣ UnionOfColumns(  ) | ( function ) | 
Returns: a homalg matrix over the ambient ring
(--> UnionOfColumns (B.1-9))
UnionOfColumns :=
  function( A, B )
    local N;
    
    N := UnionOfColumns( Eval( A ), Eval( B ) );
    
    if not ForAll( [ A, B ], HasIsReducedModuloRingRelations and
               IsReducedModuloRingRelations ) then
        
        ## reduce the matrix N w.r.t. the ring relations
        N := DecideZero( N, HomalgRing( A ) );
    fi;
    
    return N;
    
  end,
| ‣ DiagMat(  ) | ( function ) | 
Returns: a homalg matrix over the ambient ring
(--> DiagMat (B.1-10))
DiagMat :=
  function( e )
    local N;
    
    N := DiagMat( List( e, Eval ) );
    
    if not ForAll( e, HasIsReducedModuloRingRelations and
               IsReducedModuloRingRelations ) then
        
        ## reduce the matrix N w.r.t. the ring relations
        N := DecideZero( N, HomalgRing( e[1] ) );
    fi;
    
    return N;
    
  end,
| ‣ KroneckerMat(  ) | ( function ) | 
Returns: a homalg matrix over the ambient ring
(--> KroneckerMat (B.1-11))
KroneckerMat :=
  function( A, B )
    local N;
    
    N := KroneckerMat( Eval( A ), Eval( B ) );
    
    if not ForAll( [ A, B ], HasIsReducedModuloRingRelations and
               IsReducedModuloRingRelations ) then
        
        ## reduce the matrix N w.r.t. the ring relations
        N := DecideZero( N, HomalgRing( A ) );
    fi;
    
    return N;
    
  end,
| ‣ MulMat(  ) | ( function ) | 
Returns: a homalg matrix over the ambient ring
(--> MulMat (B.1-12))
MulMat :=
  function( a, A )
    
    return DecideZero( EvalRingElement( a ) * Eval( A ), HomalgRing( A ) );
    
  end,
MulMatRight :=
  function( A, a )
    
    return DecideZero( Eval( A ) * EvalRingElement( a ), HomalgRing( A ) );
    
  end,
| ‣ AddMat(  ) | ( function ) | 
Returns: a homalg matrix over the ambient ring
(--> AddMat (B.1-13))
AddMat :=
  function( A, B )
    
    return DecideZero( Eval( A ) + Eval( B ), HomalgRing( A ) );
    
  end,
| ‣ SubMat(  ) | ( function ) | 
Returns: a homalg matrix over the ambient ring
(--> SubMat (B.1-14))
SubMat :=
  function( A, B )
    
    return DecideZero( Eval( A ) - Eval( B ), HomalgRing( A ) );
    
  end,
| ‣ Compose(  ) | ( function ) | 
Returns: a homalg matrix over the ambient ring
(--> Compose (B.1-15))
Compose :=
  function( A, B )
    
    return DecideZero( Eval( A ) * Eval( B ), HomalgRing( A ) );
    
  end,
| ‣ IsZeroMatrix( M ) | ( function ) | 
Returns: true or false
(--> IsZeroMatrix (B.1-16))
IsZeroMatrix := M -> IsZero( DecideZero( Eval( M ), HomalgRing( M ) ) ),
| ‣ NrRows( C ) | ( function ) | 
Returns: a nonnegative integer
(--> NrRows (B.1-17))
NrRows := C -> NrRows( Eval( C ) ),
| ‣ NrColumns( C ) | ( function ) | 
Returns: a nonnegative integer
(--> NrColumns (B.1-18))
NrColumns := C -> NrColumns( Eval( C ) ),
| ‣ Determinant( C ) | ( function ) | 
Returns: an element of ambient homalg ring
(--> Determinant (B.1-19))
Determinant := C -> DecideZero( Determinant( Eval( C ) ), HomalgRing( C ) ),
Here we list those matrix operations for which homalg does provide a fallback method. But specifying the below homalgTable functions increases the performance by replacing the fallback method.
| ‣ AreEqualMatrices( A, B ) | ( function ) | 
Returns: true or false
(--> AreEqualMatrices (B.2-1))
AreEqualMatrices :=
  function( A, B )
    
    return IsZero( DecideZero( Eval( A ) - Eval( B ), HomalgRing( A ) ) );
    
  end,
| ‣ IsOne( M ) | ( function ) | 
Returns: true or false
(--> IsIdentityMatrix (B.2-2))
IsIdentityMatrix := M ->
          IsOne( DecideZero( Eval( M ), HomalgRing( M ) ) ),
| ‣ IsDiagonalMatrix( M ) | ( function ) | 
Returns: true or false
(--> IsDiagonalMatrix (B.2-3))
IsDiagonalMatrix := M ->
          IsDiagonalMatrix( DecideZero( Eval( M ), HomalgRing( M ) ) ),
| ‣ ZeroRows( C ) | ( function ) | 
Returns: a homalg matrix over the ambient ring
(--> ZeroRows (B.2-4))
ZeroRows := C -> ZeroRows( DecideZero( Eval( C ), HomalgRing( C ) ) ),
| ‣ ZeroColumns( C ) | ( function ) | 
Returns: a homalg matrix over the ambient ring
(--> ZeroColumns (B.2-5))
ZeroColumns := C -> ZeroColumns( DecideZero( Eval( C ), HomalgRing( C ) ) ),
generated by GAPDoc2HTML