Permutation group elements¶
AUTHORS:
- David Joyner (2006-02) 
- David Joyner (2006-03): word problem method and reorganization 
- Robert Bradshaw (2007-11): convert to Cython 
- Sebastian Oehms (2018-11): Added - gap()as synonym to- _gap_()(compatibility to libgap framework, see Issue #26750)
- Sebastian Oehms (2019-02): Implemented - gap()properly (Issue #27234)
There are several ways to define a permutation group element:
- Define a permutation group \(G\), then use - G.gens()and multiplication- *to construct elements.
- Define a permutation group \(G\), then use, e.g., - G([(1,2),(3,4,5)])to construct an element of the group. You could also use- G('(1,2)(3,4,5)')
- Use, e.g., - PermutationGroupElement([(1,2),(3,4,5)])or- PermutationGroupElement('(1,2)(3,4,5)')to make a permutation group element with parent \(S_5\).
EXAMPLES:
We illustrate construction of permutation using several different methods.
First we construct elements by multiplying together generators for a group:
sage: G = PermutationGroup(['(1,2)(3,4)', '(3,4,5,6)'], canonicalize=False)
sage: s = G.gens()
sage: s[0]
(1,2)(3,4)
sage: s[1]
(3,4,5,6)
sage: s[0]*s[1]
(1,2)(3,5,6)
sage: (s[0]*s[1]).parent()
Permutation Group with generators [(1,2)(3,4), (3,4,5,6)]
>>> from sage.all import *
>>> G = PermutationGroup(['(1,2)(3,4)', '(3,4,5,6)'], canonicalize=False)
>>> s = G.gens()
>>> s[Integer(0)]
(1,2)(3,4)
>>> s[Integer(1)]
(3,4,5,6)
>>> s[Integer(0)]*s[Integer(1)]
(1,2)(3,5,6)
>>> (s[Integer(0)]*s[Integer(1)]).parent()
Permutation Group with generators [(1,2)(3,4), (3,4,5,6)]
Next we illustrate creation of a permutation using coercion into an already-created group:
sage: g = G([(1,2),(3,5,6)])
sage: g
(1,2)(3,5,6)
sage: g.parent()
Permutation Group with generators [(1,2)(3,4), (3,4,5,6)]
sage: g == s[0]*s[1]
True
>>> from sage.all import *
>>> g = G([(Integer(1),Integer(2)),(Integer(3),Integer(5),Integer(6))])
>>> g
(1,2)(3,5,6)
>>> g.parent()
Permutation Group with generators [(1,2)(3,4), (3,4,5,6)]
>>> g == s[Integer(0)]*s[Integer(1)]
True
We can also use a string or one-line notation to specify the permutation:
sage: h = G('(1,2)(3,5,6)')
sage: i = G([2,1,5,4,6,3])
sage: g == h == i
True
>>> from sage.all import *
>>> h = G('(1,2)(3,5,6)')
>>> i = G([Integer(2),Integer(1),Integer(5),Integer(4),Integer(6),Integer(3)])
>>> g == h == i
True
The Rubik’s cube group:
sage: f = [(17,19,24,22),(18,21,23,20),( 6,25,43,16),( 7,28,42,13),( 8,30,41,11)]
sage: b = [(33,35,40,38),(34,37,39,36),( 3, 9,46,32),( 2,12,47,29),( 1,14,48,27)]
sage: l = [( 9,11,16,14),(10,13,15,12),( 1,17,41,40),( 4,20,44,37),( 6,22,46,35)]
sage: r = [(25,27,32,30),(26,29,31,28),( 3,38,43,19),( 5,36,45,21),( 8,33,48,24)]
sage: u = [( 1, 3, 8, 6),( 2, 5, 7, 4),( 9,33,25,17),(10,34,26,18),(11,35,27,19)]
sage: d = [(41,43,48,46),(42,45,47,44),(14,22,30,38),(15,23,31,39),(16,24,32,40)]
sage: cube = PermutationGroup([f, b, l, r, u, d])
sage: F, B, L, R, U, D = cube.gens()
sage: cube.order()
43252003274489856000
sage: F.order()
4
>>> from sage.all import *
>>> f = [(Integer(17),Integer(19),Integer(24),Integer(22)),(Integer(18),Integer(21),Integer(23),Integer(20)),( Integer(6),Integer(25),Integer(43),Integer(16)),( Integer(7),Integer(28),Integer(42),Integer(13)),( Integer(8),Integer(30),Integer(41),Integer(11))]
>>> b = [(Integer(33),Integer(35),Integer(40),Integer(38)),(Integer(34),Integer(37),Integer(39),Integer(36)),( Integer(3), Integer(9),Integer(46),Integer(32)),( Integer(2),Integer(12),Integer(47),Integer(29)),( Integer(1),Integer(14),Integer(48),Integer(27))]
>>> l = [( Integer(9),Integer(11),Integer(16),Integer(14)),(Integer(10),Integer(13),Integer(15),Integer(12)),( Integer(1),Integer(17),Integer(41),Integer(40)),( Integer(4),Integer(20),Integer(44),Integer(37)),( Integer(6),Integer(22),Integer(46),Integer(35))]
>>> r = [(Integer(25),Integer(27),Integer(32),Integer(30)),(Integer(26),Integer(29),Integer(31),Integer(28)),( Integer(3),Integer(38),Integer(43),Integer(19)),( Integer(5),Integer(36),Integer(45),Integer(21)),( Integer(8),Integer(33),Integer(48),Integer(24))]
>>> u = [( Integer(1), Integer(3), Integer(8), Integer(6)),( Integer(2), Integer(5), Integer(7), Integer(4)),( Integer(9),Integer(33),Integer(25),Integer(17)),(Integer(10),Integer(34),Integer(26),Integer(18)),(Integer(11),Integer(35),Integer(27),Integer(19))]
>>> d = [(Integer(41),Integer(43),Integer(48),Integer(46)),(Integer(42),Integer(45),Integer(47),Integer(44)),(Integer(14),Integer(22),Integer(30),Integer(38)),(Integer(15),Integer(23),Integer(31),Integer(39)),(Integer(16),Integer(24),Integer(32),Integer(40))]
>>> cube = PermutationGroup([f, b, l, r, u, d])
>>> F, B, L, R, U, D = cube.gens()
>>> cube.order()
43252003274489856000
>>> F.order()
4
We create element of a permutation group of large degree:
sage: G = SymmetricGroup(30)
sage: s = G(srange(30,0,-1)); s
(1,30)(2,29)(3,28)(4,27)(5,26)(6,25)(7,24)(8,23)(9,22)(10,21)(11,20)(12,19)(13,18)(14,17)(15,16)
>>> from sage.all import *
>>> G = SymmetricGroup(Integer(30))
>>> s = G(srange(Integer(30),Integer(0),-Integer(1))); s
(1,30)(2,29)(3,28)(4,27)(5,26)(6,25)(7,24)(8,23)(9,22)(10,21)(11,20)(12,19)(13,18)(14,17)(15,16)
- class sage.groups.perm_gps.permgroup_element.PermutationGroupElement[source]¶
- Bases: - MultiplicativeGroupElement- An element of a permutation group. - EXAMPLES: - sage: G = PermutationGroup(['(1,2,3)(4,5)']); G Permutation Group with generators [(1,2,3)(4,5)] sage: g = G.random_element() sage: g in G True sage: g = G.gen(0); g (1,2,3)(4,5) sage: print(g) (1,2,3)(4,5) sage: g*g (1,3,2) sage: g**(-1) (1,3,2)(4,5) sage: g**2 (1,3,2) sage: G = PermutationGroup([(1,2,3)]) sage: g = G.gen(0); g (1,2,3) sage: g.order() 3 - >>> from sage.all import * >>> G = PermutationGroup(['(1,2,3)(4,5)']); G Permutation Group with generators [(1,2,3)(4,5)] >>> g = G.random_element() >>> g in G True >>> g = G.gen(Integer(0)); g (1,2,3)(4,5) >>> print(g) (1,2,3)(4,5) >>> g*g (1,3,2) >>> g**(-Integer(1)) (1,3,2)(4,5) >>> g**Integer(2) (1,3,2) >>> G = PermutationGroup([(Integer(1),Integer(2),Integer(3))]) >>> g = G.gen(Integer(0)); g (1,2,3) >>> g.order() 3 - This example illustrates how permutations act on multivariate polynomials. - sage: R = PolynomialRing(RationalField(), 5, ["x","y","z","u","v"]) sage: x, y, z, u, v = R.gens() sage: f = x**2 - y**2 + 3*z**2 sage: G = PermutationGroup(['(1,2,3)(4,5)', '(1,2,3,4,5)']) sage: sigma = G.gen(0) sage: f * sigma 3*x^2 + y^2 - z^2 - >>> from sage.all import * >>> R = PolynomialRing(RationalField(), Integer(5), ["x","y","z","u","v"]) >>> x, y, z, u, v = R.gens() >>> f = x**Integer(2) - y**Integer(2) + Integer(3)*z**Integer(2) >>> G = PermutationGroup(['(1,2,3)(4,5)', '(1,2,3,4,5)']) >>> sigma = G.gen(Integer(0)) >>> f * sigma 3*x^2 + y^2 - z^2 - cycle_string(singletons=False)[source]¶
- Return string representation of this permutation. - EXAMPLES: - sage: g = PermutationGroupElement([(1,2,3),(4,5)]) sage: g.cycle_string() '(1,2,3)(4,5)' sage: g = PermutationGroupElement([3,2,1]) sage: g.cycle_string(singletons=True) '(1,3)(2)' - >>> from sage.all import * >>> g = PermutationGroupElement([(Integer(1),Integer(2),Integer(3)),(Integer(4),Integer(5))]) >>> g.cycle_string() '(1,2,3)(4,5)' >>> g = PermutationGroupElement([Integer(3),Integer(2),Integer(1)]) >>> g.cycle_string(singletons=True) '(1,3)(2)' 
 - cycle_tuples(singletons=False)[source]¶
- Return - selfas a list of disjoint cycles, represented as tuples rather than permutation group elements.- INPUT: - singletons– boolean (default:- False); whether or not consider the cycle that correspond to fixed point
 - EXAMPLES: - sage: p = PermutationGroupElement('(2,6)(4,5,1)') sage: p.cycle_tuples() [(1, 4, 5), (2, 6)] sage: p.cycle_tuples(singletons=True) [(1, 4, 5), (2, 6), (3,)] - >>> from sage.all import * >>> p = PermutationGroupElement('(2,6)(4,5,1)') >>> p.cycle_tuples() [(1, 4, 5), (2, 6)] >>> p.cycle_tuples(singletons=True) [(1, 4, 5), (2, 6), (3,)] - EXAMPLES: - sage: S = SymmetricGroup(4) sage: S.gen(0).cycle_tuples() [(1, 2, 3, 4)] - >>> from sage.all import * >>> S = SymmetricGroup(Integer(4)) >>> S.gen(Integer(0)).cycle_tuples() [(1, 2, 3, 4)] - sage: S = SymmetricGroup(['a','b','c','d']) sage: S.gen(0).cycle_tuples() [('a', 'b', 'c', 'd')] sage: S([('a', 'b'), ('c', 'd')]).cycle_tuples() [('a', 'b'), ('c', 'd')] - >>> from sage.all import * >>> S = SymmetricGroup(['a','b','c','d']) >>> S.gen(Integer(0)).cycle_tuples() [('a', 'b', 'c', 'd')] >>> S([('a', 'b'), ('c', 'd')]).cycle_tuples() [('a', 'b'), ('c', 'd')] 
 - cycle_type(singletons=True, as_list=False)[source]¶
- Return the partition that gives the cycle type of - selfas an element of its parent.- INPUT: - g– an element of the permutation group- self.parent()
- singletons– boolean depending on whether or not trivial cycles should be counted (default:- True)
- as_list– boolean depending on whether the cycle type should be returned as a- listor as a- Partition(default:- False)
 - OUTPUT: a - Partition, or- listif- is_listis- True, giving the cycle type of- self- If speed is a concern, then - as_list=Trueshould be used.- EXAMPLES: - sage: # needs sage.combinat sage: G = DihedralGroup(3) sage: [g.cycle_type() for g in G] [[1, 1, 1], [3], [3], [2, 1], [2, 1], [2, 1]] sage: PermutationGroupElement('(1,2,3)(4,5)(6,7,8)').cycle_type() [3, 3, 2] sage: G = SymmetricGroup(3); G('(1,2)').cycle_type() [2, 1] sage: G = SymmetricGroup(4); G('(1,2)').cycle_type() [2, 1, 1] sage: G = SymmetricGroup(4); G('(1,2)').cycle_type(singletons=False) [2] sage: G = SymmetricGroup(4); G('(1,2)').cycle_type(as_list=False) [2, 1, 1] - >>> from sage.all import * >>> # needs sage.combinat >>> G = DihedralGroup(Integer(3)) >>> [g.cycle_type() for g in G] [[1, 1, 1], [3], [3], [2, 1], [2, 1], [2, 1]] >>> PermutationGroupElement('(1,2,3)(4,5)(6,7,8)').cycle_type() [3, 3, 2] >>> G = SymmetricGroup(Integer(3)); G('(1,2)').cycle_type() [2, 1] >>> G = SymmetricGroup(Integer(4)); G('(1,2)').cycle_type() [2, 1, 1] >>> G = SymmetricGroup(Integer(4)); G('(1,2)').cycle_type(singletons=False) [2] >>> G = SymmetricGroup(Integer(4)); G('(1,2)').cycle_type(as_list=False) [2, 1, 1] 
 - cycles()[source]¶
- Return - selfas a list of disjoint cycles.- EXAMPLES: - sage: G = PermutationGroup(['(1,2,3)(4,5,6,7)']) sage: g = G.0 sage: g.cycles() [(1,2,3), (4,5,6,7)] sage: a, b = g.cycles() sage: a(1), b(1) (2, 1) - >>> from sage.all import * >>> G = PermutationGroup(['(1,2,3)(4,5,6,7)']) >>> g = G.gen(0) >>> g.cycles() [(1,2,3), (4,5,6,7)] >>> a, b = g.cycles() >>> a(Integer(1)), b(Integer(1)) (2, 1) 
 - dict()[source]¶
- Return a dictionary associating each element of the domain with its image. - EXAMPLES: - sage: G = SymmetricGroup(4) sage: g = G((1,2,3,4)); g (1,2,3,4) sage: v = g.dict(); v {1: 2, 2: 3, 3: 4, 4: 1} sage: type(v[1]) <... 'int'> sage: x = G([2,1]); x (1,2) sage: x.dict() {1: 2, 2: 1, 3: 3, 4: 4} - >>> from sage.all import * >>> G = SymmetricGroup(Integer(4)) >>> g = G((Integer(1),Integer(2),Integer(3),Integer(4))); g (1,2,3,4) >>> v = g.dict(); v {1: 2, 2: 3, 3: 4, 4: 1} >>> type(v[Integer(1)]) <... 'int'> >>> x = G([Integer(2),Integer(1)]); x (1,2) >>> x.dict() {1: 2, 2: 1, 3: 3, 4: 4} 
 - domain()[source]¶
- Return the domain of - self.- EXAMPLES: - sage: G = SymmetricGroup(4) sage: x = G([2,1,4,3]); x (1,2)(3,4) sage: v = x.domain(); v [2, 1, 4, 3] sage: type(v[0]) <... 'int'> sage: x = G([2,1]); x (1,2) sage: x.domain() [2, 1, 3, 4] - >>> from sage.all import * >>> G = SymmetricGroup(Integer(4)) >>> x = G([Integer(2),Integer(1),Integer(4),Integer(3)]); x (1,2)(3,4) >>> v = x.domain(); v [2, 1, 4, 3] >>> type(v[Integer(0)]) <... 'int'> >>> x = G([Integer(2),Integer(1)]); x (1,2) >>> x.domain() [2, 1, 3, 4] 
 - gap()[source]¶
- Return - selfas a libgap element.- EXAMPLES: - sage: S = SymmetricGroup(4) sage: p = S('(2,4)') sage: p_libgap = libgap(p) sage: p_libgap.Order() 2 sage: S(p_libgap) == p True sage: # needs sage.rings.finite_rings sage: P = PGU(8,2) sage: p, q = P.gens() sage: p_libgap = p.gap() - >>> from sage.all import * >>> S = SymmetricGroup(Integer(4)) >>> p = S('(2,4)') >>> p_libgap = libgap(p) >>> p_libgap.Order() 2 >>> S(p_libgap) == p True >>> # needs sage.rings.finite_rings >>> P = PGU(Integer(8),Integer(2)) >>> p, q = P.gens() >>> p_libgap = p.gap() 
 - has_descent(i, side='right', positive=False)[source]¶
- Return whether - selfhas a left (resp. right) descent at position- i. If- positiveis- True, then test for a non descent instead.- Beware that, since permutations are acting on the right, the meaning of descents is the reverse of the usual convention. Hence, - selfhas a left descent at position- iif- self(i) > self(i+1).- INPUT: - i– an element of the index set
- side–- 'left'or- 'right'(default:- 'right')
- positive– boolean (default:- False)
 - EXAMPLES: - sage: S = SymmetricGroup([1,2,3]) sage: S.one().has_descent(1) False sage: S.one().has_descent(2) False sage: s = S.simple_reflections() sage: x = s[1]*s[2] sage: x.has_descent(1, side='right') False sage: x.has_descent(2, side='right') True sage: x.has_descent(1, side='left') True sage: x.has_descent(2, side='left') False sage: S._test_has_descent() - >>> from sage.all import * >>> S = SymmetricGroup([Integer(1),Integer(2),Integer(3)]) >>> S.one().has_descent(Integer(1)) False >>> S.one().has_descent(Integer(2)) False >>> s = S.simple_reflections() >>> x = s[Integer(1)]*s[Integer(2)] >>> x.has_descent(Integer(1), side='right') False >>> x.has_descent(Integer(2), side='right') True >>> x.has_descent(Integer(1), side='left') True >>> x.has_descent(Integer(2), side='left') False >>> S._test_has_descent() - The symmetric group acting on a set not of the form \((1,\dots,n)\) is also supported: - sage: S = SymmetricGroup([2,4,1]) sage: s = S.simple_reflections() sage: x = s[2]*s[4] sage: x.has_descent(4) True sage: S._test_has_descent() - >>> from sage.all import * >>> S = SymmetricGroup([Integer(2),Integer(4),Integer(1)]) >>> s = S.simple_reflections() >>> x = s[Integer(2)]*s[Integer(4)] >>> x.has_descent(Integer(4)) True >>> S._test_has_descent() 
 - inverse()[source]¶
- Return the inverse permutation. - OUTPUT: - For an element of a permutation group, this method returns the inverse element, which is both the inverse function and the inverse as an element of a group. - EXAMPLES: - sage: s = PermutationGroupElement("(1,2,3)(4,5)") sage: s.inverse() (1,3,2)(4,5) sage: A = AlternatingGroup(4) sage: t = A("(1,2,3)") sage: t.inverse() (1,3,2) - >>> from sage.all import * >>> s = PermutationGroupElement("(1,2,3)(4,5)") >>> s.inverse() (1,3,2)(4,5) >>> A = AlternatingGroup(Integer(4)) >>> t = A("(1,2,3)") >>> t.inverse() (1,3,2) - There are several ways (syntactically) to get an inverse of a permutation group element. - sage: s = PermutationGroupElement("(1,2,3,4)(6,7,8)") sage: s.inverse() == s^-1 True sage: s.inverse() == ~s True - >>> from sage.all import * >>> s = PermutationGroupElement("(1,2,3,4)(6,7,8)") >>> s.inverse() == s**-Integer(1) True >>> s.inverse() == ~s True 
 - matrix()[source]¶
- Return a deg \(\times\) deg permutation matrix associated to the permutation - self.- EXAMPLES: - sage: G = PermutationGroup(['(1,2,3)(4,5)']) sage: g = G.gen(0) sage: g.matrix() [0 1 0 0 0] [0 0 1 0 0] [1 0 0 0 0] [0 0 0 0 1] [0 0 0 1 0] - >>> from sage.all import * >>> G = PermutationGroup(['(1,2,3)(4,5)']) >>> g = G.gen(Integer(0)) >>> g.matrix() [0 1 0 0 0] [0 0 1 0 0] [1 0 0 0 0] [0 0 0 0 1] [0 0 0 1 0] 
 - multiplicative_order()[source]¶
- Return the order of this group element, which is the smallest positive integer \(n\) for which \(g^n = 1\). - EXAMPLES: - sage: s = PermutationGroupElement('(1,2)(3,5,6)') sage: s.multiplicative_order() 6 - >>> from sage.all import * >>> s = PermutationGroupElement('(1,2)(3,5,6)') >>> s.multiplicative_order() 6 - order()is just an alias for- multiplicative_order():- sage: s.order() 6 - >>> from sage.all import * >>> s.order() 6 
 - orbit(n, sorted=True)[source]¶
- Return the orbit of the integer \(n\) under this group element, as a sorted list. - EXAMPLES: - sage: G = PermutationGroup(['(1,2,3)(4,5)']) sage: g = G.gen(0) sage: g.orbit(4) [4, 5] sage: g.orbit(3) [1, 2, 3] sage: g.orbit(10) [10] - >>> from sage.all import * >>> G = PermutationGroup(['(1,2,3)(4,5)']) >>> g = G.gen(Integer(0)) >>> g.orbit(Integer(4)) [4, 5] >>> g.orbit(Integer(3)) [1, 2, 3] >>> g.orbit(Integer(10)) [10] - sage: s = SymmetricGroup(['a', 'b']).gen(0); s ('a','b') sage: s.orbit('a') ['a', 'b'] - >>> from sage.all import * >>> s = SymmetricGroup(['a', 'b']).gen(Integer(0)); s ('a','b') >>> s.orbit('a') ['a', 'b'] 
 - sign()[source]¶
- Return the sign of - self, which is \((-1)^{s}\), where \(s\) is the number of swaps.- EXAMPLES: - sage: s = PermutationGroupElement('(1,2)(3,5,6)') sage: s.sign() -1 - >>> from sage.all import * >>> s = PermutationGroupElement('(1,2)(3,5,6)') >>> s.sign() -1 - ALGORITHM: Only even cycles contribute to the sign, thus \[sign(sigma) = (-1)^{\sum_c len(c)-1}\]- where the sum is over cycles in - self.
 - tuple()[source]¶
- Return tuple of images of the domain under - self.- EXAMPLES: - sage: G = SymmetricGroup(5) sage: s = G([2,1,5,3,4]) sage: s.tuple() (2, 1, 5, 3, 4) sage: S = SymmetricGroup(['a', 'b']) sage: S.gen().tuple() ('b', 'a') - >>> from sage.all import * >>> G = SymmetricGroup(Integer(5)) >>> s = G([Integer(2),Integer(1),Integer(5),Integer(3),Integer(4)]) >>> s.tuple() (2, 1, 5, 3, 4) >>> S = SymmetricGroup(['a', 'b']) >>> S.gen().tuple() ('b', 'a') 
 - word_problem(words, display=True, as_list=False)[source]¶
- Try to solve the word problem for - self.- INPUT: - words– list of elements of the ambient group, generating a subgroup
- display– boolean (default:- True); whether to display additional information
- as_list– boolean (default:- False); whether to return the result as a list of pairs (generator, exponent)
 - OUTPUT: - a pair of strings, both representing the same word 
 - or - a list of pairs representing the word, each pair being (generator as a string, exponent as an integer) 
 - Let \(G\) be the ambient permutation group, containing the given element \(g\). Let \(H\) be the subgroup of \(G\) generated by the list - wordsof elements of \(G\). If \(g\) is in \(H\), this function returns an expression for \(g\) as a word in the elements of- wordsand their inverses.- This function does not solve the word problem in Sage. Rather it pushes it over to GAP, which has optimized algorithms for the word problem. Essentially, this function is a wrapper for the GAP functions - EpimorphismFromFreeGroupand- PreImagesRepresentative.- EXAMPLES: - sage: G = PermutationGroup([[(1,2,3),(4,5)],[(3,4)]], canonicalize=False) sage: g1, g2 = G.gens() sage: h = g1^2*g2*g1 sage: h.word_problem([g1,g2], False) ('x1^2*x2^-1*x1', '(1,2,3)(4,5)^2*(3,4)^-1*(1,2,3)(4,5)') sage: h.word_problem([g1,g2]) x1^2*x2^-1*x1 [['(1,2,3)(4,5)', 2], ['(3,4)', -1], ['(1,2,3)(4,5)', 1]] ('x1^2*x2^-1*x1', '(1,2,3)(4,5)^2*(3,4)^-1*(1,2,3)(4,5)') sage: h.word_problem([g1,g2], False, as_list=True) [['(1,2,3)(4,5)', 2], ['(3,4)', -1], ['(1,2,3)(4,5)', 1]] - >>> from sage.all import * >>> G = PermutationGroup([[(Integer(1),Integer(2),Integer(3)),(Integer(4),Integer(5))],[(Integer(3),Integer(4))]], canonicalize=False) >>> g1, g2 = G.gens() >>> h = g1**Integer(2)*g2*g1 >>> h.word_problem([g1,g2], False) ('x1^2*x2^-1*x1', '(1,2,3)(4,5)^2*(3,4)^-1*(1,2,3)(4,5)') >>> h.word_problem([g1,g2]) x1^2*x2^-1*x1 [['(1,2,3)(4,5)', 2], ['(3,4)', -1], ['(1,2,3)(4,5)', 1]] ('x1^2*x2^-1*x1', '(1,2,3)(4,5)^2*(3,4)^-1*(1,2,3)(4,5)') >>> h.word_problem([g1,g2], False, as_list=True) [['(1,2,3)(4,5)', 2], ['(3,4)', -1], ['(1,2,3)(4,5)', 1]] 
 
- class sage.groups.perm_gps.permgroup_element.SymmetricGroupElement[source]¶
- Bases: - PermutationGroupElement- An element of the symmetric group. - absolute_length()[source]¶
- Return the absolute length of - self.- The absolute length is the size minus the number of its disjoint cycles. Alternatively, it is the length of the shortest expression of the element as a product of reflections. - See also - absolute_le()- EXAMPLES: - sage: S = SymmetricGroup(3) sage: [x.absolute_length() for x in S] # needs sage.combinat [0, 2, 2, 1, 1, 1] - >>> from sage.all import * >>> S = SymmetricGroup(Integer(3)) >>> [x.absolute_length() for x in S] # needs sage.combinat [0, 2, 2, 1, 1, 1] 
 - has_left_descent(i)[source]¶
- Return whether \(i\) is a left descent of - self.- EXAMPLES: - sage: W = SymmetricGroup(4) sage: w = W.from_reduced_word([1,3,2,1]) sage: [i for i in W.index_set() if w.has_left_descent(i)] [1, 3] - >>> from sage.all import * >>> W = SymmetricGroup(Integer(4)) >>> w = W.from_reduced_word([Integer(1),Integer(3),Integer(2),Integer(1)]) >>> [i for i in W.index_set() if w.has_left_descent(i)] [1, 3] 
 
- sage.groups.perm_gps.permgroup_element.is_PermutationGroupElement(x)[source]¶
- Return - Trueif- xis a- PermutationGroupElement.- EXAMPLES: - sage: p = PermutationGroupElement([(1,2),(3,4,5)]) sage: from sage.groups.perm_gps.permgroup_element import is_PermutationGroupElement sage: is_PermutationGroupElement(p) doctest:warning... DeprecationWarning: The function is_PermutationGroupElement is deprecated; use 'isinstance(..., PermutationGroupElement)' instead. See https://github.com/sagemath/sage/issues/38184 for details. True - >>> from sage.all import * >>> p = PermutationGroupElement([(Integer(1),Integer(2)),(Integer(3),Integer(4),Integer(5))]) >>> from sage.groups.perm_gps.permgroup_element import is_PermutationGroupElement >>> is_PermutationGroupElement(p) doctest:warning... DeprecationWarning: The function is_PermutationGroupElement is deprecated; use 'isinstance(..., PermutationGroupElement)' instead. See https://github.com/sagemath/sage/issues/38184 for details. True 
- sage.groups.perm_gps.permgroup_element.make_permgroup_element(G, x)[source]¶
- Return a - PermutationGroupElementgiven the permutation group- Gand the permutation- xin list notation.- This is function is used when unpickling old (pre-domain) versions of permutation groups and their elements. This now does a bit of processing and calls - make_permgroup_element_v2()which is used in unpickling the current PermutationGroupElements.- EXAMPLES: - sage: from sage.groups.perm_gps.permgroup_element import make_permgroup_element sage: S = SymmetricGroup(3) sage: make_permgroup_element(S, [1,3,2]) (2,3) - >>> from sage.all import * >>> from sage.groups.perm_gps.permgroup_element import make_permgroup_element >>> S = SymmetricGroup(Integer(3)) >>> make_permgroup_element(S, [Integer(1),Integer(3),Integer(2)]) (2,3) 
- sage.groups.perm_gps.permgroup_element.make_permgroup_element_v2(G, x, domain)[source]¶
- Return a - PermutationGroupElementgiven the permutation group- G, the permutation- xin list notation, and the domain- domainof the permutation group.- This is function is used when unpickling permutation groups and their elements. - EXAMPLES: - sage: from sage.groups.perm_gps.permgroup_element import make_permgroup_element_v2 sage: S = SymmetricGroup(3) sage: make_permgroup_element_v2(S, [1,3,2], S.domain()) (2,3) - >>> from sage.all import * >>> from sage.groups.perm_gps.permgroup_element import make_permgroup_element_v2 >>> S = SymmetricGroup(Integer(3)) >>> make_permgroup_element_v2(S, [Integer(1),Integer(3),Integer(2)], S.domain()) (2,3)