documentation:master:group

no way to compare when less than two revisions

Differences

This shows you the differences between two versions of the page.


—documentation:master:group [2023/06/10 04:43] (current) – created - external edit 127.0.0.1
Line 1: Line 1:
 +====== application group ======
 + The application group provides basic functionality for working with permutation groups.  An object of type ''[[.:group:Group |Group]]'' records the abstract properties of the groups  that do not depend on any particular representation, such as [[.:group:Group#ORDER |ORDER]], [[.:group:Group#CHARACTER_TABLE |CHARACTER_TABLE]] and [[.:group:Group#CONJUGACY_CLASS_SIZES |CONJUGACY_CLASS_SIZES]]. Moreover, it can contain several subobjects of type ''[[.:group:PermutationAction |PermutationAction]]'', ''[[.:group:PermutationActionOnSets |PermutationActionOnSets]]''  or ''[[.:group:ImplicitActionOnSets |ImplicitActionOnSets]]'' that encode representations of the group. (We use the terms //action// and //representation// interchangeably).  If the group object is not contained inside a ''[[.:polytope:Cone |Cone]]'' or ''[[.:polytope:Polytope |Polytope]]'', the representation in question is encoded as a ''[[.:group:Group#PERMUTATION_ACTION |PERMUTATION_ACTION]]'', ''[[.:group:Group#SET_ACTION |SET_ACTION]]'' or  ''[[.:group:Group#IMPLICIT_SET_ACTION |IMPLICIT_SET_ACTION]]'', otherwise it may be encoded more specifically as a RAY_ACTION, FACET_ACTION, COORDINATE_ACTION, etc.  Different representations of the same group are convertible among each other either via specific rules,  or by using the function ''[[.:group#induced_action |induced_action]]'', for example.
 +
 +imports from:
 +    * application [[.:common|common]]
 +
 +===== Objects =====
 +  ** ''[[.:group:Action |Action]]'':\\  parametrized object used for encoding group actions (representations).
 +     * //GeneratorType// is 
 +       * ''Array<Int>'' for permutation groups, or 
 +       * ''Matrix<Scalar>'' for matrix groups.
 +     * //DomainType// is 
 +       * ''Int'' for permutation groups,
 +       * ''Vector<Scalar> ''for matrix groups acting on facets or vertices,
 +       * ''Set<Int>'' or ''Bitset'' for groups acting on simplices,
 +       * ''IncidenceMatrix'' for groups acting on (maximal) cones of a fan
 +     * //OrbitGeneratorScalarType// is the type of the entries of vectors that generate a geometric orbit; default ''Rational''
 +  ** ''[[.:group:Group |Group]]'':\\  Object encoding a finite group.
 +  ** ''[[.:group:ImplicitActionOnSets |ImplicitActionOnSets]]'':\\  derived object encoding an action of a permutation group on a collection of sets, but where only one representative of each orbit is stored explicitly
 +  ** ''[[.:group:LayeredPermutationAction |LayeredPermutationAction]]'':\\  object for encoding the separate actions of a group on a collection of sets, induced by the same generators
 +  ** ''[[.:group:MatrixActionOnVectors |MatrixActionOnVectors]]'':\\  derived object for matrix groups
 +  ** ''[[.:group:PermutationAction |PermutationAction]]'':\\  derived objects for permutation representations
 +  ** ''[[.:group:PermutationActionOnSets |PermutationActionOnSets]]'':\\  derived object for permuting collections of sets
 +
 +===== Functions =====
 +
 +==== Orbits ====
 + These functions are concerned with orbits in groups.
 +----
 +{{anchor:are_in_same_orbit:}}
 +  ?  **''are_in_same_orbit([[.:group:PermutationAction |PermutationAction]] a, [[.:common#Vector |Vector]] v1, [[.:common#Vector |Vector]] v2)''**
 +  :: Checks whether vectors //v1// and //v2// are in the same orbit with respect to the (coordinate) action of //group//.
 +    ? Parameters:
 +    :: ''[[.:group:PermutationAction |PermutationAction]]'' ''a'': the permutation group acting on coordinates
 +    :: ''[[.:common#Vector |Vector]]'' ''v1''
 +    :: ''[[.:common#Vector |Vector]]'' ''v2''
 +    ? Returns:
 +    :''[[.:common#Bool |Bool]]''
 +
 +
 +----
 +{{anchor:orbit:}}
 +  ?  **''orbit<action_type>([[.:common#Array |Array]] G, Any O)''**
 +  :: The orbit of an object //O// under a group generated by //G//. The action_type defines how the elements of the group work on //O//.
 +    ? Type Parameters:
 +    :: ''action_type'': controls the ''[[.:group#on_container |on_container]]'' the default. The group acts on the elements of a given container, which also could be container. ''[[.:group#on_elements |on_elements]]'' for this the group will act on the deepest elements inside a given container with respect to the type of the group elements ''[[.:group#on_rows |on_rows]]'' For this //O// should be a matrix so that the group can act on the rows of //O//. ''[[.:group#on_cols |on_cols]]'' like ''[[.:group#on_rows |on_rows]]'' this require a matrix so that the group can act on its columns ''[[.:group#on_nonhomog_cols |on_nonhomog_cols]]'' also require that //O// is a matrix on whose columns the group generated by //G// acts. The 0-th column stay fixed.
 +    ? Parameters:
 +    :: ''[[.:common#Array |Array]]'' ''G'': Group generators
 +    :: ''Any'' ''O'': (mostly Array, Vector, Matrix or Set)
 +    ? Returns:
 +    :''[[.:common#Set |Set]]<Any>''
 +    ? Example:
 +    :: <code perl> > $permutationgroup = new Array<Array<Int>>([[1,2,3,0]]);
 + > $set = new Set<Set<Int>>([[0,1],[2,3]]);
 + > print orbit<on_elements>($permutationgroup, $set);
 + {{{0 1} {2 3}} {{0 3} {1 2}}}
 +</code>
 +  ?  **''orbit<action_type>([[.:group:Group |Group]] G, Any C)''**
 +  :: The orbit of a container //C// under a group //G//.
 +    ? Type Parameters:
 +    :: ''action_type'': by default ''[[.:group#on_container |on_container]]'' can also be ''[[.:group#on_elements |on_elements]]'', ''[[.:group#on_rows |on_rows]]'', ''[[.:group#on_cols |on_cols]]'' or ''[[.:group#on_nonhomog_cols |on_nonhomog_cols]]''. Call help "<action_type>"; for more information about this.
 +    ? Parameters:
 +    :: ''[[.:group:Group |Group]]'' ''G''
 +    :: ''Any'' ''C''
 +    ? Returns:
 +    :''[[.:common#Set |Set]]<Any>''
 +  ?  **''orbit<Scalar>([[.:common#Array |Array]]<[[.:common#Matrix |Matrix]]<Scalar%%>>%% G, [[.:common#Vector |Vector]]<Scalar> V)''**
 +  :: The orbit of a vector //V// under a group generated by //G//.
 +    ? Type Parameters:
 +    :: ''Scalar'': S the number type
 +    ? Parameters:
 +    :: ''[[.:common#Array |Array]]<[[.:common#Matrix |Matrix]]<Scalar%%>>%%'' ''G'': Generators of the group
 +    :: ''[[.:common#Vector |Vector]]<Scalar>'' ''V''
 +    ? Returns:
 +    :''[[.:common#Set |Set]]''
 +
 +
 +----
 +{{anchor:orbit_permlib:}}
 +  ?  **''orbit_permlib([[.:group:PermutationAction |PermutationAction]] G, [[.:common#Set |Set]] S)''**
 +  :: The orbit of a set //S// under a group defined by //G//.
 +    ? Parameters:
 +    :: ''[[.:group:PermutationAction |PermutationAction]]'' ''G''
 +    :: ''[[.:common#Set |Set]]'' ''S''
 +    ? Returns:
 +    :''[[.:common#Set |Set]]''
 +    ? Example:
 +    :: <code perl> > $G=new Group(PERMUTATION_ACTION=>(new PermutationAction(GENERATORS=>[[1,2,0]])));
 + > print $G->PERMUTATION_ACTION->ALL_GROUP_ELEMENTS;
 + 0 1 2
 + 1 2 0
 + 2 0 1
 +</code>
 +    :: <code perl> > $S=new Set<Int>(1,2);
 + > print orbit_permlib($G->PERMUTATION_ACTION, $S);
 + {{0 1} {0 2} {1 2}}
 +</code>
 +  ?  **''orbit_permlib([[.:group:PermutationAction |PermutationAction]] G, [[.:common#Set |Set]]<[[.:common#Set |Set]]> S)''**
 +  :: The orbit of a set //S// of sets under a group given by //G//.
 +    ? Parameters:
 +    :: ''[[.:group:PermutationAction |PermutationAction]]'' ''G''
 +    :: ''[[.:common#Set |Set]]<[[.:common#Set |Set]]>'' ''S''
 +    ? Returns:
 +    :''[[.:common#Set |Set]]''
 +    ? Example:
 +    :: <code perl> > $G=new PermutationAction(new PermutationAction(GENERATORS=>[[2,0,1]]));
 + > print $G->ALL_GROUP_ELEMENTS;
 + 0 1 2
 + 2 0 1
 + 1 2 0
 +</code>
 +    :: <code perl> > $S=new Set<Set<Int>>(new Set<Int>(1,2), new Set<Int>(0,2));
 + > print orbit_permlib($G, $S);
 + {{{0 1} {0 2}} {{0 1} {1 2}} {{0 2} {1 2}}}
 +</code>
 +
 +
 +----
 +{{anchor:orbit_representatives:}}
 +  ?  **''orbit_representatives([[.:common#Array |Array]]<GeneratorType> G)''**
 +  :: The indices of one representative for each orbit under the group generated by //G//.
 +    ? Parameters:
 +    :: ''[[.:common#Array |Array]]<GeneratorType>'' ''G'': Group generators
 +    ? Returns:
 +    :''[[.:common#Array |Array]]<[[.:common#Int |Int]]>''
 +
 +
 +----
 +{{anchor:orbits_in_orbit_order:}}
 +  ?  **''orbits_in_orbit_order([[.:group:PermutationAction |PermutationAction]] a, [[.:common#Matrix |Matrix]] M)''**
 +  :: Computes the orbit of the rows of the matrix //mat// under the permutation action on coordinates //action//.
 +    ? Parameters:
 +    :: ''[[.:group:PermutationAction |PermutationAction]]'' ''a'': an action of a group of coordinate permutations
 +    :: ''[[.:common#Matrix |Matrix]]'' ''M'': some input vectors
 +    ? Returns:
 +    :''[[.:common#List |List]]''
 +
 +
 +----
 +{{anchor:orbits_of_action:}}
 +  ?  **''orbits_of_action([[.:group:PermutationAction |PermutationAction]] a)''**
 +  :: Computes the orbits of the basic set under //a//. 
 +    ? Parameters:
 +    :: ''[[.:group:PermutationAction |PermutationAction]]'' ''a'': a permutation action of a group
 +    ? Returns:
 +    :''[[.:common#Array |Array]]<[[.:common#Set |Set]]<[[.:common#Int |Int]]%%>>%%''
 +
 +
 +----
 +{{anchor:orbits_of_coordinate_action:}}
 +  ?  **''orbits_of_coordinate_action([[.:group:PermutationAction |PermutationAction]] a, [[.:common#Matrix |Matrix]]<Scalar> M)''**
 +  :: Computes the orbits of the vectors (homogenized) of the rows of a matrix //M// by permuting the coordinates of the vectors (skipping the homogenizing coordinate). The group must act on the set of vectors, and the rows of the matrix must contain the entire orbit.
 +    ? Parameters:
 +    :: ''[[.:group:PermutationAction |PermutationAction]]'' ''a'': an action of a group acting by permuting the coordinates
 +    :: ''[[.:common#Matrix |Matrix]]<Scalar>'' ''M'': a matrix on whose columns the group acts by     coordinate permutation
 +    ? Returns:
 +    :''[[.:common#Array |Array]]<[[.:common#Set |Set]]<[[.:common#Int |Int]]%%>>%%''
 +
 +
 +----
 +{{anchor:orbits_of_induced_action:}}
 +  ?  **''orbits_of_induced_action([[.:group:PermutationAction |PermutationAction]] a, [[.:common#IncidenceMatrix |IncidenceMatrix]] I)''**
 +  :: Computes the orbits of a set on which an action is induced. The incidences between the domain elements and the elements in the set are given by an incidence matrix //inc//.
 +    ? Parameters:
 +    :: ''[[.:group:PermutationAction |PermutationAction]]'' ''a'': an action of a group
 +    :: ''[[.:common#IncidenceMatrix |IncidenceMatrix]]'' ''I'': the incidences between domain elements and elements on which an action is induced
 +    ? Returns:
 +    :''[[.:common#Array |Array]]<[[.:common#Set |Set]]<[[.:common#Int |Int]]%%>>%%''
 +
 +
 +----
 +
 +==== Producing a group ====
 + With these clients you can produce objects of type ''[[.:group:Group |Group]]'' -- groups from certain parameterized families, as stabilizers of sets in other groups or from different kinds of cycle notations.
 +----
 +{{anchor:alternating_group:}}
 +  ?  **''alternating_group([[.:common#Int |Int]] d)''**
 +  :: Constructs an __alternating group__ of given degree //d//.
 +    ? Parameters:
 +    :: ''[[.:common#Int |Int]]'' ''d'': degree of the alternating group
 +    ? Returns:
 +    :''[[.:group:Group |Group]]''
 +
 +
 +----
 +{{anchor:cube_group:}}
 +  ?  **''cube_group([[.:common#Int |Int]] d)''**
 +  :: Constructs the symmetry group of a d-cube, acting on vertices, for 1 <= d <= 6 (for the moment), along with the corresponding character table and conjugacy class representatives.
 +    ? Parameters:
 +    :: ''[[.:common#Int |Int]]'' ''d'': the dimension of the cube
 +    ? Returns:
 +    :''[[.:group:Group |Group]]''
 +    ? Example:
 +    :: The following calculates the orbits of the vertices on a cube.
 +    :: <code perl> > $g = cube_group(3);
 + > print $g->PERMUTATION_ACTION->ORBITS;
 + {0 1 2 3 4 5 6 7}
 +</code>
 +
 +
 +----
 +{{anchor:cyclic_group:}}
 +  ?  **''cyclic_group([[.:common#Int |Int]] d)''**
 +  :: Constructs a __cyclic group__ of given degree //d//.
 +    ? Parameters:
 +    :: ''[[.:common#Int |Int]]'' ''d'': degree of the cyclic group
 +    ? Returns:
 +    :''[[.:group:Group |Group]]''
 +
 +
 +----
 +{{anchor:dihedral_group:}}
 +  ?  **''dihedral_group([[.:common#Int |Int]] o)''**
 +  :: Constructs a __dihedral group__ of a given order //o//. If the order is 2, 4, 6, 8, 10, 12, 16, 20 or 24, the character table is exact, otherwise some entries are mutilated rational approximations of algebraic numbers.
 +    ? Parameters:
 +    :: ''[[.:common#Int |Int]]'' ''o'': order of the dihedral group that acts on a regular //(o/2)//-gon
 +    ? Returns:
 +    :''[[.:group:Group |Group]]''
 +
 +
 +----
 +{{anchor:group_from_cyclic_notation0:}}
 +  ?  **''group_from_cyclic_notation0([[.:common#String |String]] generators)''**
 +  :: Constructs a group from a string with generators in cyclic notation. All numbers in the string are 0-based. Example: "(0,2)(1,3)"
 +    ? Parameters:
 +    :: ''[[.:common#String |String]]'' ''generators'': the group generators in cyclic notation
 +    ? Returns:
 +    :''[[.:group:Group |Group]]''
 +    ? Example:
 +    :: The following constructs a group with 2 generators.
 +    :: <code perl> > $g = group_from_cyclic_notation0("(0,2)(1,3),(0,3)");
 + > print $g->PERMUTATION_ACTION->GENERATORS;
 + 2 3 0 1
 + 3 1 2 0
 +</code>
 +
 +
 +----
 +{{anchor:group_from_cyclic_notation1:}}
 +  ?  **''group_from_cyclic_notation1([[.:common#String |String]] generators)''**
 +  :: Constructs a group from a string with generators in cyclic notation. All numbers in the string are 1-based.
 +    ? Parameters:
 +    :: ''[[.:common#String |String]]'' ''generators'': the group generators in cyclic notation
 +    ? Returns:
 +    :''[[.:group:Group |Group]]''
 +    ? Example:
 +    :: The following constructs a group with 2 generators.
 +    :: <code perl> > $g = group_from_cyclic_notation1("(1,3)(2,4),(1,4)");
 + > print $g->PERMUTATION_ACTION->GENERATORS;
 + 2 3 0 1
 + 3 1 2 0
 +</code>
 +
 +
 +----
 +{{anchor:group_from_permlib_cyclic_notation:}}
 +  ?  **''group_from_permlib_cyclic_notation([[.:common#Array |Array]]<[[.:common#String |String]]> gens, [[.:common#Int |Int]] degree)''**
 +  :: Constructs a Group from generators given in permlib cyclic notation, i.e., indices separated by whitespace, generators separated by commas.
 +    ? Parameters:
 +    :: ''[[.:common#Array |Array]]<[[.:common#String |String]]>'' ''gens'': generators of the permutation group in permlib cyclic notation
 +    :: ''[[.:common#Int |Int]]'' ''degree'': the degree of the permutation group
 +    ? Returns:
 +    :''[[.:group:Group |Group]]''
 +
 +
 +----
 +{{anchor:stabilizer_of_set:}}
 +  ?  **''stabilizer_of_set([[.:group:PermutationAction |PermutationAction]] a, [[.:common#Set |Set]] S)''**
 +  :: Computes the subgroup of //group// which stabilizes the given set of indices //set//.
 +    ? Parameters:
 +    :: ''[[.:group:PermutationAction |PermutationAction]]'' ''a'': the action of a permutation group
 +    :: ''[[.:common#Set |Set]]'' ''S'': the set to be stabilized
 +    ? Returns:
 +    :''[[.:group:Group |Group]]''
 +
 +
 +----
 +{{anchor:stabilizer_of_vector:}}
 +  ?  **''stabilizer_of_vector([[.:group:PermutationAction |PermutationAction]] a, [[.:common#Vector |Vector]] v)''**
 +  :: Computes the subgroup of //G// which stabilizes the given vector //v//.
 +    ? Parameters:
 +    :: ''[[.:group:PermutationAction |PermutationAction]]'' ''a'': the action of a permutation group
 +    :: ''[[.:common#Vector |Vector]]'' ''v'': the vector to be stabilized
 +    ? Returns:
 +    :''[[.:group:Group |Group]]''
 +
 +
 +----
 +{{anchor:symmetric_group:}}
 +  ?  **''symmetric_group([[.:common#Int |Int]] d)''**
 +  :: Constructs a __symmetric group__ of given degree //d//.
 +    ? Parameters:
 +    :: ''[[.:common#Int |Int]]'' ''d'': degree of the symmetric group
 +    ? Returns:
 +    :''[[.:group:Group |Group]]''
 +
 +
 +----
 +
 +==== Symmetry ====
 + These functions are dealing with symmetries.
 +----
 +{{anchor:all_group_elements:}}
 +  ?  **''all_group_elements<Scalar>([[.:group:MatrixActionOnVectors |MatrixActionOnVectors]]<Scalar> action)''**
 +  :: Compute all elements of a given group, expressed as a matrix group action.
 +    ? Type Parameters:
 +    :: ''Scalar'': S the underlying number type
 +    ? Parameters:
 +    :: ''[[.:group:MatrixActionOnVectors |MatrixActionOnVectors]]<Scalar>'' ''action'': the action of a permutation group
 +    ? Returns:
 +    :''[[.:common#Set |Set]]<[[.:common#Matrix |Matrix]]<Scalar%%>>%%''
 +    ? Example:
 +    :: To generate all elements of the regular representation of S_3, type
 +    :: <code perl> > print all_group_elements(symmetric_group(3)->REGULAR_REPRESENTATION);
 + <0 0 1
 + 0 1 0
 + 1 0 0
 + >
 + <0 0 1
 + 1 0 0
 + 0 1 0
 + >
 + <0 1 0
 + 0 0 1
 + 1 0 0
 + >
 + <0 1 0
 + 1 0 0
 + 0 0 1
 + >
 + <1 0 0
 + 0 0 1
 + 0 1 0
 + >
 + <1 0 0
 + 0 1 0
 + 0 0 1
 + >
 +</code>
 +
 +
 +----
 +{{anchor:automorphism_group:}}
 +  ?  **''automorphism_group([[.:common#GraphAdjacency |GraphAdjacency]] graph)''**
 +  :: Find the automorphism group of the graph.
 +    ? Parameters:
 +    :: ''[[.:common#GraphAdjacency |GraphAdjacency]]'' ''graph''
 +    ? Returns:
 +    :''[[.:group:Group |Group]]''
 +  ?  **''automorphism_group([[.:common#IncidenceMatrix |IncidenceMatrix]] I, [[.:common#Bool |Bool]] on_rows)''**
 +  :: Find the automorphism group of the incidence matrix.
 +    ? Parameters:
 +    :: ''[[.:common#IncidenceMatrix |IncidenceMatrix]]'' ''I''
 +    :: ''[[.:common#Bool |Bool]]'' ''on_rows'': true (default) for row action
 +    ? Returns:
 +    :''[[.:group:Group |Group]]''
 +
 +
 +----
 +{{anchor:col_to_row_action:}}
 +  ?  **''col_to_row_action([[.:common#Matrix |Matrix]] M, [[.:common#Array |Array]]<[[.:common#Array |Array]]> p)''**
 +  :: If the action of some permutations on the entries of the rows  maps each row of a matrix to another row we obtain an induced action on the set of rows of the matrix. Considering the rows as points this corresponds to the action on the points induced by the action of some permutations on the coordinates.
 +    ? Parameters:
 +    :: ''[[.:common#Matrix |Matrix]]'' ''M''
 +    :: ''[[.:common#Array |Array]]<[[.:common#Array |Array]]>'' ''p'': the permutations acting of the rows
 +    ? Returns:
 +    :''[[.:common#Array |Array]]<[[.:common#Array |Array]]>''
 +
 +
 +----
 +{{anchor:conjugacy_class:}}
 +  ?  **''conjugacy_class<Element>([[.:group:Action |Action]] action, Element e)''**
 +  :: Compute the conjugacy class of a group element under a given action
 +    ? Type Parameters:
 +    :: ''Element'': E the underlying element type
 +    ? Parameters:
 +    :: ''[[.:group:Action |Action]]'' ''action'': the action of the group
 +    :: ''Element'' ''e'': the element to be acted upon
 +    ? Returns:
 +    :''[[.:common#Set |Set]]<Element>''
 +  ?  **''conjugacy_class<Scalar>([[.:group:MatrixActionOnVectors |MatrixActionOnVectors]]<Scalar> action, [[.:common#Matrix |Matrix]]<Scalar> e)''**
 +  :: Compute the conjugacy class of a group element under a given action
 +    ? Type Parameters:
 +    :: ''Scalar'': E the underlying number type
 +    ? Parameters:
 +    :: ''[[.:group:MatrixActionOnVectors |MatrixActionOnVectors]]<Scalar>'' ''action'': the action of the group
 +    :: ''[[.:common#Matrix |Matrix]]<Scalar>'' ''e'': the element to be acted upon
 +    ? Returns:
 +    :''[[.:common#Set |Set]]<[[.:common#Matrix |Matrix]]<Scalar%%>>%%''
 +
 +
 +----
 +{{anchor:group_left_multiplication_table:}}
 +  ?  **''group_left_multiplication_table([[.:group:Group |Group]] G)''**
 +  :: Calculate the left multiplication table of a group action, in which GMT[g][h] = hg
 +    ? Parameters:
 +    :: ''[[.:group:Group |Group]]'' ''G''
 +    ? Options:
 +    : 
 +    :: ''[[.:common#String |String]]'' ''action'': which action to take for the calculation; default PERMUTATION_ACTION
 +    ? Returns:
 +    :''[[.:common#Array |Array]]<[[.:common#Array |Array]]<[[.:common#Int |Int]]%%>>%%''
 +
 +
 +----
 +{{anchor:group_right_multiplication_table:}}
 +  ?  **''group_right_multiplication_table([[.:group:Group |Group]] G)''**
 +  :: Calculate the right multiplication table of a group action, in which GMT[g][h] = gh
 +    ? Parameters:
 +    :: ''[[.:group:Group |Group]]'' ''G''
 +    ? Options:
 +    : 
 +    :: ''[[.:common#String |String]]'' ''action'': which action to take for the calculation; default PERMUTATION_ACTION
 +    ? Returns:
 +    :''[[.:common#Array |Array]]<[[.:common#Array |Array]]<[[.:common#Int |Int]]%%>>%%''
 +
 +
 +----
 +{{anchor:implicit_character:}}
 +  ?  **''implicit_character([[.:group:ImplicitActionOnSets |ImplicitActionOnSets]] A)''**
 +  :: Calculate character of an implicit action
 +    ? Parameters:
 +    :: ''[[.:group:ImplicitActionOnSets |ImplicitActionOnSets]]'' ''A'': the given action
 +    ? Returns:
 +    :''[[.:common#Array |Array]]<[[.:common#Int |Int]]>''
 +
 +
 +----
 +{{anchor:induce_implicit_action:}}
 +  ?  **''induce_implicit_action([[.:group:PermutationAction |PermutationAction]] original_action, [[.:common#String |String]] property)''**
 +  :: Construct an implicit action of the action induced on a collection of sets. Only a set of orbit representatives is stored, not the full induced action.
 +    ? Parameters:
 +    :: ''[[.:group:PermutationAction |PermutationAction]]'' ''original_action'': the action of the group on indices
 +    :: ''[[.:common#String |String]]'' ''property'': the name of a property that describes an ordered list of sets on which the group should act
 +    ? Returns:
 +    :''[[.:group:ImplicitActionOnSets |ImplicitActionOnSets]]''
 +    ? Example:
 +    :: To construct the implicit action of the symmetry group of a cube on its maximal simplices, type:
 +    :: <code perl> > $c=cube(3, group=>1, character_table=>0);
 + > group::induce_implicit_action($c, $c->GROUP->VERTICES_ACTION, $c->GROUP->REPRESENTATIVE_MAX_INTERIOR_SIMPLICES, "MAX_INTERIOR_SIMPLICES")->properties();
 + name: induced_implicit_action_of_ray_action_on_MAX_INTERIOR_SIMPLICES
 + type: ImplicitActionOnSets
 + description: induced from ray_action on MAX_INTERIOR_SIMPLICES
 +
 + DOMAIN_NAME
 + MAX_INTERIOR_SIMPLICES
 +
 + EXPLICIT_ORBIT_REPRESENTATIVES
 + {0 1 2 4}
 + {0 1 2 5}
 + {0 1 2 7}
 + {0 3 5 6}
 +
 +
 + GENERATORS
 + 1 0 3 2 5 4 7 6
 + 0 2 1 3 4 6 5 7
 + 0 1 4 5 2 3 6 7
 +</code>
 +
 +
 +----
 +{{anchor:induce_set_action:}}
 +  ?  **''induce_set_action([[.:polytope:Cone |Cone]] c, [[.:group:PermutationAction |PermutationAction]] a, [[.:common#String |String]] domain)''**
 +  :: Construct the induced action of a permutation action on a property that is an ordered collection of sets, such as MAX_INTERIOR_SIMPLICES.
 +    ? Parameters:
 +    :: ''[[.:polytope:Cone |Cone]]'' ''c'': the cone or polytope
 +    :: ''[[.:group:PermutationAction |PermutationAction]]'' ''a'': a permutation action on, for example, the vertex indices
 +    :: ''[[.:common#String |String]]'' ''domain'': the property the induced action should act upon
 +    ? Returns:
 +    :''[[.:group:PermutationActionOnSets |PermutationActionOnSets]]''
 +    ? Example:
 +    :: <code perl> > $c=cube(3, group=>1, character_table=>0);
 + > group::induce_set_action($c, $c->GROUP->VERTICES_ACTION, "MAX_INTERIOR_SIMPLICES")->properties();
 + name: induced_set_action_of_ray_action_on_MAX_INTERIOR_SIMPLICES
 + type: PermutationActionOnSets
 + description: induced from ray_action on MAX_INTERIOR_SIMPLICES
 +
 + DOMAIN_NAME
 + MAX_INTERIOR_SIMPLICES
 +
 + GENERATORS
 + 5 4 7 6 1 0 3 2 11 10 9 8 30 29 32 31 38 40 39 41 33 36 35 34 37 43 42 45 44 13 12 15 14 20 23 22 21 24 16 18 17 19 26 25 28 27 49 48 47 46 55 54 57 56 51 50 53 52
 + 0 2 1 3 12 14 13 15 16 17 18 19 4 6 5 7 8 9 10 11 21 20 22 24 23 25 27 26 28 29 31 30 32 34 33 35 37 36 46 47 48 49 50 52 51 53 38 39 40 41 42 44 43 45 54 56 55 57
 + 0 4 8 9 1 5 10 11 2 3 6 7 16 20 25 26 12 17 21 27 13 18 22 23 28 14 15 19 24 33 38 42 43 29 34 35 39 44 30 36 40 45 31 32 37 41 50 51 54 55 46 47 52 56 48 49 53 57
 +</code>
 +
 +
 +----
 +{{anchor:induced_action:}}
 +  ?  **''induced_action([[.:group:PermutationAction |PermutationAction]] a, [[.:common#Array |Array]]<[[.:common#Set |Set]]<[[.:common#Int |Int]]%%>>%% domain)''**
 +  :: Given a permutation action //a// on some indices and an ordered list //domain// of sets containing these indices, we ask for the permutation action induced by //a// on this list of sets.
 +    ? Parameters:
 +    :: ''[[.:group:PermutationAction |PermutationAction]]'' ''a'': a permutation action that acts on some indices
 +    :: ''[[.:common#Array |Array]]<[[.:common#Set |Set]]<[[.:common#Int |Int]]%%>>%%'' ''domain'': a list of sets of indices that //a// should act on
 +    ? Returns:
 +    :''[[.:group:PermutationActionOnSets |PermutationActionOnSets]]''
 +    ? Example:
 +    :: Consider the symmetry group of the 3-cube acting on vertices, and induce from it the action on the facets:
 +    :: <code perl> > $a = cube_group(3)->PERMUTATION_ACTION;
 + > $f = new Array<Set>([[0,2,4,6],[1,3,5,7],[0,1,4,5],[2,3,6,7],[0,1,2,3],[4,5,6,7]]);
 + > print $a->GENERATORS;
 + 1 0 3 2 5 4 7 6
 + 0 2 1 3 4 6 5 7
 + 0 1 4 5 2 3 6 7
 +</code>
 +    :: <code perl> > print induced_action($a,$f)->GENERATORS;
 + 1 0 2 3 4 5
 + 2 3 0 1 4 5
 + 0 1 4 5 2 3
 +</code>
 +    ? Example:
 +    :: To see what the permutation [0,2,1] induces on the array [{0,1},{0,2}], do the following:
 +    :: <code perl> > $a = new Array<Set<Int>>(2);
 + > $a->[0] = new Set<Int>(0,1);
 + > $a->[1] = new Set<Int>(0,2);
 + > $p = new PermutationAction(GENERATORS=>[[0,2,1]]);
 + > print induced_action($p,$a)->properties;
 + type: PermutationActionOnSets
 +
 + GENERATORS
 + 1 0
 +</code>
 +
 +
 +----
 +{{anchor:induced_permutations:}}
 +  ?  **''induced_permutations([[.:common#Array |Array]]<[[.:common#Array |Array]]<[[.:common#Int |Int]]%%>>%% gens, [[.:common#Matrix |Matrix]] M)''**
 +  :: gives the permutations that are induced on the rows of a matrix //M// by the action of //gens// on the columns of //M//
 +    ? Parameters:
 +    :: ''[[.:common#Array |Array]]<[[.:common#Array |Array]]<[[.:common#Int |Int]]%%>>%%'' ''gens'': a list of permutations
 +    :: ''[[.:common#Matrix |Matrix]]'' ''M'': the matrix acted upon
 +    ? Options:
 +    : 
 +    :: ''[[.:common#Bool |Bool]]'' ''homogeneous_action'': should the generators also act on the homogeneous column? Default False
 +    ? Returns:
 +    :''[[.:common#Array |Array]]<[[.:common#Array |Array]]<[[.:common#Int |Int]]%%>>%%''
 +  ?  **''induced_permutations([[.:common#Array |Array]]<[[.:common#Matrix |Matrix]]<Scalar%%>>%% gens, [[.:common#Matrix |Matrix]] M)''**
 +  :: gives the permutations that are induced on the rows of a matrix //M// by the action of //gens// on the columns of //M//. The matrices in gens define the permutations by multiplicate the rows from the right side on it.
 +    ? Parameters:
 +    :: ''[[.:common#Array |Array]]<[[.:common#Matrix |Matrix]]<Scalar%%>>%%'' ''gens'': a list of matrices that act as generators
 +    :: ''[[.:common#Matrix |Matrix]]'' ''M'': the matrix acted upon
 +    ? Options:
 +    : 
 +    :: ''[[.:common#Bool |Bool]]'' ''homogeneous_action'': should the generators also act on the homogeneous column? Default False
 +    ? Returns:
 +    :''[[.:common#Array |Array]]<[[.:common#Array |Array]]<[[.:common#Int |Int]]%%>>%%''
 +    ? Example:
 +    :: <code perl> > $gens = new Array<Matrix>([new Matrix([[0,1,0],[0,0,1],[1,0,0]]), new Matrix([[0,0,1],[1,0,0],[0,1,0]])]);
 + > $M = new Matrix([[1,2,3],[3,1,2],[2,3,1]]);
 + > print induced_permutations($gens, $M, homogeneous_action=>1);
 + 2 0 1
 + 1 2 0
 +</code>
 +  ?  **''induced_permutations([[.:common#Array |Array]]<[[.:common#Array |Array]]<[[.:common#Int |Int]]%%>>%% gens, [[.:common#Array |Array]]<DomainType> S)''**
 +  :: gives the permutations that are induced on an ordered collection //S// by the action of //gens// on the elements of //S//
 +    ? Parameters:
 +    :: ''[[.:common#Array |Array]]<[[.:common#Array |Array]]<[[.:common#Int |Int]]%%>>%%'' ''gens'': a list of permutations
 +    :: ''[[.:common#Array |Array]]<DomainType>'' ''S'': the collection acted upon
 +    ? Returns:
 +    :''[[.:common#Array |Array]]<[[.:common#Array |Array]]<[[.:common#Int |Int]]%%>>%%''
 +  ?  **''induced_permutations([[.:common#Array |Array]]<[[.:common#Array |Array]]<[[.:common#Int |Int]]%%>>%% a, [[.:common#IncidenceMatrix |IncidenceMatrix]] M)''**
 +  :: gives the permutations that are induced on the rows of an incidence matrix //M// by the action of //gens// on the columns of //M//
 +    ? Parameters:
 +    :: ''[[.:common#Array |Array]]<[[.:common#Array |Array]]<[[.:common#Int |Int]]%%>>%%'' ''a'': the permutation action
 +    :: ''[[.:common#IncidenceMatrix |IncidenceMatrix]]'' ''M'': the matrix acted upon
 +    ? Returns:
 +    :''[[.:common#Array |Array]]<[[.:common#Array |Array]]<[[.:common#Int |Int]]%%>>%%''
 +
 +
 +----
 +{{anchor:induced_permutations_set_set:}}
 +  ?  **''induced_permutations_set_set([[.:common#Array |Array]]<[[.:common#Array |Array]]<[[.:common#Int |Int]]%%>>%% gens, [[.:common#Array |Array]]<[[.:common#Set |Set]]<[[.:common#Set |Set]]%%>>%% domain)''**
 +  :: gives the permutations that are induced on an Array<Set<Set>> by permuting the elements of the inner set
 +    ? Parameters:
 +    :: ''[[.:common#Array |Array]]<[[.:common#Array |Array]]<[[.:common#Int |Int]]%%>>%%'' ''gens'': the generators of permutation action
 +    :: ''[[.:common#Array |Array]]<[[.:common#Set |Set]]<[[.:common#Set |Set]]%%>>%%'' ''domain'': the domain acted upon
 +    ? Returns:
 +    :''[[.:common#Array |Array]]<[[.:common#Array |Array]]<[[.:common#Int |Int]]%%>>%%''
 +
 +
 +----
 +{{anchor:induced_rep:}}
 +  ?  **''induced_rep([[.:polytope:Cone |Cone]] C, [[.:group:PermutationActionOnSets |PermutationActionOnSets]] A, [[.:common#Array |Array]]<[[.:common#Int |Int]]> g)''**
 +  :: Calculate the representation of a group element
 +    ? Parameters:
 +    :: ''[[.:polytope:Cone |Cone]]'' ''C'': the cone or polytope containing the sets acted upon
 +    :: ''[[.:group:PermutationActionOnSets |PermutationActionOnSets]]'' ''A'': the action in question
 +    :: ''[[.:common#Array |Array]]<[[.:common#Int |Int]]>'' ''g'': the group element, acting on vertices
 +    ? Returns:
 +    :''[[.:common#SparseMatrix |SparseMatrix]]''
 +
 +
 +----
 +{{anchor:invariant_polynomials:}}
 +  ?  **''invariant_polynomials([[.:group:MatrixActionOnVectors |MatrixActionOnVectors]] a, [[.:common#Int |Int]] d)''**
 +  :: Given a matrix action //a// of a group //G// on some //n//-dimensional vector space and a total degree //d//, calculate the //G//-invariant polynomials of total degree 0 < //deg// ≤ //d// in //n// variables. This is done by calculating the //a//-orbit of all monomials of total degree at most //d//. By a theorem of Noether, for //d// = the order of //G// the output is guaranteed to generate the entire ring of //G//-invariant polynomials. No effort is made to calculate a basis of the ideal generated by these invariants. 
 +    ? Parameters:
 +    :: ''[[.:group:MatrixActionOnVectors |MatrixActionOnVectors]]'' ''a'': the matrix action
 +    :: ''[[.:common#Int |Int]]'' ''d'': the maximal degree of the sought invariants
 +    ? Options:
 +    : 
 +    :: ''[[.:common#Bool |Bool]]'' ''action_is_affine'': is the action //a// affine, ie., ignore the first row and column of the generating matrices? Default yes
 +    ? Example:
 +    :: To calculate the invariants of degree at most six of the matrix action of the symmetry group of the 3-cube, type
 +    :: <code perl> > $c = cube(3, group=>1);
 + > print join "\n", @{group::invariant_polynomials($c->GROUP->MATRIX_ACTION, 6)};
 + x_0^2 + x_1^2 + x_2^2
 + x_0^2*x_1^2 + x_0^2*x_2^2 + x_1^2*x_2^2
 + x_0^2*x_1^2*x_2^2
 + x_0^4 + x_1^4 + x_2^4
 + x_0^4*x_1^2 + x_0^4*x_2^2 + x_0^2*x_1^4 + x_0^2*x_2^4 + x_1^4*x_2^2 + x_1^2*x_2^4
 + x_0^6 + x_1^6 + x_2^6
 +</code>
 +
 +
 +----
 +{{anchor:irreducible_decomposition:}}
 +  ?  **''irreducible_decomposition<Scalar>([[.:common#Vector |Vector]]<Scalar> character, [[.:group:Group |Group]] G)''**
 +  :: Calculate the decomposition into irreducible components of a given representation
 +    ? Type Parameters:
 +    :: ''Scalar'': the number type of the character
 +    ? Parameters:
 +    :: ''[[.:common#Vector |Vector]]<Scalar>'' ''character'': the character of the given representation
 +    :: ''[[.:group:Group |Group]]'' ''G'': the given group; it needs to know its CHARACTER_TABLE and CONJUGACY_CLASS_SIZES.
 +    ? Returns:
 +    :''[[.:common#Vector |Vector]]<[[.:common#Int |Int]]>''
 +    ? Example:
 +    :: Remember that in polymake, we use the terms //action// and //representation// interchangeably. To calculate the irreducible decomposition of the vertex action of the symmetry group of the 3-cube, type
 +    :: <code perl> > $g = cube_group(3); $a = $g->PERMUTATION_ACTION;
 + > print irreducible_decomposition($a->CHARACTER, $g);
 + 1 0 0 1 0 0 0 0 1 1
 +</code>
 +    ::  Thus, the action of the symmetry group on the vertices decomposes into one copy of each of the irreducible representations corresponding to the rows 0,3,8,9 of the character table:
 +    :: <code perl> > print $g->CHARACTER_TABLE->minor([0,3,8,9],All);
 + 1 1 1 1 1 1 1 1 1 1
 + 1 1 1 -1 -1 -1 -1 1 1 -1
 + 3 1 0 -1 1 -1 0 -1 -1 3
 + 3 1 0 1 -1 1 0 -1 -1 -3
 +</code>
 +    ::  The first entries of these rows say that //a// decomposes into two 1-dimensional irreps and two 3-dimensional ones. This correctly brings the dimension of the representation //a// to 8, the number of vertices of the 3-cube.
 +
 +
 +----
 +{{anchor:isotypic_basis:}}
 +  ?  **''isotypic_basis([[.:group:Group |Group]] G, [[.:group:PermutationActionOnSets |PermutationActionOnSets]] A, [[.:common#Int |Int]] i)''**
 +  :: Calculate a basis of the isotypic component given by the i-th irrep
 +    ? Parameters:
 +    :: ''[[.:group:Group |Group]]'' ''G'': the acting group, which needs to know its CHARACTER_TABLE
 +    :: ''[[.:group:PermutationActionOnSets |PermutationActionOnSets]]'' ''A'': the representation in question, which needs to know its corresponding CONJUGACY_CLASSES
 +    :: ''[[.:common#Int |Int]]'' ''i'': the index of the sought irrep
 +    ? Options:
 +    : 
 +    :: ''[[.:common#Bool |Bool]]'' ''permute_to_orbit_order'': Should the rows and columns be ordered by orbits? Default 1
 +    ? Returns:
 +    :''[[.:common#SparseMatrix |SparseMatrix]]''
 +    ? Example:
 +    :: Consider the action of the symmetry group of the 3-cube on the set of facets:
 +    :: <code perl> > $g = cube_group(3);
 + > $f = new Array<Set>([[0,2,4,6],[1,3,5,7],[0,1,4,5],[2,3,6,7],[0,1,2,3],[4,5,6,7]]);
 + > $a = induced_action($g->PERMUTATION_ACTION, $f);
 + > print irreducible_decomposition($a->CHARACTER, $g)
 + 1 0 0 0 0 1 0 0 0 1
 +</code>
 +    ::  Now we can calculate a basis of the 5th irrep:
 +    :: <code perl> > print isotypic_basis($g, $a, 5);
 + -1/6 -1/6 1/3 1/3 -1/6 -1/6
 + 1/3 1/3 -1/6 -1/6 -1/6 -1/6
 +</code>
 +  ?  **''isotypic_basis([[.:group:Group |Group]] G, [[.:group:PermutationAction |PermutationAction]] A, [[.:common#Int |Int]] i)''**
 +  :: Calculate a basis of the isotypic component given by the i-th irrep
 +    ? Parameters:
 +    :: ''[[.:group:Group |Group]]'' ''G'': the acting group, which needs to know its CHARACTER_TABLE
 +    :: ''[[.:group:PermutationAction |PermutationAction]]'' ''A'': the action in question, which needs to know its corresponding CONJUGACY_CLASSES
 +    :: ''[[.:common#Int |Int]]'' ''i'': the index of the sought irrep
 +    ? Options:
 +    : 
 +    :: ''[[.:common#Bool |Bool]]'' ''permute_to_orbit_order'': Should the rows and columns be ordered by orbits? Default 1
 +    ? Returns:
 +    :''[[.:common#SparseMatrix |SparseMatrix]]''
 +    ? Example:
 +    :: Consider the action of the symmetry group of the 3-cube on its vertices. We first calculate its decomposition into irreducible representations via
 +    :: <code perl> > $g = cube_group(3); $a = $g->PERMUTATION_ACTION;
 + > print irreducible_decomposition($a->CHARACTER, $g);
 + 1 0 0 1 0 0 0 0 1 1
 +</code>
 +    ::  We now calculate a basis of the 3rd irrep:
 +    :: <code perl> > print isotypic_basis($g,$a,3);
 + 1/8 -1/8 -1/8 1/8 -1/8 1/8 1/8 -1/8
 +</code>
 +  ?  **''isotypic_basis<Scalar>([[.:group:Group |Group]] G, [[.:group:MatrixActionOnVectors |MatrixActionOnVectors]]<Scalar> A, [[.:common#Int |Int]] i)''**
 +  :: Calculate a basis of the isotypic component given by the i-th irrep
 +    ? Type Parameters:
 +    :: ''Scalar'': S the underlying number type
 +    ? Parameters:
 +    :: ''[[.:group:Group |Group]]'' ''G'': the acting group, which needs to know its CHARACTER_TABLE
 +    :: ''[[.:group:MatrixActionOnVectors |MatrixActionOnVectors]]<Scalar>'' ''A'': the matrix action in question, which needs to know its corresponding CONJUGACY_CLASSES
 +    :: ''[[.:common#Int |Int]]'' ''i'': the index of the sought irrep
 +    ? Returns:
 +    :''[[.:common#SparseMatrix |SparseMatrix]]''
 +
 +
 +----
 +{{anchor:isotypic_projector:}}
 +  ?  **''isotypic_projector([[.:group:Group |Group]] G, [[.:group:PermutationAction |PermutationAction]] A, [[.:common#Int |Int]] i)''**
 +  :: Calculate the projection map into the isotypic component given by the i-th irrep. The map is given by a block matrix, the rows and columns of which are indexed by the domain elements; by default, these are ordered by orbits.
 +    ? Parameters:
 +    :: ''[[.:group:Group |Group]]'' ''G'': the acting group
 +    :: ''[[.:group:PermutationAction |PermutationAction]]'' ''A'': the action in question
 +    :: ''[[.:common#Int |Int]]'' ''i'': the index of the sought irrep
 +    ? Options:
 +    : 
 +    :: ''[[.:common#Bool |Bool]]'' ''permute_to_orbit_order'': Should the rows and columns be ordered by orbits? Default 1
 +    ? Returns:
 +    :''[[.:common#SparseMatrix |SparseMatrix]]<[[.:common#QuadraticExtension |QuadraticExtension]]>''
 +    ? Example:
 +    :: Consider the action of the symmetry group of the 3-cube on its vertices. We first calculate its decomposition into irreducible representations via
 +    :: <code perl> > $g = cube_group(3); $a = $g->PERMUTATION_ACTION;
 + > print irreducible_decomposition($a->CHARACTER, $g);
 + 1 0 0 1 0 0 0 0 1 1
 +</code>
 +    ::  We now calculate the projection matrices to the irreps number 3 and 8:
 +    :: <code perl> > $p3 = isotypic_projector($g,$a,3); print $p3, "\n", rank($p3);
 + 1/8 -1/8 -1/8 1/8 -1/8 1/8 1/8 -1/8
 + -1/8 1/8 1/8 -1/8 1/8 -1/8 -1/8 1/8
 + -1/8 1/8 1/8 -1/8 1/8 -1/8 -1/8 1/8
 + 1/8 -1/8 -1/8 1/8 -1/8 1/8 1/8 -1/8
 + -1/8 1/8 1/8 -1/8 1/8 -1/8 -1/8 1/8
 + 1/8 -1/8 -1/8 1/8 -1/8 1/8 1/8 -1/8
 + 1/8 -1/8 -1/8 1/8 -1/8 1/8 1/8 -1/8
 + -1/8 1/8 1/8 -1/8 1/8 -1/8 -1/8 1/8
 + 
 + 1
 +</code>
 +    :: <code perl> > $p8 = isotypic_projector($g,$a,8); print $p8, "\n", rank($p8);
 + 3/8 -1/8 -1/8 -1/8 -1/8 -1/8 -1/8 3/8
 + -1/8 3/8 -1/8 -1/8 -1/8 -1/8 3/8 -1/8
 + -1/8 -1/8 3/8 -1/8 -1/8 3/8 -1/8 -1/8
 + -1/8 -1/8 -1/8 3/8 3/8 -1/8 -1/8 -1/8
 + -1/8 -1/8 -1/8 3/8 3/8 -1/8 -1/8 -1/8
 + -1/8 -1/8 3/8 -1/8 -1/8 3/8 -1/8 -1/8
 + -1/8 3/8 -1/8 -1/8 -1/8 -1/8 3/8 -1/8
 + 3/8 -1/8 -1/8 -1/8 -1/8 -1/8 -1/8 3/8
 + 
 + 3
 +</code>
 +    ::  From this we deduce that the irrep indexed 3 has dimension 1, and the one indexed 8 has dimension 3. This is consistent with the information collected in the character table:
 +    :: <code perl> > print $g->CHARACTER_TABLE->minor([3,8],All);
 + 1 1 1 -1 -1 -1 -1 1 1 -1
 + 3 1 0 -1 1 -1 0 -1 -1 3
 +</code>
 +    ::  In effect, the first entries in these rows are 1 and 3, respectively.
 +  ?  **''isotypic_projector<Scalar>([[.:group:Group |Group]] G, [[.:group:MatrixActionOnVectors |MatrixActionOnVectors]]<Scalar> A, [[.:common#Int |Int]] i)''**
 +  :: Calculate the projection map into the isotypic component given by the i-th irrep. Note that the option //permute_to_orbit_order// makes no sense for matrix actions, so it is always set to 0.
 +    ? Type Parameters:
 +    :: ''Scalar'': S the underlying number type
 +    ? Parameters:
 +    :: ''[[.:group:Group |Group]]'' ''G'': the acting group
 +    :: ''[[.:group:MatrixActionOnVectors |MatrixActionOnVectors]]<Scalar>'' ''A'': the action in question
 +    :: ''[[.:common#Int |Int]]'' ''i'': the index of the sought irrep
 +    ? Returns:
 +    :''[[.:common#SparseMatrix |SparseMatrix]]<[[.:common#QuadraticExtension |QuadraticExtension]]>''
 +    ? Example:
 +    :: We first construct a matrix action:
 +    :: <code perl> > $s = symmetric_group(3); $a = $s->REGULAR_REPRESENTATION;
 + > print irreducible_decomposition($a->CHARACTER, $s);
 + 0 1 1
 +</code>
 +    ::  Since we now know that the irreps indexed 1 and 2 appear in the regular representation, we project to one of them:
 +    :: <code perl> > print isotypic_projector($s, $a, 1);
 + 2/3 -1/3 -1/3
 + -1/3 2/3 -1/3
 + -1/3 -1/3 2/3
 +</code>
 +
 +
 +----
 +{{anchor:isotypic_supports:}}
 +  ?  **''isotypic_supports([[.:group:PermutationActionOnSets |PermutationActionOnSets]] a, [[.:common#Array |Array]]<[[.:common#Set |Set]]> A)''**
 +  :: For each isotypic component of a representation //a//, which of a given array //A// of sets are supported on it?
 +    ? Parameters:
 +    :: ''[[.:group:PermutationActionOnSets |PermutationActionOnSets]]'' ''a'': the representation in question
 +    :: ''[[.:common#Array |Array]]<[[.:common#Set |Set]]>'' ''A'': the given array of sets
 +    ? Options:
 +    : 
 +    :: ''[[.:common#Bool |Bool]]'' ''permute_to_orbit_order'': Should the columns be ordered by orbits? Default 1
 +    ? Returns:
 +    :''[[.:common#IncidenceMatrix |IncidenceMatrix]]''
 +  ?  **''isotypic_supports([[.:group:PermutationActionOnSets |PermutationActionOnSets]] a, [[.:common#SparseMatrix |SparseMatrix]] M)''**
 +  :: For each row of a given SparseMatrix //M//, to which isotypic components of a representation //a// does it have a non-zero projection? The columns of the SparseMatrix correspond, in order, to the sets of the representation.
 +    ? Parameters:
 +    :: ''[[.:group:PermutationActionOnSets |PermutationActionOnSets]]'' ''a'': the representation in question
 +    :: ''[[.:common#SparseMatrix |SparseMatrix]]'' ''M'': the given matrix
 +    ? Options:
 +    : 
 +    :: ''[[.:common#Bool |Bool]]'' ''permute_to_orbit_order'': Should the columns be ordered by orbits? Default 1
 +    ? Returns:
 +    :''[[.:common#IncidenceMatrix |IncidenceMatrix]]''
 +
 +
 +----
 +{{anchor:lex_min_representative:}}
 +  ?  **''lex_min_representative([[.:group:Group |Group]] G, [[.:common#Set |Set]] S)''**
 +  :: Computes the lexicographically smallest representative of a given set with respect to a group
 +    ? Parameters:
 +    :: ''[[.:group:Group |Group]]'' ''G'': a symmetry group
 +    :: ''[[.:common#Set |Set]]'' ''S'': a set
 +    ? Returns:
 +    :''[[.:common#Set |Set]]''
 +    ? Example:
 +    :: To calculate the lex-min representative of the triangle [2,5,7] under the symmetry group of the 3-cube, type
 +    :: <code perl> > print lex_min_representative(cube_group(3)->PERMUTATION_ACTION, new Set([2,5,7]));
 + {0 1 6}
 +</code>
 +
 +
 +----
 +{{anchor:orbit_reps_and_sizes:}}
 +  ?  **''orbit_reps_and_sizes<Container>([[.:common#Array |Array]]<[[.:common#Array |Array]]<[[.:common#Int |Int]]%%>>%% generators, Container S)''**
 +  :: Computes the lexicographically smallest representatives of a given array of sets with respect to a group, along with the corresponding orbit sizes
 +    ? Type Parameters:
 +    :: ''Container'': a container of sets, for example Array<Set> or IncidenceMatrix
 +    ? Parameters:
 +    :: ''[[.:common#Array |Array]]<[[.:common#Array |Array]]<[[.:common#Int |Int]]%%>>%%'' ''generators'': the generators of a symmetry group
 +    :: ''Container'' ''S'': a container of sets, for example Array<Set> or IncidenceMatrix
 +    ? Returns:
 +    :''[[.:common#Pair |Pair]]<[[.:common#Array |Array]]<[[.:common#Set |Set]]<[[.:common#Int |Int]]%%>>%%,[[.:common#Array |Array]]<[[.:common#Int |Int]]%%>>%%''
 +    ? Example:
 +    :: To calculate the orbits and orbit sizes of an icosidodecahedron, type
 +    :: <code perl> > $q=polytope::icosidodecahedron();
 + > print orbit_reps_and_sizes($q->GROUP->VERTICES_ACTION->GENERATORS,$q->VERTICES_IN_FACETS);
 + <{0 1 2 4 6}
 + {0 1 3}
 + >
 + 12 20
 +</code>
 +
 +
 +----
 +{{anchor:partition_representatives:}}
 +  ?  **''partition_representatives([[.:common#Array |Array]]<[[.:common#Array |Array]]<[[.:common#Int |Int]]%%>>%% gens, [[.:common#Set |Set]]<[[.:common#Int |Int]]> S)''**
 +  :: Partition a group into translates of a set stabilizer
 +    ? Parameters:
 +    :: ''[[.:common#Array |Array]]<[[.:common#Array |Array]]<[[.:common#Int |Int]]%%>>%%'' ''gens'': the generators of a given group action
 +    :: ''[[.:common#Set |Set]]<[[.:common#Int |Int]]>'' ''S'': a set
 +    ? Returns:
 +    :''[[.:common#Array |Array]]<[[.:common#Int |Int]]>''
 +
 +
 +----
 +{{anchor:regular_representation:}}
 +  ?  **''regular_representation([[.:group:PermutationAction |PermutationAction]] a)''**
 +  :: Calculate the regular representation of a permutation action
 +    ? Parameters:
 +    :: ''[[.:group:PermutationAction |PermutationAction]]'' ''a'': a permutation action
 +    ? Returns:
 +    :''[[.:group:MatrixActionOnVectors |MatrixActionOnVectors]]''
 +    ? Example:
 +    :: To calculate the regular representation of the symmetric group S_3, type
 +    :: <code perl> > $s = symmetric_group(3); $s->REGULAR_REPRESENTATION;
 + > print $s->REGULAR_REPRESENTATION->properties();
 + type: MatrixActionOnVectors<Rational>
 + 
 + CONJUGACY_CLASS_REPRESENTATIVES
 + <1 0 0
 + 0 1 0
 + 0 0 1
 + >
 + <0 1 0
 + 1 0 0
 + 0 0 1
 + >
 + <0 0 1
 + 1 0 0
 + 0 1 0
 + >
 + 
 + 
 + GENERATORS
 + <0 1 0
 + 1 0 0
 + 0 0 1
 + >
 + <1 0 0
 + 0 0 1
 + 0 1 0
 + >
 +</code>
 +
 +
 +----
 +{{anchor:row_support_sizes:}}
 +  ?  **''row_support_sizes([[.:common#SparseMatrix |SparseMatrix]] M)''**
 +  :: How many non-zero entries are there in each row of a SparseMatrix?
 +    ? Parameters:
 +    :: ''[[.:common#SparseMatrix |SparseMatrix]]'' ''M'': the given matrix
 +    ? Returns:
 +    :''[[.:common#Array |Array]]<[[.:common#Int |Int]]>''
 +
 +
 +----
 +{{anchor:span_same_subspace:}}
 +  ?  **''span_same_subspace([[.:common#Array |Array]]<[[.:common#HashMap |HashMap]]<SetType,[[.:common#Rational |Rational]]%%>>%% S1, [[.:common#Array |Array]]<[[.:common#HashMap |HashMap]]<SetType,[[.:common#Rational |Rational]]%%>>%% S2)''**
 +  :: Do two collections //S1//, //S2// of sparse vectors span the same subspace?
 +    ? Parameters:
 +    :: ''[[.:common#Array |Array]]<[[.:common#HashMap |HashMap]]<SetType,[[.:common#Rational |Rational]]%%>>%%'' ''S1'': the sparse generating vectors of the first subspace
 +    :: ''[[.:common#Array |Array]]<[[.:common#HashMap |HashMap]]<SetType,[[.:common#Rational |Rational]]%%>>%%'' ''S2'': the sparse generating vectors of the second subspace
 +    ? Returns:
 +    :''[[.:common#Bool |Bool]]''
 +
 +
 +----
 +{{anchor:spans_invariant_subspace:}}
 +  ?  **''spans_invariant_subspace([[.:group:ImplicitActionOnSets |ImplicitActionOnSets]] a, [[.:common#Array |Array]]<[[.:common#HashMap |HashMap]]<[[.:common#Bitset |Bitset]],[[.:common#Rational |Rational]]%%>>%% S)''**
 +  :: Does a set //S// of sparse vectors span an invariant subspace under an implicit group action //a//?
 +    ? Parameters:
 +    :: ''[[.:group:ImplicitActionOnSets |ImplicitActionOnSets]]'' ''a'': the given action
 +    :: ''[[.:common#Array |Array]]<[[.:common#HashMap |HashMap]]<[[.:common#Bitset |Bitset]],[[.:common#Rational |Rational]]%%>>%%'' ''S'': the sparsely given generating vectors of the subspace
 +    ? Options:
 +    : 
 +    :: ''[[.:common#Bool |Bool]]'' ''verbose'': give a certificate if the answer is False
 +    ? Returns:
 +    :''[[.:common#Bool |Bool]]''
 +
 +
 +----
 +{{anchor:sparse_isotypic_basis:}}
 +  ?  **''sparse_isotypic_basis([[.:group:PermutationActionOnSets |PermutationActionOnSets]] rep, [[.:common#Int |Int]] i)''**
 +  :: Calculate a sparse representation of a basis for an isotypic component. For this, the sets in the representation are listed in order by orbit. In this basis, the projection matrix to the isotypic component decomposes into blocks, one for each orbit.
 +    ? Parameters:
 +    :: ''[[.:group:PermutationActionOnSets |PermutationActionOnSets]]'' ''rep'': the given representation
 +    :: ''[[.:common#Int |Int]]'' ''i'': the index of the irrep that defines the isotypic component
 +    ? Options:
 +    : 
 +    :: ''[[.:common#Bool |Bool]]'' ''use_double'': use inexact arithmetic for reducing the basis; default 0
 +    :: ''[[.:common#String |String]]'' ''filename'': if defined, the basis will be written to a file with this name, but not returned. Use this option if you expect very large output.
 +    ? Returns:
 +    :''[[.:common#Array |Array]]<[[.:common#HashMap |HashMap]]<[[.:common#Bitset |Bitset]],[[.:common#Rational |Rational]]%%>>%%''
 +
 +
 +----
 +{{anchor:sparse_isotypic_spanning_set:}}
 +  ?  **''sparse_isotypic_spanning_set([[.:group:PermutationActionOnSets |PermutationActionOnSets]] rep, [[.:common#Int |Int]] i)''**
 +  :: Calculate a sparse representation of a spanning set for an isotypic component. For this, the sets in the representation are listed in order by orbit. In this basis, the projection matrix to the isotypic component decomposes into blocks, one for each orbit.
 +    ? Parameters:
 +    :: ''[[.:group:PermutationActionOnSets |PermutationActionOnSets]]'' ''rep'': the given representation
 +    :: ''[[.:common#Int |Int]]'' ''i'': the index of the irrep that defines the isotypic component
 +    ? Options:
 +    : 
 +    :: ''[[.:common#String |String]]'' ''filename'': if defined, the basis will be written to a file with this name, but not returned. Use this option if you expect very large output.
 +    ? Returns:
 +    :''[[.:common#Array |Array]]<[[.:common#HashMap |HashMap]]<[[.:common#Bitset |Bitset]],[[.:common#Rational |Rational]]%%>>%%''
 +
 +
 +----
 +{{anchor:sparse_isotypic_support:}}
 +  ?  **''sparse_isotypic_support([[.:group:PermutationActionOnSets |PermutationActionOnSets]] rep, [[.:common#Int |Int]] i)''**
 +  :: Calculate the support of a sparse representation of a spanning set for an isotypic component.
 +    ? Parameters:
 +    :: ''[[.:group:PermutationActionOnSets |PermutationActionOnSets]]'' ''rep'': the given representation
 +    :: ''[[.:common#Int |Int]]'' ''i'': the index of the irrep that defines the isotypic component
 +    ? Options:
 +    : 
 +    :: ''[[.:common#String |String]]'' ''filename'': if defined, the basis will be written to a file with this name, but not returned. Use this option if you expect very large output.
 +    : Bool equivalence_class_only only report representatives of simplices, default true
 +
 +    : Bool index_only only output the indices of the representatives to filename, default true
 +
 +    ? Returns:
 +    :''[[.:common#HashSet |HashSet]]<[[.:common#Bitset |Bitset]]>''
 +
 +
 +----
 +
 +==== Utilities ====
 + Miscellaneous functions.
 +----
 +{{anchor:action:}}
 +  ?  **''action<action_type>(Any g, Any O)''**
 +  :: The image of an object //O// under a group element //g//.  The action_type defines how //g// acts on //O//. For more information see the help function on the action types.
 +    ? Type Parameters:
 +    :: ''action_type'': must be compatible with //O// by default ''[[.:group#on_container |on_container]]'' can also be ''[[.:group#on_elements |on_elements]]'', ''[[.:group#on_rows |on_rows]]'', ''[[.:group#on_cols |on_cols]]'', ''[[.:group#on_nonhomog_cols |on_nonhomog_cols]]''
 +    ? Parameters:
 +    :: ''Any'' ''g'': Group element
 +    :: ''Any'' ''O'': Container type like Array, Set, Matrix or Vector
 +    ? Returns:
 +    :''Any''
 +    ? Example:
 +    :: <code perl> > $g = new Array<Int>([1,2,0]);
 + > $O = new Matrix<Int>([[0,0],[1,1],[2,2]]);
 + > print $O;
 + 0 0
 + 1 1
 + 2 2
 +</code>
 +    :: <code perl> > print action<on_rows>($g, $O);
 + 1 1
 + 2 2
 + 0 0
 +</code>
 +
 +
 +----
 +{{anchor:action_from_generators:}}
 +  ?  **''action_from_generators([[.:common#Array |Array]]<[[.:common#Array |Array]]<[[.:common#Int |Int]]%%>>%% gens, [[.:group:Group |Group]] action)''**
 +  :: Computes groups with a permutation action with the basic properties [[.:group:PermutationAction#BASE |BASE]],  [[.:group:PermutationAction#STRONG_GENERATORS |STRONG_GENERATORS]], and [[.:group:PermutationAction#TRANSVERSALS |TRANSVERSALS]].
 +    ? Parameters:
 +    :: ''[[.:common#Array |Array]]<[[.:common#Array |Array]]<[[.:common#Int |Int]]%%>>%%'' ''gens'': some generators of the group
 +    :: ''[[.:group:Group |Group]]'' ''action'': the generated action
 +
 +
 +----
 +{{anchor:action_inv:}}
 +  ?  **''action_inv<action_type>([[.:common#Array |Array]]<[[.:common#Int |Int]]> p, Any O)''**
 +  :: The image of an object //O// under the inverse of a permutation //p//. The way it acts on //O// is given by the //action_type//.
 +    ? Type Parameters:
 +    :: ''action_type'': must be compatible with //O//, by default ''[[.:group#on_container |on_container]]'' can also be ''[[.:group#on_elements |on_elements]]'', ''[[.:group#on_rows |on_rows]]'', ''[[.:group#on_cols |on_cols]]'' or ''[[.:group#on_nonhomog_cols |on_nonhomog_cols]]''
 +    ? Parameters:
 +    :: ''[[.:common#Array |Array]]<[[.:common#Int |Int]]>'' ''p'': permutation
 +    :: ''Any'' ''O'': Container type like Array, Set, Matrix or Vector
 +    ? Returns:
 +    :''Any''
 +    ? Example:
 +    :: <code perl> > $p = new Array<Int>([1,2,0]);
 + > $O = new Array<Int>([2,3,1]);
 + > print action_inv($p,$O);
 + 1 2 3
 +</code>
 +
 +
 +----
 +{{anchor:action_to_cyclic_notation:}}
 +  ?  **''action_to_cyclic_notation([[.:group:PermutationAction |PermutationAction]] a)''**
 +  :: Returns group generators in 1-based cyclic notation (GAP like, not permlib like notation)
 +    ? Parameters:
 +    :: ''[[.:group:PermutationAction |PermutationAction]]'' ''a'': the action of the permutation group
 +    ? Returns:
 +    :''[[.:common#String |String]]''
 +
 +
 +----
 +{{anchor:all_group_elements:}}
 +  ?  **''all_group_elements([[.:group:PermutationAction |PermutationAction]] a)''**
 +  :: Compute all elements of a given group, expressed as a permutation action.
 +    ? Parameters:
 +    :: ''[[.:group:PermutationAction |PermutationAction]]'' ''a'': the action of a permutation group
 +    ? Returns:
 +    :''[[.:common#Array |Array]]<[[.:common#Array |Array]]<[[.:common#Int |Int]]%%>>%%''
 +
 +
 +----
 +
 +===== Small Object Types =====
 +
 +==== no category ====
 +{{anchor:switchtable:}}
 +  ?  **''SwitchTable''**
 +  ::UNDOCUMENTED
 +
 +
 +----
 +{{anchor:on_cols:}}
 +  ?  **''on_cols''**
 +  :: A template parameter used by ''[[.:group#action |action]]'' and ''[[.:group#orbit |orbit]]'' specifying that the permutation acts on the columns of a matrix.
 +
 +
 +----
 +{{anchor:on_container:}}
 +  ?  **''on_container''**
 +  :: A template parameter used by ''[[.:group#action |action]]'' and ''[[.:group#orbit |orbit]]'' specifying that the permutation acts on the given container. It will permute the order of the elements
 +
 +
 +----
 +{{anchor:on_elements:}}
 +  ?  **''on_elements''**
 +  :: A template parameter used by ''[[.:group#action |action]]'' and ''[[.:group#orbit |orbit]]'' specifying that the permutation acts on the deepest elements inside a given container, which should be of type ''[[.:common#Int |Int]]''.
 +
 +
 +----
 +{{anchor:on_nonhomog_cols:}}
 +  ?  **''on_nonhomog_cols''**
 +  :: A template parameter used by ''[[.:group#action |action]]'' and ''[[.:group#orbit |orbit]]'' specifying that the permutation acts on all columns of a matrix, except the '0'-th one, and adjusting the indices of the permutation
 +
 +
 +----
 +{{anchor:on_nonhomog_container:}}
 +  ?  **''on_nonhomog_container''**
 +  :: A template parameter used by ''[[.:group#action |action]]'' and ''[[.:group#orbit |orbit]]'' specifying that the permutation acts on the given container. It will permute the order of the elements, leaving the '0'-th one fixed and adjusting the indices of the permutation
 +
 +
 +----
 +{{anchor:on_rows:}}
 +  ?  **''on_rows''**
 +  :: A template parameter used by ''[[.:group#action |action]]'' and ''[[.:group#orbit |orbit]]'' specifying that the permutation acts on the rows of a matrix.
 +
 +
 +----
  
  • documentation/master/group.txt
  • Last modified: 2023/06/10 04:43
  • by 127.0.0.1