GAP (NumericalSgps) - Chapter 5: Constructing numerical semigroups from others

Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C Bib Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

[MathJax on]

5 Constructing numerical semigroups from others
5.1 Adding and removing elements of a numerical semigroup
5.1-1 RemoveMinimalGeneratorFromNumericalSemigroup
5.1-2 AddSpecialGapOfNumericalSemigroup
5.2 Intersections, quotients, dilatations, numerical duplications and multiples by integers
5.2-1 Intersection
5.2-2 QuotientOfNumericalSemigroup
5.2-3 MultipleOfNumericalSemigroup
5.2-4 NumericalDuplication
5.2-5 AsNumericalDuplication
5.2-6 InductiveNumericalSemigroup
5.2-7 DilatationOfNumericalSemigroup
5.3 Constructing the set of all numerical semigroups containing a given numerical semigroup
5.3-1 OverSemigroups
5.4 Constructing the set of numerical semigroup with given Frobenius number
5.4-1 NumericalSemigroupsWithFrobeniusNumberFG
5.4-2 NumericalSemigroupsWithFrobeniusNumberAndMultiplicity
5.4-3 NumericalSemigroupsWithFrobeniusNumber
5.5 Constructing the set of numerical semigroups with genus g
5.5-1 NumericalSemigroupsWithGenus
5.6 Constructing the set of numerical semigroups with a given set of pseudo-Frobenius numbers
5.6-1 ForcedIntegersForPseudoFrobenius
5.6-2 SimpleForcedIntegersForPseudoFrobenius
5.6-3 NumericalSemigroupsWithPseudoFrobeniusNumbers
5.6-4 ANumericalSemigroupWithPseudoFrobeniusNumbers

### 5 Constructing numerical semigroups from others

This chapter provides several functions to construct numerical semigroups from others (via intersections, quotients by an integer, removing or adding integers, etc.).

#### 5.1 Adding and removing elements of a numerical semigroup

In this section we show how to construct new numerical semigroups from a given numerical semigroup. Two dual operations are presented. The first one removes a minimal generator from a numerical semigroup. The second adds a special gap to a semigroup (see [RGSGGJM03]).

##### 5.1-1 RemoveMinimalGeneratorFromNumericalSemigroup

`‣ RemoveMinimalGeneratorFromNumericalSemigroup`( n, S ) | ( function )

S is a numerical semigroup and n is one if its minimal generators.

The output is the numerical semigroup S ∖{n} (see [RGSGGJM03]; S∖{n} is a numerical semigroup if and only if n is a minimal generator of S).

    gap> s:=NumericalSemigroup(3,5,7);
    <Numerical semigroup with 3 generators>
    gap> RemoveMinimalGeneratorFromNumericalSemigroup(7,s);
    <Numerical semigroup with 3 generators>
    gap> MinimalGeneratingSystemOfNumericalSemigroup(last);
    [ 3, 5 ]

##### 5.1-2 AddSpecialGapOfNumericalSemigroup

`‣ AddSpecialGapOfNumericalSemigroup`( g, S ) | ( function )

S is a numerical semigroup and g is a special gap of S.

The output is the numerical semigroup S ∪{g} (see [RGSGGJM03], where it is explained why this set is a numerical semigroup).

    gap> s:=NumericalSemigroup(3,5,7);;
    gap> s2:=RemoveMinimalGeneratorFromNumericalSemigroup(5,s);
    <Numerical semigroup with 3 generators>
    gap> s3:=AddSpecialGapOfNumericalSemigroup(5,s2);
    <Numerical semigroup>
    gap> SmallElementsOfNumericalSemigroup(s) =
    > SmallElementsOfNumericalSemigroup(s3);
    true
    gap> s=s3;
    true

#### 5.2 Intersections, quotients, dilatations, numerical duplications and multiples by integers

We provide functions to build numerical semigroups from others by means of intersections, quotients, multiples and related constructions.

##### 5.2-1 Intersection

`‣ Intersection`( S, T ) | ( operation )

`‣ IntersectionOfNumericalSemigroups`( S, T ) | ( function )

S and T are numerical semigroups. Computes the intersection of S and T (which is a numerical semigroup).

    gap> S := NumericalSemigroup("modular", 5,53);
    <Modular numerical semigroup satisfying 5x mod 53 <= x >
    gap> T := NumericalSemigroup(2,17);
    <Numerical semigroup with 2 generators>
    gap> SmallElements(S);
    [ 0, 11, 12, 13, 22, 23, 24, 25, 26, 32, 33, 34, 35, 36, 37, 38, 39, 43 ]
    gap> SmallElements(T);
    [ 0, 2, 4, 6, 8, 10, 12, 14, 16 ]
    gap> Intersection(S,T);
    <Numerical semigroup>
    gap> SmallElements(last);
    [ 0, 12, 22, 23, 24, 25, 26, 32, 33, 34, 35, 36, 37, 38, 39, 43 ]
    gap> IntersectionOfNumericalSemigroups(S,T) = Intersection(S,T);
    true

##### 5.2-2 QuotientOfNumericalSemigroup

`‣ QuotientOfNumericalSemigroup`( S, n ) | ( function )

`‣ \/`( S, n ) | ( operation )

S is a numerical semigroup and n is an integer. Computes the quotient of S by n, that is, the set { x∈ N | nx ∈ S}, which is again a numerical semigroup. `S / n` may be used as a short for `QuotientOfNumericalSemigroup(S, n)`.

    gap> s:=NumericalSemigroup(3,29);
    <Numerical semigroup with 2 generators>
    gap> SmallElements(s);
    [ 0, 3, 6, 9, 12, 15, 18, 21, 24, 27, 29, 30, 32, 33, 35, 36, 38,
    39, 41, 42, 44, 45, 47, 48, 50, 51, 53, 54, 56 ]
    gap> t:=QuotientOfNumericalSemigroup(s,7);
    <Numerical semigroup>
    gap> SmallElements(t);
    [ 0, 3, 5, 6, 8 ]
    gap> u := s / 7;
    <Numerical semigroup>
    gap> SmallElements(u);
    [ 0, 3, 5, 6, 8 ]

##### 5.2-3 MultipleOfNumericalSemigroup

`‣ MultipleOfNumericalSemigroup`( S, a, b ) | ( function )

S is a numerical semigroup, and a and b are positive integers. Computes a S∪ {b,b+1,->}. If b is smaller than a c, with c the conductor of S, then a warning is displayed.

    gap> N:=NumericalSemigroup(1);;
    gap> s:=MultipleOfNumericalSemigroup(N,4,20);;
    gap> SmallElements(s);
    [ 0, 4, 8, 12, 16, 20 ]

##### 5.2-4 NumericalDuplication

`‣ NumericalDuplication`( S, E, b ) | ( function )

S is a numerical semigroup, and E and ideal of S, and b is a positive odd integer, so that 2S∪ (2E+b) is a numerical semigroup (this extends slightly the original definition where b was imposed to be in S, [DS13]; now the condition imposed is E+E+b⊆ S). Computes 2S∪ (2E+b).

    gap> s:=NumericalSemigroup(3,5,7);
    <Numerical semigroup with 3 generators>
    gap> e:=6+s;
    <Ideal of numerical semigroup>
    gap> ndup:=NumericalDuplication(s,e,3);
    <Numerical semigroup with 4 generators>
    gap> SmallElements(ndup);
    [ 0, 6, 10, 12, 14, 15, 16, 18, 20, 21, 22, 24 ]

##### 5.2-5 AsNumericalDuplication

`‣ AsNumericalDuplication`( T ) | ( function )

T is a numerical semigroup. Detects whether or not T can be expressed as `NumericalDuplication`(S,E,b), with E a proper ideal of S. Returns the list [S,E,b] if this is possible, and `fail` otherwise.

Notice that a numerical semigroup can be represented in different ways as a numerical duplication.

    gap> s:=NumericalSemigroup(3,5,7);;
    gap> ndup:=NumericalDuplication(s,6+s,11);;
    gap> asdup:=AsNumericalDuplication(ndup);
    [ <Numerical semigroup with 3 generators>, <Ideal of numerical semigroup>, 3 ]
    gap> ndup = CallFuncList(NumericalDuplication,asdup);
    true

##### 5.2-6 InductiveNumericalSemigroup

`‣ InductiveNumericalSemigroup`( a, b ) | ( function )

a and b are lists of positive integers, with k the length of a and b, and such that b[i+1]ge a[i]b[i] (0le ile k-1). Computes inductively S_0= N and S_i+1=a[i]S_i∪ {a[i]b[i],a[i]b[i]+1,->}, and returns S_k.

    gap> s:=InductiveNumericalSemigroup([4,2],[5,23]);;
    gap> SmallElements(s);
    [ 0, 8, 16, 24, 32, 40, 42, 44, 46 ]

##### 5.2-7 DilatationOfNumericalSemigroup

`‣ DilatationOfNumericalSemigroup`( S, a ) | ( function )

S is a numerical semigroup, and a is a positive integer. If M is the maximal ideal of S, then a must be in M-2M. Computes the numerical semigroup {0} ∪ {a+s ∣ s∈ M}, see [BS19].

    gap> s:=NumericalSemigroup(3,4,5);;
    gap> m:=MaximalIdeal(s);;
    gap> SmallElements(m-2*m);
    [ -3 ]
    gap> d:=DilatationOfNumericalSemigroup(s,3);
    <Numerical semigroup>
    gap> SmallElements(d);
    [ 0, 6 ]

#### 5.3 Constructing the set of all numerical semigroups containing a given numerical semigroup

In order to construct the set of numerical semigroups containing a fixed numerical semigroup S, one first constructs its unitary extensions, that is to say, the sets S∪{g} that are numerical semigroups with g a positive integer. This is achieved by constructing the special gaps of the semigroup, and then adding each of them to the numerical semigroup. Then we repeat the process for each of these new numerical semigroups until we reach N.

These procedures are described in [RGSGGJM03].

##### 5.3-1 OverSemigroups

`‣ OverSemigroups`( s ) | ( operation )

`‣ OverSemigroupsNumericalSemigroup`( s ) | ( function )

s is a numerical semigroup. The output is the set of numerical semigroups containing it.

    gap> s := NumericalSemigroup(3,5,7);;
    gap> OverSemigroups(s);
    [ <The numerical semigroup N>, <Numerical semigroup with 2 generators>,
      <Numerical semigroup with 3 generators>,
      <Numerical semigroup with 3 generators> ]
    gap> List(last,s->MinimalGenerators(s));
    [ [ 1 ], [ 2, 3 ], [ 3 .. 5 ], [ 3, 5, 7 ] ]
    gap> OverSemigroupsNumericalSemigroup(s) = OverSemigroups(s);
    true

#### 5.4 Constructing the set of numerical semigroup with given Frobenius number

Finding the set of all numerical semigroups with a given Frobenius number is not accomplished via over semigroups. In order to achieve this, we use fundamental gaps. If the multiplicity is fixed, then the construction relies on the calculation of irreducible numerical semigroups with that Frobenius number and multiplicity.

##### 5.4-1 NumericalSemigroupsWithFrobeniusNumberFG

`‣ NumericalSemigroupsWithFrobeniusNumberFG`( f ) | ( function )

f is an integer. The output is the set of numerical semigroups with Frobenius number f. The algorithm implemented is given in [RGSGGJM04].

    gap> Length(NumericalSemigroupsWithFrobeniusNumberFG(15));
    200

##### 5.4-2 NumericalSemigroupsWithFrobeniusNumberAndMultiplicity

`‣ NumericalSemigroupsWithFrobeniusNumberAndMultiplicity`( f, m ) | ( function )

f and m are integers. The output is the set of numerical semigroups with Frobenius number f and multiplicity m. The algorithm implemented is given in [ttt19].

    gap> Length(NumericalSemigroupsWithFrobeniusNumberAndMultiplicity(15,6));
    28

##### 5.4-3 NumericalSemigroupsWithFrobeniusNumber

`‣ NumericalSemigroupsWithFrobeniusNumber`( f, m ) | ( function )

f is an integer. As happens with the function `NumericalSemigroupsWithFrobeniusNumberFG` (5.4-1), the output is the set of numerical semigroups with Frobenius number f. It makes use of `NumericalSemigroupsWithFrobeniusNumberAndMultiplicity` (5.4-2) to compute the semigroups with the Frobenius number given for all the possible multiplicities.

    gap> Length(NumericalSemigroupsWithFrobeniusNumber(15));
    200

#### 5.5 Constructing the set of numerical semigroups with genus g

Given a numerical semigroup of genus g (that is, with exactly g gaps), removing minimal generators, one obtains numerical semigroups of genus g+1. In order to avoid repetitions, we only remove minimal generators greater than the Frobenius number of the numerical semigroup (this is accomplished with the local function sons).

These procedures are described in [RGSGGB03] and [BA08].

##### 5.5-1 NumericalSemigroupsWithGenus

`‣ NumericalSemigroupsWithGenus`( g ) | ( function )

g is a nonnegative integer. The output is the set of numerical semigroups with genus g. If the user just wants to use some numerical semigroup with a given genus pseudo-randomly choosen, he is probably looking for the function `RandomNumericalSemigroupWithGenus` (B.1-7).

    gap> NumericalSemigroupsWithGenus(5);
    [ <Numerical semigroup with 6 generators>,
      <Numerical semigroup with 5 generators>,
      <Numerical semigroup with 5 generators>,
      <Numerical semigroup with 5 generators>,
      <Numerical semigroup with 5 generators>,
      <Numerical semigroup with 4 generators>,
      <Numerical semigroup with 4 generators>,
      <Numerical semigroup with 4 generators>,
      <Numerical semigroup with 4 generators>,
      <Numerical semigroup with 3 generators>,
      <Numerical semigroup with 3 generators>,
      <Numerical semigroup with 2 generators> ]
    gap> List(last,MinimalGenerators);
    [ [ 6 .. 11 ], [ 5, 7, 8, 9, 11 ], [ 5, 6, 8, 9 ], [ 5, 6, 7, 9 ],
      [ 5, 6, 7, 8 ], [ 4, 6, 7 ], [ 4, 7, 9, 10 ], [ 4, 6, 9, 11 ],
      [ 4, 5, 11 ], [ 3, 8, 10 ], [ 3, 7, 11 ], [ 2, 11 ] ]

#### 5.6 Constructing the set of numerical semigroups with a given set of pseudo-Frobenius numbers

Refer to `PseudoFrobeniusOfNumericalSemigroup` (3.1-25).

These procedures are described in [DGSRP16], and are used to find the set of numerical semigroups with a prescribed set of pseudo-Frobenius numbers.

##### 5.6-1 ForcedIntegersForPseudoFrobenius

`‣ ForcedIntegersForPseudoFrobenius`( PF ) | ( function )

PF is a list of positive integers (given as a list or individual elements). The output is:

- in case there exists a numerical semigroup S such that PF(S)=PF:

  - a list [forced_gaps,forced_elts] such that:

    - forced_gaps is contained in N - S for any numerical semigroup S such that PF(S)={g_1,...,g_n}

    - forced_elts is contained in S for any numerical semigroup S such that PF(S)={g_1,...,g_n}

- "fail" in case it is found some condition that fails.

    gap> pf := [ 58, 64, 75 ];
    [ 58, 64, 75 ]
    gap> ForcedIntegersForPseudoFrobenius(pf);
    [ [ 1, 2, 3, 4, 5, 6, 7, 8, 11, 15, 16, 17, 25, 29, 32, 58, 64, 75 ],
      [ 0, 59, 60, 67, 68, 69, 70, 71, 72, 73, 74, 76 ] ]

##### 5.6-2 SimpleForcedIntegersForPseudoFrobenius

`‣ SimpleForcedIntegersForPseudoFrobenius`( fg, fe, PF ) | ( function )

Is just a quicker version of `ForcedIntegersForPseudoFrobenius` (5.6-1)

fg is a list of integers that we require to be gaps of the semigroup; fe is a list of integers that we require to be elements of the semigroup; PF is a list of positive integers. The output is:

- in case there exists a numerical semigroup S such that PF(S)=PF:

  - a list [forced_gaps,forced_elts] such that:

    - forced_gaps is contained in N - S for any numerical semigroup S such that PF(S)={g_1,...,g_n}

    - forced_elts is contained in S for any numerical semigroup S such that PF(S)={g_1,...,g_n}

- "fail" in case it is found some condition that fails.

    gap> pf := [ 15, 20, 27, 35 ];;
    gap> fint := ForcedIntegersForPseudoFrobenius(pf);
    [ [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 15, 16, 20, 27, 35 ],
      [ 0, 19, 23, 25, 26, 28, 29, 30, 31, 32, 33, 34, 36 ] ]
    gap> free := Difference([1..Maximum(pf)],Union(fint));
    [ 11, 13, 14, 17, 18, 21, 22, 24 ]
    gap> SimpleForcedIntegersForPseudoFrobenius(fint[1],Union(fint[2],[free[1]]),pf);
    [ [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 13, 15, 16, 20, 24, 27, 35 ],
      [ 0, 11, 19, 22, 23, 25, 26, 28, 29, 30, 31, 32, 33, 34, 36 ] ]

##### 5.6-3 NumericalSemigroupsWithPseudoFrobeniusNumbers

`‣ NumericalSemigroupsWithPseudoFrobeniusNumbers`( PF ) | ( function )

PF is a list of positive integers (given as a list or individual elements). The output is: a list of numerical semigroups S such that PF(S)=PF. When Length(PF)=1, it makes use of the function `NumericalSemigroupsWithFrobeniusNumber` (5.4-3)

    gap> pf := [ 58, 64, 75 ];
    [ 58, 64, 75 ]
    gap> Length(NumericalSemigroupsWithPseudoFrobeniusNumbers(pf));
    561
    gap> pf := [11,19,22];;
    gap> NumericalSemigroupsWithPseudoFrobeniusNumbers(pf);
    [ <Numerical semigroup>, <Numerical semigroup>, <Numerical semigroup>,
      <Numerical semigroup>, <Numerical semigroup> ]
    gap> List(last,MinimalGenerators);
    [ [ 7, 9, 17, 20 ], [ 7, 10, 13, 16, 18 ], [ 9, 12, 14, 15, 16, 17, 20 ],
      [ 10, 13, 14, 15, 16, 17, 18, 21 ],
      [ 12, 13, 14, 15, 16, 17, 18, 20, 21, 23 ] ]
    gap> Set(last2,PseudoFrobeniusOfNumericalSemigroup);
    [ [ 11, 19, 22 ] ]
    g

##### 5.6-4 ANumericalSemigroupWithPseudoFrobeniusNumbers

`‣ ANumericalSemigroupWithPseudoFrobeniusNumbers`( PF ) | ( function )

PF is a list of positive integers (given as a list or individual elements). Alternatively, a record with fields "pseudo_frobenius" and "max_attempts" may be given. The output is: A numerical semigroup S such that PF(S)=PF. Returns fail if it concludes that it does not exist and suggests to use NumericalSemigroupsWithPseudoFrobeniusNumbers if it is not able to conclude...

When Length(PF)=1 or Length(PF)=2 and 2*PF[1] = PF[2], it makes use of the function `AnIrreducibleNumericalSemigroupWithFrobeniusNumber` (6.1-4).

    gap> pf := [ 83, 169, 173, 214, 259 ];;
    gap> ANumericalSemigroupWithPseudoFrobeniusNumbers(pf);
    <Numerical semigroup>
    gap> gen := MinimalGeneratingSystem(last);
    [ 38, 57, 64, 72, 79, 98, 99, 106, 118, 120, 124, 132, 134, 146, 147, 154,
      165, 168, 179 ]
    gap> ns := NumericalSemigroup(gen);
    <Numerical semigroup with 19 generators>
    gap> PseudoFrobeniusOfNumericalSemigroup(ns);
    [ 83, 169, 173, 214, 259 ]

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 14 A B C Bib Ind

generated by GAPDoc2HTML