Algebraic Topology

Algebraic topology turns topology problems into algebra problems.

As discussed on an earlier page, in two dimensions it is relatively easy to determine if two spaces are topologically equivalent (homeomorphic). We can check if they:

However, when we scale up to higher dimensions this does not work and it can become impossible to determine homeomorphism. There are methods which will, at least, allow us to prove more formally when topological objects are not homeomorphic.

These methods use 'invariants': properties of topological objects which do not change when going through a homeomorphism. Here we look at two types of invariants which arise from homotopy and homology.

These invariants can be expressed as algebraic structures, particularly groups, so this subject is called 'algebraic topology'. The way that these algebraic structures arise is discussed on the homotopy and homology pages but first we need to introduce a way to specify topological objects in a way that we can calculate with. We will do this by using simplicial complexes.

Equivalance Classes

Equivalance classes exist when we have classes we wish to consider essentially the same.

Examples:

So we can start to get the idea that this is related to the concept of quotient.

An equivalence relation has the following properties:

See partial order for more.

Homotopy and Homology Equivalance

In the homotopy case we have path components of X written π(X)

equivalence

We have a continous map from space X to space Y:

f: X -> Y

and a continous map from space Y to space X:

g: Y -> X

Homotopy Homomorphism

A homotopy equivalence is where the composition:

g o f: X -> X

is homotopic to the identity map on X

and simlarly for:

f o g: Y -> Y

A homomorphism is where the composition:

g o f: X -> X

is equal to the identity map on X

and simlarly for:

f o g: Y -> Y

Simplicial Complexes

I would like to code finitely defined topological spaces, simplicial complexes allow us to do this in a systematic way.

Introduction

A 'simplex' is a set of vertices such that every subset is included in the simplex. For example a tetrahedron contains all its faces and lines.

A 'simplicial complex' is a set of these simplexes which may have vertices in common.

Because each simplex contains its subsets this is a combinatorial structure, when used in this way the structure is known as an 'abstract simplicial complex' optionally we can also associate a point in a space with each vertex, in this case the structure is known as an 'geometric simplicial complex' and it has geometric/topological/homotopy properties.

Representation

The representation holds whole Simplicial Complex. This consists of a vertex set, represented as a vertex list so that we can index it. Also a list of simplices (that is n-dimensional faces). each simplice is an array of vertex indexes. So each simplice is a subset of the vertex set.

If the dimension given for the simplicial complex is 'k' then:

For example, a triangle has 3 vertexes, so it is maximum size face in 3-1=2 dimensions.

dimension vertex simplice - (faces)
0 0 elements point
1 1 element vertex line - (edge)
2 2 element vertex triangle
3 3 element vertex tetrahedron
n n element vertex simplice

Delta Complex

The above representation defines faces, of any dimension, by their vertices. This is an efficient way to define them, the only disadvantage is that intermediate parts, such as edges, are not indexed. It is sometimes useful to be able to do this, for example, when generating homotopy groups such as the fundamental group.

To do this we represent the complex as a sequence of 'face maps' each one indexed into the next.

As an example consider the representation for a single tetrahedron:

The usual representation would be: (1,2,3,4)
which is very efficient but it does not allow us to refer to its edges and triangles.  

Here we have indexed:

  • The 4 vertices (in red)
  • The 6 edges (in green)
  • The 4 triangles (in blue)
indexed representation
This representation holds all these indexes so that we don't have to keep creating them and they can be used consistently.

Face Maps

So the tetrahedron indexes its 4 triangles, each triangle indexes its 3 edges and each edge indexes its 2 vertices.

Each face table therefore indexes into the next. To show this I have drawn some of the arrows (I could not draw all the arrows as that would have made the diagram too messy).

indexed table

Since edges, triangles, tetrahedrons, etc. are oriented we need to put the indexed in a certain order.

Edges are directed in the order of the vertex indices. That is low numbered index to high numbered index: edge numbering

For triangles we go in the order of the edges, except the middle edge is reversed.

On the diagram the edges are coloured as follows:

  • green arrows - not reversed
  • purple arrows - reversed

This gives the triangles a consistent winding

indexed triangle
However the whole tetrahedron is not yet consistent because some adjacent edges go in the same direction and some go in opposite directions. indexed tetrahedron
This gives the orientation of the faces as given by the right hand rule. That is: if the thumb of the right hand is outside the tetrahedion, pointing toward the face, then the fingers tend to curl round in the direction of the winding. right hand rule

I have put more information about delta complexes on the page here.

Abstract Simplicial Complex vs. Geometric Simplicial Complex

If we apply the restrictions explained so far we have an abstract simplicial complex, However, for a geometric simplicial complex there are some additional conditions.

The additional tests for a geometric simplicial complex are described on the page here.

An Abstract Simplicial Complex is purely combinatorial, that is we don't need the geometric information.

Therefore the AbstractSimplicialComplex domain does not need coordinates for the vertices and they can be denoted by symbols.

Simplicial Maps

Allow edges to be collapsed into vertices.

Oriented Simplexes Maps

Because the code uses Lists instead of Sets the simplexes are oriented by default, if that is not needed then we can just ignore the order.

Topological Aspects of Simplicial Complexes

We implement topological aspects of simplicial complexes such as boundaries and cycles.

The code for this is explained on the page here.

boundary

Operations on Simplicial Complexes

Here are some examples, first we setup some simplicial complexes to work with:

(1) -> ASIMP := FiniteSimplicialComplex(VertexSetAbstract)
   (1)  FiniteSimplicialComplex(VertexSetAbstract)
                                                                   Type: Type

(2) -> v1:List(List(NNI)) := [[1::NNI,2::NNI,3::NNI],[4::NNI,2::NNI,1::NNI]]
   (2)  [[1,2,3],[4,2,1]]
                                         Type: List(List(NonNegativeInteger))

(3) -> sc1 := simplicialComplex(vertexSeta(4::NNI),v1)$ASIMP

   (3)
        (1,2,3)
        (1,2,4)
                             Type: FiniteSimplicialComplex(VertexSetAbstract)

(4) -> v2:List(List(NNI)) := [[1::NNI,2::NNI]]
 

   (4)  [[1,2]]
                                         Type: List(List(NonNegativeInteger))
(5) -> sc2 := simplicialComplex(vertexSeta(2::NNI),v2)$ASIMP

   (5)
        (1,2)
                             Type: FiniteSimplicialComplex(VertexSetAbstract)

Now we can calculate a boundary. Note that this corresponds to the red line on the diagram above, that is, the boundary.

(6) -> delta(sc1)$ASIMP

   (6)
         -(1,3)
         (2,3)
         (1,4)
         -(2,4)
                             Type: FiniteSimplicialComplex(VertexSetAbstract)

Now we can test star,join and link

(7) -> star(sc1,orientedFacet(1,[4]))

   (7)
        -(1,2,4)
                             Type: FiniteSimplicialComplex(VertexSetAbstract)
(8) -> link(sc1,orientedFacet(1,[4]))

   (8)
        -(1,2)
        (1,4)
        -(2,4)
                             Type: FiniteSimplicialComplex(VertexSetAbstract)
(9) -> cone(sc1,5)

   (9)
         (1,2,3,5)
         (1,2,4,5)
                             Type: FiniteSimplicialComplex(VertexSetAbstract)
(10) -> delta(sc2)$ASIMP

   (10)
         (1)
         -(2)
                             Type: FiniteSimplicialComplex(VertexSetAbstract)
(11) -> simplicialJoin(sc1,sc2)

   (11)
         (1,2,3)
         -(1,2,4)
          (1,2)
                             Type: FiniteSimplicialComplex(VertexSetAbstract)

We can also calculate products and sums of simplicial complexes. Products are quite complicated so I have put this on a separate page here.

Vertex Set Code

We want an indexed set of points, the simplest way to do the indexing is to use 'List' instead of 'Set'.

The vertices themselves may be either:

So we cave a category that can represent any of these types and then a domain for each type.

Next Steps

Bibliography

For more details see:


metadata block
see also:

Other Sites

Correspondence about this page

Book Shop - Further reading.

Where I can, I have put links to Amazon for books that are relevant to the subject, click on the appropriate country flag to get more details of the book or to buy it from them.

flag flag flag flag flag flag Mathematics++: Selected Topics Beyond the Basic Courses (Student Mathematical Library) Kantor, Ida.

Chapters:

  1. Measure
  2. High Dimensional Geometry
  3. Fourier Analysis
  4. Representations of Finite Groups
  5. Polynomials
  6. Topology

Chapter 6 - Topology. Contains a relatively gentle introduction to homology.

 

This site may have errors. Don't use for critical systems.

Copyright (c) 1998-2017 Martin John Baker - All rights reserved - privacy policy.