Goto Chapter: | Top | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | Bib | Ind

### 6. Bistellar flips

#### 6.1 Theory

Bistellar flips, first introduced by Pachner in [P87] and sometimes also refered to as Pachner moves, can prove useful for the following tasks:

1. Try to decide whether two closed simplicial pseudomanifolds are PL-homeomorphic.

2. Reduce a given triangulation without changing its PL-type.

3. Verify whether a closed simplicial pseudomanifold is a combinatorial manifold.

Bistellar moves are a convenient means to prove the PL equivalence of triangulations, see [L03] for an example.

Since bistellar flips do not respect the combinatorial properties of a complex, no attention to the original vertex labels is payed, i. e. the flipped complex will be relabeled whenever its vertex labels become different from the standard labeling (for example after every reverse 0-move).

#### 6.2 Functions for bistellar flips

##### 6.2-1 SCBistellarOptions

`> SCBistellarOptions`( ) | ( property )

Record of global variables to adjust output an behavior of bistellar moves in `SCIntFunc.SCChooseMove` (6.2-4) and `SCReduceComplexEx` (6.2-13) respectively.

1. `BaseRelaxation`: determines the length of the relaxation period. Default: 3

2. `BaseHeating`: determines the length of the heating period. Default: 4

3. `Relaxation`: value of the current relaxation period. Default: 0

4. `Heating`: value of the current heating period. Default: 0

5. `MaxRounds`: maximal over all number of bistellar flips that will be performed. Default: 500000

6. `MaxInterval`: maximal number of bistellar flips that will be performed without a change of the moved complex. Default: 100000

7. `Mode`: flip mode, 0=reducing, 1=comparing, 2=reduce as subcomplex. Default: 0

8. `LogLevel`: 0=no logging, 1=reduced logging, 2=full logging, information about every flip. Default: 2

9. `WriteLevel`: 0=no output, 1=storing of every vertex minimal complex to user library, 2=e-mail notification. Default: 1

10. `MailNotifyIntervall`: (minimum) number of seconds between two e-mail notifications. Default: 24 * 60 * 60 (one day)

11. `MaxIntervalIsManifold`: maximal number of bistellar flips that will be performed without a change of a vertex link while trying to prove that the complex is a combinatorial manifold. Default: 500

     gap> SCBistellarOptions.BaseRelaxation;
     3
     gap> SCBistellarOptions.BaseHeating;
     4
     gap> SCBistellarOptions.Relaxation;
     0
     gap> SCBistellarOptions.Heating;
     0
     gap> SCBistellarOptions.MaxRounds;
     500000
     gap> SCBistellarOptions.MaxInterval;
     100000
     gap> SCBistellarOptions.Mode;
     0
     gap> SCBistellarOptions.LogLevel;
     2
     gap> SCBistellarOptions.WriteLevel;
     1
     gap> SCBistellarOptions.MailNotifyInterval;
     86400
     gap> SCBistellarOptions.MaxIntervalIsManifold;
     5000

##### 6.2-2 SCEquivalent

`> SCEquivalent`( complex1, complex2 ) | ( function )

Returns: `true` / `false` upon success, `fail` otherwise.

Tests, whether the closed simplicial pseudomanifold complex1 can be reduced via bistellar moves to complex2, i. e. whether complex1 and complex2 are PL-homeomorphic. Note, that in general the problem is undecidable.

It is recommended to use a minimal triangulation of complex2 for the check if possible.

Internally calls `SCReduceComplexEx` (6.2-13)`(complex1,complex2,1,SCIntFunc.SCChooseMove);`

     # hexagon
     gap> obj:=SC([[1,2],[2,3],[3,4],[4,5],[5,6],[6,1]]);;
     # triangle as a (minimal) reference object
     gap> refObj:=SCBdSimplex(2);;
     gap> SCEquivalent(obj,refObj);
     #I  round 0: [ 5, 5 ]
     #I  round 1: [ 4, 4 ]
     #I  round 2: [ 3, 3 ]
     #I  SCReduceComplexEx: complexes are bistellarly equivalent.
     true

##### 6.2-3 SCExamineComplexBistellar

`> SCExamineComplexBistellar`( complex ) | ( function )

Returns: simplicial complex passed as argument with additional properties upon success, `fail` otherwise.

Computes face lattice, f-vector, AS-determinant, dimension and maximal vertex label of complex.

     gap> obj:=SC([[1,2],[2,3],[3,4],[4,5],[5,6],[6,1]]);
     [SimplicialComplex

      Properties known: Dim, Facets, Name, VertexLabels.

      Name="unnamed complex n"
      Dim=1

     /SimplicialComplex]
     gap> SCExamineComplexBistellar(obj);
     [SimplicialComplex

      Properties known: AltshulerSteinberg, Boundary, Chi, Dim, F, Faces, Facets,
                        HasBoundary, IsPM, IsPure, Name, VertexLabels.

      Name="unnamed complex 21"
      Dim=1
      Chi=0
      F=[ 6, 6 ]
      HasBoundary=false
      IsPM=true
      IsPure=true

     /SimplicialComplex]

##### 6.2-4 SCIntFunc.SCChooseMove

`> SCIntFunc.SCChooseMove`( dim, moves ) | ( function )

Returns: a bistellar move, i. e. a pair of lists upon success, `fail` otherwise.

Since the problem of finding a bistellar flip sequence that reduces a simplicial complex is undecidable, we have to use an heuristic approach to choose the next move.

The implemented strategy `SCIntFunc.SCChooseMove` first tries to directly remove vertices, edges, i-faces in increasing dimension etc. If this is not possible it inserts high dimensional faces in decreasing co-dimension. To do this in an efficient way a number of parameters have to be adjusted, namely `SCBistellarOptions.BaseHeating` and `SCBistellarOptions.BaseRelaxation`. See `SCBistellarOptions` (6.2-1) for further options.

If this strategy does not work for you, just implement a customized strategy and pass it to `SCReduceComplexEx` (6.2-13).

See `SCRMoves` (6.2-10) for further information.

##### 6.2-5 SCIsKStackedSphere

`> SCIsKStackedSphere`( complex, k ) | ( function )

Returns: an integer value upon success, `fail` otherwise.

Checks, whether the given complex that must be a homology sphere is a k-stacked sphere by a randomized algorithm based on bistellar moves. Returns an integer less or equal to k, where a positive return value of `i` means that the complex is `i`-stacked, a zero return value means that the complex cannot be k-stacked and -1 if the question could not be decided.

Internally calls `SCReduceComplexEx` (6.2-13).

     gap> SCLib.SearchByName("S^4~S^1");
     [ [ 204, "S^4~S^1 (VT)" ], [ 339, "S^4~S^1 (VT)" ], [ 341, "S^4~S^1 (VT)" ],
       [ 438, "S^4~S^1 (VT)" ], [ 493, "S^4~S^1 (VT)" ], [ 494, "S^4~S^1 (VT)" ],
       [ 495, "S^4~S^1 (VT)" ], [ 496, "S^4~S^1 (VT)" ], [ 497, "S^4~S^1 (VT)" ],
       [ 500, "S^4~S^1 (VT)" ], [ 501, "S^4~S^1 (VT)" ], [ 502, "S^4~S^1 (VT)" ] ]
     gap> c:=SCLib.Load(204);;
     gap> l:=c.Link(1);
     [SimplicialComplex

      Properties known: Dim, Facets, Name, VertexLabels.

      Name="lk(1) in S^4~S^1 (VT)"
      Dim=4

     /SimplicialComplex]
     gap> SCIsKStackedSphere(l,1);
     #I  SCIsKStackedSphere: try 1/50
     #I  round 0: [ 11, 40, 70, 65, 26 ]
     #I  round 1: [ 10, 35, 60, 55, 22 ]
     #I  round 2: [ 9, 30, 50, 45, 18 ]
     #I  round 3: [ 8, 25, 40, 35, 14 ]
     #I  round 4: [ 7, 20, 30, 25, 10 ]
     #I  round 5: [ 6, 15, 20, 15, 6 ]
     #I  SCReduceComplexEx: computed locally minimal complex after 6 rounds.
     1
     gap>

##### 6.2-6 SCIsManifold

`> SCIsManifold`( complex ) | ( function )

Returns: `true` / `false` upon success, `fail` otherwise.

Tries to prove that a closed simplicial d-pseudomanifold is a combinatorial manifold by reducing its vertex links to the boundary of the d-simplex.

`false` is only returned, if a minimal version of a reduced vertex link can be computed which is different from the boundary of the simplex. Internally calls `SCReduceComplexEx` (6.2-13)`(link,SCEmpty(),0,SCIntFunc.SCChooseMove);` for every link of complex. Note, that `false` is returned in case of a bounded manifold.

     gap> c:=SCBdCrossPolytope(3);;
     gap> SCIsManifold(c);
     #I  SCIsManifold: processing vertex link 1/6
     #I  round 0: [ 3, 3 ]
     #I  SCReduceComplexEx: computed locally minimal complex after 1 rounds.
     #I  SCIsManifold: link is sphere.
     ...
     #I  SCIsManifold: processing vertex link 6/6
     #I  round 0: [ 3, 3 ]
     #I  SCReduceComplexEx: computed locally minimal complex after 1 rounds.
     #I  SCIsManifold: link is sphere.
     true

##### 6.2-7 SCIsMovableComplex

`> SCIsMovableComplex`( complex ) | ( function )

Returns: `true` / `false` upon success, `fail` otherwise.

Checks, if complex can be modified by bistellar moves, i. e. if it is a closed combinatorial pseudomanifold.

     gap> c:=SCBdCrossPolytope(3);;
     gap> SCIsMovableComplex(c);
     true

Bounded pseudomanifold

     gap> c:=SC([[1,2],[2,3],[3,4],[3,1]]);;
     gap> SCIsMovableComplex(c);
     false

##### 6.2-8 SCMove

`> SCMove`( complex, move ) | ( function )

Returns: a new simplicial complex in standard labeling.

Applies the bistellar move move to complex. move is given as a (r+1)-tuple together with a (d+1-r)-tuple if d is the dimension of complex an if move is a r-move. See `SCRMoves` (6.2-10) for detailed information about bistellar r-Moves.

Note: move and complex should be given in standard labeling to ensure a correct result.

     gap> obj:=SC([[1,2],[2,3],[3,4],[4,1]]);
     [SimplicialComplex

     Properties known: Dim, Facets, Name, VertexLabels.

     Name="unnamed complex n"
     Dim=1

     /SimplicialComplex]
     gap> moves:=SCMoves(obj);
     [[[[1, 2], []], [[1, 4], []],
         [[2, 3], []], [[3, 4], []]],
       [[[1], [2, 4]], [[2], [1, 3]],
         [[3], [2, 4]], [[4], [1, 3]]]]
     gap> obj:=SCMove(obj,last[2][1]);
     [SimplicialComplex

      Properties known: Chi, Dim, F, Faces, Facets, VertexLabels.

      Name="unnamed complex n"
      Dim=1
      Chi=0
      F=[3, 3]

     /SimplicialComplex]

##### 6.2-9 SCMoves

`> SCMoves`( complex ) | ( function )

Returns: a list of list of pairs of lists upon success, `fail` otherwise.

See `SCRMoves` (6.2-10) for further information.

     gap> c:=SCBdCrossPolytope(3);;
     gap> moves:=SCMoves(c);
     [
     # 0-moves
       [[[1, 3, 5], []], [[1, 3, 6], []], [[1, 4, 5], []],
         [[1, 4, 6], []], [[2, 3, 5], []], [[2, 3, 6], []],
         [[2, 4, 5], []], [[2, 4, 6], []]],
     # 1-moves
       [[[1, 3], [5, 6]], [[1, 4], [5, 6]], [[1, 5], [3, 4]],
         [[1, 6], [3, 4]], [[2, 3], [5, 6]], [[2, 4], [5, 6]],
         [[2, 5], [3, 4]], [[2, 6], [3, 4]], [[3, 5], [1, 2]],
         [[3, 6], [1, 2]], [[4, 5], [1, 2]], [[4, 6], [1, 2]]],
     # 2-moves
       []
    ]

##### 6.2-10 SCRMoves

`> SCRMoves`( complex, r ) | ( function )

Returns: a list of pairs of the form `[ list, list ]`.

A bistellar r-move of a d-dimensional combinatorial manifold complex is a r-face m_1 together with a d-r-tuple m_2 where m_1 is a common face of exactly (d+1-r) facets and m_2 is not a face of complex.

The r-Move removes all facets containing m_1 and replaces them by the (r+1) faces obtained by uniting m_2 with any subset of m_1 of order r.

The resulting complex has the same (PL-)topolgy as complex.

     gap> c:=SCBdCrossPolytope(3);;
     gap> moves:=SCRMoves(c,1);
     [ [ [ 1, 3 ], [ 5, 6 ] ], [ [ 1, 4 ], [ 5, 6 ] ], [ [ 1, 5 ], [ 3, 4 ] ],
       [ [ 1, 6 ], [ 3, 4 ] ], [ [ 2, 3 ], [ 5, 6 ] ], [ [ 2, 4 ], [ 5, 6 ] ],
       [ [ 2, 5 ], [ 3, 4 ] ], [ [ 2, 6 ], [ 3, 4 ] ], [ [ 3, 5 ], [ 1, 2 ] ],
       [ [ 3, 6 ], [ 1, 2 ] ], [ [ 4, 5 ], [ 1, 2 ] ], [ [ 4, 6 ], [ 1, 2 ] ] ]

##### 6.2-11 SCReduceAsSubcomplex

`> SCReduceAsSubcomplex`( complex1, complex2 ) | ( function )

Returns: `SCBistellarOptions.WriteLevel=0`: a triple of the form `[ boolean, simplicial complex, rounds performed ]` upon termination of the algorithm.
`SCBistellarOptions.WriteLevel=1`: A library of simplicial complexes with all vertex minimal complexes and (upon termination) a triple of the form `[ boolean, simplicial complex, rounds performed ]`.
`SCBistellarOptions.WriteLevel=2`: A mail in case a smaller version of complex1 was found, a library of simplicial complexes with all vertex minimal complexes and (upon termination) a triple of the form `[ boolean, simplicial complex, rounds performed ]` upon termination of the algorithm.
Returns `fail` upon an error.

Reduces a closed simplicial pseudomanifold complex1 as a subcomplex of complex2.

Main application: Reduce a subcomplex of the cross polytope without introducing diagonals.

Internally calls `SCReduceComplexEx` (6.2-13)`(complex1,complex2,2,SCIntFunc.SCChooseMove);`

     gap> c:=SCFromFacets([[1,3],[3,5],[4,5],[4,1]]);;
     gap> SCReduceAsSubcomplex(c,SCBdCrossPolytope(3));
     #I  round 0, move: [ [ 2 ], [ 1, 4 ] ]
     [ 3, 3 ]
     #I  SCReduceComplexEx: computed locally minimal complex after 1 rounds.
     [ true, [SimplicialComplex

          Properties known: Dim, Facets, Name, VertexLabels.

          Name="unnamed complex 9"
          Dim=1

         /SimplicialComplex], 1 ]

##### 6.2-12 SCReduceComplex

`> SCReduceComplex`( complex ) | ( function )

Returns: `SCBistellarOptions.WriteLevel=0`: a triple of the form `[ boolean, simplicial complex, rounds performed ]` upon termination of the algorithm.
`SCBistellarOptions.WriteLevel=1`: A library of simplicial complexes with all vertex minimal complexes and (upon termination) a triple of the form `[ boolean, simplicial complex, rounds performed ]`.
`SCBistellarOptions.WriteLevel=2`: A mail in case a smaller version of complex1 was found, a library of simplicial complexes with all vertex minimal complexes and (upon termination) a triple of the form `[ boolean, simplicial complex, rounds performed ]` upon termination of the algorithm.
Returns `fail` upon an error..

Reduces a closed simplicial pseudomanifold via bistellar moves. Internally calls `SCReduceComplexEx` (6.2-13)`(complex,SCEmpty(),0,SCIntFunc.SCChooseMove);`

     # hexagon
     gap> obj:=SC([[1,2],[2,3],[3,4],[4,5],[5,6],[6,1]]);;
     gap> SCReduceComplex(obj);
     #I  round 0, move: [ [ 6 ], [ 1, 5 ] ]
     [ 5, 5 ]
     #I  round 1, move: [ [ 4 ], [ 3, 5 ] ]
     [ 4, 4 ]
     #I  round 2, move: [ [ 3 ], [ 2, 5 ] ]
     [ 3, 3 ]
     #I  SCReduceComplexEx: computed locally minimal complex after 3 rounds.
     [ true, [SimplicialComplex

          Properties known: Dim, Facets, Name, VertexLabels.

          Name="unnamed complex 6"
          Dim=1

         /SimplicialComplex], 3 ]
     ##

##### 6.2-13 SCReduceComplexEx

`> SCReduceComplexEx`( complex, refComplex, mode, choosemove ) | ( function )

Returns: `SCBistellarOptions.WriteLevel=0`: a triple of the form `[ boolean, simplicial complex, rounds ]` upon termination of the algorithm.
`SCBistellarOptions.WriteLevel=1`: A library of simplicial complexes with all vertex minimal complexes and (upon termination) a triple of the form `[ boolean, simplicial complex, rounds ]`.
`SCBistellarOptions.WriteLevel=2`: A mail in case a smaller version of complex1 was found, a library of simplicial complexes with all vertex minimal complexes and (upon termination) a triple of the form `[ boolean, simplicial complex, rounds ]` upon termination of the algorithm.
Returns `fail` upon an error.

Reduces a closed simplicial pseudomanifold (complex) via bistellar moves. Compares it ("mode"=1) to refComplex or reduces it as a subcomplex of refComplex (mode=2).

choosemove is a function containing a flip strategy for the flip sequence, see also `SCIntFunc.SCChooseMove` (6.2-4).

The currently minimal complex is stored to the variable `minComplex`, the currently minimal f-vector to `minF`. Note, that in general the algorithm will not stop until the maximum number of rounds is reached. You can adjust the maximum number of rounds via the property `SCBistellarOptions` (6.2-1). The number of rounds performed is returned in the third entry of the triple returned by this function.
This function is called by

1. `SCReduceComplex` (6.2-12),

2. `SCEquivalent` (6.2-2),

3. `SCReduceAsSubcomplex` (6.2-11),

4. `SCIsManifold` (6.2-6).

Please see `SCMailIsPending` (9.2-3) for further information about the email notification system in case `SCBistellarOptions.WriteLevel=2` is set.

Top of Book | Previous Chapter | Next Chapter

Goto Chapter: | Top | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | Bib | Ind

generated by GAPDoc2HTML