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).
  
    Example  
     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).
  
    Example  
     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.
  
    Example  
     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).
  
    Example  
     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.
  
    Example  
     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"
     16
     
  
  
  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.
  
    Example  
     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.
  
    Example  
     gap> s:="deeee";;
     gap> c:=SCFromIsoSig(s);;
     gap> SCIsIsomorphic(c,SCBdSimplex(4));
     true
     
  
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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].
  
    Example  
     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
  
    Example  
     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"
     
  
  
    Example  
     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.
  
    Example  
    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.
  
    Example  
    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.
  
    Example  
     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.
  
    Example  
     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
     
  
  
    Example  
     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]
  
    Example  
     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).
  
    Example  
     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.
  
    Example  
     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).
  
    Example  
     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 ] ]
     
  
  
    Example  
     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].
  
    Example  
     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.
  
    Example  
     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).
  
    Example  
     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"
     
  
  
    Example  
     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).
  
    Example  
     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].
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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, 2 ], [ 1, 12 ], [ 2, 11 ], [ 11, 12 ] ]
     gap> SCCollapseGreedy(Mplus).Facets; 
     [ [ 7, 14 ], [ 7, 15 ], [ 8, 13 ], [ 8, 16 ], [ 13, 14 ], [ 15, 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).
  
    Example  
     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].
  
    Example  
     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.
  
    Example  
     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"
     
  
  
    Example  
     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.
  
    Example  
     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].
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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).
  
    Example  
     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.
  
    Example  
     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
     
  
  
    Example  
     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.
  
    Example  
     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
     
  
  
    Example  
     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).
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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
  '':''.
  
    Example  
     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
  '':''.
  
    Example  
     gap> c:=SCBdSimplex(5);;
     gap> SCAutomorphismGroupInternal(c);
     Sym( [ 1 .. 6 ] )
     
  
  
    Example  
     gap> c:=SC([[1,2],[2,3],[1,3]]);;
     gap> g:=SCAutomorphismGroupInternal(c);
     PrimitiveGroup(3,2) = S(3)
     gap> List(g);
     [ (), (1,3,2), (1,2,3), (2,3), (1,3), (1,2) ]
     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).
  
    Example  
     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).
  
    Example  
     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].
  
    Example  
     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.
  
    Example  
     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).
  
    Example  
     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).
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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).
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     gap> list:=SCLib.SearchByName("T^2");;
     gap> torus:=SCLib.Load(list[1][1]);;
     gap> SCGenerators(torus); 
     [ [ [ 1, 2, 4 ], 14 ] ]
     
  
  
    Example  
     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.
  
    Example  
     gap> list:=SCLib.SearchByName("T^2");;
     gap> torus:=SCLib.Load(list[1][1]);;
     gap> SCGeneratorsEx(torus); 
     [ [ [ 1, 2, 4 ], 14 ] ]
     
  
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     gap> SCLib.SearchByName("K^2"); 
     [ [ 17, "K^2 (VT)" ], [ 571, "K^2 (VT)" ] ]
     gap> kleinBottle:=SCLib.Load(last[1][1]);;
     gap> SCHasBoundary(kleinBottle);
     false
     
  
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     gap> c:=SCBdCrossPolytope(4);;
     gap> SCIsCentrallySymmetric(c);
     true
     
  
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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 connected simplicial complex of dimension at
  least  one is a flag complex if all cliques in its 1-skeleton span a face of
  the complex (cf. [Fro08]).
  
    Example  
     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);
     false
     
  
  
  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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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/1
     #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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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 ]
     
  
  
    Example  
     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.
  
    Example  
     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).
  
    Example  
     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!
  
    Example  
     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.
  
    Example  
     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).
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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).
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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, [  ] ] ]
     
  
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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].
  
    Example  
     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.
  
    Example  
     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].
  
    Example  
     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.
  
    Example  
     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 ] ]
     
  
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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.
  
    Example  
     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 ] ] ]