  
  [1X21. Simplicial Complexes[0X
  
      | [10X Homology(T,n)[0X [10X Homology(T)[0X Inputs a pure cubical complex, or cubical complex, or simplicial complex T and a non-negative integer n. It returns the n-th integral homology of T as a list of torsion integers. If no value of n is input then the list of all homologies of T in dimensions 0 to Dimension(T) is returned .                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | 
      | [10X Bettinumbers(T)[0X Inputs a pure cubical complex, or cubical complex, or simplicial complex T. The list of free ranks of the homology groups of T in dimensions 0 to Dimension(T) is returned .                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 
      | [10XChainComplex(T)[0X Inputs a pure cubical complex, or cubical complex, or simplicial complex T and returns the (often very large) cellular chain complex of T.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 
      | [10XCechComplexOfPureCubicalComplex(T)[0X Inputs a d-dimensional pure cubical complex T and returns a simplicial complex S. The simplicial complex S has one vertex for each d-cube in T, and an n-simplex for each collection of n+1 d-cubes with non-trivial common intersection.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 
      | [10XRipsChainComplex(S,epsilon)[0X [10XRipsChainComplex(S,epsilon,true)[0X Inputs an n x n symmetric matrix S with non-negative rational entries, together with a positive rational number epsilon. The matrix is interpreted as that arising from a set of n points in a metric space, the (i,j) entry representing the distance between the i-th and j-th points. (However, for the construction to work, there is no need for S to actually arise in this way.) The function constructs the simplicial complex X with n vertices and with one k-simplex for each subset of k points where any two elements in the subset are within a distance epsilon of each other. The function then returns the low dimensions of a chain complex C which is homotopy equivalent to the cellular chain complex C(X). With any luck C will be smaller than C(X). At present the function only returns C up to and including dimension 2. So it can be used to compute the first homology of X. If an optional third argument is set equal to true then the function returns a list of chain complexes whose direct sum is homotopy equivalent to C(X) in low dimensions. This option can be used to calculate the homology of C more efficiently. | 
      | [10XVectorsToSymmetricMatrix(M)[0X [10XVectorsToSymmetricMatrix(M,distance)[0X Inputs a matrix M of rational numbers and returns a symmetric matrix S whose (i,j) entry is the distance between the i-th row and j-th rows of M where distance is given by the sum of the absolute values of the coordinate differences. Optionally, a function distance(v,w) can be entered as a second argument. This function has to return a rational number for each pair of rational vectors v,w of length Length(M[1]).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 
      | [10XEulerCharacteristic(T)[0X Inputs a pure cubical complex, or cubical complex, or simplicial complex T and returns its Euler characteristic.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | 
      | [10XMaximalSimplicesToSimplicialComplex(L)[0X Inputs a list L whose entries are lists of vertices representing the maximal simplices of a simplicial complex. The simplicial complex is returned. Here a "vertex" is a GAP object such as an integer or a subgroup.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 
      | [10XSkeletonOfSimplicialComplex(S,k)[0X Inputs a simplicial complex S and a positive integer k less than or equal to the dimension of S. It returns the truncated k-dimensional simplicial complex S^k (and leaves S unchanged).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | 
      | [10XQuillenComplex(G)[0X Inputs a finite group G and returns, as a simplicial complex, the order complex of the poset of non-trivial elementary abelian subgroups of G.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 
  
