SSL ideals-def.gi Sprache: unbekannt

#############################################################################
##
#W ideals-def.gi Manuel Delgado <mdelgado@fc.up.pt>
#W Pedro Garcia-Sanchez <pedro@ugr.es>
#W Jose Morais <josejoao@fc.up.pt>
##
##
#Y Copyright 2005 by Manuel Delgado,
#Y Pedro Garcia-Sanchez and Jose Joao Morais
#Y We adopt the copyright regulations of GAP as detailed in the
#Y copyright notice in the GAP manual.
##
#############################################################################

#############################################################################
##################### Defining Ideals ######################
#############################################################################
##
#F IdealOfNumericalSemigroup(l,S)
##
## l is a list of integers and S a numerical semigroup
##
## returns the ideal of S generated by l.
##
#############################################################################
InstallGlobalFunction(IdealOfNumericalSemigroup, function(l,S)
 local I;
 if not (IsNumericalSemigroup(S) and IsListOfIntegersNS(l)) then
 Error("The arguments of IdealOfNumericalSemigroup must be a numerical semigroup and a nonempty list of integers.");
 fi;
 I := rec();
 ObjectifyWithAttributes(I, IdealsOfNumericalSemigroupsType,
 UnderlyingNSIdeal, S,
 Generators, Set(l)
 );
 return I;
end );

##############################################################################
## L is a list of integers and S a numerical semigroup
## L + S is an abbreviation for IdealOfNumericalSemigroup(L, S)
##
InstallOtherMethod( \+, "for a list and a numerical semigroup", true,
 [IsList and IsAdditiveElement,
 IsNumericalSemigroup], 0,
 function( L,S )
 return(IdealOfNumericalSemigroup(L, S));
end);

##############################################################################
## n is an integer and S a numerical semigroup
## n + S is an abbreviation for IdealOfNumericalSemigroup([n], S)
##
InstallOtherMethod( \+, "for an integer and a numerical semigroup", true,
 [IsInt and IsAdditiveElement,
 IsNumericalSemigroup], 0,
 function( n,S )
 return(IdealOfNumericalSemigroup([n], S));
end);

#############################################################################
##
#M PrintObj(S)
##
## This method for ideals of numerical semigroups.
##
#############################################################################

InstallMethod( PrintObj,
 "prints an Ideal of a Numerical Semigroup",
 [ IsIdealOfNumericalSemigroup],
 function( I )
 Print(Generators(I)," + NumericalSemigroup( ", GeneratorsOfNumericalSemigroup(UnderlyingNSIdeal(I)), " )\n");
end);

#############################################################################
##
#M ViewString(S)
##
## This method for ideals of numerical semigroups.
##
#############################################################################

InstallMethod( ViewString,
 "prints an Ideal of a Numerical Semigroup",
 [ IsIdealOfNumericalSemigroup],
 function( I )
 return ("Ideal of numerical semigroup");
end);

#############################################################################
##
#M ViewObj(S)
##
## This method for ideals of numerical semigroups.
##
#############################################################################

InstallMethod( ViewObj,
 "prints an Ideal of a Numerical Semigroup",
 [ IsIdealOfNumericalSemigroup],
 function( I )
 Print("<Ideal of numerical semigroup>");
end);

#############################################################################
##
#M DisplayObj(S)
##
## This method for ideals of numerical semigroups.
##
#############################################################################
InstallMethod( Display,
 "displays an ideal of a numerical semigroup",
 [IsIdealOfNumericalSemigroup],
 function( I )
 local condensed, L, M, u;

 condensed := function(L)
 local C, bool, j, c, search;

 C := [];
 bool := true;
 j := 0;
 c := L[1];
 search := function(n) # searches the greatest subinterval starting in n
 local i, k;
 k := 0;
 for i in [Position(L,n).. Length(L)-1] do
 if not (L[i]+1 = L[i+1]) then
 c := L[i+1];
 return [n..n+k];
 fi;
 k := k+1;
 od;
 bool := false;
 return [n..L[Length(L)]];
 end;
 while bool do
 Add(C,search(c));
 od;
 return C;
 end;
 ## End of condensed() --

 L := SmallElementsOfIdealOfNumericalSemigroup(I);
 M := condensed(L);
 u := [M[Length(M)][1],"->"];
 M[Length(M)] := u;
 return M;
end);

############################################################################
##
#M Methods for the comparison of ideals of a numerical semigroup.
##
InstallMethod( \=,
 "for two ideals of numerical semigroups",
 [IsIdealOfNumericalSemigroup,
 IsIdealOfNumericalSemigroup],
 function(I, J )

 if not AmbientNumericalSemigroupOfIdeal(I)
 = AmbientNumericalSemigroupOfIdeal(J) then
 #Error("The ambient numerical semigroup must be the same for both ideals.");
 return false;
 fi;
 if HasMinimalGeneratingSystemOfIdealOfNumericalSemigroup(I) and HasMinimalGeneratingSystemOfIdealOfNumericalSemigroup(J) then
 return MinimalGeneratingSystemOfIdealOfNumericalSemigroup(I)
 = MinimalGeneratingSystemOfIdealOfNumericalSemigroup(J);
 fi;
 return SmallElementsOfIdealOfNumericalSemigroup(I)
 = SmallElementsOfIdealOfNumericalSemigroup(J);
end);

InstallMethod( \<,
 "for two ideals of a numerical semigroups",
 [IsIdealOfNumericalSemigroup,IsIdealOfNumericalSemigroup],
 function(I, J )
 if not AmbientNumericalSemigroupOfIdeal(I)
 = AmbientNumericalSemigroupOfIdeal(J) then
 Error("The ambient numerical semigroup must be the same for both ideals.");
 fi;
 return(SmallElementsOfIdealOfNumericalSemigroup(I) < SmallElementsOfIdealOfNumericalSemigroup(J));
end );

# inclusion

InstallMethod(IsSubset,
 "for ideals of affine semigroups",
 [IsIdealOfNumericalSemigroup,
 IsIdealOfNumericalSemigroup],
 function(I, J)

 if not AmbientNumericalSemigroupOfIdeal(I)
 = AmbientNumericalSemigroupOfIdeal(J) then
 return false;
 fi;
 return ForAll(MinimalGenerators(J), j-> j in I);
end);

#############################################################################
##
#A Generators(I)
#A GeneratorsOfIdealOfNumericalSemigroup(I)
##
## Returns a set of generators of the ideal I.
## If a minimal generating system has already been computed, this
## is the set returned.
############################################################################
InstallMethod(GeneratorsOfIdealOfNumericalSemigroup,
 "Returns the minimal generating system of an ideal",
 [IsIdealOfNumericalSemigroup],
 function(I)
 if HasMinimalGenerators(I) then
 return (MinimalGenerators(I));
 fi;
 return(Generators(I));
end);

#############################################################################
##
#F GeneratorsOfIdealOfNumericalSemigroupNC(I)
##
## Returns a set of generators of the ideal I.
############################################################################
# InstallGlobalFunction(GeneratorsOfIdealOfNumericalSemigroupNC, function(I)
# if not IsIdealOfNumericalSemigroup(I) then
# Error("The argument must be an ideal of a numerical semigroup.");
# fi;
# return(GeneratorsIdealNS(I));
# end);

#############################################################################
##
#F AmbientNumericalSemigroupOfIdeal(I)
##
## Returns the ambient semigroup of the ideal I.
############################################################################
InstallGlobalFunction(AmbientNumericalSemigroupOfIdeal, function(I)
 if not IsIdealOfNumericalSemigroup(I) then
 Error("The argument must be an ideal of a numerical semigroup.");
 fi;
 return(UnderlyingNSIdeal(I));
end);

#############################################################################
##
#P IsIntegralIdealOfNumericalSemigroup(i)
##
## Detects if the ideal i is contained in its ambient semigroup
##
#############################################################################
InstallMethod(IsIntegralIdealOfNumericalSemigroup,
 "Test it the ideal is integral", [IsIdealOfNumericalSemigroup],
 function(I)
 local s;

 s:=AmbientNumericalSemigroupOfIdeal(I);

 return IsSubset(s,MinimalGeneratingSystemOfIdealOfNumericalSemigroup(I));
end);

#############################################################################
##
#A SmallElementsOfIdealOfNumericalSemigroup
##
## Returns the list of elements in the ideal I up to the last gap + 1.
##
#############################################################################
InstallMethod(SmallElementsOfIdealOfNumericalSemigroup,
 "Returns the list of elements in the ideal not greater that the last gap",
 [IsIdealOfNumericalSemigroup ],
 function(I)
 local smallS, g, gI, l, min, l2, maxgap;

 # if not (IsIdealOfNumericalSemigroup(I)) then
 # Error("The argument must be an ideal of a numerical semigroup");
 # fi;

 smallS := SmallElementsOfNumericalSemigroup(AmbientNumericalSemigroupOfIdeal(I));
 g := smallS[Length(smallS)]; #Frobenius number + 1
 gI := GeneratorsOfIdealOfNumericalSemigroup(I);

 l := Union(List(gI, i -> i+ smallS));

 min := Minimum(gI);

 l := Intersection(l,[min .. min+g]);

 l2 := Difference([min..min+g],l);
 if l2 = [] then
 return([min]);
 else
 maxgap := Maximum(Difference(l2,l));
 return(Intersection(l,[min..maxgap+1]));
 fi;
end);

#############################################################################
##
#F ConductorOfIdealOfNumericalSemigroup(I)
##
## Returns the conductor of I, the largest element in SmallElements(I)
##
#############################################################################
InstallMethod(Conductor,
 "Returns the conductor of I, the largest element in SmallElements(I)",
 [IsIdealOfNumericalSemigroup ],
 function(I)
 local seI;

 # if not IsIdealOfNumericalSemigroup(I) then
 # Error("The argument must be an ideal of a numerical semigroup");
 # fi;
 seI:=SmallElementsOfIdealOfNumericalSemigroup(I);

 return seI[Length(seI)];
end);

#############################################################################
##
#F FrobeniusNumberOfIdealOfNumericalSemigroup(I)
##
## Returns the largest integer not belonging to I
##
#############################################################################
InstallMethod(FrobeniusNumber,
 "Returns the largest integer not belonging to the ideal",
 [IsIdealOfNumericalSemigroup ],
 function(I)
 return Conductor(I)-1;
end);

#############################################################################
##
#A PseudoFrobenius(I)
##
## Returns the pseudo-Frobenius numbers of the ideal I, see [DS21]
##
#############################################################################
InstallMethod(PseudoFrobenius,"Pseudo-frobenius numbers for ideals",true, [IsIdealOfNumericalSemigroup],
function(i)
 local m;
 m:=MaximalIdeal(AmbientNumericalSemigroupOfIdeal(i));
 return Difference(i-m,i);
end);

#############################################################################
##
#O Type(I)
##
## Returns the type of the ideal I, see [DS21]
##
#############################################################################
InstallMethod(Type,"Pseudo-frobenius numbers for ideals",true, [IsIdealOfNumericalSemigroup],
function(i)
 return Length(PseudoFrobenius(i));
end);

#############################################################################
##
#F BelongsToIdealOfNumericalSemigroup(n,I)
##
## Tests if the integer n belongs to the ideal I.
##
#############################################################################
InstallGlobalFunction(BelongsToIdealOfNumericalSemigroup, function(x, I)
 local gI, S, small;

 if not (IsIdealOfNumericalSemigroup(I) and IsInt(x)) then
 Error("The arguments must be an integer and an ideal of a numerical semigroup");
 fi;
 if HasSmallElementsOfIdealOfNumericalSemigroup(I) then
 small := SmallElementsOfIdealOfNumericalSemigroup(I);
 return( (x in small) or (x > Maximum(small)));
 fi;

 S := AmbientNumericalSemigroupOfIdeal(I);
 gI := GeneratorsOfIdealOfNumericalSemigroup(I);

 return(First(gI, n -> (BelongsToNumericalSemigroup(x-n,S))) <> fail);
end);
###########################################################
## n in I means BelongsToIdealOfNumericalSemigroup(n,I)
##########
InstallMethod( \in,
 "for ideals of numerical semigroups",
 [ IsInt, IsIdealOfNumericalSemigroup ],
 function( x, I )
 return BelongsToIdealOfNumericalSemigroup(x,I);
end);

#############################################################################
##
#A MinimalGenerators(I)
#A MinimalGeneratingSystem(I)
#A MinimalGeneratingSystemOfIdealOfNumericalSemigroup(I)
##
## The argument I is an ideal of a numerical semigroup
## returns the minimal generating system of I.
##
#############################################################################
InstallMethod(MinimalGeneratingSystemOfIdealOfNumericalSemigroup,
 "Returns the minimal generating system of an ideal",
 [IsIdealOfNumericalSemigroup],
 function(I)
 local S, m, mingens;

 S := AmbientNumericalSemigroupOfIdeal(I);
 m := MaximalIdealOfNumericalSemigroup(S);
 mingens := DifferenceOfIdealsOfNumericalSemigroup(I,m+I);
# Setter(Generators)(I,mingens); #does not work
 return mingens;
 end);

#############################################################################
##
#F SumIdealsOfNumericalSemigroup(I,J)
##
## returns the sum of the ideals I and J (in the same ambient semigroup)
#############################################################################
InstallGlobalFunction(SumIdealsOfNumericalSemigroup, function(I, J)
 local l1, l2, l;

 if not (IsIdealOfNumericalSemigroup(I) and IsIdealOfNumericalSemigroup(J))
 or not AmbientNumericalSemigroupOfIdeal(I)
 = AmbientNumericalSemigroupOfIdeal(J) then
 Error("The arguments must be ideals of the same numerical semigroup.");
 fi;

 l1:=GeneratorsOfIdealOfNumericalSemigroup(I);
 l2:=GeneratorsOfIdealOfNumericalSemigroup(J);
 l := Set(Cartesian(l1,l2),n -> Sum(n));
 return(IdealOfNumericalSemigroup(l,AmbientNumericalSemigroupOfIdeal(I)));
end);

###########################################################
## I + J means SumIdealsOfNumericalSemigroup(I,J)
##########

InstallOtherMethod( \+, "for ideals of the same numerical semigroup", true,
 [IsIdealOfNumericalSemigroup,
 IsIdealOfNumericalSemigroup], 0,
 function( I, J )
 return(SumIdealsOfNumericalSemigroup( I, J ));
end);

#############################################################################
##
#F SubtractIdealsOfNumericalSemigroup(I,J)
##
## returns the ideal I - J
#############################################################################
InstallGlobalFunction(SubtractIdealsOfNumericalSemigroup, function(I, J)
 local s, g, mult, gI, gJ, i, j, l, l2, maxgap, maxl, mingen,
 ideal;

 if not (IsIdealOfNumericalSemigroup(I) and IsIdealOfNumericalSemigroup(J))
 or not AmbientNumericalSemigroupOfIdeal(I)
 = AmbientNumericalSemigroupOfIdeal(J) then
 Error("The arguments must be ideals of the same numerical semigroup.");
 fi;
 s := AmbientNumericalSemigroupOfIdeal(I);
 g := FrobeniusNumberOfNumericalSemigroup(s);
 mult:= MultiplicityOfNumericalSemigroup(s);

 gI := GeneratorsOfIdealOfNumericalSemigroup(I);
 gJ := GeneratorsOfIdealOfNumericalSemigroup(J);

 i := Minimum(gI);
 j := Minimum(gJ);

 l := Filtered([i-j..i-j+g+1], n -> ForAll(gJ, z-> BelongsToIdealOfNumericalSemigroup(z+n,I)));

 l2 := Difference([i-j..i-j+g+1],l);
 if l2 = [] then
 maxgap := i-j-1;
 else
 maxgap := Maximum(Difference(l2,l));
 fi;

 l := Intersection(l,[i-j..maxgap+1]);
 maxl:= Maximum(l);

 mingen := MinimalGeneratingSystemOfIdealOfNumericalSemigroup(
 Concatenation(l,[maxl+1..maxl+mult+1])+s);

 ideal := mingen + s;

 Setter(SmallElementsOfIdealOfNumericalSemigroup)(ideal,l);

 Setter(MinimalGeneratingSystemOfIdealOfNumericalSemigroup)(ideal,mingen);

 return ideal;
end);

###########################################################
## I - J means SubtractIdealsOfNumericalSemigroup(I,J)
## I can be the ambient numerical semigroup of J
##########

InstallOtherMethod( \-, "for ideals of the same numerical semigroup", true,
 [IsIdealOfNumericalSemigroup,
 IsIdealOfNumericalSemigroup], 0,
 function( I, J )
 return(SubtractIdealsOfNumericalSemigroup( I, J ));
end);

InstallOtherMethod( \-, "for a numerical semigroup and one of its ideals", true,
 [IsNumericalSemigroup,
 IsIdealOfNumericalSemigroup], 0,
 function( S, J )
 return(SubtractIdealsOfNumericalSemigroup( 0+S, J ));
end);

#############################################################################
##
#F DifferenceOfdealsOfNumericalSemigroup(I,J)
##
## returns the set difference I\J #(J must be contained in I)-no more required, from version 1.1 on
#############################################################################
InstallOtherMethod(Difference, [IsIdealOfNumericalSemigroup, IsIdealOfNumericalSemigroup], function(I, J)
 return DifferenceOfIdealsOfNumericalSemigroup(I,J);
end);

InstallGlobalFunction(DifferenceOfIdealsOfNumericalSemigroup, function(I, J)
 local sI, sJ, MI, MJ, M, SI, SJ;

 if not (IsIdealOfNumericalSemigroup(I) and IsIdealOfNumericalSemigroup(J))
# or not AmbientNumericalSemigroupOfIdeal(I) = AmbientNumericalSemigroupOfIdeal(J)
 then
# Error("The arguments must be ideals of the same numerical semigroup.");
 Error("The arguments must be ideals of some numerical semigroup.");
 fi;
 sI := SmallElementsOfIdealOfNumericalSemigroup(I);
 sJ := SmallElementsOfIdealOfNumericalSemigroup(J);
 MI := Maximum(sI);
 MJ := Maximum(sJ);
 M := Maximum(MI,MJ);
 SI := Union(sI,[MI..M]);
 SJ := Union(sJ,[MJ..M]);
 # if not IsSubset(SI,SJ) then
 # Error("The second ideal must be contained in the first");
 # fi;
 return Difference(SI,SJ);
end);

#############################################################################
##
#F MultipleOfIdealOfNumericalSemigroup(n,I)
##
## n is a non negative integer and I is an ideal
## returns the multiple nI (I+...+I n times) of I
#############################################################################
InstallGlobalFunction(MultipleOfIdealOfNumericalSemigroup, function(n,I)
 local i, II;
 if not (IsInt(n) and n >=0 and IsIdealOfNumericalSemigroup(I)) then
 Error("The arguments must be a non negative integer and an ideal.");
 fi;
 if n=0 then
 return [0]+AmbientNumericalSemigroupOfIdeal(I);
 elif n=1 then
 return I;
 fi;
 II:=I;
 for i in [1..n-1] do
 II := II+I;
 od;
 return II;
end);
###########################################################
## n is an integer and S a numerical semigroup
## n * I is an abbreviation for MultipleOfIdealOfNumericalSemigroup(n,I)
##########
InstallOtherMethod( \*, "for a non negative integer and an ideal of a numerical semigroup", true,
 [IsInt and IsMultiplicativeElement,
 IsIdealOfNumericalSemigroup], 999999990,
 function( n,I )
 return(MultipleOfIdealOfNumericalSemigroup(n, I));
end);

#############################################################################
##
#F HilbertFunctionOfIdealOfNumericalSemigroup(n,I)
##
## returns the value of the Hilbert function associated to I in n,
## that is, nI\(n+1)I. I must be an ideal included in its ambient semigroup.
#############################################################################
InstallGlobalFunction(HilbertFunctionOfIdealOfNumericalSemigroup, function(n,I)
 if not (IsInt(n) and n >=0 and IsIdealOfNumericalSemigroup(I)) then
 Error("The arguments must be a non negative integer and an ideal.");
 fi;
 return Length(DifferenceOfIdealsOfNumericalSemigroup(n*I,(n+1)*I));
end);

InstallMethod(HilbertFunction,
 "gives the Hilbert function of the ideal",
 [IsIdealOfNumericalSemigroup],
 function(I)
 return n->HilbertFunctionOfIdealOfNumericalSemigroup(n,I);
 end);

#############################################################################
##
#P IsMonomialNumericalSemigroup
## Tests if a numerical semigroup is a monomial semigroup ring
##
#############################################################################
InstallMethod(IsMonomialNumericalSemigroup,
 "Detects if the semigroup ring of the semigroup is monomial",[IsNumericalSemigroup],
 function(s)
 local l,c,gen,gaps;

 gen:=MinimalGeneratingSystemOfNumericalSemigroup(s);
 gaps:=GapsOfNumericalSemigroup(s);
 l:=List(gen,g->Filtered(gaps-g,x->x>0));
 c:=Filtered(Cartesian([1..Length(l)],[1..Length(l)]),x->x[1]<x[2]);
 return First(c,x->Intersection(l[x[1]],l[x[2]])<>[])=fail;
end);

#############################################################################
##
#F BlowUpIdealOfNumericalSemigroup(I)
##
##
#############################################################################
InstallGlobalFunction(BlowUpIdealOfNumericalSemigroup, function(I)
 local r;
 if not IsIdealOfNumericalSemigroup(I) then
 Error("The argument must be an ideal.");
 fi;

 r:=ReductionNumberIdealNumericalSemigroup(I);

 return r*I-r*I;
end);

InstallMethod(BlowUp,
 "blow up of a numerical semigroup",
 [IsIdealOfNumericalSemigroup],
 BlowUpIdealOfNumericalSemigroup);

#############################################################################
##
#F MaximalIdealOfNumericalSemigroup(S)
##
## Returns the maximal ideal of S.
##
#############################################################################
InstallGlobalFunction(MaximalIdealOfNumericalSemigroup, function(S)
 if not IsNumericalSemigroup(S) then
 Error("The argument must be a numerical semigroup.");
 fi;
 return MinimalGeneratingSystemOfNumericalSemigroup(S)+S;
end);

InstallMethod(MaximalIdeal,
 "of a numerical semigroup",
 [IsNumericalSemigroup],
 MaximalIdealOfNumericalSemigroup);

#############################################################################
##
#F BlowUpOfNumericalSemigroup(s)
##
## Computes the Blow Up (of the maximal ideal) of
## the numerical semigroup <s>.
##
#############################################################################
InstallGlobalFunction(BlowUpOfNumericalSemigroup, function(s)
 local gen, genbu, m;

 if not IsNumericalSemigroup(s) then
 Error("The argument must be a numerical semigroup.");
 fi;

 gen:=MinimalGeneratingSystemOfNumericalSemigroup(s);
 m:=MultiplicityOfNumericalSemigroup(s);
 genbu:=gen-m;
 genbu:=genbu+[m];

 return NumericalSemigroup(genbu);
end);

InstallMethod(BlowUp,
 "Blow up of the numerical semigroup",
 [IsNumericalSemigroup],
 BlowUpOfNumericalSemigroup);

#############################################################################
##
#F MultiplicitySequenceOfNumericalSemigroup(s)
##
## Computes the multiplicity sequence of the numerical semigroup <s>.
##
#############################################################################
InstallGlobalFunction(MultiplicitySequenceOfNumericalSemigroup, function(s)
 local msg, m;

 if not(IsNumericalSemigroup(s)) then
 Error("The argument must be a numerical semigroup");
 fi;

 if (1 in s) then
 return [1];
 fi;

 msg:=MinimalGenerators(s);
 m:=MultiplicityOfNumericalSemigroup(s);
 msg:=Union(Difference(msg-m,[0]),[m]);
 return Concatenation([m],MultiplicitySequenceOfNumericalSemigroup(NumericalSemigroup(msg)));
end);

InstallMethod(MultiplicitySequence,
 "of a numerical semigroup",
 [IsNumericalSemigroup],
 MultiplicitySequenceOfNumericalSemigroup);

#############################################################################
##
#F MicroInvariantsOfNumericalSemigroup(s)
##
## Computes the microinvariants of the numerical semigroup <s>
## using the formula given by Valentina and Ralf [BF06]. The
## microinvariants of a numerial semigroup where introduced
## by J. Elias in [E01].
##
#############################################################################
InstallGlobalFunction(MicroInvariantsOfNumericalSemigroup, function(s)
 local e,m;

 if not IsNumericalSemigroup(s) then
 Error("The argument must be a numerical semigroup.");
 fi;

 m:=MaximalIdealOfNumericalSemigroup(s);
 e:=MultiplicityOfNumericalSemigroup(s);
 return (-AperyListOfNumericalSemigroupWRTElement(BlowUpOfNumericalSemigroup(s),e)
 +AperyListOfNumericalSemigroupWRTElement(s,e))/e;

end);
InstallMethod(MicroInvariants,
 "of a numerical semigroup",
 [IsNumericalSemigroup],
 MicroInvariantsOfNumericalSemigroup);

#############################################################################
##
#P IsGradedAssociatedRingNumericalSemigroupCM(s)
##
## Returns true if the associated graded ring of
## the semigroup ring algebra k[[s]] is Cohen-Macaulay.
## This function implements the algorithm given in [BF06].
##
#############################################################################
InstallMethod(IsGradedAssociatedRingNumericalSemigroupCM,
 "Tests for Cohen-Macaulayness of graded ring associated to the numerical semigroup",
 [IsNumericalSemigroup],
 function(s)
 local ai,bi,e,m;

 if not IsNumericalSemigroup(s) then
 Error("The argument must be a numerical semigroup.");
 fi;

 m:=MaximalIdealOfNumericalSemigroup(s);
 e:=MultiplicityOfNumericalSemigroup(s);
 ai:=MicroInvariantsOfNumericalSemigroup(s);
 bi:=List(AperyListOfNumericalSemigroupWRTElement(s,e),
 w->MaximumDegreeOfElementWRTNumericalSemigroup(w,s));
 return ai=bi;
end);

#############################################################################
##
#F CanonicalIdealOfNumericalSemigroup(S)
##
## Computes a canonical ideal of S [B06]:
## { x in Z | g-x not in S}
##
#############################################################################
InstallGlobalFunction(CanonicalIdealOfNumericalSemigroup, function(s)

 if not IsNumericalSemigroup(s) then
 Error("The argument must be a numerical semigroup.");
 fi;

 return IdealOfNumericalSemigroup(FrobeniusNumberOfNumericalSemigroup(s)-
 PseudoFrobeniusOfNumericalSemigroup(s),s);
end);

InstallMethod(CanonicalIdeal,
 "of a numerical semigroup",
 [IsNumericalSemigroup],
 CanonicalIdealOfNumericalSemigroup);

#############################################################################
##
#P IsCanonicalIdealOfNumericalSemigroup(e)
##
## Detects if the ideal e is a translation of the canonical ideal of its
## ambient semigroup
##
#############################################################################
InstallMethod(IsCanonicalIdealOfNumericalSemigroup,
 "Detects if the ideal is canonical", [IsIdealOfNumericalSemigroup],
 function(i)

 local c, mc, me;

 if not(IsIdealOfNumericalSemigroup(i)) then
 Error("The argument must be an ideal of a numerical semigroup");
 fi;

 c:=CanonicalIdealOfNumericalSemigroup(AmbientNumericalSemigroupOfIdeal(i));
 if c=i then
 return true;
 fi;

 mc:=Minimum(Generators(c));
 me:=Minimum(Generators(i));

 return i=(me-mc)+c;
end);

#############################################################################
##
#P IsAlmostCanonical(e)
##
## Detects if the ideal e is almost canonical as defined in [DS21]
##
#############################################################################
InstallMethod(IsAlmostCanonical, "Tests if an ideal of a numerical semigroup is almost canonical", true, [IsIdealOfNumericalSemigroup],
function(I)
local S,f,c,J,K,M;
S:=AmbientNumericalSemigroupOfIdeal(I);
f:=FrobeniusNumber(S);
c:=Conductor(I);
J:=(f-c+1)+I;
M:=MaximalIdeal(S);
 K:=CanonicalIdeal(S);
return(J-M=K-M);
end);

InstallTrueMethod(IsAlmostCanonical, IsCanonicalIdeal);

#############################################################################
##
#F TraceIdealOfNumericalSemigroup(S)
##
## Computes a canonical ideal of S [B06]:
## { x in Z | g-x not in S}
##
#############################################################################
InstallGlobalFunction(TraceIdealOfNumericalSemigroup, function(s)
 local K;

 if not IsNumericalSemigroup(s) then
 Error("The argument must be a numerical semigroup.");
 fi;
 K:=CanonicalIdeal(s);
 return(K+(s-K));

end);

InstallMethod(TraceIdeal,
 "of a numerical semigroup",
 [IsNumericalSemigroup],
 TraceIdealOfNumericalSemigroup);

#############################################################################
##
#F ReductionNumberIdealNumericalSemigroup(I)
##
## Returns the least nonnegative integer such that
## nI-nI=(n+1)I-(n+1)I, see [B06].
##
#############################################################################
InstallMethod(ReductionNumber,
"Computes the reduction number of the ideal",
[IsIdealOfNumericalSemigroup],
function(I)

 local n, S, i;

 i:=Minimum(SmallElementsOfIdealOfNumericalSemigroup(I));
 n := 1;
 S:=AmbientNumericalSemigroupOfIdeal(I);
 while (n+1)*I <> (i+MinimalGeneratingSystemOfIdealOfNumericalSemigroup(n*I))+S do
 n := n+1;
 od;
 return n;

end);

#############################################################################
##
#F RatliffRushClosureOfIdealOfNumericalSemigroup(I)
##
## Returns the the union of all (n+1)I-nI with n nonnegative integers
##
#############################################################################
InstallGlobalFunction(RatliffRushClosureOfIdealOfNumericalSemigroup,
function(I)

 local r,S;

 if not IsIdealOfNumericalSemigroup(I) then
 Error("The argument must be an ideal.");
 fi;

 r:=ReductionNumberIdealNumericalSemigroup(I);
 S:=AmbientNumericalSemigroupOfIdeal(I);
 return Intersection(0+S,(r+1)*I-r*I);
end);

InstallMethod(RatliffRushClosure,
 "Ratliff-Rush closure of an ideal of a numerical semigroup",
 [IsIdealOfNumericalSemigroup],
 RatliffRushClosureOfIdealOfNumericalSemigroup);

#############################################################################
##
#F RatliffRushNumberOfIdealOfNumericalSemigroup(I)
##
## Returns the least nonnegative integer such that
## (n+1)I-nI is the Ratliff-Rush closure of I, see [DA-G-H].
##
#############################################################################
InstallGlobalFunction(RatliffRushNumberOfIdealOfNumericalSemigroup,
function(I)

 local n, S, rrc;

 if not IsIdealOfNumericalSemigroup(I) then
 Error("The argument must be an ideal.");
 fi;

 rrc:=RatliffRushClosureOfIdealOfNumericalSemigroup(I);
 S:=AmbientNumericalSemigroupOfIdeal(I);
 n:=0;
 while rrc<>Intersection(0+S,(n+1)*I-n*I) do
 n:=n+1;
 od;

 return n;
end);

InstallMethod(RatliffRushNumber,
 "Ratliff-Rush number of ideal of a numerical semigroup",
 [IsIdealOfNumericalSemigroup],
 RatliffRushNumberOfIdealOfNumericalSemigroup);

#############################################################################
##
#F AsymptoticRatliffRushNumberOfIdealOfNumericalSemigroup(I)
##
## Returns the least nonnegative integer n such that
## mI equals the Ratliff-Rush closure of mI for all m>=n, see [DA-G-H].
##
#############################################################################
InstallGlobalFunction(AsymptoticRatliffRushNumberOfIdealOfNumericalSemigroup,
function(I)

 local r, nI, n;

 if not IsIdealOfNumericalSemigroup(I) then
 Error("The argument must be an ideal.");
 fi;

 r:=ReductionNumberIdealNumericalSemigroup(I);
 n:=r;
 while n>0 do
 nI:=n*I;
 if nI<>RatliffRushClosureOfIdealOfNumericalSemigroup(nI) then
 return n+1;
 fi;
 n:=n-1;
 od;
end);

InstallMethod(AsymptoticRatliffRushNumber,
 "Asymptotic Ratliff-Rush number of ideal of a numerical semigroup",
 [IsIdealOfNumericalSemigroup],
 AsymptoticRatliffRushNumberOfIdealOfNumericalSemigroup);

#############################################################################
##
#F TranslationOfIdealOfNumericalSemigroup(k,I)
##
## Given an ideal of a numerical semigroup S and an integer <k>
## returns an ideal of the numerical semigroup S generated by
## {i1+k,...,in+k} where {i1,...,in} is the system of generators of .
##
#############################################################################
InstallGlobalFunction(TranslationOfIdealOfNumericalSemigroup, function(k,I)
 local l;
 if not IsInt(k) then
 Error("<k> must be an integer");
 fi;
 if not IsIdealOfNumericalSemigroup(I) then
 Error(" must be an ideal of a numerical semigroup");
 fi;
 l := List(GeneratorsOfIdealOfNumericalSemigroup(I), g -> g+k);
 return IdealOfNumericalSemigroup(l, AmbientNumericalSemigroupOfIdeal(I));
end);

##############################################################################
##
## <k> is an integer and an ideal of a numerical semigroup.
## k + I is an abbreviation for TranslationOfIdealOfNumericalSemigroup(k, I)
##
InstallOtherMethod( \+, "for an integer and an ideal of a numerical semigroup", true,
 [IsInt and IsAdditiveElement,
 IsIdealOfNumericalSemigroup], 0,
 function(k,I)
 return(TranslationOfIdealOfNumericalSemigroup(k, I));
end);
InstallOtherMethod( \+, "for an ideal of a numerical semigroup and an integer", true,
 [IsIdealOfNumericalSemigroup,
 IsInt and IsAdditiveElement], 0,
 function(I,k)
 return(TranslationOfIdealOfNumericalSemigroup(k, I));
end);

#############################################################################
##
#F IntersectionIdealsOfNumericalSemigroup(I,J)
##
## Given two ideals and <J> of a numerical semigroup S
## returns the ideal of the numerical semigroup S which is the
## intersection of the ideals and <J>.
##
#############################################################################
InstallOtherMethod(Intersection2, [IsIdealOfNumericalSemigroup, IsIdealOfNumericalSemigroup], function(I,J)
 return IntersectionIdealsOfNumericalSemigroup(I,J);
end);

InstallGlobalFunction(IntersectionIdealsOfNumericalSemigroup, function(I, J)
 local l,i,j,max,mult,l1,l2;

 if not (IsIdealOfNumericalSemigroup(I) and IsIdealOfNumericalSemigroup(J))
 or not AmbientNumericalSemigroupOfIdeal(I)
 = AmbientNumericalSemigroupOfIdeal(J) then
 Error("The arguments must be ideals of the same numerical semigroup.");
 fi;

 mult:=MultiplicityOfNumericalSemigroup(AmbientNumericalSemigroupOfIdeal(I));

 l1:=SmallElementsOfIdealOfNumericalSemigroup(I);
 l2:=SmallElementsOfIdealOfNumericalSemigroup(J);
 i:=Maximum(l1);
 j:=Maximum(l2);
 max:=Maximum(i,j);
 l1:=Concatenation(l1,[(i+1)..max]);
 l2:=Concatenation(l2,[(j+1)..max]);
 l := Concatenation(Intersection(l1,l2),[(max+1)..(max+mult)]);

 return(IdealOfNumericalSemigroup(l,AmbientNumericalSemigroupOfIdeal(I)));

end);

#############################################################################
##
#O Union(I,J)
##
## Given two ideals and <J> of a numerical semigroup S
## returns their union
##
#############################################################################
InstallOtherMethod(Union2, [IsIdealOfNumericalSemigroup, IsIdealOfNumericalSemigroup],
function(I,J)
 if not(AmbientNumericalSemigroupOfIdeal(I)=AmbientNumericalSemigroupOfIdeal(J)) then
 Error("Both ideals must be ideals of the same semigroup");
 fi;
 return Union(MinimalGenerators(I),MinimalGenerators(J))+AmbientNumericalSemigroupOfIdeal(I);
end);

########################################################################
##
#F AperyListOfIdealOfNumericalSemigroupWRTElement(I,n)
##
## Computes the sets of elements x of I such that x-n not in I,
## where n is supposed to be in the ambient semigroup of I.
## The element in the i-th position of the output list (starting in 0)
## is congruent with i modulo n
########################################################################
InstallGlobalFunction(AperyListOfIdealOfNumericalSemigroupWRTElement,function(ideal,n)
local msg, apambient, s, ap, cand, i;

s:=AmbientNumericalSemigroupOfIdeal(ideal);
apambient:=AperyListOfNumericalSemigroupWRTElement(s,n);
msg:=MinimalGeneratingSystemOfIdealOfNumericalSemigroup(ideal);
ap:=ShallowCopy(apambient);

cand:=Set(Cartesian(msg,apambient), p->p[1]+p[2]);

for i in [0..n-1] do
 ap[i+1]:=Minimum(Filtered(cand, w-> w mod n=i));
od;
return ap;
end);

InstallOtherMethod(AperyList,
 "for ideals and an element in the ambient semigroup",
 [IsIdealOfNumericalSemigroup,IsInt],
 AperyListOfIdealOfNumericalSemigroupWRTElement);

InstallOtherMethod(AperyList,
 "for ideals and the multiplicity of the ambient semigroup",
 [IsIdealOfNumericalSemigroup],
 function(i)
 return AperyListOfIdealOfNumericalSemigroupWRTElement(i,Multiplicity(AmbientNumericalSemigroupOfIdeal(i)));
 end);

########################################################################
##
#F AperyTableOfNumericalSemigroup(S)
##
## Computes the Apéry table associated to S as
## explained in [CJZ],
## that is, a list containing the Apéry list of S with respect to
## its multiplicity and the Apéry lists of kM (with M the maximal
## ideal of S) with respect to the multiplicity of S, for k=1..r,
## where r is the reduction number of M
## (see ReductionNumberIdealNumericalSemigroup).
########################################################################
InstallGlobalFunction(AperyTableOfNumericalSemigroup,function(S)
local M,m, table, k, r;

M:=MaximalIdealOfNumericalSemigroup(S);
m:=MultiplicityOfNumericalSemigroup(S);
table:=[AperyListOfNumericalSemigroupWRTElement(S,m)];
r:=ReductionNumberIdealNumericalSemigroup(M);
for k in [1..r] do
 Append(table,[AperyListOfIdealOfNumericalSemigroupWRTElement(k*M,m)]);
od;
return table;
end);

InstallMethod(AperyTable,
 "for numerical semigroups",
 [IsNumericalSemigroup],
 AperyTableOfNumericalSemigroup);

########################################################################
##
#F StarClosureOfIdealOfNumericalSemigroup(i,is)
## i is an ideal and is is a set of ideals (all from the same
## numerical semigroup). The output is i^{*_is}, where
## *_is is the star operation generated by is
## The implementation uses Section 3 of
## -D. Spirito, Star Operations on Numerical Semigroups
########################################################################

InstallGlobalFunction(StarClosureOfIdealOfNumericalSemigroup, function(i,is)
local j, s, k;

s:=AmbientNumericalSemigroupOfIdeal(i);
j:=s-(s-i); # i^v

for k in is do
 j:=IntersectionIdealsOfNumericalSemigroup(j,k-(k-i));
od;

return j;

end);

########################################################################
## The minimum of an ideal
##

InstallOtherMethod( MinimumList,
"minimum of an ideal",
[IsIdealOfNumericalSemigroup],
function( I )
 if HasSmallElements(I) then
 return Minimum(SmallElements(I));
 fi;
 return Minimum(Generators(I));
end);

##################################################################################
##
#O Iterator(I)
## Iterator for ideals of numerical semigroups
##################################################################################
InstallMethod(Iterator,
 "Iterator for numerical semigroups",
 [IsIdealOfNumericalSemigroup],
 function(ideal)
 local iter;

 iter:=IteratorByFunctions(rec(
 pos := -1,
 i := ideal,
 IsDoneIterator := ReturnFalse,
 NextIterator := function(iter)
 local n, m;
 m:=Multiplicity(AmbientNumericalSemigroupOfIdeal(iter!.i));
 n:=First([iter!.pos+1..iter!.pos+m+1],
 x->x in iter!.i);
 iter!.pos:=n;
 return n;
 end,
 ShallowCopy := iter -> rec( i := iter!.i, pos := iter!.pos )
 ));
 return iter;
 end
);

#############################################################################
##
#F ElementNumber_IdealOfNumericalSemigroup(I,n)
# Given an ideal I of a numerical semigroup and an integer n, returns
# the nth element of I
#############################################################################
InstallGlobalFunction(ElementNumber_IdealOfNumericalSemigroup,
 function(I,r)
 local selts, n;
 if r<=0 then
 Error("The index must be a positive integer");
 fi;
 if not(IsIdealOfNumericalSemigroup(I)) then
 Error("The first argument must be an ideal of a numerical semigroup");
 fi;
 selts := SmallElementsOfIdealOfNumericalSemigroup( I );
 n := Length(selts);
 if r <= Length(selts) then
 return selts[r];
 else
 return selts[n] + r - n;
 fi;
end);

#############################################################################
##
#F NumberElement_IdealOfNumericalSemigroup(S,n)
# Given an ideal of a numerical semigroup I and an integer n, returns the
# position of n in I
#############################################################################
InstallGlobalFunction(NumberElement_IdealOfNumericalSemigroup,
 function(i,n)
 local c, nse;
 if not(n in i) then
 return(fail);
 fi;
 c:=Conductor(i);
 if n<=c then
 return Position(SmallElements(i),n);
 fi;
 nse:=Length(SmallElements(i));
 return nse+n-c;
 end
);

##################################################################################
##
#O I[n]
## The nth element of I
##################################################################################

InstallOtherMethod(\[\], [IsIdealOfNumericalSemigroup,IsInt],
 function(i,n)
 return ElementNumber_IdealOfNumericalSemigroup(i,n);
 end
);

##################################################################################
##
#O I{ls}
## [I[n] : n in ls]
##################################################################################

InstallOtherMethod(\{\}, [IsIdealOfNumericalSemigroup,IsList],
 function(i,l)
 return List(l,n->i[n]);
 end
);

########################################################################
##
#O IrreducibleZComponents(I)
##
## I is an ideal of a numerical semigroup
## The output is the list of irreducible Z-components of the ideal
## There are exactly t(I) (type of I) Z-components and I is the
## intersection of them
## See Proposition 24 in A. Assi, M. D'Anna, P. A. García-Sánchez,
## Numerical semigroups and applications, Second edition,
## RSME Springer series 3, Springer, Switzerland, 2020.
########################################################################
InstallMethod(IrreducibleZComponents,
 "Irreducible Z-components for ideals of numerical semigroups",
 [IsIdealOfNumericalSemigroup],
function(I)
 local K, MG, output, g, S;
 S:=AmbientNumericalSemigroupOfIdeal(I);
 K:=CanonicalIdeal(S);
 MG:=K-I;
 MG:=MinimalGenerators(MG);
 output:=[];
 for g in MG do
 Add(output, -g+K);
 od;
 return output;
end
);

########################################################################
##
#O DecomposeIntegralIdealIntoIrreducibles(i)
##
## i is an integral (proper) ideal of a numerical semigroup S
## The output is a list of irreducible ideals of S, such that its
## intersection is the unique irredundant decompostion of i into
## proper irreducible ideals
## The calculation is performed using Theorem 4 in
## A. Assi, M. D'Anna, P. A. García-Sánchez,
## Numerical semigroups and applications, Second edition,
## RSME Springer series 3, Springer, Switzerland, 2020.
########################################################################
InstallMethod(DecomposeIntegralIdealIntoIrreducibles,
 "for integral (proper) ideals of numerical semigroups",
 [IsIdealOfNumericalSemigroup],
function(I)
 local M,Dif, XI,output,x,d,S;
 if not(IsIntegral(I)) then
 Error("The argument must be an integral ideal (proper ideal)");
 fi;
 S:=AmbientNumericalSemigroupOfIdeal(I);
 M:=MaximalIdeal(S);
 Dif:=I-M;
 XI:=Difference(Intersection(0+S,Dif),I);
 output:=[];
 for x in XI do
 d:=DivisorsOfElementInNumericalSemigroup(x,S);
 Add(output,IdealByDivisorClosedSet(d,S));
 od;
 return output;
end
);

SSL ideals-def.gi Sprache: unbekannt

[ Verzeichnis aufwärts0.54unsichere Verbindung Übersetzung europäischer Sprachen durch Browser ]