|
#############################################################################
##
## This file is part of GAP, a system for computational discrete algebra.
## This file's authors include Frank Celler, Alexander Hulpke.
##
## Copyright of GAP belongs to its developers, whose names are too numerous
## to list here. Please refer to the COPYRIGHT file for details.
##
## SPDX-License-Identifier: GPL-2.0-or-later
##
## This file contains the declarations of operations for the 1-Cohomology
##
#############################################################################
##
#V InfoCoh
##
## <#GAPDoc Label="InfoCoh">
## <ManSection>
## <InfoClass Name="InfoCoh"/>
##
## <Description>
## The info class for the cohomology calculations is
## <Ref InfoClass="InfoCoh"/>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareInfoClass("InfoCoh");
#############################################################################
##
#O TriangulizedGeneratorsByMatrix( <gens>, <M>, <F> )
## triangulize and make base
##
## <ManSection>
## <Oper Name="TriangulizedGeneratorsByMatrix" Arg='gens, M, F'/>
##
## <Description>
## AKA <C>AbstractBaseMat</C>
## </Description>
## </ManSection>
##
DeclareGlobalFunction("TriangulizedGeneratorsByMatrix");
## For all following functions, the group is given as second argument to
## allow dispatching after the group type
#############################################################################
##
#O OCAddGenerators( <ocr>, <G> ) . . . . . . . . . . . add generators, local
##
## <ManSection>
## <Oper Name="OCAddGenerators" Arg='ocr, G'/>
##
## <Description>
## </Description>
## </ManSection>
##
DeclareGlobalFunction( "OCAddGenerators" );
#############################################################################
##
#O OCAddMatrices( <ocr>, <gens> ) . . . . . . add operation matrices, local
##
## <ManSection>
## <Oper Name="OCAddMatrices" Arg='ocr, gens'/>
##
## <Description>
## </Description>
## </ManSection>
##
DeclareGlobalFunction( "OCAddMatrices" );
#############################################################################
##
#O OCAddToFunctions( <ocr> ) . . . . add operation matrices, local
##
## <ManSection>
## <Oper Name="OCAddToFunctions" Arg='ocr'/>
##
## <Description>
## </Description>
## </ManSection>
##
DeclareGlobalFunction( "OCAddToFunctions" );
DeclareOperation( "OCAddToFunctions2", [IsRecord, IsListOrCollection] );
#############################################################################
##
#O OCAddRelations( <ocr>,<gens> ) . . . . . . . . . . add relations, local
##
## <ManSection>
## <Oper Name="OCAddRelations" Arg='ocr,gens'/>
##
## <Description>
## </Description>
## </ManSection>
##
DeclareOperation( "OCAddRelations",
[IsRecord, IsListOrCollection] );
#############################################################################
##
#O OCNormalRelations( <ocr>,<G>,<gens> ) rels for normal complements, local
##
## <ManSection>
## <Oper Name="OCNormalRelations" Arg='ocr,G,gens'/>
##
## <Description>
## </Description>
## </ManSection>
##
DeclareOperation( "OCNormalRelations",
[IsRecord,IsGroup,IsListOrCollection] );
#############################################################################
##
#O OCAddSumMatrices( <ocr>, <gens> ) . . . . . . . . . . . add sums, local
##
## <ManSection>
## <Oper Name="OCAddSumMatrices" Arg='ocr, gens'/>
##
## <Description>
## </Description>
## </ManSection>
##
DeclareOperation("OCAddSumMatrices",
[IsRecord,IsListOrCollection]);
#############################################################################
##
#O OCAddBigMatrices( <ocr>, <gens> ) . . . . . . . . . . . . . . . . local
##
## <ManSection>
## <Oper Name="OCAddBigMatrices" Arg='ocr, gens'/>
##
## <Description>
## </Description>
## </ManSection>
##
DeclareOperation( "OCAddBigMatrices",
[IsRecord,IsListOrCollection] );
#############################################################################
##
#O OCCoprimeComplement( <ocr>, <gens> ) . . . . . . . . coprime complement
##
## <ManSection>
## <Oper Name="OCCoprimeComplement" Arg='ocr, gens'/>
##
## <Description>
## </Description>
## </ManSection>
##
DeclareOperation( "OCCoprimeComplement",
[IsRecord,IsListOrCollection] );
#############################################################################
##
#O OneCoboundaries( <G>, <M> ) . . . . . . . . . . one cobounds of <G> / <M>
##
## <#GAPDoc Label="OneCoboundaries">
## <ManSection>
## <Func Name="OneCoboundaries" Arg='G, M'/>
##
## <Description>
## computes the group of 1-coboundaries.
## Syntax of input and output otherwise is the same as with
## <Ref Func="OneCocycles" Label="for two groups"/> except that entries that
## refer to cocycles are not computed.
## <P/>
## The operations <Ref Func="OneCocycles" Label="for two groups"/> and
## <Ref Func="OneCoboundaries"/> return a record with
## (at least) the components:
## <P/>
## <List>
## <Mark><C>generators</C></Mark>
## <Item>
## Is a list of representatives for a generating set of <A>G</A>/<A>M</A>.
## Cocycles are represented with respect to these generators.
## </Item>
## <Mark><C>oneCocycles</C></Mark>
## <Item>
## A space of row vectors over GF(<M>p</M>), representing <M>Z^1</M>.
## The vectors are represented in dimension <M>a \cdot b</M> where <M>a</M>
## is the length of <C>generators</C> and <M>p^b</M> the size of <A>M</A>.
## </Item>
## <Mark><C>oneCoboundaries</C></Mark>
## <Item>
## A space of row vectors that represents <M>B^1</M>.
## </Item>
## <Mark><C>cocycleToList</C></Mark>
## <Item>
## is a function to convert a cocycle (a row vector in <C>oneCocycles</C>) to
## a corresponding list of elements of <A>M</A>.
## </Item>
## <Mark><C>listToCocycle</C></Mark>
## <Item>
## is a function to convert a list of elements of <A>M</A> to a cocycle.
## </Item>
## <Mark><C>isSplitExtension</C></Mark>
## <Item>
## indicates whether <A>G</A> splits over <A>M</A>.
## The following components are only bound if the extension splits.
## Note that if <A>M</A> is given by a modulo pcgs all subgroups are given
## as subgroups of <A>G</A> by generators corresponding to <C>generators</C>
## and thus may not contain the denominator of the modulo pcgs.
## In this case taking the closure with this denominator will give the full
## preimage of the complement in the factor group.
## </Item>
## <Mark><C>complement</C></Mark>
## <Item>
## One complement to <A>M</A> in <A>G</A>.
## </Item>
## <Mark><C>cocycleToComplement( cyc )</C></Mark>
## <Item>
## is a function that takes a cocycle from <C>oneCocycles</C> and returns
## the corresponding complement to <A>M</A> in <A>G</A>
## (with respect to the fixed complement <C>complement</C>).
## </Item>
## <Mark><C>complementToCocycle(<A>U</A>)</C></Mark>
## <Item>
## is a function that takes a complement and returns the corresponding
## cocycle.
## </Item>
## </List>
## <P/>
## If the factor <A>G</A>/<A>M</A> is given by a (modulo) pcgs <A>gens</A>
## then special methods are used that compute a presentation for the factor
## implicitly from the pcgs.
## <P/>
## Note that the groups of 1-cocycles and 1-coboundaries are not groups in
## the sense of <Ref Func="Group" Label="for several generators"/> for &GAP;
## but vector spaces.
## <P/>
## <Example><![CDATA[
## gap> g:=Group((1,2,3,4),(1,2));;
## gap> n:=Group((1,2)(3,4),(1,3)(2,4));;
## gap> oc:=OneCocycles(g,n);
## rec( cocycleToComplement := function( c ) ... end,
## cocycleToList := function( c ) ... end,
## complement := Group([ (3,4), (2,4,3) ]),
## complementGens := [ (3,4), (2,4,3) ],
## complementToCocycle := function( K ) ... end,
## factorGens := [ (3,4), (2,4,3) ], generators := [ (3,4), (2,4,3) ],
## isSplitExtension := true, listToCocycle := function( L ) ... end,
## oneCoboundaries := <vector space over GF(2), with 2 generators>,
## oneCocycles := <vector space over GF(2), with 2 generators> )
## gap> oc.cocycleToList([ 0*Z(2), Z(2)^0, 0*Z(2), Z(2)^0 ]);
## [ (1,2)(3,4), (1,2)(3,4) ]
## gap> oc.listToCocycle([(),(1,3)(2,4)]) = Z(2) * [ 0, 0, 1, 0];
## true
## gap> oc.cocycleToComplement([ 0*Z(2), 0*Z(2), Z(2)^0, 0*Z(2) ]);
## Group([ (3,4), (1,3,4) ])
## gap> oc.complementToCocycle(Group((1,2,4),(1,4))) = Z(2) * [ 0, 1, 1, 1 ];
## true
## ]]></Example>
## <P/>
## The factor group
## <M>H^1(<A>G</A>/<A>M</A>, <A>M</A>) =
## Z^1(<A>G</A>/<A>M</A>, <A>M</A>) / B^1(<A>G</A>/<A>M</A>, <A>M</A>)</M>
## is called the first cohomology group.
## Currently there is no function which explicitly computes this group.
## The easiest way to represent it is as a vector space complement to
## <M>B^1</M> in <M>Z^1</M>.
## <P/>
## If the only purpose of the calculation of <M>H^1</M> is the determination
## of complements it might be desirable to stop calculations
## once it is known that the extension cannot split.
## This can be achieved via the more technical function
## <Ref Func="OCOneCocycles"/>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "OneCoboundaries" );
#############################################################################
##
#O OneCocycles( <G>, <M> )
#O OneCocycles( <gens>, <M> )
#O OneCocycles( <G>, <mpcgs> )
#O OneCocycles( <gens>, <mpcgs> )
##
## <#GAPDoc Label="OneCocycles">
## <ManSection>
## <Heading>OneCocycles</Heading>
## <Func Name="OneCocycles" Arg='G, M' Label="for two groups"/>
## <Func Name="OneCocycles" Arg='G, mpcgs' Label="for a group and a pcgs"/>
## <Func Name="OneCocycles" Arg='gens, M'
## Label="for generators and a group"/>
## <Func Name="OneCocycles" Arg='gens, mpcgs'
## Label="for generators and a pcgs"/>
##
## <Description>
## Computes the group of 1-cocycles <M>Z^1(<A>G</A>/<A>M</A>,<A>M</A>)</M>.
## The normal subgroup <A>M</A> may be given by a (Modulo)Pcgs <A>mpcgs</A>.
## In this case the whole calculation is performed modulo the normal
## subgroup defined by <C>DenominatorOfModuloPcgs(<A>mpcgs</A>)</C>
## (see <Ref Sect="Polycyclic Generating Systems"/>).
## Similarly the group <A>G</A> may instead be specified by a set of
## elements <A>gens</A> that are representatives for a generating system for
## the factor group <A>G</A>/<A>M</A>.
## If this is done the 1-cocycles are computed
## with respect to these generators (otherwise the routines try to select
## suitable generators themselves).
## The current version of the code assumes that <A>G</A> is a permutation
## group or a pc group.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction( "OneCocycles" );
#############################################################################
##
#O OCOneCoboundaries( <ocr> ) . . . . . . . . . . one cobounds main routine
##
## <ManSection>
## <Oper Name="OCOneCoboundaries" Arg='ocr'/>
##
## <Description>
## </Description>
## </ManSection>
##
DeclareGlobalFunction("OCOneCoboundaries");
#############################################################################
##
#O OCConjugatingWord( <ocr>, <c1>, <c2> ) . . . . . . . . . . . . . . local
##
## <ManSection>
## <Oper Name="OCConjugatingWord" Arg='ocr, c1, c2'/>
##
## <Description>
## Compute a Word n in <A>ocr.module</A> such that <A>c1</A> ^ n = <A>c2</A>.
## </Description>
## </ManSection>
##
DeclareGlobalFunction("OCConjugatingWord");
#############################################################################
##
#O OCEquationMatrix( <ocr>, <r>, <n> ) . . . . . . . . . . . . . . . local
##
## <ManSection>
## <Oper Name="OCEquationMatrix" Arg='ocr, r, n'/>
##
## <Description>
## </Description>
## </ManSection>
##
DeclareGlobalFunction("OCEquationMatrix");
#############################################################################
##
#O OCSmallEquationMatrix( <ocr>, <r>, <n> ) . . . . . . . . . . . . . local
##
## <ManSection>
## <Oper Name="OCSmallEquationMatrix" Arg='ocr, r, n'/>
##
## <Description>
## </Description>
## </ManSection>
##
DeclareGlobalFunction("OCSmallEquationMatrix");
#############################################################################
##
#O OCEquationVector( <ocr>, <r> ) . . . . . . . . . . . . . . . . . . local
##
## <ManSection>
## <Oper Name="OCEquationVector" Arg='ocr, r'/>
##
## <Description>
## </Description>
## </ManSection>
##
DeclareGlobalFunction("OCEquationVector");
#############################################################################
##
#O OCSmallEquationVector( <ocr>, <r> ) . . . . . . . . . . . . . . . . local
##
## <ManSection>
## <Oper Name="OCSmallEquationVector" Arg='ocr, r'/>
##
## <Description>
## </Description>
## </ManSection>
##
DeclareGlobalFunction("OCSmallEquationVector");
#############################################################################
##
#O OCAddComplement( <ocr>, <ocr.group>, <K> ) . . . . . . . . . . . . . local
##
## <ManSection>
## <Oper Name="OCAddComplement" Arg='ocr, ocr.group, K'/>
##
## <Description>
## </Description>
## </ManSection>
##
DeclareOperation("OCAddComplement",
[IsRecord,IsGroup,IsListOrCollection]);
#############################################################################
##
#O OCOneCocycles( <ocr>, <onlySplit> ) . . . . . . one cocycles main routine
##
## <#GAPDoc Label="OCOneCocycles">
## <ManSection>
## <Func Name="OCOneCocycles" Arg='ocr, onlySplit'/>
##
## <Description>
## is the more technical function to compute 1-cocycles. It takes a record
## <A>ocr</A> as first argument which must contain at least the components
## <C>group</C> for the group and <C>modulePcgs</C> for a (modulo) pcgs of
## the module. This record
## will also be returned with components as described under
## <Ref Func="OneCocycles" Label="for two groups"/>
## (with the exception of <C>isSplitExtension</C> which is indicated by the
## existence of a <C>complement</C>)
## but components such as <C>oneCoboundaries</C> will only be
## computed if not already present.
## <P/>
## If <A>onlySplit</A> is <K>true</K>,
## <Ref Func="OCOneCocycles"/> returns <K>false</K> as soon as
## possible if the extension does not split.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction("OCOneCocycles");
#############################################################################
##
#O ComplementClassesRepresentativesEA(<G>,<N>) . complement classes to el.ab. N by 1-Cohom.
##
## <#GAPDoc Label="ComplementClassesRepresentativesEA">
## <ManSection>
## <Func Name="ComplementClassesRepresentativesEA" Arg='G, N'/>
##
## <Description>
## computes complement classes to an elementary abelian normal subgroup
## <A>N</A> via 1-Cohomology. Normally, a user program should call
## <Ref Oper="ComplementClassesRepresentatives"/> instead, which also works
## for a solvable (not necessarily elementary abelian) <A>N</A>.
## </Description>
## </ManSection>
## <#/GAPDoc>
##
DeclareGlobalFunction("ComplementClassesRepresentativesEA");
#############################################################################
##
#o OCPPrimeSets( <U> ) . . . . . . . . . . . . . . . . . . . . . . . . local
##
## Construct a generating set, which has the generators of Hall-subgroups
## of a Sylow complement system as sublist.
##
#T DeclareGlobalFunction("OCPPrimeSets");
#T up to now no function is installed
[ Dauer der Verarbeitung: 0.38 Sekunden
(vorverarbeitet)
]
|
