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

Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 Bib Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

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.9-12 SCDualGraph
6.9-13 SCEulerCharacteristic
6.9-14 SCFVector
6.9-15 SCFaceLattice
6.9-16 SCFaceLatticeEx
6.9-17 SCFaces
6.9-18 SCFacesEx
6.9-19 SCFacets
6.9-20 SCFacetsEx
6.9-21 SCFpBettiNumbers
6.9-22 SCFundamentalGroup
6.9-23 SCGVector
6.9-24 SCGenerators
6.9-25 SCGeneratorsEx
6.9-26 SCHVector
6.9-27 SCHasBoundary
6.9-28 SCHasInterior
6.9-29 SCHeegaardSplittingSmallGenus
6.9-30 SCHeegaardSplitting
6.9-31 SCHomologyClassic
6.9-32 SCIncidences
6.9-33 SCIncidencesEx
6.9-34 SCInterior
6.9-35 SCIsCentrallySymmetric
6.9-36 SCIsConnected
6.9-37 SCIsEmpty
6.9-38 SCIsEulerianManifold
6.9-39 SCIsFlag
6.9-40 SCIsHeegaardSplitting
6.9-41 SCIsHomologySphere
6.9-42 SCIsInKd
6.9-43 SCIsKNeighborly
6.9-44 SCIsOrientable
6.9-45 SCIsPseudoManifold
6.9-46 SCIsPure
6.9-47 SCIsShellable
6.9-48 SCIsStronglyConnected
6.9-49 SCMinimalNonFaces
6.9-50 SCMinimalNonFacesEx
6.9-51 SCNeighborliness
6.9-52 SCNumFaces
6.9-53 SCOrientation
6.9-54 SCSkel
6.9-55 SCSkelEx
6.9-56 SCSpanningTree
6.10 Operations on simplicial complexes
6.10-1 SCAlexanderDual
6.10-2 SCClose
6.10-3 SCCone
6.10-4 SCDeletedJoin
6.10-5 SCDifference
6.10-6 SCFillSphere
6.10-7 SCHandleAddition
6.10-8 SCIntersection
6.10-9 SCIsIsomorphic
6.10-10 SCIsSubcomplex
6.10-11 SCIsomorphism
6.10-12 SCIsomorphismEx
6.10-13 SCJoin
6.10-14 SCNeighbors
6.10-15 SCNeighborsEx
6.10-16 SCShelling
6.10-17 SCShellingExt
6.10-18 SCShellings
6.10-19 SCSpan
6.10-20 SCSuspension
6.10-21 SCUnion
6.10-22 SCVertexIdentification
6.10-23 SCWedge

### 6 Functions and operations for `SCSimplicialComplex`

#### 6.1 Creating an `SCSimplicialComplex` object from a facet list

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

`‣ SCFromFacets`( facets ) | ( method )

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

      Properties known: Dim, FacetsEx, Name, Vertices.

      Name="unnamed complex 9"
      Dim=2

     /SimplicialComplex]
     gap> c:=SCFromFacets([["a","b","c"], ["a","b",1], ["a","c",1], ["b","c",1]]);
     [SimplicialComplex

      Properties known: Dim, FacetsEx, Name, Vertices.

      Name="unnamed complex 10"
      Dim=2

     /SimplicialComplex]

##### 6.1-2 SC

`‣ SC`( facets ) | ( method )

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

      Properties known: Dim, FacetsEx, Name, Vertices.

      Name="unnamed complex 11"
      Dim=4

     /SimplicialComplex]

##### 6.1-3 SCFromDifferenceCycles

`‣ SCFromDifferenceCycles`( diffcycles ) | ( method )

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 : ... : d_n+1) induces a simplex ∆ = ( v_1 , ... , v_n+1 ) by v_1 = d_1, v_i = v_i-1 + d_i and a cyclic group action by Z_σ where σ = ∑ d_i is the modulus of D. The function returns the Z_σ-orbit of ∆.

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

`‣ SCFromGenerators`( group, generators ) | ( method )

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

      Properties known: Dim, FacetsEx, Name, Vertices.

      Name="complex from generators under unknown group"
      Dim=2

     /SimplicialComplex]
     gap> SCLib.DetermineTopologicalType(c);
     [SimplicialComplex

      Properties known: BoundaryEx, Dim, FacetsEx, HasBoundary,
                        IsPseudoManifold, IsPure, Name, SkelExs[],
                        Vertices.

      Name="complex from generators under unknown group"
      Dim=2
      HasBoundary=false
      IsPseudoManifold=true
      IsPure=true

     /SimplicialComplex]

#### 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 ∆ ∈ P and a numbering 1, 2, ... , d+1 of the vertices of ∆ (which in turn determines a numbering of the co-dimension one faces of ∆ 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 ∆ and label the opposite vertex of the unique other facet δ meeting face 1 by d+2, go on with face 2 of ∆ and so on. After finishing with the first facet we now have a numbering on δ, repeat the procedure for δ, 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

`‣ SCExportToString`( c ) | ( function )

Returns: string upon success, `fail` otherwise.

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"
     0
     gap> s:=SCExportIsoSig(c); time;
     "deefgaf.hbi.gbh.eaiaeaicg.g.ibf.heg.iff.hggcfffgg"
     20

##### 6.2-2 SCExportIsoSig

`‣ SCExportIsoSig`( c ) | ( method )

Returns: string upon success, `fail` otherwise.

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

`‣ SCFromIsoSig`( str ) | ( method )

Returns: a SCSimplicialComplex object upon success, `fail` otherwise.

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

          Properties known: Dim, ExportIsoSig, FacetsEx, Name, Vertices.

          Name="unnamed complex 7"
          Dim=3

         /SimplicialComplex] ]
     gap> cc[1].F;
     [ 5, 10, 10, 5 ]

#### 6.3 Generating some standard triangulations

##### 6.3-1 SCBdCyclicPolytope

`‣ SCBdCyclicPolytope`( d, n ) | ( function )

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≥ d+2.

     gap> SCBdCyclicPolytope(3,8);
     [SimplicialComplex

      Properties known: Dim, EulerCharacteristic, FacetsEx, HasBoundary,
                        Homology, IsConnected, IsStronglyConnected, Name,
                        NumFaces[], TopologicalType, Vertices.

      Name="Bd(C_3(8))"
      Dim=2
      EulerCharacteristic=2
      HasBoundary=false
      Homology=[ [ 0, [ ] ], [ 0, [ ] ], [ 1, [ ] ] ]
      IsConnected=true
      IsStronglyConnected=true
      TopologicalType="S^2"

     /SimplicialComplex]

##### 6.3-2 SCBdSimplex

`‣ SCBdSimplex`( d ) | ( function )

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

Generates the boundary of the d-simplex ∆^d, a combinatorial d-1-sphere.

     gap> SCBdSimplex(5);
     [SimplicialComplex

      Properties known: AutomorphismGroup, AutomorphismGroupSize,
                        AutomorphismGroupStructure,
                        AutomorphismGroupTransitivity, Dim,
                        EulerCharacteristic, FacetsEx, GeneratorsEx,
                        HasBoundary, Homology, IsConnected,
                        IsStronglyConnected, Name, NumFaces[],
                        TopologicalType, Vertices.

      Name="S^4_6"
      Dim=4
      AutomorphismGroupSize=720
      AutomorphismGroupStructure="S6"
      AutomorphismGroupTransitivity=6
      EulerCharacteristic=2
      HasBoundary=false
      Homology=[ [ 0, [ ] ], [ 0, [ ] ], [ 0, [ ] ], [ 0, [ ] ], [ 1, [ ] ] ]
      IsConnected=true
      IsStronglyConnected=true
      TopologicalType="S^4"

     /SimplicialComplex]

##### 6.3-3 SCEmpty

`‣ SCEmpty`( ) | ( function )

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

      Properties known: Dim, FacetsEx, Name, Vertices.

      Name="empty complex"
      Dim=-1

     /SimplicialComplex]

##### 6.3-4 SCSimplex

`‣ SCSimplex`( d ) | ( function )

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

Generates the d-simplex.

     gap> SCSimplex(3);
     [SimplicialComplex

      Properties known: Dim, EulerCharacteristic, FacetsEx, Name,
                        NumFaces[], TopologicalType, Vertices.

      Name="B^3_4"
      Dim=3
      EulerCharacteristic=1
      TopologicalType="B^3"

     /SimplicialComplex]

##### 6.3-5 SCSeriesTorus

`‣ SCSeriesTorus`( d ) | ( function )

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

Generates the d-torus described in [K{\86].

     gap> t4:=SCSeriesTorus(4);
     [SimplicialComplex

      Properties known: DifferenceCycles, Dim, FacetsEx, Name,
                        TopologicalType, Vertices.

      Name="4-torus T^4"
      Dim=4
      TopologicalType="T^4"

     /SimplicialComplex]
     gap> t4.Homology;
     [ [ 0, [  ] ], [ 4, [  ] ], [ 6, [  ] ], [ 4, [  ] ], [ 1, [  ] ] ]

##### 6.3-6 SCSurface

`‣ SCSurface`( g, orient ) | ( function )

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(operatornamelog (g)) memory. If orient is `true` and g≥ 50 or if orient is `false` and g≥ 100 only the difference cycles of the surface are returned

     gap> c:=SCSurface(23,true);
     [SimplicialComplex

      Properties known: DifferenceCycles, Dim, FacetsEx, Name,
                        TopologicalType, Vertices.

      Name="S_23^or"
      Dim=2
      TopologicalType="(T^2)^#23"

     /SimplicialComplex]
     gap> c.Homology;
     [ [ 0, [  ] ], [ 46, [  ] ], [ 1, [  ] ] ]
     gap> c.TopologicalType;
     "(T^2)^#23"
     gap> c:=SCSurface(23,false);
     [SimplicialComplex

      Properties known: DifferenceCycles, Dim, FacetsEx, Name,
                        TopologicalType, Vertices.

      Name="S_23^non"
      Dim=2
      TopologicalType="(RP^2)^#23"

     /SimplicialComplex]
     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

      Properties known: DifferenceCycles, Dim, FacetsEx, Name, Vertices.

      Name="complex from diffcycles [ [ 1, 1, 1374 ], [ 2, 343, 1031 ], [ 343, 345,\
      688 ] ]"
      Dim=2

     /SimplicialComplex]
     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

`‣ SCFVectorBdCrossPolytope`( d ) | ( function )

Returns: a list of integers of size `d + 1` upon success, `fail` otherwise.

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

`‣ SCFVectorBdCyclicPolytope`( d, n ) | ( function )

Returns: a list of integers of size `d+1` upon success, `fail` otherwise.

Computes the f-vector of the d-dimensional cyclic polytope on n vertices, n≥ 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

`‣ SCFVectorBdSimplex`( d ) | ( function )

Returns: a list of integers of size `d + 1` upon success, `fail` otherwise.

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

`‣ SCSeriesAGL`( p ) | ( function )

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

`‣ SCSeriesBrehmKuehnelTorus`( n ) | ( function )

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≥ 15 . The triangulations are taken from [BK12]

     gap> T3:=SCSeriesBrehmKuehnelTorus(15);
     [SimplicialComplex

      Properties known: DifferenceCycles, Dim, FacetsEx, Name,
                        TopologicalType, Vertices.

      Name="Neighborly 3-Torus NT3(15)"
      Dim=3
      TopologicalType="T^3"

     /SimplicialComplex]
     gap> T3.Homology;
     [ [ 0, [  ] ], [ 3, [  ] ], [ 3, [  ] ], [ 1, [  ] ] ]
     gap> T3.Neighborliness;
     2
     gap> T3:=SCSeriesBrehmKuehnelTorus(16);
     [SimplicialComplex

      Properties known: DifferenceCycles, Dim, FacetsEx, Name,
                        TopologicalType, Vertices.

      Name="Centrally symmetric 3-Torus SCT3(16)"
      Dim=3
      TopologicalType="T^3"

     /SimplicialComplex]
     gap> T3.Homology;
     [ [ 0, [  ] ], [ 3, [  ] ], [ 3, [  ] ], [ 1, [  ] ] ]
     gap> T3.IsCentrallySymmetric;
     true

##### 6.4-3 SCSeriesBdHandleBody

`‣ SCSeriesBdHandleBody`( d, n ) | ( function )

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

`SCSeriesBdHandleBody(d,n)` generates a transitive d-dimensional sphere bundle (d ≥ 2) with n vertices (n ≥ 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

      Properties known: Dim, FacetsEx, IsOrientable, Name, TopologicalType,
                        Vertices.

      Name="Sphere bundle S^1 x S^1"
      Dim=2
      IsOrientable=true
      TopologicalType="S^1 x S^1"

     /SimplicialComplex]
     gap> SCLib.DetermineTopologicalType(c);
     [SimplicialComplex

      Properties known: BoundaryEx, Dim, FacetsEx, HasBoundary,
                        IsOrientable, IsPseudoManifold, IsPure, Name,
                        SkelExs[], TopologicalType, Vertices.

      Name="Sphere bundle S^1 x S^1"
      Dim=2
      HasBoundary=false
      IsOrientable=true
      IsPseudoManifold=true
      IsPure=true
      TopologicalType="S^1 x S^1"

     /SimplicialComplex]
     gap> SCIsIsomorphic(c,SCSeriesHandleBody(3,7).Boundary);
     true

##### 6.4-4 SCSeriesBid

`‣ SCSeriesBid`( i, d ) | ( function )

Returns: a simplicial complex upon success, `fail` otherwise.

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× S^d-i-2 with vertex transitive automorphism group.

     gap> b26:=SCSeriesBid(2,6);
     [SimplicialComplex

      Properties known: Dim, FacetsEx, Name, Reference, Vertices.

      Name="B(2,6)"
      Dim=5

     /SimplicialComplex]
     gap> s2s2:=SCBoundary(b26);
     [SimplicialComplex

      Properties known: Dim, FacetsEx, Name, Vertices.

      Name="Bd(B(2,6))"
      Dim=4

     /SimplicialComplex]
     gap> SCFVector(s2s2);
     [ 12, 60, 160, 180, 72 ]
     gap> SCAutomorphismGroup(s2s2);
     TransitiveGroup(12,28) = D(4)[x]S(3)
     gap> SCIsManifold(s2s2);
     true
     gap> SCHomology(s2s2);
     [ [ 0, [  ] ], [ 0, [  ] ], [ 2, [  ] ], [ 0, [  ] ], [ 1, [  ] ] ]

##### 6.4-5 SCSeriesC2n

`‣ SCSeriesC2n`( n ) | ( function )

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

Generates the combinatorial 3-manifold C_2n, n ≥ 8, with 2n vertices from [Spr11a], Section 4.5.3 and Section 5.2. The complex is homeomorphic to S^2 × 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

      Properties known: DifferenceCycles, Dim, FacetsEx, Name,
                        TopologicalType, Vertices.

      Name="C_16 = { (1:1:3:11),(1:1:11:3),(1:3:1:11),(2:3:2:9),(2:5:2:7) }"
      Dim=3
      TopologicalType="S^2 ~ S^1"

     /SimplicialComplex]
     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

      Properties known: DifferenceCycles, Dim, FacetsEx, Name,
                        TopologicalType, Vertices.

      Name="D_16 = { (1:1:1:13),(1:2:11:2),(3:4:5:4),(2:3:4:7),(2:7:4:3) }"
      Dim=3
      TopologicalType="S^2 ~ S^1"

     /SimplicialComplex]
     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

`‣ SCSeriesConnectedSum`( k ) | ( function )

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

      Properties known: DifferenceCycles, Dim, FacetsEx, Name,
                        TopologicalType, Vertices.

      Name="(S^2xS^1)^#12)"
      Dim=3
      TopologicalType="(S^2xS^1)^#12)"

     /SimplicialComplex]
     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

`‣ SCSeriesCSTSurface`( l[, j], 2k ) | ( function )

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

      Properties known: DifferenceCycles, Dim, FacetsEx, Name, Vertices.

      Name="cst surface S_{(2,4,14)} = { (2:4:8),(2:8:4) }"
      Dim=2

     /SimplicialComplex]
     gap> last.Homology;
     [ [ 1, [  ] ], [ 4, [  ] ], [ 2, [  ] ] ]
     gap> SCSeriesCSTSurface(2,10);
     [SimplicialComplex

      Properties known: DifferenceCycles, Dim, FacetsEx, Name, Vertices.

      Name="cst surface S_{(2,10)} = { (2:2:6),(3:3:4) }"
      Dim=2

     /SimplicialComplex]
     gap> last.Homology;
     [ [ 0, [  ] ], [ 1, [ 2 ] ], [ 0, [  ] ] ]

##### 6.4-8 SCSeriesD2n

`‣ SCSeriesD2n`( n ) | ( function )

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

Generates the combinatorial 3-manifold D_2n, n ≥ 8, n ≠ 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

      Properties known: DifferenceCycles, Dim, FacetsEx, Name,
                        TopologicalType, Vertices.

      Name="D_30 = { (1:1:1:27),(1:2:25:2),(3:11:5:11),(2:3:11:14),(2:14:11:3) }"
      Dim=3
      TopologicalType="S^2 ~ S^1"

     /SimplicialComplex]
     gap> SCAutomorphismGroup(d);
     TransitiveGroup(30,14) = t30n14
     gap> StructureDescription(last);
     "D60"

     gap> c:=SCSeriesC2n(8);;
     gap> d:=SCSeriesD2n(8);
     [SimplicialComplex

      Properties known: DifferenceCycles, Dim, FacetsEx, Name,
                        TopologicalType, Vertices.

      Name="D_16 = { (1:1:1:13),(1:2:11:2),(3:4:5:4),(2:3:4:7),(2:7:4:3) }"
      Dim=3
      TopologicalType="S^2 ~ S^1"

     /SimplicialComplex]
     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

`‣ SCSeriesHandleBody`( d, n ) | ( function )

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

`SCSeriesHandleBody(d,n)` generates a transitive d-dimensional handle body (d ≥ 3) with n vertices (n ≥ 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 : ... : 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

      Properties known: DifferenceCycles, Dim, FacetsEx, IsOrientable,
                        Name, TopologicalType, Vertices.

      Name="Handle body B^2 x S^1"
      Dim=3
      IsOrientable=true
      TopologicalType="B^2 x S^1"

     /SimplicialComplex]
     gap> SCAutomorphismGroup(c);
     PrimitiveGroup(7,2) = D(2*7)
     gap> bd:=SCBoundary(c);;
     gap> SCAutomorphismGroup(bd);
     PrimitiveGroup(7,4) = AGL(1, 7)
     gap> SCIsIsomorphic(bd,SCSeriesBdHandleBody(2,7));
     true

##### 6.4-10 SCSeriesHomologySphere

`‣ SCSeriesHomologySphere`( p, q, r ) | ( function )

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

Generates a combinatorial Brieskorn homology sphere of type Σ (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

      Properties known: DifferenceCycles, Dim, FacetsEx, Name,
                        TopologicalType, Vertices.

      Name="Homology sphere Sigma(2,3,5)"
      Dim=3
      TopologicalType="Sigma(2,3,5)"

     /SimplicialComplex]
     gap> c.Homology;
     [ [ 0, [  ] ], [ 0, [  ] ], [ 0, [  ] ], [ 1, [  ] ] ]
     gap> c:=SCSeriesHomologySphere(3,4,13);
     [SimplicialComplex

      Properties known: DifferenceCycles, Dim, FacetsEx, Name,
                        TopologicalType, Vertices.

      Name="Homology sphere Sigma(3,4,13)"
      Dim=3
      TopologicalType="Sigma(3,4,13)"

     /SimplicialComplex]
     gap> c.Homology;
     [ [ 0, [  ] ], [ 0, [  ] ], [ 0, [  ] ], [ 1, [  ] ] ]

##### 6.4-11 SCSeriesK

`‣ SCSeriesK`( i, k ) | ( function )

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

Generates the k-th member (k ≥ 0) of the series K^i (1 ≤ i ≤ 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

`‣ SCSeriesKu`( n ) | ( function )

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

      Properties known: Dim, FacetsEx, Name, Vertices.

      Name="Sl_16 = G{ [1,2,5,9],[1,2,9,10],[1,5,9,16] }"
      Dim=3

     /SimplicialComplex]
     gap> SCSlicing(c,[[1,2,3,4,9,10,11,12],[5,6,7,8,13,14,15,16]]);
     [NormalSurface

      Properties known: ConnectedComponents, Dim, EulerCharacteristic, FVector, Fac\
     etsEx, Genus, IsConnected, IsOrientable, NSTriangulation, Name, TopologicalTyp\
     e, Vertices.

      Name="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
      FVector=[ 32, 80, 32, 16 ]
      EulerCharacteristic=0
      IsOrientable=true
      TopologicalType="T^2"

     /NormalSurface]
     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;
     [ [ 1, 9 ], [ 1, 10 ], [ 3, 10 ], [ 3, 11 ], [ 4, 9 ], [ 4, 12 ], [ 11, 12 ] ]
     gap> SCCollapseGreedy(Mplus).Facets;
     [ [ 5, 8 ], [ 5, 16 ], [ 6, 14 ], [ 6, 15 ], [ 8, 15 ], [ 13, 14 ], [ 13, 16 ] ]

##### 6.4-13 SCSeriesL

`‣ SCSeriesL`( i, k ) | ( function )

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

Generates the k-th member (k ≥ 0) of the series L^i, 1 ≤ i ≤ 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

`‣ SCSeriesLe`( k ) | ( function )

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

Generates the k-th member (k ≥ 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

      Properties known: DifferenceCycles, Dim, FacetsEx, Name, Vertices.

      Name="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

     /SimplicialComplex]
     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

`‣ SCSeriesLensSpace`( p, q ) | ( function )

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 ≥ 0 and `fail` otherwise. All complexes have a transitive cyclic automorphism group.

     gap> l154:=SCSeriesLensSpace(15,4);
     [SimplicialComplex

      Properties known: DifferenceCycles, Dim, FacetsEx, Name,
                        TopologicalType, Vertices.

      Name="Lens space L(15,4)"
      Dim=3
      TopologicalType="L(15,4)"

     /SimplicialComplex]
     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

      Properties known: DifferenceCycles, Dim, FacetsEx, Name,
                        TopologicalType, Vertices.

      Name="Lens space L(15,1)"
      Dim=3
      TopologicalType="L(15,1)"

     /SimplicialComplex]
     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

`‣ SCSeriesPrimeTorus`( l, j, p ) | ( function )

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

`‣ SCSeriesSeifertFibredSpace`( p, q, r ) | ( function )

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

Generates a combinatorial Seifert fibred space of type

SFS [ (\mathbb{T}^2)^{(a-1)(b-1)} : (p/a,b_1)^b , (q/b,b_2)^a, (r/ab,b_3) ]

where p and q are co-prime, a = operatornamegcd (p,r), b = operatornamegcd (p,r), and the b_i are given by the identity

\frac{b_1}{p} + \frac{b_2}{q} + \frac{b_3}{r} = \frac{\pm ab}{pqr}.

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

      Properties known: DifferenceCycles, Dim, FacetsEx, Name,
                        TopologicalType, Vertices.

      Name="SFS [ S^2 : (2,b1)^3, (5,b3) ]"
      Dim=3
      TopologicalType="SFS [ S^2 : (2,b1)^3, (5,b3) ]"

     /SimplicialComplex]
     gap> c.Homology;
     [ [ 0, [  ] ], [ 0, [ 2, 2 ] ], [ 0, [  ] ], [ 1, [  ] ] ]

##### 6.4-18 SCSeriesS2xS2

`‣ SCSeriesS2xS2`( k ) | ( function )

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

Generates a combinatorial version of (S^2 × S^2)^# k.

     gap> c:=SCSeriesS2xS2(3);
     [SimplicialComplex

      Properties known: DifferenceCycles, Dim, FacetsEx, Name,
                        TopologicalType, Vertices.

      Name="(S^2 x S^2)^(# 3)"
      Dim=4
      TopologicalType="(S^2 x S^2)^(# 3)"

     /SimplicialComplex]
     gap> c.Homology;
     [ [ 0, [  ] ], [ 0, [  ] ], [ 6, [  ] ], [ 0, [  ] ], [ 1, [  ] ] ]

#### 6.5 A census of regular and chiral maps

##### 6.5-1 SCChiralMap

`‣ SCChiralMap`( m, g ) | ( function )

Returns: a `SCSimplicialComplex` object upon success, `fail` otherwise.

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

      Properties known: Dim, FacetsEx, Name, TopologicalType, Vertices.

      Name="Chiral map {8,10}"
      Dim=2
      TopologicalType="(T^2)^#10"

     /SimplicialComplex]
     gap> c.Homology;
     [ [ 0, [  ] ], [ 20, [  ] ], [ 1, [  ] ] ]

##### 6.5-2 SCChiralMaps

`‣ SCChiralMaps`( ) | ( function )

Returns: a list of lists upon success, `fail` otherwise.

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

      Properties known: Dim, FacetsEx, Name, TopologicalType, Vertices.

      Name="Chiral map {18,28}"
      Dim=2
      TopologicalType="(T^2)^#28"

     /SimplicialComplex]
     gap> SCHomology(c);
     [ [ 0, [  ] ], [ 56, [  ] ], [ 1, [  ] ] ]

##### 6.5-3 SCChiralTori

`‣ SCChiralTori`( n ) | ( function )

Returns: a `SCSimplicialComplex` object upon success, `fail` otherwise.

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

     gap> cc:=SCChiralTori(91);
     [ [SimplicialComplex

          Properties known: AutomorphismGroup, Dim, FacetsEx, Name,
                            TopologicalType, Vertices.

          Name="{3,6}_(9,1)"
          Dim=2
          TopologicalType="T^2"

         /SimplicialComplex], [SimplicialComplex

          Properties known: AutomorphismGroup, Dim, FacetsEx, Name,
                            TopologicalType, Vertices.

          Name="{3,6}_(6,5)"
          Dim=2
          TopologicalType="T^2"

         /SimplicialComplex] ]
     gap> SCIsIsomorphic(cc[1],cc[2]);
     false

##### 6.5-4 SCNrChiralTori

`‣ SCNrChiralTori`( n ) | ( function )

Returns: an integer upon success, `fail` otherwise.

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

`‣ SCNrRegularTorus`( n ) | ( function )

Returns: an integer upon success, `fail` otherwise.

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

`‣ SCRegularMap`( m, g, orient ) | ( function )

Returns: a `SCSimplicialComplex` object upon success, `fail` otherwise.

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

      Properties known: Dim, FacetsEx, Name, TopologicalType, Vertices.

      Name="Orientable regular map {7,7}"
      Dim=2
      TopologicalType="(T^2)^#7"

     /SimplicialComplex]
     gap> g:=SCAutomorphismGroup(c);
     #I  group not listed
     C2 x PSL(2,8)
     gap> Size(g);
     1008

##### 6.5-7 SCRegularMaps

`‣ SCRegularMaps`( ) | ( function )

Returns: a list of lists upon success, `fail` otherwise.

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

      Properties known: Dim, FacetsEx, Name, TopologicalType, Vertices.

      Name="Non-orientable regular map {7,15}"
      Dim=2
      TopologicalType="(RP^2)^#15"

     /SimplicialComplex]
     gap> SCHomology(c);
     [ [ 0, [  ] ], [ 14, [ 2 ] ], [ 0, [  ] ] ]
     gap> SCGenerators(c);
     [ [ [ 1, 4, 7 ], 182 ] ]

##### 6.5-8 SCRegularTorus

`‣ SCRegularTorus`( n ) | ( function )

Returns: a `SCSimplicialComplex` object upon success, `fail` otherwise.

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

          Properties known: AutomorphismGroup, Dim, FacetsEx, Name,
                            TopologicalType, Vertices.

          Name="{3,6}_(3,0)"
          Dim=2
          TopologicalType="T^2"

         /SimplicialComplex] ]
     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

`‣ SCSeriesSymmetricTorus`( p, q ) | ( function )

Returns: a `SCSimplicialComplex` object upon success, `fail` otherwise.

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

      Properties known: AutomorphismGroup, Dim, FacetsEx, Name,
                        TopologicalType, Vertices.

      Name="{3,6}_(2,1)"
      Dim=2
      TopologicalType="T^2"

     /SimplicialComplex]
     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

`‣ SCCartesianPower`( complex, n ) | ( method )

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 ⋅ d and has f_d^n ⋅ n ⋅ frac2n-12^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

      Properties known: Dim, FacetsEx, Name, TopologicalType, Vertices.

      Name="(S^1_3)^4"
      Dim=4
      TopologicalType="(S^1)^4"

     /SimplicialComplex]
     gap> 4torus.Homology;
     [ [ 0, [  ] ], [ 4, [  ] ], [ 6, [  ] ], [ 4, [  ] ], [ 1, [  ] ] ]
     gap> 4torus.Chi;
     0
     gap> 4torus.F;
     [ 81, 1215, 4050, 4860, 1944 ]

##### 6.6-2 SCCartesianProduct

`‣ SCCartesianProduct`( complex1, complex2 ) | ( method )

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 ⋅ n_2 ⋅ 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

      Properties known: Dim, FacetsEx, Name, TopologicalType, Vertices.

      Name="S^1_3xS^2_4"
      Dim=3
      TopologicalType="S^1xS^2"

     /SimplicialComplex]
     gap> c3.Homology;
     [ [ 0, [  ] ], [ 1, [  ] ], [ 1, [  ] ], [ 1, [  ] ] ]
     gap> c3.F;
     [ 12, 48, 72, 36 ]

##### 6.6-3 SCConnectedComponents

`‣ SCConnectedComponents`( complex ) | ( method )

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

Computes all connected components of an arbitrary simplicial complex.

     gap> c:=SC([[1,2,3],[3,4,5],[4,5,6,7,8]]);;
     gap> SCRename(c,"connected complex");;
     gap> SCConnectedComponents(c);
     [ [SimplicialComplex

          Properties known: Dim, FacetsEx, Name, Vertices.

          Name="Connected component #1 of connected complex"
          Dim=4

         /SimplicialComplex] ]
     gap> c:=SC([[1,2,3],[4,5],[6,7,8]]);;
     gap> SCRename(c,"non-connected complex");;
     gap> SCConnectedComponents(c);
     [ [SimplicialComplex

          Properties known: Dim, FacetsEx, Name, Vertices.

          Name="Connected component #1 of non-connected complex"
          Dim=2

         /SimplicialComplex], [SimplicialComplex

          Properties known: Dim, FacetsEx, Name, Vertices.

          Name="Connected component #2 of non-connected complex"
          Dim=1

         /SimplicialComplex], [SimplicialComplex

          Properties known: Dim, FacetsEx, Name, Vertices.

          Name="Connected component #3 of non-connected complex"
          Dim=2

         /SimplicialComplex] ]

##### 6.6-4 SCConnectedProduct

`‣ SCConnectedProduct`( complex, n ) | ( method )

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

If n ≥ 2, the function internally calls 1 × `SCConnectedSum` (6.6-5) and (n-2) × `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)" ],
       [ 18, "T^2 (VT)" ], [ 20, "(T^2)#2" ] ]
     gap> torus:=SCLib.Load(last[1][1]);;
     gap> genus10:=SCConnectedProduct(torus,10);
     [SimplicialComplex

      Properties known: Dim, FacetsEx, Name, Vertices.

      Name="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

     /SimplicialComplex]
     gap> genus10.Chi;
     -18
     gap> genus10.F;
     [ 43, 183, 122 ]

##### 6.6-5 SCConnectedSum

`‣ SCConnectedSum`( complex1, complex2 ) | ( method )

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)" ],
       [ 18, "T^2 (VT)" ], [ 20, "(T^2)#2" ] ]
     gap> torus:=SCLib.Load(last[1][1]);;
     gap> genus2:=SCConnectedSum(torus,torus);
     [SimplicialComplex

      Properties known: Dim, FacetsEx, Name, Vertices.

      Name="T^2 (VT)#+-T^2 (VT)"
      Dim=2

     /SimplicialComplex]
     gap> genus2.Homology;
     [ [ 0, [  ] ], [ 4, [  ] ], [ 1, [  ] ] ]
     gap> genus2.Chi;
     -2

     gap> SCLib.SearchByName("CP^2");
     [ [ 16, "CP^2 (VT)" ], [ 99, "CP^2#-CP^2" ], [ 100, "CP^2#CP^2" ],
       [ 400, "CP^2#(S^2xS^2)" ], [ 2486, "Gaifullin CP^2" ],
       [ 4401, "(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

`‣ SCConnectedSumMinus`( complex1, complex2 ) | ( method )

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)" ],
       [ 18, "T^2 (VT)" ], [ 20, "(T^2)#2" ] ]
     gap> torus:=SCLib.Load(last[1][1]);;
     gap> genus2:=SCConnectedSumMinus(torus,torus);
     [SimplicialComplex

      Properties known: Dim, FacetsEx, Name, Vertices.

      Name="T^2 (VT)#+-T^2 (VT)"
      Dim=2

     /SimplicialComplex]
     gap> genus2.Homology;
     [ [ 0, [  ] ], [ 4, [  ] ], [ 1, [  ] ] ]
     gap> genus2.Chi;
     -2

     gap> SCLib.SearchByName("CP^2");
     [ [ 16, "CP^2 (VT)" ], [ 99, "CP^2#-CP^2" ], [ 100, "CP^2#CP^2" ],
       [ 400, "CP^2#(S^2xS^2)" ], [ 2486, "Gaifullin CP^2" ],
       [ 4401, "(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

`‣ SCDifferenceCycleCompress`( simplex, modulus ) | ( function )

Returns: list with possibly duplicate entries upon success, `fail` otherwise.

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

`‣ SCDifferenceCycleExpand`( diffcycle ) | ( function )

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

diffcycle induces a simplex ∆ = ( v_1 , ... , v_n+1 ) by v_1 =diffcycle[1], v_i = v_i-1 + diffcycle[i] and a cyclic group action by Z_σ where σ = ∑ diffcycle[i] is the modulus of `diffcycle`. The function returns the Z_σ-orbit of ∆.

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

`‣ SCStronglyConnectedComponents`( complex ) | ( method )

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

Computes all strongly connected components of a pure simplicial complex.

     gap> c:=SC([[1,2,3],[2,3,4],[4,5,6],[5,6,7]]);;
     gap> comps:=SCStronglyConnectedComponents(c);
     [ [SimplicialComplex

          Properties known: Dim, FacetsEx, Name, Vertices.

          Name="Strongly connected component #1 of unnamed complex 82"
          Dim=2

         /SimplicialComplex], [SimplicialComplex

          Properties known: Dim, FacetsEx, Name, Vertices.

          Name="Strongly connected component #2 of unnamed complex 82"
          Dim=2

         /SimplicialComplex] ]
     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], [ManifoldPage] and in particular his program `MANIFOLD_VT`.

##### 6.7-1 SCsFromGroupExt

`‣ SCsFromGroupExt`( G, n, d, objectType, cache, removeDoubleEntries, outfile, maxLinkSize, subset ) | ( function )

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 ≥ 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

      Properties known: Dim, ExportIsoSig, FacetsEx, Name, Vertices.

      Name="unnamed complex 6"
      Dim=3

     /SimplicialComplex]
     gap> SCNeighborliness(c);
     3
     gap> c.F;
     [ 8, 28, 56, 28 ]
     gap> c.IsManifold;
     false
     gap> SCLibDetermineTopologicalType(SCLink(c,1));
     [SimplicialComplex

      Properties known: BoundaryEx, Dim, FacetsEx, HasBoundary,
                        IsPseudoManifold, IsPure, Name, SkelExs[],
                        Vertices.

      Name="lk([ 1 ]) in unnamed complex 6"
      Dim=2
      HasBoundary=false
      IsPseudoManifold=true
      IsPure=true

     /SimplicialComplex]
     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

`‣ SCsFromGroupByTransitivity`( n, d, k, maniflag, computeAutGroup, removeDoubleEntries ) | ( function )

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 ≥ 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

`‣ SCNrCyclic3Mflds`( i ) | ( function )

Returns: integer upon success, `fail` otherwise.

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

`‣ SCCyclic3MfldTopTypes`( i ) | ( function )

Returns: a list of strings upon success, `fail` otherwise.

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

`‣ SCCyclic3Mfld`( i, j ) | ( function )

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

      Properties known: AutomorphismGroupTransitivity, DifferenceCycles,
                        Dim, FacetsEx, IsManifold, Name, TopologicalType,
                        Vertices.

      Name="Cyclic 3-mfld (15,34): T^3"
      Dim=3
      AutomorphismGroupTransitivity=1
      TopologicalType="T^3"

     /SimplicialComplex]

##### 6.8-4 SCCyclic3MfldByType

`‣ SCCyclic3MfldByType`( type ) | ( function )

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

      Properties known: AutomorphismGroupTransitivity, DifferenceCycles,
                        Dim, FacetsEx, IsManifold, Name, TopologicalType,
                        Vertices.

      Name="Cyclic 3-mfld (15,34): T^3"
      Dim=3
      AutomorphismGroupTransitivity=1
      TopologicalType="T^3"

     /SimplicialComplex]

##### 6.8-5 SCCyclic3MfldListOfGivenType

`‣ SCCyclic3MfldListOfGivenType`( type ) | ( function )

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

Returns a list of indices { (i_1, j_1) , (i_1, j_1) , ... (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

`‣ SCAltshulerSteinberg`( complex ) | ( method )

Returns: a non-negative integer upon success, `fail` otherwise.

Computes the Altshuler-Steinberg determinant.

Definition: Let v_i, 1 ≤ i ≤ n be the vertices and let F_j, 1 ≤ j ≤ m be the facets of a pure simplicial complex C, then the determinant of AS ∈ Z^n × m, AS_ij=1 if v_i ∈ F_j, AS_ij=0 otherwise, is called the Altshuler-Steinberg matrix. The Altshuler-Steinberg determinant is the determinant of the quadratic matrix AS ⋅ 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

`‣ SCAutomorphismGroup`( complex ) | ( method )

Returns: a GAP permutation group upon success, `fail` otherwise.

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");
     [ [ 7648, "K3_16" ], [ 7649, "K3_17" ] ]
     gap> k3surf:=SCLib.Load(last[1][1]);;
     gap> SCAutomorphismGroup(k3surf);
     Group([ (1,3,8,4,9,16,15,2,14,12,6,7,13,5,10), (1,13)(2,14)(3,15)(4,16)(5,9)
     (6,10)(7,11)(8,12) ])

##### 6.9-3 SCAutomorphismGroupInternal

`‣ SCAutomorphismGroupInternal`( complex ) | ( method )

Returns: a GAP permutation group upon success, `fail` otherwise.

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 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> c:=SCBdSimplex(5);;
     gap> SCAutomorphismGroupInternal(c);
     Sym( [ 1 .. 6 ] )

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

##### 6.9-4 SCAutomorphismGroupSize

`‣ SCAutomorphismGroupSize`( complex ) | ( method )

Returns: a positive integer group upon success, `fail` otherwise.

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

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

##### 6.9-5 SCAutomorphismGroupStructure

`‣ SCAutomorphismGroupStructure`( complex ) | ( method )

Returns: the GAP structure description upon success, `fail` otherwise.

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

     gap> SCLib.SearchByName("K3");
     [ [ 7648, "K3_16" ], [ 7649, "K3_17" ] ]
     gap> k3surf:=SCLib.Load(last[1][1]);;
     gap> SCAutomorphismGroupStructure(k3surf);
     "((C2 x C2 x C2 x C2) : C5) : C3"

##### 6.9-6 SCAutomorphismGroupTransitivity

`‣ SCAutomorphismGroupTransitivity`( complex ) | ( method )

Returns: a positive integer upon success, `fail` otherwise.

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");
     [ [ 7648, "K3_16" ], [ 7649, "K3_17" ] ]
     gap> k3surf:=SCLib.Load(last[1][1]);;
     gap> SCAutomorphismGroupTransitivity(k3surf);
     2

##### 6.9-7 SCBoundary

`‣ SCBoundary`( complex ) | ( method )

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

      Properties known: Dim, FacetsEx, Name, Vertices.

      Name="unnamed complex 52"
      Dim=3

     /SimplicialComplex]
     gap> SCBoundary(c);
     [SimplicialComplex

      Properties known: Dim, FacetsEx, Name, Vertices.

      Name="Bd(unnamed complex 52)"
      Dim=2

     /SimplicialComplex]
     gap> c;
     [SimplicialComplex

      Properties known: BoundaryEx, Dim, FacetsEx, HasBoundary,
                        IsPseudoManifold, IsPure, Name, SkelExs[],
                        Vertices.

      Name="unnamed complex 52"
      Dim=3
      HasBoundary=true
      IsPseudoManifold=true
      IsPure=true

     /SimplicialComplex]

##### 6.9-8 SCDehnSommervilleCheck

`‣ SCDehnSommervilleCheck`( c ) | ( method )

Returns: `true` or `false` upon success, `fail` otherwise.

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 (χ (M) - 2) for 0 ≤ j ≤ fracd2 and d even, and h_j - h_d+1-j = 0 for 0 ≤ j ≤ fracd-12 and d odd. Where h_j is the jth 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

`‣ SCDehnSommervilleMatrix`( d ) | ( method )

Returns: a `(d+1)`×`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 (χ (M) - 2) for 0 ≤ j ≤ fracd2 and d even, and h_j - h_d+1-j = 0 for 0 ≤ j ≤ fracd-12 and d odd. Where h_j is the jth 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

`‣ SCDifferenceCycles`( complex ) | ( method )

Returns: a list of lists upon success, `fail` otherwise.

Computes the difference cycles of complex in standard labeling if complex is invariant under a shift of the vertices of type v ↦ 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

      Properties known: DifferenceCycles, Dim, FacetsEx, Name, Vertices.

      Name="complex from diffcycles [ [ 1, 2, 4 ], [ 1, 4, 2 ] ]"
      Dim=2

     /SimplicialComplex]
     gap> torus.Homology;
     [ [ 0, [  ] ], [ 2, [  ] ], [ 1, [  ] ] ]
     gap> torus.DifferenceCycles;
     [ [ 1, 2, 4 ], [ 1, 4, 2 ] ]

##### 6.9-11 SCDim

`‣ SCDim`( complex ) | ( method )

Returns: an integer ≥ -1 upon success, `fail` otherwise.

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

`‣ SCDualGraph`( complex ) | ( method )

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

Computes the dual graph of the pure simplicial complex complex.

     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

      Properties known: Dim, FacetsEx, Name, Vertices.

      Name="dual graph of S^4_6"
      Dim=1

     /SimplicialComplex]
     gap> graph.Facets = dualGraph.Facets;
     true

##### 6.9-13 SCEulerCharacteristic

`‣ SCEulerCharacteristic`( complex ) | ( method )

Returns: integer upon success, `fail` otherwise.

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

`‣ SCFVector`( complex ) | ( method )

Returns: a list of non-negative integers upon success, `fail` otherwise.

Computes the f-vector of the simplicial complex complex, i. e. the number of i-dimensional faces for 0 ≤ i ≤ 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

`‣ SCFaceLattice`( complex ) | ( method )

Returns: a list of face lists upon success, `fail` otherwise.

Computes the entire face lattice of a d-dimensional simplicial complex, i. e. all of its i-skeletons for 0 ≤ i ≤ 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

`‣ SCFaceLatticeEx`( complex ) | ( method )

Returns: a list of face lists upon success, `fail` otherwise.

Computes the entire face lattice of a d-dimensional simplicial complex, i. e. all of its i-skeletons for 0 ≤ i ≤ 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

`‣ SCFaces`( complex, k ) | ( method )

Returns: a face list upon success, `fail` otherwise.

This is a synonym of the function `SCSkel` (7.3-13).

##### 6.9-18 SCFacesEx

`‣ SCFacesEx`( complex, k ) | ( method )

Returns: a face list upon success, `fail` otherwise.

This is a synonym of the function `SCSkelEx` (7.3-14).

##### 6.9-19 SCFacets

`‣ SCFacets`( complex ) | ( method )

Returns: a facet list upon success, `fail` otherwise.

Returns the facets of a simplicial complex in the original vertex labeling.

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

##### 6.9-20 SCFacetsEx

`‣ SCFacetsEx`( complex ) | ( method )

Returns: a facet list upon success, `fail` otherwise.

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

`‣ SCFpBettiNumbers`( complex, p ) | ( method )

Returns: a list of non-negative integers upon success, `fail` otherwise.

Computes the Betti numbers of a simplicial complex with respect to the field F_p for any prime number `p`.

     gap> SCLib.SearchByName("K^2");
     [ [ 17, "K^2 (VT)" ], [ 571, "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

`‣ SCFundamentalGroup`( complex ) | ( method )

Returns: a GAP fp group upon success, `fail` otherwise.

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)" ], [ 635, "RP^2xS^1" ] ]
     gap> c:=SCLib.Load(list[1][1]);
     [SimplicialComplex

      Properties known: AltshulerSteinberg, AutomorphismGroup,
                        AutomorphismGroupSize, AutomorphismGroupStructure,
                        AutomorphismGroupTransitivity, ConnectedComponents,
                        Dim, DualGraph, EulerCharacteristic, FVector,
                        FacetsEx, GVector, GeneratorsEx, HVector,
                        HasBoundary, HasInterior, Homology, Interior,
                        IsCentrallySymmetric, IsConnected,
                        IsEulerianManifold, IsManifold, IsOrientable,
                        IsPseudoManifold, IsPure, IsStronglyConnected,
                        MinimalNonFacesEx, Name, Neighborliness,
                        NumFaces[], Orientation, Reference, SkelExs[],
                        Vertices.

      Name="RP^2 (VT)"
      Dim=2
      AltshulerSteinberg=3645
      AutomorphismGroupSize=60
      AutomorphismGroupStructure="A5"
      AutomorphismGroupTransitivity=2
      EulerCharacteristic=1
      FVector=[ 6, 15, 10 ]
      GVector=[ 2, 3 ]
      HVector=[ 3, 6, 0 ]
      HasBoundary=false
      HasInterior=true
      Homology=[ [ 0, [ ] ], [ 0, [ 2 ] ], [ 0, [ ] ] ]
      IsCentrallySymmetric=false
      IsConnected=true
      IsEulerianManifold=true
      IsOrientable=false
      IsPseudoManifold=true
      IsPure=true
      IsStronglyConnected=true
      Neighborliness=2

     /SimplicialComplex]
     gap> g:=SCFundamentalGroup(c);;
     gap> StructureDescription(g);
     "C2"

##### 6.9-23 SCGVector

`‣ SCGVector`( complex ) | ( method )

Returns: a list of integers upon success, `fail` otherwise.

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)" ], [ 635, "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

`‣ SCGenerators`( complex ) | ( method )

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.

The function returns the simplices together with the length of their orbits.

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

     gap> SCLib.SearchByName("K3");
     [ [ 7648, "K3_16" ], [ 7649, "K3_17" ] ]
     gap> SCLib.Load(last[1][1]);
     [SimplicialComplex

      Properties known: AltshulerSteinberg, AutomorphismGroup,
                        AutomorphismGroupSize, AutomorphismGroupStructure,
                        AutomorphismGroupTransitivity, ConnectedComponents,
                        Dim, DualGraph, EulerCharacteristic, FVector,
                        FacetsEx, GVector, GeneratorsEx, HVector,
                        HasBoundary, HasInterior, Homology, Interior,
                        IsCentrallySymmetric, IsConnected,
                        IsEulerianManifold, IsManifold, IsOrientable,
                        IsPseudoManifold, IsPure, IsStronglyConnected,
                        MinimalNonFacesEx, Name, Neighborliness,
                        NumFaces[], Orientation, SkelExs[], Vertices.

      Name="K3_16"
      Dim=4
      AltshulerSteinberg=883835714748069945165599539200
      AutomorphismGroupSize=240
      AutomorphismGroupStructure="((C2 x C2 x C2 x C2) : C5) : C3"
      AutomorphismGroupTransitivity=2
      EulerCharacteristic=24
      FVector=[ 16, 120, 560, 720, 288 ]
      GVector=[ 10, 55, 220 ]
      HVector=[ 11, 66, 286, -99, 23 ]
      HasBoundary=false
      HasInterior=true
      Homology=[ [ 0, [ ] ], [ 0, [ ] ], [ 22, [ ] ], [ 0, [ ] ], [ 1, [ ] ] ]
      IsCentrallySymmetric=false
      IsConnected=true
      IsEulerianManifold=true
      IsOrientable=true
      IsPseudoManifold=true
      IsPure=true
      IsStronglyConnected=true
      Neighborliness=3

     /SimplicialComplex]
     gap> SCGenerators(last);
     [ [ [ 1, 2, 3, 8, 12 ], 240 ], [ [ 1, 2, 5, 8, 14 ], 48 ] ]

##### 6.9-25 SCGeneratorsEx

`‣ SCGeneratorsEx`( complex ) | ( method )

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.

The function returns the simplices together with the length of their orbits.

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

     gap> SCLib.SearchByName("K3");
     [ [ 7648, "K3_16" ], [ 7649, "K3_17" ] ]
     gap> SCLib.Load(last[1][1]);
     [SimplicialComplex

      Properties known: AltshulerSteinberg, AutomorphismGroup,
                        AutomorphismGroupSize, AutomorphismGroupStructure,
                        AutomorphismGroupTransitivity, ConnectedComponents,
                        Dim, DualGraph, EulerCharacteristic, FVector,
                        FacetsEx, GVector, GeneratorsEx, HVector,
                        HasBoundary, HasInterior, Homology, Interior,
                        IsCentrallySymmetric, IsConnected,
                        IsEulerianManifold, IsManifold, IsOrientable,
                        IsPseudoManifold, IsPure, IsStronglyConnected,
                        MinimalNonFacesEx, Name, Neighborliness,
                        NumFaces[], Orientation, SkelExs[], Vertices.

      Name="K3_16"
      Dim=4
      AltshulerSteinberg=883835714748069945165599539200
      AutomorphismGroupSize=240
      AutomorphismGroupStructure="((C2 x C2 x C2 x C2) : C5) : C3"
      AutomorphismGroupTransitivity=2
      EulerCharacteristic=24
      FVector=[ 16, 120, 560, 720, 288 ]
      GVector=[ 10, 55, 220 ]
      HVector=[ 11, 66, 286, -99, 23 ]
      HasBoundary=false
      HasInterior=true
      Homology=[ [ 0, [ ] ], [ 0, [ ] ], [ 22, [ ] ], [ 0, [ ] ], [ 1, [ ] ] ]
      IsCentrallySymmetric=false
      IsConnected=true
      IsEulerianManifold=true
      IsOrientable=true
      IsPseudoManifold=true
      IsPure=true
      IsStronglyConnected=true
      Neighborliness=3

     /SimplicialComplex]
     gap> SCGeneratorsEx(last);
     [ [ [ 1, 2, 3, 8, 12 ], 240 ], [ [ 1, 2, 5, 8, 14 ], 48 ] ]

##### 6.9-26 SCHVector

`‣ SCHVector`( complex ) | ( method )

Returns: a list of integers upon success, `fail` otherwise.

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 ≤ k ≤ 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)" ], [ 635, "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

`‣ SCHasBoundary`( complex ) | ( method )

Returns: `true` or `false` upon success, `fail` otherwise.

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");
     [ [ 17, "K^2 (VT)" ], [ 571, "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

`‣ SCHasInterior`( complex ) | ( method )

Returns: `true` or `false` upon success, `fail` otherwise.

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

`‣ SCHeegaardSplittingSmallGenus`( M ) | ( method )

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

`‣ SCHeegaardSplitting`( M ) | ( method )

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

      Properties known: ConnectedComponents, Dim, EulerCharacteristic, FVector, Fac\
     etsEx, Genus, IsConnected, IsOrientable, NSTriangulation, Name, TopologicalTyp\
     e, Vertices.

      Name="slicing [ [ 1, 2, 3, 5, 9 ], [ 4, 6, 7, 8, 10, 11, 12 ] ] of Sphere bun\
     dle S^2 x S^1"
      Dim=2
      FVector=[ 24, 55, 14, 17 ]
      EulerCharacteristic=0
      IsOrientable=true
      TopologicalType="T^2"

     /NormalSurface]

##### 6.9-31 SCHomologyClassic

`‣ SCHomologyClassic`( complex ) | ( function )

Returns: a list of pairs of the form `[ integer, list ]`.

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≅ Z^f + Z / t_1 Z × dots × Z / t_n 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");
     [ [ 17, "K^2 (VT)" ], [ 571, "K^2 (VT)" ] ]
     gap> kleinBottle:=SCLib.Load(last[1][1]);;
     gap> kleinBottle.Homology;
     [ [ 0, [  ] ], [ 1, [ 2 ] ], [ 0, [  ] ] ]
     gap> SCLib.SearchByName("L_"){[1..10]};
     [ [ 139, "L_3_1" ], [ 634, "L_4_1" ], [ 754, "L_5_2" ],
       [ 2416, "(S^2~S^1)#L_3_1" ], [ 2417, "(S^2xS^1)#L_3_1" ], [ 2490, "L_5_1" ],
       [ 2492, "(S^2~S^1)#2#L_3_1" ], [ 2494, "(S^2xS^1)#2#L_3_1" ],
       [ 7467, "L_7_2" ], [ 7468, "L_8_3" ] ]
     gap> c:=SCConnectedSum(SCLib.Load(last[9][1]),
                            SCConnectedProduct(SCLib.Load(last[10][1]),2));
     > [SimplicialComplex

      Properties known: Dim, FacetsEx, Name, Vertices.

      Name="L_7_2#+-L_8_3#+-L_8_3"
      Dim=3

     /SimplicialComplex]
     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

`‣ SCIncidences`( complex, k ) | ( method )

Returns: a list of face lists upon success, `fail` otherwise.

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

`‣ SCIncidencesEx`( complex, k ) | ( method )

Returns: a list of face lists upon success, `fail` otherwise.

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 standard 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-34 SCInterior

`‣ SCInterior`( complex ) | ( method )

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

`‣ SCIsCentrallySymmetric`( complex ) | ( method )

Returns: `true` or `false` upon success, `fail` otherwise.

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

`‣ SCIsConnected`( complex ) | ( method )

Returns: `true` or `false` upon success, `fail` otherwise.

Checks if a simplicial complex complex is connected.

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

##### 6.9-37 SCIsEmpty

`‣ SCIsEmpty`( complex ) | ( method )

Returns: `true` or `false` upon success, `fail` otherwise.

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

`‣ SCIsEulerianManifold`( complex ) | ( method )

Returns: `true` or `false` upon success, `fail` otherwise.

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

      Properties known: Dim, EulerCharacteristic, FVector, FacetsEx,
                        GVector, HVector, HasBoundary, Homology,
                        IsConnected, IsManifold, IsPseudoManifold,
                        MinimalNonFacesEx, Name, NumFaces[], SkelExs[],
                        Vertices.

      Name="Moebius Strip"
      Dim=2
      EulerCharacteristic=0
      FVector=[ 5, 10, 5 ]
      GVector=[ 1, 1 ]
      HVector=[ 2, 3, -1 ]
      HasBoundary=true
      Homology=[ [ 0 ], [ 1 ], [ 0 ] ]
      IsConnected=true
      IsPseudoManifold=true

     /SimplicialComplex]
     gap> SCIsEulerianManifold(moebius);
     false

##### 6.9-39 SCIsFlag

`‣ SCIsFlag`( complex, k ) | ( method )

Returns: `true` or `false` upon success, `fail` otherwise.

Checks if complex is flag. A simplicial complex is a flag complex if all edges of a potential face of the complex are in the complex, or equivalently if all of its minimal non-faces are edges (cf. [Fro08]).

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

##### 6.9-40 SCIsHeegaardSplitting

`‣ SCIsHeegaardSplitting`( c, list ) | ( method )

Returns: `true` or `false` upon success, `fail` otherwise.

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

`‣ SCIsHomologySphere`( complex ) | ( method )

Returns: `true` or `false` upon success, `fail` otherwise.

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

`‣ SCIsInKd`( complex, k ) | ( method )

Returns: `true` / `false` upon success, `fail` otherwise.

Checks whether the simplicial complex complex that must be a combinatorial d-manifold is in the class mathcalK^k(d), 1≤ k≤ ⌊fracd+12⌋, 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 mathcalK^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,3)(4,9)(5,8)(6,7), (1,9,8,7,6,5,4,3,2) ])
     gap> SCIsInKd(c,1);
     #I  SCIsKStackedSphere: checking if complex is a 1-stacked sphere...
     #I  SCIsKStackedSphere: try 1/50
     #I  SCIsKStackedSphere: complex is a 1-stacked sphere.
     true

##### 6.9-43 SCIsKNeighborly

`‣ SCIsKNeighborly`( complex, k ) | ( method )

Returns: `true` or `false` upon success, `fail` otherwise.

     gap> SCLib.SearchByName("RP^2");
     [ [ 3, "RP^2 (VT)" ], [ 635, "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

`‣ SCIsOrientable`( complex ) | ( method )

Returns: `true` or `false` upon success, `fail` otherwise.

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

`‣ SCIsPseudoManifold`( complex ) | ( method )

Returns: `true` or `false` upon success, `fail` otherwise.

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

`‣ SCIsPure`( complex ) | ( method )

Returns: a boolean upon success, `fail` otherwise.

Checks if a simplicial complex complex is pure.

     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

`‣ SCIsShellable`( complex ) | ( method )

Returns: `true` or `false` upon success, `fail` otherwise.

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, ... , F_r) on the facet list of a simplicial complex is called a shelling if and only if F_i ∩ (F_1 ∪ ... ∪ F_i-1) is a pure simplicial complex of dimension d-1 for all i = 1, ... , r. A simplicial complex is called shellable, if at least one shelling exists.

See [Zie95], [Pac87] to learn more about shellings.

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

##### 6.9-48 SCIsStronglyConnected

`‣ SCIsStronglyConnected`( complex ) | ( method )

Returns: `true` or `false` upon success, `fail` otherwise.

Checks if a simplicial complex complex is strongly connected, i. e. if for any pair of facets (hat∆,tilde∆) there exists a sequence of facets ( ∆_1 , ... , ∆_k ) with ∆_1 = hat∆ and ∆_k = tilde∆ and dim(∆_i , ∆_i+1 ) = d - 1 for all 1 ≤ i ≤ 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

      Properties known: Dim, FacetsEx, Name, Vertices.

      Name="unnamed complex 24"
      Dim=2

     /SimplicialComplex]
     gap> SCIsConnected(c);
     true
     gap> SCIsStronglyConnected(c);
     false

##### 6.9-49 SCMinimalNonFaces

`‣ SCMinimalNonFaces`( complex ) | ( method )

Returns: a list of face lists upon success, `fail` otherwise.

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

`‣ SCMinimalNonFacesEx`( complex ) | ( method )

Returns: a list of face lists upon success, `fail` otherwise.

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)" ],
       [ 18, "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

`‣ SCNeighborliness`( complex ) | ( method )

Returns: a positive integer upon success, `fail` otherwise.

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

Note that every complex is at least 1-neighborly.

     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)" ], [ 7648, "K3_16" ] ]
     gap> cp2:=SCLib.Load(last[2][1]);;
     gap> SCNeighborliness(cp2);
     3

##### 6.9-52 SCNumFaces

`‣ SCNumFaces`( complex[, i] ) | ( method )

Returns: an integer or a list of integers upon success, `fail` otherwise.

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

`‣ SCOrientation`( complex ) | ( method )

Returns: a list of the type { ± 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

`‣ SCSkel`( complex, k ) | ( method )

Returns: a face list or a list of face lists upon success, `fail` otherwise.

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)" ], [ 635, "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

`‣ SCSkelEx`( complex, k ) | ( method )

Returns: a face list or a list of face lists upon success, `fail` otherwise.

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 standard labeling.

     gap> SCLib.SearchByName("RP^2");
     [ [ 3, "RP^2 (VT)" ], [ 635, "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

`‣ SCSpanningTree`( complex ) | ( method )

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

      Properties known: Dim, FacetsEx, Name, Vertices.

      Name="spanning tree of unnamed complex 1"
      Dim=1

     /SimplicialComplex]
     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

`‣ SCAlexanderDual`( complex ) | ( method )

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

`‣ SCClose`( complex[, apex] ) | ( function )

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

`‣ SCCone`( complex, apex ) | ( function )

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" ], [ 113, "RP^3=L(2,1) (VT)" ], [ 589, "(S^2~S^1)#RP^3" ],
       [ 590, "(S^2xS^1)#RP^3" ], [ 632, "(S^2~S^1)#2#RP^3" ],
       [ 633, "(S^2xS^1)#2#RP^3" ], [ 2414, "RP^3#RP^3" ],
       [ 2426, "RP^3=L(2,1) (VT)" ], [ 2488, "(S^2~S^1)#3#RP^3" ],
       [ 2489, "(S^2xS^1)#3#RP^3" ], [ 2502, "RP^3=L(2,1) (VT)" ],
       [ 7473, "(S^2~S^1)#4#RP^3" ], [ 7474, "(S^2xS^1)#4#RP^3" ],
       [ 7504, "(S^2~S^1)#5#RP^3" ], [ 7505, "(S^2xS^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

`‣ SCDeletedJoin`( complex1, complex2 ) | ( method )

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

      Properties known: Dim, FacetsEx, Name, Vertices.

      Name="S^2_4 deljoin S^2_4"
      Dim=3

     /SimplicialComplex]
     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

`‣ SCDifference`( complex1, complex2 ) | ( method )

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

`‣ SCFillSphere`( complex[, vertex] ) | ( function )

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)" ],
       [ 130, "S^4 (VT)" ], [ 463, "S^4~S^1 (VT)" ], [ 713, "S^4xS^1 (VT)" ],
       [ 1472, "S^4xS^1 (VT)" ], [ 1473, "S^4~S^1 (VT)" ],
       [ 1474, "S^4~S^1 (VT)" ], [ 1475, "S^4xS^1 (VT)" ],
       [ 2477, "S^4~S^1 (VT)" ], [ 2478, "S^4 (VT)" ], [ 3435, "S^4 (VT)" ],
       [ 4395, "S^4~S^1 (VT)" ], [ 4396, "S^4~S^1 (VT)" ],
       [ 4397, "S^4~S^1 (VT)" ], [ 4398, "S^4~S^1 (VT)" ],
       [ 4399, "S^4~S^1 (VT)" ], [ 4402, "S^4~S^1 (VT)" ],
       [ 4403, "S^4~S^1 (VT)" ], [ 4404, "S^4~S^1 (VT)" ], [ 7479, "S^4xS^2" ],
       [ 7539, "S^4xS^3" ], [ 7573, "S^4xS^4" ] ]
     gap> s:=SCLib.Load(last[1][1]);;
     gap> filled:=SCFillSphere(s);
     [SimplicialComplex

      Properties known: Dim, FacetsEx, Name, Vertices.

      Name="FilledSphere(S^4 (VT)) at vertex [ 1 ]"
      Dim=5

     /SimplicialComplex]
     gap> SCHomology(filled);
     [ [ 0, [  ] ], [ 0, [  ] ], [ 0, [  ] ], [ 0, [  ] ], [ 0, [  ] ],
       [ 0, [  ] ] ]
     gap> SCCollapseGreedy(filled);
     [SimplicialComplex

      Properties known: Dim, FVector, FacetsEx, IsPure, Name, NumFaces[],
                        SkelExs[], Vertices.

      Name="collapsed version of FilledSphere(S^4 (VT)) at vertex [ 1 ]"
      Dim=0
      FVector=[ 1 ]
      IsPure=true

     /SimplicialComplex]
     gap> bd:=SCBoundary(filled);;
     gap> bd=s;
     true

##### 6.10-7 SCHandleAddition

`‣ SCHandleAddition`( complex, f1, f2 ) | ( method )

Returns: simplicial complex of type `SCSimplicialComplex`, `fail` otherwise.

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) ≥ 3 for any two vertices v ∈f1 and w ∈f2, where d(⋅,⋅) 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

`‣ SCIntersection`( complex1, complex2 ) | ( method )

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

`‣ SCIsIsomorphic`( complex1, complex2 ) | ( method )

Returns: `true` or `false` upon success, `fail` otherwise.

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

`‣ SCIsSubcomplex`( sc1, sc2 ) | ( method )

Returns: `true` or `false` upon success, `fail` otherwise.

Returns `true` if the simplicial complex sc2 is a sub-complex of simplicial complex sc1, `false` otherwise. If dim(sc2) ≤ 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, "K^2 (VT)" ], [ 18, "T^2 (VT)" ], [ 19, "S^3 (VT)" ],
       [ 20, "(T^2)#2" ], [ 21, "S^3 (VT)" ], [ 22, "S^2xS^1 (VT)" ],
       [ 23, "S^3 (VT)" ], [ 24, "(T^2)#3" ], [ 25, "(P^2)#7 (VT)" ],
       [ 26, "S^3 (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

`‣ SCIsomorphism`( complex1, complex2 ) | ( method )

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. Internally calls `SCIsomorphismEx` (6.10-12).

     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

`‣ SCIsomorphismEx`( complex1, complex2 ) | ( method )

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

`‣ SCJoin`( complex1, complex2 ) | ( method )

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

      Properties known: Dim, FacetsEx, Name, Vertices.

      Name="S^1_3 join S^1_3"
      Dim=3

     /SimplicialComplex]
     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

      Properties known: Dim, FacetsEx, Name, Vertices.

      Name="unnamed complex 4 join S^1_3"
      Dim=2

     /SimplicialComplex]
     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

`‣ SCNeighbors`( complex, face ) | ( method )

Returns: a list of faces upon success, `fail` otherwise.

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

      Properties known: Dim, FacetsEx, Name, Vertices.

      Name="unnamed complex 22"
      Dim=1

     /SimplicialComplex]
     gap> SCNeighbors(c,["a","d"]);
     [ [ "a", "b" ], [ "a", "c" ] ]

##### 6.10-15 SCNeighborsEx

`‣ SCNeighborsEx`( complex, face ) | ( method )

Returns: a list of faces upon success, `fail` otherwise.

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 standard labeling.

     gap> c:=SCFromFacets(Combinations(["a","b","c"],2));
     [SimplicialComplex

      Properties known: Dim, FacetsEx, Name, Vertices.

      Name="unnamed complex 21"
      Dim=1

     /SimplicialComplex]
     gap> SCLabels(c);
     [ "a", "b", "c" ]
     gap> SCNeighborsEx(c,[1,2]);
     [ [ 1, 3 ], [ 2, 3 ] ]

##### 6.10-16 SCShelling

`‣ SCShelling`( complex ) | ( method )

Returns: a facet list or `false` upon success, `fail` otherwise.

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, ... , F_r) on the facet list of a simplicial complex is a shelling if and only if F_i ∩ (F_1 ∪ ... ∪ F_i-1) is a pure simplicial complex of dimension d-1 for all i = 1, ... , 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

`‣ SCShellingExt`( complex, all, checkvector ) | ( method )

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)).

An ordering (F_1, F_2, ... , F_r) on the facet list of a simplicial complex is a shelling if and only if F_i ∩ (F_1 ∪ ... ∪ F_i-1) is a pure simplicial complex of dimension d-1 for all i = 1, ... , r.

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.

See [Zie95], [Pac87] to learn more about shellings.

     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

`‣ SCShellings`( complex ) | ( method )

Returns: a list of facet lists upon success, `fail` otherwise.

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, ... , F_r) on the facet list of a simplicial complex is a shelling if and only if F_i ∩ (F_1 ∪ ... ∪ F_i-1) is a pure simplicial complex of dimension d-1 for all i = 1, ... , r.

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

`‣ SCSpan`( complex, subset ) | ( method )

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, 2, 3, 4, 5, 6, 7, 8 ]
     gap> span:=SCSpan(c,[1,2,3,4]);
     [SimplicialComplex

      Properties known: Dim, FacetsEx, Name, Vertices.

      Name="span([ 1, 2, 3, 4 ]) in Bd(\beta^4)"
      Dim=1

     /SimplicialComplex]
     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

      Properties known: Dim, FacetsEx, Name, Vertices.

      Name="span([ 2, 3, 5 ]) in unnamed complex 121"
      Dim=1

     /SimplicialComplex]
     gap> SCFacets(span);
     [ [ 2, 3 ], [ 5 ] ]

##### 6.10-20 SCSuspension

`‣ SCSuspension`( complex ) | ( method )

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");
     [ [ 7469, "Poincare_sphere" ] ]
     gap> phs:=SCLib.Load(last[1][1]);
     [SimplicialComplex

      Properties known: AltshulerSteinberg, AutomorphismGroup,
                        AutomorphismGroupSize, AutomorphismGroupStructure,
                        AutomorphismGroupTransitivity, ConnectedComponents,
                        Dim, DualGraph, EulerCharacteristic, FVector,
                        FacetsEx, GVector, GeneratorsEx, HVector,
                        HasBoundary, HasInterior, Homology, Interior,
                        IsCentrallySymmetric, IsConnected,
                        IsEulerianManifold, IsManifold, IsOrientable,
                        IsPseudoManifold, IsPure, IsStronglyConnected,
                        MinimalNonFacesEx, Name, Neighborliness,
                        NumFaces[], Orientation, SkelExs[], Vertices.

      Name="Poincare_sphere"
      Dim=3
      AltshulerSteinberg=115400413872363901952
      AutomorphismGroupSize=1
      AutomorphismGroupStructure="1"
      AutomorphismGroupTransitivity=0
      EulerCharacteristic=0
      FVector=[ 16, 106, 180, 90 ]
      GVector=[ 11, 52 ]
      HVector=[ 12, 64, 12, 1 ]
      HasBoundary=false
      HasInterior=true
      Homology=[ [ 0, [ ] ], [ 0, [ ] ], [ 0, [ ] ], [ 1, [ ] ] ]
      IsCentrallySymmetric=false
      IsConnected=true
      IsEulerianManifold=true
      IsOrientable=true
      IsPseudoManifold=true
      IsPure=true
      IsStronglyConnected=true
      Neighborliness=1

     /SimplicialComplex]
     gap> susp:=SCSuspension(phs);;
     gap> edwardsSphere:=SCSuspension(susp);
     [SimplicialComplex

      Properties known: Dim, FacetsEx, Name, Vertices.

      Name="susp of susp of Poincare_sphere"
      Dim=5

     /SimplicialComplex]

##### 6.10-21 SCUnion

`‣ SCUnion`( complex1, complex2 ) | ( method )

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

      Properties known: Dim, FacetsEx, Name, Vertices.

      Name="S^2_4 cup S^2_4"
      Dim=2

     /SimplicialComplex]

##### 6.10-22 SCVertexIdentification

`‣ SCVertexIdentification`( complex, v1, v2 ) | ( method )

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) ≥ 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

`‣ SCWedge`( complex1, complex2 ) | ( method )

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.

     gap> wedge:=SCWedge(SCBdSimplex(2),SCBdSimplex(2));
     [SimplicialComplex

      Properties known: Dim, FacetsEx, Name, Vertices.

      Name="unnamed complex 17"
      Dim=1

     /SimplicialComplex]
     gap> wedge.Facets;
     [ [ 1, [ 1, 2 ] ], [ 1, [ 1, 3 ] ], [ 1, [ 2, 2 ] ], [ 1, [ 2, 3 ] ],
       [ [ 1, 2 ], [ 1, 3 ] ], [ [ 2, 2 ], [ 2, 3 ] ] ]

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 Bib Ind

generated by GAPDoc2HTML