This chapter contains examples of several advanced applications for the SimplicialSurface--package. It mainly serves as a guideline that shows which problems can be solved by the package. If it uses many unclear terms, it is recommended to skip this chapter.
In this section, we want to construct a simplicial surface with the following properties:
It is spherical, i.e. closed, orientable, with Euler-characteristic 2.
It has exactly 30 faces.
It has trivial automorphism group.
A simple way to construct large surfaces is by stacking together small surfaces with ConnectedFaceSum (12.5-1). Combining two spherical surfaces with 16 faces would create a spherical surface with 30 faces (since two faces are lost in the construction). We can obtain a list of spherical surfaces with 16 faces by accessing the surface-library with AllSimplicialSpheres (14.2-1):
gap> surf16 := AllSimplicialSpheres(16);; gap> Length(surf16); 10
The method ConnectedFaceSum requires flags of the surfaces we want to combine. We can obtain the set of all flags by calling Flags(22.1-1).
gap> Flags(surf16[1]); [ [ 1, 1, 1 ], [ 1, 1, 2 ], [ 1, 2, 3 ], [ 1, 2, 4 ], [ 1, 3, 1 ], [ 1, 3, 3 ], [ 1, 4, 2 ], [ 1, 4, 4 ], [ 2, 5, 5 ], [ 2, 5, 6 ], [ 2, 6, 7 ], [ 2, 6, 8 ], [ 2, 7, 5 ], [ 2, 7, 7 ], [ 2, 8, 6 ], [ 2, 8, 8 ], [ 3, 5, 5 ], [ 3, 5, 6 ], [ 3, 9, 5 ], [ 3, 9, 9 ], [ 3, 10, 6 ], [ 3, 10, 10 ], [ 3, 11, 9 ], [ 3, 11, 10 ], [ 4, 6, 7 ], [ 4, 6, 8 ], [ 4, 12, 7 ], [ 4, 12, 11 ], [ 4, 13, 8 ], [ 4, 13, 12 ], [ 4, 14, 11 ], [ 4, 14, 12 ], [ 5, 7, 5 ], [ 5, 7, 7 ], [ 5, 9, 5 ], [ 5, 9, 9 ], [ 5, 12, 7 ], [ 5, 12, 11 ], [ 5, 15, 9 ], [ 5, 15, 13 ], [ 5, 16, 11 ], [ 5, 16, 14 ], [ 5, 17, 13 ], [ 5, 17, 14 ], [ 6, 8, 6 ], [ 6, 8, 8 ], [ 6, 10, 6 ], [ 6, 10, 10 ], [ 6, 13, 8 ], [ 6, 13, 12 ], [ 6, 18, 10 ], [ 6, 18, 15 ], [ 6, 19, 12 ], [ 6, 19, 16 ], [ 6, 20, 15 ], [ 6, 20, 16 ], [ 7, 1, 1 ], [ 7, 1, 2 ], [ 7, 11, 9 ], [ 7, 11, 10 ], [ 7, 15, 9 ], [ 7, 15, 13 ], [ 7, 18, 10 ], [ 7, 18, 15 ], [ 7, 21, 1 ], [ 7, 21, 13 ], [ 7, 22, 2 ], [ 7, 22, 15 ], [ 8, 2, 3 ], [ 8, 2, 4 ], [ 8, 14, 11 ], [ 8, 14, 12 ], [ 8, 16, 11 ], [ 8, 16, 14 ], [ 8, 19, 12 ], [ 8, 19, 16 ], [ 8, 23, 3 ], [ 8, 23, 14 ], [ 8, 24, 4 ], [ 8, 24, 16 ], [ 9, 3, 1 ], [ 9, 3, 3 ], [ 9, 17, 13 ], [ 9, 17, 14 ], [ 9, 21, 1 ], [ 9, 21, 13 ], [ 9, 23, 3 ], [ 9, 23, 14 ], [ 10, 4, 2 ], [ 10, 4, 4 ], [ 10, 20, 15 ], [ 10, 20, 16 ], [ 10, 22, 2 ], [ 10, 22, 15 ], [ 10, 24, 4 ], [ 10, 24, 16 ] ] gap> surfA := surf16[1];; gap> surfB := surf16[2];; gap> newSurf := ConnectedFaceSum(surfA, Flags(surfA)[1], surfB, Flags(surfB)[1]); simplicial surface (17 vertices, 45 edges, and 30 faces)
To check whether this new surface has trivial automorphism group, we compute the automorphism group with AutomorphismGroup (15.6-1).
gap> IsTrivial(AutomorphismGroup(newSurf)); true
Since this is the trivial group, we succeeded in our goal.
In this section, we present several options to analyse a given surface. As an example, we will use the surface that we constructed in the last section.
gap> newSurf; simplicial surface (17 vertices, 45 edges, and 30 faces)
We can already read of the number of vertices, edges, and faces. Some other elementary properties are orientability (IsOrientablComplex, 8.7-1), connectivity (IsConnectedComplex, 8.6-1), closedness (IsClosedComplex, 9.1-2), and the Euler-characteristic (EulerCharacteristic, 9.1-1).
gap> IsOrientableSurface(newSurf); true gap> IsConnectedSurface(newSurf); true gap> IsClosedSurface(newSurf); true gap> EulerCharacteristic(newSurf); 2
In our case, we can deduce that the surface newSurf can be represented as a triangulation of the sphere. We might want to know how many vertices there are of different degrees. This can be found out by using CounterOfVertices (9.2-4).
gap> ListCounter(CounterOfVertices(newSurf)); [ [ 4, 8 ], [ 5, 2 ], [ 6, 5 ], [ 7, 1 ], [ 11, 1 ] ]
This tells us that there are 8 vertices of degree 4, for example. We could be interested in the distance of the two vertices of degree 5. For that, we have to find these vertices first. For this, we need to know the degrees of each vertex. This can be calculated by DegreeOfVertex (9.2-2).
gap> Filtered( Vertices(newSurf), v -> DegreeOfVertex(newSurf,v) = 5 ); [ 31, 33 ]
The distance between two vertices can be calculated with DistanceOfVertices (11.1-1).
gap> DistanceOfVertices(newSurf, 31, 33); 1
Therefore, the two vertices of degree 5 are adjacent.
In this section, we want to construct the following surface:
Start with a spherical surface that has 10 faces, two vertices of degree 5 and five vertices of degree 4, such that the two vertices of degree 5 are not adjacent.
Pick two adjacent faces that are not incident to the same vertex of degree 5 and ``stack'' an octahedron onto them.
Compute the automorphism group of the resulting surface.
Remove the unique vertex that is fixed by the whole automorphism group.
A tedious way would be to construct this surface by hand, label all vertices, edges, and faces, and use one of the methods from chapter 4 to construct the surface. Instead, we can also follow the guidelines to construct the surface. First, we have to obtain the spherical surface. Since the two vertices of degree 5 are not adjacent, the faces incident to them are distinct. We can construct those by the method SimplicialUmbrella (14.4-4):
gap> umb5 := SimplicialUmbrella(5); simplicial surface (6 vertices, 10 edges, and 5 faces)
Since two of these umbrellas have 10 faces in total, we can construct the surface from two umbrellas. We can do so by identifying their boundaries. This process is known as joining and the relevant methods are documented in section 12.4. For our purpose, we need JoinBoundaries (12.4-5). This method requires a vertex and an edge of each umbrella, that lie on the boundary and are incident to each other. The easiest way would be to look up the labelling in the documentation of SimplicialUmbrella (14.4-4), but we can also find one of them ourselves:
gap> boundaryEdges := BoundaryEdges(umb5); [ 6, 7, 8, 9, 10 ] gap> verts := VerticesOfEdge(umb5, 6); [ 1, 2 ]
Therefore, 1 is a boundary vertex incident to the boundary edge 6. This allows us to join the boundaries of two umbrellas.
gap> join := JoinBoundaries(umb5, [1,6], umb5, [1,6]); [ simplicial surface (7 vertices, 15 edges, and 10 faces), ( v17, E21, v18, E22, v19, E23, v20, E24, v21, E25, v17 ) , 10 ] gap> doubleFiveGon := join[1]; simplicial surface (7 vertices, 15 edges, and 10 faces)
The second component of join is a vertex-edge-path (compare section 8.1) that describes how the old boundary lies in the new surface. In particular, E21 tells us that edge 21 was a boundary edge before the joining. Therefore, the two faces adjacent to that edge are not incident to the same vertex of degree 5.
gap> adjFaces := FacesOfEdge(doubleFiveGon, 21); [1, 11]
Next, we want to ``stack'' an octahedron onto each of these faces. We can construct an octahedron directly by calling Octahedron (14.3-4), and we can ``stack'' two surfaces by using ConnectedFaceSum (12.5-1). Unfortunately, this method requires a flag of each surface (it needs to know how exactly we want to combine the surfaces). Since the octahedron is highly symmetric, all possible choices lead to the same surface. For the flag of doubleFiveGon we already have an edge (21) and a face (1 and 11). We only need a vertex incident to the edge.
gap> VerticesOfEdge(doubleFiveGon, 21); [ 17, 18 ]
For the octahedron, we can use any flag. We can use Flags (22.1-1) to compute all of them.
gap> octa := Octahedron(); simplicial surface (6 vertices, 12 edges, and 8 faces) gap> octaFlag := Flags(octa)[1]; [ 1, 1, 1 ]
This allows the first combination.
gap> faceSum1 := ConnectedFaceSum(doubleFiveGon, [17,21,1], octa, [1,1,1]); simplicial surface (10 vertices, 24 edges, and 16 faces) gap> [ 17, 21, 11 ] in Flags(faceSum1); false
Such a combination might force a partial relabelling of the surface and in our case, this has happened: the triple [17,21,11] is no flag of the new surface. Fortunately, it is easy to reconstruct: We are searching for a face whose vertices have degrees [5,6,6]. To localise such subconfigurations, the methods of Section 10.4 can be used. For our purposes, the method FacesWithVertexProperties (10.4-3) is appropriate.
gap> face := FacesWithVertexProperties(faceSum1, [ > v -> FaceDegreeOfVertex(faceSum1, v) = 5, > v -> FaceDegreeOfVertex(faceSum1, v) = 6, > v -> FaceDegreeOfVertex(faceSum1, v) = 6]); [ 11 ] gap> edge := EdgesOfFace(faceSum1, face[1])[1]; 11 gap> vertex := VerticesOfEdge(faceSum1, edge)[1]; 16 gap> faceSum2 := ConnectedFaceSum(faceSum1,[vertex, edge, face[1]], octa,[1,1,1]); simplicial surface (13 vertices, 33 edges, and 22 faces)
To compute the automorphism group, we can use the methods from Section 15.6 . Since we want to compute all fixed vertices, we use AutomorphismGroupOnVertices (15.6-3).
gap> aut := AutomorphismGroupOnVertices(faceSum2); permutation group with 2 generators gap> fixedVertices := Filtered( Vertices(faceSum2), > v -> ForAll(aut, a -> v^a=v) ); [ 20 ]
Removing the vertex 20 means removing all faces incident to that vertex. This can be done by SubsurfaceByFaces (12.2-1).
gap> incFaces := FacesOfVertex(faceSum2, fixedVertices[1]); [ 3, 4, 13, 14 ] gap> remainingFaces := Difference( Faces(faceSum2), incFaces ); [ 2, 5, 12, 15, 27, 28, 29, 30, 31, 32, 33, 42, 43, 44, 45, 46, 47, 48 ] gap> surf := SubsurfaceByFaces(faceSum2, remainingFaces); simplicial surface (12 vertices, 29 edges, and 18 faces)
generated by GAPDoc2HTML