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.2 Isomorphism signatures
 6.3 Generating some standard triangulations
 6.4 Generating infinite series of transitive triangulations
 6.5 A census of regular and chiral maps
 6.6 Generating new complexes from old
 6.7 Simplicial complexes from transitive permutation groups
 6.8 The classification of cyclic combinatorial 3-manifolds
 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 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