############################################################################# ## ## This file is part of GAP, a system for computational discrete algebra. ## This file's authors include Heiko Theißen. ## ## 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 ##
DeclareInfoClass("nfoAction")
eclareInfoClass("");
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
############################################################################# ## #C IsExternalSet(<obj>) ## ## <#GAPDoc Label="IsExternalSet"> ## <ManSection> ## <Filt Name="IsExternalSet" Arg='obj' Type='Category'/> ## ## <Description> ## An <E>external set</E> specifies a group action ## <M>\mu: \Omega \times G \mapsto \Omega</M> of a group <M>G</M> ## on a domain <M>\Omega</M>. The external set knows the group, ## the domain and the actual acting function. ## Mathematically, an external set is the set <M>\Omega</M>, ## which is endowed with the action of a group <M>G</M> via the group action ## <M>\mu</M>. ## For this reason &GAP; treats an external set as a domain whose elements ## are the elements of <M>\Omega</M>. ## An external set is always a union of orbits. ## Currently the domain <M>\Omega</M> must always be finite. ## If <M>\Omega</M> is not a list, ## an enumerator for <M>\Omega</M> is automatically chosen, ## see <Ref Attr="Enumerator"/>. ## </Description> ## </ManSection> ## <#/GAPDoc> ##
,
############################################################################# ## #R IsExternalSubset(<obj>) ## ## <#GAPDoc Label="IsExternalSubset"> ## <ManSection> ## <Filt Name="IsExternalSubset" Arg='obj' Type='Representation'/> ## ## <Description> ## An external subset is the restriction of an external set to a subset ## of the domain (which must be invariant under the action). It is again an ## external set. ## </Description> ## </ManSection> ## <#/GAPDoc> ##
DeclareRepresentation( "IsExternalSubset",
IsComponentObjectRep and IsAttributeStoringRep and IsExternalSet,
["tart"];
############################################################################# ## #R IsExternalOrbit(<obj>) ## ## <#GAPDoc Label="IsExternalOrbit"> ## <ManSection> ## <Filt Name="IsExternalOrbit" Arg='obj' Type='Representation'/> ## ## <Description> ## An external orbit is an external subset consisting of one orbit. ## </Description> ## </ManSection> ## <#/GAPDoc> ##
DeclareRepresentation( "IsExternalOrbit" IsExternalSubset ["tart"])
,["" ;
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 0
############################################################################# ## #R IsExternalSetDefaultRep(<obj>) #R IsExternalSetByActorsRep(<obj>) ## ## <ManSection> ## <Filt Name="IsExternalSetDefaultRep" Arg='obj' Type='Representation'/> ## <Filt Name="IsExternalSetByActorsRep" Arg='obj' Type='Representation'/> ## ## <Description> ## External sets can be specified directly (<C>IsExternalSetDefaultRep</C>), or ## via <A>gens</A> and <A>acts</A> (<C>IsExternalSetByActorsRep</C>). ## </Description> ## </ManSection> ##
[ ]] )
DeclareRepresentation("sExternalSetByActorsRep",
[ java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
DeclareRepresentation( "IsExternalSetByActorsRepDeclareSynonym("sExternalSetByOperatorsRep,);
IsAttributeStoringRep and ,
[ "generators
DeclareSynonym"sExternalSetByOperatorsRep");
#
##<GAPDoc =ActingDomain"
#
##<Attr Name=ActingDomainArg=xset'>
##
## <#GAPDoc Label="ActingDomain">
## <ManSectionjava.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
# Attr =" Arg=xset'>
##
## <Description>
## This attribute returns the group with java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 12
# definedjava.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
## </Description
####################################
##
##
DeclareAttribute( "ActingDomain", AHomeEnumeratorxset>)
########################### ManSectionjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
##
# HomeEnumerator( <set>)
#
##returnsan enumerator the action domain with which theexternal set
## <#<>set</> defined.
## <Attr Name="HomeEnumerator" Arg='xset'/>
##
## <Description>
## returns an enumerator of#< =Enumerator/>value of <><A,
##</A was defined.
# external subsets,this is ingeneral from
## <Ref Attr="#gap>ActingDomain(;
## Group( (,,) (,,)])
## Example>!CDATA[
###
# Group(1,,,(,,)]
## gap> FunctionAction(e)=OnRight;
# true
# gap>HomeEnumerator()java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
# [(,(,,) (2,,,(,)34) (1,,) (,,) 1,,)
## (1,3,4), (1
## ]#<GAPDoc>
# <Description>
#ManSection
## <DeclareRepresentation IsActionHomomorphism"
##IsGroupHomomorphism IsAttributeStoringRep and
DeclareAttribute("omeEnumerator )java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
java.lang.StringIndexOutOfBoundsException: Range [24, 21) out of bounds for length 46
IsGroupHomomorphism and IsAttributeStoringRep and
A ActionKernelExternalSet(<>)
DeclareRepresentation( " ManSection>
, [ ])
# <escription>
########################################## P>
###<- moment no exist issolelyusedto transfer->
# ( <>)
##
## <ManSection>
## <Attr Name=# <Description>
#java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
## <>
## This#####################################
# </java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
# <anSection>
# !- . ->
# <Description>
## </ManSection>
##
DeclareAttribute( "java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 17
###########<Description
#
# (<>java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
##
# <ManSection>
## # IsConstituentHomomorphism(obj>
##
## >
##< Name""'bj Type=Representation/>
## </java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 2
# <ManSectionjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
##
IsActionHomomorphism conperm);
DeclareRepresentation( "IsBlocksHomomorphism",
###################IsActionHomomorphism,[r"])
##
####################################java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
##
# <anSection>
## <Filt Name="IsConstituentHomomorphism" Arg#<ilt="sLinearActionHomomorphism"Arg='om'Type='epresentation>
##
## <Description#
## </Description>
# <escription>
#
## groups acting naturally a ofvectors.
sActionHomomorphism" ])java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
############################################################################# ## #A LinearActionBasis(<hom>) ## ## <ManSection> ## <Attr Name="LinearActionBasis" Arg='hom'/> ## ## <Description> ## for action homomorphisms in the representation ## <C>IsLinearActionHomomorphism</C> or ## <C>IsProjectiveActionHomomorphism</C>, ## this attribute contains a vector space ## basis as subset of the domain or <K>fail</K> if the domain does not span the ## vector space that the group acts on. ## groups acting naturally on a set of vectors. ## </Description> ## </ManSection> ##
DeclareAttribute( "LinearActionBasis",java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
############################################################################# ## #A FunctionAction( <xset> ) ## ## <#GAPDoc Label="FunctionAction"> ## <ManSection> ## <Attr Name="FunctionAction" Arg='xset'/> ## ## <Description> ## is the acting function with which the external set <A>xset</A> was ## defined. ## </Description> ## </ManSection> ## <#/GAPDoc> ##
DeclareAttribute## <ManSection>
############################################################################# ## #A StabilizerOfExternalSet( <xset> ) . stabilizer of `Representative(xset)' ## ## <#GAPDoc Label="StabilizerOfExternalSet"> ## <ManSection> ## <Attr Name="StabilizerOfExternalSet" Arg='xset'/> ## ## <Description> ## computes the stabilizer of the <Ref Attr="Representative"/> value of ## the external set <A>xset</A>. ## The stabilizer will have the acting group of <A>xset</A> as its parent. ## <Example><![CDATA[ ## gap> Representative(e); ## (1,2,3) ## gap> StabilizerOfExternalSet(e); ## Group([ (1,2,3) ]) ## ]]></Example> ## </Description> ## </ManSection> ## <#/GAPDoc> ##
## </ManSection>## <#/GAPDoc>
############################################################################# ## #A CanonicalRepresentativeOfExternalSet( <xset> ) ## ## <#GAPDoc Label="CanonicalRepresentativeOfExternalSet"> ## <ManSection> ## <Attr Name="CanonicalRepresentativeOfExternalSet" Arg='xset'/> ## ## <Description> ## The canonical representative of an external set <A>xset</A> may only ## depend on the defining attributes <A>G</A>, <A>Omega</A>, <A>act</A> ## of <A>xset</A> and (in the case of external subsets) ## <C>Enumerator( <A>xset</A> )</C>. ## It must <E>not</E> depend, e.g., on the representative of an external ## orbit. ## &GAP; does not know methods for arbitrary external sets to compute a ## canonical representative, ## see <Ref Attr="CanonicalRepresentativeDeterminatorOfExternalSet"/>. ## </Description> ## </ManSection> ## <#/GAPDoc> ##
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
############################################################################# ## #A CanonicalRepresentativeDeterminatorOfExternalSet( <xset> ) ## ## <#GAPDoc Label="CanonicalRepresentativeDeterminatorOfExternalSet"> ## <ManSection> ## <Attr Name="CanonicalRepresentativeDeterminatorOfExternalSet" Arg='xset'/> ## ## <Description> ## returns a function that takes as its arguments the acting group and a ## point. ## This function returns a list of length 1 or 3, ## the first entry being the canonical representative and the other entries ## (if bound) being the stabilizer of the canonical representative and a ## conjugating element, respectively. ## </ManSection> ## representative if it has a ## <Ref Attr="CanonicalRepresentativeDeterminatorOfExternalSet"/>. ## </Description> ## </ManSection> ## <#/GAPDoc> ##
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 2
IsExternalSet )#
############################################################################# ## #P CanEasilyDetermineCanonicalRepresentativeExternalSet( <xset> ) ## ## <ManSection> ## <Prop Name="CanEasilyDetermineCanonicalRepresentativeExternalSet" Arg='xset'/> ## ## <Description> ## This property indicates whether an external set knows or has a ## possibility to determine a canonical representative ## </Description> HasCanonicalRepresentativeDeterminatorOfExternalSet); ##
DeclareProperty(""
IsExternalSet );
InstallTrueMethod(java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 2
## <Attr Name="ActorOfExternalSet" Arg='xset'/>
InstallTrueMethod(CanEasilyDetermineCanonicalRepresentativeExternalSet,
HasCanonicalRepresentativeOfExternalSet);
############################################################################# ## #A ActorOfExternalSet( <xset> ) ## ## <#GAPDoc Label="ActorOfExternalSet"> ## <ManSection> ## <Attr Name="ActorOfExternalSet" Arg='xset'/> ## ## <Description> ## returns an element mapping <C>Representative(<A>xset</A>)</C> to ## <C>CanonicalRepresentativeOfExternalSet(<A>xset</A>)</C> under the given ## action. ## <Example><![CDATA[ DeclareSynonymAttr( "OperatorOfExternalSet", ActorOfExternalSet ); ## gap> e:=RightCoset(u,(1,2)(3,4));; ## gap> CanonicalRepresentativeOfExternalSet(e); ## (2,4,3) ## gap> ActorOfExternalSet(e); ## (1,3,2) ## gap> FunctionAction(e)((1,2)(3,4),last); ## (2,4,3) ## ]]></Example> ## </Description> ## </ManSection> ## <#/GAPDoc> ##
DeclareAttribute( "ActorOfExternalSet##
## tests whether the identity element java.lang.StringIndexOutOfBoundsException: Range [0, 44) out of bounds for length 31
############################################################################# ## #F TestIdentityAction(acts,pnt,act) ## ## <ManSection> ## <Func Name="TestIdentityAction" Arg='acts,pnt,act'/> ## ## <Description> ## tests whether the identity element fixes <A>pnt</A> ## –if not the action is ## not well-defined. If the global option <C>NoTestAction</C> is set to <K>true</K> ## this test is skipped. (This is essentially a hack.) ## </Description> ## </ManSection> ##
BindGlobalError(Action not well-efined.See the manualsectionn"
local ,java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13 if ValueOption(NoTestAction"< and (cts)0java.lang.StringIndexOutOfBoundsException: Range [62, 63) out of bounds for length 62
id:=One
img:=act(pnt,id); if img##
Error(## <ManSection> "``Action on## fi;
pnt:=img; fi;
return pnt; end);
############################################################################# ## #F OrbitsishOperation( <name>, <reqs>, <usetype>, <AorP> ) . orbits-like op. ## ## <#GAPDoc Label="OrbitsishOperation"> ## <ManSection> ## <Func Name="OrbitsishOperation" Arg='name, reqs, usetype, AorP'/> ## ## <Description> ## declares an attribute <C>op</C>, with name <A>name</A>. ## The second argument <A>reqs</A> specifies the list of required filters ## for the usual (five-argument) methods that do the real work. ## <P/> ## If the third argument <A>usetype</A> is <K>true</K>, ## the function call <C>op( xset )</C> will ## –if the value of <C>op</C> for <C>xset</C> is not yet known– ## delegate to the five-argument call of <C>op</C> with second argument ## <C>xset</C> rather than with <C>D</C>. ## This allows certain methods for <C>op</C> to make use of the type of ## <C>xset</C>, in which the types of the external subsets of <C>xset</C> ## and of the external orbits in <C>xset</C> are stored. ## (This is used to avoid repeated calls of ## <Ref Func="NewType"/> in functions like ## <C>ExternalOrbits( xset )</C>, ## which call <C>ExternalOrbit( xset, pnt )</C> for several values of ## <C>pnt</C>.) ## <P/> ## For property testing functions such as ## <Ref Oper="IsTransitive" Label="for a group, an action domain, etc."/>, ## the fourth argument <A>AorP</A> must be ## <Ref Func="NewProperty"/>, ## otherwise it must be <Ref Func="NewAttribute"/>; ## in the former case, a property is returned, in the latter case an ## attribute that is not a property. ## <P/> ## For example, to set up the operation <Ref Oper="Orbits" Label="operation"/>, ## the declaration file <F>lib/oprt.gd</F> contains the following line of ## code: ## <Log><![CDATA[ ## OrbitsishOperation( "Orbits", OrbitsishReq, false, NewAttribute ); ## ]]></Log> ## The global variable <C>OrbitsishReq</C> contains the standard ## requirements ## <Log><![CDATA[ ## OrbitsishReq := [ IsGroup, IsList, ## IsList, ## IsList, ## IsFunction ]; ## ]]></Log> ## which are usually entered in calls to <Ref Func="OrbitsishOperation"/>. ## <P/> ## The new operation, e.g., <Ref Oper="Orbits" Label="operation"/>, ## can be called either as <C>Orbits( <A>xset</A> )</C> for an external set ## <A>xset</A>, or as <C>Orbits( <A>G</A> )</C> for a permutation group ## <P/> ## points of <A>G</A> via <Ref Func="OnPoints"/>, ## or as ## <P/> ## <C>Orbits( <A>G</A>, <A>Omega</A>[, <A>gens</A>, <A>acts</A>][, ## <A>act</A>] )</C>, ## <P/> ## with a group <A>G</A>, a domain or list <A>Omega</A>, ## generators <A>gens</A> of <A>G</A>, and corresponding elements ## <A>acts</A> that act on <A>Omega</A> via the function <A>act</A>; ## the default of <A>gens</A> and <A>acts</A> is a list of group generators ## of <A>G</A>, ## the default of <A>act</A> is <Ref Func="OnPoints"/>. ## <P/> ## Only methods for the five-argument version need to be installed for ## doing the real work. ## (And of course methods for one argument in case one wants to define ## a new meaning of the attribute.) ## </Description> ## </ManSection> ## <#/GAPDoc> ##
BindGlobal(DeclareOperationname )
local op;
# Create the attribute or property.
op: NewAorP(name,IsExternalSet )
BIND_GLOBAL(name )
BIND_SETTER_TESTER InstallMethod(op,
# Make declarationfornondefault.
DeclareOperation,
# Install the default methods.
# 1. `op( <xset> )' # (The `usetype' value concerns only the `return' statement.) if usetype then
InstallMethod opjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24 "for gens : !generatorsjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
truejava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
[IsExternalSet,0, function( xset )
local G, gens, acts
: ActingDomainxset ) ifIsExternalSetByActorsRep(xset) then
acts : ;
acts: xset!operators
act : ; else if CanEasilyComputePcgs( G ) then
else
"for an set,
;
[IsExternalSet ],0,
ionAction(xset) filocal G,gens,,act;
return op(G,xset gens, ,act )
( then
else
InstallMethod( op, "for an external set",
true,
], 0,
( )
local
G gens : GeneratorsOfGroup(G)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
( xset )
= xset!g;
acts: xset.operators;
act := xset!.funcOperation;
e if CanEasilyComputePcgs
gens : (G)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
InstallOtherMethod( op #java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67 " a permutation group"
true,
[ IsPermGroup ], ,IsObject ,0,
local gens ocal gens;
gens( G )
return: Pcgs(G ) end );
> ) <> domain <mega # (add group generators and `OnPoints' as default arguments)fijava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
"for a group and a java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 11
true,
IsGroup,IsObject ] ,
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
local gens; # of integers
gens: Pcgs(G) else
"for agroup and a domain or list "
[IsPermGroup, IsListOrCollection ]0, if IsDomain( D ) then if (D )then D= AsSSortedList(D ; else :=Enumerator(D) ; fi;
, gens OnPoints ) end );
# 4. `op( <G>, <Omega> )' with permutation group <G> and domain or list # <Omega> # of integers # (if <Omega> equals the moved points of <G> then call `op( <G> )')# 5. `op( <G>, <Omega>, <act> )' with group <G>, domain or list <Omega>,
(op, "for a permutation group and a domain or list of for agroup,a domain ,and function,
true,
[ IsPermGroup, IsListOrCollection ], function(G,D,act java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29 function( G, D ) if D = MovedPoints( G ) then
return op( G ); elsegens: (G ;
TryNextMethod(); fi; end );
# 5. `op( <G>, <Omega>, <act> )' with group <G>, domain or list <Omega>, # and function <act> # (add group generators as default arguments)
InstallOtherMethod( op, "for a groupreturn ( G,D,gens,gens, )
true, # 6. `op( <G>, <Omega>, <act> )' with permutation group <G>, function( G, D, act )
local gens; ifCanEasilyComputePcgs(G )then
gens=Pcgs(G ; else
: GeneratorsOfGroup G ; fi , ifIsDomain(D)then if java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 29 fi
return op( G,( ; end
6. `op( <G>, <Omega>, <act> )' with permutation group <G>, # domain or list <Omega> of integers, and function <act> # (if <Omega> equals the moved points of <G> and <act> equals `OnPoints' # (add default value `OnPoints')
(op, "for permutation group, domain or list of integers, and function",
true,
,IsListOrCollection,IsFunction ] 0,
[IsGroup,IsObject,IsList ,0, ifD = MovedPoints(G )and ( act,OnPoints )
return op( G if (D
se
TryNextMethod
(G,D,gens,acts,OnPoints)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48 end#java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
# 7. `op( <G>, <Omega>, <gens>, <acts> )' with group <G>, # domain or list <Omega>, and two lists <gens>, <acts>
InstallOtherMethod(op,
InstallOtherMethod op, "for a group, a domain or list, and two lists",
,
[ IsGroup, IsObject, IsList, IsList ], 0, function( G, D, gens, acts return ( G,Enumerator(D ) ,acts,act ; if IsDomain( D ) then if IsFinite( java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0 fi;
return op( G, D## end );
# 8. `op( <G>, <Omega>, <gens>, <acts>, <act> )' with group <G>,
## is used to create operations like <Ref Oper="Orbit"/>. ## This function is analogous to <Ref Func="OrbitsishOperation"/>,
InstallOtherMethod( op, "for a group, a domain, two lists, and a function## Since the return values of these operations depend on the additional
true,
[ IsGroup, IsDomain, IsList, IsList, IsFunction ## operation, with names <A>name</A> and <A>name</A><C>Op</C>. function( G, D, gens, acts, act )
return op## <P/> end ); end );
############################################################################# ## #F OrbitishFO( <name>, <reqs>, <famrel>, <usetype>, <realenum> ) ## ## <#GAPDoc Label="OrbitishFO"> ## <ManSection> ## <Func Name="OrbitishFO" Arg='name, reqs, famrel, usetype, realenum'/> ## ## <Description> ## is used to create operations like <Ref Oper="Orbit"/>. ## This function is analogous to <Ref Func="OrbitsishOperation"/>, ## but for operations <A>orbish</A> like ## <C>Orbit( <A>G</A>, <A>Omega</A>, <A>pnt</A> )</C>. ## Since the return values of these operations depend on the additional ## argument <A>pnt</A>, there is no associated attribute. ## <P/> ## The call of <Ref Func="OrbitishFO"/> declares a wrapper function and its ## operation, with names <A>name</A> and <A>name</A><C>Op</C>. ## <P/> ## The second argument <A>reqs</A> specifies the list of required filters ## for the operation <A>name</A><C>Op</C>. ## <P/> ## The third argument <A>famrel</A> is used to test the family relation ## between the second and third argument of ## <C><A>name</A>( <A>G</A>, <A>D</A>, <A>pnt</A> )</C>. ## For example, <A>famrel</A> is <C>IsCollsElms</C> in the case of ## <Ref Oper="Orbit"/> because <A>pnt</A> must be an element ## of <A>D</A>. ## Similarly, in the call <C>Blocks( <A>G</A>, <A>D</A>, <A>seed</A> )</C>, ## <A>seed</A> must be a subset of <A>D</A>, ## and the family relation must be ## <Ref Func="IsIdenticalObj"/>. ## <P/> ## The fourth argument <A>usetype</A> serves the same purpose as in the case ## of <Ref Func="OrbitsishOperation"/>. ## <A>usetype</A> can also be an attribute, such as ## <C>BlocksAttr</C> or <C>MaximalBlocksAttr</C>. ## In this case, if only one of the two arguments <A>Omega</A> and ## <A>pnt</A> is given, ## blocks with no seed are computed, they are stored as attribute values ## according to the rules of <Ref Func="OrbitsishOperation"/>. ## <P/> ## If the 5th argument is set to <K>true</K>, the action for an external set ## should use the enumerator, otherwise it uses the ## <Ref Attr="HomeEnumerator"/> value. This will ## make a difference for external orbits as part of a larger domain. ## </Description> ## </ManSection> ## <#/GAPDoc> ##
BindGlobal( "java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
ocal, orbish,func,snotest
# Create the operation.
str: (arg)1
isnotest:=Length(name)>5 and pnt : Immutable([ )java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
pnt:java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
G := Actin(xset )
orbish: (str reqs)
BIND_GLOBAL :Enumeratorxset;
: xset.; if le = 0then
Error( usage );
<=2 and IsExternalSet( rg[1])then
:=arg[1 ] if Length(arg)> : FunctionAction xset) # force immutability
pnt :G=arg[1]java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21 else
pnt:=[]; fi;
G := ActingDomain( ifrealenumthen
D:Enumeratorxset) else if HasHomeEnumerator( xset ) then
D := HomeEnumerator( xset ); pnt:Immutable arg2 ; fi; fi; if IsExternalSetByActorsRep( xset ) then 2;
acts: !operators
act (IsList(pnt IsEmpty(pnt)
act IsDomain( D then fi; elif2 <= le and le <= 6then
G=arg[1 ; if IsFunction( arg[ le ] ) then
act D: Enumerator(D)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
: le-java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20 else
act:= OnPoints;
; # now we have one of the following:: [ ; # le = 2: G, pnt[, act] # le = 3: G, Omega, pnt[, act] # le = 4: G, pnt, gens, acts[, act] # le = 5: G, Omega, pnt, gens, acts[, act]
java.lang.StringIndexOutOfBoundsException: Range [6, 1) out of bounds for length 9
pnt: if (not IsPermGroup() and(G)then
pnt:= Immutableelse # deal with Omega
D=arg[] if not acts =gens;
IsList(pnt ) and IsEmpty(pnt )then
Error( "wrong notisnotest then elif IsDomain( D ) then if IsFinite( D ) then
D:= AsSSortedList( D ); else
D= ( ) fi# acting on its moved points, use an attribute for $G$. fi; fi; if le and gens=acts # deal with acts, gens
gens:= arg[ le - 1 ];
acts:= arg[ le ]; fi; else
Error( usage ); fi;
elifandTester( usetype )(G)then if(not IsPermGroup() and CanEasilyComputePcgs(G ) then elif usetype=true java.lang.StringIndexOutOfBoundsException: Range [41, 39) out of bounds for length 53
gens := java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 29 fi;
acts := gens; fijava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
then # `Blocks' has <pnt> a list of points
pnt:=TestIdentityAction(acts,pnt,act); fi;
# In the case of `[Maximal]Blocks', where $G$ is a permutation group # acting on its moved points, use an attribute for $G$.
and gens = acts
(usetype ) )
returnresultjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
andend )
java.lang.StringIndexOutOfBoundsException: Range [0, 8) out of bounds for length 0
result := #O ActionHomomorphism(<G>,<Omega> [,<gens>,<acts>] [,<act>] [,#A ActionHomomorphism( <xset> [,"surjective"#A ActionHomomorphism( <action> ) elif attrG and Tester( usetype
result := usetype( G ); elif usetype## <Func Name="ActionHomomorphism" Arg='xset[, "surjective"]'
result := orbish( G, ## <Func Name="ActionHomomorphism" Arg='action' elif IsBound(##
result :# computes a homomorphism from <A>G</A> into the symmetric group on else
# The following line is also executed when `Blocks(<G>, <Omega>, <act>)'
## is given by the positions of points in <A>Omega</A>.) # <Omega>, i.e., the operation domain!
result := orbish( G, pnt, gens,## <P/>
fi;
# Store the result in the case of an attribute `[Maximal]BlocksAttr'.
## symmetric group) to avoid unnecessary computation of the image. if IsBound( xset ) then
Setter( usetype )( xset, result ); fi;
Setter( usetype )( G, result ); fi;
## <P/> end;
## <Example><![CDATA[ end );
############################################################################# ## #O ActionHomomorphism(<G>,<Omega> [,<gens>,<acts>] [,<act>] [,"surjective"]) #A ActionHomomorphism( <xset> [,"surjective"] ) #A ActionHomomorphism( <action> ) ## ## <#GAPDoc Label="ActionHomomorphism"> ## <ManSection> ## <Heading>ActionHomomorphism</Heading> ## <Func Name="ActionHomomorphism" ## Arg='G, Omega[, gens, acts][, act][, "surjective"]' ## Label="for a group, an action domain, etc."/> ## <Func Name="ActionHomomorphism" Arg='xset[, "surjective"]' ## Label="for an external set"/> ## <Func Name="ActionHomomorphism" Arg='action' ## Label="for an action image"/> ## ## <Description> ## computes a homomorphism from <A>G</A> into the symmetric group on ## <M>|<A>Omega</A>|</M> points that gives the permutation action of ## <A>G</A> on <A>Omega</A>. (In particular, this homomorphism is a ## permutation equivalence, that is the permutation image of a group element ## is given by the positions of points in <A>Omega</A>.) ## <P/> ## The result is undefined if <A>G</A> does not act on <A>Omega</A>. ## <P/> ## By default the homomorphism returned by ## <Ref Func="ActionHomomorphism" Label="for a group, an action domain, etc."/> ## is not necessarily surjective (its ## <Ref Attr="Range" Label="of a general mapping"/> value is the full ## symmetric group) to avoid unnecessary computation of the image. ## If the optional string argument <C>"surjective"</C> is given, ## a surjective homomorphism is created. ## <P/> ## The third version (which is supported only for &GAP;3 compatibility) ## returns the action homomorphism that belongs to the image obtained via ## <Ref Func="Action" Label="for a group, an action domain, etc."/>. ## <P/> ## (See Section <Ref Sect="Basic Actions"/> ## for information about specific actions.) ## <P/> ## <Example><![CDATA[ ## gap> g:=Group((1,2,3),(1,2));; ## gap> hom:=ActionHomomorphism(g,Arrangements([1..4],3),OnTuples); ## <action homomorphism> ## gap> Image(hom); ## Group( ## [ (1,9,13)(2,10,14)(3,7,15)(4,8,16)(5,12,17)(6,11,18)(19,22,23)(20,21, ## 24), (1,7)(2,8)(3,9)(4,10)(5,11)(6,12)(13,15)(14,16)(17,18)(19, ## 21)(20,22)(23,24) ]) ## gap> Size(Range(hom));Size(Image(hom)); ## 620448401733239439360000 ## 6 ## gap> hom:=ActionHomomorphism(g,Arrangements([1..4],3),OnTuples, ## > "surjective");; ## gap> Size(Range(hom)); ## 6 ## ]]></Example> ## <P/> ## When acting on a domain, the operation <Ref Oper="PositionCanonical"/> ## is used to determine the position of elements in the domain. ## This can be used to act on a domain given by a list of representatives ## for which <Ref Oper="PositionCanonical"/> is implemented, ## for example the return value of <Ref Oper="RightTransversal"/>. ## </Description> ## </ManSection> ## <#/GAPDoc> ##
DeclareGlobalFunction( "ActionHomomorphism" );
DeclareAttribute( "ActionHomomorphismAttr", IsExternalSet );
## </ManSection>
DeclareAttribute( "UnderlyingExternalSet", IsActionHomomorphism ); ## #A SurjectiveActionHomomorphismAttr( <xset> ) ## ## <#GAPDoc Label="SurjectiveActionHomomorphismAttr"> ## <ManSection> ## <Attr Name="SurjectiveActionHomomorphismAttr" Arg='xset'/> ## ## <Description> ## returns an action homomorphism for the external set <A>xset</A> ## which is surjective. ## (As the <Ref Func="Image" Label="set of images of the source of a general mapping"/> ## value of this homomorphism has to be computed ## to obtain the range, this may take substantially longer ## than <Ref Func="ActionHomomorphism" Label="for an external set"/>.) ## </Description> ## </ManSection> ## <#/GAPDoc> ##
DeclareAttribute(## will be sorted.
############################################################################# ## #F DoSparseActionHomomorphism(<G>,<start>,<gens>,<acts>,<act>,<phash>,<sort>) ## ## <ManSection> ## <Func Name="DoSparseActionHomomorphism" ## Arg='G, start, gens, acts, act, phash, sort'/> ## ## <Description> ## is the function implementing the sparse action homomorphisms and syntax ## is as for these. ## <A>phash</A> must be an injective (&GAP;)-function, for ## example a perfect hash, element comparisons are done in its range. ## Unless a fast enumeration is known, <C>IdFunc</C> should be used. ## If <A>sort</A> is true, the action domain for the resulting homomorphism ## will be sorted. ## </Description> ## </ManSection> ##
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
############################################################################# ## #O SparseActionHomomorphism( <G>, <start> [,<gens>,<acts>] [,<act>] ) #O SortedSparseActionHomomorphism(<G>,<start>[,<gens>,<acts>] [,<act>]) ## ## <#GAPDoc Label="SparseActionHomomorphism"> ## <ManSection> ## <Oper Name="SparseActionHomomorphism" ## Arg='G, start[, gens, acts][, act]'/> ## <Oper Name="SortedSparseActionHomomorphism" ## Arg='G, start[, gens, acts][, act]'/> ## ## <Description> ## <Ref Oper="SparseActionHomomorphism"/> computes the action homomorphism ## (see <Ref Func="ActionHomomorphism" Label="for a group, an action domain, etc."/>) ## with arguments <A>G</A>, <M>D</M>, and the optional arguments given, ## where <M>D</M> is the union of the <A>G</A>-orbits of all points in ## <A>start</A>. ## In the <Ref Oper="Orbit"/> calls that are used to create <M>D</M>, ## again the optional arguments given are entered.) ## <P/> ## If <A>G</A> acts on a very large domain not surjectively ## this may yield a permutation image of ## substantially smaller degree than by action on the whole domain. ## <P/> ## The operation <Ref Oper="SparseActionHomomorphism"/> will only use ## <Ref Oper="\="/> comparisons of points in the orbit. ## Therefore it can be used even if no good <Ref Oper="\<"/> ## comparison method for these points is available. ## However the image group will depend on the ## generators <A>gens</A> of <A>G</A>. ## <P/> ## The operation <Ref Oper="SortedSparseActionHomomorphism"/> in contrast ## will sort the orbit and thus produce an image group which does not ## depend on these generators. ## <P/> ## <Example><![CDATA[ ## gap> h:=Group(Z(3)*[[[1,1],[0,1]]]); ## Group([ [ [ Z(3), Z(3) ], [ 0*Z(3), Z(3) ] ] ]) ## gap> hom:=ActionHomomorphism(h,GF(3)^2,OnRight);; ## gap> Image(hom); ## Group([ (2,3)(4,9,6,7,5,8) ]) ## gap> hom:=SparseActionHomomorphism(h,[Z(3)*[1,0]],OnRight);; ## gap> Image(hom); ## Group([ (1,2,3,4,5,6) ]) ## ]]></Example> ## </Description> ## </ManSection> ## <#/GAPDoc> ##
BindGlobal( "SparseActHomFO", function( name, reqs, famrel )
local
# Create the operation.
str: SHALLOW_COPY_OBJ name)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
# Create the wrapper function.##
func := function## computes the image of <A>elm</A> under the action homomorphism <A>op</A> and is
local G, D, pnt, gens, acts, ## in some methods to bootstrap the range).
# Get the arguments.## if2 < Length
############################################################################# if IsFunction( arg[ le#O Action( <G>, <Omega> [<gens>,<acts>] [,<act>] )
act := arg[ le ## <#GAPDoc Label="Action"> else
## Label="for a group, an action domain, etc."/> fi; if Length( arg ) > 2
and famrel( FamilyObj( arg[## returns the image group of then
D := arg[ 2 ]; if IsDomain( D ) then if IsFinite( D ) then D:= AsSSortedList( D ); else D:= Enumerator( D## action homomorphism) this image group internally stores the action fi;
p := 3; else
p := 2; fi;
pnt := Immutable(arg[ p ]);
## <P/>
gens := arg[ p + 1## gap> g:=Group((1,2,3),(1,2));;
acts## Group([ (1,5,3)(2,6,4), (1,6)(2,5)(3,4) ]) fi; else
Error( "usage: ", name,## <#/GAPDoc> fiDeclareGlobalFunction(";
############################################################################# ## #O ImageElmActionHomomorphism( <op>,<elm> ) ## ## <ManSection> ## <Oper Name="ImageElmActionHomomorphism" Arg='op,elm'/> ## ## <Description> ## computes the image of <A>elm</A> under the action homomorphism <A>op</A> and is ## guaranteed to use the action (and not the <C>AsGHBI</C>, this is required ## in some methods to bootstrap the range). ## </Description> ## ##
## <Oper Name="RestrictedExternalSet" Arg='xset, U'##
############################################################################# ## #O Action( <G>, <Omega> [<gens>,<acts>] [,<act>] ) #A Action( <xset> ) ## ## <#GAPDoc Label="Action"> ## <ManSection> ## <Func Name="Action" Arg='G, Omega[, gens, acts][, act]' ## Label="for a group, an action domain, etc."/> ## <Func Name="Action" Arg='xset' ## Label="for an external set"/> ## ## <Description> ## returns the image group of ## <Ref Func="ActionHomomorphism" Label="for a group, an action domain, etc."/> ## called with the same parameters. ## <P/> ## Note that (for compatibility reasons to be able to get the ## action homomorphism) this image group internally stores the action ## homomorphism. ## If <A>G</A> or <A>Omega</A> are extremely big, this can cause memory ## problems. In this case compute only generator images and form the image ## group yourself. ## <P/> ## (See Section <Ref Sect="Basic Actions"/> ## for information about specific actions.) ## <P/> ## <Index>regular action</Index> ## The following code shows for example how to create the regular action of a ## group. ## <P/> ## <Example><![CDATA[ ## gap> g:=Group((1,2,3),(1,2));; ## gap> Action(g,AsList(g),OnRight); ## Group([ (1,5,3)(2,6,4), (1,6)(2,5)(3,4) ]) ## ]]></Example> ## </Description> ## </ManSection> ## <#/GAPDoc> ##
DeclareGlobalFunction( "Action" );
############################################################################# ## #O ExternalSet( <G>, <Omega>[, <gens>, <acts>][, <act>] ) ## ## <#GAPDoc Label="ExternalSet"> ## <ManSection> ## <Oper Name="ExternalSet" Arg='G, Omega[, gens, acts][, act]'/> ## ## <Description> ## creates the external set for the action <A>act</A> of <A>G</A> on <A>Omega</A>. ## <A>Omega</A> can be either a proper set, or a domain which is represented as ## described in <Ref Sect="Domains"/> and <Ref Chap="Collections"/>, or (to use ## less memory but with a slower performance) an enumerator ## (see <Ref Attr="Enumerator"/> ) of this domain. ## <P/> ## The result is undefined if <A>G</A> does not act on <A>Omega</A>. ## <Example><![CDATA[ ## under the action of the group <A>G</A> w.r.t. the action function ## gap> e:=ExternalSet(g,[1..4]); ## <xset:[ 1, 2, 3, 4 ]> ## gap> e:=ExternalSet(g,g,OnRight); ## <xset:[ (), (2,3,4), (2,4,3), (1,2)(3,4), (1,2,3), (1,2,4), (1,3,2), ## (1,3,4), (1,3)(2,4), (1,4,2), (1,4,3), (1,4)(2,3) ]> ## gap> Orbits(e); ## [ [ (), (1,2)(3,4), (1,3)(2,4), (1,4)(2,3), (2,4,3), (1,4,2), ## (1,2,3), (1,3,4), (2,3,4), (1,3,2), (1,4,3), (1,2,4) ] ] ## ]]></Example> ## ## </Description> ## </ManSection> ## <#/GAPDoc> ##
## [ [ 1, 2 ], [ 1, 3 ], [ 1, 4 ], [ 2, 3 ], [ 3, 4 ], [ 2, 4 ] ]
## ## <ManSection> ## <Oper Name="RestrictedExternalSet" Arg='xset, U'/> ## ## <Description> ## ## returns an external set for the same action which has the ## <C>ActingDomain</C> <A>U</A>. ## </Description> ## </ManSection> ##
DeclareOperation("## <Attr Name="Orbits" Arg='xset' Label="attribute"/>
############################################################################# ## #O ExternalSubset(<G>,<Omega>,<start>,[<gens>,<acts>,]<act>) ## ## <#GAPDoc Label="ExternalSubset"> ## <ManSection> ## <Oper Name="ExternalSubset" Arg='G,Omega,start,[gens,acts,]act'/> ## ## <Description> ## constructs the external subset of <A>Omega</A> on the union of orbits of ## the points in <A>start</A>. ## <P/> ## The result is undefined if <A>G</A> does not act on <A>Omega</A>. ## </Description> ## </ManSection> ## <#/GAPDoc> ##
OrbitishFO( "## the domain and the actual acting function.
[IsGroup,IsList,IsList,
IsList,
## </ManSection>##
IsFunction ], IsIdenticalObj, true, false );
############################################################################# ## ## <Heading>OrbitsDomain</Heading> ## ## <#GAPDoc Label="ExternalOrbit"> ## <ManSection> ## <Oper Name="ExternalOrbit" Arg='G, Omega, pnt, [gens,acts,] act'/> ## ## <Description> ## constructs the external subset on the orbit of <A>pnt</A>. The ## <Ref Attr="Representative"/> value of this external set is <A>pnt</A>. ## <P/> ## The result is undefined if <A>G</A> does not act on <A>Omega</A>. ## <Example><![CDATA[ ## gap> e:=ExternalOrbit(g,g,(1,2,3)); ## (1,2,3)^G ## ]]></Example> ## </Description> ## </ManSection> ## <#/GAPDoc> ##
[ "generators", "operators ])java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
############################################################################# ## #O Orbit( <G>[, <Omega>], <pnt>[, <gens>, <acts>][, <act>] ) ## ## <#GAPDoc Label="Orbit"> ## <ManSection> ## <Oper Name="Orbit" Arg='G[, Omega], pnt[, gens, acts][, act]'/> ## ## <Description> ## The orbit of the point <A>pnt</A> is the list of all images of <A>pnt</A> ## under the action of the group <A>G</A> w.r.t. the action function ## <A>act</A> or <Ref Func="OnPoints"/> if no action function is given. ## <P/> ## (Note that the arrangement of points in this list is not defined by the ## operation.) ## <P/> ## The orbit of <A>pnt</A> will always contain one element that is ## <E>equal</E> to <A>pnt</A>, however for performance reasons ## this element is not necessarily <E>identical</E> to <A>pnt</A>, ## in particular if <A>pnt</A> is mutable. ## <Example><![CDATA[ ## gap> g:=Group((1,3,2),(2,4,3));; ## gap> Orbit(g,1); ## [ 1, 3, 2, 4 ] ## gap> Orbit(g,[1,2],OnSets); ## [ [ 1, 2 ], [ 1, 3 ], [ 1, 4 ], [ 2, 3 ], [ 3, 4 ], [ 2, 4 ] ] ## ]]></Example> ## <P/> ## (See Section <Ref Sect="Basic Actions"/> ## for information about specific actions.) ## </Description> ## </ManSection> ## <#/GAPDoc> ##
OrbitishFO( "Orbit", java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
############################################################################# ## #O Orbits( <G>, <seeds>[, <gens>, <acts>][, <act>] ) #A Orbits( <G> ) #A Orbits( <xset> ) ## ## <#GAPDoc Label="Orbits"> ## <ManSection> ## <Oper Name="Orbits" Arg='G, seeds[, gens, acts][, act]' Label="operation"/> ## <Attr Name="Orbits" Arg='G' ## Label="for a permutation group"/> ## <Attr Name="Orbits" Arg='xset' Label="attribute"/> ## ## <Description> ## returns a duplicate-free list of the orbits of the elements in ## <A>seeds</A> under the action <A>act</A> of <A>G</A> or under ## <Ref Func="OnPoints"/> if no action function is given. ## <P/> ## For a permutation group <A>G</A>, one may also invoke this as ## <C>Orbits(<A>G</A>)</C>, which returns all the orbits of its natural ## action on the set of points moved by it. ## For example the group <M>\langle (1,2,3), (4,5) \rangle</M> ## has the orbits <M>\{1,2,3\}</M> and <M>\{4,5\}</M>. ## <P/> ## (Note that the arrangement of orbits or of points within one orbit is ## not defined by the operation.) ## </Description> ## </ManSection> ## <#/GAPDoc> ## ## <C>OrbitLengthsDomain(<A>G</A>)</C>, which returns the length of all
############################################################################# ## #O OrbitsDomain( <G>, <Omega>[, <gens>, <acts>][, <act>] ) #A OrbitsDomain( <G> ) #A OrbitsDomain( <xset> ) ## ## <#GAPDoc Label="OrbitsDomain"> ## <ManSection> ## <Heading>OrbitsDomain</Heading> ## <Oper Name="OrbitsDomain" Arg='G, Omega[, gens, acts][, act]' ## Label="for a group and an action domain"/> ## <Attr Name="OrbitsDomain" Arg='G' ## Label="for a permutation group"/> ## </Description> ## Label="of an external set"/> ## ## <Description> ## returns a list of the orbits of <A>G</A> on the domain <A>Omega</A> ## (given as lists) under the action <A>act</A> or under ## <Ref Func="OnPoints"/> if no action function is given. ## <P/> ## This operation is often faster than ## <Ref Oper="Orbits" Label="operation"/>. ## The domain <A>Omega</A> must be closed under the action of <A>G</A>, ## otherwise an error can occur. ## <P/> ## For a permutation group <A>G</A>, one may also invoke this as ## <C>OrbitsDomain(<A>G</A>)</C>, which returns all the orbits of its natural ## action on the set of points moved by it. ## <P/> ## (Note that the arrangement of orbits or of points within one orbit is ## not defined by the operation.) ## <Example><![CDATA[ ## gap> g:=Group((1,3,2),(2,4,3));; ## gap> Orbits(g,[1..5]); ## [ [ 1, 3, 2, 4 ], [ 5 ] ] ## gap> OrbitsDomain(g,Arrangements([1..4],3),OnTuples); ## [ [ [ 1, 2, 3 ], [ 3, 1, 2 ], [ 1, 4, 2 ], [ 2, 3, 1 ], [ 2, 1, 4 ], ## [ 3, 4, 1 ], [ 1, 3, 4 ], [ 4, 2, 1 ], [ 4, 1, 3 ], ## [ 2, 4, 3 ], [ 3, 2, 4 ], [ 4, 3, 2 ] ], ## [ [ 1, 2, 4 ], [ 3, 1, 4 ], [ 1, 4, 3 ], [ 2, 3, 4 ], [ 2, 1, 3 ], ## [ 3, 4, 2 ], [ 1, 3, 2 ], [ 4, 2, 3 ], [ 4, 1, 2 ], ## [ 2, 4, 1 ], [ 3, 2, 1 ], [ 4, 3, 1 ] ] ] ## gap> OrbitsDomain(g,GF(2)^2,[(1,2,3),(1,4)(2,3)], ## > [[[Z(2)^0,Z(2)^0],[Z(2)^0,0*Z(2)]],[[Z(2)^0,0*Z(2)],[0*Z(2),Z(2)^0]]]); ## [ [ <an immutable GF2 vector of length 2> ], ## [ <an immutable GF2 vector of length 2>, ## <an immutable GF2 vector of length 2>, ## <an immutable GF2 vector of length 2> ] ] ## ]]></Example> ## <P/> ## (See Section <Ref Sect="Basic Actions"/> ## for information about specific actions.) ## </Description> ## </ManSection> ## <#/GAPDoc> ##
, NewAttribute)
############################################################################# ## #O OrbitLength( <G>[, <Omega>], <pnt> [, <gens>, <acts>][, <act>] ) ## ## <#GAPDoc Label="OrbitLength"> ## <ManSection> ## <Oper Name="OrbitLength" Arg='G[, Omega], pnt[, gens, acts][, act]'/> ## ## <Description> ## computes the length of the orbit of <A>pnt</A> under ## the action function <A>act</A> or <Ref Func="OnPoints"/> ## if no action function is given. ## </Description> ## </ManSection> ## <#/GAPDoc> ##
OrbitishFO( "OrbitLength", OrbitishReq, IsCollsElms, false, false );
############################################################################# ## #O OrbitLengths( <G>, <seeds>[, <gens>, <acts>][, <act>] ) #A OrbitLengths( <G> ) #A OrbitLengths( <xset> ) ## ## <#GAPDoc Label="OrbitLengths"> ## <ManSection> ## <Heading>OrbitLengths</Heading> ## <Oper Name="OrbitLengths" Arg='G, seeds[, gens, acts][, act]' ## Label="for a group, a set of seeds, etc."/> ## <Attr Name="OrbitLengths" Arg='G' Label="for a permutation group"/> ## <Attr Name="OrbitLengths" Arg='xset' Label="for an external set"/> ## ## <Description> ## computes the lengths of all the orbits of the elements in <A>seeds</A> ## under the action <A>act</A> of <A>G</A>. ## <P/> ## For a permutation group <A>G</A>, one may also invoke this as ## <C>OrbitLengths(<A>G</A>)</C>, which returns the lengths of all the ## orbits of its natural action on the set of points moved by it. ## For example the group <M>\langle (1,2,3), (5,6) \rangle</M> ## has the orbit lengths 2 and 3. ## </Description> ## </ManSection> ## <#/GAPDoc> ##
OrbitsishOperation( "OrbitLengths", OrbitsishReq, false, NewAttribute );
############################################################################# ## #O OrbitLengthsDomain( <G>, <Omega>[, <gens>, <acts>][, <act>] ) #A OrbitLengthsDomain( <G> ) #A OrbitLengthsDomain( <xset> ) ## ## <#GAPDoc Label="OrbitLengthsDomain"> ## <ManSection> ## <Heading>OrbitLengthsDomain</Heading> ## <Oper Name="OrbitLengthsDomain" Arg='G, Omega[, gens, acts][, act]' ## Label="for a group and a set of seeds"/> ## <Attr Name="OrbitLengthsDomain" Arg='G' ## Label="for a permutation group"/> ## <Attr Name="OrbitLengthsDomain" Arg='xset' Label="of an external set"/> ## ## <Description> ## computes the lengths of all the orbits of <A>G</A> on <A>Omega</A>. ## <P/> ## This operation is often faster than ## <Ref Oper="OrbitLengths" Label="for a group, a set of seeds, etc."/>. ## The domain <A>Omega</A> must be closed under the action of <A>G</A>, ## otherwise an error can occur. ## <P/> ## For a permutation group <A>G</A>, one may also invoke this as ## <C>OrbitLengthsDomain(<A>G</A>)</C>, which returns the length of all ## the orbits of its natural action on the set of points moved by it. ## <Example><![CDATA[ ## gap> g:=Group((1,3,2),(2,4,3));; ## gap> OrbitLength(g,[1,2,3,4],OnTuples); ## 12 ## gap> OrbitLengths(g,Arrangements([1..4],4),OnTuples); ## [ 12, 12 ] ## gap> g:=Group((1,2,3),(5,6,7));; ## gap> OrbitLengthsDomain(g,[1,2,3]); ## [ 3 ] ## gap> OrbitLengthsDomain(g); ## [ 3, 3 ] ## ]]></Example> ## </Description> ## </ManSection> ## <#/GAPDoc> ##
OrbitsishOperation( "OrbitLengthsDomain", OrbitsishReq, false, NewAttribute );
############################################################################# ## #O OrbitStabilizer( <G>[, <Omega>], <pnt>[, <gens>,<acts>][, <act>] ) ## ## <#GAPDoc Label="OrbitStabilizer"> ## <ManSection> ## <Oper Name="OrbitStabilizer" Arg='G[, Omega], pnt[, gens, acts][, act]'/> ## ## <Description> ## computes the orbit and the stabilizer of <A>pnt</A> simultaneously in a ## single orbit-stabilizer algorithm. ## <P/> ## The stabilizer will have <A>G</A> as its parent. ## </Description> ## </ManSection> ## <#/GAPDoc> ##
## </ManSection>
############################################################################# ## #O ExternalOrbits( <G>, <Omega>[, <gens>, <acts>][, <act>] ) #A ExternalOrbits( <xset> ) ## ## <#GAPDoc Label="ExternalOrbits"> ## <ManSection> ## <Heading>ExternalOrbits</Heading> ## <Oper Name="ExternalOrbits" Arg='G, Omega[, gens, acts][, act]' ## Label="for a group, an action domain, etc."/> ## <Attr Name="ExternalOrbits" Arg='xset' [ IsPermGroup ], 0, ## ## <Description> ## computes a list of external orbits that give the orbits of <A>G</A>. ## <Example><![CDATA[ ## gap> ExternalOrbits(g,AsList(g)); ## [ ()^G, (2,3,4)^G, (2,4,3)^G, (1,2)(3,4)^G ] ## ]]></Example> ## </Description> ## </ManSection> ## <#/GAPDoc> ##
OrbitsishOperation( " ,
############################################################################# ## #O ExternalOrbitsStabilizers( <G>, <Omega>[, <gens>, <acts>][, <act>] ) #A ExternalOrbitsStabilizers( <xset> ) ## ## <#GAPDoc Label="ExternalOrbitsStabilizers"> ## <ManSection> ## <Heading>ExternalOrbitsStabilizers</Heading> ## <Oper Name="ExternalOrbitsStabilizers" ## Arg='G, Omega[, gens, acts][, act]' ## Label="for a group, an action domain, etc."/> ## <Attr Name="ExternalOrbitsStabilizers" Arg='xset' ## Label="for an external set"/> ## ## <Description> ## In addition to ## <Ref Oper="ExternalOrbits" Label="for a group, an action domain, etc."/>, ## this operation also computes the stabilizers of the representatives of ## the external orbits at the same time. ## (This can be quicker than computing the ## <Ref Oper="ExternalOrbits" Label="for a group, an action domain, etc."/> ## value first and the stabilizers afterwards.) ## <Example><![CDATA[ ## gap> e:=ExternalOrbitsStabilizers(g,AsList(g)); ## [ ()^G, (2,3,4)^G, (2,4,3)^G, (1,2)(3,4)^G ] ## gap> HasStabilizerOfExternalSet(e[3]); ## true ## gap> StabilizerOfExternalSet(e[3]); ## Group([ (2,4,3) ]) ## ]]></Example> ## </Description> ## </ManSection> ## <#/GAPDoc> ##
OrbitsishOperation( "ExternalOrbitsStabilizers", OrbitsishReq( t
true, NewAttribute ,
############################################################################# ## #O Transitivity( <G>, <Omega>[, <gens>, <acts>][, <act>] ) #A Transitivity( <G> ) #A Transitivity( <xset> ) ## ## <#GAPDoc Label="Transitivity:oprt"> ## <ManSection> ## <Heading>Transitivity</Heading> ## <Oper Name="Transitivity" Arg='G, Omega[, gens, acts][, act]' ## Label="for a group and an action domain"/> ## <Attr Name="Transitivity" Arg='G' ## Label="for a permutation group"/> ## <Attr Name="Transitivity" Arg='xset' Label="for an external set"/> ## ## <Description> ## returns the degree <M>k</M> (a non-negative integer) of transitivity of ## the action implied by the arguments, ## i.e. the largest integer <M>k</M> such that the action is ## <M>k</M>-transitive. ## If the action is not transitive <C>0</C> is returned. ## <P/> ## An action is <E><M>k</M>-transitive</E> if every <M>k</M>-tuple of points ## can be mapped simultaneously to every other <M>k</M>-tuple. ## <P/> ## For a permutation group <A>G</A>, one may also invoke this as ## <C>Transitivity(<A>G</A>)</C>, which returns the degree of transitivity ## of the group with respect to its natural action on the set of points ## moved by it. ## For example the group <M>\langle (2,3,4),(2,3) \rangle</M> ## is 3-transitive on the set <M>\{2, 3, 4\}</M>. ## <Example><![CDATA[ ## gap> g:=Group((1,3,2),(2,4,3));; ## gap> IsTransitive(g,[1..5]); ## false ## gap> Transitivity(g,[1..4]); ## 2 ## gap> Transitivity(g); ## 2 ## ]]></Example> ## </Description> ## </ManSection> ## <#/GAPDoc> ##
OrbitsishOperation( "Transitivity", OrbitsishReq, false, NewAttribute );
############################################################################# ## #O Blocks( <G>, <Omega>[, <seed>][, <gens>, <acts>][, <act>] ) #A Blocks( <xset>[, <seed>] ) ## ## <#GAPDoc Label="Blocks"> ## <ManSection> ## <Heading>Blocks</Heading> ## <Oper Name="Blocks" Arg='G, Omega[, seed][, gens, acts][, act]' ## Label="for a group, an action domain, etc."/> ## <Attr Name="Blocks" Arg='xset[, seed]' ## Label="for an external set"/> ## ## <Description> ## computes a block system for the transitive (see ## <Ref Oper="IsTransitive" Label="for a group, an action domain, etc."/>) ## action of <A>G</A> on <A>Omega</A>. ## If <A>seed</A> is not given and the action is imprimitive, ## a minimal nontrivial block system will be found. ## If <A>seed</A> is given, a block system in which <A>seed</A> ## is the subset of one block is computed. ## <P/> ## The result is undefined if the action is not transitive. ## <Example><![CDATA[ ## gap> g:=TransitiveGroup(8,3); ## E(8)=2[x]2[x]2 ## gap> Blocks(g,[1..8]); ## [ [ 1, 8 ], [ 2, 3 ], [ 4, 5 ], [ 6, 7 ] ] ## gap> Blocks(g,[1..8],[1,4]); ## [ [ 1, 4 ], [ 2, 7 ], [ 3, 6 ], [ 5, 8 ] ] ## ]]></Example> ## <P/> ## (See Section <Ref Sect="Basic Actions"/> ## for information about specific actions.) ## </Description> ## </ManSection> ## <#/GAPDoc> ##
DeclareAttribute## <Description>
OrbitishFO(## This function is analogous to <Ref Func="OrbitsishOperation"/>,
[ut for operations <A>java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 17
IsList,
IsList,
## The call of <Ref Func="OrbitishFO"/> declares a wrapper function and its
############################################################################# ## #O MaximalBlocks( <G>, <Omega>[, <seed>][, <gens>, <acts>][, <act>] ) #A MaximalBlocks( <xset>[, <seed>] ) ## ## <#GAPDoc Label="MaximalBlocks"> ## <ManSection> ## <Heading>MaximalBlocks</Heading> ## <Oper Name="MaximalBlocks" Arg='G, Omega[, seed][, gens, acts][, act]' ## Label="for a group, an action domain, etc."/> ## <Attr Name="MaximalBlocks" Arg='xset[, seed]' ## Label="for an external set"/> ## ## <Description> ## returns a block system that is maximal (i.e., blocks are maximal with ## respect to inclusion) for the transitive (see ## <Ref Oper="IsTransitive" Label="for a group, an action domain, etc."/>) ## action of <A>G</A> on <A>Omega</A>. ## If <A>seed</A> is given, a block system is computed in which <A>seed</A> ## is a subset of one block. ## <P/> ## The result is undefined if the action is not transitive. ## <Example><![CDATA[ ## gap> MaximalBlocks(g,[1..8]); ## [ [ 1, 2, 3, 8 ], [ 4 .. 7 ] ] ## ]]></Example> ## </Description> ## </ManSection> ## <#/GAPDoc> ##
DeclareAttribute MaximalBlocksAttr,IsExternalSet )java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
OrbitishFO( "MaximalBlocks",
[ IsGroup, IsList, IsList,
IsList,
IsList,## For a permutation group <A>G</A>, one may also invoke this as
IsFunction## <C>IsPrimitive(<A>G</A>)</C>, which tests whether the group is
#T the following syntax would be nice for consistency as well: ## RepresentativesMinimalBlocks(<G>,<Omega>[,<seed>][,<gens>,<acts>][,<act>]) ## RepresentativesMinimalBlocks( <xset>, <seed> )
############################################################################# ## #O RepresentativesMinimalBlocks(<G>,<Omega>[,<gens>,<acts>][,<act>]) #A RepresentativesMinimalBlocks( <xset> ) ## ## <#GAPDoc Label="RepresentativesMinimalBlocks"> ## <ManSection> ## <Heading>RepresentativesMinimalBlocks</Heading> ## <Oper Name="RepresentativesMinimalBlocks" ## Arg='G, Omega[, gens, acts][, act]' ## Label="for a group, an action domain, etc."/> ## <Attr Name="RepresentativesMinimalBlocks" Arg='xset' ## Label="for an external set"/> ## ## <Description> ## computes a list of block representatives for all minimal (i.e blocks are ## minimal with respect to inclusion) nontrivial block systems for the ## transitive (see ## <Ref Oper="IsTransitive" Label="for a group, an action domain, etc."/>) ## action of <A>G</A> on <A>Omega</A>. ## <P/> ## The result is undefined if the action is not transitive. ## <Example><![CDATA[ ## gap> RepresentativesMinimalBlocks(g,[1..8]); ## [ [ 1, 2 ], [ 1, 3 ], [ 1, 4 ], [ 1, 5 ], [ 1, 6 ], [ 1, 7 ], ## [ 1, 8 ] ] ## ]]></Example> ## </Description> ## </ManSection> ## <#/GAPDoc> ##
DeclareAttribute( "RepresentativesMinimalBlocksAttr", D:=HomeEnumerator( xset#############################################################################
############################################################################# ## #O Earns( <G>, <Omega>[, <gens>, <acts>][, <act>] ) #A Earns( <xset> ) ## ## <#GAPDoc Label="Earns"> ## <ManSection> ## <Heading>Earns</Heading> ## <Oper Name="Earns" Arg='G, Omega[, gens, acts][, act]' ## Label="for a group, an action domain, etc."/> ## <Attr Name="Earns" Arg='xset' ## Label="for an external set"/> ## ## <Description> ## returns a list of the elementary abelian regular ## (when acting on <A>Omega</A>) normal subgroups of <A>G</A>. ## <P/> ## At the moment only methods for a primitive group <A>G</A> are implemented. ## </Description> ## </ManSection> ## <#/GAPDoc> ##
OrbitsishOperation( "Earnselse
############################################################################# ## #O IsTransitive( <G>, <Omega>[, <gens>, <acts>][, <act>] ) #P IsTransitive( <permgroup> ) #P IsTransitive( <xset> ) ## ## <#GAPDoc Label="IsTransitive:oprt"> ## <ManSection> ## <Heading>IsTransitive</Heading> ## <Oper Name="IsTransitive" Arg='G, Omega[, gens, acts][, act]' ## Label="for a group, an action domain, etc."/> ## <Prop Name="IsTransitive" Arg='G' ## Label="for a permutation group"/> ## <Prop Name="IsTransitive" Arg='xset' ## Label="for an external set"/> ## ## <Description> ## returns <K>true</K> if the action implied by the arguments is transitive, ## or <K>false</K> otherwise. ## <P/> ## <Index>transitive</Index> ## We say that a group <A>G</A> acts <E>transitively</E> on a domain ## <M>D</M> if and only if <A>G</A> acts on <M>D</M> and for every pair of ## points <M>d, e \in D</M> ## there is an element <M>g</M> in <A>G</A> such that <M>d^g = e</M>. ## <P/> ## For a permutation group <A>G</A>, one may also invoke this as ## <C>IsTransitive(<A>G</A>)</C>, which tests whether the group is ## transitive with respect to its natural action on the set of points ## moved by it. ## For example the group <M>\langle (2,3,4),(2,3) \rangle</M> ## is transitive on the set <M>\{2, 3, 4\}</M>. ## <Example><![CDATA[ ## gap> G:= Group( (2,3,4), (2,3) );; ## gap> IsTransitive( G, [ 2 .. 4 ] ); ## true ## gap> IsTransitive( G, [ 2, 3 ] ); # G does not act on [ 2, 3 ] ## false ## gap> IsTransitive( G, [ 1 .. 4 ] ); # G has two orbits on [ 1 .. 4 ] ## false ## gap> IsTransitive( G ); # G is transitive on [ 2 .. 4 ] ## true ## gap> IsTransitive( SL(2, 3), NormedRowVectors( GF(3)^2 ) ); ## false ## gap> IsTransitive( SL(2, 3), NormedRowVectors( GF(3)^2 ), OnLines ); ## true ## ]]></Example> ## </Description> ## </ManSection> ## <#/GAPDoc> ##
HasMovedPoints ## <Oper Name="IsRegular" Arg='G, Omega[, gens, acts][, act]'
############################################################################# ## #O IsPrimitive( <G>, <Omega>[, <gens>, <acts>][, <act>] ) #P IsPrimitive( <G> ) #P IsPrimitive( <xset> ) ## ## <#GAPDoc Label="IsPrimitive"> ## <ManSection> ## <Heading>IsPrimitive</Heading> ## <Oper Name="IsPrimitive" Arg='G, Omega[, gens, acts][, act]' ## Label="for a group, an action domain, etc."/> ## <Prop Name="IsPrimitive" Arg='G' ## Label="for a permutation group"/> ## <Prop Name="IsPrimitive" Arg='xset' ## Label="for an external set"/> ## ## <Description> ## returns <K>true</K> if the action implied by the arguments is primitive, ## or <K>false</K> otherwise. ## <P/> ## <Index>primitive</Index> ## An action is <E>primitive</E> if it is transitive (see ## <Ref Oper="IsTransitive" Label="for a group, an action domain, etc."/>) ## and the action admits ## no nontrivial block systems. See <Ref Sect="Block Systems"/> for ## the definition of block systems. ## <P/> ## For a permutation group <A>G</A>, one may also invoke this as ## <C>IsPrimitive(<A>G</A>)</C>, which tests whether the group is ## primitive with respect to its natural action on the set of points ## moved by it. ## For example the group <M>\langle (2,3,4),(2,3) \rangle</M> ## is primitive on the set <M>\{2, 3, 4\}</M>. ## <P/> ## For an explanation of the meaning of all the inputs, please refer to ## <Ref Sect="About Group Actions"/>. ## <P/> ## <E>Note:</E> This operation does not tell whether a matrix group is ## primitive in the sense of preserving a direct sum of vector spaces. ## To do this use <C>IsPrimitiveMatrixGroup</C> or ## <C>IsPrimitive</C> from the package <Package>IRREDSOL</Package>. ## ## <Example><![CDATA[ ## gap> IsPrimitive(g,Orbit(g,(1,2)(3,4))); ## true ## ]]></Example> ## </Description> ## </ManSection> ## <#/GAPDoc> ##
OrbitsishOperation( "IsPrimitive", OrbitsishReq, false, NewProperty ## gap> Size(Range(hom));Size(Image(hom));
InstallTrueMethod( IsPrimitive, IsNaturalSymmetricGroup );
InstallTrueMethod## > "surjective");;
InstallTrueMethod( IsTransitive, IsPrimitive and java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 5
############################################################################# ## #O IsPrimitiveAffine( <G>, <Omega>[, <gens>, <acts>][, <act>] ) #P IsPrimitiveAffine( <xset> ) ## ## <ManSection> ## <Oper Name="IsPrimitiveAffine" Arg='G, Omega[, gens, acts][, act]' ## Label="for a group, an action domain, etc."/> ## <Prop Name="IsPrimitiveAffine" Arg='xset' ## Label="for an external set"/> ## ## <Description> ## </Description> ## </ManSection> ##
OrbitsishOperation( "IsPrimitiveAffine", ## computes the permutation that corresponds to the action of <A>g</A> on
############################################################################# ## #O IsSemiRegular( <G>, <Omega>[, <gens>, <acts>][, <act>] ) #P IsSemiRegular( <G> ) #P IsSemiRegular( <xset> ) ## ## <#GAPDoc Label="IsSemiRegular"> ## <ManSection> ## <Heading>IsSemiRegular</Heading> ## <Oper Name="IsSemiRegular" Arg='G, Omega[, gens, acts][, act]' ## Label="for a group, an action domain, etc."/> ## <Prop Name="IsSemiRegular" Arg='G' ## Label="for a permutation group"/> ## <Prop Name="IsSemiRegular" Arg='xset' ## Label="for an external set"/> ## ## <Description> ## returns <K>true</K> if the action implied by the arguments is ## semiregular, or <K>false</K> otherwise. ## <P/> ## <Index>semiregular</Index> ## An action is <E>semiregular</E> if the stabilizer of each point is the ## identity. ## <P/> ## For a permutation group <A>G</A>, one may also invoke this as ## <C>IsSemiRegular(<A>G</A>)</C>, which tests whether the group is ## semiregular with respect to its natural action on the set of points ## moved by it. ## For example the group <M>\langle (2,3,4) (5,6,7) \rangle</M> ## is semiregular on the set <M>\{2, 3, 4, 5, 6, 7\}</M>. ## </Description> ## </ManSection> ## <#/GAPDoc> ##
OrbitsishOperation## <Func Name="PermutationCycle" Arg='g, Omega, pnt[, act]'/>
############################################################################# ## #O IsRegular( <G>, <Omega>[, <gens>, <acts>][, <act>] ) #P IsRegular( <G> ) #P IsRegular( <xset> ) ## ## <#GAPDoc Label="IsRegular"> ## <ManSection> ## <Heading>IsRegular</Heading> ## <Oper Name="IsRegular" Arg='G, Omega[, gens, acts][, act]' ## Label="for a group, an action domain, etc."/> ## <Prop Name="IsRegular" Arg='G' ## Label="for a permutation group"/> ## <Prop Name="IsRegular" Arg='xset' ## Label="for an external set"/> ## ## <Description> ## returns <K>true</K> if the action implied by the arguments is regular, or ## <K>false</K> otherwise. ## <P/> ## <Index>regular</Index> ## An action is <E>regular</E> if it is both semiregular ## (see <Ref Oper="IsSemiRegular" Label="for a group, an action domain, etc."/>) ## and transitive ## (see <Ref Oper="IsTransitive" Label="for a group, an action domain, etc."/>). ## In this case every point <A>pnt</A> of <A>Omega</A> defines a one-to-one ## correspondence between <A>G</A> and <A>Omega</A>. ## <P/> ## For a permutation group <A>G</A>, one may also invoke this as ## <C>IsRegular(<A>G</A>)</C>, which tests whether the group is ## regular with respect to its natural action on the set of points moved by it. ## For example the group <M>\langle (2,3,4) \rangle</M> ## is regular on the set <M>\{2, 3, 4\}</M>. ## ## <Example><![CDATA[ ## gap> IsSemiRegular(g,Arrangements([1..4],3),OnTuples); ## true ## gap> IsRegular(g,Arrangements([1..4],3),OnTuples); ## false ## ]]></Example> ## </Description> ## </ManSection> ## <#/GAPDoc> ##
OrbitsishOperation( "IsRegular", OrbitsishReq, false, NewProperty );
InstallTrueMethod( IsRegular, java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 2
############################################################################# ## #O RankAction( <G>, <Omega>[, <gens>, <acts>][, <act>] ) #A RankAction( <xset> ) ## ## <#GAPDoc Label="RankAction"> ## <ManSection> ## <Heading>RankAction</Heading> ## <Oper Name="RankAction" Arg='G, Omega[, gens, acts][, act]' ## Label="for a group, an action domain, etc."/> ## <Attr Name="RankAction" Arg='xset' ## Label="for an external set"/> ## ## <Description> ## returns the rank of the transitive (see ## <Ref Oper="IsTransitive" Label="for a group, an action domain, etc."/>) ## action of <A>G</A> on <A>Omega</A>, i. e., the number of orbits of ## any point stabilizer. ## <Example><![CDATA[ ## gap> RankAction(g,Combinations([1..4],2),OnSets); ## 4 ## ]]></Example> ## </Description> ## </ManSection> ## <#/GAPDoc> ##
OrbitsishOperation( "## Group([ [ [ Z(3), Z(3) ], [ 0*Z(3), Z(3) ] ] ])
############################################################################# ## #F Permutation( <g>, <Omega>[, <gens>, <acts>][, <act>] ) #F Permutation( <g>, <xset> ) ## ## <#GAPDoc Label="Permutation"> ## <ManSection> ## <Heading>Permutation</Heading> ## <Func Name="Permutation" Arg='g, Omega[, gens, acts][, act]' ## Label="for a group, an action domain, etc."/> ## <Func Name="Permutation" Arg='g, xset' Label="for an external set"/> ## ## <Description> ## computes the permutation that corresponds to the action of <A>g</A> on ## the permutation domain <A>Omega</A> ## (a list of objects that are permuted). ## If an external set <A>xset</A> is given, ## the permutation domain is the <Ref Attr="HomeEnumerator"/> value ## of this external set (see Section <Ref Sect="External Sets"/>). ## Note that the points of the returned permutation refer to the positions ## in <A>Omega</A>, even if <A>Omega</A> itself consists of integers. ## <P/> ## If <A>g</A> does not leave the domain invariant, or does not map the ## domain injectively then <K>fail</K> is returned. ## </Description> ## </ManSection> ## <#/GAPDoc> ##
java.lang.StringIndexOutOfBoundsException: Range [24, 21) out of bounds for length 39
ac le]
############################################################################# ## #O PermutationCycle( <g>, <Omega>, <pnt>[, <act>] ) ## ## <#GAPDoc Label="PermutationCycle"> ## <ManSection> ## <Func Name="PermutationCycle" Arg='g, Omega, pnt[, act]'/> ## ## <Description> ## computes the permutation that represents the cycle of <A>pnt</A> under ## the action of the element <A>g</A>. ## <Example><![CDATA[ ## gap> Permutation([[Z(3),-Z(3)],[Z(3),0*Z(3)]],AsList(GF(3)^2)); ## (2,7,6)(3,4,8) ## gap> Permutation((1,2,3)(4,5)(6,7),[4..7]); ## (1,2)(3,4) ## gap> PermutationCycle((1,2,3)(4,5)(6,7),[4..7],4); ## (1,2) ## ]]></Example> ## </Description> ## </ManSection> ## <#/GAPDoc> ##
DeclareGlobalFunction( "PermutationCycle" );
DeclareOperation( "java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 13
[ IsObject, IsList, IsObject, IsFunction ] );
############################################################################# ## #O Cycle( <g>, <Omega>, <pnt> [,<act>] ) ## ## <#GAPDoc Label="Cycle"> ## <ManSection> ## <Func Name="Cycle" Arg='g, Omega, pnt[, act]'/> ## ## <Description> ## returns a list of the points in the cycle of <A>pnt</A> under the action ## of the element <A>g</A>. ## </Description> ## </ManSection> ## <#/GAPDoc> ##
DeclareGlobalFunction( "Cycle" );
ion "ycleOp", IsObject, IsList, IsObject, IsFunction ] );
############################################################################# ## #O Cycles( <g>, <Omega> [,<act>] ) ## ## <#GAPDoc Label="Cycles"> ## <ManSection> ## <Func Name="Cycles" Arg='g, Omega[, act]'/> ## ## <Description> ## returns a list of the cycles (as lists of points) of the action of the ## element <A>g</A>. ## </Description> ## </ManSection> ## <#/GAPDoc> ##
DeclareGlobalFunction( "Cycles" );
DeclareOperation## For a permutation group <A>G</A>, one may also invoke this as
############################################################################# ## #O CycleLength( <g>, <Omega>, <pnt> [,<act>] ) ## ## <#GAPDoc Label="CycleLength"> ## <ManSection> ## <Func Name="CycleLength" Arg='g, Omega, pnt[, act]'/> ## ## <Description> ## returns the length of the cycle of <A>pnt</A> under the action of the element ## <A>g</A>. ## </Description> ## </ManSection> ## <#/GAPDoc> ##
DeclareGlobalFunction( "CycleLength" );
############################################################################# ## #F CycleIndex( <g>, <Omega>[, <act>] ) #F CycleIndex( <G>, <Omega>[, <act>] ) ## ## <#GAPDoc Label="CycleIndex"> ## <ManSection> ## <Heading>CycleIndex</Heading> ## <Func Name="CycleIndex" Arg='g, Omega[, act]' ## Label="for a permutation and an action domain"/> ## <Func Name="CycleIndex" Arg='G, Omega[, act]' ## Label="for a permutation group and an action domain"/> ## ## <Description> ## The <E>cycle index</E> of a permutation <A>g</A> acting on <A>Omega</A> ## is defined as ## <Display Mode="M"> ## z(<A>g</A>) = s_1^{{c_1}} s_2^{{c_2}} \cdots s_n^{{c_n}} ## </Display> ## where <M>c_k</M> is the number of <M>k</M>-cycles in the cycle ## decomposition of <A>g</A> and the <M>s_i</M> are indeterminates. ## <P/> ## The <E>cycle index</E> of a group <A>G</A> is defined as ## <Display Mode="M"> ## Z(<A>G</A>) = \left( \sum_{{g \in <A>G</A>}} z(g) \right) / |<A>G</A>| . ## </Display> ## <P/> ## The indeterminates used by ## <Ref Func="CycleIndex" Label="for a permutation and an action domain"/> ## are the indeterminates <M>1</M> to <M>n</M> over the rationals ## (see <Ref Oper="Indeterminate" Label="for a ring (and a number)"/>). ## <P/> ## <Example><![CDATA[ ## gap> g:=TransitiveGroup(6,8); ## S_4(6c) = 1/2[2^3]S(3) ## gap> CycleIndex(g); ## 1/24*x_1^6+1/8*x_1^2*x_2^2+1/4*x_1^2*x_4+1/4*x_2^3+1/3*x_3^2 ## ]]></Example> ## </Description> ## </ManSection> ## <#/GAPDoc> ##
DeclareGlobalFunction # For a permutation group <A>G</A>, one may also invoke this as
############################################################################# ## #O RepresentativeAction( <G> [,<Omega>], <d>, <e> [,<gens>,<acts>] [,<act>] ) ## ## <#GAPDoc Label="RepresentativeAction"> ## <ManSection> ## <Func Name="RepresentativeAction" ## Arg='G[, Omega], d, e[, gens, acts][, act]'/> ## ## <Description> ## computes an element of <A>G</A> that maps <A>d</A> to <A>e</A> under the ## given action and returns <K>fail</K> if no such element exists. ## <Example><![CDATA[ ## gap> g:=Group((1,3,2),(2,4,3));; ## gap> RepresentativeAction(g,1,3); ## (1,3)(2,4) ## gap> RepresentativeAction(g,1,3,OnPoints); ## (1,3)(2,4) ## gap> RepresentativeAction(g,(1,2,3),(2,4,3)); ## (1,2,4) ## gap> RepresentativeAction(g,(1,2,3),(2,3,4)); ## fail ## gap> RepresentativeAction(g,Group((1,2,3)),Group((2,3,4))); ## (1,2,4) ## gap> RepresentativeAction(g,[1,2,3],[1,2,4],OnSets); ## (2,4,3) ## gap> RepresentativeAction(g,[1,2,3],[1,2,4],OnTuples); ## fail ## ]]></Example> ## <P/> ## (See Section <Ref Sect="Basic Actions"/> ## for information about specific actions.) ## <P/> ## Again the standard method for <Ref Func="RepresentativeAction"/> is ## an orbit-stabilizer algorithm, ## for permutation groups and standard actions a backtrack algorithm is used. ## </Description> ## </ManSection> ## <#/GAPDoc> ##
## gap> ExternalOrbits(g,AsList(g));
DeclareOperation( "RepresentativeActionOp",
[ IsGroup, IsList,
############################################################################# ## #F Stabilizer( <G> [,<Omega>], <pnt> [,<gens>,<acts>] [,<act>] ) ## ## <#GAPDoc Label="Stabilizer"> ## <ManSection> ## <Func Name="Stabilizer" Arg='G[, Omega], pnt[, gens, acts][, act]'/> ## ## <Description> ## computes the stabilizer in <A>G</A> of the point <A>pnt</A>, ## that is the subgroup of those elements of <A>G</A> that fix <A>pnt</A>. ## The stabilizer will have <A>G</A> as its parent. ## <Example><![CDATA[ ## gap> g:=Group((1,3,2),(2,4,3));; ## gap> stab:=Stabilizer(g,4); ## Group([ (1,3,2) ]) ## gap> Parent(stab); ## Group([ (1,3,2), (2,4,3) ]) ## ]]></Example> ## <P/> ## The stabilizer of a set or tuple of points can be computed by specifying ## an action of sets or tuples of points. ## <Example><![CDATA[ ## gap> Stabilizer(g,[1,2],OnSets); ## Group([ (1,2)(3,4) ]) ## gap> Stabilizer(g,[1,2],OnTuples); ## Group(()) ## gap> orbstab:=OrbitStabilizer(g,[1,2],OnSets); ## rec( ## orbit := [ [ 1, 2 ], [ 1, 3 ], [ 1, 4 ], [ 2, 3 ], [ 3, 4 ], ## [ 2, 4 ] ], stabilizer := Group([ (1,2)(3,4) ]) ) ## gap> Parent(orbstab.stabilizer); ## Group([ (1,3,2), (2,4,3) ]) ## ]]></Example> ## <P/> ## (See Section <Ref Sect="Basic Actions"/> ## for information about specific actions.) ## <P/> ## The standard methods for all these actions are an orbit-stabilizer ## algorithm. For permutation groups backtrack algorithms are used. For ## solvable groups an orbit-stabilizer algorithm for solvable groups, which ## uses the fact that the orbits of a normal subgroup form a block system ## (see <Cite Key="SOGOS"/>) is used. ## </Description> ## </ManSection> ## <#/GAPDoc> ##
DeclareGlobalFunction##
OrbitishFO( "StabilizerFunc", OrbitishReq, IsCollsElms, false,false );
BindGlobal## i.e. the largest integer <M>k</M> such that the action is
############################################################################# ## #F StabilizerPcgs( <pcgs>, <pnt> [,<acts>] [,<act>] ) ## ## <#GAPDoc Label="StabilizerPcgs"> ## <ManSection> ## <Func Name="StabilizerPcgs" Arg='pcgs, pnt[, acts][, act]'/> ## ## <Description> ## computes the stabilizer in the group generated by <A>pcgs</A> of the ## point <A>pnt</A>. ## If given, <A>acts</A> are elements by which <A>pcgs</A> acts, ## <A>act</A> is the acting function. ## This function returns a pcgs for the stabilizer which is induced by the ## <C>ParentPcgs</C> of <A>pcgs</A>, that is it is compatible ## with <A>pcgs</A>. ## </Description> ## </ManSection> ## <#/GAPDoc> ##
DeclareGlobalFunction( "StabilizerPcgs" );
############################################################################# ## #F OrbitStabilizerAlgorithm( <G>, <Omega>, <blist>, <gens>,<acts>, <pntact> ) ## ## <#GAPDoc Label="OrbitStabilizerAlgorithm"> ## <ManSection> ## <Oper Name="OrbitStabilizerAlgorithm" ## Arg='G, Omega, blist, gens, acts, pntact'/> ## ## <Description> ## This operation should not be called by a user. It is documented however ## for purposes to extend or maintain the group actions package ## (the word <Q>package</Q> here refers to the &GAP; functionality for ## group actions, not to a &GAP; package). ## <P/> ## <Ref Oper="OrbitStabilizerAlgorithm"/> performs an orbit stabilizer ## algorithm for the group <A>G</A> acting with the generators <A>gens</A> ## via the generator images <A>gens</A> and the group action <A>act</A> on ## the element <A>pnt</A>. ## (For technical reasons <A>pnt</A> and <A>act</A> are put in one record ## with components <C>pnt</C> and <C>act</C> respectively.) ## <P/> ## The <A>pntact</A> record may carry a component <A>stabsub</A>. ## If given, this must be a subgroup stabilizing <E>all</E> points in the ## domain and can be used to abbreviate stabilizer calculations. ## <P/> ## The <A>pntact</A> component also may contain the boolean entry <C>onlystab</C> set ## to <K>true</K>. In this case the <C>orbit</C> component may be omitted from the ## result. ## <P/> ## The argument <A>Omega</A> (which may be replaced by <K>false</K> to be ignored) is ## the set within which the orbit is computed (once the orbit is the full ## domain, the orbit calculation may stop). If <A>blist</A> is given it must be ## a bit list corresponding to <A>Omega</A> in which elements which have been found ## already will be <Q>ticked off</Q> with <K>true</K>. (In particular, the entries ## for the orbit of <A>pnt</A> still must be all set to <K>false</K>). Again the ## remaining action domain (the bits set initially to <K>false</K>) can be ## used to stop if the orbit cannot grow any longer. ## Another use of the bit list is if <A>Omega</A> is an enumerator which can ## determine <Ref Oper="PositionCanonical"/> values very quickly. ## In this situation it can be ## worth to search images not in the orbit found so far, but via their ## position in <A>Omega</A> and use a the bit list to keep track whether the ## element is in the orbit found so far. ## </Description> ## </ManSection> ## <#/GAPDoc> ##
DeclareOperation( "OrbitStabilizerAlgorithm#O MaximalBlocks( <G>, <Omega>[, <seed>][, <gens>, <acts>][, <act>] )
[IsGroup,## The argument <A>Omega</A> (which may be replaced by <K>false</K> to be ignored) is##
DeclareGlobalFunction( "OrbitByPosOp" );
# AH, 5-feb-99 This function is neither documented not used. #DeclareGlobalFunction( "OrbitStabilizerListByGenerators" );
DeclareGlobalFunction( "## remaining action domain (the bits set initially to <K>false</K>) can## respect to inclusion) for the transitive (see
DeclareGlobalFunction( "StabilizerOfBlockNC" );
############################################################################# ## #O AbelianSubfactorAction(<G>,<M>,<N>) ## ## <#GAPDoc Label="AbelianSubfactorAction"> ## <ManSection> ## <Oper Name="AbelianSubfactorAction" Arg='G, M, N'/> ## ## <Description> ## Let <A>G</A> be a group and <M><A>M</A> \geq <A>N</A></M> be subgroups ## of a common parent that are normal under <A>G</A>, such that ## the subfactor <M><A>M</A>/<A>N</A></M> is elementary abelian. ## The operation <Ref Oper="AbelianSubfactorAction"/> returns a list ## <C>[ <A>phi</A>, <A>alpha</A>, <A>bas</A> ]</C> where ## <A>bas</A> is a list of elements of <A>M</A> which are representatives ## for a basis of <M><A>M</A>/<A>N</A></M>, ## <A>alpha</A> is a map from <A>M</A> into a <M>n</M>-dimensional row space ## over <M>GF(p)</M> where <M>[<A>M</A>:<A>N</A>] = p^n</M> that is the ## natural homomorphism of <A>M</A> by <A>N</A> with the quotient ## represented as an additive group. ## Finally <A>phi</A> is a homomorphism from <A>G</A> ## into <M>GL_n(p)</M> that represents the action of <A>G</A> on the factor ## <M><A>M</A>/<A>N</A></M>. ## <P/> ## Note: If only matrices for the action are needed, ## <Ref Func="LinearActionLayer"/> might be faster. ## <Example><![CDATA[ ## gap> g:=Group((1,8,10,7,3,5)(2,4,12,9,11,6), ## > (1,9,5,6,3,10)(2,11,12,8,4,7));; ## gap> c:=ChiefSeries(g);;List(c,Size); ## [ 96, 48, 16, 4, 1 ] ## gap> HasElementaryAbelianFactorGroup(c[3],c[4]); ## true ## gap> SetName(c[3],"my_group");; ## gap> a:=AbelianSubfactorAction(g,c[3],c[4]); ## [ [ (1,8,10,7,3,5)(2,4,12,9,11,6), (1,9,5,6,3,10)(2,11,12,8,4,7) ] -> ## [ <an immutable 2x2 matrix over GF2>, ## <an immutable 2x2 matrix over GF2> ], #A Earns( <xset> ) ## 2 ), function( e ) ... end, function( r ) ... end ), ## Pcgs([ (2,9,3,8)(4,11,5,10), (1,6,12,7)(4,10,5,11) ]) ] ## gap> mat:=Image(a[1],g); ## Group([ <an immutable 2x2 matrix over GF2>, ## <an immutable 2x2 matrix over GF2> ]) ## gap> Size(mat); ## 3 ## gap> e:=PreImagesRepresentative(a[2],[Z(2),0*Z(2)]); ## (2,9,3,8)(4,11,5,10) ## gap> e in c[3];e in c[4]; ## true ## false ## ]]></Example> ## </Description> ## </ManSection> ## <#/GAPDoc> ##
## <Heading>IsTransitive</Heading>
############################################################################# ## #F OnPoints( <pnt>, <g> ) ## ## <#GAPDoc Label="OnPoints"> ## <ManSection> ## <Func Name="OnPoints" Arg='pnt, g'/> ## ## <Description> ## <Index>conjugation</Index> ## <Index Subkey="by conjugation">action</Index> ## returns <C><A>pnt</A> ^ <A>g</A></C>. ## This is for example the action of a permutation group on points, ## or the action of a group on its elements via conjugation, ## that is, if both <A>pnt</A> and <A>g</A> are elements from a common group ## then <C><A>pnt</A> ^ <A>g</A></C> is equal to ## <A>g</A><M>^{{-1}}</M><C>*</C><A>pnt</A><C>*</C><A>g</A>. ## The action of a matrix group on vectors from the right is described by ## both <Ref Func="OnPoints"/> and <Ref Func="OnRight"/>. ## <Example><![CDATA[ ## gap> OnPoints( 1, (1,2,3) ); ## 2 ## gap> OnPoints( (1,2), (1,2,3) ); ## (2,3) ## gap> g:= Group( (1,2,3), (2,3,4) );; ## gap> Orbit( g, 1, OnPoints ); ## [ 1, 2, 3, 4 ] #P IsPrimitiveAffine( <xset> ) ## </Description> ## </ManSection> ## <#/GAPDoc> ##
############################################################################# ## #F OnRight( <pnt>, <g> ) ## ## <#GAPDoc Label="OnRight"> ## gap> OnTuples( [ (2,3), (1,2) ], (1,2,3) ); ## <Func Name="OnRight" Arg='pnt, g'/> ## ## <Description> ## returns <C><A>pnt</A> * <A>g</A></C>. ## This is for example the action of a group on its elements via right ## multiplication, ## or the action of a group on the cosets of a subgroup. ## The action of a matrix group on vectors from the right is described by ## both <Ref Func="OnPoints"/> and <Ref Func="OnRight"/>. ## <Example><![CDATA[ ## gap> OnRight( [ 1, 2 ], [ [ 1, 2 ], [ 3, 4 ] ] ); ## [ 7, 10 ] ## gap> OnRight( (1,2,3), (2,3,4) ); ## (1,3)(2,4) ## gap> g:= Group( (1,2,3), (2,3,4) );; ## gap> Orbit( g, (), OnRight ); ## [ (), (1,2,3), (2,3,4), (1,3,2), (1,3)(2,4), (1,2)(3,4), (2,4,3), ## (1,4,2), (1,4,3), (1,3,4), (1,2,4), (1,4)(2,3) ] ## ]]></Example> ## </Description> ## </ManSection> ## <#/GAPDoc> ##
############################################################################# ## #F OnLeftInverse( <pnt>, <g> ) ## ## <#GAPDoc Label="OnLeftInverse"> ## <ManSection> ## <Func Name="OnLeftInverse" Arg='pnt, g'/> ## ## <Description> ## returns <M><A>g</A>^{{-1}}</M> <C>* <A>pnt</A></C>. ## Forming the inverse is necessary to make this a proper action, ## as in &GAP; groups always act from the right. ## <P/> ## <Ref Func="OnLeftInverse"/> is used for example in the representation ## of a right coset as an external set ## (see <Ref Sect="External Sets"/>), ## that is, a right coset <M>Ug</M> is an external set for the group ## <M>U</M> acting on it via <Ref Func="OnLeftInverse"/>.) ## <Example><![CDATA[ ## ]]></Example> ## [ 0, 1/2 ] ## gap> OnLeftInverse( (1,2,3), (2,3,4) ); ## (1,2,4) ## gap> g:= Group( (1,2,3), (2,3,4) );; ## gap> Orbit( g, (), OnLeftInverse ); ## [ (), (1,3,2), (2,4,3), (1,2,3), (1,3)(2,4), (1,2)(3,4), (2,3,4), ## (1,2,4), (1,3,4), (1,4,3), (1,4,2), (1,4)(2,3) ] ## ]]></Example> ## </Description> ## </ManSection> ## <#/GAPDoc> ##
############################################################################# ## #F OnSets( <set>, <g> ) ## ## <#GAPDoc Label="OnSets"> ## <ManSection> ## <Func Name="OnSets" Arg='set, g'/> ## ## <Description> ## <Index Subkey="on sets">action</Index> ## <Index Subkey="on blocks">action</Index> ## Let <A>set</A> be a proper set ## (see <Ref Sect="Sorted Lists and Sets"/>). ## <Ref Func="OnSets"/> returns the proper set formed by the images ## of all points <M>x</M> of <A>set</A> via the action function ## <Ref Func="OnPoints"/>, applied to <M>x</M> and <A>g</A>. ## <P/> ## <Ref Func="OnSets"/> is for example used to compute the action of ## a permutation group on blocks. ## <P/> ## (<Ref Func="OnTuples"/> is an action on lists that preserves the ordering ## of entries.) ## <Example><![CDATA[ ## gap> OnSets( [ 1, 3 ], (1,2,3) ); ## [ 1, 2 ] ## gap> OnSets( [ (2,3), (1,2) ], (1,2,3) ); ## [ (2,3), (1,3) ] ## gap> g:= Group( (1,2,3), (2,3,4) );; ## gap> Orbit( g, [ 1, 2 ], OnSets ); ## [ [ 1, 2 ], [ 2, 3 ], [ 1, 3 ], [ 3, 4 ], [ 1, 4 ], [ 2, 4 ] ] ## ]]></Example> ############################################################################# ## </ManSection> ## <#/GAPDoc> ##
############################################################################# ## #F OnTuples( <tup>, <g> ) ## ## <#GAPDoc Label="OnTuples"> ## <ManSection> ## <Func Name="OnTuples" Arg='tup, g'/> ## ## <Description> ## Let <A>tup</A> be a list. ## <Ref Func="OnTuples"/> returns the list formed by the images ## of all points <M>x</M> of <A>tup</A> via the action function ## <Ref Func="OnPoints"/>, applied to <M>x</M> and <A>g</A>. ## <P/> ## (<Ref Func="OnSets"/> is an action on lists that additionally sorts ## the entries of the result.) ## <Example><![CDATA[ ## gap> OnTuples( [ 1, 3 ], (1,2,3) ); ## [ 2, 1 ] ## gap> OnTuples( [ (2,3), (1,2) ], (1,2,3) ); ## [ (1,3), (2,3) ] ## gap> g:= Group( (1,2,3), (2,3,4) );; ## gap> Orbit( g, [ 1, 2 ], OnTuples ); ## [ [ 1, 2 ], [ 2, 3 ], [ 1, 3 ], [ 3, 1 ], [ 3, 4 ], [ 2, 1 ], ## [ 1, 4 ], [ 4, 1 ], [ 4, 2 ], [ 3, 2 ], [ 2, 4 ], [ 4, 3 ] ] ## ]]></Example> ## </Description> ## </ManSection> ## <#/GAPDoc> ##
############################################################################# ## #F OnPairs( <tup>, <g> ) ## ## <#GAPDoc Label="OnPairs"> ## <ManSection> ## <Func Name="OnPairs" Arg='tup, g'/> ## ## <Description> ## is a special case of <Ref Func="OnTuples"/> for lists <A>tup</A> ## of length 2. ## </Description> ## </ManSection> ## <#/GAPDoc> ##
############################################################################# ## #F OnLines( <vec>, <g> ) ## ## <#GAPDoc Label="OnLines"> ## <ManSection> ## <Func Name="OnLines" Arg='vec, g'/> ## ## <Description> ## Let <A>vec</A> be a <E>normed</E> row vector, that is, ## its first nonzero entry is normed to the identity of the relevant field, ## see <Ref Attr="NormedRowVector"/>. ## The function <Ref Func="OnLines"/> returns the row vector obtained from ## first multiplying <A>vec</A> from the right with <A>g</A> ## (via <Ref Func="OnRight"/>) and then normalizing the resulting row vector ## by scalar multiplication from the left. ## <P/> ## This action corresponds to the projective action of a matrix group ## on one-dimensional subspaces. ## <P/> ## If <A>vec</A> is a zero vector or is not normed then ## an error is triggered ## (see <Ref Sect="Action on canonical representatives"/>). ## <P/> ## <Example><![CDATA[ ## gap> OnLines( [ 1, 2 ], [ [ 1, 2 ], [ 3, 4 ] ] ); ## [ 1, 10/7 ] ## gap> gl:=GL(2,5);;v:=[1,0]*Z(5)^0; ## [ Z(5)^0, 0*Z(5) ] ## gap> h:=Action(gl,Orbit(gl,v,OnLines),OnLines); ## Group([ (2,3,5,6), (1,2,4)(3,6,5) ]) ## ]]></Example> ## </Description> ## </ManSection> ## <#/GAPDoc> ##
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
############################################################################# ## #F OnSetsSets( <set>, <g> ) ## ## <#GAPDoc Label="OnSetsSets"> ## <ManSection> ## <Func Name="OnSetsSets" Arg='set, g'/> ## ## <Description> ## implements the action on sets of sets. ## For the special case that the sets are pairwise disjoint, ## it is possible to use <Ref Func="OnSetsDisjointSets"/>. ## <A>set</A> must be a sorted list whose entries are again sorted lists, ## otherwise an error is triggered ## (see <Ref Sect="Action on canonical representatives"/>). ## <Example><![CDATA[ ## gap> OnSetsSets( [ [ 1, 2 ], [ 3, 4 ] ], (1,2,3) ); ## [ [ 1, 4 ], [ 2, 3 ] ] ## gap> g:= Group( (1,2,3), (2,3,4) );; ## gap> Orbit( g, [ [ 1, 2 ], [ 3, 4 ] ], OnSetsSets ); ## [ [ [ 1, 2 ], [ 3, 4 ] ], [ [ 1, 4 ], [ 2, 3 ] ], ## [ [ 1, 3 ], [ 2, 4 ] ] ] ## ]]></Example> ## </Description> ## </ManSection> ## <#/GAPDoc> ##
DeclareGlobalFunction( "java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
############################################################################# ## #F OnSetsDisjointSets( <set>, <g> ) ## ## <#GAPDoc Label="OnSetsDisjointSets"> ## <ManSection> ## <Func Name="OnSetsDisjointSets" Arg='set, g'/> ## ## <Description> ## implements the action on sets of pairwise disjoint sets ## (see also <Ref Func="OnSetsSets"/>). ## <A>set</A> must be a sorted list whose entries are again sorted lists, ## otherwise an error is triggered ## (see <Ref Sect="Action on canonical representatives"/>). ## </Description> ## </ManSection> ## <#/GAPDoc> ##
DeclareGlobalFunction## gap> RepresentativeAction(g,(1,2,3),(2,3,4));
############################################################################# ## #O DomainForAction( <pnt>, <acts>, <act> ) ## ## <ManSection> ## <Oper Name="DomainForAction" Arg='pnt, acts, act'/> ## ## <Description> ## returns a domain which will contain the orbit of <A>pnt</A> under the action ## <A>act</A> of the group ## generated by <A>acts</A>. (Such a domain can be helpful for obtaining ## a dictionary.) ## The default method returns <K>fail</K> to indicate that no special domain is ## defined, a special method exists for matrix groups over finite fields. ## </Description> ## </ManSection> ##
DomainForActionIsObjectIsListOrCollectionjava.lang.StringIndexOutOfBoundsException: Range [75, 74) out of bounds for length 77
Messung V0.5 in Prozent
¤ Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.0.67Bemerkung:
¤
Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.
Bemerkung:
Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.
