|
# 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 );
[ Dauer der Verarbeitung: 0.27 Sekunden
(vorverarbeitet)
]
|
