6 Functions and operations for

`SCSimplicialComplex`

6.4 Generating infinite series of transitive triangulations

6.4-1 SCSeriesAGL

6.4-2 SCSeriesBrehmKuehnelTorus

6.4-3 SCSeriesBdHandleBody

6.4-4 SCSeriesBid

6.4-5 SCSeriesC2n

6.4-6 SCSeriesConnectedSum

6.4-7 SCSeriesCSTSurface

6.4-8 SCSeriesD2n

6.4-9 SCSeriesHandleBody

6.4-10 SCSeriesHomologySphere

6.4-11 SCSeriesK

6.4-12 SCSeriesKu

6.4-13 SCSeriesL

6.4-14 SCSeriesLe

6.4-15 SCSeriesLensSpace

6.4-16 SCSeriesPrimeTorus

6.4-17 SCSeriesSeifertFibredSpace

6.4-18 SCSeriesS2xS2

6.4-1 SCSeriesAGL

6.4-2 SCSeriesBrehmKuehnelTorus

6.4-3 SCSeriesBdHandleBody

6.4-4 SCSeriesBid

6.4-5 SCSeriesC2n

6.4-6 SCSeriesConnectedSum

6.4-7 SCSeriesCSTSurface

6.4-8 SCSeriesD2n

6.4-9 SCSeriesHandleBody

6.4-10 SCSeriesHomologySphere

6.4-11 SCSeriesK

6.4-12 SCSeriesKu

6.4-13 SCSeriesL

6.4-14 SCSeriesLe

6.4-15 SCSeriesLensSpace

6.4-16 SCSeriesPrimeTorus

6.4-17 SCSeriesSeifertFibredSpace

6.4-18 SCSeriesS2xS2

6.9 Computing properties of simplicial complexes

6.9-1 SCAltshulerSteinberg

6.9-2 SCAutomorphismGroup

6.9-3 SCAutomorphismGroupInternal

6.9-4 SCAutomorphismGroupSize

6.9-5 SCAutomorphismGroupStructure

6.9-6 SCAutomorphismGroupTransitivity

6.9-7 SCBoundary

6.9-8 SCDehnSommervilleCheck

6.9-9 SCDehnSommervilleMatrix

6.9-10 SCDifferenceCycles

6.9-11 SCDim

6.9-12 SCDualGraph

6.9-13 SCEulerCharacteristic

6.9-14 SCFVector

6.9-15 SCFaceLattice

6.9-16 SCFaceLatticeEx

6.9-17 SCFaces

6.9-18 SCFacesEx

6.9-19 SCFacets

6.9-20 SCFacetsEx

6.9-21 SCFpBettiNumbers

6.9-22 SCFundamentalGroup

6.9-23 SCGVector

6.9-24 SCGenerators

6.9-25 SCGeneratorsEx

6.9-26 SCHVector

6.9-27 SCHasBoundary

6.9-28 SCHasInterior

6.9-29 SCHeegaardSplittingSmallGenus

6.9-30 SCHeegaardSplitting

6.9-31 SCHomologyClassic

6.9-32 SCIncidences

6.9-33 SCIncidencesEx

6.9-34 SCInterior

6.9-35 SCIsCentrallySymmetric

6.9-36 SCIsConnected

6.9-37 SCIsEmpty

6.9-38 SCIsEulerianManifold

6.9-39 SCIsFlag

6.9-40 SCIsHeegaardSplitting

6.9-41 SCIsHomologySphere

6.9-42 SCIsInKd

6.9-43 SCIsKNeighborly

6.9-44 SCIsOrientable

6.9-45 SCIsPseudoManifold

6.9-46 SCIsPure

6.9-47 SCIsShellable

6.9-48 SCIsStronglyConnected

6.9-49 SCMinimalNonFaces

6.9-50 SCMinimalNonFacesEx

6.9-51 SCNeighborliness

6.9-52 SCNumFaces

6.9-53 SCOrientation

6.9-54 SCSkel

6.9-55 SCSkelEx

6.9-56 SCSpanningTree

6.9-1 SCAltshulerSteinberg

6.9-2 SCAutomorphismGroup

6.9-3 SCAutomorphismGroupInternal

6.9-4 SCAutomorphismGroupSize

6.9-5 SCAutomorphismGroupStructure

6.9-6 SCAutomorphismGroupTransitivity

6.9-7 SCBoundary

6.9-8 SCDehnSommervilleCheck

6.9-9 SCDehnSommervilleMatrix

6.9-10 SCDifferenceCycles

6.9-11 SCDim

6.9-12 SCDualGraph

6.9-13 SCEulerCharacteristic

6.9-14 SCFVector

6.9-15 SCFaceLattice

6.9-16 SCFaceLatticeEx

6.9-17 SCFaces

6.9-18 SCFacesEx

6.9-19 SCFacets

6.9-20 SCFacetsEx

6.9-21 SCFpBettiNumbers

6.9-22 SCFundamentalGroup

6.9-23 SCGVector

6.9-24 SCGenerators

6.9-25 SCGeneratorsEx

6.9-26 SCHVector

6.9-27 SCHasBoundary

6.9-28 SCHasInterior

6.9-29 SCHeegaardSplittingSmallGenus

6.9-30 SCHeegaardSplitting

6.9-31 SCHomologyClassic

6.9-32 SCIncidences

6.9-33 SCIncidencesEx

6.9-34 SCInterior

6.9-35 SCIsCentrallySymmetric

6.9-36 SCIsConnected

6.9-37 SCIsEmpty

6.9-38 SCIsEulerianManifold

6.9-39 SCIsFlag

6.9-40 SCIsHeegaardSplitting

6.9-41 SCIsHomologySphere

6.9-42 SCIsInKd

6.9-43 SCIsKNeighborly

6.9-44 SCIsOrientable

6.9-45 SCIsPseudoManifold

6.9-46 SCIsPure

6.9-47 SCIsShellable

6.9-48 SCIsStronglyConnected

6.9-49 SCMinimalNonFaces

6.9-50 SCMinimalNonFacesEx

6.9-51 SCNeighborliness

6.9-52 SCNumFaces

6.9-53 SCOrientation

6.9-54 SCSkel

6.9-55 SCSkelEx

6.9-56 SCSpanningTree

6.10 Operations on simplicial complexes

6.10-1 SCAlexanderDual

6.10-2 SCClose

6.10-3 SCCone

6.10-4 SCDeletedJoin

6.10-5 SCDifference

6.10-6 SCFillSphere

6.10-7 SCHandleAddition

6.10-8 SCIntersection

6.10-9 SCIsIsomorphic

6.10-10 SCIsSubcomplex

6.10-11 SCIsomorphism

6.10-12 SCIsomorphismEx

6.10-13 SCJoin

6.10-14 SCNeighbors

6.10-15 SCNeighborsEx

6.10-16 SCShelling

6.10-17 SCShellingExt

6.10-18 SCShellings

6.10-19 SCSpan

6.10-20 SCSuspension

6.10-21 SCUnion

6.10-22 SCVertexIdentification

6.10-23 SCWedge

6.10-1 SCAlexanderDual

6.10-2 SCClose

6.10-3 SCCone

6.10-4 SCDeletedJoin

6.10-5 SCDifference

6.10-6 SCFillSphere

6.10-7 SCHandleAddition

6.10-8 SCIntersection

6.10-9 SCIsIsomorphic

6.10-10 SCIsSubcomplex

6.10-11 SCIsomorphism

6.10-12 SCIsomorphismEx

6.10-13 SCJoin

6.10-14 SCNeighbors

6.10-15 SCNeighborsEx

6.10-16 SCShelling

6.10-17 SCShellingExt

6.10-18 SCShellings

6.10-19 SCSpan

6.10-20 SCSuspension

6.10-21 SCUnion

6.10-22 SCVertexIdentification

6.10-23 SCWedge

`SCSimplicialComplex`

`SCSimplicialComplex`

object from a facet listThis 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.

`‣ SCFromFacets` ( facets ) | ( method ) |

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

Constructs a simplicial complex object from the given facet list. The facet list `facets` has to be a duplicate free list (or set) which consists of duplicate free entries, which are in turn lists or sets. For the vertex labels (i. e. the entries of the list items of `facets`) an ordering via the less-operator has to be defined. Following Section 4.11 of the **GAP** manual this is the case for objects of the following families: rationals `IsRat`

, cyclotomics `IsCyclotomic`

, finite field elements `IsFFE`

, permutations `IsPerm`

, booleans `IsBool`

, characters `IsChar`

and lists (strings) `IsList`

.

Internally the vertices are mapped to the standard labeling 1..n, where n is the number of vertices of the complex and the vertex labels of the original complex are stored in the property ''VertexLabels'', see `SCLabels`

(4.2-3) and the `SCRelabel..`

functions like `SCRelabel`

(4.2-6) or `SCRelabelStandard`

(4.2-7).

gap> c:=SCFromFacets([[1,2,5], [1,4,5], [1,4,6], [2,3,5], [3,4,6], [3,5,6]]); [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="unnamed complex 9" Dim=2 /SimplicialComplex] gap> c:=SCFromFacets([["a","b","c"], ["a","b",1], ["a","c",1], ["b","c",1]]); [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="unnamed complex 10" Dim=2 /SimplicialComplex]

`‣ SC` ( facets ) | ( method ) |

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

A shorter function to create a simplicial complex from a facet list, just calls `SCFromFacets`

(6.1-1)(`facets`).

gap> c:=SC(Combinations([1..6],5)); [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="unnamed complex 11" Dim=4 /SimplicialComplex]

`‣ SCFromDifferenceCycles` ( diffcycles ) | ( method ) |

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

Creates a simplicial complex object from the list of difference cycles provided. If `diffcycles` is of length 1 the computation is equivalent to the one in `SCDifferenceCycleExpand`

(6.6-8). Otherwise the induced modulus (the sum of all entries of a difference cycle) of all cycles has to be equal and the union of all expanded difference cycles is returned.

A n-dimensional difference cycle D = (d_1 : ... : d_n+1) induces a simplex ∆ = ( v_1 , ... , v_n+1 ) by v_1 = d_1, v_i = v_i-1 + d_i and a cyclic group action by Z_σ where σ = ∑ d_i is the modulus of D. The function returns the Z_σ-orbit of ∆.

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

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

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

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

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

and `SCFromFacets`

(6.1-1).

gap> #group: AGL(1,7) of order 42 gap> G:=Group([(2,6,5,7,3,4),(1,3,5,7,2,4,6)]);; gap> c:=SCFromGenerators(G,[[ 1, 2, 4 ]]); [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="complex from generators under unknown group" Dim=2 /SimplicialComplex] gap> SCLib.DetermineTopologicalType(c); [SimplicialComplex Properties known: BoundaryEx, Dim, FacetsEx, HasBoundary, IsPseudoManifold, IsPure, Name, SkelExs[], Vertices. Name="complex from generators under unknown group" Dim=2 HasBoundary=false IsPseudoManifold=true IsPure=true /SimplicialComplex]

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.

`‣ SCExportToString` ( c ) | ( function ) |

Returns: string upon success, `fail`

otherwise.

Computes one string representation of a closed and strongly connected weak pseudomanifold. Compare `SCExportIsoSig`

(6.2-2), which returns the lexicographically minimal string representation.

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

`‣ SCExportIsoSig` ( c ) | ( method ) |

Returns: string upon success, `fail`

otherwise.

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

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

`‣ SCFromIsoSig` ( str ) | ( method ) |

Returns: a SCSimplicialComplex object upon success, `fail`

otherwise.

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

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

gap> s:="deeee";; gap> PrintTo("tmp.txt",s,"\n");; gap> cc:=SCFromIsoSig("tmp.txt"); [ [SimplicialComplex Properties known: Dim, ExportIsoSig, FacetsEx, Name, Vertices. Name="unnamed complex 7" Dim=3 /SimplicialComplex] ] gap> cc[1].F; [ 5, 10, 10, 5 ]

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

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

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

gap> SCBdCyclicPolytope(3,8); [SimplicialComplex Properties known: Dim, EulerCharacteristic, FacetsEx, HasBoundary, Homology, IsConnected, IsStronglyConnected, Name, NumFaces[], TopologicalType, Vertices. Name="Bd(C_3(8))" Dim=2 EulerCharacteristic=2 HasBoundary=false Homology=[ [ 0, [ ] ], [ 0, [ ] ], [ 1, [ ] ] ] IsConnected=true IsStronglyConnected=true TopologicalType="S^2" /SimplicialComplex]

`‣ SCBdSimplex` ( d ) | ( function ) |

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

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

gap> SCBdSimplex(5); [SimplicialComplex Properties known: AutomorphismGroup, AutomorphismGroupSize, AutomorphismGroupStructure, AutomorphismGroupTransitivity, Dim, EulerCharacteristic, FacetsEx, GeneratorsEx, HasBoundary, Homology, IsConnected, IsStronglyConnected, Name, NumFaces[], TopologicalType, Vertices. Name="S^4_6" Dim=4 AutomorphismGroupSize=720 AutomorphismGroupStructure="S6" AutomorphismGroupTransitivity=6 EulerCharacteristic=2 HasBoundary=false Homology=[ [ 0, [ ] ], [ 0, [ ] ], [ 0, [ ] ], [ 0, [ ] ], [ 1, [ ] ] ] IsConnected=true IsStronglyConnected=true TopologicalType="S^4" /SimplicialComplex]

`‣ SCEmpty` ( ) | ( function ) |

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

Generates an empty complex (of dimension -1), i. e. a `SCSimplicialComplex`

object with empty facet list.

gap> SCEmpty(); [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="empty complex" Dim=-1 /SimplicialComplex]

`‣ SCSimplex` ( d ) | ( function ) |

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

Generates the `d`-simplex.

gap> SCSimplex(3); [SimplicialComplex Properties known: Dim, EulerCharacteristic, FacetsEx, Name, NumFaces[], TopologicalType, Vertices. Name="B^3_4" Dim=3 EulerCharacteristic=1 TopologicalType="B^3" /SimplicialComplex]

`‣ SCSeriesTorus` ( d ) | ( function ) |

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

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

gap> t4:=SCSeriesTorus(4); [SimplicialComplex Properties known: DifferenceCycles, Dim, FacetsEx, Name, TopologicalType, Vertices. Name="4-torus T^4" Dim=4 TopologicalType="T^4" /SimplicialComplex] gap> t4.Homology; [ [ 0, [ ] ], [ 4, [ ] ], [ 6, [ ] ], [ 4, [ ] ], [ 1, [ ] ] ]

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

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

Generates the surface of genus `g` where the boolean argument `orient` specifies whether the surface is orientable or not. The surfaces have transitive cyclic group actions and can be described using the minimum amount of O(operatornamelog (g)) memory. If `orient` is `true`

and `g`≥ 50 or if `orient` is `false`

and `g`≥ 100 only the difference cycles of the surface are returned

gap> c:=SCSurface(23,true); [SimplicialComplex Properties known: DifferenceCycles, Dim, FacetsEx, Name, TopologicalType, Vertices. Name="S_23^or" Dim=2 TopologicalType="(T^2)^#23" /SimplicialComplex] gap> c.Homology; [ [ 0, [ ] ], [ 46, [ ] ], [ 1, [ ] ] ] gap> c.TopologicalType; "(T^2)^#23" gap> c:=SCSurface(23,false); [SimplicialComplex Properties known: DifferenceCycles, Dim, FacetsEx, Name, TopologicalType, Vertices. Name="S_23^non" Dim=2 TopologicalType="(RP^2)^#23" /SimplicialComplex] gap> c.Homology; [ [ 0, [ ] ], [ 22, [ 2 ] ], [ 0, [ ] ] ] gap> c.TopologicalType; "(RP^2)^#23"

gap> dc:=SCSurface(345,true); [ [ 1, 1, 1374 ], [ 2, 343, 1031 ], [ 343, 345, 688 ] ] gap> c:=SCFromDifferenceCycles(dc); [SimplicialComplex Properties known: DifferenceCycles, Dim, FacetsEx, Name, Vertices. Name="complex from diffcycles [ [ 1, 1, 1374 ], [ 2, 343, 1031 ], [ 343, 345,\ 688 ] ]" Dim=2 /SimplicialComplex] gap> c.Chi; -688 gap> dc:=SCSurface(12345678910,true); time; [ [ 1, 1, 24691357816 ], [ 2, 4, 24691357812 ], [ 3, 3, 24691357812 ], [ 4, 12345678907, 12345678907 ] ] 0

`‣ SCFVectorBdCrossPolytope` ( d ) | ( function ) |

Returns: a list of integers of size `d + 1`

upon success, `fail`

otherwise.

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

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

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

Returns: a list of integers of size `d+1`

upon success, `fail`

otherwise.

Computes the f-vector of the `d`-dimensional cyclic polytope on `n` vertices, n≥ d+2, without generating the underlying complex.

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

`‣ SCFVectorBdSimplex` ( d ) | ( function ) |

Returns: a list of integers of size `d + 1`

upon success, `fail`

otherwise.

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

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

`‣ SCSeriesAGL` ( p ) | ( function ) |

Returns: a permutation group and a list of 5-tuples of integers upon success, `fail`

otherwise.

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

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

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

`‣ SCSeriesBrehmKuehnelTorus` ( n ) | ( function ) |

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

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

gap> T3:=SCSeriesBrehmKuehnelTorus(15); [SimplicialComplex Properties known: DifferenceCycles, Dim, FacetsEx, Name, TopologicalType, Vertices. Name="Neighborly 3-Torus NT3(15)" Dim=3 TopologicalType="T^3" /SimplicialComplex] gap> T3.Homology; [ [ 0, [ ] ], [ 3, [ ] ], [ 3, [ ] ], [ 1, [ ] ] ] gap> T3.Neighborliness; 2 gap> T3:=SCSeriesBrehmKuehnelTorus(16); [SimplicialComplex Properties known: DifferenceCycles, Dim, FacetsEx, Name, TopologicalType, Vertices. Name="Centrally symmetric 3-Torus SCT3(16)" Dim=3 TopologicalType="T^3" /SimplicialComplex] gap> T3.Homology; [ [ 0, [ ] ], [ 3, [ ] ], [ 3, [ ] ], [ 1, [ ] ] ] gap> T3.IsCentrallySymmetric; true

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

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

`SCSeriesBdHandleBody(d,n)`

generates a transitive d-dimensional sphere bundle (d ≥ 2) with n vertices (n ≥ 2d + 3) which coincides with the boundary of `SCSeriesHandleBody`

(6.4-9)`(d,n)`

. The sphere bundle is orientable if d is even or if d is odd and n is even, otherwise it is not orientable. Internally calls `SCFromDifferenceCycles`

(6.1-3).

gap> c:=SCSeriesBdHandleBody(2,7); [SimplicialComplex Properties known: Dim, FacetsEx, IsOrientable, Name, TopologicalType, Vertices. Name="Sphere bundle S^1 x S^1" Dim=2 IsOrientable=true TopologicalType="S^1 x S^1" /SimplicialComplex] gap> SCLib.DetermineTopologicalType(c); [SimplicialComplex Properties known: BoundaryEx, Dim, FacetsEx, HasBoundary, IsOrientable, IsPseudoManifold, IsPure, Name, SkelExs[], TopologicalType, Vertices. Name="Sphere bundle S^1 x S^1" Dim=2 HasBoundary=false IsOrientable=true IsPseudoManifold=true IsPure=true TopologicalType="S^1 x S^1" /SimplicialComplex] gap> SCIsIsomorphic(c,SCSeriesHandleBody(3,7).Boundary); true

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

Returns: a simplicial complex upon success, `fail`

otherwise.

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

gap> b26:=SCSeriesBid(2,6); [SimplicialComplex Properties known: Dim, FacetsEx, Name, Reference, Vertices. Name="B(2,6)" Dim=5 /SimplicialComplex] gap> s2s2:=SCBoundary(b26); [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="Bd(B(2,6))" Dim=4 /SimplicialComplex] gap> SCFVector(s2s2); [ 12, 60, 160, 180, 72 ] gap> SCAutomorphismGroup(s2s2); TransitiveGroup(12,28) = D(4)[x]S(3) gap> SCIsManifold(s2s2); true gap> SCHomology(s2s2); [ [ 0, [ ] ], [ 0, [ ] ], [ 2, [ ] ], [ 0, [ ] ], [ 1, [ ] ] ]

`‣ SCSeriesC2n` ( n ) | ( function ) |

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

Generates the combinatorial 3-manifold C_2n, n ≥ 8, with 2n vertices from [Spr11a], Section 4.5.3 and Section 5.2. The complex is homeomorphic to S^2 × S^1 for n odd and homeomorphic to S^2 dtimes S^1 in case n is an even number. In the latter case C_2n is isomorphic to D_2n from `SCSeriesD2n`

(6.4-8). The complexes are believed to appear as the vertex links of some of the members of the series of 2-transitive 4-pseudomanifolds from `SCSeriesAGL`

(6.4-1). Internally calls `SCFromDifferenceCycles`

(6.1-3).

gap> c:=SCSeriesC2n(8); [SimplicialComplex Properties known: DifferenceCycles, Dim, FacetsEx, Name, TopologicalType, Vertices. Name="C_16 = { (1:1:3:11),(1:1:11:3),(1:3:1:11),(2:3:2:9),(2:5:2:7) }" Dim=3 TopologicalType="S^2 ~ S^1" /SimplicialComplex] gap> SCGenerators(c); [ [ [ 1, 2, 3, 6 ], 32 ], [ [ 1, 2, 5, 6 ], 16 ], [ [ 1, 3, 6, 8 ], 16 ], [ [ 1, 3, 8, 10 ], 16 ] ]

gap> c:=SCSeriesC2n(8);; gap> d:=SCSeriesD2n(8); [SimplicialComplex Properties known: DifferenceCycles, Dim, FacetsEx, Name, TopologicalType, Vertices. Name="D_16 = { (1:1:1:13),(1:2:11:2),(3:4:5:4),(2:3:4:7),(2:7:4:3) }" Dim=3 TopologicalType="S^2 ~ S^1" /SimplicialComplex] gap> SCIsIsomorphic(c,d); true gap> c:=SCSeriesC2n(11);; gap> d:=SCSeriesD2n(11);; gap> c.Homology; [ [ 0, [ ] ], [ 1, [ ] ], [ 1, [ ] ], [ 1, [ ] ] ] gap> d.Homology; [ [ 0, [ ] ], [ 1, [ ] ], [ 0, [ 2 ] ], [ 0, [ ] ] ]

`‣ SCSeriesConnectedSum` ( k ) | ( function ) |

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

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

gap> c:=SCSeriesConnectedSum(12); [SimplicialComplex Properties known: DifferenceCycles, Dim, FacetsEx, Name, TopologicalType, Vertices. Name="(S^2xS^1)^#12)" Dim=3 TopologicalType="(S^2xS^1)^#12)" /SimplicialComplex] gap> c.Homology; [ [ 0, [ ] ], [ 12, [ ] ], [ 12, [ ] ], [ 1, [ ] ] ] gap> g:=SimplifiedFpGroup(SCFundamentalGroup(c)); <fp group of size infinity on the generators [ [2,3], [2,14], [3,4], [6,7], [9,10], [10,11], [11,12], [12,13], [26,32], [26,34], [29,31], [33,35] ]> gap> RelatorsOfFpGroup(g); [ ]

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

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

`SCSeriesCSTSurface(l,j,2k)`

generates the centrally symmetric transitive (cst) surface S_(l,j,2k), `SCSeriesCSTSurface(l,2k)`

generates the cst surface S_(l,2k) from [Spr12], Section 4.4.

gap> SCSeriesCSTSurface(2,4,14); [SimplicialComplex Properties known: DifferenceCycles, Dim, FacetsEx, Name, Vertices. Name="cst surface S_{(2,4,14)} = { (2:4:8),(2:8:4) }" Dim=2 /SimplicialComplex] gap> last.Homology; [ [ 1, [ ] ], [ 4, [ ] ], [ 2, [ ] ] ] gap> SCSeriesCSTSurface(2,10); [SimplicialComplex Properties known: DifferenceCycles, Dim, FacetsEx, Name, Vertices. Name="cst surface S_{(2,10)} = { (2:2:6),(3:3:4) }" Dim=2 /SimplicialComplex] gap> last.Homology; [ [ 0, [ ] ], [ 1, [ 2 ] ], [ 0, [ ] ] ]

`‣ SCSeriesD2n` ( n ) | ( function ) |

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

Generates the combinatorial 3-manifold D_2n, n ≥ 8, n ≠ 9, with 2n vertices from [Spr11a], Section 4.5.3 and Section 5.2. The complex is homeomorphic to S^2 dtimes S^1. In the case that n is even D_2n is isomorphic to C_2n from `SCSeriesC2n`

(6.4-5). The complexes are believed to appear as the vertex links of some of the members of the series of 2-transitive 4-pseudomanifolds from `SCSeriesAGL`

(6.4-1). Internally calls `SCFromDifferenceCycles`

(6.1-3).

gap> d:=SCSeriesD2n(15); [SimplicialComplex Properties known: DifferenceCycles, Dim, FacetsEx, Name, TopologicalType, Vertices. Name="D_30 = { (1:1:1:27),(1:2:25:2),(3:11:5:11),(2:3:11:14),(2:14:11:3) }" Dim=3 TopologicalType="S^2 ~ S^1" /SimplicialComplex] gap> SCAutomorphismGroup(d); TransitiveGroup(30,14) = t30n14 gap> StructureDescription(last); "D60"

gap> c:=SCSeriesC2n(8);; gap> d:=SCSeriesD2n(8); [SimplicialComplex Properties known: DifferenceCycles, Dim, FacetsEx, Name, TopologicalType, Vertices. Name="D_16 = { (1:1:1:13),(1:2:11:2),(3:4:5:4),(2:3:4:7),(2:7:4:3) }" Dim=3 TopologicalType="S^2 ~ S^1" /SimplicialComplex] gap> SCIsIsomorphic(c,d); true gap> c:=SCSeriesC2n(11);; gap> d:=SCSeriesD2n(11);; gap> c.Homology; [ [ 0, [ ] ], [ 1, [ ] ], [ 1, [ ] ], [ 1, [ ] ] ] gap> d.Homology; [ [ 0, [ ] ], [ 1, [ ] ], [ 0, [ 2 ] ], [ 0, [ ] ] ]

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

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

`SCSeriesHandleBody(d,n)`

generates a transitive d-dimensional handle body (d ≥ 3) with n vertices (n ≥ 2d + 1). The handle body is orientable if d is odd or if d and n are even, otherwise it is not orientable. The complex equals the difference cycle (1 : ... : 1 : n-d) To obtain the boundary complexes of `SCSeriesHandleBody(d,n)`

use the function `SCSeriesBdHandleBody`

(6.4-3). Internally calls `SCFromDifferenceCycles`

(6.1-3).

gap> c:=SCSeriesHandleBody(3,7); [SimplicialComplex Properties known: DifferenceCycles, Dim, FacetsEx, IsOrientable, Name, TopologicalType, Vertices. Name="Handle body B^2 x S^1" Dim=3 IsOrientable=true TopologicalType="B^2 x S^1" /SimplicialComplex] gap> SCAutomorphismGroup(c); PrimitiveGroup(7,2) = D(2*7) gap> bd:=SCBoundary(c);; gap> SCAutomorphismGroup(bd); PrimitiveGroup(7,4) = AGL(1, 7) gap> SCIsIsomorphic(bd,SCSeriesBdHandleBody(2,7)); true

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

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

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

gap> c:=SCSeriesHomologySphere(2,3,5); [SimplicialComplex Properties known: DifferenceCycles, Dim, FacetsEx, Name, TopologicalType, Vertices. Name="Homology sphere Sigma(2,3,5)" Dim=3 TopologicalType="Sigma(2,3,5)" /SimplicialComplex] gap> c.Homology; [ [ 0, [ ] ], [ 0, [ ] ], [ 0, [ ] ], [ 1, [ ] ] ] gap> c:=SCSeriesHomologySphere(3,4,13); [SimplicialComplex Properties known: DifferenceCycles, Dim, FacetsEx, Name, TopologicalType, Vertices. Name="Homology sphere Sigma(3,4,13)" Dim=3 TopologicalType="Sigma(3,4,13)" /SimplicialComplex] gap> c.Homology; [ [ 0, [ ] ], [ 0, [ ] ], [ 0, [ ] ], [ 1, [ ] ] ]

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

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

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

(6.4-13) for a list of series of order 2.

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

`‣ SCSeriesKu` ( n ) | ( function ) |

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

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

gap> c:=SCSeriesKu(4); [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="Sl_16 = G{ [1,2,5,9],[1,2,9,10],[1,5,9,16] }" Dim=3 /SimplicialComplex] gap> SCSlicing(c,[[1,2,3,4,9,10,11,12],[5,6,7,8,13,14,15,16]]); [NormalSurface Properties known: ConnectedComponents, Dim, EulerCharacteristic, FVector, Fac\ etsEx, Genus, IsConnected, IsOrientable, NSTriangulation, Name, TopologicalTyp\ e, Vertices. Name="slicing [ [ 1, 2, 3, 4, 9, 10, 11, 12 ], [ 5, 6, 7, 8, 13, 14, 15, 16 ]\ ] of Sl_16 = G{ [1,2,5,9],[1,2,9,10],[1,5,9,16] }" Dim=2 FVector=[ 32, 80, 32, 16 ] EulerCharacteristic=0 IsOrientable=true TopologicalType="T^2" /NormalSurface] gap> Mminus:=SCSpan(c,[1,2,3,4,9,10,11,12]);; gap> Mplus:=SCSpan(c,[5,6,7,8,13,14,15,16]);; gap> SCCollapseGreedy(Mminus).Facets; [ [ 1, 9 ], [ 1, 10 ], [ 3, 10 ], [ 3, 11 ], [ 4, 9 ], [ 4, 12 ], [ 11, 12 ] ] gap> SCCollapseGreedy(Mplus).Facets; [ [ 5, 8 ], [ 5, 16 ], [ 6, 14 ], [ 6, 15 ], [ 8, 15 ], [ 13, 14 ], [ 13, 16 ] ]

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

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

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

(6.4-11).

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

`‣ SCSeriesLe` ( k ) | ( function ) |

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

Generates the `k`-th member (k ≥ 7) of the series `Le`

from [Spr11a], Section 4.5.1. The series can be constructed as the generalization of the boundary of a genus 1 handlebody decomposition of the manifold `manifold_3_14_1_5`

from the classification in [Lut03].

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

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

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

Generates the lens space L(p,q) whenever p = (k+2)^2-1 and q = k+2 or p = 2k+3 and q = 1 for a k ≥ 0 and `fail`

otherwise. All complexes have a transitive cyclic automorphism group.

gap> l154:=SCSeriesLensSpace(15,4); [SimplicialComplex Properties known: DifferenceCycles, Dim, FacetsEx, Name, TopologicalType, Vertices. Name="Lens space L(15,4)" Dim=3 TopologicalType="L(15,4)" /SimplicialComplex] gap> l154.Homology; [ [ 0, [ ] ], [ 0, [ 15 ] ], [ 0, [ ] ], [ 1, [ ] ] ] gap> g:=SimplifiedFpGroup(SCFundamentalGroup(l154)); <fp group on the generators [ [2,5] ]> gap> StructureDescription(g); "C15"

gap> l151:=SCSeriesLensSpace(15,1); [SimplicialComplex Properties known: DifferenceCycles, Dim, FacetsEx, Name, TopologicalType, Vertices. Name="Lens space L(15,1)" Dim=3 TopologicalType="L(15,1)" /SimplicialComplex] gap> l151.Homology; [ [ 0, [ ] ], [ 0, [ 15 ] ], [ 0, [ ] ], [ 1, [ ] ] ] gap> g:=SimplifiedFpGroup(SCFundamentalGroup(l151)); <fp group on the generators [ [2,3] ]> gap> StructureDescription(g); "C15"

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

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

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

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

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

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

Generates a combinatorial Seifert fibred space of type

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

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

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

This 3-parameter family of combinatorial 3-manifolds contains the families generated by `SCSeriesHomologySphere`

(6.4-10), `SCSeriesConnectedSum`

(6.4-6) and parts of `SCSeriesLensSpace`

(6.4-15), internally calls `SCIntFunc.SeifertFibredSpace(p,q,r)`

. The complexes are combinatorial 3-manifolds with transitive cyclic symmetry as described in [BS14].

gap> c:=SCSeriesSeifertFibredSpace(2,3,15); [SimplicialComplex Properties known: DifferenceCycles, Dim, FacetsEx, Name, TopologicalType, Vertices. Name="SFS [ S^2 : (2,b1)^3, (5,b3) ]" Dim=3 TopologicalType="SFS [ S^2 : (2,b1)^3, (5,b3) ]" /SimplicialComplex] gap> c.Homology; [ [ 0, [ ] ], [ 0, [ 2, 2 ] ], [ 0, [ ] ], [ 1, [ ] ] ]

`‣ SCSeriesS2xS2` ( k ) | ( function ) |

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

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

gap> c:=SCSeriesS2xS2(3); [SimplicialComplex Properties known: DifferenceCycles, Dim, FacetsEx, Name, TopologicalType, Vertices. Name="(S^2 x S^2)^(# 3)" Dim=4 TopologicalType="(S^2 x S^2)^(# 3)" /SimplicialComplex] gap> c.Homology; [ [ 0, [ ] ], [ 0, [ ] ], [ 6, [ ] ], [ 0, [ ] ], [ 1, [ ] ] ]

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

Returns: a `SCSimplicialComplex`

object upon success, `fail`

otherwise.

Returns the (hyperbolic) chiral map of vertex valence `m` and genus `g` if existent and `fail`

otherwise. The list was generated with the help of the classification of regular maps by Marston Conder [Con09]. Use `SCChiralMaps`

(6.5-2) to get a list of all chiral maps available.

gap> SCChiralMaps(); [ [ 7, 17 ], [ 8, 10 ], [ 8, 28 ], [ 8, 37 ], [ 8, 46 ], [ 8, 82 ], [ 9, 43 ], [ 10, 73 ], [ 12, 22 ], [ 12, 33 ], [ 12, 40 ], [ 12, 51 ], [ 12, 58 ], [ 12, 64 ], [ 12, 85 ], [ 12, 94 ], [ 12, 97 ], [ 18, 28 ] ] gap> c:=SCChiralMap(8,10); [SimplicialComplex Properties known: Dim, FacetsEx, Name, TopologicalType, Vertices. Name="Chiral map {8,10}" Dim=2 TopologicalType="(T^2)^#10" /SimplicialComplex] gap> c.Homology; [ [ 0, [ ] ], [ 20, [ ] ], [ 1, [ ] ] ]

`‣ SCChiralMaps` ( ) | ( function ) |

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

otherwise.

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

(6.5-1) to get the corresponding triangulations.

gap> ll:=SCChiralMaps(); [ [ 7, 17 ], [ 8, 10 ], [ 8, 28 ], [ 8, 37 ], [ 8, 46 ], [ 8, 82 ], [ 9, 43 ], [ 10, 73 ], [ 12, 22 ], [ 12, 33 ], [ 12, 40 ], [ 12, 51 ], [ 12, 58 ], [ 12, 64 ], [ 12, 85 ], [ 12, 94 ], [ 12, 97 ], [ 18, 28 ] ] gap> c:=SCChiralMap(ll[18][1],ll[18][2]); [SimplicialComplex Properties known: Dim, FacetsEx, Name, TopologicalType, Vertices. Name="Chiral map {18,28}" Dim=2 TopologicalType="(T^2)^#28" /SimplicialComplex] gap> SCHomology(c); [ [ 0, [ ] ], [ 56, [ ] ], [ 1, [ ] ] ]

`‣ SCChiralTori` ( n ) | ( function ) |

Returns: a `SCSimplicialComplex`

object upon success, `fail`

otherwise.

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

gap> cc:=SCChiralTori(91); [ [SimplicialComplex Properties known: AutomorphismGroup, Dim, FacetsEx, Name, TopologicalType, Vertices. Name="{3,6}_(9,1)" Dim=2 TopologicalType="T^2" /SimplicialComplex], [SimplicialComplex Properties known: AutomorphismGroup, Dim, FacetsEx, Name, TopologicalType, Vertices. Name="{3,6}_(6,5)" Dim=2 TopologicalType="T^2" /SimplicialComplex] ] gap> SCIsIsomorphic(cc[1],cc[2]); false

`‣ SCNrChiralTori` ( n ) | ( function ) |

Returns: an integer upon success, `fail`

otherwise.

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

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

`‣ SCNrRegularTorus` ( n ) | ( function ) |

Returns: an integer upon success, `fail`

otherwise.

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

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

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

Returns: a `SCSimplicialComplex`

object upon success, `fail`

otherwise.

Returns the (hyperbolic) regular map of vertex valence `m`, genus `g` and orientability `orient` if existent and `fail`

otherwise. The triangulations were generated with the help of the classification of regular maps by Marston Conder [Con09]. Use `SCRegularMaps`

(6.5-7) to get a list of all regular maps available.

gap> SCRegularMaps(){[1..10]}; [ [ 7, 3, true ], [ 7, 7, true ], [ 7, 8, false ], [ 7, 14, true ], [ 7, 15, false ], [ 7, 147, false ], [ 8, 3, true ], [ 8, 5, true ], [ 8, 8, true ], [ 8, 9, false ] ] gap> c:=SCRegularMap(7,7,true); [SimplicialComplex Properties known: Dim, FacetsEx, Name, TopologicalType, Vertices. Name="Orientable regular map {7,7}" Dim=2 TopologicalType="(T^2)^#7" /SimplicialComplex] gap> g:=SCAutomorphismGroup(c); #I group not listed C2 x PSL(2,8) gap> Size(g); 1008

`‣ SCRegularMaps` ( ) | ( function ) |

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

otherwise.

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

(6.5-6) to get the corresponding triangulations. g

gap> ll:=SCRegularMaps(){[1..10]}; [ [ 7, 3, true ], [ 7, 7, true ], [ 7, 8, false ], [ 7, 14, true ], [ 7, 15, false ], [ 7, 147, false ], [ 8, 3, true ], [ 8, 5, true ], [ 8, 8, true ], [ 8, 9, false ] ] gap> c:=SCRegularMap(ll[5][1],ll[5][2],ll[5][3]); [SimplicialComplex Properties known: Dim, FacetsEx, Name, TopologicalType, Vertices. Name="Non-orientable regular map {7,15}" Dim=2 TopologicalType="(RP^2)^#15" /SimplicialComplex] gap> SCHomology(c); [ [ 0, [ ] ], [ 14, [ 2 ] ], [ 0, [ ] ] ] gap> SCGenerators(c); [ [ [ 1, 4, 7 ], 182 ] ]

`‣ SCRegularTorus` ( n ) | ( function ) |

Returns: a `SCSimplicialComplex`

object upon success, `fail`

otherwise.

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

gap> cc:=SCRegularTorus(9); [ [SimplicialComplex Properties known: AutomorphismGroup, Dim, FacetsEx, Name, TopologicalType, Vertices. Name="{3,6}_(3,0)" Dim=2 TopologicalType="T^2" /SimplicialComplex] ] gap> g:=SCAutomorphismGroup(cc[1]); Group([ (2,7)(3,4)(5,9), (1,4,2)(3,7,9)(5,8,6), (2,8,7,3,6,4)(5,9) ]) gap> SCNumFaces(cc[1],0)*12 = Size(g); true

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

Returns: a `SCSimplicialComplex`

object upon success, `fail`

otherwise.

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

gap> c:=SCSeriesSymmetricTorus(2,1); [SimplicialComplex Properties known: AutomorphismGroup, Dim, FacetsEx, Name, TopologicalType, Vertices. Name="{3,6}_(2,1)" Dim=2 TopologicalType="T^2" /SimplicialComplex] gap> SCFVector(c); [ 7, 21, 14 ]

See also `SCSurface`

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

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

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

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

gap> c:=SCBdSimplex(2);; gap> 4torus:=SCCartesianPower(c,4); [SimplicialComplex Properties known: Dim, FacetsEx, Name, TopologicalType, Vertices. Name="(S^1_3)^4" Dim=4 TopologicalType="(S^1)^4" /SimplicialComplex] gap> 4torus.Homology; [ [ 0, [ ] ], [ 4, [ ] ], [ 6, [ ] ], [ 4, [ ] ], [ 1, [ ] ] ] gap> 4torus.Chi; 0 gap> 4torus.F; [ 81, 1215, 4050, 4860, 1944 ]

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

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

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

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

gap> c1:=SCBdSimplex(2);; gap> c2:=SCBdSimplex(3);; gap> c3:=SCCartesianProduct(c1,c2); [SimplicialComplex Properties known: Dim, FacetsEx, Name, TopologicalType, Vertices. Name="S^1_3xS^2_4" Dim=3 TopologicalType="S^1xS^2" /SimplicialComplex] gap> c3.Homology; [ [ 0, [ ] ], [ 1, [ ] ], [ 1, [ ] ], [ 1, [ ] ] ] gap> c3.F; [ 12, 48, 72, 36 ]

`‣ SCConnectedComponents` ( complex ) | ( method ) |

Returns: a list of simplicial complexes of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

Computes all connected components of an arbitrary simplicial complex.

gap> c:=SC([[1,2,3],[3,4,5],[4,5,6,7,8]]);; gap> SCRename(c,"connected complex");; gap> SCConnectedComponents(c); [ [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="Connected component #1 of connected complex" Dim=4 /SimplicialComplex] ] gap> c:=SC([[1,2,3],[4,5],[6,7,8]]);; gap> SCRename(c,"non-connected complex");; gap> SCConnectedComponents(c); [ [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="Connected component #1 of non-connected complex" Dim=2 /SimplicialComplex], [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="Connected component #2 of non-connected complex" Dim=1 /SimplicialComplex], [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="Connected component #3 of non-connected complex" Dim=2 /SimplicialComplex] ]

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

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

If n ≥ 2, the function internally calls 1 × `SCConnectedSum`

(6.6-5) and (n-2) × `SCConnectedSumMinus`

(6.6-6).

gap> SCLib.SearchByName("T^2"){[1..6]}; [ [ 4, "T^2 (VT)" ], [ 5, "T^2 (VT)" ], [ 9, "T^2 (VT)" ], [ 10, "T^2 (VT)" ], [ 18, "T^2 (VT)" ], [ 20, "(T^2)#2" ] ] gap> torus:=SCLib.Load(last[1][1]);; gap> genus10:=SCConnectedProduct(torus,10); [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="T^2 (VT)#+-T^2 (VT)#+-T^2 (VT)#+-T^2 (VT)#+-T^2 (VT)#+-T^2 (VT)#+-T^2 (\ VT)#+-T^2 (VT)#+-T^2 (VT)#+-T^2 (VT)" Dim=2 /SimplicialComplex] gap> genus10.Chi; -18 gap> genus10.F; [ 43, 183, 122 ]

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

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

In a lexicographic ordering the smallest facet of both `complex1` and `complex2` is removed and the complexes are glued together along the resulting boundaries. The bijection used to identify the vertices of the boundaries differs from the one chosen in `SCConnectedSumMinus`

(6.6-6) by a transposition. Thus, the topological type of `SCConnectedSum`

is different from the one of `SCConnectedSumMinus`

(6.6-6) whenever `complex1` and `complex2` do not allow an orientation reversing homeomorphism.

gap> SCLib.SearchByName("T^2"){[1..6]}; [ [ 4, "T^2 (VT)" ], [ 5, "T^2 (VT)" ], [ 9, "T^2 (VT)" ], [ 10, "T^2 (VT)" ], [ 18, "T^2 (VT)" ], [ 20, "(T^2)#2" ] ] gap> torus:=SCLib.Load(last[1][1]);; gap> genus2:=SCConnectedSum(torus,torus); [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="T^2 (VT)#+-T^2 (VT)" Dim=2 /SimplicialComplex] gap> genus2.Homology; [ [ 0, [ ] ], [ 4, [ ] ], [ 1, [ ] ] ] gap> genus2.Chi; -2

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

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

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

In a lexicographic ordering the smallest facet of both `complex1` and `complex2` is removed and the complexes are glued together along the resulting boundaries. The bijection used to identify the vertices of the boundaries differs from the one chosen in `SCConnectedSum`

(6.6-5) by a transposition. Thus, the topological type of `SCConnectedSumMinus`

is different from the one of `SCConnectedSum`

(6.6-5) whenever `complex1` and `complex2` do not allow an orientation reversing homeomorphism.

gap> SCLib.SearchByName("T^2"){[1..6]}; [ [ 4, "T^2 (VT)" ], [ 5, "T^2 (VT)" ], [ 9, "T^2 (VT)" ], [ 10, "T^2 (VT)" ], [ 18, "T^2 (VT)" ], [ 20, "(T^2)#2" ] ] gap> torus:=SCLib.Load(last[1][1]);; gap> genus2:=SCConnectedSumMinus(torus,torus); [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="T^2 (VT)#+-T^2 (VT)" Dim=2 /SimplicialComplex] gap> genus2.Homology; [ [ 0, [ ] ], [ 4, [ ] ], [ 1, [ ] ] ] gap> genus2.Chi; -2

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

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

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

otherwise.

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

(6.6-8).

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

`‣ SCDifferenceCycleExpand` ( diffcycle ) | ( function ) |

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

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

. The function returns the Z_σ-orbit of ∆.

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

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

`‣ SCStronglyConnectedComponents` ( complex ) | ( method ) |

Returns: a list of simplicial complexes of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

Computes all strongly connected components of a pure simplicial complex.

gap> c:=SC([[1,2,3],[2,3,4],[4,5,6],[5,6,7]]);; gap> comps:=SCStronglyConnectedComponents(c); [ [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="Strongly connected component #1 of unnamed complex 82" Dim=2 /SimplicialComplex], [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="Strongly connected component #2 of unnamed complex 82" Dim=2 /SimplicialComplex] ] gap> comps[1].Facets; [ [ 1, 2, 3 ], [ 2, 3, 4 ] ] gap> comps[2].Facets; [ [ 4, 5, 6 ], [ 5, 6, 7 ] ]

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`

.

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

Returns: a list of simplicial complexes of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

Computes all combinatorial `d`-pseudomanifolds, d=2 / all strongly connected combinatorial `d`-pseudomanifolds, d ≥ 3, as a union of orbits of the group action of `G` on `(d+1)`

-tuples on the set of `n` vertices, see [Lut03]. The integer argument `objectType` specifies, whether complexes exceeding the maximal size of each vertex link for combinatorial manifolds are sorted out (`objectType = 0`

) or not (`objectType = 1`

, in this case some combinatorial pseudomanifolds won't be found, but no combinatorial manifold will be sorted out). The integer argument `cache` specifies if the orbits are held in memory during the computation, a value of `0`

means that the orbits are discarded, trading speed for memory, any other value means that they are kept, trading memory for speed. The boolean argument `removeDoubleEntries` specifies whether the results are checked for combinatorial isomorphism, preventing isomorphic entries. The argument `outfile` specifies an output file containing all complexes found by the algorithm, if `outfile` is anything else than a string, not output file is generated. The argument `maxLinkSize` determines a maximal link size of any output complex. If `maxLinkSize`=0 or if `maxLinkSize` is anything else than an integer the argument is ignored. The argument `subset` specifies a set of orbits (given by a list of indices of `repHigh`

) which have to be contained in any output complex. If `subset` is anything else than a subset of `matrixAllowedRows`

the argument is ignored.

gap> G:=PrimitiveGroup(8,5); PGL(2, 7) gap> Size(G); 336 gap> Transitivity(G); 3 gap> list:=SCsFromGroupExt(G,8,3,1,0,true,false,0,[]); [ "defgh.g.h.fah.e.gaf.h.eag.e.faf.a.haa.g.fah.a.gjhzh" ] gap> c:=SCFromIsoSig(list[1]); [SimplicialComplex Properties known: Dim, ExportIsoSig, FacetsEx, Name, Vertices. Name="unnamed complex 6" Dim=3 /SimplicialComplex] gap> SCNeighborliness(c); 3 gap> c.F; [ 8, 28, 56, 28 ] gap> c.IsManifold; false gap> SCLibDetermineTopologicalType(SCLink(c,1)); [SimplicialComplex Properties known: BoundaryEx, Dim, FacetsEx, HasBoundary, IsPseudoManifold, IsPure, Name, SkelExs[], Vertices. Name="lk([ 1 ]) in unnamed complex 6" Dim=2 HasBoundary=false IsPseudoManifold=true IsPure=true /SimplicialComplex] gap> # there are no 3-neighborly 3-manifolds with 8 vertices gap> list:=SCsFromGroupExt(PrimitiveGroup(8,5),8,3,0,0,true,false,0,[]); gap> [ ]

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

Returns: a list of simplicial complexes of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

Computes all combinatorial `d`-pseudomanifolds, d = 2 / all strongly connected combinatorial `d`-pseudomanifolds, d ≥ 3, as union of orbits of group actions for all `k`-transitive groups on `(d+1)`

-tuples on the set of `n` vertices, see [Lut03]. The boolean argument `maniflag` specifies, whether the resulting complexes should be listed separately by combinatorial manifolds, combinatorial pseudomanifolds and complexes where the verification that the object is at least a combinatorial pseudomanifold failed. The boolean argument `computeAutGroup` specifies whether or not the real automorphism group should be computed (note that a priori the generating group is just a subgroup of the automorphism group). The boolean argument `removeDoubleEntries` specifies whether the results are checked for combinatorial isomorphism, preventing isomorphic entries. Internally calls `SCsFromGroupExt`

(6.7-1) for every group.

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

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

`‣ SCNrCyclic3Mflds` ( i ) | ( function ) |

Returns: integer upon success, `fail`

otherwise.

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

gap> SCNrCyclic3Mflds(22); 3090

`‣ SCCyclic3MfldTopTypes` ( i ) | ( function ) |

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

otherwise.

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

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

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

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

Returns the `j`th combinatorial 3-manifold with `i` vertices in the classification of combinatorial 3-manifolds with transitive cyclic symmetry. See [Spr14] for more about the classification of combinatorial 3-manifolds with transitive cyclic symmetry up to 22 vertices.

gap> SCCyclic3Mfld(15,34); [SimplicialComplex Properties known: AutomorphismGroupTransitivity, DifferenceCycles, Dim, FacetsEx, IsManifold, Name, TopologicalType, Vertices. Name="Cyclic 3-mfld (15,34): T^3" Dim=3 AutomorphismGroupTransitivity=1 TopologicalType="T^3" /SimplicialComplex]

`‣ SCCyclic3MfldByType` ( type ) | ( function ) |

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

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

gap> SCCyclic3MfldByType("T^3"); [SimplicialComplex Properties known: AutomorphismGroupTransitivity, DifferenceCycles, Dim, FacetsEx, IsManifold, Name, TopologicalType, Vertices. Name="Cyclic 3-mfld (15,34): T^3" Dim=3 AutomorphismGroupTransitivity=1 TopologicalType="T^3" /SimplicialComplex]

`‣ SCCyclic3MfldListOfGivenType` ( type ) | ( function ) |

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

Returns a list of indices { (i_1, j_1) , (i_1, j_1) , ... (i_n, j_n) } of all combinatorial 3-manifolds in the classification of combinatorial 3-manifolds with transitive cyclic symmetry of topological type `type`. Complexes can be obtained by calling `SCCyclic3Mfld`

(6.8-3) using these indices. See [Spr14] for more about the classification of combinatorial 3-manifolds with transitive cyclic symmetry up to 22 vertices.

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

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.

`‣ SCAltshulerSteinberg` ( complex ) | ( method ) |

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

otherwise.

Computes the Altshuler-Steinberg determinant.

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

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

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

`‣ SCAutomorphismGroup` ( complex ) | ( method ) |

Returns: a **GAP** permutation group upon success, `fail`

otherwise.

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

The function uses an efficient algorithm provided by the package **GRAPE** (see [Soi12], which is based on the program `nauty`

by Brendan McKay [MP14]). If the package **GRAPE** is not available, this function call falls back to `SCAutomorphismGroupInternal`

(6.9-3).

The position of the group in the **GAP** libraries of small groups, transitive groups or primitive groups is given. If the group is not listed, its structure description, provided by the **GAP** function `StructureDescription()`

, is returned as the name of the group. Note that the latter form is not always unique, since every non trivial semi-direct product is denoted by ''`:`

''.

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

`‣ SCAutomorphismGroupInternal` ( complex ) | ( method ) |

Returns: a **GAP** permutation group upon success, `fail`

otherwise.

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

The position of the group in the **GAP** libraries of small groups, transitive groups or primitive groups is given. If the group is not listed, its structure description, provided by the **GAP** function `StructureDescription()`

, is returned as the name of the group. Note that the latter form is not always unique, since every non trivial semi-direct product is denoted by ''`:`

''.

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

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

`‣ SCAutomorphismGroupSize` ( complex ) | ( method ) |

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

otherwise.

Computes the size of the automorphism group of a strongly connected pseudomanifold `complex`, see `SCAutomorphismGroup`

(6.9-2).

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

`‣ SCAutomorphismGroupStructure` ( complex ) | ( method ) |

Returns: the **GAP** structure description upon success, `fail`

otherwise.

Computes the **GAP** structure description of the automorphism group of a strongly connected pseudomanifold `complex`, see `SCAutomorphismGroup`

(6.9-2).

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

`‣ SCAutomorphismGroupTransitivity` ( complex ) | ( method ) |

Returns: a positive integer upon success, `fail`

otherwise.

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

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

`‣ SCBoundary` ( complex ) | ( method ) |

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

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

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

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

.

gap> c:=SC([[1,2,3,4],[1,2,3,5],[1,2,4,5],[1,3,4,5]]); [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="unnamed complex 52" Dim=3 /SimplicialComplex] gap> SCBoundary(c); [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="Bd(unnamed complex 52)" Dim=2 /SimplicialComplex] gap> c; [SimplicialComplex Properties known: BoundaryEx, Dim, FacetsEx, HasBoundary, IsPseudoManifold, IsPure, Name, SkelExs[], Vertices. Name="unnamed complex 52" Dim=3 HasBoundary=true IsPseudoManifold=true IsPure=true /SimplicialComplex]

`‣ SCDehnSommervilleCheck` ( c ) | ( method ) |

Returns: `true`

or `false`

upon success, `fail`

otherwise.

Checks if the simplicial complex `c` fulfills the Dehn Sommerville equations: h_j - h_d+1-j = (-1)^d+1-j d+1 choose j (χ (M) - 2) for 0 ≤ j ≤ fracd2 and d even, and h_j - h_d+1-j = 0 for 0 ≤ j ≤ fracd-12 and d odd. Where h_j is the jth component of the h-vector, see `SCHVector`

(6.9-26).

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

`‣ SCDehnSommervilleMatrix` ( d ) | ( method ) |

Returns: a `(d+1)`

×`Int(d+1/2)`

matrix with integer entries upon success, `fail`

otherwise.

Computes the coefficients of the Dehn Sommerville equations for dimension `d`

: h_j - h_d+1-j = (-1)^d+1-j d+1 choose j (χ (M) - 2) for 0 ≤ j ≤ fracd2 and d even, and h_j - h_d+1-j = 0 for 0 ≤ j ≤ fracd-12 and d odd. Where h_j is the jth component of the h-vector, see `SCHVector`

(6.9-26).

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

`‣ SCDifferenceCycles` ( complex ) | ( method ) |

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

otherwise.

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

gap> torus:=SCFromDifferenceCycles([[1,2,4],[1,4,2]]); [SimplicialComplex Properties known: DifferenceCycles, Dim, FacetsEx, Name, Vertices. Name="complex from diffcycles [ [ 1, 2, 4 ], [ 1, 4, 2 ] ]" Dim=2 /SimplicialComplex] gap> torus.Homology; [ [ 0, [ ] ], [ 2, [ ] ], [ 1, [ ] ] ] gap> torus.DifferenceCycles; [ [ 1, 2, 4 ], [ 1, 4, 2 ] ]

`‣ SCDim` ( complex ) | ( method ) |

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

otherwise.

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

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

`‣ SCDualGraph` ( complex ) | ( method ) |

Returns: 1-dimensional simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

Computes the dual graph of the pure simplicial complex `complex`.

gap> sphere:=SCBdSimplex(5);; gap> graph:=SCFaces(sphere,1); [ [ 1, 2 ], [ 1, 3 ], [ 1, 4 ], [ 1, 5 ], [ 1, 6 ], [ 2, 3 ], [ 2, 4 ], [ 2, 5 ], [ 2, 6 ], [ 3, 4 ], [ 3, 5 ], [ 3, 6 ], [ 4, 5 ], [ 4, 6 ], [ 5, 6 ] ] gap> graph:=SC(graph);; gap> dualGraph:=SCDualGraph(sphere); [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="dual graph of S^4_6" Dim=1 /SimplicialComplex] gap> graph.Facets = dualGraph.Facets; true

`‣ SCEulerCharacteristic` ( complex ) | ( method ) |

Returns: integer upon success, `fail`

otherwise.

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

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

`‣ SCFVector` ( complex ) | ( method ) |

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

otherwise.

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

(6.9-52).

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

`‣ SCFaceLattice` ( complex ) | ( method ) |

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

otherwise.

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

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

`‣ SCFaceLatticeEx` ( complex ) | ( method ) |

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

otherwise.

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

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

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

Returns: a face list upon success, `fail`

otherwise.

This is a synonym of the function `SCSkel`

(7.3-13).

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

Returns: a face list upon success, `fail`

otherwise.

This is a synonym of the function `SCSkelEx`

(7.3-14).

`‣ SCFacets` ( complex ) | ( method ) |

Returns: a facet list upon success, `fail`

otherwise.

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

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

`‣ SCFacetsEx` ( complex ) | ( method ) |

Returns: a facet list upon success, `fail`

otherwise.

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

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

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

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

otherwise.

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

.

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

`‣ SCFundamentalGroup` ( complex ) | ( method ) |

Returns: a **GAP** fp group upon success, `fail`

otherwise.

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

to simplify the group presenation.

gap> list:=SCLib.SearchByName("RP^2"); [ [ 3, "RP^2 (VT)" ], [ 635, "RP^2xS^1" ] ] gap> c:=SCLib.Load(list[1][1]); [SimplicialComplex Properties known: AltshulerSteinberg, AutomorphismGroup, AutomorphismGroupSize, AutomorphismGroupStructure, AutomorphismGroupTransitivity, ConnectedComponents, Dim, DualGraph, EulerCharacteristic, FVector, FacetsEx, GVector, GeneratorsEx, HVector, HasBoundary, HasInterior, Homology, Interior, IsCentrallySymmetric, IsConnected, IsEulerianManifold, IsManifold, IsOrientable, IsPseudoManifold, IsPure, IsStronglyConnected, MinimalNonFacesEx, Name, Neighborliness, NumFaces[], Orientation, Reference, SkelExs[], Vertices. Name="RP^2 (VT)" Dim=2 AltshulerSteinberg=3645 AutomorphismGroupSize=60 AutomorphismGroupStructure="A5" AutomorphismGroupTransitivity=2 EulerCharacteristic=1 FVector=[ 6, 15, 10 ] GVector=[ 2, 3 ] HVector=[ 3, 6, 0 ] HasBoundary=false HasInterior=true Homology=[ [ 0, [ ] ], [ 0, [ 2 ] ], [ 0, [ ] ] ] IsCentrallySymmetric=false IsConnected=true IsEulerianManifold=true IsOrientable=false IsPseudoManifold=true IsPure=true IsStronglyConnected=true Neighborliness=2 /SimplicialComplex] gap> g:=SCFundamentalGroup(c);; gap> StructureDescription(g); "C2"

`‣ SCGVector` ( complex ) | ( method ) |

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

otherwise.

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

Let h be the h-vector of a d-dimensional simplicial complex C, then g_i:=h_{i+1} - h_{i} ; \quad \frac{d}{2} \geq i \geq 0 is called the g-vector of C. For the definition of the h-vector see `SCHVector`

(6.9-26). The information contained in g suffices to determine the f-vector of C.

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

`‣ SCGenerators` ( complex ) | ( method ) |

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

upon success, `fail`

otherwise.

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

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

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

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

gap> SCLib.SearchByName("K3"); [ [ 7648, "K3_16" ], [ 7649, "K3_17" ] ] gap> SCLib.Load(last[1][1]); [SimplicialComplex Properties known: AltshulerSteinberg, AutomorphismGroup, AutomorphismGroupSize, AutomorphismGroupStructure, AutomorphismGroupTransitivity, ConnectedComponents, Dim, DualGraph, EulerCharacteristic, FVector, FacetsEx, GVector, GeneratorsEx, HVector, HasBoundary, HasInterior, Homology, Interior, IsCentrallySymmetric, IsConnected, IsEulerianManifold, IsManifold, IsOrientable, IsPseudoManifold, IsPure, IsStronglyConnected, MinimalNonFacesEx, Name, Neighborliness, NumFaces[], Orientation, SkelExs[], Vertices. Name="K3_16" Dim=4 AltshulerSteinberg=883835714748069945165599539200 AutomorphismGroupSize=240 AutomorphismGroupStructure="((C2 x C2 x C2 x C2) : C5) : C3" AutomorphismGroupTransitivity=2 EulerCharacteristic=24 FVector=[ 16, 120, 560, 720, 288 ] GVector=[ 10, 55, 220 ] HVector=[ 11, 66, 286, -99, 23 ] HasBoundary=false HasInterior=true Homology=[ [ 0, [ ] ], [ 0, [ ] ], [ 22, [ ] ], [ 0, [ ] ], [ 1, [ ] ] ] IsCentrallySymmetric=false IsConnected=true IsEulerianManifold=true IsOrientable=true IsPseudoManifold=true IsPure=true IsStronglyConnected=true Neighborliness=3 /SimplicialComplex] gap> SCGenerators(last); [ [ [ 1, 2, 3, 8, 12 ], 240 ], [ [ 1, 2, 5, 8, 14 ], 48 ] ]

`‣ SCGeneratorsEx` ( complex ) | ( method ) |

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

upon success, `fail`

otherwise.

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

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

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

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

gap> SCLib.SearchByName("K3"); [ [ 7648, "K3_16" ], [ 7649, "K3_17" ] ] gap> SCLib.Load(last[1][1]); [SimplicialComplex Properties known: AltshulerSteinberg, AutomorphismGroup, AutomorphismGroupSize, AutomorphismGroupStructure, AutomorphismGroupTransitivity, ConnectedComponents, Dim, DualGraph, EulerCharacteristic, FVector, FacetsEx, GVector, GeneratorsEx, HVector, HasBoundary, HasInterior, Homology, Interior, IsCentrallySymmetric, IsConnected, IsEulerianManifold, IsManifold, IsOrientable, IsPseudoManifold, IsPure, IsStronglyConnected, MinimalNonFacesEx, Name, Neighborliness, NumFaces[], Orientation, SkelExs[], Vertices. Name="K3_16" Dim=4 AltshulerSteinberg=883835714748069945165599539200 AutomorphismGroupSize=240 AutomorphismGroupStructure="((C2 x C2 x C2 x C2) : C5) : C3" AutomorphismGroupTransitivity=2 EulerCharacteristic=24 FVector=[ 16, 120, 560, 720, 288 ] GVector=[ 10, 55, 220 ] HVector=[ 11, 66, 286, -99, 23 ] HasBoundary=false HasInterior=true Homology=[ [ 0, [ ] ], [ 0, [ ] ], [ 22, [ ] ], [ 0, [ ] ], [ 1, [ ] ] ] IsCentrallySymmetric=false IsConnected=true IsEulerianManifold=true IsOrientable=true IsPseudoManifold=true IsPure=true IsStronglyConnected=true Neighborliness=3 /SimplicialComplex] gap> SCGeneratorsEx(last); [ [ [ 1, 2, 3, 8, 12 ], 240 ], [ [ 1, 2, 5, 8, 14 ], 48 ] ]

`‣ SCHVector` ( complex ) | ( method ) |

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

otherwise.

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

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

`‣ SCHasBoundary` ( complex ) | ( method ) |

Returns: `true`

or `false`

upon success, `fail`

otherwise.

Checks if a simplicial complex `complex` that fulfills the weak pseudo manifold property has a boundary, i. e. d-1-faces of valence 1. If `complex` is closed `false`

is returned, if `complex` does not fulfill the weak pseudomanifold property, `fail`

is returned, otherwise `true`

is returned.

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

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

`‣ SCHasInterior` ( complex ) | ( method ) |

Returns: `true`

or `false`

upon success, `fail`

otherwise.

Returns `true`

if a simplicial complex `complex` that fulfills the weak pseudomanifold property has at least one d-1-face of valence 2, i. e. if there exist at least one d-1-face that is not in the boundary of `complex`, if no such face can be found `false`

is returned. It `complex` does not fulfill the weak pseudomanifold property `fail`

is returned.

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

`‣ SCHeegaardSplittingSmallGenus` ( M ) | ( method ) |

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

otherwise.

Computes a Heegaard splitting of the combinatorial 3-manifold `M` of small genus. The function returns the genus of the Heegaard splitting, the vertex partition of the Heegaard splitting and information whether the splitting is minimal or just small (i. e. the Heegaard genus could not be determined). See also `SCHeegaardSplitting`

(6.9-30) for a faster computation of a Heegaard splitting of arbitrary genus and `SCIsHeegaardSplitting`

(6.9-40) for a test whether or not a given splitting defines a Heegaard splitting.

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

`‣ SCHeegaardSplitting` ( M ) | ( method ) |

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

otherwise.

Computes a Heegaard splitting of the combinatorial 3-manifold `M`. The function returns the genus of the Heegaard splitting, the vertex partition of the Heegaard splitting and a note, that splitting is arbitrary and in particular possibly not minimal. See also `SCHeegaardSplittingSmallGenus`

(6.9-29) for the calculation of a Heegaard splitting of small genus and `SCIsHeegaardSplitting`

(6.9-40) for a test whether or not a given splitting defines a Heegaard splitting.

gap> M:=SCSeriesBdHandleBody(3,12);; gap> list:=SCHeegaardSplitting(M); [ 1, [ [ 1, 2, 3, 5, 9 ], [ 4, 6, 7, 8, 10, 11, 12 ] ], "arbitrary" ] gap> sl:=SCSlicing(M,list[2]); [NormalSurface Properties known: ConnectedComponents, Dim, EulerCharacteristic, FVector, Fac\ etsEx, Genus, IsConnected, IsOrientable, NSTriangulation, Name, TopologicalTyp\ e, Vertices. Name="slicing [ [ 1, 2, 3, 5, 9 ], [ 4, 6, 7, 8, 10, 11, 12 ] ] of Sphere bun\ dle S^2 x S^1" Dim=2 FVector=[ 24, 55, 14, 17 ] EulerCharacteristic=0 IsOrientable=true TopologicalType="T^2" /NormalSurface]

`‣ SCHomologyClassic` ( complex ) | ( function ) |

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

.

Computes the integral simplicial homology groups of a simplicial complex `complex` (internally calls the function `SimplicialHomology(complex.FacetsEx)`

from the **homology** package, see [DHSW11]).

If the **homology** package is not available, this function call falls back to `SCHomologyInternal`

(8.1-5). The output is a list of homology groups of the form [H_0,....,H_d], where d is the dimension of `complex`. The format of the homology groups H_i is given in terms of their maximal cyclic subgroups, i.e. a homology group H_i≅ Z^f + Z / t_1 Z × dots × Z / t_n Z is returned in form of a list [ f, [t_1,...,t_n] ], where f is the (integer) free part of H_i and t_i denotes the torsion parts of H_i ordered in weakly increasing size.

gap> SCLib.SearchByName("K^2"); [ [ 17, "K^2 (VT)" ], [ 571, "K^2 (VT)" ] ] gap> kleinBottle:=SCLib.Load(last[1][1]);; gap> kleinBottle.Homology; [ [ 0, [ ] ], [ 1, [ 2 ] ], [ 0, [ ] ] ] gap> SCLib.SearchByName("L_"){[1..10]}; [ [ 139, "L_3_1" ], [ 634, "L_4_1" ], [ 754, "L_5_2" ], [ 2416, "(S^2~S^1)#L_3_1" ], [ 2417, "(S^2xS^1)#L_3_1" ], [ 2490, "L_5_1" ], [ 2492, "(S^2~S^1)#2#L_3_1" ], [ 2494, "(S^2xS^1)#2#L_3_1" ], [ 7467, "L_7_2" ], [ 7468, "L_8_3" ] ] gap> c:=SCConnectedSum(SCLib.Load(last[9][1]), SCConnectedProduct(SCLib.Load(last[10][1]),2)); > [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="L_7_2#+-L_8_3#+-L_8_3" Dim=3 /SimplicialComplex] gap> SCHomology(c); [ [ 0, [ ] ], [ 0, [ 8, 56 ] ], [ 0, [ ] ], [ 1, [ ] ] ] gap> SCFpBettiNumbers(c,2); [ 1, 2, 2, 1 ] gap> SCFpBettiNumbers(c,3); [ 1, 0, 0, 1 ]

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

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

otherwise.

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

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

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

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

otherwise.

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

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

`‣ SCInterior` ( complex ) | ( method ) |

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

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

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

`‣ SCIsCentrallySymmetric` ( complex ) | ( method ) |

Returns: `true`

or `false`

upon success, `fail`

otherwise.

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

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

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

`‣ SCIsConnected` ( complex ) | ( method ) |

Returns: `true`

or `false`

upon success, `fail`

otherwise.

Checks if a simplicial complex `complex` is connected.

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

`‣ SCIsEmpty` ( complex ) | ( method ) |

Returns: `true`

or `false`

upon success, `fail`

otherwise.

Checks if a simplicial complex `complex` is the empty complex, i. e. a `SCSimplicialComplex`

object with empty facet list.

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

`‣ SCIsEulerianManifold` ( complex ) | ( method ) |

Returns: `true`

or `false`

upon success, `fail`

otherwise.

Checks whether a given simplicial complex `complex` is a Eulerian manifold or not, i. e. checks if all vertex links of `complex` have the Euler characteristic of a sphere. In particular the function returns `false`

in case `complex` has a non-empty boundary.

gap> c:=SCBdSimplex(4);; gap> SCIsEulerianManifold(c); true gap> SCLib.SearchByName("Moebius"); [ [ 1, "Moebius Strip" ] ] gap> moebius:=SCLib.Load(last[1][1]); # a moebius strip [SimplicialComplex Properties known: Dim, EulerCharacteristic, FVector, FacetsEx, GVector, HVector, HasBoundary, Homology, IsConnected, IsManifold, IsPseudoManifold, MinimalNonFacesEx, Name, NumFaces[], SkelExs[], Vertices. Name="Moebius Strip" Dim=2 EulerCharacteristic=0 FVector=[ 5, 10, 5 ] GVector=[ 1, 1 ] HVector=[ 2, 3, -1 ] HasBoundary=true Homology=[ [ 0 ], [ 1 ], [ 0 ] ] IsConnected=true IsPseudoManifold=true /SimplicialComplex] gap> SCIsEulerianManifold(moebius); false

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

Returns: `true`

or `false`

upon success, `fail`

otherwise.

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

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

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

Returns: `true`

or `false`

upon success, `fail`

otherwise.

Checks whether `list` defines a Heegaard splitting of `c` or not. See also `SCHeegaardSplitting`

(6.9-30) and `SCHeegaardSplittingSmallGenus`

(6.9-29) for functions to compute Heegaard splittings.

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

`‣ SCIsHomologySphere` ( complex ) | ( method ) |

Returns: `true`

or `false`

upon success, `fail`

otherwise.

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

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

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

Returns: `true`

/ `false`

upon success, `fail`

otherwise.

Checks whether the simplicial complex `complex` that must be a combinatorial d-manifold is in the class mathcalK^k(d), 1≤ k≤ ⌊fracd+12⌋, of simplicial complexes that only have k-stacked spheres as vertex links, see [Eff11b]. Note that it is not checked whether `complex` is a combinatorial manifold -- if not, the algorithm will not succeed. Returns `true`

/ `false`

upon success. If `true`

is returned this means that `complex` is at least `k`-stacked and thus that the complex is in the class mathcalK^k(d), i.e. all vertex links are `i`

-stacked spheres. If `false`

is returnd the complex cannot be `k`-stacked. In some cases the question can not be decided. In this case `fail`

is returned.

Internally calls `SCIsKStackedSphere`

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

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

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

Returns: `true`

or `false`

upon success, `fail`

otherwise.

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

`‣ SCIsOrientable` ( complex ) | ( method ) |

Returns: `true`

or `false`

upon success, `fail`

otherwise.

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

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

`‣ SCIsPseudoManifold` ( complex ) | ( method ) |

Returns: `true`

or `false`

upon success, `fail`

otherwise.

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

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

`‣ SCIsPure` ( complex ) | ( method ) |

Returns: a boolean upon success, `fail`

otherwise.

Checks if a simplicial complex `complex` is pure.

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

`‣ SCIsShellable` ( complex ) | ( method ) |

Returns: `true`

or `false`

upon success, `fail`

otherwise.

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

(6.9-7)).

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

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

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

`‣ SCIsStronglyConnected` ( complex ) | ( method ) |

Returns: `true`

or `false`

upon success, `fail`

otherwise.

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

gap> c:=SC([[1,2,3],[1,2,4],[1,3,4],[2,3,4], [1,5,6],[1,5,7],[1,6,7],[5,6,7]]); [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="unnamed complex 24" Dim=2 /SimplicialComplex] gap> SCIsConnected(c); true gap> SCIsStronglyConnected(c); false

`‣ SCMinimalNonFaces` ( complex ) | ( method ) |

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

otherwise.

Computes all missing proper faces of a simplicial complex `complex` by calling `SCMinimalNonFacesEx`

(6.9-50). The simplices are returned in the original labeling of `complex`.

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

`‣ SCMinimalNonFacesEx` ( complex ) | ( method ) |

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

otherwise.

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

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

`‣ SCNeighborliness` ( complex ) | ( method ) |

Returns: a positive integer upon success, `fail`

otherwise.

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

(6.9-43).

Note that every complex is at least 1-neighborly.

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

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

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

otherwise.

If `i` is not specified the function computes the f-vector of the simplicial complex `complex` (cf. `SCFVector`

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

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

`‣ SCOrientation` ( complex ) | ( method ) |

Returns: a list of the type { ± 1 }^f_d or `[ ]`

upon success, `fail`

otherwise.

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

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

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

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

otherwise.

If `k` is an integer, the `k`-skeleton of a simplicial complex `complex`, i. e. all `k`-faces of `complex`, is computed. If `k` is a list, a list of all `k``[i]`

-faces of `complex` for each entry `k``[i]`

(which has to be an integer) is returned. The faces are returned in the original labeling.

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

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

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

otherwise.

If `k` is an integer, the `k`-skeleton of a simplicial complex `complex`, i. e. all `k`-faces of `complex`, is computed. If `k` is a list, a list of all `k``[i]`

-faces of `complex` for each entry `k``[i]`

(which has to be an integer) is returned. The faces are returned in the standard labeling.

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

`‣ SCSpanningTree` ( complex ) | ( method ) |

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

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

gap> c:=SC([["a","b","c"],["a","b","d"], ["a","c","d"], ["b","c","d"]]);; gap> s:=SCSpanningTree(c); [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="spanning tree of unnamed complex 1" Dim=1 /SimplicialComplex] gap> s.Facets; [ [ 1, 2 ], [ 1, 3 ], [ 1, 4 ] ]

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.

`‣ SCAlexanderDual` ( complex ) | ( method ) |

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

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

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

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

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

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

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

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

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

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

If called with a facet list instead of a `SCSimplicialComplex`

object and `apex` is not specified, internally falls back to the homology package [DHSW11], if available.

gap> SCLib.SearchByName("RP^3"); [ [ 45, "RP^3" ], [ 113, "RP^3=L(2,1) (VT)" ], [ 589, "(S^2~S^1)#RP^3" ], [ 590, "(S^2xS^1)#RP^3" ], [ 632, "(S^2~S^1)#2#RP^3" ], [ 633, "(S^2xS^1)#2#RP^3" ], [ 2414, "RP^3#RP^3" ], [ 2426, "RP^3=L(2,1) (VT)" ], [ 2488, "(S^2~S^1)#3#RP^3" ], [ 2489, "(S^2xS^1)#3#RP^3" ], [ 2502, "RP^3=L(2,1) (VT)" ], [ 7473, "(S^2~S^1)#4#RP^3" ], [ 7474, "(S^2xS^1)#4#RP^3" ], [ 7504, "(S^2~S^1)#5#RP^3" ], [ 7505, "(S^2xS^1)#5#RP^3" ] ] gap> rp3:=SCLib.Load(last[1][1]);; gap> rp3.F; [ 11, 51, 80, 40 ] gap> cone:=SCCone(rp3);; gap> cone.F; [ 12, 62, 131, 120, 40 ]

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

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

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

Calculates the simplicial deleted join of the simplicial complexes `complex1` and `complex2`. If called with a facet list instead of a `SCSimplicialComplex`

object, the function internally falls back to the **homology** package [DHSW11], if available.

gap> deljoin:=SCDeletedJoin(SCBdSimplex(3),SCBdSimplex(3)); [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="S^2_4 deljoin S^2_4" Dim=3 /SimplicialComplex] gap> bddeljoin:=SCBoundary(deljoin);; gap> bddeljoin.Homology; [ [ 1, [ ] ], [ 0, [ ] ], [ 2, [ ] ] ] gap> deljoin.Facets; [ [ [ 1, 1 ], [ 2, 1 ], [ 3, 1 ], [ 4, 2 ] ], [ [ 1, 1 ], [ 2, 1 ], [ 3, 2 ], [ 4, 1 ] ], [ [ 1, 1 ], [ 2, 1 ], [ 3, 2 ], [ 4, 2 ] ], [ [ 1, 1 ], [ 2, 2 ], [ 3, 1 ], [ 4, 1 ] ], [ [ 1, 1 ], [ 2, 2 ], [ 3, 1 ], [ 4, 2 ] ], [ [ 1, 1 ], [ 2, 2 ], [ 3, 2 ], [ 4, 1 ] ], [ [ 1, 1 ], [ 2, 2 ], [ 3, 2 ], [ 4, 2 ] ], [ [ 1, 2 ], [ 2, 1 ], [ 3, 1 ], [ 4, 1 ] ], [ [ 1, 2 ], [ 2, 1 ], [ 3, 1 ], [ 4, 2 ] ], [ [ 1, 2 ], [ 2, 1 ], [ 3, 2 ], [ 4, 1 ] ], [ [ 1, 2 ], [ 2, 1 ], [ 3, 2 ], [ 4, 2 ] ], [ [ 1, 2 ], [ 2, 2 ], [ 3, 1 ], [ 4, 1 ] ], [ [ 1, 2 ], [ 2, 2 ], [ 3, 1 ], [ 4, 2 ] ], [ [ 1, 2 ], [ 2, 2 ], [ 3, 2 ], [ 4, 1 ] ] ]

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

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

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

(5.3-2).

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

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

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise .

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

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

gap> SCLib.SearchByName("S^4"); [ [ 36, "S^4 (VT)" ], [ 37, "S^4 (VT)" ], [ 38, "S^4 (VT)" ], [ 130, "S^4 (VT)" ], [ 463, "S^4~S^1 (VT)" ], [ 713, "S^4xS^1 (VT)" ], [ 1472, "S^4xS^1 (VT)" ], [ 1473, "S^4~S^1 (VT)" ], [ 1474, "S^4~S^1 (VT)" ], [ 1475, "S^4xS^1 (VT)" ], [ 2477, "S^4~S^1 (VT)" ], [ 2478, "S^4 (VT)" ], [ 3435, "S^4 (VT)" ], [ 4395, "S^4~S^1 (VT)" ], [ 4396, "S^4~S^1 (VT)" ], [ 4397, "S^4~S^1 (VT)" ], [ 4398, "S^4~S^1 (VT)" ], [ 4399, "S^4~S^1 (VT)" ], [ 4402, "S^4~S^1 (VT)" ], [ 4403, "S^4~S^1 (VT)" ], [ 4404, "S^4~S^1 (VT)" ], [ 7479, "S^4xS^2" ], [ 7539, "S^4xS^3" ], [ 7573, "S^4xS^4" ] ] gap> s:=SCLib.Load(last[1][1]);; gap> filled:=SCFillSphere(s); [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="FilledSphere(S^4 (VT)) at vertex [ 1 ]" Dim=5 /SimplicialComplex] gap> SCHomology(filled); [ [ 0, [ ] ], [ 0, [ ] ], [ 0, [ ] ], [ 0, [ ] ], [ 0, [ ] ], [ 0, [ ] ] ] gap> SCCollapseGreedy(filled); [SimplicialComplex Properties known: Dim, FVector, FacetsEx, IsPure, Name, NumFaces[], SkelExs[], Vertices. Name="collapsed version of FilledSphere(S^4 (VT)) at vertex [ 1 ]" Dim=0 FVector=[ 1 ] IsPure=true /SimplicialComplex] gap> bd:=SCBoundary(filled);; gap> bd=s; true

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

Returns: simplicial complex of type `SCSimplicialComplex`

, `fail`

otherwise.

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

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

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

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

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

(5.3-3).

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

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

Returns: `true`

or `false`

upon success, `fail`

otherwise.

The function returns `true`

, if the simplicial complexes `complex1` and `complex2` are combinatorially isomorphic, `false`

if not.

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

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

Returns: `true`

or `false`

upon success, `fail`

otherwise.

Returns `true`

if the simplicial complex `sc2` is a sub-complex of simplicial complex `sc1`, `false`

otherwise. If dim(`sc2`) ≤ dim(`sc1`) the facets of `sc2` are compared with the dim(`sc2`)-skeleton of `sc1`. Only works for pure simplicial complexes. Note: for the intersection process the vertex labelings of the complexes are taken into account.

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

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

Returns: a list of pairs of vertex labels or `false`

upon success, `fail`

otherwise.

Returns an isomorphism of simplicial complex `complex1` to simplicial complex `complex2` in the standard labeling if they are combinatorially isomorphic, `false`

otherwise. Internally calls `SCIsomorphismEx`

(6.10-12).

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

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

Returns: a list of pairs of vertex labels or `false`

upon success, `fail`

otherwise.

Returns an isomorphism of simplicial complex `complex1` to simplicial complex `complex2` in the standard labeling if they are combinatorially isomorphic, `false`

otherwise. If the f-vector and the Altshuler-Steinberg determinant of `complex1` and `complex2` are equal, the internal function `SCIntFunc.SCComputeIsomorphismsEx(complex1,complex2,true)`

is called.

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

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

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

Calculates the simplicial join of the simplicial complexes `complex1` and `complex2`. If facet lists instead of `SCSimplicialComplex`

objects are passed as arguments, the function internally falls back to the homology package [DHSW11], if available. Note that the vertex labelings of the complexes passed as arguments are not propagated to the new complex.

gap> sphere:=SCJoin(SCBdSimplex(2),SCBdSimplex(2)); [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="S^1_3 join S^1_3" Dim=3 /SimplicialComplex] gap> SCHasBoundary(sphere); false gap> sphere.Facets; [ [ [ 1, 1 ], [ 1, 2 ], [ 2, 1 ], [ 2, 2 ] ], [ [ 1, 1 ], [ 1, 2 ], [ 2, 1 ], [ 2, 3 ] ], [ [ 1, 1 ], [ 1, 2 ], [ 2, 2 ], [ 2, 3 ] ], [ [ 1, 1 ], [ 1, 3 ], [ 2, 1 ], [ 2, 2 ] ], [ [ 1, 1 ], [ 1, 3 ], [ 2, 1 ], [ 2, 3 ] ], [ [ 1, 1 ], [ 1, 3 ], [ 2, 2 ], [ 2, 3 ] ], [ [ 1, 2 ], [ 1, 3 ], [ 2, 1 ], [ 2, 2 ] ], [ [ 1, 2 ], [ 1, 3 ], [ 2, 1 ], [ 2, 3 ] ], [ [ 1, 2 ], [ 1, 3 ], [ 2, 2 ], [ 2, 3 ] ] ] gap> sphere.Homology; [ [ 0, [ ] ], [ 0, [ ] ], [ 0, [ ] ], [ 1, [ ] ] ]

gap> ball:=SCJoin(SC([[1]]),SCBdSimplex(2)); [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="unnamed complex 4 join S^1_3" Dim=2 /SimplicialComplex] gap> ball.Homology; [ [ 0, [ ] ], [ 0, [ ] ], [ 0, [ ] ] ] gap> ball.Facets; [ [ [ 1, 1 ], [ 2, 1 ], [ 2, 2 ] ], [ [ 1, 1 ], [ 2, 1 ], [ 2, 3 ] ], [ [ 1, 1 ], [ 2, 2 ], [ 2, 3 ] ] ]

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

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

otherwise.

In a simplicial complex `complex` all neighbors of the `k`

-face `face`, i. e. all `k`

-faces distinct from `face` intersecting with `face` in a common (k-1)-face, are returned in the original labeling.

gap> c:=SCFromFacets(Combinations(["a","b","c"],2)); [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="unnamed complex 22" Dim=1 /SimplicialComplex] gap> SCNeighbors(c,["a","d"]); [ [ "a", "b" ], [ "a", "c" ] ]

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

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

otherwise.

In a simplicial complex `complex` all neighbors of the `k`

-face `face`, i. e. all `k`

-faces distinct from `face` intersecting with `face` in a common (k-1)-face, are returned in the standard labeling.

gap> c:=SCFromFacets(Combinations(["a","b","c"],2)); [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="unnamed complex 21" Dim=1 /SimplicialComplex] gap> SCLabels(c); [ "a", "b", "c" ] gap> SCNeighborsEx(c,[1,2]); [ [ 1, 3 ], [ 2, 3 ] ]

`‣ SCShelling` ( complex ) | ( method ) |

Returns: a facet list or `false`

upon success, `fail`

otherwise.

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

(6.9-7)).

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

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

is returned.

Internally calls `SCShellingExt`

(6.10-17)`(complex,false,[]);`

. To learn more about shellings see [Zie95], [Pac87].

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

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

Returns: a list of facet lists (if `checkvector = []`) or `true`

or `false`

(if `checkvector` is not empty), `fail`

otherwise.

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

(6.9-7)).

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

If `all` is set to `true`

all possible shellings of `complex` are computed. If `all` is set to `false`

, at most one shelling is computed.

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

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

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

`‣ SCShellings` ( complex ) | ( method ) |

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

otherwise.

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

(6.9-7)).

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

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

is returned.

Internally calls `SCShellingExt`

(6.10-17)`(complex,true,[]);`

. To learn more about shellings see [Zie95], [Pac87].

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

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

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

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

gap> c:=SCBdCrossPolytope(4);; gap> SCVertices(c); [ 1, 2, 3, 4, 5, 6, 7, 8 ] gap> span:=SCSpan(c,[1,2,3,4]); [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="span([ 1, 2, 3, 4 ]) in Bd(\beta^4)" Dim=1 /SimplicialComplex] gap> span.Facets; [ [ 1, 3 ], [ 1, 4 ], [ 2, 3 ], [ 2, 4 ] ]

gap> c:=SC([[1,2],[1,4,5],[2,3,4]]);; gap> span:=SCSpan(c,[2,3,5]); [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="span([ 2, 3, 5 ]) in unnamed complex 121" Dim=1 /SimplicialComplex] gap> SCFacets(span); [ [ 2, 3 ], [ 5 ] ]

`‣ SCSuspension` ( complex ) | ( method ) |

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

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

gap> SCLib.SearchByName("Poincare"); [ [ 7469, "Poincare_sphere" ] ] gap> phs:=SCLib.Load(last[1][1]); [SimplicialComplex Properties known: AltshulerSteinberg, AutomorphismGroup, AutomorphismGroupSize, AutomorphismGroupStructure, AutomorphismGroupTransitivity, ConnectedComponents, Dim, DualGraph, EulerCharacteristic, FVector, FacetsEx, GVector, GeneratorsEx, HVector, HasBoundary, HasInterior, Homology, Interior, IsCentrallySymmetric, IsConnected, IsEulerianManifold, IsManifold, IsOrientable, IsPseudoManifold, IsPure, IsStronglyConnected, MinimalNonFacesEx, Name, Neighborliness, NumFaces[], Orientation, SkelExs[], Vertices. Name="Poincare_sphere" Dim=3 AltshulerSteinberg=115400413872363901952 AutomorphismGroupSize=1 AutomorphismGroupStructure="1" AutomorphismGroupTransitivity=0 EulerCharacteristic=0 FVector=[ 16, 106, 180, 90 ] GVector=[ 11, 52 ] HVector=[ 12, 64, 12, 1 ] HasBoundary=false HasInterior=true Homology=[ [ 0, [ ] ], [ 0, [ ] ], [ 0, [ ] ], [ 1, [ ] ] ] IsCentrallySymmetric=false IsConnected=true IsEulerianManifold=true IsOrientable=true IsPseudoManifold=true IsPure=true IsStronglyConnected=true Neighborliness=1 /SimplicialComplex] gap> susp:=SCSuspension(phs);; gap> edwardsSphere:=SCSuspension(susp); [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="susp of susp of Poincare_sphere" Dim=5 /SimplicialComplex]

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

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

Forms the union of two simplicial complexes `complex1` and `complex2` as the simplicial complex formed by the union of their facets sets. The two arguments are not altered. Note: for the union process the vertex labelings of the complexes are taken into account, see also `Operation Union (SCSimplicialComplex, SCSimplicialComplex)`

(5.3-1). Facets occurring in both arguments are treated as one facet in the new complex.

gap> c:=SCUnion(SCBdSimplex(3),SCBdSimplex(3)+3); #a wedge of two 2-spheres [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="S^2_4 cup S^2_4" Dim=2 /SimplicialComplex]

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

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

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

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

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

Returns: simplicial complex of type `SCSimplicialComplex`

upon success, `fail`

otherwise.

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

gap> wedge:=SCWedge(SCBdSimplex(2),SCBdSimplex(2)); [SimplicialComplex Properties known: Dim, FacetsEx, Name, Vertices. Name="unnamed complex 17" Dim=1 /SimplicialComplex] gap> wedge.Facets; [ [ 1, [ 1, 2 ] ], [ 1, [ 1, 3 ] ], [ 1, [ 2, 2 ] ], [ 1, [ 2, 3 ] ], [ [ 1, 2 ], [ 1, 3 ] ], [ [ 2, 2 ], [ 2, 3 ] ] ]

generated by GAPDoc2HTML