  
  [1m[4m[31m6. Bistellar flips[0m
  
  
  [1m[4m[31m6.1 Theory[0m
  
  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).
  
  
  [1m[4m[31m6.2 Functions for bistellar flips[0m
  
  [1m[4m[31m6.2-1 SCBistellarOptions[0m
  
  [1m[34m> SCBistellarOptions( [0m[22m[34m[0m[1m[34m ) ___________________________________________[0mproperty
  
  Record  of  global variables to adjust output an behavior of bistellar moves
  in    [1m[34mSCIntFunc.SCChooseMove[0m    ([1m6.2-4[0m)   and   [1m[34mSCReduceComplexEx[0m   ([1m6.2-13[0m)
  respectively.
  
  (1)   [22m[32mBaseRelaxation[0m:  determines  the  length  of  the  relaxation  period.
        Default: 3
  
  (2)   [22m[32mBaseHeating[0m: determines the length of the heating period. Default: 4
  
  (3)   [22m[32mRelaxation[0m: value of the current relaxation period. Default: 0
  
  (4)   [22m[32mHeating[0m: value of the current heating period. Default: 0
  
  (5)   [22m[32mMaxRounds[0m:  maximal  over  all  number of bistellar flips that will be
        performed. Default: 500000
  
  (6)   [22m[32mMaxInterval[0m:  maximal number of bistellar flips that will be performed
        without a change of the moved complex. Default: 100000
  
  (7)   [22m[32mMode[0m:  flip  mode,  0=reducing,  1=comparing,  2=reduce as subcomplex.
        Default: 0
  
  (8)   [22m[32mLogLevel[0m: 0=no logging, 1=reduced logging, 2=full logging, information
        about every flip. Default: 2
  
  (9)   [22m[32mWriteLevel[0m:  0=no output, 1=storing of every vertex minimal complex to
        user library, 2=e-mail notification. Default: 1
  
  (10)  [22m[32mMailNotifyIntervall[0m:  (minimum)  number  of seconds between two e-mail
        notifications. Default: 24 * 60 * 60 (one day)
  
  (11)  [22m[32mMaxIntervalIsManifold[0m:  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
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m gap> SCBistellarOptions.BaseRelaxation;[0m
    [22m[35m 3[0m
    [22m[35m gap> SCBistellarOptions.BaseHeating;[0m
    [22m[35m 4[0m
    [22m[35m gap> SCBistellarOptions.Relaxation;[0m
    [22m[35m 0[0m
    [22m[35m gap> SCBistellarOptions.Heating;[0m
    [22m[35m 0[0m
    [22m[35m gap> SCBistellarOptions.MaxRounds;[0m
    [22m[35m 500000[0m
    [22m[35m gap> SCBistellarOptions.MaxInterval;[0m
    [22m[35m 100000[0m
    [22m[35m gap> SCBistellarOptions.Mode;[0m
    [22m[35m 0[0m
    [22m[35m gap> SCBistellarOptions.LogLevel;[0m
    [22m[35m 2[0m
    [22m[35m gap> SCBistellarOptions.WriteLevel;[0m
    [22m[35m 1[0m
    [22m[35m gap> SCBistellarOptions.MailNotifyInterval;[0m
    [22m[35m 86400[0m
    [22m[35m gap> SCBistellarOptions.MaxIntervalIsManifold;[0m
    [22m[35m 5000[0m
    [22m[35m [0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m6.2-2 SCEquivalent[0m
  
  [1m[34m> SCEquivalent( [0m[22m[34mcomplex1, complex2[0m[1m[34m ) _______________________________[0mfunction
  [1mReturns:[0m  [22m[32mtrue[0m / [22m[32mfalse[0m upon success, [22m[32mfail[0m otherwise.
  
  Tests,  whether the closed simplicial pseudomanifold [22m[34mcomplex1[0m can be reduced
  via  bistellar  moves  to  [22m[34mcomplex2[0m, i. e. whether [22m[34mcomplex1[0m and [22m[34mcomplex2[0m are
  PL-homeomorphic. Note, that in general the problem is undecidable.
  
  It  is  recommended to use a minimal triangulation of [22m[34mcomplex2[0m for the check
  if possible.
  
  Internally                      calls                      [1m[34mSCReduceComplexEx[0m
  ([1m6.2-13[0m)[22m[32m(complex1,complex2,1,SCIntFunc.SCChooseMove);[0m
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m # hexagon[0m
    [22m[35m gap> obj:=SC([[1,2],[2,3],[3,4],[4,5],[5,6],[6,1]]);;[0m
    [22m[35m # triangle as a (minimal) reference object[0m
    [22m[35m gap> refObj:=SCBdSimplex(2);;[0m
    [22m[35m gap> SCEquivalent(obj,refObj);[0m
    [22m[35m #I  round 0: [ 5, 5 ][0m
    [22m[35m #I  round 1: [ 4, 4 ][0m
    [22m[35m #I  round 2: [ 3, 3 ][0m
    [22m[35m #I  SCReduceComplexEx: complexes are bistellarly equivalent.[0m
    [22m[35m true[0m
    [22m[35m [0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m6.2-3 SCExamineComplexBistellar[0m
  
  [1m[34m> SCExamineComplexBistellar( [0m[22m[34mcomplex[0m[1m[34m ) _____________________________[0mfunction
  [1mReturns:[0m  simplicial  complex  passed as argument with additional properties
            upon success, [22m[32mfail[0m otherwise.
  
  Computes  face  lattice,  f-vector,  AS-determinant,  dimension  and maximal
  vertex label of [22m[34mcomplex[0m.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m gap> obj:=SC([[1,2],[2,3],[3,4],[4,5],[5,6],[6,1]]);[0m
    [22m[35m [SimplicialComplex[0m
    [22m[35m [0m
    [22m[35m  Properties known: Dim, Facets, Name, VertexLabels.[0m
    [22m[35m [0m
    [22m[35m  Name="unnamed complex n"[0m
    [22m[35m  Dim=1[0m
    [22m[35m [0m
    [22m[35m /SimplicialComplex][0m
    [22m[35m gap> SCExamineComplexBistellar(obj);[0m
    [22m[35m [SimplicialComplex[0m
    [22m[35m [0m
    [22m[35m  Properties known: AltshulerSteinberg, Boundary, Chi, Dim, F, Faces, Facets, [0m
    [22m[35m                    HasBoundary, IsPM, IsPure, Name, VertexLabels.[0m
    [22m[35m [0m
    [22m[35m  Name="unnamed complex 21"[0m
    [22m[35m  Dim=1[0m
    [22m[35m  Chi=0[0m
    [22m[35m  F=[ 6, 6 ][0m
    [22m[35m  HasBoundary=false[0m
    [22m[35m  IsPM=true[0m
    [22m[35m  IsPure=true[0m
    [22m[35m [0m
    [22m[35m /SimplicialComplex][0m
    [22m[35m [0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m6.2-4 SCIntFunc.SCChooseMove[0m
  
  [1m[34m> SCIntFunc.SCChooseMove( [0m[22m[34mdim, moves[0m[1m[34m ) _____________________________[0mfunction
  [1mReturns:[0m  a  bistellar  move,  i.  e.  a  pair  of  lists upon success, [22m[32mfail[0m
            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  [22m[32mSCIntFunc.SCChooseMove[0m  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
  [22m[32mSCBistellarOptions.BaseHeating[0m  and  [22m[32mSCBistellarOptions.BaseRelaxation[0m.  See
  [1m[34mSCBistellarOptions[0m ([1m6.2-1[0m) for further options.
  
  If this strategy does not work for you, just implement a customized strategy
  and pass it to [1m[34mSCReduceComplexEx[0m ([1m6.2-13[0m).
  
  See [1m[34mSCRMoves[0m ([1m6.2-10[0m) for further information.
  
  [1m[4m[31m6.2-5 SCIsKStackedSphere[0m
  
  [1m[34m> SCIsKStackedSphere( [0m[22m[34mcomplex, k[0m[1m[34m ) _________________________________[0mfunction
  [1mReturns:[0m  an integer value upon success, [22m[32mfail[0m otherwise.
  
  Checks,  whether  the  given  [22m[34mcomplex[0m  that  must  be a homology sphere is a
  [22m[34mk[0m-stacked sphere by a randomized algorithm based on bistellar moves. Returns
  an integer less or equal to [22m[34mk[0m, where a positive return value of [22m[32mi[0m means that
  the  complex is [22m[32mi[0m-stacked, a zero return value means that the complex cannot
  be [22m[34mk[0m-stacked and -1 if the question could not be decided.
  
  Internally calls [1m[34mSCReduceComplexEx[0m ([1m6.2-13[0m).
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m gap> SCLib.SearchByName("S^4~S^1");[0m
    [22m[35m [ [ 204, "S^4~S^1 (VT)" ], [ 339, "S^4~S^1 (VT)" ], [ 341, "S^4~S^1 (VT)" ], [0m
    [22m[35m   [ 438, "S^4~S^1 (VT)" ], [ 493, "S^4~S^1 (VT)" ], [ 494, "S^4~S^1 (VT)" ], [0m
    [22m[35m   [ 495, "S^4~S^1 (VT)" ], [ 496, "S^4~S^1 (VT)" ], [ 497, "S^4~S^1 (VT)" ], [0m
    [22m[35m   [ 500, "S^4~S^1 (VT)" ], [ 501, "S^4~S^1 (VT)" ], [ 502, "S^4~S^1 (VT)" ] ][0m
    [22m[35m gap> c:=SCLib.Load(204);;[0m
    [22m[35m gap> l:=c.Link(1);[0m
    [22m[35m [SimplicialComplex[0m
    [22m[35m [0m
    [22m[35m  Properties known: Dim, Facets, Name, VertexLabels.[0m
    [22m[35m [0m
    [22m[35m  Name="lk(1) in S^4~S^1 (VT)"[0m
    [22m[35m  Dim=4[0m
    [22m[35m [0m
    [22m[35m /SimplicialComplex][0m
    [22m[35m gap> SCIsKStackedSphere(l,1);[0m
    [22m[35m #I  SCIsKStackedSphere: try 1/50[0m
    [22m[35m #I  round 0: [ 11, 40, 70, 65, 26 ][0m
    [22m[35m #I  round 1: [ 10, 35, 60, 55, 22 ][0m
    [22m[35m #I  round 2: [ 9, 30, 50, 45, 18 ][0m
    [22m[35m #I  round 3: [ 8, 25, 40, 35, 14 ][0m
    [22m[35m #I  round 4: [ 7, 20, 30, 25, 10 ][0m
    [22m[35m #I  round 5: [ 6, 15, 20, 15, 6 ][0m
    [22m[35m #I  SCReduceComplexEx: computed locally minimal complex after 6 rounds.[0m
    [22m[35m 1[0m
    [22m[35m gap> [0m
    [22m[35m [0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m6.2-6 SCIsManifold[0m
  
  [1m[34m> SCIsManifold( [0m[22m[34mcomplex[0m[1m[34m ) __________________________________________[0mfunction
  [1mReturns:[0m  [22m[32mtrue[0m / [22m[32mfalse[0m upon success, [22m[32mfail[0m 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.
  
  [22m[32mfalse[0m 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  [1m[34mSCReduceComplexEx[0m  ([1m6.2-13[0m)[22m[32m(link,SCEmpty(),0,SCIntFunc.SCChooseMove);[0m
  for every link of [22m[34mcomplex[0m. Note, that [22m[32mfalse[0m is returned in case of a bounded
  manifold.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m gap> c:=SCBdCrossPolytope(3);;[0m
    [22m[35m gap> SCIsManifold(c);[0m
    [22m[35m #I  SCIsManifold: processing vertex link 1/6[0m
    [22m[35m #I  round 0: [ 3, 3 ][0m
    [22m[35m #I  SCReduceComplexEx: computed locally minimal complex after 1 rounds.[0m
    [22m[35m #I  SCIsManifold: link is sphere.[0m
    [22m[35m ...[0m
    [22m[35m #I  SCIsManifold: processing vertex link 6/6[0m
    [22m[35m #I  round 0: [ 3, 3 ][0m
    [22m[35m #I  SCReduceComplexEx: computed locally minimal complex after 1 rounds.[0m
    [22m[35m #I  SCIsManifold: link is sphere.[0m
    [22m[35m true[0m
    [22m[35m [0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m6.2-7 SCIsMovableComplex[0m
  
  [1m[34m> SCIsMovableComplex( [0m[22m[34mcomplex[0m[1m[34m ) ____________________________________[0mfunction
  [1mReturns:[0m  [22m[32mtrue[0m / [22m[32mfalse[0m upon success, [22m[32mfail[0m otherwise.
  
  Checks,  if  [22m[34mcomplex[0m  can  be  modified by bistellar moves, i. e. if it is a
  closed combinatorial pseudomanifold.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m gap> c:=SCBdCrossPolytope(3);;[0m
    [22m[35m gap> SCIsMovableComplex(c);[0m
    [22m[35m true[0m
    [22m[35m [0m
  [22m[35m------------------------------------------------------------------[0m
  
  Bounded pseudomanifold
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m gap> c:=SC([[1,2],[2,3],[3,4],[3,1]]);;[0m
    [22m[35m gap> SCIsMovableComplex(c);[0m
    [22m[35m false[0m
    [22m[35m [0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m6.2-8 SCMove[0m
  
  [1m[34m> SCMove( [0m[22m[34mcomplex, move[0m[1m[34m ) __________________________________________[0mfunction
  [1mReturns:[0m  a new simplicial complex in standard labeling.
  
  Applies  the  bistellar move [22m[34mmove[0m to [22m[34mcomplex[0m. [22m[34mmove[0m is given as a (r+1)-tuple
  together with a (d+1-r)-tuple if d is the dimension of [22m[34mcomplex[0m an if [22m[34mmove[0m is
  a  r-move.  See  [1m[34mSCRMoves[0m  ([1m6.2-10[0m) for detailed information about bistellar
  r-Moves.
  
  Note:  [22m[34mmove[0m  and  [22m[34mcomplex[0m  should  be given in standard labeling to ensure a
  correct result.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m gap> obj:=SC([[1,2],[2,3],[3,4],[4,1]]);[0m
    [22m[35m [SimplicialComplex[0m
    [22m[35m[0m
    [22m[35m Properties known: Dim, Facets, Name, VertexLabels.[0m
    [22m[35m[0m
    [22m[35m Name="unnamed complex n"[0m
    [22m[35m Dim=1[0m
    [22m[35m[0m
    [22m[35m /SimplicialComplex][0m
    [22m[35m gap> moves:=SCMoves(obj);[0m
    [22m[35m [[[[1, 2], []], [[1, 4], []], [0m
    [22m[35m     [[2, 3], []], [[3, 4], []]], [0m
    [22m[35m   [[[1], [2, 4]], [[2], [1, 3]], [0m
    [22m[35m     [[3], [2, 4]], [[4], [1, 3]]]][0m
    [22m[35m gap> obj:=SCMove(obj,last[2][1]);[0m
    [22m[35m [SimplicialComplex[0m
    [22m[35m [0m
    [22m[35m  Properties known: Chi, Dim, F, Faces, Facets, VertexLabels.[0m
    [22m[35m[0m
    [22m[35m  Name="unnamed complex n"[0m
    [22m[35m  Dim=1[0m
    [22m[35m  Chi=0[0m
    [22m[35m  F=[3, 3][0m
    [22m[35m [0m
    [22m[35m /SimplicialComplex][0m
    [22m[35m [0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m6.2-9 SCMoves[0m
  
  [1m[34m> SCMoves( [0m[22m[34mcomplex[0m[1m[34m ) _______________________________________________[0mfunction
  [1mReturns:[0m  a list of list of pairs of lists upon success, [22m[32mfail[0m otherwise.
  
  See [1m[34mSCRMoves[0m ([1m6.2-10[0m) for further information.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m gap> c:=SCBdCrossPolytope(3);;[0m
    [22m[35m gap> moves:=SCMoves(c);[0m
    [22m[35m [[0m
    [22m[35m # 0-moves[0m
    [22m[35m   [[[1, 3, 5], []], [[1, 3, 6], []], [[1, 4, 5], []], [0m
    [22m[35m     [[1, 4, 6], []], [[2, 3, 5], []], [[2, 3, 6], []],[0m
    [22m[35m     [[2, 4, 5], []], [[2, 4, 6], []]], [0m
    [22m[35m # 1-moves[0m
    [22m[35m   [[[1, 3], [5, 6]], [[1, 4], [5, 6]], [[1, 5], [3, 4]], [0m
    [22m[35m     [[1, 6], [3, 4]], [[2, 3], [5, 6]], [[2, 4], [5, 6]], [0m
    [22m[35m     [[2, 5], [3, 4]], [[2, 6], [3, 4]], [[3, 5], [1, 2]], [0m
    [22m[35m     [[3, 6], [1, 2]], [[4, 5], [1, 2]], [[4, 6], [1, 2]]],[0m
    [22m[35m # 2-moves[0m
    [22m[35m   [] [0m
    [22m[35m][0m
    [22m[35m [0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m6.2-10 SCRMoves[0m
  
  [1m[34m> SCRMoves( [0m[22m[34mcomplex, r[0m[1m[34m ) ___________________________________________[0mfunction
  [1mReturns:[0m  a list of pairs of the form [22m[32m[ list, list ][0m.
  
  A  bistellar  r-move  of a d-dimensional combinatorial manifold [22m[34mcomplex[0m 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 [22m[34mcomplex[0m.
  
  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 [22m[34mcomplex[0m.
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m gap> c:=SCBdCrossPolytope(3);;[0m
    [22m[35m gap> moves:=SCRMoves(c,1);[0m
    [22m[35m [ [ [ 1, 3 ], [ 5, 6 ] ], [ [ 1, 4 ], [ 5, 6 ] ], [ [ 1, 5 ], [ 3, 4 ] ], [0m
    [22m[35m   [ [ 1, 6 ], [ 3, 4 ] ], [ [ 2, 3 ], [ 5, 6 ] ], [ [ 2, 4 ], [ 5, 6 ] ], [0m
    [22m[35m   [ [ 2, 5 ], [ 3, 4 ] ], [ [ 2, 6 ], [ 3, 4 ] ], [ [ 3, 5 ], [ 1, 2 ] ], [0m
    [22m[35m   [ [ 3, 6 ], [ 1, 2 ] ], [ [ 4, 5 ], [ 1, 2 ] ], [ [ 4, 6 ], [ 1, 2 ] ] ][0m
    [22m[35m [0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m6.2-11 SCReduceAsSubcomplex[0m
  
  [1m[34m> SCReduceAsSubcomplex( [0m[22m[34mcomplex1, complex2[0m[1m[34m ) _______________________[0mfunction
  [1mReturns:[0m  [22m[32mSCBistellarOptions.WriteLevel=0[0m:  a  triple of the form [22m[32m[ boolean,
            simplicial  complex,  rounds  performed  ][0m upon termination of the
            algorithm.
            [22m[32mSCBistellarOptions.WriteLevel=1[0m: A library of simplicial complexes
            with  all vertex minimal complexes and (upon termination) a triple
            of the form [22m[32m[ boolean, simplicial complex, rounds performed ][0m.
            [22m[32mSCBistellarOptions.WriteLevel=2[0m:  A mail in case a smaller version
            of  [22m[34mcomplex1[0m was found, a library of simplicial complexes with all
            vertex  minimal  complexes  and (upon termination) a triple of the
            form  [22m[32m[  boolean,  simplicial  complex,  rounds  performed  ][0m upon
            termination of the algorithm.
            Returns [22m[32mfail[0m upon an error.
  
  Reduces  a  closed  simplicial  pseudomanifold  [22m[34mcomplex1[0m  as a subcomplex of
  [22m[34mcomplex2[0m.
  
  Main  application:  Reduce  a  subcomplex  of  the  cross  polytope  without
  introducing diagonals.
  
  Internally                      calls                      [1m[34mSCReduceComplexEx[0m
  ([1m6.2-13[0m)[22m[32m(complex1,complex2,2,SCIntFunc.SCChooseMove);[0m
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m gap> c:=SCFromFacets([[1,3],[3,5],[4,5],[4,1]]);;[0m
    [22m[35m gap> SCReduceAsSubcomplex(c,SCBdCrossPolytope(3));[0m
    [22m[35m #I  round 0, move: [ [ 2 ], [ 1, 4 ] ][0m
    [22m[35m [ 3, 3 ][0m
    [22m[35m #I  SCReduceComplexEx: computed locally minimal complex after 1 rounds.[0m
    [22m[35m [ true, [SimplicialComplex[0m
    [22m[35m     [0m
    [22m[35m      Properties known: Dim, Facets, Name, VertexLabels.[0m
    [22m[35m     [0m
    [22m[35m      Name="unnamed complex 9"[0m
    [22m[35m      Dim=1[0m
    [22m[35m     [0m
    [22m[35m     /SimplicialComplex], 1 ][0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m6.2-12 SCReduceComplex[0m
  
  [1m[34m> SCReduceComplex( [0m[22m[34mcomplex[0m[1m[34m ) _______________________________________[0mfunction
  [1mReturns:[0m  [22m[32mSCBistellarOptions.WriteLevel=0[0m:  a  triple of the form [22m[32m[ boolean,
            simplicial  complex,  rounds  performed  ][0m upon termination of the
            algorithm.
            [22m[32mSCBistellarOptions.WriteLevel=1[0m: A library of simplicial complexes
            with  all vertex minimal complexes and (upon termination) a triple
            of the form [22m[32m[ boolean, simplicial complex, rounds performed ][0m.
            [22m[32mSCBistellarOptions.WriteLevel=2[0m:  A mail in case a smaller version
            of  [22m[34mcomplex1[0m was found, a library of simplicial complexes with all
            vertex  minimal  complexes  and (upon termination) a triple of the
            form  [22m[32m[  boolean,  simplicial  complex,  rounds  performed  ][0m upon
            termination of the algorithm.
            Returns [22m[32mfail[0m upon an error..
  
  Reduces  a  closed simplicial pseudomanifold via bistellar moves. Internally
  calls                                                      [1m[34mSCReduceComplexEx[0m
  ([1m6.2-13[0m)[22m[32m(complex,SCEmpty(),0,SCIntFunc.SCChooseMove);[0m
  
  [22m[35m---------------------------  Example  ----------------------------[0m
    [22m[35m # hexagon[0m
    [22m[35m gap> obj:=SC([[1,2],[2,3],[3,4],[4,5],[5,6],[6,1]]);;[0m
    [22m[35m gap> SCReduceComplex(obj);[0m
    [22m[35m #I  round 0, move: [ [ 6 ], [ 1, 5 ] ][0m
    [22m[35m [ 5, 5 ][0m
    [22m[35m #I  round 1, move: [ [ 4 ], [ 3, 5 ] ][0m
    [22m[35m [ 4, 4 ][0m
    [22m[35m #I  round 2, move: [ [ 3 ], [ 2, 5 ] ][0m
    [22m[35m [ 3, 3 ][0m
    [22m[35m #I  SCReduceComplexEx: computed locally minimal complex after 3 rounds.[0m
    [22m[35m [ true, [SimplicialComplex[0m
    [22m[35m     [0m
    [22m[35m      Properties known: Dim, Facets, Name, VertexLabels.[0m
    [22m[35m     [0m
    [22m[35m      Name="unnamed complex 6"[0m
    [22m[35m      Dim=1[0m
    [22m[35m     [0m
    [22m[35m     /SimplicialComplex], 3 ][0m
    [22m[35m ## [0m
  [22m[35m------------------------------------------------------------------[0m
  
  [1m[4m[31m6.2-13 SCReduceComplexEx[0m
  
  [1m[34m> SCReduceComplexEx( [0m[22m[34mcomplex, refComplex, mode, choosemove[0m[1m[34m ) _______[0mfunction
  [1mReturns:[0m  [22m[32mSCBistellarOptions.WriteLevel=0[0m:  a  triple of the form [22m[32m[ boolean,
            simplicial complex, rounds ][0m upon termination of the algorithm.
            [22m[32mSCBistellarOptions.WriteLevel=1[0m: A library of simplicial complexes
            with  all vertex minimal complexes and (upon termination) a triple
            of the form [22m[32m[ boolean, simplicial complex, rounds ][0m.
            [22m[32mSCBistellarOptions.WriteLevel=2[0m:  A mail in case a smaller version
            of  [22m[34mcomplex1[0m was found, a library of simplicial complexes with all
            vertex  minimal  complexes  and (upon termination) a triple of the
            form  [22m[32m[  boolean, simplicial complex, rounds ][0m upon termination of
            the algorithm.
            Returns [22m[32mfail[0m upon an error.
  
  Reduces  a  closed  simplicial pseudomanifold ([22m[34mcomplex[0m) via bistellar moves.
  Compares  it  ("mode"=1)  to  [22m[34mrefComplex[0m  or  reduces  it as a subcomplex of
  [22m[34mrefComplex[0m ([22m[34mmode[0m=2).
  
  [22m[34mchoosemove[0m  is  a function containing a flip strategy for the flip sequence,
  see also [1m[34mSCIntFunc.SCChooseMove[0m ([1m6.2-4[0m).
  
  The  currently  minimal  complex  is  stored to the variable [22m[32mminComplex[0m, the
  currently minimal f-vector to [22m[32mminF[0m. 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 [1m[34mSCBistellarOptions[0m ([1m6.2-1[0m). The
  number  of  rounds  performed  is  returned in the third entry of the triple
  returned by this function.
  This function is called by
  
  (1)   [1m[34mSCReduceComplex[0m ([1m6.2-12[0m),
  
  (2)   [1m[34mSCEquivalent[0m ([1m6.2-2[0m),
  
  (3)   [1m[34mSCReduceAsSubcomplex[0m ([1m6.2-11[0m),
  
  (4)   [1m[34mSCIsManifold[0m ([1m6.2-6[0m).
  
  Please  see  [1m[34mSCMailIsPending[0m ([1m9.2-3[0m) for further information about the email
  notification system in case [22m[32mSCBistellarOptions.WriteLevel=2[0m is set.
  
