排列

class sympy.combinatorics.permutations.Permutation(*args, size=None, **kwargs)

排列，又称为‘排列数’或‘排序’，是将有序列表的元素重新排列成与自身一一对应的一种安排。给定排列的排列是通过指示元素在重新排列后的位置来给出的 [2]。例如，如果从元素 [x, y, a, b]``（按此顺序）开始，并将它们重新排序为 ``[x, y, b, a]，那么排列将是 [0, 1, 3, 2]。注意，（在SymPy中）第一个元素总是被引用为0，并且排列使用的是元素在原始顺序中的索引，而不是元素 (a, b, ...) 本身。

>>> from sympy.combinatorics import Permutation
>>> from sympy import init_printing
>>> init_printing(perm_cyclic=False, pretty_print=False)

属性:

args

返回 ‘self’ 的参数元组。

array_form

返回属性 _array_form 的副本

assumptions0

返回对象 \(type\) 假设。

canonical_variables

返回一个字典，将 self.bound_symbols 中定义的任何变量映射到与表达式中任何自由符号不冲突的符号。

cardinality

返回所有可能排列的数量。

cycle_structure

返回置换的循环结构，以字典形式表示每个循环长度的多重性。

cycles

返回置换中包含的循环数（包括单元素循环）。

cyclic_form

这用于从标准表示法转换为循环表示法。

expr_free_symbols

free_symbols

从自身的原子中返回那些自由符号。

full_cyclic_form

返回包括单个元素在内的循环形式的排列。

func

表达式中的顶级函数。

is_Empty

检查排列是否为零元素的集合

is_Identity

如果排列是恒等排列，则返回 True。

is_Singleton

检查排列是否只包含一个数字并且是

is_algebraic

is_antihermitian

is_commutative

is_comparable

如果 self 可以计算为一个具有精度的实数（或已经是一个实数），则返回 True，否则返回 False。

is_complex

is_composite

is_even

检查一个排列是否为偶排列。

is_extended_negative

is_extended_nonnegative

is_extended_nonpositive

is_extended_nonzero

is_extended_positive

is_extended_real

is_finite

is_hermitian

is_identity

is_imaginary

is_infinite

is_integer

is_irrational

is_negative

is_noninteger

is_nonnegative

is_nonpositive

is_nonzero

is_odd

检查一个排列是否为奇排列。

is_polar

is_positive

is_prime

is_rational

is_real

is_transcendental

is_zero

print_cyclic

size

返回排列中的元素数量。

方法

__call__(*i)	允许将置换实例作为双射函数应用。
apply(i)	将排列应用于表达式。
as_content_primitive([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
as_dummy()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
ascents()	返回排列中的上升位置，即 p[i] < p[i+1] 的位置。
atoms()	返回排列的所有元素
class_key()
commutator(x)	返回 self 和 x 的交换子：~x*~self*x*self
commutes_with(other)	检查元素是否可交换。
compare(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
count(query)	计算匹配的子表达式的数量。
count_ops([visual])	用于返回操作计数的 count_ops 的包装器。
descents()	返回排列中下降的位置，即 p[i] > p[i+1] 的位置。
doit(**hints)
dummy_eq(other[, symbol])	比较两个表达式并处理哑符号。
find(query[, group])	查找所有匹配查询的子表达式。
from_inversion_vector(inversion)	计算从逆向量得到排列。
from_sequence(i[, key])	返回从 i 的排序元素中获得 i 所需排列。
fromiter(args, **assumptions)	从可迭代对象创建一个新对象。
get_adjacency_distance(other)	计算两个排列之间的邻接距离。
get_adjacency_matrix()	计算置换的邻接矩阵。
get_positional_distance(other)	计算两个排列之间的位置距离。
get_precedence_distance(other)	计算两个排列之间的优先距离。
get_precedence_matrix()	获取优先级矩阵。
has(*patterns)	测试是否有任何子表达式匹配任何模式。
has_free(*patterns)	如果 self 包含对象 x 作为自由表达式，则返回 True，否则返回 False。
has_xfree(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
index()	返回一个排列的索引。
inversion_vector()	返回排列的逆向量。
inversions()	计算排列的逆序数。
is_same(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
josephus(m, n[, s])	返回一个排列，使用约瑟夫斯方案对 range(n) 进行洗牌，其中每第 m 个项目被选中，直到所有项目都被选中。
length()	返回由排列移动的整数数量。
list([size])	返回排列为一个显式列表，如果大小小于排列中的最大元素，则可能会修剪未移动的元素；如果需要这样做，设置 size=-1 将保证这种修剪。
match(pattern[, old])	模式匹配。
matches(expr[, repl_dict, old])
max()	置换移动的最大元素。
min()	置换移动的最小元素。
mul_inv(other)	other*~self, self 和 other 具有 _array_form
next_lex()	返回按字典顺序排列的下一个排列。
next_nonlex()	返回非词典顺序的下一个排列 [3]。
next_trotterjohnson()	返回Trotter-Johnson顺序中的下一个排列。
order()	计算排列的阶。
parity()	计算排列的奇偶性。
random(n)	生成一个长度为 n 的随机排列。
rank()	返回排列的字典序排名。
rank_nonlex([inv_perm])	这是一个线性时间排序算法，不强制执行字典顺序 [3]。
rank_trotterjohnson()	返回Trotter Johnson秩，这是我们从最小变化算法中得到的。
rcall(*args)	通过表达式树递归应用于参数。
refine([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
replace(query, value[, map, simultaneous, exact])	将 self 中匹配的子表达式替换为 value。
resize(n)	将排列调整为新的尺寸 n。
rewrite(*args[, deep])	使用定义的规则重写 self。
rmul(*args)	返回排列 [a, b, c, ...] 的乘积作为排列，其第 i 个值为 a(b(c(i)))。
rmul_with_af(*args)	与 rmul 相同，但 args 的元素是 Permutation 对象，这些对象具有 _array_form
runs()	返回排列的运行。
signature()	给出将置换元素排列为规范顺序所需的置换签名。
simplify(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])
subs(*args, **kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
support()	返回排列 P 中满足 P[i] != i 的元素。
transpositions()	返回将排列分解为换位列表。
unrank_lex(size, rank)	字典序排列的无排名。
unrank_nonlex(n, r)	这是一个不遵循字典顺序的线性时间无排名算法 [3]。
unrank_trotterjohnson(size, rank)	Trotter Johnson 排列无排名。
xreplace(rule[, hack2])

复制
could_extract_minus_sign
is_hypergeometric

参见

Cycle

参考文献

[1]

Skiena, S. ‘排列.’ 1.1 在 Implementing Discrete Mathematics Combinatorics and Graph Theory with Mathematica. Reading, MA: Addison-Wesley, pp. 3-16, 1990.

[2]

Knuth, D. E. 《计算机程序设计艺术》，第4卷：组合算法，第1版。马萨诸塞州雷丁：Addison-Wesley出版社，2011年。

[3]

Wendy Myrvold 和 Frank Ruskey. 2001. 在線性時間內排列和取消排列。Inf. Process. Lett. 79, 6 (2001年9月), 281-284. DOI=10.1016/S0020-0190(01)00141-7

[4]

D. L. Kreher, D. R. Stinson ‘Combinatorial Algorithms’ CRC Press, 1999

[5]

Graham, R. L.; Knuth, D. E.; 和 Patashnik, O. 《具体数学：计算机科学基础》，第二版。Reading, MA: Addison-Wesley, 1994.

[6]

https://en.wikipedia.org/w/index.php?oldid=499948155#产品和逆元素

[7]

https://zh.wikipedia.org/wiki/勒梅尔编码

apply(i)

将排列应用于表达式。

参数:

i表达式

它应该是一个介于 \(0\) 和 \(n-1\) 之间的整数，其中 \(n\) 是排列的大小。

如果它是一个可以有整数值的符号或符号表达式，将返回一个 AppliedPermutation 对象，该对象可以表示一个未计算的函数。

注释

任何排列都可以定义为一个双射函数 \(\sigma : \{ 0, 1, \dots, n-1 \} \rightarrow \{ 0, 1, \dots, n-1 \}\)，其中 \(n\) 表示排列的大小。

该定义甚至可以扩展到任何具有独特元素的集合，使得排列甚至可以应用于实数等，然而，由于计算原因和与群论模块的完整性，目前尚未实现。

此函数类似于 __call__ 魔术方法，然而，__call__ 魔术方法已经有一些其他应用，例如排列数组或附加新周期，这些应用并不总是数学上一致的。

这也保证了返回类型是一个 SymPy 整数，这保证了使用假设的安全性。

property array_form

Return a copy of the attribute _array_form .. rubric:: 示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([[2, 0], [3, 1]])
>>> p.array_form
[2, 3, 0, 1]
>>> Permutation([[2, 0, 3, 1]]).array_form
[3, 2, 0, 1]
>>> Permutation([2, 0, 3, 1]).array_form
[2, 0, 3, 1]
>>> Permutation([[1, 2], [4, 5]]).array_form
[0, 2, 1, 3, 5, 4]

ascents()

返回排列中的上升位置，即 p[i] < p[i+1] 的位置。

参见

descents, inversions, min, max

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([4, 0, 1, 3, 2])
>>> p.ascents()
[1, 2]

atoms()

返回排列的所有元素

示例

>>> from sympy.combinatorics import Permutation
>>> Permutation([0, 1, 2, 3, 4, 5]).atoms()
{0, 1, 2, 3, 4, 5}
>>> Permutation([[0, 1], [2, 3], [4, 5]]).atoms()
{0, 1, 2, 3, 4, 5}

property cardinality

返回所有可能排列的数量。

参见

length, order, rank, size

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([0, 1, 2, 3])
>>> p.cardinality
24

commutator(x)

返回 self 和 x 的交换子：~x*~self*x*self

如果 f 和 g 是一个群 G 的元素，那么 f 和 g 的换位子是群的单位元当且仅当 f 和 g 可交换，即 fg == gf。

参考文献

[1]

https://zh.wikipedia.org/wiki/换向器

示例

>>> from sympy.combinatorics import Permutation
>>> from sympy import init_printing
>>> init_printing(perm_cyclic=False, pretty_print=False)
>>> p = Permutation([0, 2, 3, 1])
>>> x = Permutation([2, 0, 3, 1])
>>> c = p.commutator(x); c
Permutation([2, 1, 3, 0])
>>> c == ~x*~p*x*p
True

>>> I = Permutation(3)
>>> p = [I + i for i in range(6)]
>>> for i in range(len(p)):
...     for j in range(len(p)):
...         c = p[i].commutator(p[j])
...         if p[i]*p[j] == p[j]*p[i]:
...             assert c == I
...         else:
...             assert c != I
...

commutes_with(other)

检查元素是否可交换。

示例

>>> from sympy.combinatorics import Permutation
>>> a = Permutation([1, 4, 3, 0, 2, 5])
>>> b = Permutation([0, 1, 2, 3, 4, 5])
>>> a.commutes_with(b)
True
>>> b = Permutation([2, 3, 5, 4, 1, 0])
>>> a.commutes_with(b)
False

property cycle_structure

返回置换的循环结构，以字典形式表示每个循环长度的多重性。

示例

>>> from sympy.combinatorics import Permutation
>>> Permutation(3).cycle_structure
{1: 4}
>>> Permutation(0, 4, 3)(1, 2)(5, 6).cycle_structure
{2: 2, 3: 1}

property cycles

返回置换中包含的循环数（包括单元素循环）。

参见

sympy.functions.combinatorial.numbers.stirling

示例

>>> from sympy.combinatorics import Permutation
>>> Permutation([0, 1, 2]).cycles
3
>>> Permutation([0, 1, 2]).full_cyclic_form
[[0], [1], [2]]
>>> Permutation(0, 1)(2, 3).cycles
2

property cyclic_form

这用于从规范表示法转换为循环表示法。单例被省略。

参见

array_form, full_cyclic_form

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([0, 3, 1, 2])
>>> p.cyclic_form
[[1, 3, 2]]
>>> Permutation([1, 0, 2, 4, 3, 5]).cyclic_form
[[0, 1], [3, 4]]

descents()

返回排列中下降的位置，即 p[i] > p[i+1] 的位置。

参见

ascents, inversions, min, max

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([4, 0, 1, 3, 2])
>>> p.descents()
[0, 3]

classmethod from_inversion_vector(inversion)

计算从逆向量得到排列。

示例

>>> from sympy.combinatorics import Permutation
>>> from sympy import init_printing
>>> init_printing(perm_cyclic=False, pretty_print=False)
>>> Permutation.from_inversion_vector([3, 2, 1, 0, 0])
Permutation([3, 2, 1, 0, 4, 5])

classmethod from_sequence(i, key=None)

返回从 i 的排序元素中获得 i 所需排列。如果需要自定义排序，可以提供一个键。

示例

>>> from sympy.combinatorics import Permutation

>>> Permutation.from_sequence('SymPy')
(4)(0 1 3)
>>> _(sorted("SymPy"))
['S', 'y', 'm', 'P', 'y']
>>> Permutation.from_sequence('SymPy', key=lambda x: x.lower())
(4)(0 2)(1 3)

property full_cyclic_form

返回包括单个元素在内的循环形式的排列。

示例

>>> from sympy.combinatorics import Permutation
>>> Permutation([0, 2, 1]).full_cyclic_form
[[0], [1, 2]]

get_adjacency_distance(other)

计算两个排列之间的邻接距离。

参见

get_precedence_matrix, get_precedence_distance, get_adjacency_matrix

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([0, 3, 1, 2, 4])
>>> q = Permutation.josephus(4, 5, 2)
>>> p.get_adjacency_distance(q)
3
>>> r = Permutation([0, 2, 1, 4, 3])
>>> p.get_adjacency_distance(r)
4

get_adjacency_matrix()

计算置换的邻接矩阵。

参见

get_precedence_matrix, get_precedence_distance, get_adjacency_distance

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation.josephus(3, 6, 1)
>>> p.get_adjacency_matrix()
Matrix([
[0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 1],
[0, 1, 0, 0, 0, 0],
[1, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0]])
>>> q = Permutation([0, 1, 2, 3])
>>> q.get_adjacency_matrix()
Matrix([
[0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1],
[0, 0, 0, 0]])

get_positional_distance(other)

计算两个排列之间的位置距离。

参见

get_precedence_distance, get_adjacency_distance

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([0, 3, 1, 2, 4])
>>> q = Permutation.josephus(4, 5, 2)
>>> r = Permutation([3, 1, 4, 0, 2])
>>> p.get_positional_distance(q)
12
>>> p.get_positional_distance(r)
12

get_precedence_distance(other)

计算两个排列之间的优先距离。

参见

get_precedence_matrix, get_adjacency_matrix, get_adjacency_distance

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([2, 0, 4, 3, 1])
>>> q = Permutation([3, 1, 2, 4, 0])
>>> p.get_precedence_distance(q)
7
>>> q.get_precedence_distance(p)
7

get_precedence_matrix()

获取优先级矩阵。这用于计算两个排列之间的距离。

参见

get_precedence_distance, get_adjacency_matrix, get_adjacency_distance

示例

>>> from sympy.combinatorics import Permutation
>>> from sympy import init_printing
>>> init_printing(perm_cyclic=False, pretty_print=False)
>>> p = Permutation.josephus(3, 6, 1)
>>> p
Permutation([2, 5, 3, 1, 4, 0])
>>> p.get_precedence_matrix()
Matrix([
[0, 0, 0, 0, 0, 0],
[1, 0, 0, 0, 1, 0],
[1, 1, 0, 1, 1, 1],
[1, 1, 0, 0, 1, 0],
[1, 0, 0, 0, 0, 0],
[1, 1, 0, 1, 1, 0]])

index()

返回一个排列的索引。

排列的索引是所有下标 j 的和，其中 p[j] 大于 p[j+1]。

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([3, 0, 2, 1, 4])
>>> p.index()
2

inversion_vector()

返回排列的逆向量。

逆向向量由一些元素组成，这些元素的值表示在排列中比它小且位于其右侧的元素的数量。

逆向向量与排列的Lehmer编码相同。

参见

from_inversion_vector

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([4, 8, 0, 7, 1, 5, 3, 6, 2])
>>> p.inversion_vector()
[4, 7, 0, 5, 0, 2, 1, 1]
>>> p = Permutation([3, 2, 1, 0])
>>> p.inversion_vector()
[3, 2, 1]

逆向向量随排列的秩按字典顺序增加，第 -i 个元素在 0..i 之间循环。

>>> p = Permutation(2)
>>> while p:
...     print('%s %s %s' % (p, p.inversion_vector(), p.rank()))
...     p = p.next_lex()
(2) [0, 0] 0
(1 2) [0, 1] 1
(2)(0 1) [1, 0] 2
(0 1 2) [1, 1] 3
(0 2 1) [2, 0] 4
(0 2) [2, 1] 5

inversions()

计算排列的逆序数。

参见

descents, ascents, min, max

参考文献

[1]

https://www.cp.eng.chula.ac.th/~prabhas//teaching/algo/algo2008/count-inv.htm

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([0, 1, 2, 3, 4, 5])
>>> p.inversions()
0
>>> Permutation([3, 2, 1, 0]).inversions()
6

property is_Empty

检查排列是否为零元素的集合

参见

is_Singleton

示例

>>> from sympy.combinatorics import Permutation
>>> Permutation([]).is_Empty
True
>>> Permutation([0]).is_Empty
False

property is_Identity

如果排列是恒等排列，则返回 True。

参见

order

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([])
>>> p.is_Identity
True
>>> p = Permutation([[0], [1], [2]])
>>> p.is_Identity
True
>>> p = Permutation([0, 1, 2])
>>> p.is_Identity
True
>>> p = Permutation([0, 2, 1])
>>> p.is_Identity
False

property is_Singleton

检查排列是否只包含一个数字，因此是这组数字的唯一可能排列

参见

is_Empty

示例

>>> from sympy.combinatorics import Permutation
>>> Permutation([0]).is_Singleton
True
>>> Permutation([0, 1]).is_Singleton
False

property is_even

检查一个排列是否为偶排列。

参见

is_odd

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([0, 1, 2, 3])
>>> p.is_even
True
>>> p = Permutation([3, 2, 1, 0])
>>> p.is_even
True

property is_odd

检查一个排列是否为奇排列。

参见

is_even

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([0, 1, 2, 3])
>>> p.is_odd
False
>>> p = Permutation([3, 2, 0, 1])
>>> p.is_odd
True

classmethod josephus(m, n, s=1)

返回一个排列，使用Josephus方案对range(n)进行洗牌，其中每第m个元素被选中，直到所有元素都被选中。返回的排列按它们被选中的顺序列出元素。

参数 s 在剩余 s 个项目时停止选择过程，并通过继续选择，以1为单位计数而不是以 m 为单位计数来选择这些项目。

考虑从6个项目中每隔3个选择一个，直到只剩下2个:

choices    chosen
========   ======
  012345
  01 345   2
  01 34    25
  01  4    253
  0   4    2531
  0        25314
           253140

参考文献

[1]

https://en.wikipedia.org/wiki/Flavius_Josephus

[2]

https://en.wikipedia.org/wiki/约瑟夫斯问题

[3]

https://web.archive.org/web/20171008094331/http://www.wou.edu/~burtonl/josephus.html

示例

>>> from sympy.combinatorics import Permutation
>>> Permutation.josephus(3, 6, 2).array_form
[2, 5, 3, 1, 4, 0]

length()

返回由排列移动的整数数量。

参见

min, max, support, cardinality, order, rank, size

示例

>>> from sympy.combinatorics import Permutation
>>> Permutation([0, 3, 2, 1]).length()
2
>>> Permutation([[0, 1], [2, 3]]).length()
4

list(size=None)

返回排列为一个显式列表，如果大小小于排列中的最大元素，则可能会修剪未移动的元素；如果需要这样做，设置 size=-1 将保证这种修剪。

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation(2, 3)(4, 5)
>>> p.list()
[0, 1, 3, 2, 5, 4]
>>> p.list(10)
[0, 1, 3, 2, 5, 4, 6, 7, 8, 9]

传递一个过小的长度将修剪排列中尾部未改变的元素：

>>> Permutation(2, 4)(1, 2, 4).list(-1)
[0, 2, 1]
>>> Permutation(3).list(-1)
[]

max() → int

置换移动的最大元素。

参见

min, descents, ascents, inversions

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([1, 0, 2, 3, 4])
>>> p.max()
1

min() → int

置换移动的最小元素。

参见

max, descents, ascents, inversions

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([0, 1, 4, 3, 2])
>>> p.min()
2

mul_inv(other)

other*~self, self 和 other 具有 _array_form

next_lex()

返回按字典顺序的下一个排列。如果自身是按字典顺序的最后一个排列，则返回 None。参见 [4] 第 2.4 节。

参见

rank, unrank_lex

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([2, 3, 1, 0])
>>> p = Permutation([2, 3, 1, 0]); p.rank()
17
>>> p = p.next_lex(); p.rank()
18

next_nonlex()

返回非字典序的下一个排列 [3]。如果 self 是此顺序中的最后一个排列，则返回 None。

参见

rank_nonlex, unrank_nonlex

示例

>>> from sympy.combinatorics import Permutation
>>> from sympy import init_printing
>>> init_printing(perm_cyclic=False, pretty_print=False)
>>> p = Permutation([2, 0, 3, 1]); p.rank_nonlex()
5
>>> p = p.next_nonlex(); p
Permutation([3, 0, 1, 2])
>>> p.rank_nonlex()
6

next_trotterjohnson()

返回Trotter-Johnson顺序中的下一个排列。如果self是最后一个排列，则返回None。参见[4]第2.4节。如果希望生成所有此类排列，可以使用``generate_bell``函数更快地按顺序生成它们。

参见

rank_trotterjohnson, unrank_trotterjohnson, sympy.utilities.iterables.generate_bell

示例

>>> from sympy.combinatorics import Permutation
>>> from sympy import init_printing
>>> init_printing(perm_cyclic=False, pretty_print=False)
>>> p = Permutation([3, 0, 2, 1])
>>> p.rank_trotterjohnson()
4
>>> p = p.next_trotterjohnson(); p
Permutation([0, 3, 2, 1])
>>> p.rank_trotterjohnson()
5

order()

计算排列的阶。

当排列的幂次等于其阶数时，它等于单位排列。

参见

identity, cardinality, length, rank, size

示例

>>> from sympy.combinatorics import Permutation
>>> from sympy import init_printing
>>> init_printing(perm_cyclic=False, pretty_print=False)
>>> p = Permutation([3, 1, 5, 2, 4, 0])
>>> p.order()
4
>>> (p**(p.order()))
Permutation([], size=6)

parity()

计算排列的奇偶性。

参见

_af_parity

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([0, 1, 2, 3])
>>> p.parity()
0
>>> p = Permutation([3, 2, 0, 1])
>>> p.parity()
1

classmethod random(n)

生成一个长度为 n 的随机排列。

使用底层的 Python 伪随机数生成器。

示例

>>> from sympy.combinatorics import Permutation
>>> Permutation.random(2) in (Permutation([1, 0]), Permutation([0, 1]))
True

rank()

返回排列的字典序排名。

参见

next_lex, unrank_lex, cardinality, length, order, size

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([0, 1, 2, 3])
>>> p.rank()
0
>>> p = Permutation([3, 2, 1, 0])
>>> p.rank()
23

rank_nonlex(inv_perm=None)

这是一个线性时间排序算法，不强制执行字典顺序 [3]。

参见

next_nonlex, unrank_nonlex

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([0, 1, 2, 3])
>>> p.rank_nonlex()
23

rank_trotterjohnson()

返回Trotter Johnson秩，这是我们从最小变化算法中得到的。参见[4]第2.4节。

参见

unrank_trotterjohnson, next_trotterjohnson

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([0, 1, 2, 3])
>>> p.rank_trotterjohnson()
0
>>> p = Permutation([0, 2, 1, 3])
>>> p.rank_trotterjohnson()
7

resize(n)

将排列调整为新的尺寸 n。

参数:

n整数

排列的新大小。

Raises:

ValueError

如果排列不能调整到给定的大小。这可能仅在调整到比原始尺寸更小的尺寸时发生。

示例

>>> from sympy.combinatorics import Permutation

增加排列的大小：

>>> p = Permutation(0, 1, 2)
>>> p = p.resize(5)
>>> p
(4)(0 1 2)

减小排列的大小：

>>> p = p.resize(4)
>>> p
(3)(0 1 2)

如果调整到特定大小会破坏循环：

>>> p.resize(2)
Traceback (most recent call last):
...
ValueError: The permutation cannot be resized to 2 because the
cycle (0, 1, 2) may break.

static rmul(*args)

返回排列 [a, b, c, …] 的乘积作为排列，其第 i 个值为 a(b(c(i)))。

a, b, c, … 可以是排列对象或元组。

注释

只要第一个项目是排列，序列中的所有项目都将根据需要由排列进行解析：

>>> Permutation.rmul(a, [0, 2, 1]) == Permutation.rmul(a, b)
True

参数的反向顺序将引发 TypeError。

示例

>>> from sympy.combinatorics import Permutation

>>> a, b = [1, 0, 2], [0, 2, 1]
>>> a = Permutation(a); b = Permutation(b)
>>> list(Permutation.rmul(a, b))
[1, 2, 0]
>>> [a(b(i)) for i in range(3)]
[1, 2, 0]

这与 * 运算符相比，处理操作数的顺序是相反的：

>>> a = Permutation(a); b = Permutation(b)
>>> list(a*b)
[2, 0, 1]
>>> [b(a(i)) for i in range(3)]
[2, 0, 1]

classmethod rmul_with_af(*args)

与 rmul 相同，但 args 的元素是 Permutation 对象，这些对象具有 _array_form

runs()

返回排列的运行。

在排列中，一个升序序列被称为一个 run [5]。

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([2, 5, 7, 3, 6, 0, 1, 4, 8])
>>> p.runs()
[[2, 5, 7], [3, 6], [0, 1, 4, 8]]
>>> q = Permutation([1,3,2,0])
>>> q.runs()
[[1, 3], [2], [0]]

signature()

给出将置换元素排列为规范顺序所需的置换签名。

签名是按 (-1)^<逆序数> 计算的

参见

inversions

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([0, 1, 2])
>>> p.inversions()
0
>>> p.signature()
1
>>> q = Permutation([0,2,1])
>>> q.inversions()
1
>>> q.signature()
-1

property size

返回排列中的元素数量。

参见

cardinality, length, order, rank

示例

>>> from sympy.combinatorics import Permutation
>>> Permutation([[3, 2], [0, 1]]).size
4

support()

返回排列 P 中满足 P[i] != i 的元素。

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([[3, 2], [0, 1], [4]])
>>> p.array_form
[1, 0, 3, 2, 4]
>>> p.support()
[0, 1, 2, 3]

transpositions()

返回将排列分解为换位列表。

参考文献

[1]

https://en.wikipedia.org/wiki/Transposition_%28mathematics%29#Properties

示例

>>> from sympy.combinatorics import Permutation
>>> p = Permutation([[1, 2, 3], [0, 4, 5, 6, 7]])
>>> t = p.transpositions()
>>> t
[(0, 7), (0, 6), (0, 5), (0, 4), (1, 3), (1, 2)]
>>> print(''.join(str(c) for c in t))
(0, 7)(0, 6)(0, 5)(0, 4)(1, 3)(1, 2)
>>> Permutation.rmul(*[Permutation([ti], size=p.size) for ti in t]) == p
True

classmethod unrank_lex(size, rank)

字典序排列的无排名。

参见

rank, next_lex

示例

>>> from sympy.combinatorics import Permutation
>>> from sympy import init_printing
>>> init_printing(perm_cyclic=False, pretty_print=False)
>>> a = Permutation.unrank_lex(5, 10)
>>> a.rank()
10
>>> a
Permutation([0, 2, 4, 1, 3])

classmethod unrank_nonlex(n, r)

这是一个不遵循字典顺序的线性时间无排名算法 [3]。

参见

next_nonlex, rank_nonlex

示例

>>> from sympy.combinatorics import Permutation
>>> from sympy import init_printing
>>> init_printing(perm_cyclic=False, pretty_print=False)
>>> Permutation.unrank_nonlex(4, 5)
Permutation([2, 0, 3, 1])
>>> Permutation.unrank_nonlex(4, -1)
Permutation([0, 1, 2, 3])

classmethod unrank_trotterjohnson(size, rank)

Trotter Johnson 排列无排名。参见 [4] 第 2.4 节。

参见

rank_trotterjohnson, next_trotterjohnson

示例

>>> from sympy.combinatorics import Permutation
>>> from sympy import init_printing
>>> init_printing(perm_cyclic=False, pretty_print=False)
>>> Permutation.unrank_trotterjohnson(5, 10)
Permutation([0, 3, 1, 2, 4])

class sympy.combinatorics.permutations.Cycle(*args)

围绕字典的包装器，提供了不相交循环的功能。

属性:

大小

方法

__call__(*other)	返回从 R 到 L 处理后的循环乘积。
clear()
copy()
fromkeys(iterable[, value])	使用可迭代对象中的键创建一个新字典，并将值设置为指定的值。
get(key[, default])	如果字典中存在键，则返回键的值，否则返回默认值。
items()
keys()
list([size])	返回一个从 0 开始到循环中最大值和大小中较大者的显式列表。
pop(key[, default])	如果未找到键，则返回给定的默认值；否则，引发 KeyError。
popitem(/)	移除并返回一个 (键, 值) 对作为 2-tuple。
setdefault(key[, default])	如果字典中不存在键，则插入键并赋予默认值。
update([E, ]**F)	如果 E 存在且有 .keys() 方法，则执行： for k in E: D[k] = E[k] 如果 E 存在但没有 .keys() 方法，则执行： for k, v in E: D[k] = v 在任何一种情况下，之后都会执行： for k in F: D[k] = F[k]
values()

参见

Permutation

注释

Cycle 的底层结构是一个字典，尽管 __iter__ 方法已被重新定义以提供循环的数组形式，但底层字典项仍然可以通过 items() 等方法访问。

>>> list(Cycle(1, 2).items())
[(1, 2), (2, 1)]

list(size=None)

返回一个从 0 开始到循环中最大值和大小中较大者的显式列表。

当大小小于循环中的最大元素时，将发生尾部未移动项的截断；如果需要这种截断，设置 size=-1 将保证这种修剪。

示例

>>> from sympy.combinatorics import Cycle
>>> p = Cycle(2, 3)(4, 5)
>>> p.list()
[0, 1, 3, 2, 5, 4]
>>> p.list(10)
[0, 1, 3, 2, 5, 4, 6, 7, 8, 9]

传递一个过小的长度将修剪排列中尾部未改变的元素：

>>> Cycle(2, 4)(1, 2, 4).list(-1)
[0, 2, 1]

sympy.combinatorics.permutations._af_parity(pi)

计算数组形式排列的奇偶性。

参见

Permutation

示例

>>> from sympy.combinatorics.permutations import _af_parity
>>> _af_parity([0, 1, 2, 3])
0
>>> _af_parity([3, 2, 0, 1])
1

生成器

generators.symmetric()

生成阶为 n 的对称群，Sn。

示例

>>> from sympy.combinatorics.generators import symmetric
>>> list(symmetric(3))
[(2), (1 2), (2)(0 1), (0 1 2), (0 2 1), (0 2)]

generators.cyclic()

生成阶为 n 的循环群，Cn。

参见

dihedral

示例

>>> from sympy.combinatorics.generators import cyclic
>>> list(cyclic(5))
[(4), (0 1 2 3 4), (0 2 4 1 3),
 (0 3 1 4 2), (0 4 3 2 1)]

generators.alternating()

生成阶为 n 的交替群，An。

示例

>>> from sympy.combinatorics.generators import alternating
>>> list(alternating(3))
[(2), (0 1 2), (0 2 1)]

generators.dihedral()

生成阶为 2n 的二面体群 Dn。

结果给定为 Sn 的一个子群，除了特殊情况 n=1（群 S2）和 n=2（Klein 4-群），在这些情况下不可能实现，分别给出了嵌入在 S2 和 S4 中。

参见

cyclic

示例

>>> from sympy.combinatorics.generators import dihedral
>>> list(dihedral(3))
[(2), (0 2), (0 1 2), (1 2), (0 2 1), (2)(0 1)]