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.
  
    Example  
    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.
  
    Example  
    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.
  
    Example  
    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.
  
    Example  
    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.
  
    Example  
    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.
  
    Example  
    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.
  
    Example  
    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.
  
    Example  
    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.
  
    Example  
    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.
  
    Example  
    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