FiniteSimplicialComplex(VS)

alg_top.spad line 1711 [edit on github]

A Finite Simplicial Complex for more documentation see: http://www.euclideanspace.com/prog/scratchpad/mycode/topology/simplex/ Date Created: Dec 2015 Basic Operations: star, link, cone, product Related packages: Related categories: Related Domains: DeltaComplex is an alternative representation which is less compact but allows edges, triangles, etc to be indexed. Also See: AMS Classifications:

= : (%, %) -> Boolean
from BasicType
addImpliedFaces : % -> List(List(OrientedFacet))

a function to take a set of faces and add those that are implied by the simplecicalComplex conventions (if they don't already exist). For example, if the input is a triangle ((1, 2, 3)) then we would add: its points ((1), (2), (3)). and its edges ((1, 2), (1, 3), (2, 3)).

addSimplex : (%, OrientedFacet) -> %

Add a facet to this simplex If the facet is also in the list then, do not append, instead change the multiplier. Used by boundary function

boundary : % -> %

Step down to the next lower dimension, this is like hollowing out the complex. It takes the highest dimension entries and replaces them with their boundaries, cancelling out where it can.

chain : % -> ChainComplex

returns a matrix sequence representing the face maps in linear algebra form For more information: htm

coChain : % -> CoChainComplex(VS)

returns a matrix sequence representing the face maps in linear algebra form For more information: htm

coHomology : % -> List(Homology)

calculate cohomology using SmithNormalForm htm

coerce : % -> DeltaComplex(VS)

coerce SimplicialComplex to DeltaComplex

coerce : % -> OutputForm
from CoercibleTo(OutputForm)
cone : (%, NonNegativeInteger) -> %

The 'cone' of a simplicial complex is formed by adding the vertex to every facet. 'vertex' should not already be included in existing faces, this is not checked and so will lead to simplexes with duplicate vertices.

fundamentalGroup : % -> GroupPresentation

Generates fundamental group from this simplicial complex. This works by converting to a DeltaComplex and then generating the fundamentalGroup from that. This is not the most efficient method because the conversion generates lots of higher order faceMaps which are not used. This will attempt to simplify the group presentation, if you don't want this use alternative function of same name. For more information: htm

fundamentalGroup : (%, Boolean, Boolean) -> GroupPresentation

Generates fundamental group from this simplicial complex. This works by converting to a DeltaComplex and then generating the fundamentalGroup from that. This is not the most efficient method because the conversion generates lots of higher order faceMaps which are not used. This version has options to: simplify - if true attempts to simplify the group presentation trace - if true outputs trace of simplification rules used. For more information: htm

grade : % -> List(List(OrientedFacet))

a function to grade simplexes according to their lengths. This nests the lists according to their length. Vertices, edges, triangles and so on. The list is returned in reverse order, that is, it starts at highest grade and works down.

homology : % -> List(Homology)

calculate homology using SmithNormalForm For more information: htm

latex : % -> String
from SetCategory
link : (%, OrientedFacet) -> %

The 'link' of a simplicial complex and a vertex contains the boundary of the simplexes of s which include simplex.

makeDisjoint : (%, %) -> %

If index numbers of 'b' overlap with index numbers of 'a' then refactor 'b' so that it does not overlap.

maxIndex : % -> NonNegativeInteger

find the maximum index.

merge : (%, %) -> %

Forms union of two simplicial complexes.

minIndex : % -> NonNegativeInteger

find the minimum index.

oneSkeleton : % -> DirectedGraph(NonNegativeInteger)

generates graph AKA 1-skeleton

product : (%, %) -> %

Forms product of two simplicial complexes. For more detailed explanation of simplex product code see: Also see Hatcher [9]. page 277 - The simplicial cross product. page 278 - The cohomology cross product. Returns list, each entry is a 'lattice path' from (0, 0) to (x, y) where x is number of entries in sa and y is number of entries in sb.

refactorIndexes : (%, NonNegativeInteger) -> %

add 'n' to all indexes without changing the structure of this simplicial complex.

simplicialComplex : List(VS) -> %

construct empty simplex

simplicialComplex : (List(VS), List(List(NonNegativeInteger))) -> %

constructor where the simplices are supplied

simplicialComplex : (List(VS), NonNegativeInteger, List(List(NonNegativeInteger))) -> %

constructor where the simplices are supplied

simplicialComplexIfCan : DeltaComplex(VS) -> Union(%, "failed")

construct FiniteSimplicialComplex from DeltaComplex. If there are 'implied' loops, such as facets with multiple entries with the same index, then this function may fail.

simplicialComplexIfCan : (DeltaComplex(VS), Boolean) -> Union(%, "failed")

construct FiniteSimplicialComplex from DeltaComplex with trace. If there are 'implied' loops, such as facets with multiple entries with the same index, then this function may fail.

simplicialJoin : (%, %, Boolean) -> %

Forms join of two simplicial complexes. The join S*T of two simplicial sets S and T is a new simplicial set that may geometrically be thought of as a cone over T with tip of shape S. simplicialJoin is commutative and associative. For more information: htm

sort : % -> %

sort

star : (%, OrientedFacet) -> %

The 'star' of a simplicial complex and a facet contains only the faces of s which include simplex.

~= : (%, %) -> Boolean
from BasicType

CoercibleTo(OutputForm)

BasicType

SetCategory