李代数

class sympy.liealgebras.root_system.RootSystem(cartantype)

表示一个简单李代数的根系

每个简单的李代数都有一个唯一的根系。为了找到根系，我们首先考虑 g 的卡坦子代数，这是最大的交换子代数，并考虑 g 在这个子代数上的伴随作用。与此作用相关联的是一个根系。现在，向量空间 V 上的一个根系是一个有限向量集 Φ（称为根），它们满足：

1. 根跨越 V

2. 在 Phi 中，x 的唯一标量倍数是 x 和 -x

3. 对于Phi中的每一个x，集合Phi在通过垂直于x的超平面的反射下是封闭的。

4. 如果 x 和 y 是 Phi 中的根，那么 y 在通过 x 的直线上的投影是 x 的半整数倍。

现在，存在一个 Phi 的子集，我们称之为 Delta，使得：1. Delta 是 V 的基 2. 每个根 x 在 Phi 中都可以写成 x = ∑ k_y y 对于 y 在 Delta 中

Delta 的元素被称为单根。因此，我们看到单根张成了给定单李代数的根空间。

属性:

args

返回 ‘self’ 的参数元组。

assumptions0

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

canonical_variables

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

expr_free_symbols

free_symbols

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

func

表达式中的顶级函数。

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_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

方法

add_as_roots(root1, root2)	当且仅当它们的和也是根时，将两个根相加
add_simple_roots(root1, root2)	将两个简单的根相加
all_roots()	生成给定根系的所有根
as_content_primitive([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
as_dummy()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
atoms(*types)	返回构成当前对象的原子。
cartan_matrix()	与此根系相关的李代数的嘉当矩阵
class_key()
compare(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
count(query)	计算匹配的子表达式的数量。
count_ops([visual])	用于返回操作计数的 count_ops 的包装器。
doit(**hints)
dummy_eq(other[, symbol])	比较两个表达式并处理哑符号。
dynkin_diagram()	与此根系相关的李代数的Dynkin图
find(query[, group])	查找所有匹配查询的子表达式。
fromiter(args, **assumptions)	从可迭代对象创建一个新对象。
has(*patterns)	测试是否有任何子表达式匹配任何模式。
has_free(*patterns)	如果 self 包含对象 x 作为自由表达式，则返回 True，否则返回 False。
has_xfree(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
is_same(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
match(pattern[, old])	模式匹配。
matches(expr[, repl_dict, old])
rcall(*args)	通过表达式树递归应用于参数。
refine([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
replace(query, value[, map, simultaneous, exact])	将 self 中匹配的子表达式替换为 value。
rewrite(*args[, deep])	使用定义的规则重写 self。
root_space()	返回简单根的跨度
simple_roots()	生成李代数的简单根
simplify(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])
subs(*args, **kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
xreplace(rule[, hack2])

复制
could_extract_minus_sign
is_hypergeometric

参考文献

[1]

https://en.wikipedia.org/wiki/根系

[2]

李代数与表示论 - Humphreys

add_as_roots(root1, root2)

当且仅当它们的和也是根时，将两个根相加

它以两个向量作为输入，这两个向量应该是根。然后计算它们的和，并检查它是否在所有可能的根的列表中。如果是，则返回和。否则，返回一个字符串，说明和不是一个根。

示例

>>> from sympy.liealgebras.root_system import RootSystem
>>> c = RootSystem("A3")
>>> c.add_as_roots([1, 0, -1, 0], [0, 0, 1, -1])
[1, 0, 0, -1]
>>> c.add_as_roots([1, -1, 0, 0], [0, 0, -1, 1])
'The sum of these two roots is not a root'

add_simple_roots(root1, root2)

将两个简单的根相加

该函数以两个整数 root1 和 root2 作为输入。然后，它使用这些整数作为简单根字典中的键，并获取相应的简单根，然后将它们相加。

示例

>>> from sympy.liealgebras.root_system import RootSystem
>>> c = RootSystem("A3")
>>> newroot = c.add_simple_roots(1, 2)
>>> newroot
[1, 0, -1, 0]

all_roots()

生成给定根系的所有根

结果是一个字典，其中键是整数。它通过从基类中获取所有正根的字典，然后取每个根，乘以 -1 并将其添加到字典中来生成根。通过这种方式生成所有负根。

cartan_matrix()

与此根系相关的李代数的嘉当矩阵

示例

>>> from sympy.liealgebras.root_system import RootSystem
>>> c = RootSystem("A3")
>>> c.cartan_matrix()
Matrix([
    [ 2, -1,  0],
    [-1,  2, -1],
    [ 0, -1,  2]])

dynkin_diagram()

与此根系相关的李代数的Dynkin图

示例

>>> from sympy.liealgebras.root_system import RootSystem
>>> c = RootSystem("A3")
>>> print(c.dynkin_diagram())
0---0---0
1   2   3

root_space()

返回简单根的跨度

根空间是由单根张成的向量空间，即它是一个具有区分基的向量空间，单根。此方法返回一个字符串，该字符串表示根空间为单根 alpha[1],…., alpha[n] 的张成。

示例

>>> from sympy.liealgebras.root_system import RootSystem
>>> c = RootSystem("A3")
>>> c.root_space()
'alpha[1] + alpha[2] + alpha[3]'

simple_roots()

生成李代数的简单根

李代数的秩决定了它所拥有的单根的数量。此方法获取李代数的秩，然后使用李代数类中的simple_root方法生成所有单根。

示例

>>> from sympy.liealgebras.root_system import RootSystem
>>> c = RootSystem("A3")
>>> roots = c.simple_roots()
>>> roots
{1: [1, -1, 0, 0], 2: [0, 1, -1, 0], 3: [0, 0, 1, -1]}

class sympy.liealgebras.type_a.TypeA(n)

此类包含有关 A 系列简单李代数的信息。 ====

属性:

args

返回 ‘self’ 的参数元组。

assumptions0

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

canonical_variables

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

expr_free_symbols

free_symbols

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

func

表达式中的顶级函数。

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_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

方法

as_content_primitive([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
as_dummy()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
atoms(*types)	返回构成当前对象的原子。
basic_root(i, j)	这是一个仅在第 i 位置生成 1，在第 j 位置生成 -1 的方法。
basis()	返回 A_n 的独立生成元的数量
cartan_matrix()	返回 A_n 的 Cartan 矩阵。
class_key()
compare(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
count(query)	计算匹配的子表达式的数量。
count_ops([visual])	用于返回操作计数的 count_ops 的包装器。
dimension()	李代数基础向量空间 V 的维数
doit(**hints)
dummy_eq(other[, symbol])	比较两个表达式并处理哑符号。
find(query[, group])	查找所有匹配查询的子表达式。
fromiter(args, **assumptions)	从可迭代对象创建一个新对象。
has(*patterns)	测试是否有任何子表达式匹配任何模式。
has_free(*patterns)	如果 self 包含对象 x 作为自由表达式，则返回 True，否则返回 False。
has_xfree(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
highest_root()	返回 A_n 的最高权重根
is_same(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
lie_algebra()	返回与 A_n 相关的李代数
match(pattern[, old])	模式匹配。
matches(expr[, repl_dict, old])
positive_roots()	此方法生成 A_n 的所有正根。
rank()	返回李代数的秩
rcall(*args)	通过表达式树递归应用于参数。
refine([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
replace(query, value[, map, simultaneous, exact])	将 self 中匹配的子表达式替换为 value。
rewrite(*args[, deep])	使用定义的规则重写 self。
roots()	返回 A_n 的总根数
series()	返回李代数的类型
simple_root(i)	每个李代数都有一个唯一的根系。
simplify(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])
subs(*args, **kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
xreplace(rule[, hack2])

复制
could_extract_minus_sign
dynkin_diagram
is_hypergeometric

basic_root(i, j)

这是一个仅在第 i 位置生成 1，在第 j 位置生成 -1 的方法。

basis()

返回 A_n 的独立生成元的数量

cartan_matrix()

返回 A_n 的 Cartan 矩阵。李代数的 Cartan 矩阵是通过为单根分配一个顺序（alpha[1], …., alpha[l]）生成的。然后，Cartan 矩阵的第 ij 个条目是 (<alpha[i],alpha[j]>).

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType('A4')
>>> c.cartan_matrix()
Matrix([
[ 2, -1,  0,  0],
[-1,  2, -1,  0],
[ 0, -1,  2, -1],
[ 0,  0, -1,  2]])

dimension()

李代数基础向量空间 V 的维数

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("A4")
>>> c.dimension()
5

highest_root()

返回 A_n 的最高权重根

lie_algebra()

返回与 A_n 相关的李代数

positive_roots()

此方法生成 A_n 的所有正根。这是 A_n 所有根的一半；通过将所有正根乘以 -1，我们得到负根。

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("A3")
>>> c.positive_roots()
{1: [1, -1, 0, 0], 2: [1, 0, -1, 0], 3: [1, 0, 0, -1], 4: [0, 1, -1, 0],
        5: [0, 1, 0, -1], 6: [0, 0, 1, -1]}

roots()

返回 A_n 的总根数

simple_root(i)

每个李代数都有一个唯一的根系。给定一个根系 Q，存在一个根的子集，使得 Q 中的元素如果不能被写成 Q 中两个元素的和，则称为简单根。如果我们用 D 表示简单根的集合，那么显然 Q 中的每个元素都可以被写成 D 中元素的线性组合，且所有系数均为非负。

在 A_n 中，第 i 个简单根是根，它在第 i 个位置有一个 1，在第 (i+1) 个位置有一个 -1，其他位置为零。

此方法返回 A 系列中的第 i 个简单根。

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("A4")
>>> c.simple_root(1)
[1, -1, 0, 0, 0]

class sympy.liealgebras.type_b.TypeB(n)

属性:

args

返回 ‘self’ 的参数元组。

assumptions0

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

canonical_variables

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

expr_free_symbols

free_symbols

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

func

表达式中的顶级函数。

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_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

方法

as_content_primitive([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
as_dummy()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
atoms(*types)	返回构成当前对象的原子。
basic_root(i, j)	这是一个仅在第 i 位置生成 1，在第 j 位置生成 -1 的方法。
basis()	返回 B_n 的独立生成元的数量
cartan_matrix()	返回 B_n 的 Cartan 矩阵。
class_key()
compare(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
count(query)	计算匹配的子表达式的数量。
count_ops([visual])	用于返回操作计数的 count_ops 的包装器。
dimension()	李代数基础向量空间 V 的维数
doit(**hints)
dummy_eq(other[, symbol])	比较两个表达式并处理哑符号。
find(query[, group])	查找所有匹配查询的子表达式。
fromiter(args, **assumptions)	从可迭代对象创建一个新对象。
has(*patterns)	测试是否有任何子表达式匹配任何模式。
has_free(*patterns)	如果 self 包含对象 x 作为自由表达式，则返回 True，否则返回 False。
has_xfree(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
is_same(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
lie_algebra()	返回与 B_n 相关的李代数
match(pattern[, old])	模式匹配。
matches(expr[, repl_dict, old])
positive_roots()	此方法生成 A_n 的所有正根。
rank()	返回李代数的秩
rcall(*args)	通过表达式树递归应用于参数。
refine([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
replace(query, value[, map, simultaneous, exact])	将 self 中匹配的子表达式替换为 value。
rewrite(*args[, deep])	使用定义的规则重写 self。
roots()	返回 B_n 的总根数
series()	返回李代数的类型
simple_root(i)	每个李代数都有一个唯一的根系。
simplify(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])
subs(*args, **kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
xreplace(rule[, hack2])

复制
could_extract_minus_sign
dynkin_diagram
is_hypergeometric

basic_root(i, j)

这是一个仅在第 i 位置生成 1，在第 j 位置生成 -1 的方法。

basis()

返回 B_n 的独立生成元的数量

cartan_matrix()

返回 B_n 的 Cartan 矩阵。李代数的 Cartan 矩阵是通过对单根（alpha[1], …., alpha[l]）进行排序生成的。然后，Cartan 矩阵的第 ij 个条目是（<alpha[i],alpha[j]>）。

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType('B4')
>>> c.cartan_matrix()
Matrix([
[ 2, -1,  0,  0],
[-1,  2, -1,  0],
[ 0, -1,  2, -2],
[ 0,  0, -1,  2]])

dimension()

李代数基础向量空间 V 的维数

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("B3")
>>> c.dimension()
3

lie_algebra()

返回与 B_n 相关的李代数

positive_roots()

此方法生成 A_n 的所有正根。这是 B_n 所有根的一半；通过将所有正根乘以 -1，我们得到负根。

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("A3")
>>> c.positive_roots()
{1: [1, -1, 0, 0], 2: [1, 0, -1, 0], 3: [1, 0, 0, -1], 4: [0, 1, -1, 0],
        5: [0, 1, 0, -1], 6: [0, 0, 1, -1]}

roots()

返回 B_n 的总根数

simple_root(i)

每个李代数都有一个唯一的根系。给定一个根系 Q，存在一个根的子集，使得 Q 中的元素如果不能被写成 Q 中两个元素的和，则称为简单根。如果我们用 D 表示简单根的集合，那么显然 Q 中的每个元素都可以被写成 D 中元素的线性组合，且所有系数均为非负。

在 B_n 中，前 n-1 个单根与 A_(n-1) 中的根相同（在第 i 个位置为 1，在第 (i+1) 个位置为 -1，其他位置为零）。第 n 个单根是第 n 个位置为 1，其他位置为零的根。

此方法返回 B 系列的第 i 个简单根。

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("B3")
>>> c.simple_root(2)
[0, 1, -1]

class sympy.liealgebras.type_c.TypeC(n)

属性:

args

返回 ‘self’ 的参数元组。

assumptions0

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

canonical_variables

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

expr_free_symbols

free_symbols

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

func

表达式中的顶级函数。

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_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

方法

as_content_primitive([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
as_dummy()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
atoms(*types)	返回构成当前对象的原子。
basic_root(i, j)	在第i个位置生成根为1，在第j个位置生成根为-1
basis()	返回 C_n 的独立生成元的数量
cartan_matrix()	C_n 的嘉当矩阵
class_key()
compare(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
count(query)	计算匹配的子表达式的数量。
count_ops([visual])	用于返回操作计数的 count_ops 的包装器。
dimension()	李代数基础向量空间 V 的维数
doit(**hints)
dummy_eq(other[, symbol])	比较两个表达式并处理哑符号。
find(query[, group])	查找所有匹配查询的子表达式。
fromiter(args, **assumptions)	从可迭代对象创建一个新对象。
has(*patterns)	测试是否有任何子表达式匹配任何模式。
has_free(*patterns)	如果 self 包含对象 x 作为自由表达式，则返回 True，否则返回 False。
has_xfree(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
is_same(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
lie_algebra()	返回与 C_n 相关的李代数
match(pattern[, old])	模式匹配。
matches(expr[, repl_dict, old])
positive_roots()	生成 A_n 的所有正根
rank()	返回李代数的秩
rcall(*args)	通过表达式树递归应用于参数。
refine([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
replace(query, value[, map, simultaneous, exact])	将 self 中匹配的子表达式替换为 value。
rewrite(*args[, deep])	使用定义的规则重写 self。
roots()	返回 C_n 的总根数
series()	返回李代数的类型
simple_root(i)	C 系列的第 i 个简单根
simplify(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])
subs(*args, **kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
xreplace(rule[, hack2])

复制
could_extract_minus_sign
dynkin_diagram
is_hypergeometric

basic_root(i, j)

在第i个位置生成根为1，在第j个位置生成根为-1

basis()

返回 C_n 的独立生成元的数量

cartan_matrix()

C_n 的嘉当矩阵

李代数的Cartan矩阵是通过对单根（alpha[1], …., alpha[l]）进行排序生成的。然后，Cartan矩阵的第ij个条目是（<alpha[i],alpha[j]>）。

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType('C4')
>>> c.cartan_matrix()
Matrix([
[ 2, -1,  0,  0],
[-1,  2, -1,  0],
[ 0, -1,  2, -1],
[ 0,  0, -2,  2]])

dimension()

李代数基础向量空间 V 的维数

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("C3")
>>> c.dimension()
3

lie_algebra()

返回与 C_n 相关的李代数

positive_roots()

生成 A_n 的所有正根

这是 C_n 的所有根的一半；通过将所有正根乘以 -1，我们得到负根。

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("A3")
>>> c.positive_roots()
{1: [1, -1, 0, 0], 2: [1, 0, -1, 0], 3: [1, 0, 0, -1], 4: [0, 1, -1, 0],
        5: [0, 1, 0, -1], 6: [0, 0, 1, -1]}

roots()

返回 C_n 的总根数

simple_root(i)

C 系列的第 i 个简单根

每个李代数都有一个唯一的根系。给定一个根系 Q，存在一个根的子集，使得 Q 中的元素如果不能被写成 Q 中两个元素的和，则称为简单根。如果我们用 D 表示简单根的集合，那么显然 Q 中的每个元素都可以被写成 D 中元素的线性组合，且所有系数均为非负。

在 C_n 中，前 n-1 个单根与 A_(n-1) 中的根相同（在第 i 个位置为 1，第 (i+1) 个位置为 -1，其他位置为零）。第 n 个单根是第 n 个位置为 2，其他位置为零的根。

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("C3")
>>> c.simple_root(2)
[0, 1, -1]

class sympy.liealgebras.type_d.TypeD(n)

属性:

args

返回 ‘self’ 的参数元组。

assumptions0

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

canonical_variables

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

expr_free_symbols

free_symbols

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

func

表达式中的顶级函数。

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_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

方法

as_content_primitive([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
as_dummy()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
atoms(*types)	返回构成当前对象的原子。
basic_root(i, j)	这是一个仅在第 i 位置生成 1，在第 j 位置生成 -1 的方法。
basis()	返回 D_n 的独立生成元的数量
cartan_matrix()	返回 D_n 的 Cartan 矩阵。
class_key()
compare(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
count(query)	计算匹配的子表达式的数量。
count_ops([visual])	用于返回操作计数的 count_ops 的包装器。
dimension()	李代数的基础向量空间 V 的维度
doit(**hints)
dummy_eq(other[, symbol])	比较两个表达式并处理哑符号。
find(query[, group])	查找所有匹配查询的子表达式。
fromiter(args, **assumptions)	从可迭代对象创建一个新对象。
has(*patterns)	测试是否有任何子表达式匹配任何模式。
has_free(*patterns)	如果 self 包含对象 x 作为自由表达式，则返回 True，否则返回 False。
has_xfree(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
is_same(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
lie_algebra()	返回与 D_n 相关的李代数
match(pattern[, old])	模式匹配。
matches(expr[, repl_dict, old])
positive_roots()	此方法生成 A_n 的所有正根。
rank()	返回李代数的秩
rcall(*args)	通过表达式树递归应用于参数。
refine([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
replace(query, value[, map, simultaneous, exact])	将 self 中匹配的子表达式替换为 value。
rewrite(*args[, deep])	使用定义的规则重写 self。
roots()	返回 D_n 的总根数
series()	返回李代数的类型
simple_root(i)	每个李代数都有一个唯一的根系。
simplify(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])
subs(*args, **kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
xreplace(rule[, hack2])

复制
could_extract_minus_sign
dynkin_diagram
is_hypergeometric

basic_root(i, j)

这是一个仅在第 i 位置生成 1，在第 j 位置生成 -1 的方法。

basis()

返回 D_n 的独立生成元的数量

cartan_matrix()

返回 D_n 的 Cartan 矩阵。Lie 代数的 Cartan 矩阵是通过为单根分配一个顺序生成的，（alpha[1], …., alpha[l]）。然后，Cartan 矩阵的第 ij 个条目是 (<alpha[i],alpha[j]>)。

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType('D4')
>>> c.cartan_matrix()
    Matrix([
    [ 2, -1,  0,  0],
    [-1,  2, -1, -1],
    [ 0, -1,  2,  0],
    [ 0, -1,  0,  2]])

dimension()

李代数的基础向量空间 V 的维度

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("D4")
>>> c.dimension()
4

lie_algebra()

返回与 D_n 相关的李代数

positive_roots()

此方法生成 A_n 的所有正根。这是 D_n 所有根的一半，通过将所有正根乘以 -1，我们得到负根。

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("A3")
>>> c.positive_roots()
{1: [1, -1, 0, 0], 2: [1, 0, -1, 0], 3: [1, 0, 0, -1], 4: [0, 1, -1, 0],
        5: [0, 1, 0, -1], 6: [0, 0, 1, -1]}

roots()

返回 D_n 的总根数

simple_root(i)

每个李代数都有一个唯一的根系。给定一个根系 Q，存在一个根的子集，使得 Q 中的元素如果不能被写成 Q 中两个元素的和，则称为简单根。如果我们用 D 表示简单根的集合，那么显然 Q 中的每个元素都可以被写成 D 中元素的线性组合，且所有系数均为非负。

在 D_n 中，前 n-1 个单根与 A_(n-1) 中的根相同（在第 i 个位置为 1，在第 (i+1) 个位置为 -1，其他位置为零）。第 n 个单根是根中第 n 和第 (n-1) 个位置为 1，其他位置为零。

此方法返回 D 系列中的第 i 个简单根。

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("D4")
>>> c.simple_root(2)
[0, 1, -1, 0]

class sympy.liealgebras.type_e.TypeE(n)

属性:

args

返回 ‘self’ 的参数元组。

assumptions0

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

canonical_variables

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

expr_free_symbols

free_symbols

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

func

表达式中的顶级函数。

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_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

方法

as_content_primitive([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
as_dummy()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
atoms(*types)	返回构成当前对象的原子。
basic_root(i, j)	这是一个仅用于在第 i 个位置生成带有 -1 而在第 j 个位置生成 1 的根的方法。
basis()	返回 E_n 的独立生成元的数量
cartan_matrix()	返回 G_2 的 Cartan 矩阵 李代数的 Cartan 矩阵是通过对单根 (alpha[1], ...., alpha[l]) 进行排序生成的。
class_key()
compare(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
count(query)	计算匹配的子表达式的数量。
count_ops([visual])	用于返回操作计数的 count_ops 的包装器。
dimension()	李代数基础向量空间 V 的维数
doit(**hints)
dummy_eq(other[, symbol])	比较两个表达式并处理哑符号。
find(query[, group])	查找所有匹配查询的子表达式。
fromiter(args, **assumptions)	从可迭代对象创建一个新对象。
has(*patterns)	测试是否有任何子表达式匹配任何模式。
has_free(*patterns)	如果 self 包含对象 x 作为自由表达式，则返回 True，否则返回 False。
has_xfree(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
is_same(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
match(pattern[, old])	模式匹配。
matches(expr[, repl_dict, old])
positive_roots()	此方法生成 A_n 的所有正根。
rank()	返回李代数的秩
rcall(*args)	通过表达式树递归应用于参数。
refine([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
replace(query, value[, map, simultaneous, exact])	将 self 中匹配的子表达式替换为 value。
rewrite(*args[, deep])	使用定义的规则重写 self。
roots()	返回 E_n 的总根数
series()	返回李代数的类型
simple_root(i)	每个李代数都有一个唯一的根系。
simplify(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])
subs(*args, **kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
xreplace(rule[, hack2])

复制
could_extract_minus_sign
dynkin_diagram
is_hypergeometric

basic_root(i, j)

这是一个仅用于在第 i 个位置生成带有 -1 而在第 j 个位置生成 1 的根的方法。

basis()

返回 E_n 的独立生成元的数量

cartan_matrix()

返回 G_2 的 Cartan 矩阵 对于一个李代数，Cartan 矩阵是通过对单根（alpha[1], …., alpha[l]）进行排序生成的。然后，Cartan 矩阵的第 ij 项是 (<alpha[i],alpha[j]>).

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType('A4')
>>> c.cartan_matrix()
Matrix([
[ 2, -1,  0,  0],
[-1,  2, -1,  0],
[ 0, -1,  2, -1],
[ 0,  0, -1,  2]])

dimension()

李代数基础向量空间 V 的维数

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("E6")
>>> c.dimension()
8

positive_roots()

此方法生成 A_n 的所有正根。这是 E_n 所有根的一半；通过将所有正根乘以 -1，我们得到负根。

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("A3")
>>> c.positive_roots()
{1: [1, -1, 0, 0], 2: [1, 0, -1, 0], 3: [1, 0, 0, -1], 4: [0, 1, -1, 0],
        5: [0, 1, 0, -1], 6: [0, 0, 1, -1]}

roots()

返回 E_n 的总根数

simple_root(i)

每个李代数都有一个唯一的根系。给定一个根系 Q，存在一个根的子集，使得 Q 中的一个元素被称为简单根，如果它不能被写成 Q 中两个元素的和。如果我们用 D 表示简单根的集合，那么显然 Q 中的每个元素都可以被写成 D 中元素的线性组合，且所有系数均为非负。

此方法返回 E_n 的第 i 个简单根。

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("E6")
>>> c.simple_root(2)
[1, 1, 0, 0, 0, 0, 0, 0]

class sympy.liealgebras.type_f.TypeF(n)

属性:

args

返回 ‘self’ 的参数元组。

assumptions0

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

canonical_variables

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

expr_free_symbols

free_symbols

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

func

表达式中的顶级函数。

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_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

方法

as_content_primitive([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
as_dummy()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
atoms(*types)	返回构成当前对象的原子。
basic_root(i, j)	在第i个位置生成根为1，在第j个位置生成根为-1
basis()	返回 F_4 的独立生成元的数量
cartan_matrix()	F_4 的嘉当矩阵
class_key()
compare(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
count(query)	计算匹配的子表达式的数量。
count_ops([visual])	用于返回操作计数的 count_ops 的包装器。
dimension()	李代数基础向量空间 V 的维数
doit(**hints)
dummy_eq(other[, symbol])	比较两个表达式并处理哑符号。
find(query[, group])	查找所有匹配查询的子表达式。
fromiter(args, **assumptions)	从可迭代对象创建一个新对象。
has(*patterns)	测试是否有任何子表达式匹配任何模式。
has_free(*patterns)	如果 self 包含对象 x 作为自由表达式，则返回 True，否则返回 False。
has_xfree(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
is_same(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
match(pattern[, old])	模式匹配。
matches(expr[, repl_dict, old])
positive_roots()	生成 A_n 的所有正根
rank()	返回李代数的秩
rcall(*args)	通过表达式树递归应用于参数。
refine([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
replace(query, value[, map, simultaneous, exact])	将 self 中匹配的子表达式替换为 value。
rewrite(*args[, deep])	使用定义的规则重写 self。
roots()	返回 F_4 的总根数
series()	返回李代数的类型
simple_root(i)	F_4 的第 i 个简单根
simplify(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])
subs(*args, **kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
xreplace(rule[, hack2])

复制
could_extract_minus_sign
dynkin_diagram
is_hypergeometric

basic_root(i, j)

在第i个位置生成根为1，在第j个位置生成根为-1

basis()

返回 F_4 的独立生成元的数量

cartan_matrix()

F_4 的嘉当矩阵

李代数的Cartan矩阵是通过对单根（alpha[1], …., alpha[l]）进行排序生成的。然后，Cartan矩阵的第ij个条目是（<alpha[i],alpha[j]>）。

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType('A4')
>>> c.cartan_matrix()
Matrix([
[ 2, -1,  0,  0],
[-1,  2, -1,  0],
[ 0, -1,  2, -1],
[ 0,  0, -1,  2]])

dimension()

李代数基础向量空间 V 的维数

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("F4")
>>> c.dimension()
4

positive_roots()

生成 A_n 的所有正根

这是 F_4 的所有根的一半；通过将所有正根乘以 -1，我们得到负根。

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("A3")
>>> c.positive_roots()
{1: [1, -1, 0, 0], 2: [1, 0, -1, 0], 3: [1, 0, 0, -1], 4: [0, 1, -1, 0],
        5: [0, 1, 0, -1], 6: [0, 0, 1, -1]}

roots()

返回 F_4 的总根数

simple_root(i)

F_4 的第 i 个简单根

每个李代数都有一个唯一的根系。给定一个根系 Q，存在一个根的子集，使得 Q 中的元素如果不能被写成 Q 中两个元素的和，则称为简单根。如果我们用 D 表示简单根的集合，那么显然 Q 中的每个元素都可以被写成 D 中元素的线性组合，且所有系数均为非负。

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("F4")
>>> c.simple_root(3)
[0, 0, 0, 1]

class sympy.liealgebras.type_g.TypeG(n)

属性:

args

返回 ‘self’ 的参数元组。

assumptions0

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

canonical_variables

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

expr_free_symbols

free_symbols

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

func

表达式中的顶级函数。

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_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

方法

as_content_primitive([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
as_dummy()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
atoms(*types)	返回构成当前对象的原子。
basis()	返回 G_2 的独立生成元的数量
cartan_matrix()	G_2 的 Cartan 矩阵
class_key()
compare(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
count(query)	计算匹配的子表达式的数量。
count_ops([visual])	用于返回操作计数的 count_ops 的包装器。
dimension()	李代数基础向量空间 V 的维数
doit(**hints)
dummy_eq(other[, symbol])	比较两个表达式并处理哑符号。
find(query[, group])	查找所有匹配查询的子表达式。
fromiter(args, **assumptions)	从可迭代对象创建一个新对象。
has(*patterns)	测试是否有任何子表达式匹配任何模式。
has_free(*patterns)	如果 self 包含对象 x 作为自由表达式，则返回 True，否则返回 False。
has_xfree(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
is_same(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
match(pattern[, old])	模式匹配。
matches(expr[, repl_dict, old])
positive_roots()	生成 A_n 的所有正根
rank()	返回李代数的秩
rcall(*args)	通过表达式树递归应用于参数。
refine([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
replace(query, value[, map, simultaneous, exact])	将 self 中匹配的子表达式替换为 value。
rewrite(*args[, deep])	使用定义的规则重写 self。
roots()	返回 G_2 的总根数
series()	返回李代数的类型
simple_root(i)	G_2 的第 i 个简单根
simplify(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])
subs(*args, **kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
xreplace(rule[, hack2])

复制
could_extract_minus_sign
dynkin_diagram
is_hypergeometric

basis()

返回 G_2 的独立生成元的数量

cartan_matrix()

G_2 的 Cartan 矩阵

李代数的Cartan矩阵是通过对单根（alpha[1], …., alpha[l]）进行排序生成的。然后，Cartan矩阵的第ij个条目是（<alpha[i],alpha[j]>）。

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("G2")
>>> c.cartan_matrix()
Matrix([
    [ 2, -1],
    [-3,  2]])

dimension()

李代数基础向量空间 V 的维数

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("G2")
>>> c.dimension()
3

positive_roots()

生成 A_n 的所有正根

这是 A_n 的所有根的一半；通过将所有正根乘以 -1，我们得到负根。

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("A3")
>>> c.positive_roots()
{1: [1, -1, 0, 0], 2: [1, 0, -1, 0], 3: [1, 0, 0, -1], 4: [0, 1, -1, 0],
        5: [0, 1, 0, -1], 6: [0, 0, 1, -1]}

roots()

返回 G_2 的总根数

simple_root(i)

G_2 的第 i 个简单根

每个李代数都有一个唯一的根系。给定一个根系 Q，存在一个根的子集，使得 Q 中的元素如果不能被写成 Q 中两个元素的和，则称为简单根。如果我们用 D 表示简单根的集合，那么显然 Q 中的每个元素都可以被写成 D 中元素的线性组合，且所有系数均为非负。

示例

>>> from sympy.liealgebras.cartan_type import CartanType
>>> c = CartanType("G2")
>>> c.simple_root(1)
[0, 1, -1]

class sympy.liealgebras.weyl_group.WeylGroup(cartantype)

对于每一个半单李群，我们都有一个Weyl群。它是根系等距群的一个子群。具体来说，它是通过与根正交的超平面的反射生成的子群。因此，Weyl群是反射群，所以Weyl群是一个有限Coxeter群。

属性:

args

返回 ‘self’ 的参数元组。

assumptions0

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

canonical_variables

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

expr_free_symbols

free_symbols

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

func

表达式中的顶级函数。

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_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

方法

as_content_primitive([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
as_dummy()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
atoms(*types)	返回构成当前对象的原子。
class_key()
compare(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
count(query)	计算匹配的子表达式的数量。
count_ops([visual])	用于返回操作计数的 count_ops 的包装器。
coxeter_diagram()	此方法返回与Weyl群对应的Coxeter图。
delete_doubles(reflections)	这是一个用于确定G2的Weyl群中元素顺序的辅助方法。
doit(**hints)
dummy_eq(other[, symbol])	比较两个表达式并处理哑符号。
element_order(weylelt)	此方法返回给定Weyl群元素的阶数，该元素应由用户以生成反射的乘积形式指定，即形式为 r1*r2 等。
find(query[, group])	查找所有匹配查询的子表达式。
fromiter(args, **assumptions)	从可迭代对象创建一个新对象。
generators()	此方法为给定的李代数生成Weyl群的反射。
group_name()	此方法返回给定李代数的Weyl群的一些一般信息。
group_order()	此方法返回Weyl群的顺序。
has(*patterns)	测试是否有任何子表达式匹配任何模式。
has_free(*patterns)	如果 self 包含对象 x 作为自由表达式，则返回 True，否则返回 False。
has_xfree(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
is_same(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
match(pattern[, old])	模式匹配。
matches(expr[, repl_dict, old])
matrix_form(weylelt)	此方法以生成反射的产品形式从用户处获取输入，并返回与Weyl群元素对应的矩阵。
rcall(*args)	通过表达式树递归应用于参数。
refine([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
replace(query, value[, map, simultaneous, exact])	将 self 中匹配的子表达式替换为 value。
rewrite(*args[, deep])	使用定义的规则重写 self。
simplify(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])
subs(*args, **kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
xreplace(rule[, hack2])

复制
could_extract_minus_sign
is_hypergeometric

coxeter_diagram()

此方法返回与Weyl群对应的Coxeter图。Coxeter图可以通过删除李代数的Dynkin图中的所有箭头来获得；Coxeter图是无向图。Coxeter图的顶点表示Weyl群的生成反射，\(s_i\)。如果\(s_i\)和\(s_j\)之间的边的顺序\(m(i, j)\)大于二，则在\(s_i\)和\(s_j\)之间绘制一条边。如果有一条边，顺序\(m(i, j)\)为3。如果有两条边，顺序\(m(i, j)\)为4，如果有三条边，顺序\(m(i, j)\)为6。

示例

>>> from sympy.liealgebras.weyl_group import WeylGroup
>>> c = WeylGroup("B3")
>>> print(c.coxeter_diagram())
0---0===0
1   2   3

delete_doubles(reflections)

这是一个用于确定G2的Weyl群中元素顺序的辅助方法。它接受一个Weyl元素，如果其中重复了简单的反射，则删除它们。

element_order(weylelt)

此方法返回给定Weyl群元素的阶数，该元素应由用户以生成反射的乘积形式指定，即形式为 r1*r2 等。

对于类型 A-F，此方法目前通过获取指定元素的矩阵形式，然后找出矩阵的哪个幂是单位矩阵。然后返回这个幂。

示例

>>> from sympy.liealgebras.weyl_group import WeylGroup
>>> b = WeylGroup("B4")
>>> b.element_order('r1*r4*r2')
4

generators()

此方法为给定的李代数创建Weyl群的生成反射。对于秩为n的李代数，有n个不同的生成反射。此函数以列表形式返回它们。

示例

>>> from sympy.liealgebras.weyl_group import WeylGroup
>>> c = WeylGroup("F4")
>>> c.generators()
['r1', 'r2', 'r3', 'r4']

group_name()

此方法返回给定李代数的Weyl群的一些一般信息。如果相关，它返回群的名称和它所作用的元素。

group_order()

此方法返回Weyl群的阶数。对于类型A、B、C、D和E，阶数取决于李代数的秩。对于类型F和G，阶数是固定的。

示例

>>> from sympy.liealgebras.weyl_group import WeylGroup
>>> c = WeylGroup("D4")
>>> c.group_order()
192.0

matrix_form(weylelt)

此方法以生成反射的产品形式从用户处获取输入，并返回与Weyl群元素对应的矩阵。由于Weyl群的每个元素都是某种类型的反射，因此存在相应的矩阵表示。此方法使用所有生成反射的标准表示。

示例

>>> from sympy.liealgebras.weyl_group import WeylGroup
>>> f = WeylGroup("F4")
>>> f.matrix_form('r2*r3')
Matrix([
[1, 0, 0,  0],
[0, 1, 0,  0],
[0, 0, 0, -1],
[0, 0, 1,  0]])

class sympy.liealgebras.cartan_type.CartanType_generator

用于实际创建事物的构造函数

方法

__call__(*args)

class sympy.liealgebras.cartan_type.Standard_Cartan(series, n)

Cartan 类型的具体基类，例如 A4 等

属性:

args

返回 ‘self’ 的参数元组。

assumptions0

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

canonical_variables

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

expr_free_symbols

free_symbols

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

func

表达式中的顶级函数。

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_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

方法

as_content_primitive([radical, clear])	一个存根，允许在计算表达式的内容和基本组件时跳过基本参数（如元组）。
as_dummy()	返回表达式，其中任何具有结构绑定符号的对象都被替换为在其出现的对象中唯一的规范符号，并且仅对交换性具有默认假设为True。
atoms(*types)	返回构成当前对象的原子。
class_key()
compare(other)	如果对象在规范意义上小于、等于或大于其他对象，则返回 -1、0、1。
count(query)	计算匹配的子表达式的数量。
count_ops([visual])	用于返回操作计数的 count_ops 的包装器。
doit(**hints)
dummy_eq(other[, symbol])	比较两个表达式并处理哑符号。
find(query[, group])	查找所有匹配查询的子表达式。
fromiter(args, **assumptions)	从可迭代对象创建一个新对象。
has(*patterns)	测试是否有任何子表达式匹配任何模式。
has_free(*patterns)	如果 self 包含对象 x 作为自由表达式，则返回 True，否则返回 False。
has_xfree(s)	如果 self 有 s 中的任何一个模式作为自由参数，则返回 True，否则返回 False。
is_same(b[, approx])	如果 a 和 b 结构相同则返回 True，否则返回 False。
match(pattern[, old])	模式匹配。
matches(expr[, repl_dict, old])
rank()	返回李代数的秩
rcall(*args)	通过表达式树递归应用于参数。
refine([assumption])	请参阅 sympy.assumptions 中的 refine 函数。
replace(query, value[, map, simultaneous, exact])	将 self 中匹配的子表达式替换为 value。
rewrite(*args[, deep])	使用定义的规则重写 self。
series()	返回李代数的类型
simplify(**kwargs)	请参阅 sympy.simplify 中的 simplify 函数。
sort_key([order])
subs(*args, **kwargs)	在简化参数后，在表达式中用新内容替换旧内容。
xreplace(rule[, hack2])

复制
could_extract_minus_sign
is_hypergeometric

rank()

返回李代数的秩

series()

返回李代数的类型

sympy.liealgebras.dynkin_diagram.DynkinDiagram(t)

显示给定李代数的Dynkin图

通过生成输入 t 的 CartanType，然后从各个类中返回 Dynkin 图方法来工作。

示例

>>> from sympy.liealgebras.dynkin_diagram import DynkinDiagram
>>> print(DynkinDiagram("A3"))
0---0---0
1   2   3

>>> print(DynkinDiagram("B4"))
0---0---0=>=0
1   2   3   4

sympy.liealgebras.cartan_matrix.CartanMatrix(ct)

访问特定李代数的嘉当矩阵

示例

>>> from sympy.liealgebras.cartan_matrix import CartanMatrix
>>> CartanMatrix("A2")
Matrix([
[ 2, -1],
[-1,  2]])

>>> CartanMatrix(['C', 3])
Matrix([
[ 2, -1,  0],
[-1,  2, -1],
[ 0, -2,  2]])

此方法通过返回与Cartan类型t相对应的Cartan矩阵来工作。