CoChain Complexes Code

When we looked at the delta complex we got a chain of 'face maps' between each dimension and the next lower one. homology face maps
For cochain we reverse the arrows: cohomology face maps

As with the chain (see previous page) we represent each one of these mappings with a matrix. For a cochain this matrix is transposed compared to the chain.

FriCAS Implementation

In the following example we create a shape (triangle) with 3 points. We then associate a value (in this case an integer) to each of these points:
Point Value
1 3
2 4
3 5

The coboundary function then calculates the differences: [1,2,1]. That is the difference between 3 and 4 is 1, the difference between 3 and 5 is 2, and the difference between 4 and 5 is 1.

When we apply the coboundary function again we get the difference around the loop, that is, 0.

For comparison, first generate a chain.
(1) -> FACTORY := _
	       SimplicialComplexFactory(Integer)

   (1)  SimplicialComplexFactory(Integer)
                                      Type: Type
(2) -> b1 := sphereSolid(2)$FACTORY

   (2)  points 1..3
          (1,2,3)
          Type: FiniteSimplicialComplex(Integer)
(3) -> d1 := deltaComplex(b1)

   (3)
                2D:[[1,- 2,3]]
         1D:[[1,- 2],[1,- 3],[2,- 3]]
               0D:[[0],[0],[0]]
                     Type: DeltaComplex(Integer)
(4) -> c1 := chain(d1)

                  + 1    1    0 + + 1 +
   (4)  [0  0  0],|- 1   0    1 |,|- 1|,[]
                  + 0   - 1  - 1+ + 1 +
                              Type: ChainComplex
The cochain has the reverse order and the matrices are all transposed
(5) -> cc1 := coChain(d1)

                       +1  - 1   0 + +0+
   (5)  [],[1  - 1  1],|1   0   - 1|,|0|
                       +0   1   - 1+ +0+
                   Type: CoChainComplex(Integer)
We associate integer values, one for each point. The coboundary function takes these values and calculates the differences.
(6) -> cb1 := coboundary(cc1,2::NNI,_
             [3::Integer,4::Integer,5::Integer])

   (6)  [1,2,1]
                             Type: List(Integer)
(7) -> cb2 := coboundary(cc1,3::NNI,cb1)

   (7)  [0]
                             Type: List(Integer)

The values used here were Integers but we could use any type that implements AbelianGroup.

For example we could have real (Float) values associated with each point representing say voltage or height or some other quantity for each point.

Perhaps the most obvious quantity we could associate with each point is position, given by a vector relative to some origin and coordinate system. However the type (domain) needs to implement AbelianGroup. Unfortunately Vectors in FriCAS don't implement AbelianGroup because it needs to implement 0:% which it can't because the nearest function in Vector is zero: NonNegativeInteger -> % but this needs to know the number of dimensions.

What is needed is a version of Vector which has the number of dimensions built in to the type (as a type parameter) rather than having a variable dimension. This could then implement AbelianGroup.

 
(8) -> P1 : DirectProduct(3,DoubleFloat) := _
     construct([1.2,3.4,6.7])$(Vector DoubleFloat)

   (8)  [1.2,3.4,6.699999999999999]
              Type: DirectProduct(3,DoubleFloat)
(9) -> P2 : DirectProduct(3,DoubleFloat) := _
     construct([1.9,3.2,6.0])$(Vector DoubleFloat)

   (9)  [1.9,3.2,6.0]
              Type: DirectProduct(3,DoubleFloat)
(10) -> P3 : DirectProduct(3,DoubleFloat) := _
     construct([1.7,3.8,6.9])$(Vector DoubleFloat)

   (10)  [1.7,3.8,6.9]
              Type: DirectProduct(3,DoubleFloat)
(11) -> FACTORY2 := SimplicialComplexFactory(_
            DirectProduct(3,DoubleFloat))

   (11)  SimplicialComplexFactory(DirectProduct(3,DoubleFloat))
                                      Type: Type
(12) -> b2 := sphereSolid(2)$FACTORY2

   (12)  points 1..3
           (1,2,3)
                  Type: FiniteSimplicialComplex(DirectProduct(3,DoubleFloat))
(13) -> cc3 := coChain(b2)

                        +1  - 1   0 + +0+
                        |           | | |
   (13)  [],[1  - 1  1],|1   0   - 1|,|0|
                        |           | | |
                        +0   1   - 1+ +0+
                           Type: CoChainComplex(DirectProduct(3,DoubleFloat))
(14) -> lab : List(DirectProduct(3,DoubleFloat)) := [P1,P2,P3]

   (14)  [[1.2,3.4,6.699999999999999],[1.9,3.2,6.0],[1.7,3.8,6.9]]
        Type: List(DirectProduct(3,DoubleFloat))
(15) -> cb3 := coboundary(cc3,2::NNI,lab)

   (15)
   [[0.7,- 0.19999999999999973,- 0.6999999999999993],
    [0.5,0.3999999999999999,0.20000000000000107],
    [- 0.19999999999999996,0.5999999999999996,0.9000000000000004]]
        Type: List(DirectProduct(3,DoubleFloat))

 


metadata block
see also:
  • I have put the code here.
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-2018 Martin John Baker - All rights reserved - privacy policy.