代数操作
代数操作
| Expand[poly] | 展开积和幂 |
| Factor[poly] | 完全因子分解 |
| FactorTerms[poly] | 提取数字公因子 |
| FactorTerms[poly,{x,y,…}] | 提取任何与 x、y、… 无关的公因子 |
| Collect[poly,x] | 将多项式写为 x 的幂的和 |
| Collect[poly,{x,y,…}] | 将多项式写为 x、y、… 的幂的和 |
(2 + 4 x ^ 2) ^ 2 (x - 1) ^ 3Expand 展开乘积和幂，将多项式写为各项之和：
t = Expand[%]Factor 执行多项式的完全因子分解：
Factor[t]FactorTerms[t]可将多项式写为多种形式. 函数 Expand、FactorTerms 和 Factor 提供了三种常见方式. Expand 将多项式写为各项之和，且展开所有的积. FactorTerms 从每项中提取公因子. Factor 进行完全因子分解，将多项式写为各项的乘积，每一项的次数都尽可能的小.
Expand[(1 + 2x + y) ^ 3]Collect[%, x]如果指定变量列表，Collect 将表达式写成这些变量的多项式：
Collect[Expand[(1 + x + 2y + 3z) ^ 3], {x, y}]| Expand[poly,patt] | 展开 poly，避免展开不含有与 patt 匹配的项的部分 |
Expand[(x + 1) ^ 2 (y + 1) ^ 2, x]Expand[(a[1] + a[2] + 1) ^ 2 (1 + b[1]) ^ 2, b[_]]| PowerExpand[expr] | 展开 expr 中的 (ab)c 和 (ab)c |
| PowerExpand[expr,Assumptions->assum] | |
在假设条件 assum 的情况下展开 expr | |
Wolfram 系统不会自动展开形式为 (ab)c 的表达式，除非 c 是整数. 通常，仅当 a 和 b 为正实数时才进行此扩展. 然而，函数 PowerExpand 可进行此扩展，实际上假定 a 和 b 确实为正实数.
(x y) ^ nPowerExpand[%]不会自动展开 Log：
Log[%]PowerExpand 可进行此扩展：
PowerExpand[%]PowerExpand 针对给定假设返回正确的结果：
PowerExpand[%%, Assumptions -> {x > 0, n < 0}]t = 3 + x f[1] + x ^ 2 f[1] + y f[2] ^ 2 + z f[2] ^ 2Collect[t, f[_]]对每个系数应用 Factor：
Collect[t, f[_], Factor]| HornerForm[expr,x] | 将 expr 写成关于 x 的霍纳形式 |
HornerForm[1 + 2x + 3x ^ 2 + 4x ^ 3, x]| PolynomialQ[expr,x] | 测试 expr 是否是关于 x 的多项式 |
| PolynomialQ[expr,{x1,x2,…}] | 测试 expr 是否是关于 xi 的多项式 |
| Variables[poly] | poly 中出现的变量的列表 |
| Exponent[poly,x] | poly 中出现的 x 的最大指数 |
| Coefficient[poly,expr] | poly 中 expr 的系数 |
| Coefficient[poly,expr,n] | poly 中 exprn 的系数 |
| Coefficient[poly,expr,0] | poly 中与 expr 无关的项 |
| CoefficientList[poly,{x1,x2,…}] | 生成 poly 中 xi 的系数数组 |
| CoefficientRules[poly,{x1,x2,…}] | 获取单项式的指数向量和系数 |
t = (1 + x) ^ 3 (1 - y - x) ^ 2Expand[t]PolynomialQ[t, x]PolynomialQ[x + Sin[x], x]Variables[t]Exponent[t, x]Coefficient[t, x ^ 2]这相当于 Coefficient[t,x^2]：
Coefficient[t, x, 2]
Coefficient[t, x, 0]
CoefficientList[1 + 3x ^ 2 + 4x ^ 4, x]对于多变量多项式，CoefficientList 给出每个变量的每个幂的系数数组：
CoefficientList[t, {x, y}]CoefficientRules 只包含具有非零系数的单项式：
CoefficientRules[t, {x, y}]x ^ a + x ^ b + y ^ cExponent[%, x]| MonomialList[poly] | 获取单项式列表 |
| CoefficientRules[poly] | 用指数向量和系数表示单项式 |
| FromCoefficientRules[list] | 根据规则列表构建多项式 |
poly = -10x ^ 5y ^ 4z ^ 2 + 7x ^ 2y ^ 5z ^ 3 - 10x ^ 2y z ^ 5 - 7x y ^ 5z ^ 4 + 6x y ^ 4z ^ 3 + 6x y ^ 3z ^ 3 + 3x y ^ 2z + y ^ 4z - 7y ^ 2z + 2z ^ 5MonomialList[poly, {x, y, z}]CoefficientRules[poly, {x, y, z}]
MemberQ[poly, -10x ^ 5y ^ 4z ^ 2]FromCoefficientRules 根据规则和变量列表构建原始多项式：
FromCoefficientRules[CoefficientRules[poly, {x, y, z}], {x, y, z}] == polyVariables[poly]
CoefficientRules[poly]MemberQ[poly, -7y ^ 5z ^ 4x]
对于诸如 GroebnerBasis 和 PolynomialReduce 之类的函数，顺序必须是有理有据的，以确保元素的任何递减序列都是有限的（元素是非负指数组成的向量）. 为了使该条件成立，权重矩阵的每一列中的第一个非零值必须为正.
y x + x//FullFormList@@(y x + x)MonomialList[poly, Reverse[{x, y, z}], "NegativeLexicographic"]MonomialList[poly, {x, y, z}, {{0, 0, -1}, {0, -1, 0}, {-1, 0, 0}}]% == List@@polyTraditionalForm 尝试按接近字典顺序的顺序排列各个项.
按 TraditionalForm 显示的多项式：
poly//TraditionalForm下面使用高级排版功能来获取各个项的列表，顺序与在 TraditionalForm 输出中出现的顺序相同：
ToExpression[RowBox /@ Partition[Prepend[ToBoxes[poly, TraditionalForm][[1, 1]], "+"], 2]]% == MonomialList[poly, {x, y, z}]TraditionalForm[x ^ 3 + a x + b]TraditionalForm[x ^ 3 + a x + b, ParameterVariables :> {a, b}]只需反转结果列表，即可从 MonomialList 中使用的六种排序中获得其他排序. 这实际上相当于对指数向量取负. 在可交换情况下，还可以通过反转变量的顺序来获得其他排序.
| ExpandNumerator[expr] | 只展开分子 |
| ExpandDenominator[expr] | 只展开分母 |
| Expand[expr] | 展开分子，每一项都除以分母 |
| ExpandAll[expr] | 将分子和分母都全部展开 |
t = (1 + x) ^ 2 / (1 - x) + 3 x ^ 2 / (1 + x) ^ 2 + (2 - x) ^ 2ExpandNumerator 将每一项的分子展开：
ExpandNumerator[t]Expand 展开每一项的分子，且每一项都除以适当的分母：
Expand[t]ExpandDenominator 将每一项的分母展开：
ExpandDenominator[t]ExpandAll 将每一项的分子和分母都全部展开：
ExpandAll[t]| ExpandAll[expr,patt] 等 | 避免展开不包含与 patt 匹配的项的部分 |
ExpandAll[(x + 1) ^ 2 / y ^ 2 + (z + 1) ^ 2 / z ^ 2, z]| Together[expr] | 将所有项合并在一起，放在公分母上 |
| Apart[expr] | 将表达式写成具有简单分母的项的和 |
| Cancel[expr] | 约去分子和分母的公因子 |
| Factor[expr] | 进行完全因式分解 |
u = (-4x + x ^ 2) / (-x + x ^ 2) + (-4 + 3x + x ^ 2) / (-1 + x ^ 2)Together 将所有项放在公分母上：
Together[u]可用 Factor 对所得表达式的分子和分母进行因式分解：
Factor[%]Apart 将表达式写成各个项的和，每个项的分母都尽可能的简单：
Apart[u]Cancel 约去分子和分母的公因子：
Cancel[u]Factor 先将所有项放在公分母上，然后对结果进行因式分解：
Factor[%]在含有多个变量的表达式中，可用 Apart[expr,var] 关于不同变量进行部分分数分解.
v = (x ^ 2 + y ^ 2) / (x + x y)Apart[v, x]Apart[v, y]| PolynomialQuotient[poly1,poly2,x] | 给出关于 x 的多项式 poly1 除以 poly2 的结果，丢弃余式 |
| PolynomialRemainder[poly1,poly2,x] | 给出关于 x 的多项式 poly1 除以 poly2 所得的余式 |
| PolynomialQuotientRemainder[poly1,poly2,x] | |
以列表形式给出商和余式 | |
| PolynomialMod[poly,m] | 对 m 取模，约简多项式 poly |
| PolynomialGCD[poly1,poly2] | 求两个多项式的最大公因式 |
| PolynomialLCM[poly1,poly2] | 求两个多项式的最小公倍式 |
| PolynomialExtendedGCD[poly1,poly2] | 求两个多项式的扩展最大公因式 |
| Resultant[poly1,poly2,x] | 求两个多项式的结式 |
| Subresultants[poly1,poly2,x] |
求两个多项式的主子结式系数 (principal subresultant coefficient)
|
| Discriminant[poly,x] | 求多项式的 poly 的判別式 |
| GroebnerBasis[{poly1,poly2,…},{x1,x2,…}] | |
求多项式 polyi 的 Gröbner 基 | |
| GroebnerBasis[{poly1,poly2,…},{x1,x2,…},{y1,y2,…}] | |
求消掉 yi 的 Gröbner 基 | |
| PolynomialReduce[poly,{poly1,poly2,…},{x1,x2,…}] | |
求用 polyi 表示时 poly 的最小表示 | |
PolynomialRemainder[x ^ 2, x + 1, x]
PolynomialQuotient[x ^ 2, x + 1, x]Simplify[(x + 1)% + %%]{PolynomialRemainder[x + y, x - y, x], PolynomialRemainder[x + y, x - y, y]}PolynomialMod 实际上是对针对整数的函数 Mod 的模拟（针对的是多项式）. 当模 m 为整数时，PolynomialMod[poly,m] 只是将 poly 中的每个系数对整数 m 取模. 如果 m 是多项式，则 PolynomialMod[poly,m] 实际上尝试通过从 poly 中减去 m 的适当倍数 q m 来获得次数尽可能低的多项式. 倍数 q 本身可以是一个多项式，但是其次数始终小于 poly 的次数. PolynomialMod 最终给出一个多项式，其次数和首项的系数都尽可能的小.
PolynomialMod[x ^ 2, x + 1]{PolynomialMod[x ^ 2, a x + 1], PolynomialRemainder[x ^ 2, a x + 1, x]}PolynomialMod 和 PolynomialRemainder 之间的主要区别在于，前者只是对多项式进行相乘和相减，而后者使用除法来获取结果. 此外，PolynomialMod 允许同时对几个模式取模. 典型的情况是同时对多项式和整数取模.
PolynomialMod[x ^ 2 + 1, {x + 1, 2}]PolynomialGCD 给出了两个多项式的最大公因式：
PolynomialGCD[(1 - x) ^ 2 (1 + x) (2 + x), (1 - x) (2 + x) (3 + x)]PolynomialExtendedGCD 给出了两个多项式的扩展最大公因式：
{g, {r, s}} = PolynomialExtendedGCD[x ^ 3 + 2x ^ 2 - x + 1, x ^ 4 + x + 2, x]
r(x ^ 3 + 2x ^ 2 - x + 1) + s(x ^ 4 + x + 2) //Expand函数 Resultant[poly1,poly2,x] 被用在许多经典的代数算法中. 首项系数都为 1 的两个多项式 
和 
的结式，由多项式所有的根之间的差 
的乘积给出. 事实证明，对于任何一对多项式，其结式始终两个多项式的系数所构成的多项式. 通过查看结果何时为零，可以知道两个多项式的参数取什么值时才有公根. 如果列表 Subresultants[poly1,poly2,x] 中的前 
个元素恰好为零，则首项系数都为 1 的两个多项式有 
个公根.
和 的结式，由多项式所有的根之间的差 的乘积给出. 事实证明，对于任何一对多项式，其结式始终两个多项式的系数所构成的多项式. 通过查看结果何时为零，可以知道两个多项式的参数取什么值时才有公根. 如果列表 Subresultants[poly1,poly2,x] 中的前 个元素恰好为零，则首项系数都为 1 的两个多项式有 个公根. Resultant[(x - y) ^ 2 - 2, y ^ 2 - 3, y]函数 Discriminant[poly,x] 是其根的差的平方的乘积. 可用于确定多项式是否有重根. 判别式等于多项式及其导数的结式，与变量无关.
Discriminant[(x - 1) ^ 2, x]Discriminant[x ^ 4 - 1, x]Gröbner 基出现在许多现代代数算法和应用中. 函数 GroebnerBasis[{poly1,poly2,…},{x1,x2,…}] 接受一组多项式，并将其简化为可以方便地推导出许多特性的标准形式. 一个重要的特点是，从 GroebnerBasis 获取的多项式组始终与原始多项式组有完全相同的公根集合.
GroebnerBasis[{(x + y), (x + y) ^ 2}, {x, y}]GroebnerBasis[{x + y, x ^ 2 - 1, y ^ 2 - 2x}, {x, y}]GroebnerBasis[{x y ^ 2 + 2 x y + x ^ 2 + 1, x y + y ^ 2 + 1}, {x, y}]
PolynomialReduce[x ^ 2 + y ^ 2, {x - y, y + a}, {x, y}]| Factor[poly] | 对多项式进行因式分解 |
| FactorSquareFree[poly] | 将多项式写为无平方因式的乘积 |
| FactorTerms[poly,x] | 提取不依赖于 x 的项 |
| FactorList[poly]
,
FactorSquareFreeList[poly]
,
FactorTermsList[poly] | |
以因式列表的形式给出结果 | |
Factor、FactorTerms 和 FactorSquareFree 对多项式进行不同程度的因式分解. Factor 对整数进行完全因子分解. FactorTerms 提取多项式的“内容”. FactorSquareFree 提取出现的任何倍数因子.
t = Expand[2 (1 + x) ^ 2 (2 + x) (3 + x)]FactorTerms[t, x]
FactorSquareFree[t]Factor 进行完全因式分解，恢复原始形式：
Factor[t]特别是当你编写处理多项式的程序时，通常会发现以标准形式提取多项式更方便. 函数 FactorList 给出了多项式的所有因子及其指数的列表. 列表的第一个元素始终是多项式的整体数值因子.
FactorList[t]| Factor[poly,GaussianIntegers->True] | |
对多项式进行因式分解，允许用高斯整数作为系数 | |
Factor 及相关函数通常只处理系数为普通整数或有理数的多项式. 但是，如果设置选项 GaussianIntegers->True，则 Factor 将允许处理系数为复数（实部和虚部为有理数）的多项式. 这使得我们可以进行更大范围的因式分解.
Factor[1 + x ^ 2]Factor[1 + x ^ 2, GaussianIntegers -> True]| IrreduciblePolynomialQ[poly] | 测试 poly 在有理数上是否不可约 |
| IrreduciblePolynomialQ[poly,GaussianIntegers->True] | 测试 poly 在高斯有理数上是否不可约 |
| IrreduciblePolynomialQ[poly,Extension->Automatic] | 在由 poly 的代数数系数扩展的有理数上测试不可约性 |
IrreduciblePolynomialQ[x ^ 2 + 4]IrreduciblePolynomialQ[x ^ 2 + 4, GaussianIntegers -> True]IrreduciblePolynomialQ[x ^ 2 + 2 Sqrt[2]x + 2]在由 Sqrt[2] 扩展的有理数上，多项式是可约的：
IrreduciblePolynomialQ[x ^ 2 + 2 Sqrt[2]x + 2, Extension -> Automatic]| Cyclotomic[n,x] | 给出关于 x 的 n 次分圆多项式 |
Cyclotomic[6, x]
Factor[x ^ 6 - 1]| Decompose[poly,x] | 可能的情况下，将 poly 分解为更简单的多项式 |
Decompose[x ^ 4 + x ^ 2 + 1, x](q1[x_] = 1 - 2x + x ^ 4;q2[x_] = 5x + x ^ 3;)Expand[q1[q2[x]]]Decompose 恢复原来的函数：
Decompose[%, x]Decompose[poly,x] 被设计为给出关于 x 的多项式列表，如果重新复合这些多项式，将再现原始多项式. 原始多项式可以包含 x 以外的变量，但是 Decompose 产生的多项式序列应被视为关于 x 的函数.
与因式分解不同，多项式的分解不是完全唯一的. 例如，两组多项式 
和 
，
和 
给出同样的复合结果，使得 
. Wolfram 语言遵循以下约定：将所有常数项吸收到 Decompose 产生的列表的第一个多项式中.
和 ， 和 给出同样的复合结果，使得 . Wolfram 语言遵循以下约定：将所有常数项吸收到 Decompose 产生的列表的第一个多项式中. | InterpolatingPolynomial[{f1,f2,…},x] | |
给出关于 x 的多项式，当 x 为整数 i 时，它等于 fi | |
| InterpolatingPolynomial[{{x1,f1},{x2,f2},…},x] | |
给出关于 x 的多项式，当 x 为 xi 时，它等于 fi | |
InterpolatingPolynomial[{{-1, 4}, {0, 2}, {1, 6}}, x]% /. x -> 0
| PolynomialMod[poly,p] | 对 p 取模，约简多项式的系数 |
| Expand[poly,Modulus->p] | 展开 poly 模 p |
| Factor[poly,Modulus->p] | 对 poly 模 p 进行因式分解 |
| PolynomialGCD[poly1,poly2,Modulus->p] | |
求 polyi 模 p 的 GCD | |
| GroebnerBasis[polys,vars,Modulus->p] | |
求模 p 的 Gröbner 基 | |
Expand[(1 + x) ^ 6]PolynomialMod[%, 2]Factor[%]Factor[%, Modulus -> 2]
| SymmetricPolynomial[k,{x1,…,xn}] | 给出关于变量  的第  个基本对称多项式 |
| SymmetricReduction[f,{x1,…,xn}] | 给出关于  的一对多项式  ，使得  ，其中  是对称部分， 为余式 |
| SymmetricReduction[f,{x1,…,xn},{s1,…,sn}] | |
给出一对多项式  ，将  中的基本对称多项式替换为  | |
SymmetricPolynomial[3, {x, y, z, t}]
SymmetricReduction[(x + y)^2 + (x + z)^2 + (z + y)^2, {x, y, z}]
SymmetricReduction[x^5 + y^5 + z^4, {x, y, z}, {Subscript[s, 1], Subscript[s, 2], Subscript[s, 3]}]SymmetricReduction 适用于具有符号系数的多项式：
SymmetricReduction[x^5 + y^5 + z^4 + a x^4 + b y^4 + c z^5, {x, y, z}, {Subscript[s, 1], Subscript[s, 2], Subscript[s, 3]}]Factor[1 + x ^ 4]
Factor[1 + x ^ 4, Extension -> {Sqrt[2]}]
Factor[1 + x ^ 4, Extension -> {Sqrt[-1]}]Factor[1 + x ^ 4, GaussianIntegers -> True]
Factor[1 + x ^ 4, Extension -> {Sqrt[2], Sqrt[-1]}]Expand 返回原始多项式：
Expand[%]
t = Expand[(Sqrt[2] + x) ^ 2]默认情况下，Factor 不会对多项式进行因式分解：
Factor[t]
Factor[t, Extension -> Automatic]默认情况下，Cancel 不对这些多项式进行约简：
Cancel[t / (x ^ 2 - 2)]Cancel[t / (x ^ 2 - 2), Extension -> Automatic]默认情况下，PolynomialLCM 无法提取公因子：
PolynomialLCM[t, x ^ 2 - 2]PolynomialLCM[t, x ^ 2 - 2, Extension -> Automatic]| IrreduciblePolynomialQ[poly,ExtensionAutomatic] | 测试 poly 在由 poly 的系数扩展的有理数上是否不可约 |
| IrreduciblePolynomialQ[poly,Extension->{a1,a2,…}] | 测试 poly 在由 poly 的系数和 a1,a2,… 扩展的有理数上是否不可约 |
| IrreduciblePolynomialQ[poly,ExtensionAll] | 在所有复数域上测试不可约性 |
IrreduciblePolynomialQ[x ^ 2 + 2 Sqrt[2]x + 2]在由 Sqrt[2] 扩展的有理数上，多项式是可约的：
IrreduciblePolynomialQ[x ^ 2 + 2 Sqrt[2]x + 2, Extension -> Automatic]IrreduciblePolynomialQ[x ^ 2 - 3]在由 Sqrt[3] 扩展的有理数上，多项式是可约的：
IrreduciblePolynomialQ[x ^ 2 - 3, Extension -> {Sqrt[3]}]IrreduciblePolynomialQ[x ^ 3 - 5x y + 7, Extension -> All]| TrigExpand[expr] | 将三角函数式展开成各项的和 |
| TrigFactor[expr] | 将三角函数式分解为各项的积 |
| TrigFactorList[expr] | 用列表给出各个项及其指数 |
| TrigReduce[expr] | 用倍角约简三角函数式 |
TrigExpand[Sin[2 x] Cos[2 y]]TrigFactor[%]TrigReduce[%]TrigExpand 适用于双曲函数和圆函数：
TrigExpand[Tanh[x + y]]TrigReduce 恢复原始形式：
TrigReduce[%]Wolfram 系统会在可能的情况下自动使用如 Tan 这样的函数：
Sin[x] ^ 2 / Cos[x]TrigFactorList[%]TrigToExp 用指数函数写出三角函数：
TrigToExp[Tan[x]]TrigToExp 也适用于双曲函数：
TrigToExp[Tanh[x]]ExpToTrig 进行相反的操作，在可能的情况下消除显式复数：
ExpToTrig[%]ExpToTrig 可处理双曲函数和圆函数：
ExpToTrig[Exp[x] - Exp[-x]]也可以对纯数值表达式使用 ExpToTrig：
ExpToTrig[(-1) ^ (1 / 17)]函数 ComplexExpand 展开代数和三角函数式，对出现的变量进行确定的假设.
| ComplexExpand[expr] | 假定所有变量都是实数，展开 expr |
| ComplexExpand[expr,{x1,x2,…}] | 假定 xi 为复数，展开 expr |
ComplexExpand[Tan[x + I y]]ComplexExpand[a + x ^ 2, {x}]ComplexExpand[Sin[x] Exp[y], {x, y}]ComplexExpand 中的选项 TargetFunctions 允许你指定应如何写出复变量. 可以将 TargetFunctions 设为 {Re,Im,Abs,Arg,Conjugate,Sign} 中的函数. ComplexExpand 将根据要求尝试以这些形式给出结果. 默认情况下通常以 Re 和 Im 形式给出结果.
ComplexExpand[Re[z ^ 2], {z}]ComplexExpand[Re[z ^ 2], {z}, TargetFunctions -> {Abs, Arg}]ComplexExpand[Re[z ^ 2], {z}, TargetFunctions -> Conjugate]| LogicalExpand[expr] | 展开 expr 中的逻辑函数 |
| PiecewiseExpand[expr] | 展开 expr 中的分段函数 |
| PiecewiseExpand[expr,assum] | 按指定假设展开表达式 |
LogicalExpand 将逻辑表达式转换成标准的析取范式 (DNF)，由 ANDs 的 OR 组成.
(a || b) && cLogicalExpand 将其展开为 ANDs 的 OR :
LogicalExpand[%]LogicalExpand 适用于所有逻辑函数，始终将其转换为标准的 ANDs 的 OR 形式. 有时结果会很大.
Xor 可被表示为 ANDs 的 OR：
LogicalExpand[Xor[a, b, c]]实际上，可将任意一组嵌套条件展平为由单个 Piecewise 对象组成的分段范式 (piecewise normal form). 可以使用 PiecewiseExpand 在 Wolfram 语言中执行此操作.
If[x > 0, If[x < 1, a, b], c]PiecewiseExpand[%]给出单个 Piecewise对象的结果：
PiecewiseExpand[Max[Min[a, b], c]]PiecewiseExpand[Abs[x], x ∈ Reals]PiecewiseExpand[Floor[x ^ 2], 0 < x < 2]默认情况下，Wolfram 语言限制了 Wolfram 语言在计算的任何阶段展开任何分段函数（如 Floor）时生成的分段的个数. 可以通过重置 $MaxPiecewiseCases 的值来改变此限制.
| Simplify[expr] | 尝试各种代数和三角变换来简化表达式 |
| FullSimplify[expr] | 尝试更大范围的转换 |
(1 - x) / (1 - x ^ 2)Simplify 可进行简化：
Simplify[%]Simplify 执行标准的代数和三角函数简化：
Simplify[Sin[x] ^ 2 + Cos[x] ^ 2]Simplify[Gamma[1 + n] / n]FullSimplify 则可以进行这样的转换：
FullSimplify[%]| FullSimplify[expr,ExcludedForms->pattern] | |
尝试化简 expr，不处理与 pattern 匹配的子表达式 | |
t = (1 - Sin[x] ^ 2) Sqrt[Expand[(1 + Sqrt[2]) ^ 20]]默认情况下，FullSimplify 将尝试简化所有式子：
FullSimplify[t]这将使 FullSimplify 不简化平方根：
FullSimplify[t, ExcludedForms -> Sqrt[_]]| FullSimplify[expr,TimeConstraint->t] | |
尝试简化 expr，每个转换最多花费 t 秒 | |
| FullSimplify[expr,TransformationFunctions->{f1,f2,…}] | |
只使用函数 fi 转换 expr 的构成部分 | |
| FullSimplify[expr,TransformationFunctions->{Automatic,f1,f2,…}] | |
使用内置转换及 fi | |
| Simplify[expr,ComplexityFunction->c] and FullSimplify[expr,ComplexityFunction->c] | |
化简表达式，用 c 确定最简单的形式 | |
在 Simplify 和 FullSimplify 中始终存在一个问题，即什么才算是表达式的“最简单”形式. 可使用选项 ComplexityFunction->c 指定一个函数来确定. 该函数将被应用于表达式的每种候选形式，给出最小数值的函数将被认为是最简单的.
Simplify[4 Log[10]]Simplify[4 Log[10], ComplexityFunction -> LeafCount]| Refine[expr,assum] | 用假设细化 expr |
| Simplify[expr,assum] | 有假设条件的情况下进行化简 |
| FullSimplify[expr,assum] | 有假设条件的情况下进行完全化简 |
| FunctionExpand[expr,assum] | 有假设条件的情况下展开函数 |
默认情况下，Simplify 对以下表达式不进行任何操作：
Simplify[1 / Sqrt[x] - Sqrt[1 / x]]% /. x -> {-3, -2, -1, 1, 2, 3}Simplify[1 / Sqrt[x] - Sqrt[1 / x], x > 0]FunctionExpand[Log[x y]]FunctionExpand[Log[x y], x > 0 && y > 0]Simplify[Abs[x] == x]Simplify 可以证明该等式是正确的：
Simplify[Abs[x] == x, x > 0]Simplify[(x + y) / 2 >= Sqrt[x y], x >= 0 && y >= 0]
FullSimplify[0 < Erf[x] < 1, x > 0]Simplify 和 FullSimplify 总是尝试找出表达式最简单的形式. 但是，有时你可能希望 Wolfram 语言只是遵循其普通的计算过程，但是有一些假设条件. 可以使用 Refine 来完成. 其工作原理为：如果 expr 中的变量被替换为满足假设条件 assum 的数值表达式，Refine[expr,assum] 将执行与 Wolfram 语言自动执行的转换相同的转换.
Simplify 无法找到更简单的形式：
Simplify[Log[x], x < 0]Refine[Log[x], x < 0]| x∈dom or Element[x,dom] | 断言 x 是域 dom 的元素 |
| {x1,x2,…}∈dom | 断言所有的 xi 是域 dom 的元素 |
| patt∈dom | 断言与 patt 匹配的任意表达式是是域 dom 的元素 |
Pi ∈ Reals{1, Sqrt[2], 3 + Sqrt[5]} ∈ Algebraics
Pi ∈ Algebraics
E + Pi ∈ Algebraicsx ∈ Reals
Simplify[Sin[n Pi], n ∈ Integers]
Simplify[Cosh[x] >= 1, x ∈ Reals]Simplify[x ∈ Reals, x > 0]Simplify[Tan[x + Pi k], k ∈ Integers]Simplify[Tan[x + Pi k / 2], k / 2 ∈ Integers]
Simplify[Log[x] < Exp[x], x > 0]FullSimplify 可使用有关特殊函数的知识：
FullSimplify[Im[BesselJ[0, x]], x ∈ Reals]FunctionExpand[Mod[(p - 1)!, p], p ∈ Primes]FunctionExpand[EulerPhi[m n], {m, n} ∈ Integers && GCD[m, n] == 1]在如 Simplify[expr,assum] 或 Refine[expr,assum] 这样的函数中，我们可以明确给出要使用的假设. 但是有时你可能希望指定一组假设，可以在一系列操作中使用. 可通过 Assuming 来完成.
| Assuming[assum,expr] | 在计算 expr 时使用假设 assum |
| $Assumptions | 默认使用的假设条件 |
Assuming[x > 0, Simplify[Sqrt[x ^ 2]]]Assuming[x > 0, Assuming[x ∈ Integers, Refine[Floor[Sqrt[x ^ 2]]]]]诸如 Simplify 和 Refine 之类的函数接受选项 Assumptions，指定了它们应使用的默认假设. 默认情况下，此选项的设置为 Assumptions:>$Assumptions. Assuming 则为 $Assumptions 分配一个本地值，就像 Block 中一样.
除了 Simplify 和 Refine，许多其他函数也接受 Assumptions 选项，因此可以通过 Assuming 为其指定假设. 举例来说，有 FunctionExpand、Integrate、Limit、Series 和 LaplaceTransform.
Integrate 中自动使用以下假设：
Assuming[n > 0, 1 + Integrate[x ^ n, {x, 0, 1}] ^ 2]