GAP 4.8.9 installation with standard packages -- copy to your CoCalc project to get it
#############################################################################
##
#W resolutionAccess_LargeGroupRep.gi HAPcryst package Marc Roeder
##
##
##
#H @(#)$Id: resolutionAccess_LargeGroupRep.gi, v 0.1.11 2013/10/27 18:31:09 gap Exp $
##
#Y Copyright (C) 2006 Marc Roeder
#Y
#Y This program is free software; you can redistribute it and/or
#Y modify it under the terms of the GNU General Public License
#Y as published by the Free Software Foundation; either version 2
#Y of the License, or (at your option) any later version.
#Y
#Y This program is distributed in the hope that it will be useful,
#Y but WITHOUT ANY WARRANTY; without even the implied warranty of
#Y MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
#Y GNU General Public License for more details.
#Y
#Y You should have received a copy of the GNU General Public License
#Y along with this program; if not, write to the Free Software
#Y Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
##
Revision.("/Users/roeder/gap/HAPcryst/HAPcryst/lib/datatypes/resolutionAccess_LargeGroupRep_gi"):=
"@(#)$Id: resolutionAccess_LargeGroupRep.gi, v 0.1.11 2013/10/27 18:31:09 gap Exp $";
#############################################################################
##
## This file implements a representation for HapResolutions of large groups
##
## Elemements of the modules of this resolution are represented by
## integer-group element pairs.
##
## R!.elt must be present, but is not used for internal computations.
## It is used for conversion to and from the standard representation.
##
##
#############################################################################
##
#O Dimension(<resolution>)
##
## overload the Hap function using !.diension2
##
InstallOtherMethod(Dimension,
[IsHapLargeGroupResolutionRep],
function(resolution)
return function(k) return resolution!.dimension2(resolution,k);end;
end);
#############################################################################
##
#O MultiplyGroupEltsNC(<resolution>,<x>,<y>)
#O MultiplyGroupEltsNC_LargeGroupRep(<resolution>,<x>,<y>)
##
## catch, convert, delegate, convert
##
InstallMethod(MultiplyGroupEltsNC,"for HapResolutions of large groups",
[IsHapLargeGroupResolutionRep,IsPosInt,IsPosInt],
function(resolution,x,y)
local xgroup, ygroup, product;
xgroup:=GroupElementFromPosition(resolution,x);
ygroup:=GroupElementFromPosition(resolution,y);
product:=MultiplyGroupEltsNC_LargeGroupRep(resolution,xgroup,ygroup);
return PositionInGroupOfResolutionNC(resolution,product);
end);
InstallMethod(MultiplyGroupEltsNC_LargeGroupRep,"for HapResolutions of large groups",
[IsHapLargeGroupResolutionRep,IsObject,IsObject],
function(resolution,x,y)
return x*y;
end);
#############################################################################
##
#O MultiplyGroupElts_LargeGroupRep(<resolution>,<x>,<y>)
##
## interenal method for this representation.
##
InstallMethod(MultiplyGroupElts_LargeGroupRep,"for HapResolutions of large groups",
[IsHapLargeGroupResolutionRep,IsObject,IsObject],
function(resolution,x,y)
if not IsSubset(GroupOfResolution(resolution),[x,y])
then
Error("<x> and <y> must belong to <resolution>'s group");
else
return MultiplyGroupEltsNC_LargeGroupRep(resolution,x,y);
fi;
end);
#############################################################################
##
#O MultiplyGroupElts(<resolution>,<x>,<y>)
##
## interenal method for this representation.
##
InstallMethod(MultiplyGroupElts,"for HapResolutions of large groups",
[IsHapLargeGroupResolutionRep,IsObject,IsObject],
function(resolution,x,y)
if IsSubset(GroupOfResolution(resolution),[x,y])
then
return MultiplyGroupEltsNC_LargeGroupRep(resolution,x,y);
elif ForAll([x,y],i->IsValidGroupInt(resolution,i))
then
return MultiplyGroupEltsNC(resolution,x,y);
else
TryNextMethod();
fi;
end);
#############################################################################
##
## No "!"s allowed beyond this point
##
#############################################################################
#############################################################################
##
#O StrongtestValidRepresentationForLetter(resolution,term,letter)
##
## returns the strongest representation in which <letter> is a valid letter
## for <resolution>
##
InstallMethod(StrongestValidRepresentationForLetter,
[IsHapLargeGroupResolutionRep,IsInt,IsDenseList],
function(resolution,term, letter)
if IsFreeZGLetter_LargeGroupRep(resolution,term,letter)
then
return IsHapLargeGroupResolutionRep;
else
TryNextMethod();
fi;
end);
#############################################################################
##
#O StrongtestValidRepresentationForWord(resolution,term,word)
##
## returns the strongest representation in which <word> is a valid letter
## for <word>
##
InstallMethod(StrongestValidRepresentationForWord,
[IsHapLargeGroupResolutionRep,IsInt,IsDenseList],
function(resolution,term, word)
if IsFreeZGWord_LargeGroupRep(resolution,term,word)
then
return IsHapLargeGroupResolutionRep;
else
TryNextMethod();
fi;
end);
#############################################################################
##
#O ConvertStandardLetterToLargeGroupRepNC(<resolution>,<term>,<letter>)
#O ConvertStandardLetterToLargeGroupRep(<resolution>,<term>,<letter>)
##
InstallMethod(ConvertStandardLetter,
[IsHapResolutionRep,IsInt,IsDenseList],
function(resolution,term,letter)
if not IsFreeZGLetter(resolution,term,letter)
then
Error("<letter> is not a valid letter");
fi;
return ConvertStandardLetterNC(resolution,term,letter);
end);
InstallMethod(ConvertStandardLetterNC,
[IsHapResolutionRep,IsInt,IsDenseList],
function(resolution,term,letter)
return [letter[1],GroupElementFromPosition(resolution,letter[2])];
end);
#############################################################################
##
#O ConvertStandardWordNC(<resolution>,<term>,<letter>)
#O ConvertStandardWord(<resolution>,<term>,<letter>)
##
InstallMethod(ConvertStandardWord,
[IsHapResolutionRep,IsInt,IsDenseList],
function(resolution,term,word)
if not IsFreeZGWord(resolution,term,word)
then
Error("<word> is not a valid word");
fi;
return ConvertStandardWordNC(resolution,term,word);
end);
InstallMethod(ConvertStandardWordNC,
[IsHapResolutionRep,IsInt,IsDenseList],
function(resolution,term,word)
return List(word,letter->ConvertStandardLetterNC(resolution,term,letter));
end);
#############################################################################
##
#O ConvertLetterToStandardRepNC
#O ConvertLetterToStandardRep
##
InstallMethod(ConvertLetterToStandardRep,
[IsHapLargeGroupResolutionRep,IsInt,IsDenseList],
function(resolution,term,letter)
if not IsFreeZGLetter_LargeGroupRep(resolution,term,letter)
then
Error("<letter> is not a valid letter in large group representation.");
fi;
return ConvertLetterToStandardRepNC(resolution,term,letter);
end);
InstallMethod(ConvertLetterToStandardRepNC,
[IsHapLargeGroupResolutionRep,IsInt,IsDenseList],
function(resolution,term,letter)
return [letter[1],PositionInGroupOfResolution(resolution,letter[2])];
end);
#############################################################################
##
#O ConvertWordToStandardRepNC
#O ConvertWordToStandardRep
##
InstallMethod(ConvertWordToStandardRep,
[IsHapLargeGroupResolutionRep,IsInt,IsDenseList],
function(resolution,term,word)
if not IsFreeZGWord_LargeGroupRep(resolution,term,word)
then
Error("<letter> is not a valid letter in large group representation.");
fi;
return ConvertWordToStandardRepNC(resolution,term,word);
end);
InstallMethod(ConvertWordToStandardRepNC,
[IsHapLargeGroupResolutionRep,IsInt,IsDenseList],
function(resolution,term,word)
return List(word,letter->ConvertLetterToStandardRepNC(resolution,term,letter));
end);
#############################################################################
##
#O IsFreeZGLetter_LargeGroupRep(<resolution>,<term>,<letter>)
##
## check if <letter> is a letter of the <term>th module of <resolution>.
## A letter is a word of length 1.
##
##
InstallMethod(IsFreeZGLetter_LargeGroupRep,"For HapResolutions of large groups",
[IsHapLargeGroupResolutionRep,IsInt,IsDenseList],
function(resolution,term,letter)
if not (
Size(letter)=2
and IsInt(letter[1])
and AbsInt(letter[1])<=Dimension(resolution)(term)
and letter[2] in GroupOfResolution(resolution)
)
then
return false;
else
return true;
fi;
end);
#############################################################################
##
#O IsFreeZGWord_LargeGroupRep(<resolution>,<term>,<word>)
##
## Check if <word> is an element of the <term>th module in <resolution>
##
##
InstallMethod(IsFreeZGWord_LargeGroupRep,"For HapResolutions of large groups",
[IsHapLargeGroupResolutionRep,IsInt,IsDenseList],
function(resolution,term,word)
local firstEntries, secondEntries;
if not ForAll(word,IsDenseList)
then
return false;
fi;
firstEntries:=List(word,i->AbsInt(i[1]));
secondEntries:=Set(word,i->i[2]);
if Maximum(firstEntries)<=Dimension(resolution)(term)
and IsSubset(GroupOfResolution(resolution),secondEntries)
then
return true;
else
return false;
fi;
end);
#############################################################################
##
#O MultiplyFreeZGLetterWithGroupEltNC_LargeGroupRep(<resolution>,<letter>,<g>)
##
## given a pair <letter> of positive integers which represent a generator-
## group element pair, this returns the letter multiplied with the group
## element <g>.
##
##
InstallMethod(MultiplyFreeZGLetterWithGroupEltNC_LargeGroupRep,"For HapResolutions of large groups",
[IsHapLargeGroupResolutionRep,IsDenseList,IsObject],
function(resolution,letter,g)
local newgroupel;
return [letter[1],letter[2]*g];
end);
#############################################################################
##
#O MultiplyFreeZGLetterWithGroupElt_LargeGroupRep(<resolution>,<letter>,<g>)
#O MultiplyFreeZGLetterWithGroupElt(<resolution>,<letter>,<g>)
##
## Check input for sanity and delegate to NC version
##
InstallMethod(MultiplyFreeZGLetterWithGroupElt_LargeGroupRep,"For HapResolutions of large groups",
[IsHapLargeGroupResolutionRep,IsDenseList,IsObject],
function(resolution,letter,g)
if not (IsSubset(GroupOfResolution(resolution),[g,letter[2]])
and IsInt(letter[1])
)
then
Error("<letter> or <g> of wrong form");
fi;
return MultiplyFreeZGLetterWithGroupEltNC_LargeGroupRep(resolution,letter,g);
end);
#############################################################################
##
InstallMethod(MultiplyFreeZGLetterWithGroupElt,"For HapResolutions of large groups",
[IsHapLargeGroupResolutionRep,IsDenseList,IsObject],
function(resolution,letter,g)
if not (IsSubset(GroupOfResolution(resolution),[g,letter[2]])
and IsInt(letter[1])
)
then
TryNextMethod();
fi;
return MultiplyFreeZGLetterWithGroupEltNC_LargeGroupRep(resolution,letter,g);
end);
#############################################################################
##
#O MultiplyFreeZGWordWithGroupEltNC_LargeGroupRep(<resolution>,<word>,<g>)
##
## multiplies the word <word> with the group element <g>.
## No checks are performed.
##
InstallMethod(MultiplyFreeZGWordWithGroupEltNC_LargeGroupRep,"For HapResolutions of large groups",
[IsHapLargeGroupResolutionRep,IsDenseList,IsObject],
function(resolution,word,g)
return List(word,cell->MultiplyFreeZGLetterWithGroupEltNC_LargeGroupRep(resolution,cell,g));
end);
#############################################################################
##
#O MultiplyFreeZGWordWithGroupElt_LargeGroupRep(<resolution>,<word>,<g>)
#O MultiplyFreeZGWordWithGroupElt(<resolution>,<word>,<g>)
##
## Check input and delegate to NC version.
##
InstallMethod(MultiplyFreeZGWordWithGroupElt_LargeGroupRep,"For HapResolution",
[IsHapLargeGroupResolutionRep,IsDenseList,IsObject],
function(resolution,word,g)
local group;
group:=GroupOfResolution(resolution);
if not (ForAll(word,i->IsInt(i[1]) and i[2] in group)
and g in group
)
then
Error("<g> or <word> are not valid");
fi;
return MultiplyFreeZGWordWithGroupEltNC_LargeGroupRep(resolution,word,g);
end);
#############################################################################
##
InstallMethod(MultiplyFreeZGWordWithGroupElt,"For HapResolution",
[IsHapLargeGroupResolutionRep,IsDenseList,IsObject],
function(resolution,word,g)
local group;
group:=GroupOfResolution(resolution);
if not (ForAll(word,i->IsInt(i[1]) and i[2] in group)
and g in group
)
then
TryNextMethod();
fi;
return MultiplyFreeZGWordWithGroupEltNC_LargeGroupRep(resolution,word,g);
end);
#############################################################################
##
#O BoundaryOfFreeZGLetterNC(<resolution>,<term>,<cell>)
#O BoundaryOfFreeZGLetterNC_LargeGroupRep(<resolution>,<term>,<cell>)
##
## calculates the boundary of a cell in the <term>th module.
##
## catch, convert, delegate, convert
##
InstallMethod(BoundaryOfFreeZGLetterNC,"For HapResolutions of large groups",
[IsHapLargeGroupResolutionRep,IsInt,IsDenseList],
function(resolution,term,cell)
local cell_LargeGroupRep, boundary;
cell_LargeGroupRep:=[cell[1],GroupElementFromPosition(resolution,cell[2])];
boundary:=BoundaryOfFreeZGLetterNC_LargeGroupRep(resolution,term,cell_LargeGroupRep);
Apply(boundary,i->[i[1],
PositionInGroupOfResolutionNC(resolution,i[2])]);
return boundary;
end);
#############################################################################
##
InstallMethod(BoundaryOfFreeZGLetterNC_LargeGroupRep,
"For HapResolutions of large groups",
[IsHapLargeGroupResolutionRep,IsInt,IsDenseList],
function(resolution,term,cell)
local sign, boundary;
sign:=SignInt(cell[1]);
boundary:=resolution!.boundary2(resolution,term,AbsInt(cell[1]));
boundary:=MultiplyFreeZGWordWithGroupEltNC_LargeGroupRep(resolution,boundary,cell[2]);
if sign=-1
then
return NegateWord(boundary);
else
return boundary;
fi;
end);
#############################################################################
##
#O BoundaryOfFreeZGLetter_LargeGroupRep(<resolution>,<term>,<letter>)
#O BoundaryOfFreeZGLetter(<resolution>,<term>,<letter>)
##
## checks input and delegates to NC version
##
InstallMethod(BoundaryOfFreeZGLetter_LargeGroupRep,"For HapResolutions of large groups",
[IsHapLargeGroupResolutionRep,IsInt,IsDenseList],
function(resolution,term,letter)
if not IsFreeZGLetter_LargeGroupRep(resolution,term,letter)
then
Error("<letter> is not a proper letter");
fi;
return BoundaryOfFreeZGLetterNC_LargeGroupRep(resolution,term,letter);
end);
#############################################################################
##
InstallMethod(BoundaryOfFreeZGLetter,
[IsHapLargeGroupResolutionRep,IsInt,IsDenseList],
function(resolution,term,letter)
local letter_large;
if IsFreeZGLetter_LargeGroupRep(resolution,term,letter)
then
return BoundaryOfFreeZGLetterNC_LargeGroupRep(resolution,term,letter);
elif IsFreeZGLetter(resolution,term,letter)
then
letter_large:=ConvertStandardLetterNC(resolution,term,letter);
return ConvertWordToStandardRepNC(resolution,term,BoundaryOfFreeZGLetterNC_LargeGroupRep(resolution,term,letter_large));
else
TryNextMethod();
fi;
end);
#############################################################################
##
#O BoundaryOfFreeZGWordNC_LargeGroupRep(<resolution>,<term>,<word>)
##
## calculate the boundary of the element <word> of the <term>th module of the
## resolution <resolution>.
## No checks done.
##
InstallMethod(BoundaryOfFreeZGWordNC_LargeGroupRep,"For HapResolutions of large groups",
[IsHapLargeGroupResolutionRep,IsInt,IsDenseList],
function(resolution,term,word)
local boundary, letter, letterbound;
boundary:=[];
for letter in word
do
letterbound:=BoundaryOfFreeZGLetterNC_LargeGroupRep(resolution,term,letter);
boundary:=AddFreeWords(boundary,letterbound);
od;
return boundary;
end);
#############################################################################
##
#O BoundaryOfFreeZGWord_LargeGroupRep(<resolution>,<term>,<word>)
#O BoundaryOfFreeZGWord(<resolution>,<term>,<word>)
##
## Check input and delegate to NC version.
##
InstallMethod(BoundaryOfFreeZGWord_LargeGroupRep,"For HapResolution",
[IsHapLargeGroupResolutionRep,IsInt,IsDenseList],
function(resolution,term,word)
if not IsFreeZGWord_LargeGroupRep(resolution,term,word)
then
Error("<word> is not an element of the <term>th module");
fi;
return BoundaryOfFreeZGWordNC_LargeGroupRep(resolution,term,word);
end);
#############################################################################
##
InstallMethod(BoundaryOfFreeZGWord,
[IsHapLargeGroupResolutionRep,IsInt,IsDenseList],
function(resolution,term,letter)
local word_large;
if IsFreeZGWord_LargeGroupRep(resolution,term,letter)
then
return BoundaryOfFreeZGWordNC_LargeGroupRep(resolution,term,letter);
elif IsFreeZGLetter(resolution,term,letter)
then
word_large:=ConvertWordToStandardRepNC(resolution,term,letter);
return ConvertWordToStandardRepNC(resolution,term,BoundaryOfFreeZGWordNC(resolution,term,word_large));
else
TryNextMethod();
fi;
end);