Goto Chapter: Top 1 2 3 4 Bib Ind
Top of Book Previous Chapter Next Chapter

4 Resolutions of Crystallographic Groups
4.1 Fundamental Domains
4.1-1 FundamentalDomainStandardSpaceGroup
4.1-2 FundamentalDomainBieberbachGroup
4.1-3 FundamentalDomainFromGeneralPointAndOrbitPartGeometric
4.1-4 IsFundamentalDomainStandardSpaceGroup
4.1-5 IsFundamentalDomainBieberbachGroup
4.2 Face Lattice and Resolution
4.2-1 ResolutionBieberbachGroup
4.2-2 FaceLatticeAndBoundaryBieberbachGroup
4.2-3 ResolutionFromFLandBoundary

### 4 Resolutions of Crystallographic Groups

#### 4.1 Fundamental Domains

Let S be a crystallographic group. A Fundamental domain is a closed convex set containing a system of representatives for the Orbits of S in its natural action on euclidian space.
There are two algorithms for calculating fundamental domains in HAPcryst. One uses the geometry and relies on having the standard rule for evaluating the scalar product (i.e. the gramian matrix is the identity). The other one is independent of the gramian matrix but does only work for Bieberbach groups, while the first ("geometric") algorithm works for arbitrary crystallographic groups given a point with trivial stabilizer.

##### 4.1-1 FundamentalDomainStandardSpaceGroup

`> FundamentalDomainStandardSpaceGroup`( [v, ]G ) | ( method )

`> FundamentalDomainStandardSpaceGroup`( v, G ) | ( method )

Returns: a `PolymakeObject`

Let G be an `AffineCrystGroupOnRight` and v a vector. A fundamental domain containing v is calculated and returned as a `PolymakeObject`. The vector v is used as the starting point for a Dirichlet-Voronoi construction. If no v is given, the origin is used as starting point if it has trivial stabiliser. Otherwise an error is cast.

    gap> fd:=FundamentalDomainStandardSpaceGroup([1/2,0,1/5],SpaceGroup(3,9));
    <polymake object>
    gap> Polymake(fd,"N_VERTICES");
    24
    gap> fd:=FundamentalDomainStandardSpaceGroup(SpaceGroup(3,9));
    <polymake object>
    gap> Polymake(fd,"N_VERTICES");
    8

##### 4.1-2 FundamentalDomainBieberbachGroup

`> FundamentalDomainBieberbachGroup`( G ) | ( method )

`> FundamentalDomainBieberbachGroup`( v, G[, gram] ) | ( method )

Returns: a `PolymakeObject`

Given a starting vector v and a Bieberbach group G in standard form, this method calculates the Dirichlet domain with respect to v. If gram is not supplied, the average gramian matrix is used (see `GramianOfAverageScalarProductFromFiniteMatrixGroup` (2.3-1)). It is not tested if gram is symmetric and positive definite. It is also not tested, if the product defined by gram is invariant under the point group of G.

The behaviour of this function is influenced by the option `ineqThreshold`. The algorithm calculates approximations to a fundamental domain by iteratively adding inequalities. For an approximating polyhedron, every vertex is tested to find new inequalities. When all vertices have been considered or the number of new inequalities already found exceeds the value of `ineqThreshold`, a new approximating polyhedron in calculated. The default for `ineqThreshold` is 200. Roughly speaking, a large threshold means shifting work from `polymake` to GAP, a small one means more calls of (and work for) `polymake`.

If the value of `InfoHAPcryst` (1.3-1) is 2 or more, for each approximation the number of vertices of the approximation, the number of vertices that have to be considered during the calculation, the number of facets, and new inequalities is shown.

Note that the algorithm chooses vertices in random order and also writes inequalities for `polymake` in random order.

    gap> a0:=[[ 1, 0, 0, 0, 0, 0, 0 ], [ 0, -1, 0, 0, 0, 0, 0 ],
    >     [ 0, 0, 1, 0, 0, 0, 0 ], [ 0, 0, 0, 1, 0, 0, 0 ],
    >     [ 0, 0, 0, 0, 0, 1, 0 ], [ 0, 0, 0, 0, -1, -1, 0 ],
    >     [ -1/2, 0, 0, 1/6, 0, 0, 1 ]
    >     ];;
    gap> a1:=[[ 0, -1, 0, 0, 0, 0, 0 ],[ 0, 0, -1, 0, 0, 0, 0 ],
    >         [ 1, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 1, 0, 0, 0 ],
    >         [ 0, 0, 0, 0, 1, 0, 0 ], [ 0, 0, 0, 0, 0, 1, 0 ],
    >         [ 0, 0, 0, 0, 1/3, -1/3, 1 ]
    >        ];;
    gap> trans:=List(Group((1,2,3,4,5,6)),g->
    >           TranslationOnRightFromVector(Permuted([1,0,0,0,0,0],g)));;
    gap> S:=AffineCrystGroupOnRight(Concatenation(trans,[a0,a1]));
    <matrix group with 8 generators>
    gap> SetInfoLevel(InfoHAPcryst,2);
    gap> FundamentalDomainBieberbachGroup(S:ineqThreshold:=10);
    #I  v: 104/104 f:15
    #I  new: 201
    #I  v: 961/961 f:58
    #I  new: 20
    #I  v: 1143/805 f:69
    #I  new: 12
    #I  v: 1059/555 f:64
    #I  new: 15
    #I  v: 328/109 f:33
    #I  new: 12
    #I  v: 336/58 f:32
    #I  new: 0
    <polymake object>
    gap> FundamentalDomainBieberbachGroup(S:ineqThreshold:=1000);
    #I  v: 104/104 f:15
    #I  new: 149
    #I  v: 635/635 f:41
    #I  new: 115
    #I  v: 336/183 f:32
    #I  new: 0
    #I  out of inequalities
    <polymake object>

##### 4.1-3 FundamentalDomainFromGeneralPointAndOrbitPartGeometric

`> FundamentalDomainFromGeneralPointAndOrbitPartGeometric`( v, orbit ) | ( method )

Returns: a `PolymakeObject`

This uses an alternative algorithm based on geometric considerations. It is not used in any of the high-level methods. Let v be a vector and orbit a sufficiently large part of the orbit of v under a crystallographic group with standard- orthogonal point group (satisfying A^t=A^-1). A geometric algorithm is then used to calculate the Dirichlet domain with respect to v. This also works for crystallographic groups which are not Bieberbach. The point v has to have trivial stabilizer.
The intersection of the full orbit with the unit cube around v is sufficiently large.

    gap> G:=SpaceGroup(3,9);;
    gap> v:=[0,0,0];
    [ 0, 0, 0 ]
    gap> orbit:=OrbitStabilizerInUnitCubeOnRight(G,v).orbit;
    [ [ 0, 0, 0 ], [ 0, 0, 1/2 ] ]
    gap> fd:=FundamentalDomainFromGeneralPointAndOrbitPartGeometric(v,orbit);
    <polymake object>
    gap> Polymake(fd,"N_VERTICES");
    8

##### 4.1-4 IsFundamentalDomainStandardSpaceGroup

`> IsFundamentalDomainStandardSpaceGroup`( poly, G ) | ( method )

Returns: true or false

This tests if a `PolymakeObject` poly is a fundamental domain for the affine crystallographic group G in standard form.
The function tests the following: First, does the orbit of any vertex of poly have a point inside poly (if this is the case, `false` is returned). Second: Is every facet of poly the image of a different facet under a group element which does not fix poly. If this is satisfied, `true` is returned.

##### 4.1-5 IsFundamentalDomainBieberbachGroup

`> IsFundamentalDomainBieberbachGroup`( poly, G ) | ( method )

Returns: true, false or fail

This tests if a `PolymakeObject` poly is a fundamental domain for the affine crystallographic group G in standard form and if this group is torsion free (ie a Bieberbach group)
It returns `true` if G is torsion free and poly is a fundamental domain for G. If poly is not a fundamental domain, `false` is returned regardless of the structure of G. And if G is not torsion free, the method returns `fail`. If G is polycyclic, torsion freeness is tested using a representation as pcp group. Otherwise the stabilisers of the faces of the fundamental domain poly are calculated (G is torsion free if and only if it all these stabilisers are trivial).

#### 4.2 Face Lattice and Resolution

For Bieberbach groups (torsion free crystallographic groups), the following functions calcualte free resolutions. This calculation is done by finding a fundamental domain for the group. For a description of the `HapResolution` datatype, see the Hap data types documentation or the experimental datatypes documentation HAPprog: Resolutions in Hap

##### 4.2-1 ResolutionBieberbachGroup

`> ResolutionBieberbachGroup`( G[, v] ) | ( method )

Returns: a `HAPresolution`

Let G be a Bieberbach group given as an `AffineCrystGroupOnRight` and v a vector. Then a Dirichlet domain with respect to v is calculated using `FundamentalDomainBieberbachGroup` (4.1-2). From this domain, a resolution is calculated using `FaceLatticeAndBoundaryBieberbachGroup` (4.2-2) and `ResolutionFromFLandBoundary` (4.2-3). If v is not given, the origin is used.

    gap> R:=ResolutionBieberbachGroup(SpaceGroup(3,9));
    Resolution of length 3 in characteristic
    0 for SpaceGroupOnRightBBNWZ( 3, 2, 2, 2, 2 ) .
    No contracting homotopy available.

    gap> List([0..3],Dimension(R));
    [ 1, 3, 3, 1 ]
    gap> R:=ResolutionBieberbachGroup(SpaceGroup(3,9),[1/2,0,0]);
    Resolution of length 3 in characteristic
    0 for SpaceGroupOnRightBBNWZ( 3, 2, 2, 2, 2 ) .
    No contracting homotopy available.

    gap> List([0..3],Dimension(R));
    [ 6, 12, 7, 1 ]

##### 4.2-2 FaceLatticeAndBoundaryBieberbachGroup

`> FaceLatticeAndBoundaryBieberbachGroup`( poly, group ) | ( method )

Returns: Record with entries `.hasse` and `.elts` representing a part of the hasse diagram and a lookup table of group elements

Let group be a torsion free `AffineCrystGroupOnRight` (that is, a Bieberbach group). Given a `PolymakeObject` poly representing a fundamental domain for group, this method uses polymaking to calculate the face lattice of poly. From the set of faces, a system of representatives for group- orbits is chosen. For each representative, the boundary is then calculated. The list `.elts` contains elements of group (in fact, it is even a set). The structure of the returned list `.hasse` is as follows:

- The i-th entry contains a system of representatives for the i-1 dimensional faces of poly.

- Each face is represented by a pair of lists `[vertices,boundary]`. The list of integers `vertices` represents the vertices of poly which are contained in this face. The enumeration is chosen such that an `i` in the list represents the i-th entry of the list `Polymake(poly,"VERTICES");`

- The list `boundary` represents the boundary of the respective face. It is a list of pairs of integers `[j,g]`. The first entry lies between -n and n, where n is the number of faces of dimension i-1. This entry represents a face of dimension i-1 (or its additive inverse as a module generator). The second entry `g` is the position of the matrix in `.elts`.

This representation is compatible with the representation of free Z G modules in Hap and this method essentially calculates a free resolution of group. If the value of `InfoHAPcryst` (1.3-1) is 2 or more, additional information about the number of faces in every codimension, the number of orbits of the group on the free module generated by those faces, and the time it took to calculate the orbit decomposition is output.

    gap> SetInfoLevel(InfoHAPcryst,2);
    gap> G:=SpaceGroup(3,165);
    SpaceGroupOnRightBBNWZ( 3, 6, 1, 1, 4 )
    gap> fd:=FundamentalDomainBieberbachGroup(G);
    <polymake object>
    gap> fl:=FaceLatticeAndBoundaryBieberbachGroup(fd,G);;
    #I  1(4/8): 0:00:00.004
    #I  2(5/18): 0:00:00.000
    #I  3(2/12): 0:00:00.000
    #I  Face lattice done ( 0:00:00.004). Calculating boundary
    #I  done ( 0:00:00.004) Reformating...
    gap> RecNames(fl);
    [ "hasse", "elts", "groupring" ]
    gap> fl.groupring;
    <free left module over Integers, and ring-with-one, with 10 generators>

##### 4.2-3 ResolutionFromFLandBoundary

`> ResolutionFromFLandBoundary`( fl, group ) | ( method )

Returns: Free resolution

If fl is the record output by `FaceLatticeAndBoundaryBieberbachGroup` (4.2-2) and group is the corresponding group, this function returns a `HapResolution`. Of course, fl has to be generated from a fundamental domain for group

    gap> G:=SpaceGroup(3,165);
    SpaceGroupOnRightBBNWZ( 3, 6, 1, 1, 4 )
    gap> fd:=FundamentalDomainBieberbachGroup(G);
    <polymake object>
    gap> fl:=FaceLatticeAndBoundaryBieberbachGroup(fd,G);;
    gap> ResolutionFromFLandBoundary(fl,G);
    Resolution of length 3 in characteristic
    0 for SpaceGroupOnRightBBNWZ( 3, 6, 1, 1, 4 ) .
    No contracting homotopy available.

    gap> ResolutionFromFLandBoundary(fl,G);
    Resolution of length 3 in characteristic
    0 for SpaceGroupOnRightBBNWZ( 3, 6, 1, 1, 4 ) .
    No contracting homotopy available.

    gap> List([0..4],Dimension(last));
    [ 2, 5, 4, 1, 0 ]

Top of Book Previous Chapter Next Chapter
Goto Chapter: Top 1 2 3 4 Bib Ind

generated by GAPDoc2HTML