GAP (simpcomp) - Chapter 6: Functions and operations for SCSimplicialComplex

This section contains functions to generate or to construct new simplicial complexes. Some of them obtain new complexes from existing ones, some generate new complexes from scratch.

6.1-1 SCFromFacets

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Constructs a simplicial complex object from the given facet list. The facet list facets has to be a duplicate free list (or set) which consists of duplicate free entries, which are in turn lists or sets. For the vertex labels (i. e. the entries of the list items of facets) an ordering via the less-operator has to be defined. Following Section 4.11 of the GAP manual this is the case for objects of the following families: rationals IsRat, cyclotomics IsCyclotomic, finite field elements IsFFE, permutations IsPerm, booleans IsBool, characters IsChar and lists (strings) IsList.

Internally the vertices are mapped to the standard labeling \(1..n\), where \(n\) is the number of vertices of the complex and the vertex labels of the original complex are stored in the property ''VertexLabels'', see SCLabels (4.2-3) and the SCRelabel.. functions like SCRelabel (4.2-6) or SCRelabelStandard (4.2-7).

 gap> c:=SCFromFacets([[1,2,5], [1,4,5], [1,4,6], [2,3,5], [3,4,6], [3,5,6]]);
 <SimplicialComplex: unnamed complex 12 | dim = 2 | n = 6>
 gap> c:=SCFromFacets([["a","b","c"], ["a","b",1], ["a","c",1], ["b","c",1]]);
 <SimplicialComplex: unnamed complex 13 | dim = 2 | n = 4>

6.1-2 SC

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

A shorter function to create a simplicial complex from a facet list, just calls SCFromFacets (6.1-1)(facets).

 gap> c:=SC(Combinations([1..6],5));
 <SimplicialComplex: unnamed complex 14 | dim = 4 | n = 6>

6.1-3 SCFromDifferenceCycles

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Creates a simplicial complex object from the list of difference cycles provided. If diffcycles is of length \(1\) the computation is equivalent to the one in SCDifferenceCycleExpand (6.6-8). Otherwise the induced modulus (the sum of all entries of a difference cycle) of all cycles has to be equal and the union of all expanded difference cycles is returned.

A \(n\)-dimensional difference cycle \(D = (d_1 : \ldots : d_{n+1})\) induces a simplex \(\Delta = ( v_1 , \ldots , v_{n+1} )\) by \(v_1 = d_1\), \(v_i = v_{i-1} + d_i\) and a cyclic group action by \(\mathbb{Z}_{\sigma}\) where \(\sigma = \sum d_i\) is the modulus of \(D\). The function returns the \(\mathbb{Z}_{\sigma}\)-orbit of \(\Delta\).

Note that modulo operations in GAP are often a little bit cumbersome, since all integer ranges usually start from \(1\).

 gap> c:=SCFromDifferenceCycles([[1,1,6],[2,3,3]]);;
 gap> c.F;
 [ 8, 24, 16 ]
 gap> c.Homology;
 [ [ 0, [  ] ], [ 2, [  ] ], [ 1, [  ] ] ]
 gap> c.Chi;
 0
 gap> c.HasBoundary;
 false
 gap> SCIsPseudoManifold(c);
 true
 gap> SCIsManifold(c);
 true

6.1-4 SCFromGenerators

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Constructs a simplicial complex object from the set of generators on which the group group acts, i.e. a complex which has group as a subgroup of the automorphism group and a facet list that consists of the group-orbits specified by the list of representatives passed in generators. Note that group is not stored as an attribute of the resulting complex as it might just be a subgroup of the actual automorphism group. Internally calls Orbits and SCFromFacets (6.1-1).

 gap> #group: AGL(1,7) of order 42
 gap> G:=Group([(2,6,5,7,3,4),(1,3,5,7,2,4,6)]);;
 gap> c:=SCFromGenerators(G,[[ 1, 2, 4 ]]);
 <SimplicialComplex: complex from generators under unknown group | dim = 2 | n \
 = 7>
 gap> SCLib.DetermineTopologicalType(c);
 <SimplicialComplex: complex from generators under unknown group | dim = 2 | n \
 = 7>

6.2 Isomorphism signatures

This section contains functions to construct simplicial complexes from isomorphism signatures and to compress closed and strongly connected weak pseudomanifolds to strings.

The isomorphism signature of a closed and strongly connected weak pseudomanifold is a representation which is invariant under relabelings of the underlying complex and thus unique for a combinatorial type, i.e. two complexes are isomorphic iff they have the same isomorphism signature.

To compute the isomorphism signature of a closed and strongly connected weak pseudomanifold \(P\) we have to compute all canonical labelings of \(P\) and chose the one that is lexicographically minimal.

A canonical labeling of \(P\) is determined by chosing a facet \(\Delta \in P\) and a numbering \(1, 2, \ldots , d+1\) of the vertices of \(\Delta\) (which in turn determines a numbering of the co-dimension one faces of \(\Delta\) by identifying each face with its opposite vertex). This numbering can then be uniquely extended to a numbering (and thus a labeling) on all vertices of \(P\) by the weak pseudomanifold property: start at face \(1\) of \(\Delta\) and label the opposite vertex of the unique other facet \(\delta\) meeting face \(1\) by \(d+2\), go on with face \(2\) of \(\Delta\) and so on. After finishing with the first facet we now have a numbering on \(\delta\), repeat the procedure for \(\delta\), etc. Whenever the opposite vertex of a face is already labeled (and also, if the vertex occurs for the first time) we note this label. Whenever a facet is already visited we skip this step and keep track of the number of skippings between any two newly discovered facets. This results in a sequence of \(m-1\) vertex labels together with \(m-1\) skipping numbers (where \(m\) denotes the number of facets in \(P\)) which then can by encoded by characters via a lookup table.

Note that there are precisely \((d+1)! m\) canonical labelings we have to check in order to find the lexicographically minimal one. Thus, computing the isomorphism signature of a large or highly dimensional complex can be time consuming. If you are not interested in the isomorphism signature but just in the compressed string representation use SCExportToString (6.2-1) which just computes the first canonical labeling of the complex provided as argument and returns the resulting string.

Note: Another way of storing and loading complexes is provided by simpcomp's library functionality, see Section 13.1 for details.

6.2-1 SCExportToString

Computes one string representation of a closed and strongly connected weak pseudomanifold. Compare SCExportIsoSig (6.2-2), which returns the lexicographically minimal string representation.

 gap> c:=SCSeriesBdHandleBody(3,9);;
 gap> s:=SCExportToString(c); time;
 "deffg.h.f.fahaiciai.i.hai.fbgeiagihbhceceba.g.gag"
 3
 gap> s:=SCExportIsoSig(c); time;
 "deefgaf.hbi.gbh.eaiaeaicg.g.ibf.heg.iff.hggcfffgg"
 11

6.2-2 SCExportIsoSig

Computes the isomorphism signature of a closed, strongly connected weak pseudomanifold. The isomorphism signature is stored as an attribute of the complex.

 gap> c:=SCSeriesBdHandleBody(3,9);;
 gap> s:=SCExportIsoSig(c);
 "deefgaf.hbi.gbh.eaiaeaicg.g.ibf.heg.iff.hggcfffgg"

6.2-3 SCFromIsoSig

Computes a simplicial complex from its isomorphism signature. If a file with isomorphism signatures is provided a list of all complexes is returned.

 gap> s:="deeee";;
 gap> c:=SCFromIsoSig(s);;
 gap> SCIsIsomorphic(c,SCBdSimplex(4));
 true

 gap> s:="deeee";;
 gap> PrintTo("tmp.txt",s,"\n");;
 gap> cc:=SCFromIsoSig("tmp.txt");
 [ <SimplicialComplex: unnamed complex 9 | dim = 3 | n = 5> ]
 gap> cc[1].F;
 [ 5, 10, 10, 5 ]

6.3 Generating some standard triangulations

6.3-1 SCBdCyclicPolytope

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Generates the boundary complex of the d-dimensional cyclic polytope (a combinatorial \(d-1\)-sphere) on n vertices, where \(n\geq d+2\).

 gap> SCBdCyclicPolytope(3,8); 
 <SimplicialComplex: Bd(C_3(8)) | dim = 2 | n = 8>

6.3-2 SCBdSimplex

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Generates the boundary of the \(d\)-simplex \(\Delta^d\), a combinatorial \(d-1\)-sphere.

 gap> SCBdSimplex(5);
 <SimplicialComplex: S^4_6 | dim = 4 | n = 6>

6.3-3 SCEmpty

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Generates an empty complex (of dimension \(-1\)), i. e. a SCSimplicialComplex object with empty facet list.

 gap> SCEmpty();
 <SimplicialComplex: empty complex | dim = -1 | n = 0>

6.3-4 SCSimplex

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

 gap> SCSimplex(3);
 <SimplicialComplex: B^3_4 | dim = 3 | n = 4>

6.3-5 SCSeriesTorus

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

 gap> t4:=SCSeriesTorus(4);
 <SimplicialComplex: 4-torus T^4 | dim = 4 | n = 31>
 gap> t4.Homology;
 [ [ 0, [  ] ], [ 4, [  ] ], [ 6, [  ] ], [ 4, [  ] ], [ 1, [  ] ] ]

6.3-6 SCSurface

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Generates the surface of genus g where the boolean argument orient specifies whether the surface is orientable or not. The surfaces have transitive cyclic group actions and can be described using the minimum amount of \(O(\operatorname{log} (g))\) memory. If orient is true and g\( \geq 50\) or if orient is false and g\( \geq 100\) only the difference cycles of the surface are returned

 gap> c:=SCSurface(23,true); 
 <SimplicialComplex: S_23^or | dim = 2 | n = 88>
 gap> c.Homology;
 [ [ 0, [  ] ], [ 46, [  ] ], [ 1, [  ] ] ]
 gap> c.TopologicalType;
 "(T^2)^#23"
 gap> c:=SCSurface(23,false); 
 <SimplicialComplex: S_23^non | dim = 2 | n = 21>
 gap> c.Homology;
 [ [ 0, [  ] ], [ 22, [ 2 ] ], [ 0, [  ] ] ]
 gap> c.TopologicalType;
 "(RP^2)^#23"

 gap> dc:=SCSurface(345,true);
 [ [ 1, 1, 1374 ], [ 2, 343, 1031 ], [ 343, 345, 688 ] ]
 gap> c:=SCFromDifferenceCycles(dc);
 <SimplicialComplex: complex from diffcycles [ [ 1, 1, 1374 ], [ 2, 343, 1031 ]\
 , [ 343, 345, 688 ] ] | dim = 2 | n = 1376>
 gap> c.Chi;
 -688
 gap> dc:=SCSurface(12345678910,true); time;
 [ [ 1, 1, 24691357816 ], [ 2, 4, 24691357812 ], [ 3, 3, 24691357812 ], 
   [ 4, 12345678907, 12345678907 ] ]
 0

6.3-7 SCFVectorBdCrossPolytope

Computes the \(f\)-vector of the \(d\)-dimensional cross polytope without generating the underlying complex.

gap> SCFVectorBdCrossPolytope(50);
[ 100, 4900, 156800, 3684800, 67800320, 1017004800, 12785203200, 
  137440934400, 1282782054400, 10518812846080, 76500457062400, 
  497252970905600, 2907017368371200, 15365663232819200, 73755183517532160, 
  322678927889203200, 1290715711556812800, 4732624275708313600, 
  15941471244491161600, 49418560857922600960, 141195888165493145600, 
  372243705163572838400, 906332499528699084800, 2039248123939572940800, 
  4241636097794311716864, 8156992495758291763200, 14501319992459185356800, 
  23823597130468661657600, 36146147370366245273600, 50604606318512743383040, 
  65296266217435797913600, 77539316133205010022400, 84588344872587283660800, 
  84588344872587283660800, 77337915312079802204160, 64448262760066501836800, 
  48771658304915190579200, 33370081998099867238400, 20535435075753764454400, 
  11294489291664570449920, 5509506971543692902400, 2361217273518725529600, 
  878592473867432755200, 279552150776001331200, 74547240206933688320, 
  16205921784116019200, 2758454771764428800, 344806846470553600, 
  28147497671065600, 1125899906842624 ]

6.3-8 SCFVectorBdCyclicPolytope

Computes the \(f\)-vector of the d-dimensional cyclic polytope on n vertices, \(n\geq d+2\), without generating the underlying complex.

gap> SCFVectorBdCyclicPolytope(25,198); 
[ 198, 19503, 1274196, 62117055, 2410141734, 77526225777, 2126433621312, 
  50768602708824, 1071781612741840, 20256672480820776, 346204947854027808, 
  5395027104058600008, 48354596155522298656, 262068846498922699590, 
  940938105142239825104, 2379003007642628680027, 4396097923113038784642, 
  6062663500381642763609, 6294919173643129209180, 4911378208855785427761, 
  2840750019404460890298, 1183225500922302444568, 335951678686835900832, 
  58265626173398052500, 4661250093871844200 ]

6.3-9 SCFVectorBdSimplex

Computes the \(f\)-vector of the \(d\)-simplex without generating the underlying complex.

 gap> SCFVectorBdSimplex(100);
 [ 101, 5050, 166650, 4082925, 79208745, 1267339920, 17199613200, 
   202095455100, 2088319702700, 19212541264840, 158940114100040, 
   1192050855750300, 8160963550905900, 51297485177122800, 297525414027312240, 
   1599199100396803290, 7995995501984016450, 37314645675925410100, 
   163006083742200475700, 668324943343021950370, 2577824781465941808570, 
   9373908296239788394800, 32197337191432316660400, 104641345872155029146300, 
   322295345286237489770604, 942094086221309585483304, 
   2616928017281415515231400, 6916166902815169575968700, 
   17409661513983013070541900, 41783187633559231369300560, 
   95696978128474368620010960, 209337139656037681356273975, 
   437704928371715151926754675, 875409856743430303853509350, 
   1675784582908852295948146470, 3072271735332895875904935195, 
   5397234129638871133346507775, 9090078534128625066688855200, 
   14683973016669317415420458400, 22760158175837441993901710520, 
   33862674359172779551902544920, 48375249084532542217003635600, 
   66375341767149302111702662800, 87494768693060443692698964600, 
   110826707011209895344085355160, 134919469404951176940625649760, 
   157884485473879036845412994400, 177620046158113916451089618700, 
   192119641762857909630770403900, 199804427433372226016001220056, 
   199804427433372226016001220056, 192119641762857909630770403900, 
   177620046158113916451089618700, 157884485473879036845412994400, 
   134919469404951176940625649760, 110826707011209895344085355160, 
   87494768693060443692698964600, 66375341767149302111702662800, 
   48375249084532542217003635600, 33862674359172779551902544920, 
   22760158175837441993901710520, 14683973016669317415420458400, 
   9090078534128625066688855200, 5397234129638871133346507775, 
   3072271735332895875904935195, 1675784582908852295948146470, 
   875409856743430303853509350, 437704928371715151926754675, 
   209337139656037681356273975, 95696978128474368620010960, 
   41783187633559231369300560, 17409661513983013070541900, 
   6916166902815169575968700, 2616928017281415515231400, 
   942094086221309585483304, 322295345286237489770604, 
   104641345872155029146300, 32197337191432316660400, 9373908296239788394800, 
   2577824781465941808570, 668324943343021950370, 163006083742200475700, 
   37314645675925410100, 7995995501984016450, 1599199100396803290, 
   297525414027312240, 51297485177122800, 8160963550905900, 1192050855750300, 
   158940114100040, 19212541264840, 2088319702700, 202095455100, 17199613200, 
   1267339920, 79208745, 4082925, 166650, 5050, 101 ]

6.4 Generating infinite series of transitive triangulations

6.4-1 SCSeriesAGL

Returns: a permutation group and a list of \(5\)-tuples of integers upon success, fail otherwise.

For a given prime p the automorphism group (AGL\((1,p)\)) and the generators of all members of the series of \(2\)-transitive combinatorial \(4\)-pseudomanifolds with p vertices from [Spr11a], Section 5.2, is computed. The affine linear group AGL\((1,p)\) is returned as the first argument. If no member of the series with p vertices exists only the group is returned.

 gap> gens:=SCSeriesAGL(17);
 [ AGL(1,17), [ [ 1, 2, 4, 8, 16 ] ] ]
 gap> c:=SCFromGenerators(gens[1],gens[2]);;
 gap> SCIsManifold(SCLink(c,1));
 true

 gap> List([19..23],x->SCSeriesAGL(x));     
 #I  SCSeriesAGL: argument must be a prime > 13.
 #I  SCSeriesAGL: argument must be a prime > 13.
 #I  SCSeriesAGL: argument must be a prime > 13.
 [ [ AGL(1,19), [ [ 1, 2, 10, 12, 17 ] ] ], fail, fail, fail, 
   [ AGL(1,23), [ [ 1, 2, 7, 9, 19 ], [ 1, 2, 4, 8, 22 ] ] ] ]
 gap> for i in [80000..80100] do if IsPrime(i) then Print(i,"\n"); fi; od;
 80021
 80039
 80051
 80071
 80077
 gap> SCSeriesAGL(80021);                                                 
 AGL(1,80021)
 gap> SCSeriesAGL(80039);                                                 
 [ AGL(1,80039), [ [ 1, 2, 6496, 73546, 78018 ] ] ]
 gap> SCSeriesAGL(80051);                                                 
 [ AGL(1,80051), [ [ 1, 2, 31498, 37522, 48556 ] ] ]
 gap> SCSeriesAGL(80071);                                                 
 AGL(1,80071)
 gap> SCSeriesAGL(80077);                                                 
 [ AGL(1,80077), [ [ 1, 2, 4126, 39302, 40778 ] ] ]

6.4-2 SCSeriesBrehmKuehnelTorus

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Generates a neighborly 3-torus with n vertices if n is odd and a centrally symmetric 3-torus if n is even (n\(\geq 15\) . The triangulations are taken from [BK12]

 gap> T3:=SCSeriesBrehmKuehnelTorus(15);
 <SimplicialComplex: Neighborly 3-Torus NT3(15) | dim = 3 | n = 15>
 gap> T3.Homology;
 [ [ 0, [  ] ], [ 3, [  ] ], [ 3, [  ] ], [ 1, [  ] ] ]
 gap> T3.Neighborliness;
 2
 gap> T3:=SCSeriesBrehmKuehnelTorus(16);
 <SimplicialComplex: Centrally symmetric 3-Torus SCT3(16) | dim = 3 | n = 16>
 gap> T3.Homology;
 [ [ 0, [  ] ], [ 3, [  ] ], [ 3, [  ] ], [ 1, [  ] ] ]
 gap> T3.IsCentrallySymmetric;
 true

6.4-3 SCSeriesBdHandleBody

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

SCSeriesBdHandleBody(d,n) generates a transitive \(d\)-dimensional sphere bundle (\(d \geq 2\)) with \(n\) vertices (\(n \geq 2d + 3\)) which coincides with the boundary of SCSeriesHandleBody (6.4-9)(d,n). The sphere bundle is orientable if \(d\) is even or if \(d\) is odd and \(n\) is even, otherwise it is not orientable. Internally calls SCFromDifferenceCycles (6.1-3).

 gap> c:=SCSeriesBdHandleBody(2,7);
 <SimplicialComplex: Sphere bundle S^1 x S^1 | dim = 2 | n = 7>
 gap> SCLib.DetermineTopologicalType(c);
 <SimplicialComplex: Sphere bundle S^1 x S^1 | dim = 2 | n = 7>
 gap> SCIsIsomorphic(c,SCSeriesHandleBody(3,7).Boundary);
 true

6.4-4 SCSeriesBid

Constructs the complex \(B(i,d)\) as described in [KN12], cf. [Eff11a], [Spa99]. The complex \(B(i,d)\) is a \(i\)-Hamiltonian subcomplex of the \(d\)-cross polytope and its boundary topologically is a sphere product \(S^i\times S^{d-i-2}\) with vertex transitive automorphism group.

 gap> b26:=SCSeriesBid(2,6);
 <SimplicialComplex: B(2,6) | dim = 5 | n = 12>
 gap> s2s2:=SCBoundary(b26);
 <SimplicialComplex: Bd(B(2,6)) | dim = 4 | n = 12>
 gap> SCFVector(s2s2);
 [ 12, 60, 160, 180, 72 ]
 gap> SCAutomorphismGroup(s2s2); 
 Group([ (1,3)(4,6)(7,9)(10,12), (1,5)(2,10)(4,8)(6,12)(7,11), (1,10,7,4)
   (2,3,8,9)(5,12,11,6) ])
 gap> SCIsManifold(s2s2); 
 true
 gap> SCHomology(s2s2);
 [ [ 0, [  ] ], [ 0, [  ] ], [ 2, [  ] ], [ 0, [  ] ], [ 1, [  ] ] ]

6.4-5 SCSeriesC2n

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Generates the combinatorial \(3\)-manifold \(C_{2n}\), \(n \geq 8\), with \(2n\) vertices from [Spr11a], Section 4.5.3 and Section 5.2. The complex is homeomorphic to \(S^2 \times S^1\) for \(n\) odd and homeomorphic to \(S^2 \dtimes S^1\) in case \(n\) is an even number. In the latter case \(C_{2n}\) is isomorphic to \(D_{2n}\) from SCSeriesD2n (6.4-8). The complexes are believed to appear as the vertex links of some of the members of the series of \(2\)-transitive \(4\)-pseudomanifolds from SCSeriesAGL (6.4-1). Internally calls SCFromDifferenceCycles (6.1-3).

 gap> c:=SCSeriesC2n(8);
 <SimplicialComplex: C_16 = { (1:1:3:11),(1:1:11:3),(1:3:1:11),(2:3:2:9),(2:5:2\
 :7) } | dim = 3 | n = 16>
 gap> SCGenerators(c);  
 [ [ [ 1, 2, 3, 6 ], 32 ], [ [ 1, 2, 5, 6 ], 16 ], [ [ 1, 3, 6, 8 ], 16 ], 
   [ [ 1, 3, 8, 10 ], 16 ] ]

 gap> c:=SCSeriesC2n(8);;
 gap> d:=SCSeriesD2n(8); 
 <SimplicialComplex: D_16 = { (1:1:1:13),(1:2:11:2),(3:4:5:4),(2:3:4:7),(2:7:4:\
 3) } | dim = 3 | n = 16>
 gap> SCIsIsomorphic(c,d);
 true
 gap> c:=SCSeriesC2n(11);;
 gap> d:=SCSeriesD2n(11);;
 gap> c.Homology;
 [ [ 0, [  ] ], [ 1, [  ] ], [ 1, [  ] ], [ 1, [  ] ] ]
 gap> d.Homology;
 [ [ 0, [  ] ], [ 1, [  ] ], [ 0, [ 2 ] ], [ 0, [  ] ] ]

6.4-6 SCSeriesConnectedSum

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Generates a combinatorial manifold of type \((S^2 x S^1)^{\#k}\) for \(k\) even. The complex is a combinatorial \(3\)-manifold with transitive cyclic symmetry as described in [BS14].

 gap> c:=SCSeriesConnectedSum(12);
 <SimplicialComplex: (S^2xS^1)^#12) | dim = 3 | n = 52>
 gap> c.Homology;
 [ [ 0, [  ] ], [ 12, [  ] ], [ 12, [  ] ], [ 1, [  ] ] ]
 gap> g:=SimplifiedFpGroup(SCFundamentalGroup(c));
 <fp group of size infinity on the generators 
 [ [2,3], [2,14], [3,4], [6,7], [9,10], [10,11], [11,12], [12,13], [26,32], 
   [26,34], [29,31], [33,35] ]>
 gap> RelatorsOfFpGroup(g);
 [  ]

6.4-7 SCSeriesCSTSurface

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

SCSeriesCSTSurface(l,j,2k) generates the centrally symmetric transitive (cst) surface \(S_{(l,j,2k)}\), SCSeriesCSTSurface(l,2k) generates the cst surface \(S_{(l,2k)}\) from [Spr12], Section 4.4.

 gap> SCSeriesCSTSurface(2,4,14);
 <SimplicialComplex: cst surface S_{(2,4,14)} = { (2:4:8),(2:8:4) } | dim = 2 |\
  n = 14>
 gap> last.Homology;
 [ [ 1, [  ] ], [ 4, [  ] ], [ 2, [  ] ] ]
 gap> SCSeriesCSTSurface(2,10);  
 <SimplicialComplex: cst surface S_{(2,10)} = { (2:2:6),(3:3:4) } | dim = 2 | n\
  = 10>
 gap> last.Homology;                    
 [ [ 0, [  ] ], [ 1, [ 2 ] ], [ 0, [  ] ] ]

6.4-8 SCSeriesD2n

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Generates the combinatorial \(3\)-manifold \(D_{2n}\), \(n \geq 8\), \(n \neq 9\), with \(2n\) vertices from [Spr11a], Section 4.5.3 and Section 5.2. The complex is homeomorphic to \(S^2 \dtimes S^1\). In the case that \(n\) is even \(D_{2n}\) is isomorphic to \(C_{2n}\) from SCSeriesC2n (6.4-5). The complexes are believed to appear as the vertex links of some of the members of the series of \(2\)-transitive \(4\)-pseudomanifolds from SCSeriesAGL (6.4-1). Internally calls SCFromDifferenceCycles (6.1-3).

 gap> d:=SCSeriesD2n(15);
 <SimplicialComplex: D_30 = { (1:1:1:27),(1:2:25:2),(3:11:5:11),(2:3:11:14),(2:\
 14:11:3) } | dim = 3 | n = 30>
 gap> SCAutomorphismGroup(d);  
 Group([ (1,3)(4,30)(5,29)(6,28)(7,27)(8,26)(9,25)(10,24)(11,23)(12,22)(13,21)
   (14,20)(15,19)(16,18), (1,4)(2,3)(5,30)(6,29)(7,28)(8,27)(9,26)(10,25)
   (11,24)(12,23)(13,22)(14,21)(15,20)(16,19)(17,18) ])
 gap> StructureDescription(last);
 "D60"

 gap> c:=SCSeriesC2n(8);;
 gap> d:=SCSeriesD2n(8); 
 <SimplicialComplex: D_16 = { (1:1:1:13),(1:2:11:2),(3:4:5:4),(2:3:4:7),(2:7:4:\
 3) } | dim = 3 | n = 16>
 gap> SCIsIsomorphic(c,d);
 true
 gap> c:=SCSeriesC2n(11);;
 gap> d:=SCSeriesD2n(11);;
 gap> c.Homology;
 [ [ 0, [  ] ], [ 1, [  ] ], [ 1, [  ] ], [ 1, [  ] ] ]
 gap> d.Homology;
 [ [ 0, [  ] ], [ 1, [  ] ], [ 0, [ 2 ] ], [ 0, [  ] ] ]

6.4-9 SCSeriesHandleBody

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

SCSeriesHandleBody(d,n) generates a transitive \(d\)-dimensional handle body (\(d \geq 3\)) with \(n\) vertices (\(n \geq 2d + 1\)). The handle body is orientable if \(d\) is odd or if \(d\) and \(n\) are even, otherwise it is not orientable. The complex equals the difference cycle \((1 : \ldots : 1 : n-d)\) To obtain the boundary complexes of SCSeriesHandleBody(d,n) use the function SCSeriesBdHandleBody (6.4-3). Internally calls SCFromDifferenceCycles (6.1-3).

 gap> c:=SCSeriesHandleBody(3,7);
 <SimplicialComplex: Handle body B^2 x S^1 | dim = 3 | n = 7>
 gap> SCAutomorphismGroup(c);    
 Group([ (1,3)(4,7)(5,6), (1,4)(2,3)(5,7) ])
 gap> bd:=SCBoundary(c);;
 gap> SCAutomorphismGroup(bd);
 Group([ (1,2)(3,7)(4,6), (1,4,2)(3,5,6) ])
 gap> SCIsIsomorphic(bd,SCSeriesBdHandleBody(2,7));
 true

6.4-10 SCSeriesHomologySphere

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Generates a combinatorial Brieskorn homology sphere of type \(\Sigma (p,q,r)\), \(p\), \(q\) and \(r\) pairwise co-prime. The complex is a combinatorial \(3\)-manifold with transitive cyclic symmetry as described in [BS14].

 gap> c:=SCSeriesHomologySphere(2,3,5);
 <SimplicialComplex: Homology sphere Sigma(2,3,5) | dim = 3 | n = 17>
 gap> c.Homology;
 [ [ 0, [  ] ], [ 0, [  ] ], [ 0, [  ] ], [ 1, [  ] ] ]
 gap> c:=SCSeriesHomologySphere(3,4,13);
 <SimplicialComplex: Homology sphere Sigma(3,4,13) | dim = 3 | n = 37>
 gap> c.Homology;
 [ [ 0, [  ] ], [ 0, [  ] ], [ 0, [  ] ], [ 1, [  ] ] ]

6.4-11 SCSeriesK

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Generates the k-th member (\(k \geq 0\)) of the series K^i (\(1 \leq i \leq 396\)) from [Spr11a]. The \(396\) series describe a complete classification of all dense series (i. e. there is a member of the series for every integer, \(f_0 (K^i (k+1) ) = f_0 (K^i (k)) +1\)) of cyclic \(3\)-manifolds with a fixed number of difference cycles and at least one member with less than \(23\) vertices. See SCSeriesL (6.4-13) for a list of series of order \(2\).

 gap> cc:=List([1..10],x->SCSeriesK(x,0));;                                                                                                                                                                                                  
 gap> Set(List(cc,x->x.F));                                                                                                                                                                                                                        
 [ [ 9, 36, 54, 27 ], [ 11, 55, 88, 44 ], [ 13, 65, 104, 52 ], 
   [ 13, 78, 130, 65 ], [ 15, 90, 150, 75 ], [ 15, 105, 180, 90 ] ]
 gap> cc:=List([1..10],x->SCSeriesK(x,10));;
 gap> gap> cc:=List([1..10],x->SCSeriesK(x,10));;
 gap> Set(List(cc,x->x.Homology));
 [ [ [ 0, [  ] ], [ 1, [  ] ], [ 0, [ 2 ] ], [ 0, [  ] ] ] ]
 gap> Set(List(cc,x->x.IsManifold));
 [ true ]

6.4-12 SCSeriesKu

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Computes the symmetric orientable sphere bundle Ku\((n)\) with \(4n\) vertices from [Spr11a], Section 4.5.2. The series is defined as a generalization of the slicings from [Spr11a], Section 3.3.

 gap> c:=SCSeriesKu(4);                                    
 <SimplicialComplex: Sl_16 = G{ [1,2,5,9],[1,2,9,10],[1,5,9,16] } | dim = 3 | n\
  = 16>
 gap> SCSlicing(c,[[1,2,3,4,9,10,11,12],[5,6,7,8,13,14,15,16]]);
 <NormalSurface: slicing [ [ 1, 2, 3, 4, 9, 10, 11, 12 ], [ 5, 6, 7, 8, 13, 14,\
  15, 16 ] ] of Sl_16 = G{ [1,2,5,9],[1,2,9,10],[1,5,9,16] } | dim = 2>
 gap> Mminus:=SCSpan(c,[1,2,3,4,9,10,11,12]);;                  
 gap> Mplus:=SCSpan(c,[5,6,7,8,13,14,15,16]);;                  
 gap> SCCollapseGreedy(Mminus).Facets;
 [ [ 3, 4 ], [ 3, 10 ], [ 4, 12 ], [ 9, 10 ], [ 9, 12 ] ]
 gap> SCCollapseGreedy(Mplus).Facets; 
 [ [ 5, 6 ], [ 5, 8 ], [ 6, 14 ], [ 7, 8 ], [ 7, 15 ], [ 14, 15 ] ]

6.4-13 SCSeriesL

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Generates the k-th member (\(k \geq 0\)) of the series L^i, \(1 \leq i \leq 18\) from [Spr11a]. The \(18\) series describe a complete classification of all series of cyclic \(3\)-manifolds with a fixed number of difference cycles of order \(2\) (i. e. there is a member of the series for every second integer, \(f_0 (L^i (k+1) ) = f_0 (L^i (k)) +2\)) and at least one member with less than \(15\) vertices where each series does not appear as a sub series of one of the series \(K^i\) from SCSeriesK (6.4-11).

 gap> cc:=List([1..18],x->SCSeriesL(x,0));;
 gap> Set(List(cc,x->x.F));
 [ [ 10, 45, 70, 35 ], [ 12, 60, 96, 48 ], [ 12, 66, 108, 54 ], 
   [ 14, 77, 126, 63 ], [ 14, 84, 140, 70 ], [ 14, 91, 154, 77 ] ]
 gap> cc:=List([1..18],x->SCSeriesL(x,10));; 
 gap> Set(List(cc,x->x.IsManifold));
 [ true ]

6.4-14 SCSeriesLe

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Generates the k-th member (\(k \geq 7\)) of the series Le from [Spr11a], Section 4.5.1. The series can be constructed as the generalization of the boundary of a genus \(1\) handlebody decomposition of the manifold manifold_3_14_1_5 from the classification in [Lut03].

 gap> c:=SCSeriesLe(7);                     
 <SimplicialComplex: Le_14 = { (1:1:1:11),(1:2:4:7),(1:4:2:7),(2:1:4:7),(2:5:2:\
 5),(2:4:2:6) } | dim = 3 | n = 14>
 gap> d:=SCLib.DetermineTopologicalType(c);;
 gap> SCReference(d);
 "manifold_3_14_1_5 in F.H.Lutz: 'The Manifold Page', http://www.math.tu-berlin\
 .de/diskregeom/stellar/,\r\nF.H.Lutz: 'Triangulated manifolds with few vertice\
 s and vertex-transitive group actions', Doctoral Thesis TU Berlin 1999, Shaker\
 -Verlag, Aachen 1999"

6.4-15 SCSeriesLensSpace

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Generates the lens space \(L(p,q)\) whenever \(p = (k+2)^2-1\) and \(q = k+2\) or \(p = 2k+3\) and \(q = 1\) for a \(k \geq 0\) and fail otherwise. All complexes have a transitive cyclic automorphism group.

 gap> l154:=SCSeriesLensSpace(15,4);
 <SimplicialComplex: Lens space L(15,4) | dim = 3 | n = 22>
 gap> l154.Homology;
 [ [ 0, [  ] ], [ 0, [ 15 ] ], [ 0, [  ] ], [ 1, [  ] ] ]
 gap> g:=SimplifiedFpGroup(SCFundamentalGroup(l154));
 <fp group on the generators [ [2,5] ]>
 gap> StructureDescription(g);
 "C15"

 gap> l151:=SCSeriesLensSpace(15,1);
 <SimplicialComplex: Lens space L(15,1) | dim = 3 | n = 62>
 gap> l151.Homology;
 [ [ 0, [  ] ], [ 0, [ 15 ] ], [ 0, [  ] ], [ 1, [  ] ] ]
 gap> g:=SimplifiedFpGroup(SCFundamentalGroup(l151));
 <fp group on the generators [ [2,3] ]>
 gap> StructureDescription(g);
 "C15"

6.4-16 SCSeriesPrimeTorus

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Generates the well known triangulated torus \(\{ (l:j:p-l-j),(l:p-l-j:j) \}\) with \(p\) vertices, \(3p\) edges and \(2p\) triangles where \(j\) has to be greater than \(l\) and \(p\) must be any prime number greater than \(6\).

 gap> l:=List([2..19],x->SCSeriesPrimeTorus(1,x,41));; 
 gap> Set(List(l,x->SCHomology(x)));
 [ [ [ 0, [  ] ], [ 2, [  ] ], [ 1, [  ] ] ] ]

6.4-17 SCSeriesSeifertFibredSpace

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

where \(p\) and \(q\) are co-prime, \(a = \operatorname{gcd} (p,r)\), \(b = \operatorname{gcd} (p,r)\), and the \(b_i\) are given by the identity

This \(3\)-parameter family of combinatorial \(3\)-manifolds contains the families generated by SCSeriesHomologySphere (6.4-10), SCSeriesConnectedSum (6.4-6) and parts of SCSeriesLensSpace (6.4-15), internally calls SCIntFunc.SeifertFibredSpace(p,q,r). The complexes are combinatorial \(3\)-manifolds with transitive cyclic symmetry as described in [BS14].

 gap> c:=SCSeriesSeifertFibredSpace(2,3,15);
 <SimplicialComplex: SFS [ S^2 : (2,b1)^3, (5,b3) ] | dim = 3 | n = 27>
 gap> c.Homology;
 [ [ 0, [  ] ], [ 0, [ 2, 2 ] ], [ 0, [  ] ], [ 1, [  ] ] ]

6.4-18 SCSeriesS2xS2

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

 gap> c:=SCSeriesS2xS2(3);
 <SimplicialComplex: (S^2 x S^2)^(# 3) | dim = 4 | n = 24>
 gap> c.Homology;
 [ [ 0, [  ] ], [ 0, [  ] ], [ 6, [  ] ], [ 0, [  ] ], [ 1, [  ] ] ]

6.5 A census of regular and chiral maps

6.5-1 SCChiralMap

Returns the (hyperbolic) chiral map of vertex valence m and genus g if existent and fail otherwise. The list was generated with the help of the classification of regular maps by Marston Conder [Con09]. Use SCChiralMaps (6.5-2) to get a list of all chiral maps available.

 gap> SCChiralMaps();
 [ [ 7, 17 ], [ 8, 10 ], [ 8, 28 ], [ 8, 37 ], [ 8, 46 ], [ 8, 82 ], 
   [ 9, 43 ], [ 10, 73 ], [ 12, 22 ], [ 12, 33 ], [ 12, 40 ], [ 12, 51 ], 
   [ 12, 58 ], [ 12, 64 ], [ 12, 85 ], [ 12, 94 ], [ 12, 97 ], [ 18, 28 ] ]
 gap> c:=SCChiralMap(8,10);
 <SimplicialComplex: Chiral map {8,10} | dim = 2 | n = 54>
 gap> c.Homology;
 [ [ 0, [  ] ], [ 20, [  ] ], [ 1, [  ] ] ]

6.5-2 SCChiralMaps

Returns a list of all simplicial (hyperbolic) chiral maps of orientable genus up to \(100\). The list was generated with the help of the classification of regular maps by Marston Conder [Con09]. Every chiral map is given by a \(2\)-tuple \((m,g)\) where \(m\) is the vertex valence and \(g\) is the genus of the map. Use the \(2\)-tuples of the list together with SCChiralMap (6.5-1) to get the corresponding triangulations.

 gap> ll:=SCChiralMaps();
 [ [ 7, 17 ], [ 8, 10 ], [ 8, 28 ], [ 8, 37 ], [ 8, 46 ], [ 8, 82 ], 
   [ 9, 43 ], [ 10, 73 ], [ 12, 22 ], [ 12, 33 ], [ 12, 40 ], [ 12, 51 ], 
   [ 12, 58 ], [ 12, 64 ], [ 12, 85 ], [ 12, 94 ], [ 12, 97 ], [ 18, 28 ] ]
 gap> c:=SCChiralMap(ll[18][1],ll[18][2]);
 <SimplicialComplex: Chiral map {18,28} | dim = 2 | n = 27>
 gap> SCHomology(c);
 [ [ 0, [  ] ], [ 56, [  ] ], [ 1, [  ] ] ]

6.5-3 SCChiralTori

Returns a list of chiral triangulations of the torus with \(n\) vertices. See [BK08] for details.

 gap> cc:=SCChiralTori(91);
 [ <SimplicialComplex: {3,6}_(9,1) | dim = 2 | n = 91>, 
   <SimplicialComplex: {3,6}_(6,5) | dim = 2 | n = 91> ]
 gap> SCIsIsomorphic(cc[1],cc[2]);
 false

6.5-4 SCNrChiralTori

Returns the number of simplicial chiral maps on the torus with \(n\) vertices, cf. [BK08] for details.

 gap> SCNrChiralTori(7);
 1
 gap> SCNrChiralTori(343);
 2

6.5-5 SCNrRegularTorus

Returns the number of simplicial regular maps on the torus with \(n\) vertices, cf. [BK08] for details.

 gap> SCNrRegularTorus(9);
 1
 gap> SCNrRegularTorus(10);
 0

6.5-6 SCRegularMap

Returns the (hyperbolic) regular map of vertex valence m, genus g and orientability orient if existent and fail otherwise. The triangulations were generated with the help of the classification of regular maps by Marston Conder [Con09]. Use SCRegularMaps (6.5-7) to get a list of all regular maps available.

 gap> SCRegularMaps(){[1..10]};
 [ [ 7, 3, true ], [ 7, 7, true ], [ 7, 8, false ], [ 7, 14, true ], 
   [ 7, 15, false ], [ 7, 147, false ], [ 8, 3, true ], [ 8, 5, true ], 
   [ 8, 8, true ], [ 8, 9, false ] ]
 gap> c:=SCRegularMap(7,7,true);
 <SimplicialComplex: Orientable regular map {7,7} | dim = 2 | n = 72>
 gap> g:=SCAutomorphismGroup(c);
 #I  group not listed
 C2 x PSL(2,8)
 gap> Size(g);
 1008

6.5-7 SCRegularMaps

Returns a list of all simplicial (hyperbolic) regular maps of orientable genus up to \(100\) or non-orientable genus up to \(200\). The list was generated with the help of the classification of regular maps by Marston Conder [Con09]. Every regular map is given by a \(3\)-tuple \((m,g,or)\) where \(m\) is the vertex valence, \(g\) is the genus and \(or\) is a boolean stating if the map is orientable or not. Use the \(3\)-tuples of the list together with SCRegularMap (6.5-6) to get the corresponding triangulations. \(g\)

 gap> ll:=SCRegularMaps(){[1..10]};
 [ [ 7, 3, true ], [ 7, 7, true ], [ 7, 8, false ], [ 7, 14, true ], 
   [ 7, 15, false ], [ 7, 147, false ], [ 8, 3, true ], [ 8, 5, true ], 
   [ 8, 8, true ], [ 8, 9, false ] ]
 gap> c:=SCRegularMap(ll[5][1],ll[5][2],ll[5][3]);
 <SimplicialComplex: Non-orientable regular map {7,15} | dim = 2 | n = 78>
 gap> SCHomology(c);
 [ [ 0, [  ] ], [ 14, [ 2 ] ], [ 0, [  ] ] ]
 gap> SCGenerators(c);
 [ [ [ 1, 4, 7 ], 182 ] ]

6.5-8 SCRegularTorus

Returns a list of regular triangulations of the torus with \(n\) vertices (the length of the list will be at most \(1\)). See [BK08] for details.

 gap> cc:=SCRegularTorus(9);
 [ <SimplicialComplex: {3,6}_(3,0) | dim = 2 | n = 9> ]
 gap> g:=SCAutomorphismGroup(cc[1]);
 Group([ (2,7)(3,4)(5,9), (1,4,2)(3,7,9)(5,8,6), (2,8,7,3,6,4)(5,9) ])
 gap> SCNumFaces(cc[1],0)*12 = Size(g);
 true

6.5-9 SCSeriesSymmetricTorus

Returns the equivarient triangulation of the torus \(\{ 3,6 \}_{(p,q)}\) with fundamental domain \((p,q)\) on the \(2\)-dimensional integer lattice. See [BK08] for details.

 gap> c:=SCSeriesSymmetricTorus(2,1);
 <SimplicialComplex: {3,6}_(2,1) | dim = 2 | n = 7>
 gap> SCFVector(c);
 [ 7, 21, 14 ]

See also SCSurface (6.3-6) for example triangulations of all compact closed surfaces with transitive cyclic automorphism group.

6.6 Generating new complexes from old

6.6-1 SCCartesianPower

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

The new complex is \(PL\)-homeomorphic to \(n\) times the cartesian product of complex, of dimensions \(n \cdot d\) and has \(f_{d}^n \cdot n \cdot \frac{2n-1}{2^{n-1}}!\) facets where \(d\) denotes the dimension and \(f_d\) denotes the number of facets of complex. Note that the complex returned by the function is not the \(n\)-fold cartesian product complex\(^n\) of complex (which, in general, is not simplicial) but a simplicial subdivision of complex\(^n\).

 gap> c:=SCBdSimplex(2);;
 gap> 4torus:=SCCartesianPower(c,4);
 <SimplicialComplex: (S^1_3)^4 | dim = 4 | n = 81>
 gap> 4torus.Homology;
 [ [ 0, [  ] ], [ 4, [  ] ], [ 6, [  ] ], [ 4, [  ] ], [ 1, [  ] ] ]
 gap> 4torus.Chi;
 0
 gap> 4torus.F;
 [ 81, 1215, 4050, 4860, 1944 ]

6.6-2 SCCartesianProduct

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Computes the simplicial cartesian product of complex1 and complex2 where complex1 and complex2 are pure, simplicial complexes. The original vertex labeling of complex1 and complex2 is changed into the standard one. The new complex has vertex labels of type \([v_i, v_j]\) where \(v_i\) is a vertex of complex1 and \(v_j\) is a vertex of complex2.

If \(n_i\), \(i=1,2\), are the number facets and \(d_i\), \(i=1,2\), are the dimensions of complexi, then the new complex has \(n_1 \cdot n_2 \cdot { d_1+d_2 \choose d_1}\) facets. The number of vertices of the new complex equals the product of the numbers of vertices of the arguments.

 gap> c1:=SCBdSimplex(2);;
 gap> c2:=SCBdSimplex(3);;
 gap> c3:=SCCartesianProduct(c1,c2);
 <SimplicialComplex: S^1_3xS^2_4 | dim = 3 | n = 12>
 gap> c3.Homology;
 [ [ 0, [  ] ], [ 1, [  ] ], [ 1, [  ] ], [ 1, [  ] ] ]
 gap> c3.F;
 [ 12, 48, 72, 36 ]

6.6-3 SCConnectedComponents

Returns: a list of simplicial complexes of type SCSimplicialComplex upon success, fail otherwise.

 gap> c:=SC([[1,2,3],[3,4,5],[4,5,6,7,8]]);;
 gap> SCRename(c,"connected complex");;
 gap> SCConnectedComponents(c);
 [ <SimplicialComplex: Connected component #1 of connected complex | dim = 4 | \
 n = 8> ]
 gap> c:=SC([[1,2,3],[4,5],[6,7,8]]);;
 gap> SCRename(c,"non-connected complex");;
 gap> SCConnectedComponents(c);
 [ <SimplicialComplex: Connected component #1 of non-connected complex | dim = \
 2 | n = 3>, 
   <SimplicialComplex: Connected component #2 of non-connected complex | dim = \
 1 | n = 2>, 
   <SimplicialComplex: Connected component #3 of non-connected complex | dim = \
 2 | n = 3> ]

6.6-4 SCConnectedProduct

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

If \(n \geq 2\), the function internally calls \(1 \times\) SCConnectedSum (6.6-5) and \((n-2) \times\) SCConnectedSumMinus (6.6-6).

 gap> SCLib.SearchByName("T^2"){[1..6]};
 [ [ 4, "T^2 (VT)" ], [ 5, "T^2 (VT)" ], [ 9, "T^2 (VT)" ], [ 10, "T^2 (VT)" ],
   [ 17, "T^2 (VT)" ], [ 20, "(T^2)#2" ] ]
 gap> torus:=SCLib.Load(last[1][1]);;
 gap> genus10:=SCConnectedProduct(torus,10);
 <SimplicialComplex: T^2 (VT)#+-T^2 (VT)#+-T^2 (VT)#+-T^2 (VT)#+-T^2 (VT)#+-T^2\
  (VT)#+-T^2 (VT)#+-T^2 (VT)#+-T^2 (VT)#+-T^2 (VT) | dim = 2 | n = 43>
 gap> genus10.Chi;
 -18
 gap> genus10.F;
 [ 43, 183, 122 ]

6.6-5 SCConnectedSum

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

In a lexicographic ordering the smallest facet of both complex1 and complex2 is removed and the complexes are glued together along the resulting boundaries. The bijection used to identify the vertices of the boundaries differs from the one chosen in SCConnectedSumMinus (6.6-6) by a transposition. Thus, the topological type of SCConnectedSum is different from the one of SCConnectedSumMinus (6.6-6) whenever complex1 and complex2 do not allow an orientation reversing homeomorphism.

 gap> SCLib.SearchByName("T^2"){[1..6]};
 [ [ 4, "T^2 (VT)" ], [ 5, "T^2 (VT)" ], [ 9, "T^2 (VT)" ], [ 10, "T^2 (VT)" ],
   [ 17, "T^2 (VT)" ], [ 20, "(T^2)#2" ] ]
 gap> torus:=SCLib.Load(last[1][1]);;
 gap> genus2:=SCConnectedSum(torus,torus);
 <SimplicialComplex: T^2 (VT)#+-T^2 (VT) | dim = 2 | n = 11>
 gap> genus2.Homology;
 [ [ 0, [  ] ], [ 4, [  ] ], [ 1, [  ] ] ]
 gap> genus2.Chi;
 -2

 gap> SCLib.SearchByName("CP^2");
 [ [ 16, "CP^2 (VT)" ], [ 96, "CP^2#-CP^2" ], [ 97, "CP^2#CP^2" ], 
   [ 185, "CP^2#(S^2xS^2)" ], [ 397, "Gaifullin CP^2" ], 
   [ 457, "(S^3~S^1)#(CP^2)^{#5} (VT)" ] ]
 gap> cp2:=SCLib.Load(last[1][1]);;
 gap> c1:=SCConnectedSum(cp2,cp2);;
 gap> c2:=SCConnectedSumMinus(cp2,cp2);;
 gap> c1.F=c2.F;
 true
 gap> c1.ASDet=c2.ASDet;
 true
 gap> SCIsIsomorphic(c1,c2);
 false
 gap> PrintArray(SCIntersectionForm(c1));
 [ [  1,  0 ],
   [  0,  1 ] ]
 gap> PrintArray(SCIntersectionForm(c2));
 [ [   1,   0 ],
   [   0,  -1 ] ]

6.6-6 SCConnectedSumMinus

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

In a lexicographic ordering the smallest facet of both complex1 and complex2 is removed and the complexes are glued together along the resulting boundaries. The bijection used to identify the vertices of the boundaries differs from the one chosen in SCConnectedSum (6.6-5) by a transposition. Thus, the topological type of SCConnectedSumMinus is different from the one of SCConnectedSum (6.6-5) whenever complex1 and complex2 do not allow an orientation reversing homeomorphism.

 gap> SCLib.SearchByName("T^2"){[1..6]};
 [ [ 4, "T^2 (VT)" ], [ 5, "T^2 (VT)" ], [ 9, "T^2 (VT)" ], [ 10, "T^2 (VT)" ],
   [ 17, "T^2 (VT)" ], [ 20, "(T^2)#2" ] ]
 gap> torus:=SCLib.Load(last[1][1]);;
 gap> genus2:=SCConnectedSumMinus(torus,torus);
 <SimplicialComplex: T^2 (VT)#+-T^2 (VT) | dim = 2 | n = 11>
 gap> genus2.Homology;
 [ [ 0, [  ] ], [ 4, [  ] ], [ 1, [  ] ] ]
 gap> genus2.Chi;
 -2

 gap> SCLib.SearchByName("CP^2");
 [ [ 16, "CP^2 (VT)" ], [ 96, "CP^2#-CP^2" ], [ 97, "CP^2#CP^2" ], 
   [ 185, "CP^2#(S^2xS^2)" ], [ 397, "Gaifullin CP^2" ], 
   [ 457, "(S^3~S^1)#(CP^2)^{#5} (VT)" ] ]
 gap> cp2:=SCLib.Load(last[1][1]);;
 gap> c1:=SCConnectedSum(cp2,cp2);;
 gap> c2:=SCConnectedSumMinus(cp2,cp2);;
 gap> c1.F=c2.F;
 true
 gap> c1.ASDet=c2.ASDet;
 true
 gap> SCIsIsomorphic(c1,c2);
 false
 gap> PrintArray(SCIntersectionForm(c1));
 [ [  1,  0 ],
   [  0,  1 ] ]
 gap> PrintArray(SCIntersectionForm(c2));
 [ [   1,   0 ],
   [   0,  -1 ] ]

6.6-7 SCDifferenceCycleCompress

A difference cycle is returned, i. e. a list of integer values of length \((d+1)\), if \(d\) is the dimension of simplex, and a sum equal to modulus. In some sense this is the inverse operation of SCDifferenceCycleExpand (6.6-8).

 gap> sphere:=SCBdSimplex(4);;
 gap> gens:=SCGenerators(sphere);
 [ [ [ 1, 2, 3, 4 ], [ 5 ] ] ]
 gap> diffcycle:=SCDifferenceCycleCompress(gens[1][1],5);
 [ 1, 1, 1, 2 ]
 gap> c:=SCDifferenceCycleExpand([1,1,1,2]);;
 gap> c.Facets;
 [ [ 1, 2, 3, 4 ], [ 1, 2, 3, 5 ], [ 1, 2, 4, 5 ], [ 1, 3, 4, 5 ], 
   [ 2, 3, 4, 5 ] ]

6.6-8 SCDifferenceCycleExpand

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

diffcycle induces a simplex \(\Delta = ( v_1 , \ldots , v_{n+1} )\) by \(v_1 = \)diffcycle[1], \(v_i = v_{i-1} + \) diffcycle[i] and a cyclic group action by \(\mathbb{Z}_{\sigma}\) where \(\sigma = \sum \) diffcycle[i] is the modulus of diffcycle. The function returns the \(\mathbb{Z}_{\sigma}\)-orbit of \(\Delta\).

Note that modulo operations in GAP are often a little bit cumbersome, since all integer ranges usually start from \(1\).

 gap> c:=SCDifferenceCycleExpand([1,1,2]);;
 gap> c.Facets;
 [ [ 1, 2, 3 ], [ 1, 2, 4 ], [ 1, 3, 4 ], [ 2, 3, 4 ] ]

6.6-9 SCStronglyConnectedComponents

Returns: a list of simplicial complexes of type SCSimplicialComplex upon success, fail otherwise.

 gap> c:=SC([[1,2,3],[2,3,4],[4,5,6],[5,6,7]]);;
 gap> comps:=SCStronglyConnectedComponents(c);
 [ <SimplicialComplex: Strongly connected component #1 of unnamed complex 85 | \
 dim = 2 | n = 4>, 
   <SimplicialComplex: Strongly connected component #2 of unnamed complex 85 | \
 dim = 2 | n = 4> ]
 gap> comps[1].Facets;
 [ [ 1, 2, 3 ], [ 2, 3, 4 ] ]
 gap> comps[2].Facets;
 [ [ 4, 5, 6 ], [ 5, 6, 7 ] ]

6.7 Simplicial complexes from transitive permutation groups

Beginning from Version 1.3.0, simpcomp is able to generate triangulations from a prescribed transitive group action on its set of vertices. Note that the corresponding group is a subgroup of the full automorphism group, but not necessarily the full automorphism group of the triangulations obtained in this way. The methods and algorithms are based on the works of Frank H. Lutz [Lut03], [Lut] and in particular his program MANIFOLD_VT.

6.7-1 SCsFromGroupExt

Returns: a list of simplicial complexes of type SCSimplicialComplex upon success, fail otherwise.

Computes all combinatorial d-pseudomanifolds, \(d=2\) / all strongly connected combinatorial d-pseudomanifolds, \(d \geq 3\), as a union of orbits of the group action of G on (d+1)-tuples on the set of n vertices, see [Lut03]. The integer argument objectType specifies, whether complexes exceeding the maximal size of each vertex link for combinatorial manifolds are sorted out (objectType = 0) or not (objectType = 1, in this case some combinatorial pseudomanifolds won't be found, but no combinatorial manifold will be sorted out). The integer argument cache specifies if the orbits are held in memory during the computation, a value of 0 means that the orbits are discarded, trading speed for memory, any other value means that they are kept, trading memory for speed. The boolean argument removeDoubleEntries specifies whether the results are checked for combinatorial isomorphism, preventing isomorphic entries. The argument outfile specifies an output file containing all complexes found by the algorithm, if outfile is anything else than a string, not output file is generated. The argument maxLinkSize determines a maximal link size of any output complex. If maxLinkSize\(=0\) or if maxLinkSize is anything else than an integer the argument is ignored. The argument subset specifies a set of orbits (given by a list of indices of repHigh) which have to be contained in any output complex. If subset is anything else than a subset of matrixAllowedRows the argument is ignored.

 gap> G:=PrimitiveGroup(8,5);
 PGL(2, 7)
 gap> Size(G);
 336
 gap> Transitivity(G);
 3
 gap> list:=SCsFromGroupExt(G,8,3,1,0,true,false,0,[]);
 [ "defgh.g.h.fah.e.gaf.h.eag.e.faf.a.haa.g.fah.a.gjhzh" ]
 gap> c:=SCFromIsoSig(list[1]);
 <SimplicialComplex: unnamed complex 6 | dim = 3 | n = 8>
 gap> SCNeighborliness(c); 
 3
 gap> c.F;
 [ 8, 28, 56, 28 ]
 gap> c.IsManifold; 
 false
 gap> SCLibDetermineTopologicalType(SCLink(c,1));
 <SimplicialComplex: lk([ 1 ]) in unnamed complex 6 | dim = 2 | n = 7>
 gap> # there are no 3-neighborly 3-manifolds with 8 vertices
 gap> list:=SCsFromGroupExt(PrimitiveGroup(8,5),8,3,0,0,true,false,0,[]); 
 gap> [  ]

6.7-2 SCsFromGroupByTransitivity

Returns: a list of simplicial complexes of type SCSimplicialComplex upon success, fail otherwise.

Computes all combinatorial d-pseudomanifolds, \(d = 2\) / all strongly connected combinatorial d-pseudomanifolds, \(d \geq 3\), as union of orbits of group actions for all k-transitive groups on (d+1)-tuples on the set of n vertices, see [Lut03]. The boolean argument maniflag specifies, whether the resulting complexes should be listed separately by combinatorial manifolds, combinatorial pseudomanifolds and complexes where the verification that the object is at least a combinatorial pseudomanifold failed. The boolean argument computeAutGroup specifies whether or not the real automorphism group should be computed (note that a priori the generating group is just a subgroup of the automorphism group). The boolean argument removeDoubleEntries specifies whether the results are checked for combinatorial isomorphism, preventing isomorphic entries. Internally calls SCsFromGroupExt (6.7-1) for every group.

 gap> list:=SCsFromGroupByTransitivity(8,3,2,true,true,true);
 #I  SCsFromGroupByTransitivity: Building list of groups...
 #I  SCsFromGroupByTransitivity: ...2 groups found.
 #I  degree 8: [ AGL(1, 8), PSL(2, 7) ]
 #I  SCsFromGroupByTransitivity: Processing dimension 3.
 #I  SCsFromGroupByTransitivity: Processing degree 8.
 #I  SCsFromGroupByTransitivity: 1 / 2 groups calculated, found 0 complexes.
 #I  SCsFromGroupByTransitivity: Calculating 0 automorphism and homology groups...
 #I  SCsFromGroupByTransitivity: ...all automorphism groups calculated for group 1 / 2.
 #I  SCsFromGroupByTransitivity: 2 / 2 groups calculated, found 1 complexes.
 #I  SCsFromGroupByTransitivity: Calculating 1 automorphism and homology groups...
 #I  group not listed
 #I  SCsFromGroupByTransitivity: 1 / 1 automorphism groups calculated.
 #I  SCsFromGroupByTransitivity: ...all automorphism groups calculated for group 2 / 2.
 #I  SCsFromGroupByTransitivity: ...done dim = 3, deg =  8, 0 manifolds, 1 pseudomanifolds, 0 candidates found.
 #I  SCsFromGroupByTransitivity: ...done dim = 3.
 [ [  ], [  ], [  ] ]

6.8 The classification of cyclic combinatorial 3-manifolds

This section contains functions to access the classification of combinatorial 3-manifolds with transitive cyclic symmetry and up to 22 vertices as presented in [Spr14].

6.8-1 SCNrCyclic3Mflds

Returns the number of combinatorial 3-manifolds with transitive cyclic symmetry with i vertices. See [Spr14] for more about the classification of combinatorial 3-manifolds with transitive cyclic symmetry up to \(22\) vertices.

 gap> SCNrCyclic3Mflds(22);
 3090

6.8-2 SCCyclic3MfldTopTypes

Returns a list of all topological types that occur in the classification combinatorial 3-manifolds with transitive cyclic symmetry with i vertices. See [Spr14] for more about the classification of combinatorial 3-manifolds with transitive cyclic symmetry up to \(22\) vertices.

 gap> SCCyclic3MfldTopTypes(19);
 [ "B2", "RP^2xS^1", "SFS[RP^2:(2,1)(3,1)]", "S^2~S^1", "S^3", "Sigma(2,3,7)", 
   "T^3" ]

6.8-3 SCCyclic3Mfld

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Returns the jth combinatorial 3-manifold with i vertices in the classification of combinatorial 3-manifolds with transitive cyclic symmetry. See [Spr14] for more about the classification of combinatorial 3-manifolds with transitive cyclic symmetry up to \(22\) vertices.

 gap> SCCyclic3Mfld(15,34);
 <SimplicialComplex: Cyclic 3-mfld (15,34): T^3 | dim = 3 | n = 15>

6.8-4 SCCyclic3MfldByType

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Returns the smallest combinatorial 3-manifolds in the classification of combinatorial 3-manifolds with transitive cyclic symmetry of topological type type. See [Spr14] for more about the classification of combinatorial 3-manifolds with transitive cyclic symmetry up to \(22\) vertices.

 gap> SCCyclic3MfldByType("T^3");
 <SimplicialComplex: Cyclic 3-mfld (15,34): T^3 | dim = 3 | n = 15>

6.8-5 SCCyclic3MfldListOfGivenType

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Returns a list of indices \(\{ (i_1, j_1) , (i_1, j_1) , \ldots (i_n, j_n) \}\) of all combinatorial 3-manifolds in the classification of combinatorial 3-manifolds with transitive cyclic symmetry of topological type type. Complexes can be obtained by calling SCCyclic3Mfld (6.8-3) using these indices. See [Spr14] for more about the classification of combinatorial 3-manifolds with transitive cyclic symmetry up to \(22\) vertices.

 gap> SCCyclic3MfldListOfGivenType("Sigma(2,3,7)");
 [ [ 19, 100 ], [ 19, 118 ], [ 19, 120 ], [ 19, 130 ] ]

6.9 Computing properties of simplicial complexes

The following functions compute basic properties of simplicial complexes of type SCSimplicialComplex. None of these functions alter the complex. All properties are returned as immutable objects (this ensures data consistency of the cached properties of a simplicial complex). Use ShallowCopy or the internal simpcomp function SCIntFunc.DeepCopy to get a mutable copy.

Note: every simplicial complex is internally stored with the standard vertex labeling from \(1\) to \(n\) and a maptable to restore the original vertex labeling. Thus, we have to relabel some of the complex properties (facets, face lattice, generators, etc...) whenever we want to return them to the user. As a consequence, some of the functions exist twice, one of them with the appendix "Ex". These functions return the standard labeling whereas the other ones relabel the result to the original labeling.

6.9-1 SCAltshulerSteinberg

Definition: Let \(v_i\), \(1 \leq i \leq n\) be the vertices and let \(F_j\), \(1 \leq j \leq m\) be the facets of a pure simplicial complex \(C\), then the determinant of \(AS \in \mathbb{Z}^{n \times m}\), \(AS_{ij}=1\) if \(v_i \in F_j\), \(AS_{ij}=0\) otherwise, is called the Altshuler-Steinberg matrix. The Altshuler-Steinberg determinant is the determinant of the quadratic matrix \(AS \cdot AS^T\).

The Altshuler-Steinberg determinant is a combinatorial invariant of \(C\) and can be checked before searching for an isomorphism between two simplicial complexes.

 gap> list:=SCLib.SearchByName("T^2");; 
 gap> torus:=SCLib.Load(last[1][1]);;
 gap> SCAltshulerSteinberg(torus);
 73728
 gap> c:=SCBdSimplex(3);;
 gap> SCAltshulerSteinberg(c);
 9
 gap> c:=SCBdSimplex(4);;
 gap> SCAltshulerSteinberg(c);
 16
 gap> c:=SCBdSimplex(5);;
 gap> SCAltshulerSteinberg(c);
 25

6.9-2 SCAutomorphismGroup

Computes the automorphism group of a strongly connected pseudomanifold complex, i. e. the group of all automorphisms on the set of vertices of complex that do not change the complex as a whole. Necessarily the group is a subgroup of the symmetric group \(S_n\) where \(n\) is the number of vertices of the simplicial complex.

The function uses an efficient algorithm provided by the package GRAPE (see [Soi12], which is based on the program nauty by Brendan McKay [MP14]). If the package GRAPE is not available, this function call falls back to SCAutomorphismGroupInternal (6.9-3).

The position of the group in the GAP libraries of small groups, transitive groups or primitive groups is given. If the group is not listed, its structure description, provided by the GAP function StructureDescription(), is returned as the name of the group. Note that the latter form is not always unique, since every non trivial semi-direct product is denoted by '':''.

 gap> SCLib.SearchByName("K3");            
 [ [ 520, "K3_16" ], [ 539, "K3_17" ] ]
 gap> k3surf:=SCLib.Load(last[1][1]);; 
 gap> SCAutomorphismGroup(k3surf);               
 Group([ (1,2)(3,4)(5,6)(7,8)(9,10)(11,12)(13,14)(15,16), (1,2,8,14,5)
   (3,11,9,4,13)(6,7,12,15,10), (1,3,2)(5,11,14)(6,9,15)(7,10,13)(8,12,16) ])

6.9-3 SCAutomorphismGroupInternal

 gap> c:=SCBdSimplex(5);;
 gap> SCAutomorphismGroupInternal(c);
 Sym( [ 1 .. 6 ] )

 gap> c:=SC([[1,2],[2,3],[1,3]]);;
 gap> g:=SCAutomorphismGroupInternal(c);
 Group([ (2,3), (1,2,3) ])
 gap> List(g);
 [ (), (1,2,3), (1,3,2), (2,3), (1,2), (1,3) ]
 gap> StructureDescription(g);
 "S3"

6.9-4 SCAutomorphismGroupSize

Computes the size of the automorphism group of a strongly connected pseudomanifold complex, see SCAutomorphismGroup (6.9-2).

 gap> SCLib.SearchByName("K3");            
 [ [ 520, "K3_16" ], [ 539, "K3_17" ] ]
 gap> k3surf:=SCLib.Load(last[1][1]);;           
 gap> SCAutomorphismGroupSize(k3surf);               
 240

6.9-5 SCAutomorphismGroupStructure

Computes the GAP structure description of the automorphism group of a strongly connected pseudomanifold complex, see SCAutomorphismGroup (6.9-2).

 gap> SCLib.SearchByName("K3");     
 [ [ 520, "K3_16" ], [ 539, "K3_17" ] ]
 gap> k3surf:=SCLib.Load(last[1][1]);;      
 gap> SCAutomorphismGroupStructure(k3surf);
 "(C2 x C2 x C2 x C2) : C15"

6.9-6 SCAutomorphismGroupTransitivity

Computes the transitivity of the automorphism group of a strongly connected pseudomanifold complex, i. e. the maximal integer \(t\) such that for any two ordered \(t\)-tuples \(T_1\) and \(T_2\) of vertices of complex, there exists an element \(g\) in the automorphism group of complex for which \(gT_1=T_2\), see [Hup67].

 gap> SCLib.SearchByName("K3");            
 [ [ 520, "K3_16" ], [ 539, "K3_17" ] ]
 gap> k3surf:=SCLib.Load(last[1][1]);;           
 gap> SCAutomorphismGroupTransitivity(k3surf);               
 2

6.9-7 SCBoundary

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

The function computes the boundary of a simplicial complex complex satisfying the weak pseudomanifold property and returns it as a simplicial complex. In addition, it is stored as a property of complex.

The boundary of a simplicial complex is defined as the simplicial complex consisting of all \(d-1\)-faces that are contained in exactly one facet.

If complex does not fulfill the weak pseudomanifold property (i. e. if the valence of any \(d-1\)-face exceeds \(2\)) the function returns fail.

 gap> c:=SC([[1,2,3,4],[1,2,3,5],[1,2,4,5],[1,3,4,5]]);
 <SimplicialComplex: unnamed complex 63 | dim = 3 | n = 5>
 gap> SCBoundary(c);
 <SimplicialComplex: Bd(unnamed complex 63) | dim = 2 | n = 4>
 gap> c;  
 <SimplicialComplex: unnamed complex 63 | dim = 3 | n = 5>

6.9-8 SCDehnSommervilleCheck

Checks if the simplicial complex c fulfills the Dehn Sommerville equations: \(h_j - h_{d+1-j} = (-1)^{d+1-j} { d+1 \choose j } (\chi (M) - 2)\) for \(0 \leq j \leq \frac{d}{2}\) and \(d\) even, and \(h_j - h_{d+1-j} = 0\) for \(0 \leq j \leq \frac{d-1}{2}\) and \(d\) odd. Where \(h_j\) is the \(j\)th component of the \(h\)-vector, see SCHVector (6.9-26).

 gap> c:=SCBdCrossPolytope(6);;
 gap> SCDehnSommervilleCheck(c);
 true
 gap> c:=SC([[1,2,3],[1,4,5]]);;
 gap> SCDehnSommervilleCheck(c);
 false

6.9-9 SCDehnSommervilleMatrix

Returns: a (d+1)\(\times\)Int(d+1/2) matrix with integer entries upon success, fail otherwise.

Computes the coefficients of the Dehn Sommerville equations for dimension d: \(h_j - h_{d+1-j} = (-1)^{d+1-j} { d+1 \choose j } (\chi (M) - 2)\) for \(0 \leq j \leq \frac{d}{2}\) and \(d\) even, and \(h_j - h_{d+1-j} = 0\) for \(0 \leq j \leq \frac{d-1}{2}\) and \(d\) odd. Where \(h_j\) is the \(j\)th component of the \(h\)-vector, see SCHVector (6.9-26).

 gap> m:=SCDehnSommervilleMatrix(6);;
 gap> PrintArray(m);
 [ [    1,   -1,    1,   -1,    1,   -1,    1 ],
   [    0,   -2,    3,   -4,    5,   -6,    7 ],
   [    0,    0,    0,   -4,   10,  -20,   35 ],
   [    0,    0,    0,    0,    0,   -6,   21 ] ]

6.9-10 SCDifferenceCycles

Computes the difference cycles of complex in standard labeling if complex is invariant under a shift of the vertices of type \(v \mapsto v+1 \mod n\). The function returns the difference cycles as lists where the sum of the entries equals the number of vertices \(n\) of complex.

 gap> torus:=SCFromDifferenceCycles([[1,2,4],[1,4,2]]);
 <SimplicialComplex: complex from diffcycles [ [ 1, 2, 4 ], [ 1, 4, 2 ] ] | dim\
  = 2 | n = 7>
 gap> torus.Homology;
 [ [ 0, [  ] ], [ 2, [  ] ], [ 1, [  ] ] ]
 gap> torus.DifferenceCycles;
 [ [ 1, 2, 4 ], [ 1, 4, 2 ] ]

6.9-11 SCDim

Computes the dimension of a simplicial complex. If the complex is not pure, the dimension of the highest dimensional simplex is returned.

 gap> complex:=SC([[1,2,3], [1,2,4], [1,3,4], [2,3,4]]);;
 gap> SCDim(complex);                                    
 2
 gap> c:=SC([[1], [2,4], [3,4], [5,6,7,8]]);;
 gap> SCDim(c);
 3

6.9-12 SCDualGraph

Returns: 1-dimensional simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

 gap> sphere:=SCBdSimplex(5);;
 gap> graph:=SCFaces(sphere,1);       
 [ [ 1, 2 ], [ 1, 3 ], [ 1, 4 ], [ 1, 5 ], [ 1, 6 ], [ 2, 3 ], [ 2, 4 ], 
   [ 2, 5 ], [ 2, 6 ], [ 3, 4 ], [ 3, 5 ], [ 3, 6 ], [ 4, 5 ], [ 4, 6 ], 
   [ 5, 6 ] ]
 gap> graph:=SC(graph);;              
 gap> dualGraph:=SCDualGraph(sphere); 
 <SimplicialComplex: dual graph of S^4_6 | dim = 1 | n = 6>
 gap> graph.Facets = dualGraph.Facets;
 true

6.9-13 SCEulerCharacteristic

Computes the Euler characteristic \( \chi(C)=\sum \limits_{i=0}^{d} (-1)^{i} f_i \) of a simplicial complex \(C\), where \(f_i\) denotes the \(i\)-th component of the \(f\)-vector.

 gap> complex:=SCFromFacets([[1,2,3], [1,2,4], [1,3,4], [2,3,4]]);;
 gap> SCEulerCharacteristic(complex);
 2
 gap> s2:=SCBdSimplex(3);;
 gap> s2.EulerCharacteristic;
 2

6.9-14 SCFVector

Computes the \(f\)-vector of the simplicial complex complex, i. e. the number of \(i\)-dimensional faces for \( 0 \leq i \leq d \), where \(d\) is the dimension of complex. A memory-saving implicit algorithm is used that avoids calculating the face lattice of the complex. Internally calls SCNumFaces (6.9-52).

 gap> complex:=SC([[1,2,3], [1,2,4], [1,3,4], [2,3,4]]);;
 gap> SCFVector(complex);
 [ 4, 6, 4 ]

6.9-15 SCFaceLattice

Computes the entire face lattice of a \(d\)-dimensional simplicial complex, i. e. all of its \(i\)-skeletons for \(0 \leq i \leq d\). The faces are returned in the original labeling.

 gap> c:=SC([["a","b","c"],["a","b","d"], ["a","c","d"], ["b","c","d"]]);;
 gap> SCFaceLattice(c);
 [ [ [ "a" ], [ "b" ], [ "c" ], [ "d" ] ], 
   [ [ "a", "b" ], [ "a", "c" ], [ "a", "d" ], [ "b", "c" ], [ "b", "d" ], 
       [ "c", "d" ] ], 
   [ [ "a", "b", "c" ], [ "a", "b", "d" ], [ "a", "c", "d" ], 
       [ "b", "c", "d" ] ] ]

6.9-16 SCFaceLatticeEx

Computes the entire face lattice of a \(d\)-dimensional simplicial complex, i. e. all of its \(i\)-skeletons for \(0 \leq i \leq d\). The faces are returned in the standard labeling.

 gap> c:=SC([["a","b","c"],["a","b","d"], ["a","c","d"], ["b","c","d"]]);;
 gap> SCFaceLatticeEx(c);
 [ [ [ 1 ], [ 2 ], [ 3 ], [ 4 ] ], 
   [ [ 1, 2 ], [ 1, 3 ], [ 1, 4 ], [ 2, 3 ], [ 2, 4 ], [ 3, 4 ] ], 
   [ [ 1, 2, 3 ], [ 1, 2, 4 ], [ 1, 3, 4 ], [ 2, 3, 4 ] ] ]

6.9-17 SCFaces

6.9-18 SCFacesEx

6.9-19 SCFacets

 gap> c:=SC([[2,3],[3,4],[4,2]]);;
 gap> SCFacets(c);
 [ [ 2, 3 ], [ 2, 4 ], [ 3, 4 ] ]

6.9-20 SCFacetsEx

Returns the facets of a simplicial complex as they are stored, i. e. with standard vertex labeling from 1 to n.

 gap> c:=SC([[2,3],[3,4],[4,2]]);;
 gap> SCFacetsEx(c);
 [ [ 1, 2 ], [ 1, 3 ], [ 2, 3 ] ]

6.9-21 SCFpBettiNumbers

Computes the Betti numbers of a simplicial complex with respect to the field \(\mathbb{F}_p\) for any prime number p.

 gap> SCLib.SearchByName("K^2");    
 [ [ 18, "K^2 (VT)" ], [ 221, "K^2 (VT)" ] ]
 gap> kleinBottle:=SCLib.Load(last[1][1]);; 
 gap> SCHomology(kleinBottle);      
 [ [ 0, [  ] ], [ 1, [ 2 ] ], [ 0, [  ] ] ]
 gap> SCFpBettiNumbers(kleinBottle,2);
 [ 1, 2, 1 ]
 gap> SCFpBettiNumbers(kleinBottle,3);
 [ 1, 1, 0 ]

6.9-22 SCFundamentalGroup

Computes the first fundamental group of complex, which must be a connected simplicial complex, and returns it in form of a finitely presented group. The generators of the group are given as 2-tuples that correspond to the edges of complex in standard labeling. You can use GAP's SimplifiedFpGroup to simplify the group presenation.

 gap> list:=SCLib.SearchByName("RP^2");
 [ [ 3, "RP^2 (VT)" ], [ 262, "RP^2xS^1" ] ]
 gap> c:=SCLib.Load(list[1][1]);
 <SimplicialComplex: RP^2 (VT) | dim = 2 | n = 6>
 gap> g:=SCFundamentalGroup(c);;
 gap> StructureDescription(g);
 "C2"

6.9-23 SCGVector

Computes the g-vector of a simplicial complex. The \(g\)-vector is defined as follows:

Let \(h\) be the \(h\)-vector of a \(d\)-dimensional simplicial complex C, then \(g_i:=h_{i+1} - h_{i} ; \quad \frac{d}{2} \geq i \geq 0 \) is called the \(g\)-vector of \(C\). For the definition of the \(h\)-vector see SCHVector (6.9-26). The information contained in \(g\) suffices to determine the \(f\)-vector of \(C\).

 gap> SCLib.SearchByName("RP^2");
 [ [ 3, "RP^2 (VT)" ], [ 262, "RP^2xS^1" ] ]
 gap> rp2_6:=SCLib.Load(last[1][1]);;
 gap> SCFVector(rp2_6);
 [ 6, 15, 10 ]
 gap> SCHVector(rp2_6);
 [ 3, 6, 0 ]
 gap> SCGVector(rp2_6);
 [ 2, 3 ]

6.9-24 SCGenerators

Returns: a list of pairs of the form [ list, integer ] upon success, fail otherwise.

Computes the generators of a simplicial complex in the original vertex labeling.

The generating set of a simplicial complex is a list of simplices that will generate the complex by uniting their \(G\)-orbits if \(G\) is the automorphism group of complex.

 gap> list:=SCLib.SearchByName("T^2");;
 gap> torus:=SCLib.Load(list[1][1]);;
 gap> SCGenerators(torus); 
 [ [ [ 1, 2, 4 ], 14 ] ]

 gap> SCLib.SearchByName("K3");
 [ [ 520, "K3_16" ], [ 539, "K3_17" ] ]
 gap> SCLib.Load(last[1][1]);
 <SimplicialComplex: K3_16 | dim = 4 | n = 16>
 gap> SCGenerators(last);
 [ [ [ 1, 2, 3, 8, 12 ], 240 ], [ [ 1, 2, 5, 8, 14 ], 48 ] ]

6.9-25 SCGeneratorsEx

Returns: a list of pairs of the form [ list, integer ] upon success, fail otherwise.

Computes the generators of a simplicial complex in the standard vertex labeling.

The generating set of a simplicial complex is a list of simplices that will generate the complex by uniting their \(G\)-orbits if \(G\) is the automorphism group of complex.

 gap> list:=SCLib.SearchByName("T^2");;
 gap> torus:=SCLib.Load(list[1][1]);;
 gap> SCGeneratorsEx(torus); 
 [ [ [ 1, 2, 4 ], 14 ] ]

 gap> SCLib.SearchByName("K3");
 [ [ 520, "K3_16" ], [ 539, "K3_17" ] ]
 gap> SCLib.Load(last[1][1]);
 <SimplicialComplex: K3_16 | dim = 4 | n = 16>
 gap> SCGeneratorsEx(last);
 [ [ [ 1, 2, 3, 8, 12 ], 240 ], [ [ 1, 2, 5, 8, 14 ], 48 ] ]

6.9-26 SCHVector

Computes the \(h\)-vector of a simplicial complex. The \(h\)-vector is defined as \( h_{k}:= \sum \limits_{i=-1}^{k-1} (-1)^{k-i-1}{d-i-1 \choose k-i-1} f_i\) for \(0 \leq k \leq d\), where \(f_{-1} := 1\). For all simplicial complexes we have \(h_0 = 1\), hence the returned list starts with the second entry of the \(h\)-vector.

 gap> SCLib.SearchByName("RP^2");
 [ [ 3, "RP^2 (VT)" ], [ 262, "RP^2xS^1" ] ]
 gap> rp2_6:=SCLib.Load(last[1][1]);;
 gap> SCFVector(rp2_6);
 [ 6, 15, 10 ]
 gap> SCHVector(rp2_6);
 [ 3, 6, 0 ]

6.9-27 SCHasBoundary

Checks if a simplicial complex complex that fulfills the weak pseudo manifold property has a boundary, i. e. \(d-1\)-faces of valence \(1\). If complex is closed false is returned, if complex does not fulfill the weak pseudomanifold property, fail is returned, otherwise true is returned.

 gap> SCLib.SearchByName("K^2"); 
 [ [ 18, "K^2 (VT)" ], [ 221, "K^2 (VT)" ] ]
 gap> kleinBottle:=SCLib.Load(last[1][1]);;
 gap> SCHasBoundary(kleinBottle);
 false

 gap> c:=SC([[1,2,3,4],[1,2,3,5],[1,2,4,5],[1,3,4,5]]);;
 gap> SCHasBoundary(c);
 true

6.9-28 SCHasInterior

Returns true if a simplicial complex complex that fulfills the weak pseudomanifold property has at least one \(d-1\)-face of valence \(2\), i. e. if there exist at least one \(d-1\)-face that is not in the boundary of complex, if no such face can be found false is returned. It complex does not fulfill the weak pseudomanifold property fail is returned.

 gap> c:=SC([[1,2,3,4],[1,2,3,5],[1,2,4,5],[1,3,4,5]]);;
 gap> SCHasInterior(c)
 true
 gap> c:=SC([[1,2,3,4]]);;
 gap> SCHasInterior(c);
 false

6.9-29 SCHeegaardSplittingSmallGenus

Returns: a list of an integer, a list of two sublists and a string upon success, fail otherwise.

Computes a Heegaard splitting of the combinatorial \(3\)-manifold M of small genus. The function returns the genus of the Heegaard splitting, the vertex partition of the Heegaard splitting and information whether the splitting is minimal or just small (i. e. the Heegaard genus could not be determined). See also SCHeegaardSplitting (6.9-30) for a faster computation of a Heegaard splitting of arbitrary genus and SCIsHeegaardSplitting (6.9-40) for a test whether or not a given splitting defines a Heegaard splitting.

 
 gap> c:=SCSeriesBdHandleBody(3,10);;
 gap> M:=SCConnectedProduct(c,3);;
 gap> list:=SCHeegaardSplittingSmallGenus(M);
 This creates an error

6.9-30 SCHeegaardSplitting

Returns: a list of an integer, a list of two sublists and a string upon success, fail otherwise.

Computes a Heegaard splitting of the combinatorial \(3\)-manifold M. The function returns the genus of the Heegaard splitting, the vertex partition of the Heegaard splitting and a note, that splitting is arbitrary and in particular possibly not minimal. See also SCHeegaardSplittingSmallGenus (6.9-29) for the calculation of a Heegaard splitting of small genus and SCIsHeegaardSplitting (6.9-40) for a test whether or not a given splitting defines a Heegaard splitting.

 gap> M:=SCSeriesBdHandleBody(3,12);;
 gap> list:=SCHeegaardSplitting(M);
 [ 1, [ [ 1, 2, 3, 5, 9 ], [ 4, 6, 7, 8, 10, 11, 12 ] ], "arbitrary" ]
 gap> sl:=SCSlicing(M,list[2]);
 <NormalSurface: slicing [ [ 1, 2, 3, 5, 9 ], [ 4, 6, 7, 8, 10, 11, 12 ] ] of S\
 phere bundle S^2 x S^1 | dim = 2>

6.9-31 SCHomologyClassic

Computes the integral simplicial homology groups of a simplicial complex complex (internally calls the function SimplicialHomology(complex.FacetsEx) from the homology package, see [DHSW11]).

If the homology package is not available, this function call falls back to SCHomologyInternal (8.1-5). The output is a list of homology groups of the form \([H_0,....,H_d]\), where \(d\) is the dimension of complex. The format of the homology groups \(H_i\) is given in terms of their maximal cyclic subgroups, i.e. a homology group \(H_i\cong \mathbb{Z}^f + \mathbb{Z} / t_1 \mathbb{Z} \times \dots \times \mathbb{Z} / t_n \mathbb{Z}\) is returned in form of a list \([ f, [t_1,...,t_n] ]\), where \(f\) is the (integer) free part of \(H_i\) and \(t_i\) denotes the torsion parts of \(H_i\) ordered in weakly increasing size.

 gap> SCLib.SearchByName("K^2");
 [ [ 18, "K^2 (VT)" ], [ 221, "K^2 (VT)" ] ]
 gap> kleinBottle:=SCLib.Load(last[1][1]);;
 gap> kleinBottle.Homology;          
 [ [ 0, [  ] ], [ 1, [ 2 ] ], [ 0, [  ] ] ]
 gap> SCLib.SearchByName("L_"){[1..10]};
 [ [ 123, "L_3_1" ], [ 265, "L_4_1" ], [ 289, "L_5_2" ], 
   [ 368, "(S^2~S^1)#L_3_1" ], [ 369, "(S^2xS^1)#L_3_1" ], [ 400, "L_5_1" ], 
   [ 403, "(S^2~S^1)#2#L_3_1" ], [ 406, "(S^2xS^1)#2#L_3_1" ], 
   [ 496, "L_7_2" ], [ 498, "L_8_3" ] ]
 gap> c:=SCConnectedSum(SCLib.Load(last[9][1]),
                        SCConnectedProduct(SCLib.Load(last[10][1]),2));
 > <SimplicialComplex: L_7_2#+-L_8_3#+-L_8_3 | dim = 3 | n = 40>
 gap> SCHomology(c);
 [ [ 0, [  ] ], [ 0, [ 8, 56 ] ], [ 0, [  ] ], [ 1, [  ] ] ]
 gap> SCFpBettiNumbers(c,2);
 [ 1, 2, 2, 1 ]
 gap> SCFpBettiNumbers(c,3);
 [ 1, 0, 0, 1 ]

6.9-32 SCIncidences

Returns a list of all k-faces of the simplicial complex complex. The list is sorted by the valence of the faces in the k+1-skeleton of the complex, i. e. the \(i\)-th entry of the list contains all k-faces of valence \(i\). The faces are returned in the original labeling.

 gap> c:=SC([[1,2,3],[2,3,4],[3,4,5],[4,5,6],[1,5,6],[1,4,6],[2,3,6]]);;
 gap> SCIncidences(c,1);
 [ [ [ 1, 2 ], [ 1, 3 ], [ 1, 4 ], [ 1, 5 ], [ 2, 4 ], [ 2, 6 ], [ 3, 5 ], 
       [ 3, 6 ] ], [ [ 1, 6 ], [ 3, 4 ], [ 4, 5 ], [ 4, 6 ], [ 5, 6 ] ], 
   [ [ 2, 3 ] ] ]

6.9-33 SCIncidencesEx

 gap> c:=SC([[1,2,3],[2,3,4],[3,4,5],[4,5,6],[1,5,6],[1,4,6],[2,3,6]]);;
 gap> SCIncidences(c,1);
 [ [ [ 1, 2 ], [ 1, 3 ], [ 1, 4 ], [ 1, 5 ], [ 2, 4 ], [ 2, 6 ], [ 3, 5 ], 
       [ 3, 6 ] ], [ [ 1, 6 ], [ 3, 4 ], [ 4, 5 ], [ 4, 6 ], [ 5, 6 ] ], 
   [ [ 2, 3 ] ] ]

6.9-34 SCInterior

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Computes all \(d-1\)-faces of valence \(2\) of a simplicial complex complex that fulfills the weak pseudomanifold property, i. e. the function returns the part of the \(d-1\)-skeleton of \(C\) that is not part of the boundary.

 gap> c:=SC([[1,2,3,4],[1,2,3,5],[1,2,4,5],[1,3,4,5]]);;
 gap> SCInterior(c).Facets;
 [ [ 1, 2, 3 ], [ 1, 2, 4 ], [ 1, 2, 5 ], [ 1, 3, 4 ], [ 1, 3, 5 ], 
   [ 1, 4, 5 ] ]
 gap> c:=SC([[1,2,3,4]]);;
 gap> SCInterior(c).Facets;
 [  ]

6.9-35 SCIsCentrallySymmetric

Checks if a simplicial complex complex is centrally symmetric, i. e. if its automorphism group contains a fixed point free involution.

 gap> c:=SCBdCrossPolytope(4);;
 gap> SCIsCentrallySymmetric(c);
 true

 gap> c:=SCBdSimplex(4);;
 gap> SCIsCentrallySymmetric(c);
 false

6.9-36 SCIsConnected

 gap> c:=SCBdSimplex(1);;
 gap> SCIsConnected(c);
 false
 gap> c:=SCBdSimplex(2);;
 gap> SCIsConnected(c);
 true

6.9-37 SCIsEmpty

Checks if a simplicial complex complex is the empty complex, i. e. a SCSimplicialComplex object with empty facet list.

 gap> c:=SC([[1]]);;
 gap> SCIsEmpty(c);
 false
 gap> c:=SC([]);;
 gap> SCIsEmpty(c);
 true
 gap> c:=SC([[]]);;
 gap> SCIsEmpty(c);
 true

6.9-38 SCIsEulerianManifold

Checks whether a given simplicial complex complex is a Eulerian manifold or not, i. e. checks if all vertex links of complex have the Euler characteristic of a sphere. In particular the function returns false in case complex has a non-empty boundary.

 gap> c:=SCBdSimplex(4);;
 gap> SCIsEulerianManifold(c);
 true
 gap> SCLib.SearchByName("Moebius");
 [ [ 1, "Moebius Strip" ] ]
 gap> moebius:=SCLib.Load(last[1][1]); # a moebius strip
 <SimplicialComplex: Moebius Strip | dim = 2 | n = 5>
 gap> SCIsEulerianManifold(moebius);
 false

6.9-39 SCIsFlag

Checks if complex is flag. A connected simplicial complex of dimension at least one is a flag complex if all cliques in its 1-skeleton span a face of the complex (cf. [Fro08]).

 gap> SCLib.SearchByName("RP^2");   
 [ [ 3, "RP^2 (VT)" ], [ 262, "RP^2xS^1" ] ]
 gap> rp2_6:=SCLib.Load(last[1][1]);;
 gap> SCIsFlag(rp2_6);
 false

6.9-40 SCIsHeegaardSplitting

Checks whether list defines a Heegaard splitting of c or not. See also SCHeegaardSplitting (6.9-30) and SCHeegaardSplittingSmallGenus (6.9-29) for functions to compute Heegaard splittings.

 gap> c:=SCSeriesBdHandleBody(3,9);;
 gap> list:=[[1..3],[4..9]];
 [ [ 1 .. 3 ], [ 4 .. 9 ] ]
 gap> SCIsHeegaardSplitting(c,list);
 false
 gap> splitting:=SCHeegaardSplitting(c);
 [ 1, [ [ 1, 2, 3, 6 ], [ 4, 5, 7, 8, 9 ] ], "arbitrary" ]
 gap> SCIsHeegaardSplitting(c,splitting[2]);                                         
 true

6.9-41 SCIsHomologySphere

Checks whether a simplicial complex complex is a homology sphere, i. e. has the homology of a sphere, or not.

 gap> c:=SC([[2,3],[3,4],[4,2]]);;
 gap> SCIsHomologySphere(c);
 true

6.9-42 SCIsInKd

Checks whether the simplicial complex complex that must be a combinatorial \(d\)-manifold is in the class \(\mathcal{K}^k(d)\), \(1\leq k\leq \lfloor\frac{d+1}{2}\rfloor\), of simplicial complexes that only have \(k\)-stacked spheres as vertex links, see [Eff11b]. Note that it is not checked whether complex is a combinatorial manifold -- if not, the algorithm will not succeed. Returns true / false upon success. If true is returned this means that complex is at least k-stacked and thus that the complex is in the class \(\mathcal{K}^k(d)\), i.e. all vertex links are i-stacked spheres. If false is returnd the complex cannot be k-stacked. In some cases the question can not be decided. In this case fail is returned.

Internally calls SCIsKStackedSphere (9.2-5) for all links. Please note that this is a radomized algorithm that may give an indefinite answer to the membership problem.

 gap> list:=SCLib.SearchByName("S^2~S^1"){[1..3]};;
 gap> c:=SCLib.Load(list[1][1]);;
 gap> c.AutomorphismGroup;
 Group([ (1,2,3,4,5,6,7,8,9), (1,3)(4,9)(5,8)(6,7) ])
 gap> SCIsInKd(c,1);
 #I  SCIsKStackedSphere: checking if complex is a 1-stacked sphere...
 #I  SCIsKStackedSphere: try 1/1
 #I  SCIsKStackedSphere: complex is a 1-stacked sphere.
 true

6.9-43 SCIsKNeighborly

 gap> SCLib.SearchByName("RP^2");   
 [ [ 3, "RP^2 (VT)" ], [ 262, "RP^2xS^1" ] ]
 gap> rp2_6:=SCLib.Load(last[1][1]);;
 gap> SCFVector(rp2_6);
 [ 6, 15, 10 ]
 gap> SCIsKNeighborly(rp2_6,2);
 true
 gap> SCIsKNeighborly(rp2_6,3);
 false

6.9-44 SCIsOrientable

Checks if a simplicial complex complex, satisfying the weak pseudomanifold property, is orientable.

 gap> c:=SCBdCrossPolytope(4);;
 gap> SCIsOrientable(c);
 true

6.9-45 SCIsPseudoManifold

Checks if a simplicial complex complex fulfills the weak pseudomanifold property, i. e. if every \(d-1\)-face of complex is contained in at most \(2\) facets.

 gap> c:=SC([[1,2,3],[1,2,4],[1,3,4],[2,3,4],[1,5,6],[1,5,7],[1,6,7],[5,6,7]]);;
 gap> SCIsPseudoManifold(c);
 true
 gap> c:=SC([[1,2],[2,3],[3,1],[1,4],[4,5],[5,1]]);;
 gap> SCIsPseudoManifold(c);
 false

6.9-46 SCIsPure

 gap> c:=SC([[1,2], [1,4], [2,4], [2,3,4]]);;
 gap> SCIsPure(c);
 false
 gap> c:=SC([[1,2], [1,4], [2,4]]);;
 gap> SCIsPure(c);
 true

6.9-47 SCIsShellable

The simplicial complex complex must be pure, strongly connected and must fulfill the weak pseudomanifold property with non-empty boundary (cf. SCBoundary (6.9-7)).

The function checks whether complex is shellable or not. An ordering \((F_1, F_2, \ldots , F_r)\) on the facet list of a simplicial complex is called a shelling if and only if \(F_i \cap (F_1 \cup \ldots \cup F_{i-1})\) is a pure simplicial complex of dimension \(d-1\) for all \(i = 1, \ldots , r\). A simplicial complex is called shellable, if at least one shelling exists.

 gap> c:=SCBdCrossPolytope(4);;       
 gap> c:=Difference(c,SC([[1,3,5,7]]));; # bounded version
 gap> SCIsShellable(c);
 true

6.9-48 SCIsStronglyConnected

Checks if a simplicial complex complex is strongly connected, i. e. if for any pair of facets \((\hat{\Delta},\tilde{\Delta})\) there exists a sequence of facets \(( \Delta_1 , \ldots , \Delta_k )\) with \(\Delta_1 = \hat{\Delta}\) and \(\Delta_k = \tilde{\Delta}\) and dim\((\Delta_i , \Delta_{i+1} ) = d - 1\) for all \(1 \leq i \leq k - 1\).

 gap> c:=SC([[1,2,3],[1,2,4],[1,3,4],[2,3,4], [1,5,6],[1,5,7],[1,6,7],[5,6,7]]);
 <SimplicialComplex: unnamed complex 27 | dim = 2 | n = 7>
 gap> SCIsConnected(c);        
 true
 gap> SCIsStronglyConnected(c);                                                
 false

6.9-49 SCMinimalNonFaces

Computes all missing proper faces of a simplicial complex complex by calling SCMinimalNonFacesEx (6.9-50). The simplices are returned in the original labeling of complex.

 gap> c:=SCFromFacets(["abc","abd"]);;
 gap> SCMinimalNonFaces(c);           
 [ [  ], [ "cd" ] ]

6.9-50 SCMinimalNonFacesEx

Computes all missing proper faces of a simplicial complex complex, i.e. the missing \((i+1)\)-tuples in the \(i\)-dimensional skeleton of a complex. A missing \(i+1\)-tuple is not listed if it only consists of missing \(i\)-tuples. Note that whenever complex is \(k\)-neighborly the first \(k+1\) entries are empty. The simplices are returned in the standard labeling \(1,\dots,n\), where \(n\) is the number of vertices of complex.

 gap> SCLib.SearchByName("T^2"){[1..10]}; 
 [ [ 4, "T^2 (VT)" ], [ 5, "T^2 (VT)" ], [ 9, "T^2 (VT)" ], [ 10, "T^2 (VT)" ],
   [ 17, "T^2 (VT)" ], [ 20, "(T^2)#2" ], [ 24, "(T^2)#3" ], 
   [ 41, "T^2 (VT)" ], [ 44, "(T^2)#4" ], [ 65, "T^2 (VT)" ] ]
 gap> torus:=SCLib.Load(last[1][1]);;
 gap> SCFVector(torus);
 [ 7, 21, 14 ]
 gap> SCMinimalNonFacesEx(torus);
 [ [  ], [  ] ]
 gap> SCMinimalNonFacesEx(SCBdCrossPolytope(4));
 [ [  ], [ [ 1, 2 ], [ 3, 4 ], [ 5, 6 ], [ 7, 8 ] ], [  ] ]

6.9-51 SCNeighborliness

Returns \(k\) if a simplicial complex complex is \(k\)-neighborly but not \((k+1)\)-neighborly. See also SCIsKNeighborly (6.9-43).

 gap> c:=SCBdSimplex(4);;
 gap> SCNeighborliness(c);
 4
 gap> c:=SCBdCrossPolytope(4);;
 gap> SCNeighborliness(c);
 1
 gap> SCLib.SearchByAttribute("F[3]=Binomial(F[1],3) and Dim=4");
 [ [ 16, "CP^2 (VT)" ], [ 520, "K3_16" ] ]
 gap> cp2:=SCLib.Load(last[1][1]);;
 gap> SCNeighborliness(cp2);
 3

6.9-52 SCNumFaces

If i is not specified the function computes the \(f\)-vector of the simplicial complex complex (cf. SCFVector (6.9-14)). If the optional integer parameter i is passed, only the i-th position of the \(f\)-vector of complex is calculated. In any case a memory-saving implicit algorithm is used that avoids calculating the face lattice of the complex.

 gap> complex:=SC([[1,2,3], [1,2,4], [1,3,4], [2,3,4]]);;
 gap> SCNumFaces(complex,1);
 6

6.9-53 SCOrientation

Returns: a list of the type \(\{ \pm 1 \}^{f_d}\) or [ ] upon success, fail otherwise.

This function tries to compute an orientation of a pure simplicial complex complex that fulfills the weak pseudomanifold property. If complex is orientable, an orientation in form of a list of orientations for the facets of complex is returned, otherwise an empty set.

 gap> c:=SCBdCrossPolytope(4);;
 gap> SCOrientation(c);
 [ 1, -1, -1, 1, -1, 1, 1, -1, -1, 1, 1, -1, 1, -1, -1, 1 ]

6.9-54 SCSkel

If k is an integer, the k-skeleton of a simplicial complex complex, i. e. all k-faces of complex, is computed. If k is a list, a list of all k[i]-faces of complex for each entry k[i] (which has to be an integer) is returned. The faces are returned in the original labeling.

 gap> SCLib.SearchByName("RP^2"); 
 [ [ 3, "RP^2 (VT)" ], [ 262, "RP^2xS^1" ] ]
 gap> rp2_6:=SCLib.Load(last[1][1]);;      
 gap> rp2_6:=SC(rp2_6.Facets+10);;
 gap> SCSkelEx(rp2_6,1);
 [ [ 1, 2 ], [ 1, 3 ], [ 1, 4 ], [ 1, 5 ], [ 1, 6 ], [ 2, 3 ], [ 2, 4 ], 
   [ 2, 5 ], [ 2, 6 ], [ 3, 4 ], [ 3, 5 ], [ 3, 6 ], [ 4, 5 ], [ 4, 6 ], 
   [ 5, 6 ] ]
 gap> SCSkel(rp2_6,1);  
 [ [ 11, 12 ], [ 11, 13 ], [ 11, 14 ], [ 11, 15 ], [ 11, 16 ], [ 12, 13 ], 
   [ 12, 14 ], [ 12, 15 ], [ 12, 16 ], [ 13, 14 ], [ 13, 15 ], [ 13, 16 ], 
   [ 14, 15 ], [ 14, 16 ], [ 15, 16 ] ]

6.9-55 SCSkelEx

 gap> SCLib.SearchByName("RP^2"); 
 [ [ 3, "RP^2 (VT)" ], [ 262, "RP^2xS^1" ] ]
 gap> rp2_6:=SCLib.Load(last[1][1]);;      
 gap> rp2_6:=SC(rp2_6.Facets+10);;
 gap> SCSkelEx(rp2_6,1);
 [ [ 1, 2 ], [ 1, 3 ], [ 1, 4 ], [ 1, 5 ], [ 1, 6 ], [ 2, 3 ], [ 2, 4 ], 
   [ 2, 5 ], [ 2, 6 ], [ 3, 4 ], [ 3, 5 ], [ 3, 6 ], [ 4, 5 ], [ 4, 6 ], 
   [ 5, 6 ] ]
 gap> SCSkel(rp2_6,1);  
 [ [ 11, 12 ], [ 11, 13 ], [ 11, 14 ], [ 11, 15 ], [ 11, 16 ], [ 12, 13 ], 
   [ 12, 14 ], [ 12, 15 ], [ 12, 16 ], [ 13, 14 ], [ 13, 15 ], [ 13, 16 ], 
   [ 14, 15 ], [ 14, 16 ], [ 15, 16 ] ]

6.9-56 SCSpanningTree

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Computes a spanning tree of a connected simplicial complex complex using a greedy algorithm.

 gap> c:=SC([["a","b","c"],["a","b","d"], ["a","c","d"], ["b","c","d"]]);;
 gap> s:=SCSpanningTree(c);
 <SimplicialComplex: spanning tree of unnamed complex 1 | dim = 1 | n = 4>
 gap> s.Facets;
 [ [ 1, 2 ], [ 1, 3 ], [ 1, 4 ] ]

6.10 Operations on simplicial complexes

The following functions perform operations on simplicial complexes. Most of them return simplicial complexes. Thus, this section is closely related to the Sections 6.6 ''Generate new complexes from old''. However, the data generated here is rather seen as an intrinsic attribute of the original complex and not as an independent complex.

6.10-1 SCAlexanderDual

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

The Alexander dual of a simplicial complex complex with set of vertices \(V\) is the simplicial complex where any subset of \(V\) spans a face if and only if its complement in \(V\) is a non-face of complex.

 gap> c:=SC([[1,2],[2,3],[3,4],[4,1]]);;
 gap> dual:=SCAlexanderDual(c);;
 gap> dual.F;
 [ 4, 2 ]
 gap> dual.IsConnected;
 false
 gap> dual.Facets;
 [ [ 1, 3 ], [ 2, 4 ] ]

6.10-2 SCClose

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Closes a simplicial complex complex by building a cone over its boundary. If apex is specified it is assigned to the apex of the cone and the original vertex labeling of complex is preserved, otherwise an arbitrary vertex label is chosen and complex is returned in the standard labeling.

 gap> s:=SCSimplex(5);;                                       
 gap> b:=SCSimplex(5);;
 gap> s:=SCClose(b,13);;
 gap> SCIsIsomorphic(s,SCBdSimplex(6));                       
 true

6.10-3 SCCone

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

If the second argument is passed every facet of the simplicial complex complex is united with apex. If not, an arbitrary vertex label \(v\) is used (which is not a vertex of complex). In the first case the vertex labeling remains unchanged. In the second case the function returns the new complex in the standard vertex labeling from \(1\) to \(n+1\) and the apex of the cone is \(n+1\).

If called with a facet list instead of a SCSimplicialComplex object and apex is not specified, internally falls back to the homology package [DHSW11], if available.

 gap> SCLib.SearchByName("RP^3");
 [ [ 45, "RP^3" ], [ 114, "RP^3=L(2,1) (VT)" ], [ 237, "(S^2xS^1)#RP^3" ], 
   [ 238, "(S^2~S^1)#RP^3" ], [ 263, "(S^2xS^1)#2#RP^3" ], 
   [ 264, "(S^2~S^1)#2#RP^3" ], [ 366, "RP^3#RP^3" ], 
   [ 382, "RP^3=L(2,1) (VT)" ], [ 399, "(S^2~S^1)#3#RP^3" ], 
   [ 402, "(S^2xS^1)#3#RP^3" ], [ 417, "RP^3=L(2,1) (VT)" ], 
   [ 502, "(S^2~S^1)#4#RP^3" ], [ 503, "(S^2xS^1)#4#RP^3" ], 
   [ 531, "(S^2xS^1)#5#RP^3" ], [ 532, "(S^2~S^1)#5#RP^3" ] ]
 gap> rp3:=SCLib.Load(last[1][1]);;
 gap> rp3.F;
 [ 11, 51, 80, 40 ]
 gap> cone:=SCCone(rp3);;
 gap> cone.F;
 [ 12, 62, 131, 120, 40 ]

 gap> s:=SCBdSimplex(4)+12;;
 gap> s.Facets;             
 [ [ 13, 14, 15, 16 ], [ 13, 14, 15, 17 ], [ 13, 14, 16, 17 ], 
   [ 13, 15, 16, 17 ], [ 14, 15, 16, 17 ] ]
 gap> cc:=SCCone(s,13);;    
 gap> cc:=SCCone(s,12);;
 gap> cc.Facets;
 [ [ 12, 13, 14, 15, 16 ], [ 12, 13, 14, 15, 17 ], [ 12, 13, 14, 16, 17 ], 
   [ 12, 13, 15, 16, 17 ], [ 12, 14, 15, 16, 17 ] ]

6.10-4 SCDeletedJoin

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Calculates the simplicial deleted join of the simplicial complexes complex1 and complex2. If called with a facet list instead of a SCSimplicialComplex object, the function internally falls back to the homology package [DHSW11], if available.

 gap> deljoin:=SCDeletedJoin(SCBdSimplex(3),SCBdSimplex(3));
 <SimplicialComplex: S^2_4 deljoin S^2_4 | dim = 3 | n = 8>
 gap> bddeljoin:=SCBoundary(deljoin);;
 gap> bddeljoin.Homology;
 [ [ 1, [  ] ], [ 0, [  ] ], [ 2, [  ] ] ]
 gap> deljoin.Facets;
 [ [ [ 1, 1 ], [ 2, 1 ], [ 3, 1 ], [ 4, 2 ] ], 
   [ [ 1, 1 ], [ 2, 1 ], [ 3, 2 ], [ 4, 1 ] ], 
   [ [ 1, 1 ], [ 2, 1 ], [ 3, 2 ], [ 4, 2 ] ], 
   [ [ 1, 1 ], [ 2, 2 ], [ 3, 1 ], [ 4, 1 ] ], 
   [ [ 1, 1 ], [ 2, 2 ], [ 3, 1 ], [ 4, 2 ] ], 
   [ [ 1, 1 ], [ 2, 2 ], [ 3, 2 ], [ 4, 1 ] ], 
   [ [ 1, 1 ], [ 2, 2 ], [ 3, 2 ], [ 4, 2 ] ], 
   [ [ 1, 2 ], [ 2, 1 ], [ 3, 1 ], [ 4, 1 ] ], 
   [ [ 1, 2 ], [ 2, 1 ], [ 3, 1 ], [ 4, 2 ] ], 
   [ [ 1, 2 ], [ 2, 1 ], [ 3, 2 ], [ 4, 1 ] ], 
   [ [ 1, 2 ], [ 2, 1 ], [ 3, 2 ], [ 4, 2 ] ], 
   [ [ 1, 2 ], [ 2, 2 ], [ 3, 1 ], [ 4, 1 ] ], 
   [ [ 1, 2 ], [ 2, 2 ], [ 3, 1 ], [ 4, 2 ] ], 
   [ [ 1, 2 ], [ 2, 2 ], [ 3, 2 ], [ 4, 1 ] ] ]

6.10-5 SCDifference

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Forms the ``difference'' of two simplicial complexes complex1 and complex2 as the simplicial complex formed by the difference of the face lattices of complex1 minus complex2. The two arguments are not altered. Note: for the difference process the vertex labelings of the complexes are taken into account, see also Operation Difference (SCSimplicialComplex, SCSimplicialComplex) (5.3-2).

 gap> c:=SCBdSimplex(3);;
 gap> d:=SC([[1,2,3]]);;
 gap> disc:=SCDifference(c,d);;
 gap> disc.Facets;
 [ [ 1, 2, 4 ], [ 1, 3, 4 ], [ 2, 3, 4 ] ]
 gap> empty:=SCDifference(d,c);;
 gap> empty.Dim;
 -1

6.10-6 SCFillSphere

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise .

Fills the given simplicial sphere complex by forming the suspension of the anti star of vertex over vertex. This is a triangulated \((d+1)\)-ball with the boundary complex, see [BD08]. If the optional argument vertex is not supplied, the first vertex of complex is chosen.

Note that it is not checked whether complex really is a simplicial sphere -- this has to be done by the user!

 gap> SCLib.SearchByName("S^4");
 [ [ 36, "S^4 (VT)" ], [ 37, "S^4 (VT)" ], [ 38, "S^4 (VT)" ], 
   [ 117, "S^4 (VT)" ], [ 203, "S^4~S^1 (VT)" ], [ 282, "S^4xS^1 (VT)" ], 
   [ 329, "S^4xS^1 (VT)" ], [ 330, "S^4~S^1 (VT)" ], [ 331, "S^4xS^1 (VT)" ], 
   [ 332, "S^4~S^1 (VT)" ], [ 395, "S^4~S^1 (VT)" ], [ 396, "S^4 (VT)" ], 
   [ 450, "S^4 (VT)" ], [ 451, "S^4~S^1 (VT)" ], [ 452, "S^4~S^1 (VT)" ], 
   [ 453, "S^4~S^1 (VT)" ], [ 454, "S^4~S^1 (VT)" ], [ 455, "S^4~S^1 (VT)" ], 
   [ 458, "S^4~S^1 (VT)" ], [ 459, "S^4~S^1 (VT)" ], [ 460, "S^4~S^1 (VT)" ] ]
 gap> s:=SCLib.Load(last[1][1]);;
 gap> filled:=SCFillSphere(s);
 <SimplicialComplex: FilledSphere(S^4 (VT)) at vertex [ 1 ] | dim = 5 | n = 10>
 gap> SCHomology(filled);
 [ [ 0, [  ] ], [ 0, [  ] ], [ 0, [  ] ], [ 0, [  ] ], [ 0, [  ] ], 
   [ 0, [  ] ] ]
 gap> SCCollapseGreedy(filled);
 <SimplicialComplex: collapsed version of FilledSphere(S^4 (VT)) at vertex [ 1 \
 ] | dim = 0 | n = 1>
 gap> bd:=SCBoundary(filled);;
 gap> bd=s;
 true

6.10-7 SCHandleAddition

Returns a simplicial complex obtained by identifying the vertices of facet f1 with the ones from facet f2 in complex. A combinatorial handle addition is possible, whenever we have d\((v,w) \geq 3\) for any two vertices \(v \in \)f1 and \(w \in \)f2, where d\((\cdot,\cdot)\) is the length of the shortest path from \(v\) to \(w\). This condition is not checked by this algorithm. See [BD11] for further information.

 gap> c:=SC([[1,2,4],[2,4,5],[2,3,5],[3,5,6],[1,3,6],[1,4,6]]);;
 gap> c:=SCUnion(c,SCUnion(SCCopy(c)+3,SCCopy(c)+6));;
 gap> c:=SCUnion(c,SC([[1,2,3],[10,11,12]]));;
 gap> c.Facets;
 [ [ 1, 2, 3 ], [ 1, 2, 4 ], [ 1, 3, 6 ], [ 1, 4, 6 ], [ 2, 3, 5 ], 
   [ 2, 4, 5 ], [ 3, 5, 6 ], [ 4, 5, 7 ], [ 4, 6, 9 ], [ 4, 7, 9 ], 
   [ 5, 6, 8 ], [ 5, 7, 8 ], [ 6, 8, 9 ], [ 7, 8, 10 ], [ 7, 9, 12 ], 
   [ 7, 10, 12 ], [ 8, 9, 11 ], [ 8, 10, 11 ], [ 9, 11, 12 ], [ 10, 11, 12 ] ]
 gap> c.Homology;
 [ [ 0, [  ] ], [ 0, [  ] ], [ 1, [  ] ] ]
 gap> torus:=SCHandleAddition(c,[1,2,3],[10,11,12]);;
 gap> torus.Homology;
 [ [ 0, [  ] ], [ 2, [  ] ], [ 1, [  ] ] ]
 gap> ism:=SCIsManifold(torus);;
 gap> ism;
 true

6.10-8 SCIntersection

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Forms the ``intersection'' of two simplicial complexes complex1 and complex2 as the simplicial complex formed by the intersection of the face lattices of complex1 and complex2. The two arguments are not altered. Note: for the intersection process the vertex labelings of the complexes are taken into account. See also Operation Intersection (SCSimplicialComplex, SCSimplicialComplex) (5.3-3).

 gap> c:=SCBdSimplex(3);;        
 gap> d:=SCBdSimplex(3)+1;;      
 gap> d.Facets;
 [ [ 2, 3, 4 ], [ 2, 3, 5 ], [ 2, 4, 5 ], [ 3, 4, 5 ] ]
 gap> c:=SCBdSimplex(3);;  
 gap> d:=SCBdSimplex(3);;  
 gap> d:=SCMove(d,[[1,2,3],[]])+1;;
 gap> s1:=SCIntersection(c,d);;
 gap> s1.Facets;               
 [ [ 2, 3 ], [ 2, 4 ], [ 3, 4 ] ]

6.10-9 SCIsIsomorphic

The function returns true, if the simplicial complexes complex1 and complex2 are combinatorially isomorphic, false if not.

 gap> c1:=SC([[11,12,13],[11,12,14],[11,13,14],[12,13,14]]);;
 gap> c2:=SCBdSimplex(3);;
 gap> SCIsIsomorphic(c1,c2);
 true
 gap> c3:=SCBdCrossPolytope(3);;
 gap> SCIsIsomorphic(c1,c3);
 false

6.10-10 SCIsSubcomplex

Returns true if the simplicial complex sc2 is a sub-complex of simplicial complex sc1, false otherwise. If dim(sc2) \(\leq\) dim(sc1) the facets of sc2 are compared with the dim(sc2)-skeleton of sc1. Only works for pure simplicial complexes. Note: for the intersection process the vertex labelings of the complexes are taken into account.

 gap> SCLib.SearchByAttribute("F[1]=10"){[1..10]};
 [ [ 17, "T^2 (VT)" ], [ 18, "K^2 (VT)" ], [ 19, "S^3 (VT)" ], 
   [ 20, "(T^2)#2" ], [ 21, "S^3 (VT)" ], [ 22, "S^3 (VT)" ], 
   [ 23, "S^2xS^1 (VT)" ], [ 24, "(T^2)#3" ], [ 25, "(P^2)#7 (VT)" ], 
   [ 26, "S^2~S^1 (VT)" ] ]
 gap> k:=SCLib.Load(last[1][1]);;
 gap> c:=SCBdSimplex(9);;
 gap> k.F;
 [ 10, 30, 20 ]
 gap> c.F;
 [ 10, 45, 120, 210, 252, 210, 120, 45, 10 ]
 gap> SCIsSubcomplex(c,k);
 true
 gap> SCIsSubcomplex(k,c);
 false

6.10-11 SCIsomorphism

Returns: a list of pairs of vertex labels or false upon success, fail otherwise.

 gap> c1:=SC([[11,12,13],[11,12,14],[11,13,14],[12,13,14]]);;
 gap> c2:=SCBdSimplex(3);;
 gap> SCIsomorphism(c1,c2);
 [ [ 11, 1 ], [ 12, 2 ], [ 13, 3 ], [ 14, 4 ] ]
 gap> SCIsomorphismEx(c1,c2);
 [ [ [ 1, 1 ], [ 2, 2 ], [ 3, 3 ], [ 4, 4 ] ] ]

6.10-12 SCIsomorphismEx

Returns: a list of pairs of vertex labels or false upon success, fail otherwise.

Returns an isomorphism of simplicial complex complex1 to simplicial complex complex2 in the standard labeling if they are combinatorially isomorphic, false otherwise. If the \(f\)-vector and the Altshuler-Steinberg determinant of complex1 and complex2 are equal, the internal function SCIntFunc.SCComputeIsomorphismsEx(complex1,complex2,true) is called.

 gap> c1:=SC([[11,12,13],[11,12,14],[11,13,14],[12,13,14]]);;
 gap> c2:=SCBdSimplex(3);;
 gap> SCIsomorphism(c1,c2);
 [ [ 11, 1 ], [ 12, 2 ], [ 13, 3 ], [ 14, 4 ] ]
 gap> SCIsomorphismEx(c1,c2);
 [ [ [ 1, 1 ], [ 2, 2 ], [ 3, 3 ], [ 4, 4 ] ] ]

6.10-13 SCJoin

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Calculates the simplicial join of the simplicial complexes complex1 and complex2. If facet lists instead of SCSimplicialComplex objects are passed as arguments, the function internally falls back to the homology package [DHSW11], if available. Note that the vertex labelings of the complexes passed as arguments are not propagated to the new complex.

 gap> sphere:=SCJoin(SCBdSimplex(2),SCBdSimplex(2));
 <SimplicialComplex: S^1_3 join S^1_3 | dim = 3 | n = 6>
 gap> SCHasBoundary(sphere);
 false
 gap> sphere.Facets;
 [ [ [ 1, 1 ], [ 1, 2 ], [ 2, 1 ], [ 2, 2 ] ], 
   [ [ 1, 1 ], [ 1, 2 ], [ 2, 1 ], [ 2, 3 ] ], 
   [ [ 1, 1 ], [ 1, 2 ], [ 2, 2 ], [ 2, 3 ] ], 
   [ [ 1, 1 ], [ 1, 3 ], [ 2, 1 ], [ 2, 2 ] ], 
   [ [ 1, 1 ], [ 1, 3 ], [ 2, 1 ], [ 2, 3 ] ], 
   [ [ 1, 1 ], [ 1, 3 ], [ 2, 2 ], [ 2, 3 ] ], 
   [ [ 1, 2 ], [ 1, 3 ], [ 2, 1 ], [ 2, 2 ] ], 
   [ [ 1, 2 ], [ 1, 3 ], [ 2, 1 ], [ 2, 3 ] ], 
   [ [ 1, 2 ], [ 1, 3 ], [ 2, 2 ], [ 2, 3 ] ] ]
 gap> sphere.Homology;
 [ [ 0, [  ] ], [ 0, [  ] ], [ 0, [  ] ], [ 1, [  ] ] ]

 gap> ball:=SCJoin(SC([[1]]),SCBdSimplex(2));
 <SimplicialComplex: unnamed complex 4 join S^1_3 | dim = 2 | n = 4>
 gap> ball.Homology;
 [ [ 0, [  ] ], [ 0, [  ] ], [ 0, [  ] ] ]
 gap> ball.Facets;
 [ [ [ 1, 1 ], [ 2, 1 ], [ 2, 2 ] ], [ [ 1, 1 ], [ 2, 1 ], [ 2, 3 ] ], 
   [ [ 1, 1 ], [ 2, 2 ], [ 2, 3 ] ] ]

6.10-14 SCNeighbors

In a simplicial complex complex all neighbors of the k-face face, i. e. all k-faces distinct from face intersecting with face in a common \((k-1)\)-face, are returned in the original labeling.

 gap> c:=SCFromFacets(Combinations(["a","b","c"],2));
 <SimplicialComplex: unnamed complex 22 | dim = 1 | n = 3>
 gap> SCNeighbors(c,["a","d"]);
 [ [ "a", "b" ], [ "a", "c" ] ]

6.10-15 SCNeighborsEx

 gap> c:=SCFromFacets(Combinations(["a","b","c"],2));
 <SimplicialComplex: unnamed complex 21 | dim = 1 | n = 3>
 gap> SCLabels(c);
 [ "a", "b", "c" ]
 gap> SCNeighborsEx(c,[1,2]);
 [ [ 1, 3 ], [ 2, 3 ] ]

6.10-16 SCShelling

The simplicial complex complex must be pure, strongly connected and must fulfill the weak pseudomanifold property with non-empty boundary (cf. SCBoundary (6.9-7)).

An ordering \((F_1, F_2, \ldots , F_r)\) on the facet list of a simplicial complex is a shelling if and only if \(F_i \cap (F_1 \cup \ldots \cup F_{i-1})\) is a pure simplicial complex of dimension \(d-1\) for all \(i = 1, \ldots , r\).

The function checks whether complex is shellable or not. In the first case a permuted version of the facet list of complex is returned encoding a shelling of complex, otherwise false is returned.

Internally calls SCShellingExt (6.10-17)(complex,false,[]);. To learn more about shellings see [Zie95], [Pac87].

 gap> c:=SC([[1,2,3],[1,2,4],[1,3,4]]);;
 gap> SCShelling(c);
 [ [ [ 1, 2, 3 ], [ 1, 2, 4 ], [ 1, 3, 4 ] ] ]

6.10-17 SCShellingExt

Returns: a list of facet lists (if checkvector = []) or true or false (if checkvector is not empty), fail otherwise.

The simplicial complex complex must be pure of dimension \(d\), strongly connected and must fulfill the weak pseudomanifold property with non-empty boundary (cf. SCBoundary (6.9-7)).

If all is set to true all possible shellings of complex are computed. If all is set to false, at most one shelling is computed.

Every shelling is represented as a permuted version of the facet list of complex. The list checkvector encodes a shelling in a shorter form. It only contains the indices of the facets. If an order of indices is assigned to checkvector the function tests whether it is a valid shelling or not.

 gap> c:=SCBdSimplex(4);;
 gap> c:=SCDifference(c,SC([c.Facets[1]]));; # bounded version
 gap> all:=SCShellingExt(c,true,[]);;
 gap> Size(all);                                  
 24
 gap> all[1];
 [ [ 1, 2, 3, 5 ], [ 1, 2, 4, 5 ], [ 1, 3, 4, 5 ], [ 2, 3, 4, 5 ] ]
 gap> all:=SCShellingExt(c,false,[]);
 [ [ [ 1, 2, 3, 5 ], [ 1, 2, 4, 5 ], [ 1, 3, 4, 5 ], [ 2, 3, 4, 5 ] ] ]
 gap> all:=SCShellingExt(c,true,[1..4]);
 true

6.10-18 SCShellings

The simplicial complex complex must be pure, strongly connected and must fulfill the weak pseudomanifold property with non-empty boundary (cf. SCBoundary (6.9-7)).

The function checks whether complex is shellable or not. In the first case a list of permuted facet lists of complex is returned containing all possible shellings of complex, otherwise false is returned.

Internally calls SCShellingExt (6.10-17)(complex,true,[]);. To learn more about shellings see [Zie95], [Pac87].

 gap> c:=SC([[1,2,3],[1,2,4],[1,3,4]]);;
 gap> SCShellings(c);
 [ [ [ 1, 2, 3 ], [ 1, 2, 4 ], [ 1, 3, 4 ] ], 
   [ [ 1, 2, 3 ], [ 1, 3, 4 ], [ 1, 2, 4 ] ], 
   [ [ 1, 2, 4 ], [ 1, 2, 3 ], [ 1, 3, 4 ] ], 
   [ [ 1, 3, 4 ], [ 1, 2, 3 ], [ 1, 2, 4 ] ], 
   [ [ 1, 2, 4 ], [ 1, 3, 4 ], [ 1, 2, 3 ] ], 
   [ [ 1, 3, 4 ], [ 1, 2, 4 ], [ 1, 2, 3 ] ] ]

6.10-19 SCSpan

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Computes the reduced face lattice of all faces of a simplicial complex complex that are spanned by subset, a subset of the set of vertices of complex.

 gap> c:=SCBdCrossPolytope(4);;
 gap> SCVertices(c);
 [ 1 .. 8 ]
 gap> span:=SCSpan(c,[1,2,3,4]);
 <SimplicialComplex: span([ 1, 2, 3, 4 ]) in Bd(\beta^4) | dim = 1 | n = 4>
 gap> span.Facets;
 [ [ 1, 3 ], [ 1, 4 ], [ 2, 3 ], [ 2, 4 ] ]

 gap> c:=SC([[1,2],[1,4,5],[2,3,4]]);;
 gap> span:=SCSpan(c,[2,3,5]);
 <SimplicialComplex: span([ 2, 3, 5 ]) in unnamed complex 121 | dim = 1 | n = 3\
 >
 gap> SCFacets(span);
 [ [ 2, 3 ], [ 5 ] ]

6.10-20 SCSuspension

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Calculates the simplicial suspension of the simplicial complex complex. Internally falls back to the homology package [DHSW11] (if available) if a facet list is passed as argument. Note that the vertex labelings of the complexes passed as arguments are not propagated to the new complex.

 gap> SCLib.SearchByName("Poincare");
 [ [ 497, "Poincare_sphere" ] ]
 gap> phs:=SCLib.Load(last[1][1]);
 <SimplicialComplex: Poincare_sphere | dim = 3 | n = 16>
 gap> susp:=SCSuspension(phs);;
 gap> edwardsSphere:=SCSuspension(susp);
 <SimplicialComplex: susp of susp of Poincare_sphere | dim = 5 | n = 20>

6.10-21 SCUnion

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Forms the union of two simplicial complexes complex1 and complex2 as the simplicial complex formed by the union of their facets sets. The two arguments are not altered. Note: for the union process the vertex labelings of the complexes are taken into account, see also Operation Union (SCSimplicialComplex, SCSimplicialComplex) (5.3-1). Facets occurring in both arguments are treated as one facet in the new complex.

 gap> c:=SCUnion(SCBdSimplex(3),SCBdSimplex(3)+3); #a wedge of two 2-spheres
 <SimplicialComplex: S^2_4 cup S^2_4 | dim = 2 | n = 7>

6.10-22 SCVertexIdentification

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Identifies vertex v1 with vertex v2 in a simplicial complex complex and returns the result as a new object. A vertex identification of v1 and v2 is possible whenever d(v1,v2) \(\geq 3\). This is not checked by this algorithm.

 gap> c:=SC([[1,2],[2,3],[3,4]]);;
 gap> circle:=SCVertexIdentification(c,[1],[4]);;
 gap> circle.Facets;
 [ [ 1, 2 ], [ 1, 3 ], [ 2, 3 ] ]
 gap> circle.Homology;
 [ [ 0, [  ] ], [ 1, [  ] ] ]

6.10-23 SCWedge

Returns: simplicial complex of type SCSimplicialComplex upon success, fail otherwise.

Calculates the wedge product of the complexes supplied as arguments. Note that the vertex labelings of the complexes passed as arguments are not propagated to the new complex.

6 Functions and operations for SCSimplicialComplex

6.1 Creating an SCSimplicialComplex object from a facet list

6.1-1 SCFromFacets

6.1-2 SC

6.1-3 SCFromDifferenceCycles

6.1-4 SCFromGenerators

6.2 Isomorphism signatures

6.2-1 SCExportToString

6.2-2 SCExportIsoSig

6.2-3 SCFromIsoSig

6.3 Generating some standard triangulations

6.3-1 SCBdCyclicPolytope

6.3-2 SCBdSimplex

6.3-3 SCEmpty

6.3-4 SCSimplex

6.3-5 SCSeriesTorus

6.3-6 SCSurface

6.3-7 SCFVectorBdCrossPolytope

6.3-8 SCFVectorBdCyclicPolytope

6.3-9 SCFVectorBdSimplex

6.4 Generating infinite series of transitive triangulations

6.4-1 SCSeriesAGL

6.4-2 SCSeriesBrehmKuehnelTorus

6.4-3 SCSeriesBdHandleBody

6.4-4 SCSeriesBid

6.4-5 SCSeriesC2n

6.4-6 SCSeriesConnectedSum

6.4-7 SCSeriesCSTSurface

6.4-8 SCSeriesD2n

6.4-9 SCSeriesHandleBody

6.4-10 SCSeriesHomologySphere

6.4-11 SCSeriesK

6.4-12 SCSeriesKu

6.4-13 SCSeriesL

6.4-14 SCSeriesLe

6.4-15 SCSeriesLensSpace

6.4-16 SCSeriesPrimeTorus

6.4-17 SCSeriesSeifertFibredSpace

6.4-18 SCSeriesS2xS2

6.5 A census of regular and chiral maps

6.5-1 SCChiralMap

6.5-2 SCChiralMaps

6.5-3 SCChiralTori

6.5-4 SCNrChiralTori

6.5-5 SCNrRegularTorus

6.5-6 SCRegularMap

6.5-7 SCRegularMaps

6.5-8 SCRegularTorus

6.5-9 SCSeriesSymmetricTorus

6.6 Generating new complexes from old

6.6-1 SCCartesianPower

6.6-2 SCCartesianProduct

6.6-3 SCConnectedComponents

6.6-4 SCConnectedProduct

6.6-5 SCConnectedSum

6.6-6 SCConnectedSumMinus

6.6-7 SCDifferenceCycleCompress

6.6-8 SCDifferenceCycleExpand

6.6-9 SCStronglyConnectedComponents

6.7 Simplicial complexes from transitive permutation groups

6.7-1 SCsFromGroupExt

6.7-2 SCsFromGroupByTransitivity

6.8 The classification of cyclic combinatorial 3-manifolds

6.8-1 SCNrCyclic3Mflds

6.8-2 SCCyclic3MfldTopTypes

6.8-3 SCCyclic3Mfld

6.8-4 SCCyclic3MfldByType

6.8-5 SCCyclic3MfldListOfGivenType

6.9 Computing properties of simplicial complexes

6.9-1 SCAltshulerSteinberg

6.9-2 SCAutomorphismGroup

6.9-3 SCAutomorphismGroupInternal

6.9-4 SCAutomorphismGroupSize

6.9-5 SCAutomorphismGroupStructure

6.9-6 SCAutomorphismGroupTransitivity

6.9-7 SCBoundary

6.9-8 SCDehnSommervilleCheck

6.9-9 SCDehnSommervilleMatrix

6.9-10 SCDifferenceCycles

6.9-11 SCDim

6 Functions and operations for `SCSimplicialComplex`

6.1 Creating an `SCSimplicialComplex` object from a facet list