% generated by GAPDoc2LaTeX from XML source (Frank Luebeck)
\documentclass[a4paper,11pt]{report}

\usepackage[top=37mm,bottom=37mm,left=27mm,right=27mm]{geometry}
\sloppy
\pagestyle{myheadings}
\usepackage{amssymb}
\usepackage[utf8]{inputenc}
\usepackage{makeidx}
\makeindex
\usepackage{color}
\definecolor{FireBrick}{rgb}{0.5812,0.0074,0.0083}
\definecolor{RoyalBlue}{rgb}{0.0236,0.0894,0.6179}
\definecolor{RoyalGreen}{rgb}{0.0236,0.6179,0.0894}
\definecolor{RoyalRed}{rgb}{0.6179,0.0236,0.0894}
\definecolor{LightBlue}{rgb}{0.8544,0.9511,1.0000}
\definecolor{Black}{rgb}{0.0,0.0,0.0}

\definecolor{linkColor}{rgb}{0.0,0.0,0.554}
\definecolor{citeColor}{rgb}{0.0,0.0,0.554}
\definecolor{fileColor}{rgb}{0.0,0.0,0.554}
\definecolor{urlColor}{rgb}{0.0,0.0,0.554}
\definecolor{promptColor}{rgb}{0.0,0.0,0.589}
\definecolor{brkpromptColor}{rgb}{0.589,0.0,0.0}
\definecolor{gapinputColor}{rgb}{0.589,0.0,0.0}
\definecolor{gapoutputColor}{rgb}{0.0,0.0,0.0}

%%  for a long time these were red and blue by default,
%%  now black, but keep variables to overwrite
\definecolor{FuncColor}{rgb}{0.0,0.0,0.0}
%% strange name because of pdflatex bug:
\definecolor{Chapter }{rgb}{0.0,0.0,0.0}
\definecolor{DarkOlive}{rgb}{0.1047,0.2412,0.0064}


\usepackage{fancyvrb}

\usepackage{mathptmx,helvet}
\usepackage[T1]{fontenc}
\usepackage{textcomp}


\usepackage[
            pdftex=true,
            bookmarks=true,        
            a4paper=true,
            pdftitle={Written with GAPDoc},
            pdfcreator={LaTeX with hyperref package / GAPDoc},
            colorlinks=true,
            backref=page,
            breaklinks=true,
            linkcolor=linkColor,
            citecolor=citeColor,
            filecolor=fileColor,
            urlcolor=urlColor,
            pdfpagemode={UseNone}, 
           ]{hyperref}

\newcommand{\maintitlesize}{\fontsize{50}{55}\selectfont}

% write page numbers to a .pnr log file for online help
\newwrite\pagenrlog
\immediate\openout\pagenrlog =\jobname.pnr
\immediate\write\pagenrlog{PAGENRS := [}
\newcommand{\logpage}[1]{\protect\write\pagenrlog{#1, \thepage,}}
%% were never documented, give conflicts with some additional packages

\newcommand{\GAP}{\textsf{GAP}}

%% nicer description environments, allows long labels
\usepackage{enumitem}
\setdescription{style=nextline}

%% depth of toc
\setcounter{tocdepth}{1}





%% command for ColorPrompt style examples
\newcommand{\gapprompt}[1]{\color{promptColor}{\bfseries #1}}
\newcommand{\gapbrkprompt}[1]{\color{brkpromptColor}{\bfseries #1}}
\newcommand{\gapinput}[1]{\color{gapinputColor}{#1}}


\begin{document}

\logpage{[ 0, 0, 0 ]}
\begin{titlepage}
\mbox{}\vfill

\begin{center}{\maintitlesize \textbf{ HAPcryst \mbox{}}}\\
\vfill

\hypersetup{pdftitle= HAPcryst }
\markright{\scriptsize \mbox{}\hfill  HAPcryst  \hfill\mbox{}}
{\Huge \textbf{ A HAP extension for crystallographic groups \mbox{}}}\\
\vfill

{\Huge  Version 0.2.0 \mbox{}}\\[1cm]
{ 24 March 2026 \mbox{}}\\[1cm]
\mbox{}\\[2cm]
{\Large \textbf{ Marc Roeder\\
  \mbox{}}}\\
\hypersetup{pdfauthor= Marc Roeder\\
  }
\end{center}\vfill

\mbox{}\\
{\mbox{}\\
\small \noindent \textbf{ Marc Roeder\\
  }  Email: \href{mailto://roeder.marc@gmail.com} {\texttt{roeder.marc@gmail.com}}}\\
\end{titlepage}

\newpage\setcounter{page}{2}
{\small 
\section*{Copyright}
\logpage{[ 0, 0, 1 ]}
 {\copyright} 2007 Marc R{\"o}der. 

 This package is distributed under the terms of the GNU General Public License
version 2 or later (at your convenience). See the file \texttt{LICENSE} or \href{https://www.gnu.org/copyleft/gpl.html} {\texttt{https://www.gnu.org/copyleft/gpl.html}} \mbox{}}\\[1cm]
{\small 
\section*{Acknowledgements}
\logpage{[ 0, 0, 2 ]}
 This work was supported by Marie Curie Grant No.
MTKD\texttt{\symbol{45}}CT\texttt{\symbol{45}}2006\texttt{\symbol{45}}042685 \mbox{}}\\[1cm]
\newpage

\def\contentsname{Contents\logpage{[ 0, 0, 3 ]}}

\tableofcontents
\newpage

 
\chapter{\textcolor{Chapter }{Introduction}}\logpage{[ 1, 0, 0 ]}
\hyperdef{L}{X7DFB63A97E67C0A1}{}
{
 
\section{\textcolor{Chapter }{Abstract and Notation}}\logpage{[ 1, 1, 0 ]}
\hyperdef{L}{X813275957BA5B5E0}{}
{
 \textsf{HAPcryst} is an extension for "Homological Algebra Programming" (\textsf{HAP}, \cite{hap}) by Graham Ellis. It uses geometric methods to calculate resolutions for
crystallographic groups. In this manual, we will use the terms "space group"
and "crystallographic group" synonymous. As usual in \textsf{GAP}, group elements are supposed to act from the right. To emphasize this fact,
some functions have names ending in "OnRight" (namely those, which rely on the
action from the right). This is also meant to make work with \textsf{HAPcryst} and \textsf{cryst} \cite{cryst} easier.

 The functions called "somethingStandardSpaceGroup" are supposed to work for
standard crystallographic groups on left and right some time in the future.
Currently only the versions acting on right are implemented. As in \textsf{cryst} \cite{cryst}, space groups are represented as affine linear groups. For the computations
in \textsf{HAPcryst}, crystallographic groups have to be in "standard form". That is, the
translation basis has to be the standard basis of the space. This implies that
the linear part of a group element need not be orthogonal with respect to the
usual scalar product. 
\subsection{\textcolor{Chapter }{The natural action of crystallographic groups}}\logpage{[ 1, 1, 1 ]}
\hyperdef{L}{X7F4A00F481A1FB39}{}
{
 \index{action of crystallographic groups} There is some confusion about the way crystallographic groups are written.
This concerns the question if we act on left or on right and if vectors are of
the form \texttt{[1,...]} or \texttt{[...,1]}. 

 As mentioned, \textsf{HAPcryst} handles affine crystallographic groups on right (and maybe later also on left)
acting on vectors of the form $[...,1]$. 

 \textsc{BUT:} The functions in \textsf{HAPcryst} do not take augmented vectors as input (no leading or ending ones). The
handling of vectors is done internally. So in \textsf{HAPcryst}, a crystallographic group is a group of $n\times n$ matrices which acts on a vector space of dimension $n-1$ whose elements are vectors of length $n-1$ (not $n$). Example: 
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
  !gapprompt@gap>| !gapinput@G:=SpaceGroup(3,4); #This group acts on 3-Space|
  SpaceGroupOnRightBBNWZ( 3, 2, 1, 1, 2 )
  !gapprompt@gap>| !gapinput@Display(Representative(G));|
  [ [  1,  0,  0,  0 ],
    [  0,  1,  0,  0 ],
    [  0,  0,  1,  0 ],
    [  0,  0,  0,  1 ] ]
  !gapprompt@gap>| !gapinput@OrbitStabilizerInUnitCubeOnRight(G,[1/2,0,0]);|
  rec( orbit := [ [ 1/2, 0, 0 ], [ 1/2, 1/2, 0 ] ],
    stabilizer := Group([ [ [ 1, 0, 0, 0 ], [ 0, 1, 0, 0 ], [ 0, 0, 1, 0 ],
            [ 0, 0, 0, 1 ] ] ]) )
\end{Verbatim}
 }

 }

 
\section{\textcolor{Chapter }{Requirements}}\logpage{[ 1, 2, 0 ]}
\hyperdef{L}{X85A08CF187A6D986}{}
{
\index{installation} The following \textsf{GAP} packages are required 
\begin{itemize}
\item  \textsf{polymaking} which in turn depends on the computational geometry software polymake. 
\item  \textsf{HAP} 
\item  \textsf{Cryst} 
\end{itemize}
 The following \textsf{GAP} packages are not required but highly recommended: 
\begin{itemize}
\item \textsf{carat}
\item \textsf{CrystCat}
\item \textsf{GAPDoc} is needed to display the online manual
\end{itemize}
 
\subsection{\textcolor{Chapter }{Recommendation concerning polymake}}\logpage{[ 1, 2, 1 ]}
\hyperdef{L}{X7990986A8114E0DB}{}
{
 \index{polymake} Calculating resolutions of Bieberbach groups involves convex hull
computations. polymake by default uses cdd to compute convex hulls.
Experiments suggest that lrs is the more suitable algorithm for the
computations done in HAPcryst than the default cdd. You can change the
behaviour of by editing the file "yourhomedirectory/.polymake/prefer.pl". It
should contain a section like this (just make sure lrs is before cdd, the
position of beneath{\textunderscore}beyond does not matter): 
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=]
  #########################################
  application polytope;
  
  prefer "*.convex_hull  lrs, beneath_beyond, cdd";
\end{Verbatim}
 }

 }

 
\section{\textcolor{Chapter }{Global Variables}}\logpage{[ 1, 3, 0 ]}
\hyperdef{L}{X7D9044767BEB1523}{}
{
  \textsf{HAPcryst} itself does only have one global variable, namely \texttt{InfoHAPcryst} (\ref{InfoHAPcryst}). The location of files generated for interaction with polymake are determined
by the value of \texttt{POLYMAKE{\textunderscore}DATA{\textunderscore}DIR} (\textbf{polymaking: POLYMAKE{\textunderscore}DATA{\textunderscore}DIR}) which is a global variable of \textsf{polymaking}. 

\subsection{\textcolor{Chapter }{InfoHAPcryst}}
\logpage{[ 1, 3, 1 ]}\nobreak
\hyperdef{L}{X78B0A21E7FD0F3BB}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{InfoHAPcryst\index{InfoHAPcryst@\texttt{InfoHAPcryst}}
\label{InfoHAPcryst}
}\hfill{\scriptsize (info class)}}\\


 At a level of 1, only the most important messages are printed. At level 2,
additional information is displayed, and level 3 is even more verbose. At
level 0, \textsf{HAPcryst} remains silent. }

 }

 }

 
\chapter{\textcolor{Chapter }{Bits and Pieces}}\logpage{[ 2, 0, 0 ]}
\hyperdef{L}{X86FBE5B77C2F9442}{}
{
 This chapter contains a few very basic functions which are needed for space
group calculations and were missing in standard \textsf{GAP}. 
\section{\textcolor{Chapter }{Matrices and Vectors}}\logpage{[ 2, 1, 0 ]}
\hyperdef{L}{X8019925B8294F5B4}{}
{
 

\subsection{\textcolor{Chapter }{SignRat}}
\logpage{[ 2, 1, 1 ]}\nobreak
\hyperdef{L}{X7D58A1848182EC26}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{SignRat({\mdseries\slshape x})\index{SignRat@\texttt{SignRat}}
\label{SignRat}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
 sign of the rational number \mbox{\texttt{\mdseries\slshape x}} (Standard \textsf{GAP} currently only has \texttt{SignInt}). 

}

 

\subsection{\textcolor{Chapter }{VectorModOne}}
\logpage{[ 2, 1, 2 ]}\nobreak
\hyperdef{L}{X7C0552BA873515B9}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{VectorModOne({\mdseries\slshape v})\index{VectorModOne@\texttt{VectorModOne}}
\label{VectorModOne}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
Rational vector of the same length with enties in $[0,1)$



 For a rational vector \mbox{\texttt{\mdseries\slshape v}}, this returns the vector with all entries taken "mod 1". }

 
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
  !gapprompt@gap>| !gapinput@SignRat((-4)/(-2));|
  1
  !gapprompt@gap>| !gapinput@SignRat(9/(-2));|
  -1
  !gapprompt@gap>| !gapinput@VectorModOne([1/10,100/9,5/6,6/5]);|
  [ 1/10, 1/9, 5/6, 1/5 ]
\end{Verbatim}
 

\subsection{\textcolor{Chapter }{IsSquareMat}}
\logpage{[ 2, 1, 3 ]}\nobreak
\hyperdef{L}{X7BB083A57C474F45}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{IsSquareMat({\mdseries\slshape matrix})\index{IsSquareMat@\texttt{IsSquareMat}}
\label{IsSquareMat}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
 \texttt{true} if \mbox{\texttt{\mdseries\slshape matrix}} is a square matrix and \texttt{false} otherwise. 

}

 

\subsection{\textcolor{Chapter }{DimensionSquareMat}}
\logpage{[ 2, 1, 4 ]}\nobreak
\hyperdef{L}{X78C932A48515EF10}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{DimensionSquareMat({\mdseries\slshape matrix})\index{DimensionSquareMat@\texttt{DimensionSquareMat}}
\label{DimensionSquareMat}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
Number of lines in the matrix \mbox{\texttt{\mdseries\slshape matrix}} if it is square and \texttt{fail} otherwise 

}

 
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
  !gapprompt@gap>| !gapinput@m:=[[1,2,3],[4,5,6],[9,6,12]];|
  [ [ 1, 2, 3 ], [ 4, 5, 6 ], [ 9, 6, 12 ] ]
  !gapprompt@gap>| !gapinput@IsSquareMat(m);|
  true
  !gapprompt@gap>| !gapinput@DimensionSquareMat(m);|
  3
  !gapprompt@gap>| !gapinput@DimensionSquareMat([[1,2],[1,2,3]]);|
  fail
\end{Verbatim}
 Affine mappings of $n$ dimensional space are often written as a pair $(A,v)$ where $A$ is a linear mapping and $v$ is a vector. \textsf{GAP} represents affine mappings by $n+1$ times $n+1$ matrices $M$ which satisfy $M_{{n+1,n+1}}=1$ and $M_{{i,n+1}}=0$ for all $1\leq i \leq n$.

 An affine matrix acts on an $n$ dimensional space which is written as a space of $n+1$ tuples with $n+1$st entry $1$. Here we give two functions to handle these affine matrices. }

 
\section{\textcolor{Chapter }{Affine Matrices OnRight}}\logpage{[ 2, 2, 0 ]}
\hyperdef{L}{X86BD4FE4871379AD}{}
{
 

\subsection{\textcolor{Chapter }{LinearPartOfAffineMatOnRight}}
\logpage{[ 2, 2, 1 ]}\nobreak
\hyperdef{L}{X838946957FC75C17}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{LinearPartOfAffineMatOnRight({\mdseries\slshape mat})\index{LinearPartOfAffineMatOnRight@\texttt{LinearPartOfAffineMatOnRight}}
\label{LinearPartOfAffineMatOnRight}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
the linear part of the affine matrix \mbox{\texttt{\mdseries\slshape mat}}. That is, everything except for the last row and column.

}

 

\subsection{\textcolor{Chapter }{BasisChangeAffineMatOnRight}}
\logpage{[ 2, 2, 2 ]}\nobreak
\hyperdef{L}{X80DD4F2286D49F8D}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{BasisChangeAffineMatOnRight({\mdseries\slshape transform, mat})\index{BasisChangeAffineMatOnRight@\texttt{BasisChangeAffineMatOnRight}}
\label{BasisChangeAffineMatOnRight}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
affine matrix with same dimensions as \mbox{\texttt{\mdseries\slshape mat}}



 A basis change \mbox{\texttt{\mdseries\slshape transform}} of an $n$ dimensional space induces a transformation on affine mappings on this space.
If \mbox{\texttt{\mdseries\slshape mat}} is a affine matrix (in particular, it is $(n+1)\times (n+1)$), this method returns the image of \mbox{\texttt{\mdseries\slshape mat}} under the basis transformation induced by \mbox{\texttt{\mdseries\slshape transform}}. }

 
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
  !gapprompt@gap>| !gapinput@c:=[[0,1],[1,0]];|
  [ [ 0, 1 ], [ 1, 0 ] ]
  !gapprompt@gap>| !gapinput@m:=[[1/2,0,0],[0,2/3,0],[1,0,1]];|
  [ [ 1/2, 0, 0 ], [ 0, 2/3, 0 ], [ 1, 0, 1 ] ]
  !gapprompt@gap>| !gapinput@BasisChangeAffineMatOnRight(c,m);|
  [ [ 2/3, 0, 0 ], [ 0, 1/2, 0 ], [ 0, 1, 1 ] ]
\end{Verbatim}
 

\subsection{\textcolor{Chapter }{TranslationOnRightFromVector}}
\logpage{[ 2, 2, 3 ]}\nobreak
\hyperdef{L}{X81F3C49580958FB6}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{TranslationOnRightFromVector({\mdseries\slshape v})\index{TranslationOnRightFromVector@\texttt{TranslationOnRightFromVector}}
\label{TranslationOnRightFromVector}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
Affine matrix 



 Given a vector \mbox{\texttt{\mdseries\slshape v}} with $n$ entries, this method returns a $(n+1)\times (n+1)$ matrix which corresponds to the affine translation defined by \mbox{\texttt{\mdseries\slshape v}}. }

 
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
  !gapprompt@gap>| !gapinput@m:=TranslationOnRightFromVector([1,2,3]);;|
  !gapprompt@gap>| !gapinput@Display(m);|
  [ [  1,  0,  0,  0 ],
    [  0,  1,  0,  0 ],
    [  0,  0,  1,  0 ],
    [  1,  2,  3,  1 ] ]
  !gapprompt@gap>| !gapinput@LinearPartOfAffineMatOnRight(m);|
  [ [ 1, 0, 0 ], [ 0, 1, 0 ], [ 0, 0, 1 ] ]
  !gapprompt@gap>| !gapinput@BasisChangeAffineMatOnRight([[3,2,1],[0,1,0],[0,0,1]],m);|
  [ [ 1, 0, 0, 0 ], [ 0, 1, 0, 0 ], [ 0, 0, 1, 0 ], [ 3, 4, 4, 1 ] ]
\end{Verbatim}
 }

 
\section{\textcolor{Chapter }{Geometry}}\logpage{[ 2, 3, 0 ]}
\hyperdef{L}{X84A0B0637F269E37}{}
{
 

\subsection{\textcolor{Chapter }{GramianOfAverageScalarProductFromFiniteMatrixGroup}}
\logpage{[ 2, 3, 1 ]}\nobreak
\hyperdef{L}{X7A94DAE679AD73E3}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{GramianOfAverageScalarProductFromFiniteMatrixGroup({\mdseries\slshape G})\index{GramianOfAverageScalarProductFromFiniteMatrixGroup@\texttt{Gramian}\-\texttt{Of}\-\texttt{Average}\-\texttt{Scalar}\-\texttt{Product}\-\texttt{From}\-\texttt{Finite}\-\texttt{Matrix}\-\texttt{Group}}
\label{GramianOfAverageScalarProductFromFiniteMatrixGroup}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
Symmetric positive definite matrix



 For a finite matrix group \mbox{\texttt{\mdseries\slshape G}}, the gramian matrix of the average scalar product is returned. This is the
sum over all $gg^t$ with $g\in G$ (actually it is enough to take a generating set). The group \mbox{\texttt{\mdseries\slshape G}} is orthogonal with respect to the scalar product induced by the returned
matrix. }

 
\subsection{\textcolor{Chapter }{Inequalities}}\logpage{[ 2, 3, 2 ]}
\hyperdef{L}{X866942167802E036}{}
{
 Inequalities are represented in the same way they are represented in \textsf{polymaking}. The vector $(v_0,\ldots,v_n)$ represents the inequality $0\leq v_0+v_1 x_1+\ldots + v_n x_n$. }

 

\subsection{\textcolor{Chapter }{BisectorInequalityFromPointPair}}
\logpage{[ 2, 3, 3 ]}\nobreak
\hyperdef{L}{X80C365AA87BDDAFA}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{BisectorInequalityFromPointPair({\mdseries\slshape v1, v2[, gram]})\index{BisectorInequalityFromPointPair@\texttt{BisectorInequalityFromPointPair}}
\label{BisectorInequalityFromPointPair}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
vector of length \texttt{Length(v1)+1}



 Calculates the inequality defining the half\texttt{\symbol{45}}space
containing \mbox{\texttt{\mdseries\slshape v1}} such that \texttt{\mbox{\texttt{\mdseries\slshape v1}}\texttt{\symbol{45}}\mbox{\texttt{\mdseries\slshape v2}}} is perpendicular on the bounding hyperplane. And \texttt{(\mbox{\texttt{\mdseries\slshape v1}}\texttt{\symbol{45}}\mbox{\texttt{\mdseries\slshape v2}})/2} is contained in the bounding hyperplane.\\
 If the matrix \mbox{\texttt{\mdseries\slshape gram}} is given, it is used as the gramian matrix. Otherwiese, the standard scalar
product is used. It is not checked if \mbox{\texttt{\mdseries\slshape gram}} is positive definite or symmetric. }

 

\subsection{\textcolor{Chapter }{WhichSideOfHyperplane}}
\logpage{[ 2, 3, 4 ]}\nobreak
\hyperdef{L}{X8790464D86D189F4}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{WhichSideOfHyperplane({\mdseries\slshape v, ineq})\index{WhichSideOfHyperplane@\texttt{WhichSideOfHyperplane}}
\label{WhichSideOfHyperplane}
}\hfill{\scriptsize (method)}}\\
\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{WhichSideOfHyperplaneNC({\mdseries\slshape v, ineq})\index{WhichSideOfHyperplaneNC@\texttt{WhichSideOfHyperplaneNC}}
\label{WhichSideOfHyperplaneNC}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
\texttt{\symbol{45}}1 (below) 0 (in) or 1 (above).



 Let \mbox{\texttt{\mdseries\slshape v}} be a vector of length $n$ and \mbox{\texttt{\mdseries\slshape ineq}} an inequality represented by a vector of length $n+1$. Then \texttt{WhichSideOfHyperplane(\mbox{\texttt{\mdseries\slshape v, ineq}})} returns 1 if \mbox{\texttt{\mdseries\slshape v}} is a solution of the inequality but not the equation given by \mbox{\texttt{\mdseries\slshape ineq}}, it returns 0 if \mbox{\texttt{\mdseries\slshape v}} is a solution to the equation and \texttt{\symbol{45}}1 if it is not a
solution of the inequality \mbox{\texttt{\mdseries\slshape ineq}}. 

 The NC version does not test the input for correctness. }

 
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
  !gapprompt@gap>| !gapinput@BisectorInequalityFromPointPair([0,0],[1,0]);|
  [ 1, -2, 0 ]
  !gapprompt@gap>| !gapinput@ineq:=BisectorInequalityFromPointPair([0,0],[1,0],[[5,4],[4,5]]);|
  [ 5, -10, -8 ]
  !gapprompt@gap>| !gapinput@ineq{[2,3]}*[1/2,0];|
  -5
  !gapprompt@gap>| !gapinput@WhichSideOfHyperplane([0,0],ineq);|
  1
  !gapprompt@gap>| !gapinput@WhichSideOfHyperplane([1/2,0],ineq);|
  0
\end{Verbatim}
 

\subsection{\textcolor{Chapter }{RelativePositionPointAndPolygon}}
\logpage{[ 2, 3, 5 ]}\nobreak
\hyperdef{L}{X83392C417B311B6B}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{RelativePositionPointAndPolygon({\mdseries\slshape point, poly})\index{RelativePositionPointAndPolygon@\texttt{RelativePositionPointAndPolygon}}
\label{RelativePositionPointAndPolygon}
}\hfill{\scriptsize (operation)}}\\
\textbf{\indent Returns:\ }
one of \texttt{"VERTEX", "FACET", "OUTSIDE", "INSIDE"}



 Let \mbox{\texttt{\mdseries\slshape poly}} be a \texttt{PolymakeObject} and \mbox{\texttt{\mdseries\slshape point}} a vector. If \mbox{\texttt{\mdseries\slshape point}} is a vertex of \mbox{\texttt{\mdseries\slshape poly}}, the string \texttt{"VERTEX"} is returned. If \mbox{\texttt{\mdseries\slshape point}} lies inside \mbox{\texttt{\mdseries\slshape poly}}, \texttt{"INSIDE"} is returned and if it lies in a facet, \texttt{"FACET"} is returned and if \mbox{\texttt{\mdseries\slshape point}} does not lie inside \mbox{\texttt{\mdseries\slshape poly}}, the function returns \texttt{"OUTSIDE"}. }

 }

 
\section{\textcolor{Chapter }{Space Groups}}\logpage{[ 2, 4, 0 ]}
\hyperdef{L}{X7B14774981F80108}{}
{
 

\subsection{\textcolor{Chapter }{PointGroupRepresentatives}}
\logpage{[ 2, 4, 1 ]}\nobreak
\hyperdef{L}{X7E2F20607F278B70}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PointGroupRepresentatives({\mdseries\slshape group})\index{PointGroupRepresentatives@\texttt{PointGroupRepresentatives}}
\label{PointGroupRepresentatives}
}\hfill{\scriptsize (attribute)}}\\
\textbf{\indent Returns:\ }
list of matrices



 Given an \texttt{AffineCrystGroupOnLeftOrRight} \mbox{\texttt{\mdseries\slshape group}}, this returns a list of representatives of the point group of \mbox{\texttt{\mdseries\slshape group}}. That is, a system of representatives for the factor group modulo
translations. This is an attribute of \texttt{AffineCrystGroupOnLeftOrRight} }

 }

 }

 
\chapter{\textcolor{Chapter }{Algorithms of Orbit\texttt{\symbol{45}}Stabilizer Type}}\logpage{[ 3, 0, 0 ]}
\hyperdef{L}{X7F6789767FB36E74}{}
{
 We introduce a way to calculate a sufficient part of an orbit and the
stabilizer of a point. 
\section{\textcolor{Chapter }{Orbit Stabilizer for Crystallographic Groups}}\logpage{[ 3, 1, 0 ]}
\hyperdef{L}{X85CAB2EB85A6E17A}{}
{
 

\subsection{\textcolor{Chapter }{OrbitStabilizerInUnitCubeOnRight}}
\logpage{[ 3, 1, 1 ]}\nobreak
\hyperdef{L}{X7BED233684B2F811}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{OrbitStabilizerInUnitCubeOnRight({\mdseries\slshape group, x})\index{OrbitStabilizerInUnitCubeOnRight@\texttt{OrbitStabilizerInUnitCubeOnRight}}
\label{OrbitStabilizerInUnitCubeOnRight}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
 A record containing 
\begin{itemize}
\item  \texttt{.stabilizer}: the stabilizer of \mbox{\texttt{\mdseries\slshape x}}. 
\item  \texttt{.orbit} set of vectors from $[0,1)^n$ which represents the orbit. 
\end{itemize}
 



 Let \mbox{\texttt{\mdseries\slshape x}} be a rational vector from $[0,1)^n$ and \mbox{\texttt{\mdseries\slshape group}} a space group in standard form. The function then calculates the part of the
orbit which lies inside the cube $[0,1)^n$ and the stabilizer of \mbox{\texttt{\mdseries\slshape x}}. Observe that every element of the full orbit differs from a point in the
returned orbit only by a pure translation. }

 Note that the restriction to points from $[0,1)^n$ makes sense if orbits should be compared and the vector passed to \texttt{OrbitStabilizerInUnitCubeOnRight} should be an element of the returned orbit (part). 
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
  !gapprompt@gap>| !gapinput@S:=SpaceGroup(3,5);;|
  !gapprompt@gap>| !gapinput@OrbitStabilizerInUnitCubeOnRight(S,[1/2,0,9/11]);   |
  rec( orbit := [ [ 0, 1/2, 2/11 ], [ 1/2, 0, 9/11 ] ], 
    stabilizer := Group([ [ [ 1, 0, 0, 0 ], [ 0, 1, 0, 0 ], [ 0, 0, 1, 0 ], 
            [ 0, 0, 0, 1 ] ] ]) )
  !gapprompt@gap>| !gapinput@OrbitStabilizerInUnitCubeOnRight(S,[0,0,0]);     |
  rec( orbit := [ [ 0, 0, 0 ] ], stabilizer := <matrix group with 2 generators> )
\end{Verbatim}
 If you are interested in other parts of the orbit, you can use \texttt{VectorModOne} (\ref{VectorModOne}) for the base point and the functions \texttt{ShiftedOrbitPart} (\ref{ShiftedOrbitPart}), \texttt{TranslationsToOneCubeAroundCenter} (\ref{TranslationsToOneCubeAroundCenter}) and \texttt{TranslationsToBox} (\ref{TranslationsToBox}) for the resulting orbit\\
 Suppose we want to calculate the part of the orbit of \texttt{[4/3,5/3,7/3]} in the cube of sidelength \texttt{1} around this point: 
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
  !gapprompt@gap>| !gapinput@S:=SpaceGroup(3,5);;|
  !gapprompt@gap>| !gapinput@p:=[4/3,5/3,7/3];;|
  !gapprompt@gap>| !gapinput@o:=OrbitStabilizerInUnitCubeOnRight(S,VectorModOne(p)).orbit;|
  [ [ 1/3, 2/3, 1/3 ], [ 1/3, 2/3, 2/3 ] ]
  !gapprompt@gap>| !gapinput@box:=p+[[-1,1],[-1,1],[-1,1]];|
  [ [ 1/3, 8/3, 7/3 ], [ 1/3, 8/3, 7/3 ], [ 1/3, 8/3, 7/3 ] ]
  !gapprompt@gap>| !gapinput@o2:=Concatenation(List(o,i->i+TranslationsToBox(i,box)));;|
  !gapprompt@gap>| !gapinput@# This is what we looked for. But it is somewhat large:|
  !gapprompt@gap>| !gapinput@Size(o2);|
  54
\end{Verbatim}
 

\subsection{\textcolor{Chapter }{OrbitStabilizerInUnitCubeOnRightOnSets}}
\logpage{[ 3, 1, 2 ]}\nobreak
\hyperdef{L}{X82BD20307A67C119}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{OrbitStabilizerInUnitCubeOnRightOnSets({\mdseries\slshape group, set})\index{OrbitStabilizerInUnitCubeOnRightOnSets@\texttt{Orbit}\-\texttt{Stabilizer}\-\texttt{In}\-\texttt{Unit}\-\texttt{Cube}\-\texttt{On}\-\texttt{Right}\-\texttt{On}\-\texttt{Sets}}
\label{OrbitStabilizerInUnitCubeOnRightOnSets}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
 A record containing 
\begin{itemize}
\item  \texttt{.stabilizer}: the stabilizer of \mbox{\texttt{\mdseries\slshape set}}. 
\item  \texttt{.orbit} set of sets of vectors from $[0,1)^n$ which represents the orbit. 
\end{itemize}
 



 Calculates orbit and stabilizer of a set of vectors. Just as \texttt{OrbitStabilizerInUnitCubeOnRight} (\ref{OrbitStabilizerInUnitCubeOnRight}), it needs input from $[0,1)^n$. The returned orbit part \texttt{.orbit} is a set of sets such that every element of \texttt{.orbit} has a non\texttt{\symbol{45}}trivial intersection with the cube $[0,1)^n$. In general, these sets will not lie inside $[0,1)^n$ completely. }

 
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
  !gapprompt@gap>| !gapinput@S:=SpaceGroup(3,5);;|
  !gapprompt@gap>| !gapinput@OrbitStabilizerInUnitCubeOnRightOnSets(S,[[0,0,0],[0,1/2,0]]);|
  rec( orbit := [ [ [ -1/2, 0, 0 ], [ 0, 0, 0 ] ], 
                  [ [ 0, 0, 0 ], [ 0, 1/2, 0 ] ],
                  [ [ 1/2, 0, 0 ], [ 1, 0, 0 ] ] ],
    stabilizer := Group([ [ [ 1, 0, 0, 0 ], [ 0, 1, 0, 0 ], 
                          [ 0, 0, 1, 0 ], [ 0, 0, 0, 1 ] ] ]) )
\end{Verbatim}
 

\subsection{\textcolor{Chapter }{OrbitPartInVertexSetsStandardSpaceGroup}}
\logpage{[ 3, 1, 3 ]}\nobreak
\hyperdef{L}{X82CCCD597C86A08A}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{OrbitPartInVertexSetsStandardSpaceGroup({\mdseries\slshape group, vertexset, allvertices})\index{OrbitPartInVertexSetsStandardSpaceGroup@\texttt{Orbit}\-\texttt{Part}\-\texttt{In}\-\texttt{Vertex}\-\texttt{Sets}\-\texttt{Standard}\-\texttt{Space}\-\texttt{Group}}
\label{OrbitPartInVertexSetsStandardSpaceGroup}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
 Set of subsets of \mbox{\texttt{\mdseries\slshape allvertices}}. 



 If \mbox{\texttt{\mdseries\slshape allvertices}} is a set of vectors and \mbox{\texttt{\mdseries\slshape vertexset}} is a subset thereof, then \texttt{OrbitPartInVertexSetsStandardSpaceGroup} returns that part of the orbit of \mbox{\texttt{\mdseries\slshape vertexset}} which consists entirely of subsets of \mbox{\texttt{\mdseries\slshape allvertices}}. Note that,unlike the other \texttt{OrbitStabilizer} algorithms, this does not require the input to lie in some particular part of
the space. }

 
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
  !gapprompt@gap>| !gapinput@S:=SpaceGroup(3,5);;|
  !gapprompt@gap>| !gapinput@OrbitPartInVertexSetsStandardSpaceGroup(S,[[0,1,5],[1,2,0]],|
  !gapprompt@>| !gapinput@Set([[1,2,0],[2,3,1],[1,2,6],[1,1,0],[0,1,5],[3/5,7,12],[1/17,6,1/2]]));|
  [ [ [ 0, 1, 5 ], [ 1, 2, 0 ] ], [ [ 1, 2, 6 ], [ 2, 3, 1 ] ] ]
  !gapprompt@gap>| !gapinput@OrbitPartInVertexSetsStandardSpaceGroup(S, [[1,2,0]],|
  !gapprompt@>| !gapinput@Set([[1,2,0],[2,3,1],[1,2,6],[1,1,0],[0,1,5],[3/5,7,12],[1/17,6,1/2]]));|
  [ [ [ 0, 1, 5 ] ], [ [ 1, 1, 0 ] ], [ [ 1, 2, 0 ] ], [ [ 1, 2, 6 ] ], [ [ 2, 3, 1 ] ] ]
\end{Verbatim}
 

\subsection{\textcolor{Chapter }{OrbitPartInFacesStandardSpaceGroup}}
\logpage{[ 3, 1, 4 ]}\nobreak
\hyperdef{L}{X8022CD75819DE536}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{OrbitPartInFacesStandardSpaceGroup({\mdseries\slshape group, vertexset, faceset})\index{OrbitPartInFacesStandardSpaceGroup@\texttt{OrbitPartInFacesStandardSpaceGroup}}
\label{OrbitPartInFacesStandardSpaceGroup}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
 Set of subsets of \mbox{\texttt{\mdseries\slshape faceset}}. 



 This calculates the orbit of a space group on sets restricted to a set of
faces.\\
 If \mbox{\texttt{\mdseries\slshape faceset}} is a set of sets of vectors and \mbox{\texttt{\mdseries\slshape vertexset}} is an element of \mbox{\texttt{\mdseries\slshape faceset}}, then \texttt{OrbitPartInFacesStandardSpaceGroup} returns that part of the orbit of \mbox{\texttt{\mdseries\slshape vertexset}} which consists entirely of elements of \mbox{\texttt{\mdseries\slshape faceset}}.\\
 Note that,unlike the other \texttt{OrbitStabilizer} algorithms, this does not require the input to lie in some particular part of
the space. }

 

\subsection{\textcolor{Chapter }{OrbitPartAndRepresentativesInFacesStandardSpaceGroup}}
\logpage{[ 3, 1, 5 ]}\nobreak
\hyperdef{L}{X86A80FA17A4D6664}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{OrbitPartAndRepresentativesInFacesStandardSpaceGroup({\mdseries\slshape group, vertexset, faceset})\index{OrbitPartAndRepresentativesInFacesStandardSpaceGroup@\texttt{Orbit}\-\texttt{Part}\-\texttt{And}\-\texttt{Representatives}\-\texttt{In}\-\texttt{Faces}\-\texttt{Standard}\-\texttt{Space}\-\texttt{Group}}
\label{OrbitPartAndRepresentativesInFacesStandardSpaceGroup}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
 A set of face\texttt{\symbol{45}}matrix pairs . 



 This is a slight variation of \texttt{OrbitPartInFacesStandardSpaceGroup} (\ref{OrbitPartInFacesStandardSpaceGroup}) that also returns a representative for every orbit element. }

 
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
  !gapprompt@gap>| !gapinput@S:=SpaceGroup(3,5);;|
  !gapprompt@gap>| !gapinput@OrbitPartInVertexSetsStandardSpaceGroup(S,[[0,1,5],[1,2,0]],|
  !gapprompt@>| !gapinput@Set([[1,2,0],[2,3,1],[1,2,6],[1,1,0],[0,1,5],[3/5,7,12],[1/17,6,1/2]]));|
  [ [ [ 0, 1, 5 ], [ 1, 2, 0 ] ], [ [ 1, 2, 6 ], [ 2, 3, 1 ] ] ]
  !gapprompt@gap>| !gapinput@OrbitPartInFacesStandardSpaceGroup(S,[[0,1,5],[1,2,0]],|
  !gapprompt@>| !gapinput@Set( [ [ [ 0, 1, 5 ], [ 1, 2, 0 ] ], [[1/17,6,1/2],[1,2,7]]]));|
  [ [ [ 0, 1, 5 ], [ 1, 2, 0 ] ] ]
  !gapprompt@gap>| !gapinput@OrbitPartAndRepresentativesInFacesStandardSpaceGroup(S,[[0,1,5],[1,2,0]],|
  !gapprompt@>| !gapinput@Set( [ [ [ 0, 1, 5 ], [ 1, 2, 0 ] ], [[1/17,6,1/2],[1,2,7]]]));|
  [ [ [ [ 0, 1, 5 ], [ 1, 2, 0 ] ],
        [ [ 1, 0, 0, 0 ], [ 0, 1, 0, 0 ], [ 0, 0, 1, 0 ], [ 0, 0, 0, 1 ] ] ] ]
\end{Verbatim}
 

\subsection{\textcolor{Chapter }{StabilizerOnSetsStandardSpaceGroup}}
\logpage{[ 3, 1, 6 ]}\nobreak
\hyperdef{L}{X81DE08687F0DBCC6}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{StabilizerOnSetsStandardSpaceGroup({\mdseries\slshape group, set})\index{StabilizerOnSetsStandardSpaceGroup@\texttt{StabilizerOnSetsStandardSpaceGroup}}
\label{StabilizerOnSetsStandardSpaceGroup}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
finite group of affine matrices (OnRight)



 Given a set \mbox{\texttt{\mdseries\slshape set}} of vectors and a space group \mbox{\texttt{\mdseries\slshape group}} in standard form, this method calculates the stabilizer of that set in the
full crystallographic group.\\
 }

 
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
  !gapprompt@gap>| !gapinput@G:=SpaceGroup(3,12);;|
  !gapprompt@gap>| !gapinput@v:=[ 0, 0,0 ];;|
  !gapprompt@gap>| !gapinput@s:=StabilizerOnSetsStandardSpaceGroup(G,[v]);|
  <matrix group with 2 generators>
  !gapprompt@gap>| !gapinput@s2:=OrbitStabilizerInUnitCubeOnRight(G,v).stabilizer;|
  <matrix group with 2 generators>
  !gapprompt@gap>| !gapinput@s2=s;|
  true
\end{Verbatim}
 

\subsection{\textcolor{Chapter }{RepresentativeActionOnRightOnSets}}
\logpage{[ 3, 1, 7 ]}\nobreak
\hyperdef{L}{X83C6448679A54F9D}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{RepresentativeActionOnRightOnSets({\mdseries\slshape group, set, imageset})\index{RepresentativeActionOnRightOnSets@\texttt{RepresentativeActionOnRightOnSets}}
\label{RepresentativeActionOnRightOnSets}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
 Affine matrix. 



 Returns an element of the space group $S$ which takes the set \mbox{\texttt{\mdseries\slshape set}} to the set \mbox{\texttt{\mdseries\slshape imageset}}. The group must be in standard form and act on the right. }

 
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
  !gapprompt@gap>| !gapinput@S:=SpaceGroup(3,5);;|
  !gapprompt@gap>| !gapinput@RepresentativeActionOnRightOnSets(G, [[0,0,0],[0,1/2,0]],|
  !gapprompt@>| !gapinput@       [ [ 0, 1/2, 0 ], [ 0, 1, 0 ] ]);|
  [ [ 0, -1, 0, 0 ], [ -1, 0, 0, 0 ], [ 0, 0, -1, 0 ], [ 0, 1, 0, 1 ] ]
\end{Verbatim}
 
\subsection{\textcolor{Chapter }{Getting other orbit parts}}\logpage{[ 3, 1, 8 ]}
\hyperdef{L}{X8002407080DB3EA2}{}
{
 \textsf{HAPcryst} does not calculate the full orbit but only the part of it having coefficients
between $-1/2$ and $1/2$. The other parts of the orbit can be calculated using the following
functions. }

 

\subsection{\textcolor{Chapter }{ShiftedOrbitPart}}
\logpage{[ 3, 1, 9 ]}\nobreak
\hyperdef{L}{X8751429287034F4A}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ShiftedOrbitPart({\mdseries\slshape point, orbitpart})\index{ShiftedOrbitPart@\texttt{ShiftedOrbitPart}}
\label{ShiftedOrbitPart}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
Set of vectors 



 Takes each vector in \mbox{\texttt{\mdseries\slshape orbitpart}} to the cube unit cube centered in \mbox{\texttt{\mdseries\slshape point}}. }

 
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
  !gapprompt@gap>| !gapinput@ShiftedOrbitPart([0,0,0],[[1/2,1/2,1/3],-[1/2,1/2,1/2],[19,3,1]]);|
  [ [ 1/2, 1/2, 1/3 ], [ 1/2, 1/2, 1/2 ], [ 0, 0, 0 ] ]
  !gapprompt@gap>| !gapinput@ShiftedOrbitPart([1,1,1],[[1/2,1/2,1/2],-[1/2,1/2,1/2]]);|
  [ [ 3/2, 3/2, 3/2 ] ]
\end{Verbatim}
 

\subsection{\textcolor{Chapter }{TranslationsToOneCubeAroundCenter}}
\logpage{[ 3, 1, 10 ]}\nobreak
\hyperdef{L}{X82656DE584E8DC5D}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{TranslationsToOneCubeAroundCenter({\mdseries\slshape point, center})\index{TranslationsToOneCubeAroundCenter@\texttt{TranslationsToOneCubeAroundCenter}}
\label{TranslationsToOneCubeAroundCenter}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
List of integer vectors



 This method returns the list of all integer vectors which translate \mbox{\texttt{\mdseries\slshape point}} into the box \mbox{\texttt{\mdseries\slshape center}}$+[-1/2,1/2]^n$ }

 
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
  !gapprompt@gap>| !gapinput@TranslationsToOneCubeAroundCenter([1/2,1/2,1/3],[0,0,0]);|
  [ [ 0, 0, 0 ], [ 0, -1, 0 ], [ -1, 0, 0 ], [ -1, -1, 0 ] ]
  !gapprompt@gap>| !gapinput@TranslationsToOneCubeAroundCenter([1,0,1],[0,0,0]);|
  [ [ -1, 0, -1 ] ]
\end{Verbatim}
 

\subsection{\textcolor{Chapter }{TranslationsToBox}}
\logpage{[ 3, 1, 11 ]}\nobreak
\hyperdef{L}{X858C787E83A902AB}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{TranslationsToBox({\mdseries\slshape point, box})\index{TranslationsToBox@\texttt{TranslationsToBox}}
\label{TranslationsToBox}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
List of integer vectors or the empty list



 Given a vector $v$ and a list of pairs, this function returns the translation vectors (integer
vectors) which take $v$ into the box \mbox{\texttt{\mdseries\slshape box}}. The box \mbox{\texttt{\mdseries\slshape box}} has to be given as a list of pairs. }

 
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
  !gapprompt@gap>| !gapinput@TranslationsToBox([0,0],[[1/2,2/3],[1/2,2/3]]);|
  [  ]
  !gapprompt@gap>| !gapinput@TranslationsToBox([0,0],[[-3/2,1/2],[1,4/3]]);|
  [ [ -1, 1 ], [ 0, 1 ] ]
  !gapprompt@gap>| !gapinput@TranslationsToBox([0,0],[[-3/2,1/2],[2,1]]);|
  Error, Box must not be empty
\end{Verbatim}
 }

 }

 
\chapter{\textcolor{Chapter }{Resolutions of Crystallographic Groups}}\logpage{[ 4, 0, 0 ]}
\hyperdef{L}{X852C41A77C759D82}{}
{
  
\section{\textcolor{Chapter }{Fundamental Domains}}\logpage{[ 4, 1, 0 ]}
\hyperdef{L}{X7F48638F817A14B0}{}
{
 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 \textsf{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. 

\subsection{\textcolor{Chapter }{FundamentalDomainStandardSpaceGroup}}
\logpage{[ 4, 1, 1 ]}\nobreak
\hyperdef{L}{X79F4F7938116201E}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{FundamentalDomainStandardSpaceGroup({\mdseries\slshape [v, ]G})\index{FundamentalDomainStandardSpaceGroup@\texttt{FundamentalDomainStandardSpaceGroup}}
\label{FundamentalDomainStandardSpaceGroup}
}\hfill{\scriptsize (operation)}}\\
\textbf{\indent Returns:\ }
a \texttt{PolymakeObject}



 Let \mbox{\texttt{\mdseries\slshape G}} be an \texttt{AffineCrystGroupOnRight} and \mbox{\texttt{\mdseries\slshape v}} a vector. A fundamental domain containing \mbox{\texttt{\mdseries\slshape v}} is calculated and returned as a \texttt{PolymakeObject}. The vector \mbox{\texttt{\mdseries\slshape v}} is used as the starting point for a Dirichlet\texttt{\symbol{45}}Voronoi
construction. If no \mbox{\texttt{\mdseries\slshape v}} is given, the origin is used as starting point if it has trivial stabiliser.
Otherwise an error is cast. \\
 }

 
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
  !gapprompt@gap>| !gapinput@fd:=FundamentalDomainStandardSpaceGroup([1/2,0,1/5],SpaceGroup(3,9));|
  <polymake object>
  !gapprompt@gap>| !gapinput@Polymake(fd,"N_VERTICES");|
  24
  !gapprompt@gap>| !gapinput@fd:=FundamentalDomainStandardSpaceGroup(SpaceGroup(3,9));|
  <polymake object>
  !gapprompt@gap>| !gapinput@Polymake(fd,"N_VERTICES");|
  8
\end{Verbatim}
 

\subsection{\textcolor{Chapter }{FundamentalDomainBieberbachGroup}}
\logpage{[ 4, 1, 2 ]}\nobreak
\hyperdef{L}{X7A07AB55831F212F}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{FundamentalDomainBieberbachGroup({\mdseries\slshape [v, ]G[, gram]})\index{FundamentalDomainBieberbachGroup@\texttt{FundamentalDomainBieberbachGroup}}
\label{FundamentalDomainBieberbachGroup}
}\hfill{\scriptsize (operation)}}\\
\textbf{\indent Returns:\ }
a \texttt{PolymakeObject}



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

 The behaviour of this function is influenced by the option \texttt{ineqThreshold}\label{ineqThreshold}\index{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 \texttt{ineqThreshold}, a new approximating polyhedron in calculated. The default for \texttt{ineqThreshold} is 200. Roughly speaking, a large threshold means shifting work from \texttt{polymake} to \textsf{GAP}, a small one means more calls of (and work for) \texttt{polymake}. 

 If the value of \texttt{InfoHAPcryst} (\ref{InfoHAPcryst}) 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 \texttt{polymake} in random order. }

 
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
  !gapprompt@gap>| !gapinput@a0:=[[ 1, 0, 0, 0, 0, 0, 0 ], [ 0, -1, 0, 0, 0, 0, 0 ], |
  !gapprompt@>| !gapinput@    [ 0, 0, 1, 0, 0, 0, 0 ], [ 0, 0, 0, 1, 0, 0, 0 ], |
  !gapprompt@>| !gapinput@    [ 0, 0, 0, 0, 0, 1, 0 ], [ 0, 0, 0, 0, -1, -1, 0 ],|
  !gapprompt@>| !gapinput@    [ -1/2, 0, 0, 1/6, 0, 0, 1 ] |
  !gapprompt@>| !gapinput@    ];;|
  !gapprompt@gap>| !gapinput@a1:=[[ 0, -1, 0, 0, 0, 0, 0 ],[ 0, 0, -1, 0, 0, 0, 0 ],|
  !gapprompt@>| !gapinput@        [ 1, 0, 0, 0, 0, 0, 0 ], [ 0, 0, 0, 1, 0, 0, 0 ], |
  !gapprompt@>| !gapinput@        [ 0, 0, 0, 0, 1, 0, 0 ], [ 0, 0, 0, 0, 0, 1, 0 ],|
  !gapprompt@>| !gapinput@        [ 0, 0, 0, 0, 1/3, -1/3, 1 ] |
  !gapprompt@>| !gapinput@       ];;|
  !gapprompt@gap>| !gapinput@trans:=List(Group((1,2,3,4,5,6)),g->|
  !gapprompt@>| !gapinput@          TranslationOnRightFromVector(Permuted([1,0,0,0,0,0],g)));;|
  !gapprompt@gap>| !gapinput@S:=AffineCrystGroupOnRight(Concatenation(trans,[a0,a1]));|
  <matrix group with 8 generators>
  !gapprompt@gap>| !gapinput@SetInfoLevel(InfoHAPcryst,2);|
  !gapprompt@gap>| !gapinput@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>
  !gapprompt@gap>| !gapinput@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>
\end{Verbatim}
 

\subsection{\textcolor{Chapter }{FundamentalDomainFromGeneralPointAndOrbitPartGeometric}}
\logpage{[ 4, 1, 3 ]}\nobreak
\hyperdef{L}{X86A09AC4842827C9}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{FundamentalDomainFromGeneralPointAndOrbitPartGeometric({\mdseries\slshape v, orbit})\index{FundamentalDomainFromGeneralPointAndOrbitPartGeometric@\texttt{Fundamental}\-\texttt{Domain}\-\texttt{From}\-\texttt{General}\-\texttt{Point}\-\texttt{And}\-\texttt{Orbit}\-\texttt{Part}\-\texttt{Geometric}}
\label{FundamentalDomainFromGeneralPointAndOrbitPartGeometric}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
a \texttt{PolymakeObject}



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

 
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
  !gapprompt@gap>| !gapinput@G:=SpaceGroup(3,9);;|
  !gapprompt@gap>| !gapinput@v:=[0,0,0];|
  [ 0, 0, 0 ]
  !gapprompt@gap>| !gapinput@orbit:=OrbitStabilizerInUnitCubeOnRight(G,v).orbit;|
  [ [ 0, 0, 0 ], [ 0, 0, 1/2 ] ]
  !gapprompt@gap>| !gapinput@fd:=FundamentalDomainFromGeneralPointAndOrbitPartGeometric(v,orbit);|
  <polymake object>
  !gapprompt@gap>| !gapinput@Polymake(fd,"N_VERTICES");|
  8
\end{Verbatim}
 

\subsection{\textcolor{Chapter }{IsFundamentalDomainStandardSpaceGroup}}
\logpage{[ 4, 1, 4 ]}\nobreak
\hyperdef{L}{X824BC99584F5F865}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{IsFundamentalDomainStandardSpaceGroup({\mdseries\slshape poly, G})\index{IsFundamentalDomainStandardSpaceGroup@\texttt{IsFundamental}\-\texttt{Domain}\-\texttt{Standard}\-\texttt{Space}\-\texttt{Group}}
\label{IsFundamentalDomainStandardSpaceGroup}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
 true or false 



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

 

\subsection{\textcolor{Chapter }{IsFundamentalDomainBieberbachGroup}}
\logpage{[ 4, 1, 5 ]}\nobreak
\hyperdef{L}{X7D79DD6E87BCC1DC}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{IsFundamentalDomainBieberbachGroup({\mdseries\slshape poly, G})\index{IsFundamentalDomainBieberbachGroup@\texttt{IsFundamentalDomainBieberbachGroup}}
\label{IsFundamentalDomainBieberbachGroup}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
 true, false or fail 



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

 }

 
\section{\textcolor{Chapter }{Face Lattice and Resolution}}\logpage{[ 4, 2, 0 ]}
\hyperdef{L}{X78D68F6087238F97}{}
{
 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 \texttt{HapResolution} datatype, see the \textsf{Hap} data types documentation or the experimental datatypes documentation \ref{hapresolution} 

\subsection{\textcolor{Chapter }{ResolutionBieberbachGroup}}
\logpage{[ 4, 2, 1 ]}\nobreak
\hyperdef{L}{X7CA87AA478007468}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ResolutionBieberbachGroup({\mdseries\slshape G[, v]})\index{ResolutionBieberbachGroup@\texttt{ResolutionBieberbachGroup}}
\label{ResolutionBieberbachGroup}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
a \texttt{HAPresolution}



 Let \mbox{\texttt{\mdseries\slshape G}} be a Bieberbach group given as an \texttt{AffineCrystGroupOnRight} and \mbox{\texttt{\mdseries\slshape v}} a vector. Then a Dirichlet domain with respect to \mbox{\texttt{\mdseries\slshape v}} is calculated using \texttt{FundamentalDomainBieberbachGroup} (\ref{FundamentalDomainBieberbachGroup}). From this domain, a resolution is calculated using \texttt{FaceLatticeAndBoundaryBieberbachGroup} (\ref{FaceLatticeAndBoundaryBieberbachGroup}) and \texttt{ResolutionFromFLandBoundary} (\ref{ResolutionFromFLandBoundary}). If \mbox{\texttt{\mdseries\slshape v}} is not given, the origin is used. }

 
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
  !gapprompt@gap>| !gapinput@R:=ResolutionBieberbachGroup(SpaceGroup(3,9));|
  Resolution of length 3 in characteristic
  0 for SpaceGroupOnRightBBNWZ( 3, 2, 2, 2, 2 ) .
  No contracting homotopy available.
  
  !gapprompt@gap>| !gapinput@List([0..3],Dimension(R));|
  [ 1, 3, 3, 1 ]
  !gapprompt@gap>| !gapinput@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.
  
  !gapprompt@gap>| !gapinput@List([0..3],Dimension(R));|
  [ 6, 12, 7, 1 ]
\end{Verbatim}
 

\subsection{\textcolor{Chapter }{FaceLatticeAndBoundaryBieberbachGroup}}
\logpage{[ 4, 2, 2 ]}\nobreak
\hyperdef{L}{X7E854FC47F9E479E}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{FaceLatticeAndBoundaryBieberbachGroup({\mdseries\slshape poly, group})\index{FaceLatticeAndBoundaryBieberbachGroup@\texttt{Face}\-\texttt{Lattice}\-\texttt{And}\-\texttt{Boundary}\-\texttt{Bieberbach}\-\texttt{Group}}
\label{FaceLatticeAndBoundaryBieberbachGroup}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
 Record with entries \texttt{.hasse} and \texttt{.elts} representing a part of the hasse diagram and a lookup table of group elements



 Let \mbox{\texttt{\mdseries\slshape group}} be a torsion free \texttt{AffineCrystGroupOnRight} (that is, a Bieberbach group). Given a \texttt{PolymakeObject} \mbox{\texttt{\mdseries\slshape poly}} representing a fundamental domain for \mbox{\texttt{\mdseries\slshape group}}, this method uses \textsf{polymaking} to calculate the face lattice of \mbox{\texttt{\mdseries\slshape poly}}. From the set of faces, a system of representatives for \mbox{\texttt{\mdseries\slshape group}}\texttt{\symbol{45}} orbits is chosen. For each representative, the boundary
is then calculated. The list \texttt{.elts} contains elements of \mbox{\texttt{\mdseries\slshape group}} (in fact, it is even a set). The structure of the returned list \texttt{.hasse} is as follows: 
\begin{itemize}
\item The $i$\texttt{\symbol{45}}th entry contains a system of representatives for the $i-1$ dimensional faces of \mbox{\texttt{\mdseries\slshape poly}}. 
\item Each face is represented by a pair of lists \texttt{[vertices,boundary]}. The list of integers \texttt{vertices} represents the vertices of \mbox{\texttt{\mdseries\slshape poly}} which are contained in this face. The enumeration is chosen such that an \texttt{i} in the list represents the $i$\texttt{\symbol{45}}th entry of the list \texttt{Polymake(poly,"VERTICES");} 
\item  The list \texttt{boundary} represents the boundary of the respective face. It is a list of pairs of
integers \texttt{[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 \texttt{g} is the position of the matrix in \texttt{.elts}. 
\end{itemize}
 This representation is compatible with the representation of free $\mathbb Z G$ modules in \textsf{Hap} and this method essentially calculates a free resolution of \mbox{\texttt{\mdseries\slshape group}}. If the value of \texttt{InfoHAPcryst} (\ref{InfoHAPcryst}) 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. }

 
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
  !gapprompt@gap>| !gapinput@SetInfoLevel(InfoHAPcryst,2);|
  !gapprompt@gap>| !gapinput@G:=SpaceGroup(3,165);|
  SpaceGroupOnRightBBNWZ( 3, 6, 1, 1, 4 )
  !gapprompt@gap>| !gapinput@fd:=FundamentalDomainBieberbachGroup(G);|
  <polymake object>
  !gapprompt@gap>| !gapinput@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...
  !gapprompt@gap>| !gapinput@RecNames(fl);|
  [ "hasse", "elts", "groupring" ]
  !gapprompt@gap>| !gapinput@fl.groupring;|
  <free left module over Integers, and ring-with-one, with 10 generators>
\end{Verbatim}
 

\subsection{\textcolor{Chapter }{ResolutionFromFLandBoundary}}
\logpage{[ 4, 2, 3 ]}\nobreak
\hyperdef{L}{X79A0B28A7FAE31B9}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ResolutionFromFLandBoundary({\mdseries\slshape fl, group})\index{ResolutionFromFLandBoundary@\texttt{ResolutionFromFLandBoundary}}
\label{ResolutionFromFLandBoundary}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
Free resolution



 If \mbox{\texttt{\mdseries\slshape fl}} is the record output by \texttt{FaceLatticeAndBoundaryBieberbachGroup} (\ref{FaceLatticeAndBoundaryBieberbachGroup}) and \mbox{\texttt{\mdseries\slshape group}} is the corresponding group, this function returns a \texttt{HapResolution}. Of course, \mbox{\texttt{\mdseries\slshape fl}} has to be generated from a fundamental domain for \mbox{\texttt{\mdseries\slshape group}} }

 
\begin{Verbatim}[commandchars=!@|,fontsize=\small,frame=single,label=Example]
  !gapprompt@gap>| !gapinput@G:=SpaceGroup(3,165);|
  SpaceGroupOnRightBBNWZ( 3, 6, 1, 1, 4 )
  !gapprompt@gap>| !gapinput@fd:=FundamentalDomainBieberbachGroup(G);|
  <polymake object>
  !gapprompt@gap>| !gapinput@fl:=FaceLatticeAndBoundaryBieberbachGroup(fd,G);;|
  !gapprompt@gap>| !gapinput@ResolutionFromFLandBoundary(fl,G);|
  Resolution of length 3 in characteristic
  0 for SpaceGroupOnRightBBNWZ( 3, 6, 1, 1, 4 ) .
  No contracting homotopy available.
  
  !gapprompt@gap>| !gapinput@ResolutionFromFLandBoundary(fl,G);|
  Resolution of length 3 in characteristic
  0 for SpaceGroupOnRightBBNWZ( 3, 6, 1, 1, 4 ) .
  No contracting homotopy available.
  
  !gapprompt@gap>| !gapinput@List([0..4],Dimension(last));|
  [ 2, 5, 4, 1, 0 ]
\end{Verbatim}
 }

 }

 

\appendix


\chapter{\textcolor{Chapter }{Resolutions in Hap}}\label{hapresolution}
\logpage{[ "A", 0, 0 ]}
\hyperdef{L}{X7C6DD73E7BB931AB}{}
{
 This document is only concerned with the representation of resolutions in Hap.
Note that it is not a part of Hap. The framework provided here is just an
extension of Hap data types used in HAPcryst and HAPprime. 

 From now on, let $G$ be a group and $\dots \to M_n\to M_{n-1}\to\dots\to M_1\to M_0\to Z$ be a resolution with free $ZG$ modules $M_i$. 

 The elements of the modules $M_i$ can be represented in different ways. This is what makes different
representations for resolutions desirable. First, we will look at the standard
representation (\texttt{HapResolutionRep}) as it is defined in Hap. After that, we will present another representation
for infinite groups. Note that all non\texttt{\symbol{45}}standard
representations must be sub\texttt{\symbol{45}}representations of the standard
representation to ensure compatibility with Hap. 
\section{\textcolor{Chapter }{The Standard Representation \texttt{HapResolutionRep}}}\label{hapresolutionrep}
\logpage{[ "A", 1, 0 ]}
\hyperdef{L}{X804F611B7E23BDB1}{}
{
 For every $M_i$ we fix a basis and number its elements. Furthermore, it is assumed that we
have a (partial) enumeration of the group of a resolution. In practice this is
done by generating a lookup table on the fly. 

 In standard representation, the elements of the modules $M_k$ are represented by lists \texttt{\symbol{45}}"words"\texttt{\symbol{45}} of
pairs of integers. A letter \texttt{[i,g]} of such a word consists of the number of a basis element \texttt{i} or \texttt{\texttt{\symbol{45}}i} for its additive inverse and a number $g$ representing a group element. 

 A \texttt{HapResolution} in \texttt{HapResolutionRep} representation is a component object with the components 
\begin{itemize}
\item \texttt{group}, a group of arbitrary type.
\item \texttt{elts}, a (partial) list of (possibly duplicate) elements in G. This list provides
the "enumeration" of the group. Note that there are functions in Hap which
assume that \texttt{elts[1]} is the identity element of G. 
\item \texttt{appendToElts(g)} a function that appends the group element \texttt{g} to \texttt{.elts}. This is not documented in Hap 1.8.6 but seems to be required for infinite
groups. This requirement might vanish in some later version of Hap [G. Ellis,
private communication]. 
\item \texttt{dimension(k)}, a function which returns the ZG\texttt{\symbol{45}}rank of the Module $M_k$
\item \texttt{boundary(k,j)}, a function which returns the image in $M_{k-1}$ of the $j$th free generator of $M_k$. Note that negative $j$ are valid as input as well. In this case the additive inverse of the boundary
of the $j$th generator is returned
\item \texttt{homotopy(k,[i,g])} a function which returns the image in $M_{k+1}$, under a contracting homotopy $M_k \to M_{k+1}$, of the element \texttt{[[i,g]]} in $M_k$. The value of this might be \texttt{fail}. However, currently (version 1.8.4) some Hap functions assume that \texttt{homotopy} is a function without testing.
\item \texttt{properties}, a list of pairs \texttt{["name","value"]} "name" is a string and value is anything (boolean, number, string...). Every \texttt{HapResolution} (regardless of representation) has to have \texttt{["type","resolution"]}, \texttt{["length",length]} where \texttt{length} is the length of the resolution and \texttt{["characteristic",char]}. Currently (Hap 1.8.6), \texttt{length} must not be \texttt{infinity}. The values of these properties can be tested using the Hap function \texttt{EvaluateProperty(resolution,propertyname)}.
\end{itemize}
 Note that making \texttt{HapResolution}s immutable will make the \texttt{.elts} component immutable. As this lookup table might change during calculations, we
do not recommend using immutable resolutions (in any representation). }

 
\section{\textcolor{Chapter }{The \texttt{HapLargeGroupResolutionRep} Representation}}\label{largegrouprep}
\logpage{[ "A", 2, 0 ]}
\hyperdef{L}{X8024014D8488FE30}{}
{
 In this sub\texttt{\symbol{45}}representation of the standard representation,
the module elements in this resolution are lists of groupring elements. So the
lookup table \texttt{.elts} is not used as long as no conversion to standard representation takes place.
In addition to the components of a \texttt{HapResolution}, a resolution in large group representation has the following components: 
\begin{itemize}
\item \texttt{boundary2(resolution,term,gen)}, a function that returns the boundary of the \mbox{\texttt{\mdseries\slshape gen}}th generator of the \mbox{\texttt{\mdseries\slshape term}}th module.
\item \texttt{groupring} the group ring of the resolution \mbox{\texttt{\mdseries\slshape resolution}}.
\item \texttt{dimension2(resolution,term)} a function that returns the dimension of the \mbox{\texttt{\mdseries\slshape term}}th module of the resolution \mbox{\texttt{\mdseries\slshape resolution}}.
\end{itemize}
 The effort of having two versions of \texttt{boundary} and \texttt{dimension} is necessary to keep the structure compatible with the usual Hap resolution. }

 }


\chapter{\textcolor{Chapter }{Accessing and Manipulating Resolutions}}\logpage{[ "B", 0, 0 ]}
\hyperdef{L}{X86374CEA7CDC6946}{}
{
 
\section{\textcolor{Chapter }{Representation\texttt{\symbol{45}}Independent Access Methods}}\logpage{[ "B", 1, 0 ]}
\hyperdef{L}{X7A7225067E7895A9}{}
{
 All methods listed below take a \texttt{HapResolution} in any representation. If the other arguments are compatible with the
representation of the resolution, the returned value will be in the form
defined by this representation. If the other arguments are in a different
representation, \textsf{GAP}s method selection is used via \texttt{TryNextMethod()} to find an applicable method (a suitable representation). 

 The idea behind this is that the results of computations have the same form as
the input. And as all representations are
sub\texttt{\symbol{45}}representations of the \texttt{HapResolutionRep} representation, input which is compatible with the \texttt{HapResolutionRep} representation is always valid. 

 Every new representation must support the functions of this section. 

\subsection{\textcolor{Chapter }{StrongestValidRepresentationForLetter}}
\logpage{[ "B", 1, 1 ]}\nobreak
\hyperdef{L}{X7CBC6D4C783383BE}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{StrongestValidRepresentationForLetter({\mdseries\slshape resolution, term, letter})\index{StrongestValidRepresentationForLetter@\texttt{Strongest}\-\texttt{Valid}\-\texttt{Representation}\-\texttt{For}\-\texttt{Letter}}
\label{StrongestValidRepresentationForLetter}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
filter



 Finds the sub\texttt{\symbol{45}}representation of \texttt{HapResolutionRep} for which \mbox{\texttt{\mdseries\slshape letter}} is a valid letter of the \mbox{\texttt{\mdseries\slshape term}}th module of \mbox{\texttt{\mdseries\slshape resolution}}. Note that \mbox{\texttt{\mdseries\slshape resolution}} automatically is in some sub\texttt{\symbol{45}}representation of \texttt{HapResolutionRep}.This is mainly meant for debugging. }

 

\subsection{\textcolor{Chapter }{StrongestValidRepresentationForWord}}
\logpage{[ "B", 1, 2 ]}\nobreak
\hyperdef{L}{X7C10841285614D04}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{StrongestValidRepresentationForWord({\mdseries\slshape resolution, term, word})\index{StrongestValidRepresentationForWord@\texttt{StrongestValidRepresentationForWord}}
\label{StrongestValidRepresentationForWord}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
filter



 Finds the sub\texttt{\symbol{45}}representation of \texttt{HapResolutionRep} for which \mbox{\texttt{\mdseries\slshape word}} is a valid word of the \mbox{\texttt{\mdseries\slshape term}}th module of \mbox{\texttt{\mdseries\slshape resolution}}. Note that \mbox{\texttt{\mdseries\slshape resolution}} automatically is in some sub\texttt{\symbol{45}}representation of \texttt{HapResolutionRep}. This is mainly meant for debugging. }

 

\subsection{\textcolor{Chapter }{PositionInGroupOfResolution}}
\logpage{[ "B", 1, 3 ]}\nobreak
\hyperdef{L}{X780AD2DB7F5D4935}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PositionInGroupOfResolution({\mdseries\slshape resolution, g})\index{PositionInGroupOfResolution@\texttt{PositionInGroupOfResolution}}
\label{PositionInGroupOfResolution}
}\hfill{\scriptsize (method)}}\\
\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PositionInGroupOfResolutionNC({\mdseries\slshape resolution, g})\index{PositionInGroupOfResolutionNC@\texttt{PositionInGroupOfResolutionNC}}
\label{PositionInGroupOfResolutionNC}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
positive integer



 This returns the position of the group element \mbox{\texttt{\mdseries\slshape g}} in the enumeration of the group of \mbox{\texttt{\mdseries\slshape resolution}}. The NC version does not check if \mbox{\texttt{\mdseries\slshape g}} really is an element of the group of \mbox{\texttt{\mdseries\slshape resolution}}. }

 

\subsection{\textcolor{Chapter }{IsValidGroupInt}}
\logpage{[ "B", 1, 4 ]}\nobreak
\hyperdef{L}{X7A58EC7B8130D6E2}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{IsValidGroupInt({\mdseries\slshape resolution, n})\index{IsValidGroupInt@\texttt{IsValidGroupInt}}
\label{IsValidGroupInt}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
boolean



 Returns true if the \mbox{\texttt{\mdseries\slshape n}}th element of the group of \mbox{\texttt{\mdseries\slshape resolution}} is known. }

 

\subsection{\textcolor{Chapter }{GroupElementFromPosition}}
\logpage{[ "B", 1, 5 ]}\nobreak
\hyperdef{L}{X822604B67B2A9133}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{GroupElementFromPosition({\mdseries\slshape resolution, n})\index{GroupElementFromPosition@\texttt{GroupElementFromPosition}}
\label{GroupElementFromPosition}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
group element or \texttt{fail}



 Returns \mbox{\texttt{\mdseries\slshape n}}th element of the group of \mbox{\texttt{\mdseries\slshape resolution}}. If the \mbox{\texttt{\mdseries\slshape n}}th element is not known, \texttt{fail} is returned. }

 

\subsection{\textcolor{Chapter }{MultiplyGroupElts}}
\logpage{[ "B", 1, 6 ]}\nobreak
\hyperdef{L}{X7D3673E8840FA0B6}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{MultiplyGroupElts({\mdseries\slshape resolution, x, y})\index{MultiplyGroupElts@\texttt{MultiplyGroupElts}}
\label{MultiplyGroupElts}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
positive integer or group element, depending on the type of \mbox{\texttt{\mdseries\slshape x}} and \mbox{\texttt{\mdseries\slshape y}}



 If \texttt{x} and \texttt{y} are given in standard representation (i.e. as integers), this returns the
position of the product of the group elements represented by the positive
integers \mbox{\texttt{\mdseries\slshape x}} and \mbox{\texttt{\mdseries\slshape x}}. 

 If \texttt{x} and \texttt{y} are given in any other representation, the returned group element will also be
represented in this way. }

 

\subsection{\textcolor{Chapter }{MultiplyFreeZGLetterWithGroupElt}}
\logpage{[ "B", 1, 7 ]}\nobreak
\hyperdef{L}{X8540F3B37BAC695F}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{MultiplyFreeZGLetterWithGroupElt({\mdseries\slshape resolution, letter, g})\index{MultiplyFreeZGLetterWithGroupElt@\texttt{MultiplyFreeZGLetterWithGroupElt}}
\label{MultiplyFreeZGLetterWithGroupElt}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
A letter



 Multiplies the letter \mbox{\texttt{\mdseries\slshape letter}} with the group element \mbox{\texttt{\mdseries\slshape g}} and returns the result. If \mbox{\texttt{\mdseries\slshape resolution}} is in standard representation, \mbox{\texttt{\mdseries\slshape g}} has to be an integer and \mbox{\texttt{\mdseries\slshape letter}} has to be a pair of integer. If \mbox{\texttt{\mdseries\slshape resolution}} is in any other representation, \mbox{\texttt{\mdseries\slshape letter}} and \mbox{\texttt{\mdseries\slshape g}} can be in a form compatible with that representation or in the standard form
(in the latter case, the returned value will also have standard form). }

 

\subsection{\textcolor{Chapter }{MultiplyFreeZGWordWithGroupElt}}
\logpage{[ "B", 1, 8 ]}\nobreak
\hyperdef{L}{X826835B185CA4DAF}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{MultiplyFreeZGWordWithGroupElt({\mdseries\slshape resolution, word, g})\index{MultiplyFreeZGWordWithGroupElt@\texttt{MultiplyFreeZGWordWithGroupElt}}
\label{MultiplyFreeZGWordWithGroupElt}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
A word



 Multiplies the word \mbox{\texttt{\mdseries\slshape word}} with the group element \mbox{\texttt{\mdseries\slshape g}} and returns the result. If \mbox{\texttt{\mdseries\slshape resolution}} is in standard representation, \mbox{\texttt{\mdseries\slshape g}} has to be an integer and \mbox{\texttt{\mdseries\slshape word}} has to be a list of pairs of integers. If \mbox{\texttt{\mdseries\slshape resolution}} is in any other representation, \mbox{\texttt{\mdseries\slshape word}} and \mbox{\texttt{\mdseries\slshape g}} can be in a form compatible with that representation or in the standard form
(in the latter case, the returned value will also have standard form). }

 

\subsection{\textcolor{Chapter }{BoundaryOfFreeZGLetter}}
\logpage{[ "B", 1, 9 ]}\nobreak
\hyperdef{L}{X7D8B54D7828D7C5C}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{BoundaryOfFreeZGLetter({\mdseries\slshape resolution, term, letter})\index{BoundaryOfFreeZGLetter@\texttt{BoundaryOfFreeZGLetter}}
\label{BoundaryOfFreeZGLetter}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
free ZG word (in the same representation as \mbox{\texttt{\mdseries\slshape letter}})



 Calculates the boundary of the letter (word of length 1) \mbox{\texttt{\mdseries\slshape letter}} of the \mbox{\texttt{\mdseries\slshape term}}th module of \mbox{\texttt{\mdseries\slshape resolution}}. 

 The returned value is a word of the \mbox{\texttt{\mdseries\slshape term}}\texttt{\symbol{45}}1st module and comes in the same representation as \mbox{\texttt{\mdseries\slshape letter}}. }

 

\subsection{\textcolor{Chapter }{BoundaryOfFreeZGWord}}
\logpage{[ "B", 1, 10 ]}\nobreak
\hyperdef{L}{X81A6037F82C3C31E}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{BoundaryOfFreeZGWord({\mdseries\slshape resolution, term, word})\index{BoundaryOfFreeZGWord@\texttt{BoundaryOfFreeZGWord}}
\label{BoundaryOfFreeZGWord}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
free ZG word (in the same representation as \mbox{\texttt{\mdseries\slshape letter}})



 Calculates the boundary of the word \mbox{\texttt{\mdseries\slshape word}} of the \mbox{\texttt{\mdseries\slshape term}}th module of \mbox{\texttt{\mdseries\slshape resolution}}. 

 The returned value is a word of the \mbox{\texttt{\mdseries\slshape term}}\texttt{\symbol{45}}1st module and comes in the same representation as \mbox{\texttt{\mdseries\slshape word}}. }

 }

 
\section{\textcolor{Chapter }{Converting Between Representations}}\logpage{[ "B", 2, 0 ]}
\hyperdef{L}{X7B94A2ED857C62D5}{}
{
 Four methods are provided to convert letters and words from standard
representation to any other representation and back again. 

\subsection{\textcolor{Chapter }{ConvertStandardLetter}}
\logpage{[ "B", 2, 1 ]}\nobreak
\hyperdef{L}{X7EB515317948BE8E}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ConvertStandardLetter({\mdseries\slshape resolution, term, letter})\index{ConvertStandardLetter@\texttt{ConvertStandardLetter}}
\label{ConvertStandardLetter}
}\hfill{\scriptsize (method)}}\\
\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ConvertStandardLetterNC({\mdseries\slshape resolution, term, letter})\index{ConvertStandardLetterNC@\texttt{ConvertStandardLetterNC}}
\label{ConvertStandardLetterNC}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
letter in the representation of \mbox{\texttt{\mdseries\slshape resolution}}



 Converts the letter \mbox{\texttt{\mdseries\slshape letter}} in standard representation to the representation of \mbox{\texttt{\mdseries\slshape resolution}}. The NC version does not check whether \mbox{\texttt{\mdseries\slshape letter}} really is a letter in standard representation. }

 

\subsection{\textcolor{Chapter }{ConvertStandardWord}}
\logpage{[ "B", 2, 2 ]}\nobreak
\hyperdef{L}{X7A1CB5DF7A459D76}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ConvertStandardWord({\mdseries\slshape resolution, term, word})\index{ConvertStandardWord@\texttt{ConvertStandardWord}}
\label{ConvertStandardWord}
}\hfill{\scriptsize (method)}}\\
\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ConvertStandardWordNC({\mdseries\slshape resolution, term, word})\index{ConvertStandardWordNC@\texttt{ConvertStandardWordNC}}
\label{ConvertStandardWordNC}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
word in the representation of \mbox{\texttt{\mdseries\slshape resolution}}



 Converts the word \mbox{\texttt{\mdseries\slshape word}} in standard representation to the representation of \mbox{\texttt{\mdseries\slshape resolution}}. The NC version does not check whether \mbox{\texttt{\mdseries\slshape word}} is a valid word in standard representation. }

 

\subsection{\textcolor{Chapter }{ConvertLetterToStandardRep}}
\logpage{[ "B", 2, 3 ]}\nobreak
\hyperdef{L}{X83153E2682184860}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ConvertLetterToStandardRep({\mdseries\slshape resolution, term, letter})\index{ConvertLetterToStandardRep@\texttt{ConvertLetterToStandardRep}}
\label{ConvertLetterToStandardRep}
}\hfill{\scriptsize (method)}}\\
\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ConvertLetterToStandardRepNC({\mdseries\slshape resolution, term, letter})\index{ConvertLetterToStandardRepNC@\texttt{ConvertLetterToStandardRepNC}}
\label{ConvertLetterToStandardRepNC}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
letter in standard representation



 Converts the letter \mbox{\texttt{\mdseries\slshape letter}} in the representation of \mbox{\texttt{\mdseries\slshape resolution}} to the standard representation. The NC version does not check whether \mbox{\texttt{\mdseries\slshape letter}} is a valid letter of \mbox{\texttt{\mdseries\slshape resolution}}. }

 

\subsection{\textcolor{Chapter }{ConvertWordToStandardRep}}
\logpage{[ "B", 2, 4 ]}\nobreak
\hyperdef{L}{X848203218271A166}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ConvertWordToStandardRep({\mdseries\slshape resolution, term, word})\index{ConvertWordToStandardRep@\texttt{ConvertWordToStandardRep}}
\label{ConvertWordToStandardRep}
}\hfill{\scriptsize (method)}}\\
\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ConvertWordToStandardRepNC({\mdseries\slshape resolution, term, word})\index{ConvertWordToStandardRepNC@\texttt{ConvertWordToStandardRepNC}}
\label{ConvertWordToStandardRepNC}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
word in standard representation



 Converts the word \mbox{\texttt{\mdseries\slshape word}} in the representation of \mbox{\texttt{\mdseries\slshape resolution}} to the standard representation. The NC version does not check whether \mbox{\texttt{\mdseries\slshape word}} is a valid word of \mbox{\texttt{\mdseries\slshape resolution}}. }

 }

 
\section{\textcolor{Chapter }{Special Methods for \texttt{HapResolutionRep}}}\logpage{[ "B", 3, 0 ]}
\hyperdef{L}{X84FB45EB83B5822C}{}
{
 Some methods explicitely require the input to be in the standard
representation (\mbox{\texttt{\mdseries\slshape HapResolutionRep}}). Two of these test if a word/letter is really in standard representation,
the other ones are non\texttt{\symbol{45}}check versions of the universal
methods. 

\subsection{\textcolor{Chapter }{IsFreeZGLetter}}
\logpage{[ "B", 3, 1 ]}\nobreak
\hyperdef{L}{X7B803CC184BD2612}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{IsFreeZGLetter({\mdseries\slshape resolution, term, letter})\index{IsFreeZGLetter@\texttt{IsFreeZGLetter}}
\label{IsFreeZGLetter}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
boolean



 Checks if \mbox{\texttt{\mdseries\slshape letter}} is an valid letter (word of length 1) in standard representation of the \mbox{\texttt{\mdseries\slshape term}}th module of \mbox{\texttt{\mdseries\slshape resolution}}. }

 

\subsection{\textcolor{Chapter }{IsFreeZGWord}}
\logpage{[ "B", 3, 2 ]}\nobreak
\hyperdef{L}{X7A36FB7B84E9A892}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{IsFreeZGWord({\mdseries\slshape resolution, term, word})\index{IsFreeZGWord@\texttt{IsFreeZGWord}}
\label{IsFreeZGWord}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
boolean



 Check if \mbox{\texttt{\mdseries\slshape word}} is a valid word in large standard representation of the \mbox{\texttt{\mdseries\slshape term}}th module in \mbox{\texttt{\mdseries\slshape resolution}}. }

 

\subsection{\textcolor{Chapter }{MultiplyGroupEltsNC}}
\logpage{[ "B", 3, 3 ]}\nobreak
\hyperdef{L}{X836D3F9886EED6AC}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{MultiplyGroupEltsNC({\mdseries\slshape resolution, x, y})\index{MultiplyGroupEltsNC@\texttt{MultiplyGroupEltsNC}}
\label{MultiplyGroupEltsNC}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
positive integer



 Given positive integers \texttt{x} and \texttt{y}, this returns the position of the product of the group elements represented
by the positive integers \mbox{\texttt{\mdseries\slshape x}} and \mbox{\texttt{\mdseries\slshape x}}. This assumes that all input is in standard representation and does not check
the input. }

 

\subsection{\textcolor{Chapter }{MultiplyFreeZGLetterWithGroupEltNC}}
\logpage{[ "B", 3, 4 ]}\nobreak
\hyperdef{L}{X85893CC5823508A8}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{MultiplyFreeZGLetterWithGroupEltNC({\mdseries\slshape resolution, letter, g})\index{MultiplyFreeZGLetterWithGroupEltNC@\texttt{MultiplyFreeZGLetterWithGroupEltNC}}
\label{MultiplyFreeZGLetterWithGroupEltNC}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
A letter in standard representation



 Multiplies the letter \mbox{\texttt{\mdseries\slshape letter}} with the group element represented by the positive integer \mbox{\texttt{\mdseries\slshape g}} and returns the result. The input is assumed to be in \mbox{\texttt{\mdseries\slshape HapResolutionRep}} and is not checked. }

 

\subsection{\textcolor{Chapter }{MultiplyFreeZGWordWithGroupEltNC}}
\logpage{[ "B", 3, 5 ]}\nobreak
\hyperdef{L}{X8073DE7E7AD8B7CB}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{MultiplyFreeZGWordWithGroupEltNC({\mdseries\slshape resolution, word, g})\index{MultiplyFreeZGWordWithGroupEltNC@\texttt{MultiplyFreeZGWordWithGroupEltNC}}
\label{MultiplyFreeZGWordWithGroupEltNC}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
A letter in standard representation



 Multiplies the word \mbox{\texttt{\mdseries\slshape word}} with the group element represented by the positive integer \mbox{\texttt{\mdseries\slshape g}} and returns the result. The input is assumed to be in \mbox{\texttt{\mdseries\slshape HapResolutionRep}} and is not checked. }

 

\subsection{\textcolor{Chapter }{BoundaryOfFreeZGLetterNC}}
\logpage{[ "B", 3, 6 ]}\nobreak
\hyperdef{L}{X7BD3994E7C414149}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{BoundaryOfFreeZGLetterNC({\mdseries\slshape resolution, term, letter})\index{BoundaryOfFreeZGLetterNC@\texttt{BoundaryOfFreeZGLetterNC}}
\label{BoundaryOfFreeZGLetterNC}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
free ZG word in standard representation



 Calculates the boundary of the letter (word of length 1) \mbox{\texttt{\mdseries\slshape letter}} of the \mbox{\texttt{\mdseries\slshape term}}th module of \mbox{\texttt{\mdseries\slshape resolution}}. The input is assumed to be in standard representation and not checked. }

 

\subsection{\textcolor{Chapter }{BoundaryOfFreeZGWordNC}}
\logpage{[ "B", 3, 7 ]}\nobreak
\hyperdef{L}{X84B1DA21805A0880}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{BoundaryOfFreeZGWordNC({\mdseries\slshape resolution, term, word})\index{BoundaryOfFreeZGWordNC@\texttt{BoundaryOfFreeZGWordNC}}
\label{BoundaryOfFreeZGWordNC}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
free ZG word in standard representation



 Calculates the boundary of the word \mbox{\texttt{\mdseries\slshape word}} of the \mbox{\texttt{\mdseries\slshape term}}th module of \mbox{\texttt{\mdseries\slshape resolution}}. The input is assumed to be in standard representation and not checked. }

 }

 
\section{\textcolor{Chapter }{The \texttt{HapLargeGroupResolutionRep} Representation}}\logpage{[ "B", 4, 0 ]}
\hyperdef{L}{X8024014D8488FE30}{}
{
 The large group representation has one additional component called \texttt{groupring}. Elements of the modules in a resolution are represented by lists of group
ring elements. The length of the list corresponds to the dimension of the free
module. 

 All methods for the generic representation do also work for the large group
representation. Some of them are wrappers for special methods which do only
work for this representation. The following list only contains the methods
which are not already present in the generic representation. 

 Note that the input or the output of these functions does not comply with the
standard representation. 

\subsection{\textcolor{Chapter }{GroupRingOfResolution}}
\logpage{[ "B", 4, 1 ]}\nobreak
\hyperdef{L}{X861BE6C787FA8032}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{GroupRingOfResolution({\mdseries\slshape resolution})\index{GroupRingOfResolution@\texttt{GroupRingOfResolution}}
\label{GroupRingOfResolution}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
group ring



 This returns the group ring of \mbox{\texttt{\mdseries\slshape resolution}}. Note that by the way that group rings are handled in \textsf{GAP}, this is not equal to \texttt{GroupRing(R,GroupOfResolution(\mbox{\texttt{\mdseries\slshape resolution}}))} where \texttt{R} is the ring of the resolution. }

 

\subsection{\textcolor{Chapter }{MultiplyGroupElts{\textunderscore}LargeGroupRep}}
\logpage{[ "B", 4, 2 ]}\nobreak
\hyperdef{L}{X8338F7A37F240E33}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{MultiplyGroupElts{\textunderscore}LargeGroupRep({\mdseries\slshape resolution, x, y})\index{MultiplyGroupElts{\textunderscore}LargeGroupRep@\texttt{Multiply}\-\texttt{Group}\-\texttt{Elts{\textunderscore}}\-\texttt{Large}\-\texttt{GroupRep}}
\label{MultiplyGroupEltsuScoreLargeGroupRep}
}\hfill{\scriptsize (method)}}\\
\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{MultiplyGroupEltsNC{\textunderscore}LargeGroupRep({\mdseries\slshape resolution, x, y})\index{MultiplyGroupEltsNC{\textunderscore}LargeGroupRep@\texttt{Multiply}\-\texttt{Group}\-\texttt{Elts}\-\texttt{N}\-\texttt{C{\textunderscore}}\-\texttt{Large}\-\texttt{GroupRep}}
\label{MultiplyGroupEltsNCuScoreLargeGroupRep}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
group element



 Returns the product of \mbox{\texttt{\mdseries\slshape x}} and \mbox{\texttt{\mdseries\slshape y}}. The NC version does not check whether \mbox{\texttt{\mdseries\slshape x}} and \mbox{\texttt{\mdseries\slshape y}} are actually elements of the group of \mbox{\texttt{\mdseries\slshape resolution}}. }

 

\subsection{\textcolor{Chapter }{IsFreeZGLetterNoTermCheck{\textunderscore}LargeGroupRep}}
\logpage{[ "B", 4, 3 ]}\nobreak
\hyperdef{L}{X86F91A948022DEBB}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{IsFreeZGLetterNoTermCheck{\textunderscore}LargeGroupRep({\mdseries\slshape resolution, letter})\index{IsFreeZGLetterNoTermCheck{\textunderscore}LargeGroupRep@\texttt{IsFree}\-\texttt{Z}\-\texttt{G}\-\texttt{Letter}\-\texttt{No}\-\texttt{Term}\-\texttt{Check{\textunderscore}}\-\texttt{Large}\-\texttt{GroupRep}}
\label{IsFreeZGLetterNoTermCheckuScoreLargeGroupRep}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
boolean



 Returns \texttt{true} if \mbox{\texttt{\mdseries\slshape letter}} has the form of a letter (a module element with exactly one
non\texttt{\symbol{45}}zero entry which has exactly one
non\texttt{\symbol{45}}zero coefficient) a module of \mbox{\texttt{\mdseries\slshape resolution}} in the \texttt{HapLargeGroupResolution} representation. Note that it is not tested if \mbox{\texttt{\mdseries\slshape letter}} actually is a letter in any term of \mbox{\texttt{\mdseries\slshape resolution}} }

 

\subsection{\textcolor{Chapter }{IsFreeZGWordNoTermCheck{\textunderscore}LargeGroupRep}}
\logpage{[ "B", 4, 4 ]}\nobreak
\hyperdef{L}{X793BA61478AEBE16}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{IsFreeZGWordNoTermCheck{\textunderscore}LargeGroupRep({\mdseries\slshape resolution, word})\index{IsFreeZGWordNoTermCheck{\textunderscore}LargeGroupRep@\texttt{IsFree}\-\texttt{Z}\-\texttt{G}\-\texttt{Word}\-\texttt{No}\-\texttt{Term}\-\texttt{Check{\textunderscore}}\-\texttt{Large}\-\texttt{GroupRep}}
\label{IsFreeZGWordNoTermCheckuScoreLargeGroupRep}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
boolean



 Returns \texttt{true} if \mbox{\texttt{\mdseries\slshape word}} has the form of a word of a module of \mbox{\texttt{\mdseries\slshape resolution}} in the \texttt{HapLargeGroupResolution} representation. Note that it is not tested if \mbox{\texttt{\mdseries\slshape word}} actually is a word in any term of \mbox{\texttt{\mdseries\slshape resolution}}. }

 

\subsection{\textcolor{Chapter }{IsFreeZGLetter{\textunderscore}LargeGroupRep}}
\logpage{[ "B", 4, 5 ]}\nobreak
\hyperdef{L}{X85A7BFC284E9D9CB}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{IsFreeZGLetter{\textunderscore}LargeGroupRep({\mdseries\slshape resolution, term, letter})\index{IsFreeZGLetter{\textunderscore}LargeGroupRep@\texttt{IsFree}\-\texttt{Z}\-\texttt{G}\-\texttt{Letter{\textunderscore}}\-\texttt{Large}\-\texttt{GroupRep}}
\label{IsFreeZGLetteruScoreLargeGroupRep}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
boolean



 Returns \texttt{true} if and only if \mbox{\texttt{\mdseries\slshape letter}} is a letter (a word of length 1) of the \mbox{\texttt{\mdseries\slshape term}}th module of \mbox{\texttt{\mdseries\slshape resolution}} in the \texttt{hapLargeGroupResolution} representation. I.e. it tests if \mbox{\texttt{\mdseries\slshape letter}} is a module element with exactly one non\texttt{\symbol{45}}zero entry which
has exactly one non\texttt{\symbol{45}}zero coefficient. }

 

\subsection{\textcolor{Chapter }{IsFreeZGWord{\textunderscore}LargeGroupRep}}
\logpage{[ "B", 4, 6 ]}\nobreak
\hyperdef{L}{X7BF4A7EC83BE61C8}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{IsFreeZGWord{\textunderscore}LargeGroupRep({\mdseries\slshape resolution, term, word})\index{IsFreeZGWord{\textunderscore}LargeGroupRep@\texttt{IsFree}\-\texttt{Z}\-\texttt{G}\-\texttt{Word{\textunderscore}}\-\texttt{Large}\-\texttt{GroupRep}}
\label{IsFreeZGWorduScoreLargeGroupRep}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
boolean



 Tests if \mbox{\texttt{\mdseries\slshape word}} is an element of the \mbox{\texttt{\mdseries\slshape term}}th module of \mbox{\texttt{\mdseries\slshape resoultion}}. }

 

\subsection{\textcolor{Chapter }{MultiplyFreeZGLetterWithGroupElt{\textunderscore}LargeGroupRep}}
\logpage{[ "B", 4, 7 ]}\nobreak
\hyperdef{L}{X7A4B682079630694}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{MultiplyFreeZGLetterWithGroupElt{\textunderscore}LargeGroupRep({\mdseries\slshape resolution, letter, g})\index{MultiplyFreeZGLetterWithGroupElt{\textunderscore}LargeGroupRep@\texttt{Multiply}\-\texttt{Free}\-\texttt{Z}\-\texttt{G}\-\texttt{Letter}\-\texttt{With}\-\texttt{Group}\-\texttt{Elt{\textunderscore}}\-\texttt{Large}\-\texttt{GroupRep}}
\label{MultiplyFreeZGLetterWithGroupEltuScoreLargeGroupRep}
}\hfill{\scriptsize (method)}}\\
\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{MultiplyFreeZGLetterWithGroupEltNC{\textunderscore}LargeGroupRep({\mdseries\slshape resolution, letter, g})\index{MultiplyFreeZGLetterWithGroupEltNC{\textunderscore}LargeGroupRep@\texttt{Multiply}\-\texttt{Free}\-\texttt{Z}\-\texttt{G}\-\texttt{Letter}\-\texttt{With}\-\texttt{Group}\-\texttt{Elt}\-\texttt{N}\-\texttt{C{\textunderscore}}\-\texttt{Large}\-\texttt{GroupRep}}
\label{MultiplyFreeZGLetterWithGroupEltNCuScoreLargeGroupRep}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
free ZG letter in large group representation



 Multiplies the letter \mbox{\texttt{\mdseries\slshape letter}} with the group element \mbox{\texttt{\mdseries\slshape g}} and returns the result. The NC version does not check whether \mbox{\texttt{\mdseries\slshape g}} is an element of the group of \mbox{\texttt{\mdseries\slshape resolution}} and \mbox{\texttt{\mdseries\slshape letter}} can be a letter. }

 

\subsection{\textcolor{Chapter }{MultiplyFreeZGWordWithGroupElt{\textunderscore}LargeGroupRep}}
\logpage{[ "B", 4, 8 ]}\nobreak
\hyperdef{L}{X7F2365D2851E3E3C}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{MultiplyFreeZGWordWithGroupElt{\textunderscore}LargeGroupRep({\mdseries\slshape resolution, word, g})\index{MultiplyFreeZGWordWithGroupElt{\textunderscore}LargeGroupRep@\texttt{Multiply}\-\texttt{Free}\-\texttt{Z}\-\texttt{G}\-\texttt{Word}\-\texttt{With}\-\texttt{Group}\-\texttt{Elt{\textunderscore}}\-\texttt{Large}\-\texttt{GroupRep}}
\label{MultiplyFreeZGWordWithGroupEltuScoreLargeGroupRep}
}\hfill{\scriptsize (method)}}\\
\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{MultiplyFreeZGWordWithGroupEltNC{\textunderscore}LargeGroupRep({\mdseries\slshape resolution, word, g})\index{MultiplyFreeZGWordWithGroupEltNC{\textunderscore}LargeGroupRep@\texttt{Multiply}\-\texttt{Free}\-\texttt{Z}\-\texttt{G}\-\texttt{Word}\-\texttt{With}\-\texttt{Group}\-\texttt{Elt}\-\texttt{N}\-\texttt{C{\textunderscore}}\-\texttt{Large}\-\texttt{GroupRep}}
\label{MultiplyFreeZGWordWithGroupEltNCuScoreLargeGroupRep}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
free ZG word in large group representation



 Multiplies the word \mbox{\texttt{\mdseries\slshape word}} with the group element \mbox{\texttt{\mdseries\slshape g}} and returns the result. The NC version does not check whether \mbox{\texttt{\mdseries\slshape g}} is an element of the group of \mbox{\texttt{\mdseries\slshape resolution}} and \mbox{\texttt{\mdseries\slshape word}} can be a word. }

 

\subsection{\textcolor{Chapter }{GeneratorsOfModuleOfResolution{\textunderscore}LargeGroupRep}}
\logpage{[ "B", 4, 9 ]}\nobreak
\hyperdef{L}{X8355F6E8842B3D8C}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{GeneratorsOfModuleOfResolution{\textunderscore}LargeGroupRep({\mdseries\slshape resolution, term})\index{GeneratorsOfModuleOfResolution{\textunderscore}LargeGroupRep@\texttt{Generators}\-\texttt{Of}\-\texttt{Module}\-\texttt{Of}\-\texttt{Resolution{\textunderscore}}\-\texttt{Large}\-\texttt{GroupRep}}
\label{GeneratorsOfModuleOfResolutionuScoreLargeGroupRep}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
list of letters/words in large group representation



 Returns a set of generators for the \mbox{\texttt{\mdseries\slshape term}}th module of \mbox{\texttt{\mdseries\slshape resolution}}. The returned value is a list of vectors of group ring elements. }

 

\subsection{\textcolor{Chapter }{BoundaryOfGenerator{\textunderscore}LargeGroupRep}}
\logpage{[ "B", 4, 10 ]}\nobreak
\hyperdef{L}{X840DF79086D5473E}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{BoundaryOfGenerator{\textunderscore}LargeGroupRep({\mdseries\slshape resolution, term, n})\index{BoundaryOfGenerator{\textunderscore}LargeGroupRep@\texttt{Boundary}\-\texttt{Of}\-\texttt{Generator{\textunderscore}}\-\texttt{Large}\-\texttt{GroupRep}}
\label{BoundaryOfGeneratoruScoreLargeGroupRep}
}\hfill{\scriptsize (method)}}\\
\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{BoundaryOfGeneratorNC{\textunderscore}LargeGroupRep({\mdseries\slshape resolution, term, n})\index{BoundaryOfGeneratorNC{\textunderscore}LargeGroupRep@\texttt{Boundary}\-\texttt{Of}\-\texttt{Generator}\-\texttt{N}\-\texttt{C{\textunderscore}}\-\texttt{Large}\-\texttt{GroupRep}}
\label{BoundaryOfGeneratorNCuScoreLargeGroupRep}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
free ZG word in the large group representation



 Returns the boundary of the \mbox{\texttt{\mdseries\slshape n}}th generator of the \mbox{\texttt{\mdseries\slshape term}}th module of \mbox{\texttt{\mdseries\slshape resolution}} as a word in the \mbox{\texttt{\mdseries\slshape n\texttt{\symbol{45}}1}}st module (in large group representation). The NC version does not check
whether there is a \mbox{\texttt{\mdseries\slshape term}}th module and if it has at least \mbox{\texttt{\mdseries\slshape n}} generators. }

 

\subsection{\textcolor{Chapter }{BoundaryOfFreeZGLetterNC{\textunderscore}LargeGroupRep}}
\logpage{[ "B", 4, 11 ]}\nobreak
\hyperdef{L}{X83D90EC28357DCCE}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{BoundaryOfFreeZGLetterNC{\textunderscore}LargeGroupRep({\mdseries\slshape resolution, term, letter})\index{BoundaryOfFreeZGLetterNC{\textunderscore}LargeGroupRep@\texttt{Boundary}\-\texttt{Of}\-\texttt{Free}\-\texttt{Z}\-\texttt{G}\-\texttt{Letter}\-\texttt{N}\-\texttt{C{\textunderscore}}\-\texttt{Large}\-\texttt{GroupRep}}
\label{BoundaryOfFreeZGLetterNCuScoreLargeGroupRep}
}\hfill{\scriptsize (method)}}\\
\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{BoundaryOfFreeZGLetter{\textunderscore}LargeGroupRep({\mdseries\slshape resolution, term, letter})\index{BoundaryOfFreeZGLetter{\textunderscore}LargeGroupRep@\texttt{Boundary}\-\texttt{Of}\-\texttt{Free}\-\texttt{Z}\-\texttt{G}\-\texttt{Letter{\textunderscore}}\-\texttt{Large}\-\texttt{GroupRep}}
\label{BoundaryOfFreeZGLetteruScoreLargeGroupRep}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
free ZG word in large group representation



 Calculates the boundary of the letter \mbox{\texttt{\mdseries\slshape letter}} of the \mbox{\texttt{\mdseries\slshape term}}th module of \mbox{\texttt{\mdseries\slshape resolution}} in large group representation. The NC version does not check whether \mbox{\texttt{\mdseries\slshape letter}} actually is a letter in the \mbox{\texttt{\mdseries\slshape term}}th module. }

 

\subsection{\textcolor{Chapter }{BoundaryOfFreeZGWord{\textunderscore}LargeGroupRep}}
\logpage{[ "B", 4, 12 ]}\nobreak
\hyperdef{L}{X78C681D37F8DC2A1}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{BoundaryOfFreeZGWord{\textunderscore}LargeGroupRep({\mdseries\slshape resolution, term, word})\index{BoundaryOfFreeZGWord{\textunderscore}LargeGroupRep@\texttt{Boundary}\-\texttt{Of}\-\texttt{Free}\-\texttt{Z}\-\texttt{G}\-\texttt{Word{\textunderscore}}\-\texttt{Large}\-\texttt{GroupRep}}
\label{BoundaryOfFreeZGWorduScoreLargeGroupRep}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
free ZG word in large group representation



 Calculates the boundary of the element \mbox{\texttt{\mdseries\slshape word}} of the \mbox{\texttt{\mdseries\slshape term}}th module of \mbox{\texttt{\mdseries\slshape resolution}} in large group representation. The NC version does not check whether \mbox{\texttt{\mdseries\slshape word}} actually is a word in the \mbox{\texttt{\mdseries\slshape term}}th module. }

 }

 }


\chapter{\textcolor{Chapter }{Contracting Homotopies}}\logpage{[ "C", 0, 0 ]}
\hyperdef{L}{X792B9CC97C670AEA}{}
{
 
\section{\textcolor{Chapter }{The \texttt{PartialContractingHomotopy} Data Type}}\logpage{[ "C", 1, 0 ]}
\hyperdef{L}{X7E957D2381DBE362}{}
{
 A partial contracting homotopy is a component object that knows the values of
a contracting homotopy on some subspace of a resolution. It has two mandatory
components: 
\begin{itemize}
\item \texttt{.resolution} a \texttt{HapResolution} on which the contraction is defined.
\item \texttt{.knownPartOfHomotopy} a list of \texttt{Record}s with components \texttt{.space} and \texttt{.map}.
\end{itemize}
 Let \texttt{h} be a contracting homotopy. The lookup table \texttt{.knownPartOfHomotopy} has one entry for each term of the resolution \texttt{h.resolution} (that is, one more than \texttt{Length(h.resolution)}). 

 The $i$ th element of \texttt{.knownPartOfHomotopy} contains a record with components \texttt{.space} and \texttt{.map} where \texttt{.space} is a \texttt{FreeZGWord} of the $i-1$ st term of the resolution. The component \texttt{.map} is a list of length \texttt{Dimension(h.resolution)(i\texttt{\symbol{45}}1)}. The entries of this list are pairs \texttt{[g,im]} where \texttt{g} represents a group element and \texttt{im} represents the image of the contraction. So the entry \texttt{[g,im]} in the \texttt{k}th component of the list \texttt{.map} means that the \texttt{k}th free generator of the corresponding module multiplied with the group
element represented by \texttt{g} is mapped to \texttt{im} under the partial contracting homotopy. Note that the data type of \texttt{g} or \texttt{im} are not fixed at this level. They must be specified by the sub
representations. Also, \texttt{im} need not represent the actual image under a contracting homotopy. It is
possible to just store a bit of information that is then used to generate the
actual image. 

 As this is a very general data type, it has very few methods. 

\subsection{\textcolor{Chapter }{ResolutionOfContractingHomotopy}}
\logpage{[ "C", 1, 1 ]}\nobreak
\hyperdef{L}{X7D899ACD7EB512FA}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{ResolutionOfContractingHomotopy({\mdseries\slshape homotopy})\index{ResolutionOfContractingHomotopy@\texttt{ResolutionOfContractingHomotopy}}
\label{ResolutionOfContractingHomotopy}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
A \texttt{HapResolution}



 This returns the resolution of the homotopy \mbox{\texttt{\mdseries\slshape homotopy}} (the component \mbox{\texttt{\mdseries\slshape homotopy!.resolution}}). }

 

\subsection{\textcolor{Chapter }{PartialContractingHomotopyLookup}}
\logpage{[ "C", 1, 2 ]}\nobreak
\hyperdef{L}{X79C69C9B877C6D60}{}
{\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PartialContractingHomotopyLookup({\mdseries\slshape homotopy, term, generator, groupel})\index{PartialContractingHomotopyLookup@\texttt{PartialContractingHomotopyLookup}}
\label{PartialContractingHomotopyLookup}
}\hfill{\scriptsize (method)}}\\
\noindent\textcolor{FuncColor}{$\triangleright$\enspace\texttt{PartialContractingHomotopyLookupNC({\mdseries\slshape homotopy, term, generator, groupel})\index{PartialContractingHomotopyLookupNC@\texttt{PartialContractingHomotopyLookupNC}}
\label{PartialContractingHomotopyLookupNC}
}\hfill{\scriptsize (method)}}\\
\textbf{\indent Returns:\ }
The entry \texttt{im} of the corresponding lookup table



 Looks up the known part of the contracting homotopy \mbox{\texttt{\mdseries\slshape homotopy}} and returns the corresponding image. More precisely, it returns the image of
the \mbox{\texttt{\mdseries\slshape generator}}th generator times the group element represented by \mbox{\texttt{\mdseries\slshape groupel}} in term \mbox{\texttt{\mdseries\slshape term}} under the partial homotopy. The data type of this image depends on the
representation of \mbox{\texttt{\mdseries\slshape homotopy}}. 

 \mbox{\texttt{\mdseries\slshape term}} has to be an integer and \mbox{\texttt{\mdseries\slshape generator}} a positive integer. \mbox{\texttt{\mdseries\slshape groupel}} only has to be an \texttt{Object}. 

 The NC version does not do any checks on the input. The other version checks
if \mbox{\texttt{\mdseries\slshape term}} and \mbox{\texttt{\mdseries\slshape generator}} are sensible. It does not check \mbox{\texttt{\mdseries\slshape groupel}}. }

 }

 }

\def\bibname{References\logpage{[ "Bib", 0, 0 ]}
\hyperdef{L}{X7A6F98FD85F02BFE}{}
}

\bibliographystyle{alpha}
\bibliography{HAPcryst}

\addcontentsline{toc}{chapter}{References}

\def\indexname{Index\logpage{[ "Ind", 0, 0 ]}
\hyperdef{L}{X83A0356F839C696F}{}
}

\cleardoublepage
\phantomsection
\addcontentsline{toc}{chapter}{Index}


\printindex

\immediate\write\pagenrlog{["Ind", 0, 0], \arabic{page},}
\newpage
\immediate\write\pagenrlog{["End"], \arabic{page}];}
\immediate\closeout\pagenrlog
\end{document}
