Quelle Tools.gi Sprache: unbekannt

# SPDX-License-Identifier: GPL-2.0-or-later
# Modules: A homalg based package for the Abelian category of finitely presented modules over computable rings
#
# Implementations
#

##  Implementations of tool procedures.

####################################
#
# methods for operations:
#
####################################

##
InstallMethod( IntersectWithSubalgebra,
        "for ideals",
        [ IsFinitelyPresentedSubmoduleRep and ConstructedAsAnIdeal, IsList ],

  function( I, var )
    local left, ideal;

    left := IsHomalgLeftObjectOrMorphismOfLeftObjects( I );

    I := MatrixOfSubobjectGenerators( I );

    if not left then
        I := Involution( I );
    fi;

    I := IntersectWithSubalgebra( I, var );

    if not left then
        I := Involution( I );
    fi;

    if left then
        ideal := LeftSubmodule;
    else
        ideal := RightSubmodule;
    fi;

    return ideal( I );

end );

##
InstallMethod( MaximalIndependentSet,
        "for ideals",
        [ IsFinitelyPresentedSubmoduleRep and ConstructedAsAnIdeal ],

  function( I )
    local left;

    left := IsHomalgLeftObjectOrMorphismOfLeftObjects( I );

    I := MatrixOfSubobjectGenerators( I );

    if not left then
        I := Involution( I );
    fi;

    return MaximalIndependentSet( I );

end );

##
InstallMethod( EliminateOverBaseRing,
        "for a matrix and a list",
        [ IsHomalgMatrix, IsList, IsInt ],

  function( M, elim, d )
    local R, B, indets, L, N, n, monoms, monomStr, monomS, m,
          MonomsL, monomsL, monomSL, posL, coeffs, coeffsL;

    if not NumberColumns( M ) = 1 then
        Error( "the number of columns must be 1\n" );
    fi;

    R := HomalgRing( M );

    if HasRelativeIndeterminatesOfPolynomialRing( R ) then
        B := BaseRing( R );
        indets := RelativeIndeterminatesOfPolynomialRing( R );
    elif HasIndeterminatesOfPolynomialRing( R ) then
        B := CoefficientsRing( R );
        indets := IndeterminatesOfPolynomialRing( R );
    elif IsFieldForHomalg( R ) then
        return HomalgZeroMatrix( 0, 1, R );
    else
        TryNextMethod( );
    fi;

    if not IsSubset( indets, elim ) then
        Error( "the second argument is not a subset of the list of indeterminates\n" );
    fi;

    L := Difference( indets, elim );

    if d > 0 then
        indets := HomalgMatrix( indets, R );
    fi;

    while d > 0 do
        M := UnionOfRows( M, KroneckerMat( indets, M ) );
        d := d - 1;
    od;

    M := EntriesOfHomalgMatrix( M );

    M := List( M, Coefficients );

    N := List( M, a -> a!.monomials );

    n := Length( N );

    M := List( M, a -> B * a );

    monoms := Concatenation( N );

    ## check if a monomial could be reconstructed from its string
    m := Length( monoms );
    if m > 0 then
        Assert( 0, monoms[m] = String( monoms[m] ) / R );
    fi;

    monomStr := List( monoms, String );

    monomS := Set( monomStr );

    monoms := monoms{List( monomS, a -> Position( monomStr, a ) )};

    m := Length( monoms );

    MonomsL := Select( HomalgMatrix( monoms, m, 1, R ), L );

    monomsL := EntriesOfHomalgMatrix( MonomsL );

    monomSL := List( monomsL, String );

    posL := List( monomSL, a -> PositionSet( monomS, a ) );

    monoms := Concatenation( monomsL, monoms{Difference( [ 1 .. m ], posL )} );

    Assert( 0, m = Length( monoms ) );

    monomS := List( monoms, String );

    N := List( N, a -> List( a, b -> Position( monomS, String( b ) ) ) );

    coeffs := HomalgInitialMatrix( n, m, B );

    Perform( [ 1 .. n ],
            function( r )
              local l;
              l := N[r];
              Perform( [ 1 .. Length( l ) ],
                      function( c )
                        coeffs[ r, l[c] ] := M[r][ c, 1 ];
                      end );
            end );

    MakeImmutable( coeffs );

    coeffs := LeftSubmodule( coeffs );

    n := Length( monomsL );

    coeffsL := UnionOfColumns(
                       HomalgIdentityMatrix( n, B ),
                       HomalgZeroMatrix( n, m - n, B )
                       );

    coeffsL := Subobject( coeffsL, SuperObject( coeffs ) );

    elim := Intersect( coeffs, coeffsL );

    OnBasisOfPresentation( elim );

    ByASmallerPresentation( elim );

    elim := MatrixOfSubobjectGenerators( elim );

    elim := CertainColumns( elim, [ 1 .. n ] );

    return ( R * elim ) * MonomsL;

end );

##
InstallMethod( EliminateOverBaseRing,
        "for a matrix and a list",
        [ IsHomalgMatrix, IsList ],

  function( M, elim )

    return EliminateOverBaseRing( M, elim, 0 );

end );

##
InstallMethod( SimplifiedInequalities,
        [ IsList ],

  function( ineqs )
    local R, A;

    if ineqs = [ ] then
        return ineqs;
    fi;

    R := HomalgRing( ineqs[1] );

    ## normalize
    ineqs := List( ineqs, DecideZero );

    if ForAny( ineqs, IsZero ) then
        Error( "the input list of inequalities contains a zero element\n" );
    fi;

    ineqs := Set( ineqs );

    if HasAmbientRing( R ) then
        A := AmbientRing( R );
        ineqs := List( ineqs, i -> i / A );
    fi;

    ## radical decomposition
    ineqs := List( ineqs, i -> RadicalDecomposition( LeftSubmodule( [ i ] ) ) );
    ineqs := Concatenation( ineqs );
    ineqs := List( ineqs, i -> MatElm( MatrixOfSubobjectGenerators( i ), 1, 1 ) );
    ineqs := Set( ineqs );

    if HasAmbientRing( R ) then
        ineqs := List( ineqs, i -> i / R );
    fi;

    ## get rid of constants
    ineqs := Filtered( ineqs, i -> not IsUnit( i ) );

    return ineqs;

end );

##
InstallMethod( SimplifiedInequalities,
        [ IsHomalgMatrix ],

  function( ineqs )

    ineqs := EntriesOfHomalgMatrix( ineqs );

    return SimplifiedInequalities( ineqs );

end );

##
InstallMethod( DefiningIdeal,
        "for homalg rings",
        [ IsHomalgRing and IsHomalgResidueClassRingRep ],

  function( R )
    local m, ideal;

    m := MatrixOfRelations( R );

    if NumberColumns( m ) = 1 then
        ideal := LeftSubmodule;
    elif NumberRows( m ) = 1 then
        ideal := RightSubmodule;
    else
        Error( "the matrix of relations m of the residue class ring R has a weird shape\n" );
    fi;

    return ideal( m );

end );

##
InstallMethod( DefiningIdealFromNameOfResidueClassRing,
        "for a homalg ring and a string",
        [ IsHomalgRing, IsString ],

  function( R, string )
    local pos1, pos2, vars, gens;

    pos1 := Position( string, '[' );

    if not pos1 = fail then
        pos2 := Position( string, ']' );
        vars := string{[ pos1 + 1 .. pos2 - 1 ]};
        R := R * vars;
    fi;

    pos1 := Position( string, '(' );

    gens := "0";

    if not pos1 = fail then
        pos2 := Position( string, ')' );
        gens := string{[ pos1 + 1 .. pos2 - 1 ]};

    fi;

    return LeftSubmodule( gens, R );

end );

Quelle Tools.gi Sprache: unbekannt

[ Dauer der Verarbeitung: 0.27 Sekunden (vorverarbeitet) ]