GAP (HAP commands) - Chapter 16: Regular CW-structure on knots (written by Kelvin Killeen)

Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 Bib Ind
[Top of Book] [Contents] [Previous Chapter] [Next Chapter]

[MathJax on]

16 Regular CW-structure on knots (written by Kelvin Killeen)
16.1 Knot complements in the 3-ball
16.2 Tubular neighbourhoods
16.3 Knotted surface complements in the 4-ball

### 16 Regular CW-structure on knots (written by Kelvin Killeen)

#### 16.1 Knot complements in the 3-ball

While methods for endowing knot complements with CW-structure already exist in HAP (see section 2.1), they often result in a large number of cells which can make computing with them taxing. The following example shows how one can obtain a comparatively small 3-dimensional regular CW-complex corresponding to the complement of a thickened trefoil knot from an arc presentation. Recall that an arc presentation is encoded in HAP as a list of integer pairs corresponding to the position of the endpoints of each horizontal arc in a grid.

    gap> k_:=PureCubicalKnot(3,1);
    prime knot 1 with 3 crossings

    gap> arc:=ArcPresentation(k_);
    [ [ 2, 5 ], [ 1, 3 ], [ 2, 4 ], [ 3, 5 ], [ 1, 4 ] ]
    gap> k_:=RegularCWComplex(PureComplexComplement(k_));
    Regular CW-complex of dimension 3

    gap> Size(k_);
    13291
    gap> k:=KnotComplement(arc);
    Regular CW-complex of dimension 3

    gap> Size(k);
    395

An optional argument of `"rand"` in the `KnotComplement` function randomises the order in which 2-cells are added to the complex. This allows for alternate presentations of the knot group.

    gap> arc:=ArcPresentation(PureCubicalKnot(3,1));
    [ [ 2, 5 ], [ 1, 3 ], [ 2, 4 ], [ 3, 5 ], [ 1, 4 ] ]
    gap> k:=KnotComplement(arc,"rand");
    Random 2-cell selection is enabled.
    Regular CW-complex of dimension 3

    gap> g:=FundamentalGroup(k); RelatorsOfFpGroup(g);
    #I  there are 2 generators and 1 relator of total length 6
    <fp group of size infinity on the generators [ f1, f2 ]>
    [ f2^-1*f1*f2^-1*f1^-1*f2*f1^-1 ]
    gap> k:=KnotComplement(arc,"rand");
    Random 2-cell selection is enabled.
    Regular CW-complex of dimension 3

    gap> g:=FundamentalGroup(k); RelatorsOfFpGroup(g);
    #I  there are 2 generators and 1 relator of total length 7
    <fp group of size infinity on the generators [ f1, f2 ]>
    [ f1*f2^-2*f1*f2*f1^-1*f2 ]

It is often useful to obtain an inclusion of regular CW-complexes ι : ∂ (N(K)) ↪ B^3 backslash N(K) from the boundary of a tubular neighbourhood of some knot N(K) into its complement in the 3-ball B^3 backslash N(K). The below example does this for the first prime knot on 11 crossings.

    gap> arc:=ArcPresentation(PureCubicalKnot(11,1));
    [ [ 2, 9 ], [ 1, 3 ], [ 2, 6 ], [ 4, 7 ], [ 3, 5 ], [ 6, 10 ], [ 4, 8 ],
      [ 9, 11 ], [ 7, 10 ], [ 1, 8 ], [ 5, 11 ] ]
    gap> k:=KnotComplementWithBoundary(arc);
    Map of regular CW-complexes

    gap> Size(Source(i));
    616
    gap> Size(Target(i));
    1043

Note that we can add n-cells to regular CW-complexes by specifying the (n-1)-cells in their boundaries and (n+1)-cells in their coboundaries.

    gap> k:=KnotComplement([[1,2],[1,2]])!.boundaries;;
    gap> Homology(RegularCWComplex(k),0);
    [ 0 ]
    gap> AddCell(k,0,[0],[]);
    gap> Homology(RegularCWComplex(k),0);
    [ 0, 0 ]

#### 16.2 Tubular neighbourhoods

Let Y denote a CW-subcomplex of a regular CW-complex X and let N(Y) denote an open tubular neighbourhood of Y. Given an inclusion of regular CW-complexes f : Y ↪ X, this algorithm describes a procedure for obtaining the associated inclusion f' : ∂ C ↪ C where C=X backslash N(Y) and ∂ C denotes the boundary of C. The following is also assumed:

Let e^n denote a cell of X backslash Y of dimension n with bare^n denoting its closure. For each n-cell, all of the connected components of the subcomplex bare^n ∩ Y are contractible.

Some additional terminology and notation is needed to describe this algorithm. The output regular CW-complex X backslash N(Y) consists of the cell complex X backslash Y as well as some additional cells to maintain regularity. A cell of X backslash N(Y) is referred to as internal if it lies in X backslash Y, it is external otherwise. Let bare^n denote the closure in X of an internal cell e^n. Note that bare^n is a CW-subcomplex of X and so is the intersection bare^n ∩ Y which can be expressed as the union

bare^n ∩ Y = A_1 ∪ A_2 ∪ ⋯ ∪ A_k

of its path components A_i all of which are CW-subcomplexes of Y. For each n-cell of X backslash Y there is one internal n-cell e^n of X backslash N(Y). For n ≥ 1 there is also one external (n-1)-cell f^e^n_A_i for each path component A_i of bare^n ∩ Y. Lastly, we need a method for determining the homological boundary of the internal and external cells:

∙ The boundary of an internal n-cell e^n consists of all those internal (n-1)-cells of bare^n together with all external (n-1)-cells f^e^n_A_i where A_i is a path component of bare^n ∩ Y.

∙ The boundary of an external (n-1)-cell f^e^n_A_i consists of all those external (n-2)-cells f^e^n-1}_B_j where e^n-1 is an (n-1)-cell of bare^n and B_j ⊆ A_i is a path component of A_i.

The following three steps comprise the algorithm.

(1) For each internal n-cell e^n ⊂ X backslash Y, compute the CW-complex bare^n ∩ Y as a union of path components A_1 ∪ A_2 ∪ ⋯ ∪ A_k. This information can be used to determine the number of cells of X backslash N(Y) in each dimension.

(2) Create a list B=[ [ ], [ ], ..., [ ] ] of length dimX +1.

(3) For 0 ≤ n ≤ dimX set B[n+1]=[ b_1, b_2, ..., b_α_n ] where α_n is the number of n-cells in X backslash N(Y) and b_i is a list of integers describing the (n-1)-cells of the i ^ th n-cell of X backslash N(Y). The internal cells will always be listed before the external cells in each sublist. Return B as a regular CW-complex.

The following example computes the tubular neighbourhood of a 1-dimensional subcomplex of a 3-dimensional complex corresponding to the Hopf link embedded in the closed 3-ball.

    gap> arc:=[[2,4],[1,3],[2,4],[1,3]];;
    gap> f:=ArcPresentationToKnottedOneComplex(arc);
    Map of regular CW-complexes

    gap> comp:=RegularCWComplexComplement(f);
    Testing contractibility...
    151 out of 151 cells tested.
    The input is compatible with this algorithm.
    Regular CW-complex of dimension 3

Note that the output of this algorithm is just a regular CW-complex, not an inclusion map. The function `BoundaryMap` can be employed to obtain the boundary of a pure complex. This results in three path components for this example: two corresponding to the boundary of the knotted tori and the other corresponding to the boundary of the 3-ball in which the link was embedded. These path components can be obtained as individual CW-subcomplexes if desired. A CW-subcomplex is represented in HAP as a list [X,s] where X is a regular CW-complex and s is a list of length n whose i^th entry lists the indexing of each (i-1)-cell of the n-dimensional subcomplex of X. CW-subcomplexes and CW maps can be converted between each other interchangeably. This next example obtains the inclusion detailed in the above algorithm, finds the path components of the source of said inclusion, shows that they are in fact disjoint, and then obtains the first four integral homology groups of each component.

    gap> f_:=BoundaryMap(comp);
    Map of regular CW-complexes

    gap> f_:=RegularCWMapToCWSubcomplex(f_);;
    gap> paths:=PathComponentsCWSubcomplex(f_);
    [ [ Regular CW-complex of dimension 3
            ,
          [ [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 18, 19, 20 ],
              [ 1, 2, 3, 4, 5, 6, 13, 14, 15, 16, 17, 18, 33, 34, 35, 46, 47, 48
                 ], [ 11, 12, 13, 14, 15, 16, 35, 36 ] ] ],
      [ Regular CW-complex of dimension 3
            , [ [ 21, 24, 25, 27, 30, 31, 32, 37, 38, 39, 40, 43, 45, 46, 48 ],
              [ 49, 51, 53, 56, 57, 59, 61, 63, 65, 67, 69, 71, 73, 74, 76, 79,
                  82, 83, 86, 87, 90, 91 ], [ 37, 39, 41, 44, 45, 47, 49 ] ] ],
      [ Regular CW-complex of dimension 3
            , [ [ 22, 23, 26, 28, 29, 33, 34, 35, 36, 41, 42, 44, 47, 49, 50 ],
              [ 50, 52, 54, 55, 58, 60, 62, 64, 66, 68, 70, 72, 75, 77, 78, 80,
                  81, 84, 85, 88, 89, 92 ], [ 38, 40, 42, 43, 46, 48, 50 ] ] ] ]
    gap> paths:=List(paths,CWSubcomplexToRegularCWMap);
    [ Map of regular CW-complexes
        , Map of regular CW-complexes
        , Map of regular CW-complexes
         ]
    gap> List([1..3],x->List(Difference([1..3],[x]),y->IntersectionCWSubcomplex(paths[x],paths[y])));
    [ [ [ Regular CW-complex of dimension 3
                , [ [  ], [  ], [  ] ] ], [ Regular CW-complex of dimension 3
                , [ [  ], [  ], [  ] ] ] ], [ [ Regular CW-complex of dimension 3
                , [ [  ], [  ], [  ] ] ], [ Regular CW-complex of dimension 3
                , [ [  ], [  ], [  ] ] ] ], [ [ Regular CW-complex of dimension 3
                , [ [  ], [  ], [  ] ] ], [ Regular CW-complex of dimension 3
                , [ [  ], [  ], [  ] ] ] ] ]

    gap> List(paths,x->List([0..3],y->Homology(Source(x),y)));
    [ [ [ 0 ], [  ], [ 0 ], [  ] ], [ [ 0 ], [ 0, 0 ], [ 0 ], [  ] ],
      [ [ 0 ], [ 0, 0 ], [ 0 ], [  ] ] ]

As previously mentioned, for the tubular neighbourhood algorithm to work, we require that no external cells yield non-contractible path-components in their intersection with the subcomplex. If this is ever the case then we can subdivide the offending cell to prevent this from happening. We have implemented two subdivision algorithms in HAP, one for barycentrically subdividing a given cell, and the other for subdividing an n-cell into as many n-cells as there are (n-1)-cells in its boundary. Barycentric subdivision is integrated into the `RegularCWComplexComplement` function and will be performed automatically as required. The following example shows this automatic subdivision running via the complement of a tubular neighbourhood of the unknot, then obtains an inclusion map from the closure of an arbitrary 3-cell of this complex and then compares the difference in size of the two different subdivisions of a 2-cell in the boundary of this 3-cell.

    gap> arc:=[[1,2],[1,2]];;
    gap> unknot:=ArcPresentationToKnottedOneComplex(arc);
    Map of regular CW-complexes

    gap> f:=RegularCWComplexComplement(unknot);
    Testing contractibility...
    79 out of 79 cells tested.
    Subdividing 3 cell(s):
    100% complete.
    Testing contractibility...
    145 out of 145 cells tested.
    The input is compatible with this algorithm.
    Regular CW-complex of dimension 3

    gap> f:=Objectify(HapRegularCWMap,rec(source:=f,target:=f,mapping:={i,j}->j));
    Map of regular CW-complexes

    gap> closure:=ClosureCWCell(Target(f),3,1);
    [ Regular CW-complex of dimension 3
        ,
      [ [ 1, 2, 3, 4, 7, 8, 9, 10, 11, 13, 14, 20, 21, 22, 23, 25 ],
          [ 1, 2, 3, 7, 8, 9, 10, 11, 15, 16, 17, 20, 21, 22, 23, 24, 25, 27, 28, 55, 58, 59,
              60, 63 ], [ 1, 4, 7, 8, 9, 13, 14, 15, 18, 52 ], [ 1 ] ] ]
    gap> Size(Target(f));
    195
    gap> Size(Target(BarycentricallySubdivideCell(f,2,1)));
    231
    gap> Size(Target(SubdivideCell(f,2,1)));
    207

#### 16.3 Knotted surface complements in the 4-ball

A construction of Satoh's, the tube map, associates a ribbon torus-knot to virtual knot diagrams. A virtual knot diagram differs from a knot diagram in that it allows for a third type of crossing, a virtual crossing. The image of such a crossing via the tube map is two tori which pass through each other. An arc diagram is a triple of lists `[arc,cross,cols]` that encode virtual knot diagrams. `arc` is an arc presentation. `cross` is a list of length the number of crossings in the knot associated to the arc presentation whose entries are -1,0 or 1 corresponding to an undercrossing (horizontal arc underneath vertical arc), a virtual crossing (depicted by intersecting horizontal and vertical arcs) and an overcrossing (horizontal arc above vertical arc) respectively. `cols` is a list of length the number of 0 entries in `cross` and its entries are 1,2,3 or 4. It describes the types of 'colourings' we assign to the virtual crossings. We interpret each integer as the change in 4-dimensional height information as represented by a colour scale from blue (lower down in 4-space), to green (0 level), to red (higher up in 4-space). Without loss of generality, we impose that at each virtual crossing, the vertical arc passes through the horizontal arc. Thus, 1 corresponds to the vertical bar entering the horizontal bar as blue and leaving as blue, 2 corresponds to entering as blue and leaving as red, 3 corresponds to entering as red and leaving as blue and 4 corresponds to entering and leaving as red. A coloured arc diagram can be visualised using the `ViewColouredArcDiagram` function.

    gap> arc:=ArcPresentation(PureCubicalKnot(6,1));
    [ [ 5, 8 ], [ 4, 6 ], [ 3, 5 ], [ 2, 4 ], [ 1, 3 ], [ 2, 7 ], [ 6, 8 ], [ 1, 7 ] ]
    gap> cross:=[0,0,1,-1,-1,0];;
    gap> cols:=[1,4,3];;
    gap> ViewArc2Presentation([arc,cross,cols]);
    convert-im6.q16: pixels are not authentic `/tmp/HAPtmpImage.txt' @ error/cache.c/QueueAuthenticPixelCacheNexus/4381.

Towards obtaining a regular CW-decomposition of ribbon torus-knots, we first begin by embedding a self-intersecting knotted torus in the 3-ball. The function `ArcDiagramToTubularSurface` inputs a coloured arc diagram and outputs an inclusion from the boundary of some (potentially self-intersecting) torus in the 3-ball. By inputting just an arc presentation, one can obtain an inclusion identical to the `KnotComplementWithBoundary` function. By additionally inputting a list of -1s and 1s, one can obtain an inclusion similar to `KnotComplementWithBoundary` but where there is extra freedom in determining whether or not a given crossing is an under/overcrossing. If one inputs both of the above but includes 0 entries in the `cross` list and includes the list of colours, the output is then an inclusion from an embedded self-intersecting torus into the 3-ball where each 2-cell (the top-dimensional cells of the self-intersecting surface) is assigned a colour.

    gap> tub:=ArcDiagramToTubularSurface(arc);
    Map of regular CW-complexes

    gap> tub:=ArcDiagramToTubularSurface([arc,cross]);
    Map of regular CW-complexes

    gap> tub:=ArcDiagramToTubularSurface([arc,cross,cols]);
    Map of regular CW-complexes

    gap> List([1..Length(Source(tub)!.boundaries[3])],x->tub!.colour(2,tub!.mapping(2,x)));
    [ [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ],
      [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ],
      [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ],
      [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ],
      [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ -1 ], [ -1 ],
      [ 0 ], [ 0 ], [ -1 ], [ -1 ], [ -1 ], [ -1 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 1 ], [ 1 ],
      [ 0 ], [ 0 ], [ 1 ], [ 1 ], [ 1 ], [ 1 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 1 ], [ 1 ], [ 0 ],
      [ 0 ], [ -1 ], [ -1 ], [ 1 ], [ -1 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ -1 ], [ -1 ], [ 0 ],
      [ 1 ], [ 1 ], [ 0 ], [ 0 ], [ 0 ], [ 0 ], [ 1 ], [ -1 ], [ 0 ] ]

From this self-intersecting surface with colour, we can lift it to a surface without self-intersections in R^4. We do this by constructing a regular CW-complex of the direct product B^3 × [a,b] where B^3 denotes the 3-ball, a is 1 less than the smallest integer assigned to a cell by the colouring, and b is 1 greater than the largest integer assigned to a cell by the colouring. The subcomplex of the direct product corresponding to the surface without intersection can be obtained using the colouring with additional care taken to not lift any 1-cells arising as double-point singularities. The following example constructs the complement of a ribbon torus-link embedded in R^4 obtained from the Hopf link with one virtual crossing and then calculates some invariants of the resulting space. We compare the size of this complex, as well as how long it takes to obtain the same invariants, with a cubical complex of the same space. As barycentric subdivision can massively increase the size of the cell complex, the below method sequentially obtains the tubular neighbourhood of the entire subcomplex by obtaining the tubular neighbourhood of each individual 2-cell. This has yet to be optimised so it currently takes some time to complete.

    gap> arc:=[[2,4],[1,3],[2,4],[1,3]];;
    gap> tub:=ArcDiagramToTubularSurface([arc,[0,-1],[2]]);
    Map of regular CW-complexes

    gap> tub:=LiftColouredSurface(tub);
    Map of regular CW-complexes

    gap> Dimension(Source(tub));
    2
    gap> Dimension(Source(tub));
    4
    gap> map:=RegularCWMapToCWSubcomplex(tub);;
    gap> sub:=SortedList(map[2][3]);;
    gap> sub:=List(sub,x->x-(Position(sub,x)-1));;
    gap> clsr:=ClosureCWCell(map[1],2,sub[1])[2];;
    gap> seq:=CWSubcomplexToRegularCWMap([map[1],clsr]);;
    gap> tub:=RegularCWComplexComplement(seq);
    Testing contractibility...
    3501 out of 3501 cells tested.
    The input is compatible with this algorithm.
    gap> for i in [2..Length(sub)] do
    >     clsr:=ClosureCWCell(tub,2,sub[i])[2];;
    >     seq:=CWSubcomplexToRegularCWMap([tub,clsr]);;
    >     tub:=RegularCWComplexComplement(seq);
    > od;
    Testing contractibility...
    3612 out of 3612 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    3693 out of 3693 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    3871 out of 3871 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    3925 out of 3925 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    4084 out of 4084 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    4216 out of 4216 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    4348 out of 4348 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    4529 out of 4529 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    4688 out of 4688 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    4723 out of 4723 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    4918 out of 4918 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    5107 out of 5107 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    5269 out of 5269 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    5401 out of 5401 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    5548 out of 5548 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    5702 out of 5702 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    5846 out of 5846 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    6027 out of 6027 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    6089 out of 6089 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    6124 out of 6124 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    6159 out of 6159 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    6349 out of 6349 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    6467 out of 6467 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    6639 out of 6639 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    6757 out of 6757 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    6962 out of 6962 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    7052 out of 7052 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    7242 out of 7242 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    7360 out of 7360 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    7470 out of 7470 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    7561 out of 7561 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    7624 out of 7624 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    7764 out of 7764 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    7904 out of 7904 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    7979 out of 7979 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    8024 out of 8024 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    8086 out of 8086 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    8148 out of 8148 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    8202 out of 8202 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    8396 out of 8396 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    8534 out of 8534 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    8625 out of 8625 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    8736 out of 8736 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    8817 out of 8817 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    8983 out of 8983 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    9073 out of 9073 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    9218 out of 9218 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    9323 out of 9323 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    9442 out of 9442 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    9487 out of 9487 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    9538 out of 9538 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    9583 out of 9583 cells tested.
    The input is compatible with this algorithm.
    Testing contractibility...
    9634 out of 9634 cells tested.
    The input is compatible with this algorithm.
    gap> Size(tub);
    9685
    gap> total_time_1:=0;;
    gap> List([0..4],x->Homology(tub,x)); total_time_1:=total_time_1+time;;
    [ [ 0 ], [ 0, 0 ], [ 0, 0, 0, 0 ], [ 0, 0 ], [  ] ]
    gap> c:=ChainComplexOfUniversalCover(tub);; total_time_1:=total_time_1+time;;
    gap> l:=Filtered(LowIndexSubgroups(c!.group,5),g->Index(c!.group,g)=5);; total_time_1:=total_time_1+time;;
    gap> inv:=Set(l,g->Homology(TensorWithIntegersOverSubgroup(c,g),2)); total_time_1:=total_time_1+time;;
    [ [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]
     ]
    gap> total_time_1;
    3407
    gap> hopf:=PureComplexComplement(HopfSatohSurface());;
    gap> hopf:=RegularCWComplex(hopf);;
    gap> Size(hopf);
    4508573
    gap> total_time_2:=0;;
    gap> c_:=ChainComplexOfUniversalCover(hopf);; total_time_2:=total_time_2+time;;
    gap> l_:=Filtered(LowIndexSubgroups(c_!.group,5),g->Index(c_!.group,g)=5);; total_time_2:=total_time_2+time;;
    gap> inv_:=Set(l_,g->Homology(TensorWithIntegersOverSubgroup(c_,g),2));; total_time_2:=total_time_2+time;;
    gap> total_time_2;
    1116000
    gap> inv_=inv;
    true

[Top of Book] [Contents] [Previous Chapter] [Next Chapter]
Goto Chapter: Top 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 Bib Ind

generated by GAPDoc2HTML