SemidefiniteOptimization[f,cons,vars]
求可最小化受半定约束条件 cons 限制的线性目标函数 f 的变量 vars 的值.
SemidefiniteOptimization[c,{a0,a1,…,ak}]
求可最小化受线性矩阵不等式约束条件
限制的量
的向量
.
SemidefiniteOptimization[…,"prop"]
指定应返回解的属性 "prop".
SemidefiniteOptimization
SemidefiniteOptimization[f,cons,vars]
求可最小化受半定约束条件 cons 限制的线性目标函数 f 的变量 vars 的值.
SemidefiniteOptimization[c,{a0,a1,…,ak}]
求可最小化受线性矩阵不等式约束条件
限制的量
的向量
.
SemidefiniteOptimization[…,"prop"]
指定应返回解的属性 "prop".
更多信息和选项
- SemidefiniteOptimization 亦称为半定规划 (SDP) 和混合整数半定规划 (MISDP).
- 半定优化是一种凸优化问题,可以用实数、整数或复变量高效全局求解.
- 半定优化求的是能解原始问题的
: -
最小化 
受限于约束条件 ![a_(0)+a_(1) x_(1)+...+a_(k) x_(k)>=_(TemplateBox[{n}, SemidefiniteConeList])0 a_(0)+a_(1) x_(1)+...+a_(k) x_(k)>=_(TemplateBox[{n}, SemidefiniteConeList])0](Files/SemidefiniteOptimization.zh/2.png)
其中 
- 矩阵
必须是对称的
矩阵. - 混合整数半定优化求能解以下问题的
和
: -
最小化 
受限于约束条件 ![a_(0)+a_(1) x_(1)+...+a_(k_r) x_(k_r)+a_(k_r+1)y_1+...+a_(k_r+k_i)y_(k_i)>=_(TemplateBox[{n}, SemidefiniteConeList])0 a_(0)+a_(1) x_(1)+...+a_(k_r) x_(k_r)+a_(k_r+1)y_1+...+a_(k_r+k_i)y_(k_i)>=_(TemplateBox[{n}, SemidefiniteConeList])0](Files/SemidefiniteOptimization.zh/3.png)
其中 
- 当目标函数为实数时,SemidefiniteOptimization 通过在内部将
转换为实变量
来求解,其中
和
. 可以用埃尔米特矩阵
指定线性矩阵不等式. - 变量指定 vars 应该是一个列表,其中的元素按以下形式给出变量:
-
v 名称为
的变量,维度由推断而得v∈Reals 实标量变量 v∈Integers 整数标量变量 v∈Complexes 复标量变量 v∈ℛ 仅限于几何区域
的向量变量v∈Vectors[n,dom]
或
中的向量变量v∈Matrices[{m,n},dom]
或
中的矩阵变量 - 可用以下形式指定约束条件 cons:
-
LessEqual 
标量不等式 GreaterEqual 
标量不等式 VectorLessEqual 
向量不等式 VectorGreaterEqual 
向量不等式 Equal 
标量或向量等式 Element 
凸域或区域元素 - 对于 SemidefiniteOptimization[f,cons,vars],可在约束条件中包括形式为 parval 的参数方程,以定义在 f 或 cons 中使用的参数,其中 par 不在 vars 中,val 是数值或数值数组. »
- 原始最小化问题有相关的最大化问题,即拉格朗日对偶问题. 对偶最大值始终小于或等于原始最小值,因此它给出了下限. 对偶最大值点提供了有关原始问题的信息,包括最小值对约束条件变化的敏感性. »
- 半定优化有对偶问题: »
-
最大化 ![-TemplateBox[{Tr, paclet:ref/Tr}, RefLink, BaseStyle -> {2ColumnTableMod}][a_0.lambda] -TemplateBox[{Tr, paclet:ref/Tr}, RefLink, BaseStyle -> {2ColumnTableMod}][a_0.lambda]](Files/SemidefiniteOptimization.zh/6.png)
受限于约束条件 ![TemplateBox[{Tr, paclet:ref/Tr}, RefLink, BaseStyle -> {2ColumnTableMod}][a_j.lambda]=c_j,j=1,..., k,lambda>=_(TemplateBox[{n}, SemidefiniteConeList])0 TemplateBox[{Tr, paclet:ref/Tr}, RefLink, BaseStyle -> {2ColumnTableMod}][a_j.lambda]=c_j,j=1,..., k,lambda>=_(TemplateBox[{n}, SemidefiniteConeList])0](Files/SemidefiniteOptimization.zh/7.png)
其中 
- 可能的解的属性 "prop" 包括:
-
"PrimalMinimizer" 
一个最小化目标函数的变量值列表 "PrimalMinimizerRules" 
最小化
的变量值 vars={v1,…}"PrimalMinimizerVector" 
最小化
的向量"PrimalMinimumValue" 
原始最小值
"DualMaximizer" 
最大化
的矩阵"DualMaximumValue" ![-TemplateBox[{Tr, paclet:ref/Tr}, RefLink, BaseStyle -> {3ColumnTableMod}][a_0.lambda^*] -TemplateBox[{Tr, paclet:ref/Tr}, RefLink, BaseStyle -> {3ColumnTableMod}][a_0.lambda^*]](Files/SemidefiniteOptimization.zh/9.png)
对偶最大值 "DualityGap" ![-TemplateBox[{Tr, paclet:ref/Tr}, RefLink, BaseStyle -> {3ColumnTableMod}][a_0.lambda^*] - c.x^* -TemplateBox[{Tr, paclet:ref/Tr}, RefLink, BaseStyle -> {3ColumnTableMod}][a_0.lambda^*] - c.x^*](Files/SemidefiniteOptimization.zh/10.png)
对偶值和原始最优值之间的差 "Slack" 
把不等式约束条件转换成等式的矩阵 "ConstraintSensitivity"
对约束条件扰动的敏感度"ObjectiveVector" 
线性目标向量 "ConstraintMatrices" 
约束矩阵列表 {"prop1","prop2",…} 解的几个属性 - 可给出以下选项:
-
MaxIterations Automatic 使用的最大迭代次数 Method Automatic 使用的方法 PerformanceGoal $PerformanceGoal 优化的目标 Tolerance Automatic 内部比较使用的误差 - 选项 Method->method 可用于指定使用的方法. 可用的方法包括:
-
Automatic 自动选择方法 "CSDP" CSDP 半定优化求解器 "DSDP" DSDP 半定优化求解器 "SCS" SCS 分裂圆锥求解器 "MOSEK" 商用 MOSEK 凸优化求解器 - 计算受限于 MachinePrecision.
范例
打开所有单元 关闭所有单元基本范例 (3)
Subscript[a, 0] = (| | |
| - | - |
| 0 | 1 |
| 1 | 0 |);Subscript[a, 1] = (| | |
| - | - |
| 1 | 0 |
| 0 | 0 |);Subscript[a, 2] = (| | |
| - | - |
| 0 | 0 |
| 0 | 1 |);
res = SemidefiniteOptimization[2Subscript[x, 1] + 3Subscript[x, 2], Subscript[a, 0] + Subscript[a, 1]Subscript[x, 1] + Subscript[a, 2] Subscript[x, 2]Underscript[, {"SemidefiniteCone", 2}]0, {Subscript[x, 1], Subscript[x, 2]}]Show[Plot3D[2Subscript[x, 1] + 3Subscript[x, 2], {Subscript[x, 1], Subscript[x, 2]}∈ImplicitRegion[Subscript[x, 1]Subscript[x, 2] - 1 ≥ 0 && Subscript[x, 1] ≥ 0 && Subscript[x, 2] ≥ 0, {Subscript[x, 1], Subscript[x, 2]}], ...], Graphics3D[{Blue, PointSize[0.04], Point[{Subscript[x, 1], Subscript[x, 2], 2Subscript[x, 1] + 3Subscript[x, 2]} /. res]}]]Subscript[a, 0] = (| | |
| - | - |
| 0 | 1 |
| 1 | 0 |);Subscript[a, 1] = (| | |
| - | - |
| 1 | 0 |
| 0 | 0 |);Subscript[a, 2] = (| | |
| - | - |
| 0 | 0 |
| 0 | 1 |);
res = SemidefiniteOptimization[2Subscript[x, 1] + 3Subscript[x, 2], Subscript[a, 0] + Subscript[a, 1]Subscript[x, 1] + Subscript[a, 2]Subscript[x, 2]Underscript[, {"SemidefiniteCone", 2}]0, {Subscript[x, 1], Subscript[x, 2]}]xmin = SemidefiniteOptimization[{2, 3}, {Subscript[a, 0], Subscript[a, 1], Subscript[a, 2]}]Subscript[a, 0] = (| | |
| - | - |
| 0 | 1 |
| 1 | 0 |);Subscript[a, 1] = (| | |
| - | - |
| 1 | 0 |
| 0 | 0 |);Subscript[a, 2] = (| | |
| - | - |
| 0 | 0 |
| 0 | 1 |);
SemidefiniteOptimization[2Subscript[x, 1] + 3Subscript[x, 2], Subscript[a, 0] + Subscript[a, 1]Subscript[x, 1] + Subscript[a, 2]Subscript[x, 2]Underscript[, {"SemidefiniteCone", 2}]0, {Subscript[x, 1]∈Integers,
Subscript[x, 2]∈Reals}]SemidefiniteOptimization[{2, 3}, {Subscript[a, 0], Subscript[a, 1], Subscript[a, 2]}, {Integers, Reals}]范围 (29)
基本用途 (13)
res = SemidefiniteOptimization[x + 2y, {x^2 + 2y^2 ≤ 3, x + y == 2, x ≥ 1}, {x, y}]constraint = VectorGreaterEqual[{{{x, 1}, {1, y}}, 0}, {"SemidefiniteCone", 2}]SemidefiniteOptimization[x + y, constraint, {x, y}]c = {1, 1};Subscript[a, 0] = (| | |
| -- | -- |
| 0 | -1 |
| -1 | 0 |);Subscript[a, 1] = (| | |
| - | - |
| 1 | 1 |
| 1 | 1 |);Subscript[a, 2] = (| | |
| - | -- |
| 1 | 0 |
| 0 | -1 |);SemidefiniteOptimization[c.{x, y}, Subscript[a, 0] + Subscript[a, 1]x + Subscript[a, 2]yUnderscript[, {"SemidefiniteCone", 2}]0, {x, y}]Subscript[a, 0] + Subscript[a, 1]x + Subscript[a, 2]y//MatrixFormSemidefiniteOptimization[x + y, (| | |
| ------ | ------ |
| x + y | -1 + x |
| -1 + x | x - y |)Underscript[, {"SemidefiniteCone", 2}]0, {x, y}]SemidefiniteOptimization[c, {Subscript[a, 0], Subscript[a, 1], Subscript[a, 2]}]c = {1, 2};Subscript[a, 0] = (| | |
| - | - |
| 0 | 1 |
| 1 | 0 |);Subscript[a, 1] = (| | |
| - | - |
| 1 | 0 |
| 0 | 0 |);Subscript[a, 2] = (| | |
| - | - |
| 0 | 0 |
| 0 | 1 |);SemidefiniteOptimization[c.v, {Subscript[a, 1], Subscript[a, 2]}.vUnderscript[, {"SemidefiniteCone", 2}]-Subscript[a, 0], v]使用向量变量
和 Inactive[Plus] 避免意外的线程:
c = {1, 2};Subscript[a, 0] = (| | |
| - | - |
| 0 | 1 |
| 1 | 0 |);Subscript[a, 1] = (| | |
| - | - |
| 1 | 0 |
| 0 | 0 |);Subscript[a, 2] = (| | |
| - | - |
| 0 | 0 |
| 0 | 1 |);SemidefiniteOptimization[c.v, Subscript[a, 0] + {Subscript[a, 1], Subscript[a, 2]}.vUnderscript[, {"SemidefiniteCone", 2}]0, v]parEqs = {Subscript[a, 0] == (| | |
| - | - |
| 0 | 1 |
| 1 | 0 |), Subscript[a, 1] == (| | |
| - | - |
| 1 | 0 |
| 0 | 0 |), Subscript[a, 2] == (| | |
| - | - |
| 0 | 0 |
| 0 | 1 |)};SemidefiniteOptimization[{1, 1}.v, {{1, 2}, {1, 0}}.v{3, -1}, v]使用向量变量
和 Indexed[x,i] 指定单个分量:
SemidefiniteOptimization[{1, 2}.x, (| | |
| --------------- | --------------- |
| Indexed[x, {1}] | 1 |
| 1 | Indexed[x, {2}] |)Underscript[, {"SemidefiniteCone", 2}]0, x]在不明确时,使用 Vectors[n] 指定向量变量的维度:
SemidefiniteOptimization[Indexed[x, {1}] + 2Indexed[x, {2}], (| | |
| --------------- | --------------- |
| Indexed[x, {1}] | 1 |
| 1 | Indexed[x, {2}] |)Underscript[, {"SemidefiniteCone", 2}]0, x]SemidefiniteOptimization[Indexed[x, {1}] + Indexed[2x, {2}], (| | |
| --------------- | --------------- |
| Indexed[x, {1}] | 1 |
| 1 | Indexed[x, {2}] |)Underscript[, {"SemidefiniteCone", 2}]0, x∈Vectors[2]]多个线性不等式约束可用 VectorGreaterEqual 表示:
SemidefiniteOptimization[x + y, VectorGreaterEqual[{{x + 2y, x + 1}, {3, -1}}], {x, y}]使用
v>=
或 \[VectorGreaterEqual] 输入向量不等式符号 :
SemidefiniteOptimization[x + y, {x + 2y, x}{3, -1}, {x, y}]SemidefiniteOptimization[x + y, {x + 2y ≥ 3, x ≥ -1}, {x, y}]SemidefiniteOptimization[{1, 1}.v, {{1, 2}, {1, 0}}.v{3, -1}, v]使用 NonNegativeReals (
) 指定非负约束:
SemidefiniteOptimization[{1, 1}.v, {1, 2}.v3, v∈Vectors[2, NonNegativeReals]]SemidefiniteOptimization[{1, 1}.v, {{{1, 2}, {1, 0}}.v{3, 0}, v0}, v]SemidefiniteOptimization[{1, 1}.x, Norm[x] ≤ 1, x]constraint = VectorGreaterEqual[{{x, y, 3}, 0}, {"NormCone", 3}]SemidefiniteOptimization[x + y, constraint, {x, y}]整数变量 (4)
使用 Integers 指定整数域约束:
SemidefiniteOptimization[x + y, {x + 2y ≥ 3, x ≥ -2}, {x∈Integers, y∈Integers}]使用 Vectors[n,Integers] 指定向量变量的整数域约束:
SemidefiniteOptimization[Total[x], {a == {{1, 2}, {1, 0}}, b == {3, -2},
a.xb}, {x∈Vectors[2, Integers]}]使用 NonNegativeIntegers (
) 指定非负整数域约束:
SemidefiniteOptimization[x + 2y, {x^2 + 2y^2 ≤ 3, x + y == 2, x∈NonNegativeIntegers}, {x, y}]使用 NonPositiveIntegers (
) 指定非正整数域约束:
SemidefiniteOptimization[-x + y, {x + 2y ≥ 3, x∈NonPositiveIntegers}, {x, y}]复数变量 (2)
使用 Complexes 指定复数变量:
SemidefiniteOptimization[Re[z] + Im[z], Abs[z] ≤ 2, z∈Complexes]在线性矩阵不等式中,约束矩阵可以是埃尔米特矩阵或实对称矩阵:
Subscript[a, 0] = (| | |
| ----- | ----- |
| 0 | 1 + I |
| 1 - I | 0 |);Subscript[a, 1] = (| | |
| - | - |
| 1 | 0 |
| 0 | 0 |);Subscript[a, 2] = (| | |
| - | - |
| 0 | 0 |
| 0 | 1 |);c = {1, 2};
SemidefiniteOptimization[c.v, {Subscript[a, 1], Subscript[a, 2]}.vUnderscript[, {"SemidefiniteCone", 2}]-Subscript[a, 0], v∈Vectors[2, Reals]]原始模型属性 (3)
SemidefiniteOptimization[x + y, (| | |
| - | - |
| x | 1 |
| 1 | y |)Underscript[, {"SemidefiniteCone", 2}]0, {x, y}]{xmin, ymin} = SemidefiniteOptimization[x + y, (| | |
| - | - |
| x | 1 |
| 1 | y |)Underscript[, {"SemidefiniteCone", 2}]0, {x, y}, "PrimalMinimizer"]minval = SemidefiniteOptimization[x + y, (| | |
| - | - |
| x | 1 |
| 1 | y |)Underscript[, {"SemidefiniteCone", 2}]0, {x, y}, "PrimalMinimumValue"]Show[Plot3D[x + y, {x, y}∈ImplicitRegion[x y ≥ 1, {{x, 0, 5}, {y, 0, 5}}], MeshFunctions -> {#3&}], Graphics3D[{Red, PointSize[0.05], Point[{xmin, ymin, minval}]}]]c = SemidefiniteOptimization[x + y, (| | |
| - | - |
| x | 1 |
| 1 | y |)Underscript[, {"SemidefiniteCone", 2}]0, {x, y}, "ObjectiveVector"]mats = SemidefiniteOptimization[x + y, (| | |
| - | - |
| x | 1 |
| 1 | y |)Underscript[, {"SemidefiniteCone", 2}]0, {x, y}, "ConstraintMatrices"];Map[MatrixForm, mats]SemidefiniteOptimization[c, mats]s = SemidefiniteOptimization[Subscript[x, 1] + 2Subscript[x, 2], (| | |
| -- | -- |
| x1 | 1 |
| 1 | x2 |)Underscript[, {"SemidefiniteCone", 2}]0, {Subscript[x, 1], Subscript[x, 2]}, "Slack"]//Normal{x^ * , a} = SemidefiniteOptimization[Subscript[x, 1] + 2Subscript[x, 2],
(| | |
| -- | -- |
| x1 | 1 |
| 1 | x2 |)Underscript[, {"SemidefiniteCone", 2}]0, {Subscript[x, 1], Subscript[x, 2]}, {"PrimalMinimizer", "ConstraintMatrices"}]//NormalPrepend[x^ * , 1].a - s对偶模型属性 (3)
c = {2, 3};Subscript[a, 0] = (| | |
| - | - |
| 0 | 1 |
| 1 | 0 |);Subscript[a, 1] = (| | |
| - | - |
| 1 | 0 |
| 0 | 0 |);Subscript[a, 2] = (| | |
| - | - |
| 0 | 0 |
| 0 | 1 |);
xv = Table[Indexed[x, i], {i, 2}];psol = SemidefiniteOptimization[c.xv, Subscript[a, 0] + {Subscript[a, 1], Subscript[a, 2]}.xvUnderscript[, {"SemidefiniteCone", 2}]0, xv]constraints = {Table[Tr[Subscript[a, i].y] == c[[i]], {i, 2}], yUnderscript[, {"SemidefiniteCone", 2}]0};dsol = SemidefiniteOptimization[Tr[Subscript[a, 0].y], constraints, y∈Matrices[2]]{c.xv /. psol, -Tr[Subscript[a, 0].y] /. dsol}SemidefiniteOptimization[c.xv, Subscript[a, 0] + {Subscript[a, 1], Subscript[a, 2]}.xvUnderscript[, {"SemidefiniteCone", 2}]0, xv, "DualityGap"]obj = 2x + 3y;
constraints = (| | |
| - | - |
| x | 1 |
| 1 | y |)Underscript[, {"SemidefiniteCone", 2}]0;SemidefiniteOptimization[obj, constraints, {x, y}]{c, a} = SemidefiniteOptimization[obj, constraints, {x, y}, {"ObjectiveVector", "ConstraintMatrices"}];SemidefiniteOptimization[Tr[a[[1]].y], {Table[Tr[a[[i + 1]].y] == c[[i]], {i, 2}], yUnderscript[, {"SemidefiniteCone", 2}]0}, y∈Matrices[2]]obj = 2x + 3y;
constraints = (| | |
| - | - |
| x | 1 |
| 1 | y |)Underscript[, {"SemidefiniteCone", 2}]0;SemidefiniteOptimization[obj, constraints, {x, y}, "DualMaximumValue"]SemidefiniteOptimization[obj, constraints, {x, y}, "DualMaximizer"]//Normal敏感性属性 (4)
使用 "ConstraintSensitivity" 找到由于约束扰动导致优化值的改变:
c = {2, 3};Subscript[a, 0] = (| | |
| - | - |
| 0 | 3 |
| 3 | 0 |);Subscript[a, 1] = (| | |
| - | - |
| 1 | 0 |
| 0 | 0 |);Subscript[a, 2] = (| | |
| - | - |
| 0 | 0 |
| 0 | 1 |);p^ * = SemidefiniteOptimization[c, {Subscript[a, 0], Subscript[a, 1], Subscript[a, 2]}, "PrimalMinimumValue"]sens = SemidefiniteOptimization[c, {Subscript[a, 0], Subscript[a, 1], Subscript[a, 2]}, "ConstraintSensitivity"]//Normalδ = 0.01 * {{1, 2}, {2, 3}};p^ * + Tr[δ.sens]SemidefiniteOptimization[c, {Subscript[a, 0] + δ, Subscript[a, 1], Subscript[a, 2]}, "PrimalMinimumValue"]c = {2, 3};Subscript[a, 0] = (| | |
| - | - |
| 0 | 3 |
| 3 | 0 |);Subscript[a, 1] = (| | |
| - | - |
| 1 | 0 |
| 0 | 0 |);Subscript[a, 2] = (| | |
| - | - |
| 0 | 0 |
| 0 | 1 |);{p^ * , sens} = SemidefiniteOptimization[c, {Subscript[a, 0], Subscript[a, 1], Subscript[a, 2]}, {"PrimalMinimumValue", "ConstraintSensitivity"}];sens//Normalp^ * > SemidefiniteOptimization[c, {Subscript[a, 0] + {{0.01, 0}, {0, 0}}, Subscript[a, 1], Subscript[a, 2]}, "PrimalMinimumValue"]p^ * < SemidefiniteOptimization[c, {Subscript[a, 0] + {{0, 0.01}, {0.01, 0}}, Subscript[a, 1], Subscript[a, 2]}, "PrimalMinimumValue"]使用西尔维斯特 (Sylvester) 的半定性标准符号式表达扰动的约束:
c = {2, 3};Subscript[a, 0] = (| | |
| - | - |
| 0 | 3 |
| 3 | 0 |);Subscript[a, 1] = (| | |
| - | - |
| 1 | 0 |
| 0 | 0 |);Subscript[a, 2] = (| | |
| - | - |
| 0 | 0 |
| 0 | 1 |);parameters = (| | |
| ----- | ----- |
| p1, 1 | p1, 2 |
| p1, 2 | p2, 2 |);matrix = Subscript[a, 0] + parameters + Subscript[x, 1]Subscript[a, 1] + Subscript[x, 2]Subscript[a, 2];
constraints = {matrix[[1, 1]] ≥ 0, matrix[[2, 2]] ≥ 0, Det[matrix] ≥ 0}使用此格式,可以精确地在 0 附近找到作为参数函数的最小值:
Assuming[-1 < Subscript[p, 1, 2] < 1, exact = Refine[MinValue[2Subscript[x, 1] + 3Subscript[x, 2],
{Subscript[x, 1] + Subscript[p, 1, 1] ≥ 0, Subscript[x, 2] + Subscript[p, 2, 2] ≥ 0, -1 + Subscript[x, 1]Subscript[x, 2] + Subscript[x, 2]Subscript[p, 1, 1] - 2Subscript[p, 1, 2] - Subsuperscript[p, 1, 2, 2] + Subscript[x, 1]Subscript[p, 2, 2] + Subscript[p, 1, 1]Subscript[p, 2, 2] ≥ 0}, {Subscript[x, 1], Subscript[x, 2]}]]]MatrixForm[N[smat = (| | |
| -------------------- | -------------------- |
| D[exact, p1, 1] | (1/2)D[exact, p1, 2] |
| (1/2)D[exact, p1, 2] | D[exact, p2, 2] |)]]这是由 "ConstraintSensitivity" 属性给定的扰动的敏感性:
SemidefiniteOptimization[{2, 3}, {Subscript[a, 0], Subscript[a, 1], Subscript[a, 2]}, "ConstraintSensitivity"]//MatrixFormc = {2, 3};Subscript[a, 0] = (| | |
| - | - |
| 0 | 3 |
| 3 | 0 |);Subscript[a, 1] = (| | |
| - | - |
| 1 | 0 |
| 0 | 0 |);Subscript[a, 2] = (| | |
| - | - |
| 0 | 0 |
| 0 | 1 |);-SemidefiniteOptimization[c, {Subscript[a, 0], Subscript[a, 1], Subscript[a, 2]}, "DualMaximizer"]//MatrixFormSemidefiniteOptimization[c, {Subscript[a, 0], Subscript[a, 1], Subscript[a, 2]}, "ConstraintSensitivity"]//MatrixForm选项 (8)
Method (5)
SemidefiniteOptimization[Subscript[x, 1] + Subscript[x, 2], (| | |
| -- | -- |
| x1 | 1 |
| 1 | x2 |)Underscript[, {"SemidefiniteCone", n}]0, {Subscript[x, 1], Subscript[x, 2]}, Method -> Automatic]SemidefiniteOptimization[Subscript[x, 1] + Subscript[x, 2], (| | |
| -- | -- |
| x1 | 1 |
| 1 | x2 |)Underscript[, {"SemidefiniteCone", n}]0, {Subscript[x, 1], Subscript[x, 2]}, Method -> "CSDP"]SemidefiniteOptimization[Subscript[x, 1] + Subscript[x, 2], (| | |
| -- | -- |
| x1 | 1 |
| 1 | x2 |)Underscript[, {"SemidefiniteCone", n}]0, {Subscript[x, 1], Subscript[x, 2]}, Method -> "DSDP"]SemidefiniteOptimization[Subscript[x, 1] + Subscript[x, 2], (| | |
| -- | -- |
| x1 | 1 |
| 1 | x2 |)Underscript[, {"SemidefiniteCone", n}]0, {Subscript[x, 1], Subscript[x, 2]}, Method -> "SCS"]{obj, cons, var} = {Subscript[x, 1] + Subscript[x, 2], (| | |
| -- | -- |
| x1 | 1 |
| 1 | x2 |)Underscript[, {"SemidefiniteCone", 2}]0, {Subscript[x, 1], Subscript[x, 2]}};{minval, argmin} = Minimize[obj, cons, var];
exact = {minval, var /. argmin}solCSDP = SemidefiniteOptimization[obj, cons, var, {"PrimalMinimumValue", "PrimalMinimizer"}, Method -> "CSDP"];solDSDP = SemidefiniteOptimization[obj, cons, var, {"PrimalMinimumValue", "PrimalMinimizer"}, Method -> "DSDP"];solSCS = SemidefiniteOptimization[obj, cons, var, {"PrimalMinimumValue", "PrimalMinimizer"}, Method -> "SCS"];solCSDP - exactsolDSDP - exactsolSCS - exact当默认方法 "CSDP" 产生一条信息,首先尝试 "DSDP":
a = {{{0, 2}, {2, 0}}, {{1, 2}, {2, 3}}, {{5, 0}, {0, 1}}};
c = {2, 3};{xmin, min} = SemidefiniteOptimization[c, a, {"PrimalMinimizer", "PrimalMinimumValue"}, Method -> "CSDP"]{xmin, min} = SemidefiniteOptimization[c, a, {"PrimalMinimizer", "PrimalMinimumValue"}, Method -> "DSDP"]带有 10-3 默认容差的 "SCS" 是另一种可尝试的方法:
{xmin, min} = SemidefiniteOptimization[c, a, {"PrimalMinimizer", "PrimalMinimumValue"}, Method -> "SCS"]"SCS" 的结果质量通常可以通过较小的 Tolerance 来改善:
{xmin, min} = SemidefiniteOptimization[c, a, {"PrimalMinimizer", "PrimalMinimumValue"}, Method -> {"SCS", Tolerance -> 10 ^ -8}]PerformanceGoal (1)
选项 PerformanceGoal 的默认值是 $PerformanceGoal:
$PerformanceGoal使用 PerformanceGoal"Quality" 获取更精确的结果:
c = {1, 1};Subscript[a, 0] = (| | |
| - | - |
| 0 | 1 |
| 1 | 0 |);Subscript[a, 1] = (| | |
| - | - |
| 1 | 0 |
| 0 | 0 |);Subscript[a, 2] = (| | |
| - | - |
| 0 | 0 |
| 0 | 1 |);
SemidefiniteOptimization[c, {Subscript[a, 0], Subscript[a, 1], Subscript[a, 2]}, PerformanceGoal -> "Quality"]SemidefiniteOptimization[c, {Subscript[a, 0], Subscript[a, 1], Subscript[a, 2]}, PerformanceGoal -> "Speed"]使用 PerformanceGoal"Speed" 更快获取结果,但代价是质量:
n = 2000;c = ConstantArray[1, n];
Subscript[a, 0] = SparseArray[{{1, n} -> 1, {n, 1} -> 1}, {n, n}];Table[Subscript[a, i] = SparseArray[{{i, i} -> 1}, {n, n}], {i, 1, n}];Timing[resSpeed = SemidefiniteOptimization[c, Table[Subscript[a, i], {i, 0, n}], "PrimalMinimumValue", PerformanceGoal -> "Speed"];]Timing[resQuality = SemidefiniteOptimization[c, Table[Subscript[a, i], {i, 0, n}], "PrimalMinimumValue", PerformanceGoal -> "Quality"];]{resSpeed, resQuality}Tolerance (2)
更小的 Tolerance 设置给出更精确的结果:
c = {1, 1};Subscript[a, 0] = (| | |
| - | - |
| 0 | 1 |
| 1 | 0 |);Subscript[a, 1] = (| | |
| - | - |
| 1 | 0 |
| 0 | 0 |);Subscript[a, 2] = (| | |
| - | - |
| 0 | 0 |
| 0 | 1 |);用 Minimize 计算精确的最小值:
exact = Minimize[{Subscript[x, 1] + Subscript[x, 2], Subscript[a, 0] + Subscript[a, 1]Subscript[x, 1] + Subscript[a, 2]Subscript[x, 2]Underscript[, {"SemidefiniteCone", 2}]0}, {Subscript[x, 1], Subscript[x, 2]}][[1]]计算带有不同 Tolerance 设置的最小值的误差:
err = Table[{tol, Abs[SemidefiniteOptimization[c, {Subscript[a, 0], Subscript[a, 1], Subscript[a, 2]}, "PrimalMinimumValue", Tolerance -> tol] - exact]}, {tol, 10. ^ -Range[7]}]ListLogLogPlot[err, PlotRange -> All, Joined -> True, PlotMarkers -> Automatic]更小 Tolerance 设置给出更精确的结果,但花更长时间计算:
n = 2000;c = ConstantArray[1, n];
Subscript[a, 0] = SparseArray[{{1, n} -> 1, {n, 1} -> 1}, {n, n}];Table[Subscript[a, i] = SparseArray[{{i, i} -> 1}, {n, n}], {i, 1, n}];Timing[ptight = SemidefiniteOptimization[c, Table[Subscript[a, i], {i, 0, n}], "PrimalMinimumValue", Tolerance -> 10^-8];]Timing[ploose = SemidefiniteOptimization[c, Table[Subscript[a, i], {i, 0, n}], "PrimalMinimumValue", Tolerance -> 10^-1];]{ptight, ploose}应用 (33)
基本的模型变换 (13)
SemidefiniteOptimization[-(x + y), (| | |
| -- | -- |
| -x | 1 |
| 1 | -y |)Underscript[, {"SemidefiniteCone", 2}]0, {x, y}]-SemidefiniteOptimization[-(x + y), (| | |
| -- | -- |
| -x | 1 |
| 1 | -y |)Underscript[, {"SemidefiniteCone", 2}]0, {x, y}, "PrimalMinimumValue"]求最小化对称矩阵的最大特征值的
,对称矩阵线性依赖于决策变量
,
. 该问题可以作为线性矩阵不等式被公式化,因为
等价于
,其中,
是
的第 ![]()
个特征值. 定义线性矩阵函数
:
A[x_, y_] := (| | |
| -- | -- |
| 2 | -3 |
| -3 | 4 |) + (| | |
| - | - |
| 1 | 2 |
| 2 | 3 |)x + (| | |
| - | - |
| 4 | 5 |
| 5 | 6 |)yA[x, y]//MatrixForm实对称矩阵
可用正交矩阵
对角化,所以
. 因此
当且仅当
. 既然,任何
都接受
,
,因此
当且仅当
. 数值模拟显示这些公式是等价的:
eigs = Eigenvalues[A[1., 2.]]data = Table[{λ, λ(| | |
| - | - |
| 1 | 0 |
| 0 | 1 |)Underscript[, {"SemidefiniteCone", 2}]A[1., 2.]}, {λ, RandomReal[{0, 35}, 100]}];
{true, false} = {Cases[data, {λ_, True} :> λ], Cases[data, {λ_, False} :> λ]};NumberLinePlot[{eigs, true, false}, IconizedObject[«Rule»]]res = SemidefiniteOptimization[λ, λ(| | |
| - | - |
| 1 | 0 |
| 0 | 1 |)Underscript[, {"SemidefiniteCone", 2}]A[x, y], {λ, x, y}]Min[Table[Max[Eigenvalues[A@@RandomReal[{-10000, 10000}, 2]]], 10000]]求最大化对称矩阵
最小特征值的
,对称矩阵线性依赖于决策变量
. 定义线性矩阵函数
:
A[x_, y_] := (| | |
| ------------- | ------------- |
| x + 4 y + 2 | 2 x + 5 y - 3 |
| 2 x + 5 y - 3 | 3 x + 6 y + 4 |);问题可以作为线性矩阵不等式被公式化,因为
等价于
,其中,
是
的第 ![]()
个特征值. 为了最大化
,先最小化
:
res = SemidefiniteOptimization[-λ,
λ(| | |
| - | - |
| 1 | 0 |
| 0 | 1 |)Underscript[, {"SemidefiniteCone", 2}]A[x, y], {λ, x, y}]Max[Table[Min[Eigenvalues[A@@RandomReal[{-10000, 10000}, 2]]], 10000]]求最小化对称矩阵
的最大和最小特征值之间差的
,对称矩阵线性依赖于决策变量
. 定义线性矩阵函数
:
A[x_, y_] := (| | |
| ----------- | ----------- |
| x + 4y + 2 | 2x + 5y - 3 |
| 2x + 5y - 3 | 3x + 6y + 4 |);该问题可以作为线性矩阵不等式被公式化,因为
等价于
,其中,
是
的第 ![]()
个特征值. 求解由此产生的问题:
res = SemidefiniteOptimization[μ - λ, {λ(| | |
| - | - |
| 1 | 0 |
| 0 | 1 |)Underscript[, {"SemidefiniteCone", 2}]A[x, y]Underscript[, {"SemidefiniteCone", 2}]μ(| | |
| - | - |
| 1 | 0 |
| 0 | 1 |)}, {λ, μ, x, y}]{Eigenvalues[A[x, y] /. res], Chop[μ - λ /. res, 10 ^ -7]}A[x_, y_] := (| | |
| ------------- | ------------- |
| x + 4 y + 2 | 2 x + 5 y - 3 |
| 2 x + 5 y - 3 | 3 x + 6 y + 4 |);最大的特征值满足
最大绝对值的负
特征值是最大的
特征值并满足
:
res = SemidefiniteOptimization[λ, {-λ(| | |
| - | - |
| 1 | 0 |
| 0 | 1 |)Underscript[, {"SemidefiniteCone", 2}]A[x, y]Underscript[, {"SemidefiniteCone", 2}]λ(| | |
| - | - |
| 1 | 0 |
| 0 | 1 |)}, {λ, x, y}]Eigenvalues[A[x, y] /. res]A[x_, y_] := (| | | |
| ---------- | ---------- | ----- |
| 1 + x + 2y | 2 + 3y | x + 1 |
| 3 + 5y | 4 - x + 8y | 2y |);
的最大奇异值
是
最大特征值的平方根,而且根据前面的例子,它满足
或等价于
:
res = SemidefiniteOptimization[σ, **{****{****σ**(| | |
| - | - |
| 1 | 0 |
| 0 | 1 |)**, ****A[x, y]****}****, ****{****A[x, y]****, ****σ**(| | | |
| - | - | - |
| 1 | 0 | 0 |
| 0 | 1 | 0 |
| 0 | 0 | 1 |)**}****}**Underscript[, {"SemidefiniteCone", 5}]0, {x, y, **σ**}]f[x, y] := Module[{v = SingularValueList[A[x, y]]}, Max[v]];
Show[Plot3D[f[x, y], {x, -10, 10}, {y, -2, 2}], Graphics3D[{Red, PointSize[.05], Point[res[[All, 2]]]}]]最小化
. 使用辅助变量
,把问题转换为最小化
,因此
. 这个与
一样:
a = {{1, 2}, {3, 4}, {5, 6}};
b = {7, 8, 10};Schur 补充条件表示,如果
,则块矩阵
当且仅当
. 因此,当
,
⧦
,当
,使得
必须为 0:
SemidefiniteOptimization[t, {ℐ == IdentityMatrix[3],
a1 == a, b1 == b, (| | |
| --------- | --------- |
| t | a1.x - b1 |
| a1.x - b1 | t ℐ |)Underscript[, "SemidefiniteCone"]0}, {t, x}]SemidefiniteOptimization[t, {Norm[Inactive[Plus][a.x, -b]] ≤ t}, {t, x}]最小化
受限于
,假设
,当
. 使用辅助变量
,目标是最小化
,使得
:
{α, β, γ, δ} = {{1, 2}, 1, {-3, 4}, 2};
{a, b} = {{{1, -2}, {-3, 4}}, {-5, -1}};Reduce[Implies[a.{Indexed[x, {1}], Indexed[x, {2}]} + b >= 0, γ.{Indexed[x, {1}], Indexed[x, {2}]} + δ > 0], Reals]使用 Schur 补充条件,
当且仅当
. 使用 Inactive[Plus] 构建约束避免线程:
SemidefiniteOptimization[t, {(| | |
| ------- | ------- |
| t | α.x + β |
| α.x + β | γ.x + δ |)Underscript[, {"SemidefiniteCone", 2}]0, a.x + b0}, {t, x∈Vectors[2]}]对于二次集
,其包括椭球、二次锥和抛物线,确定是否
,其中,
是对称矩阵,
是向量,
是标量:
{a1, b1, c1} = {{{0.7, 0.68}, {0.68, 0.94}}, {0.35, .42}, 0.12};{a2, b2, c2} = {{{0.13, 0.2}, {0.2, 0.62}}, {.2, .4}, .01};With[{x = {x1, x2}}, RegionPlot[{x.a1.x + 2b1.x + c1 ≤ 0, x.a2.x + 2b2.x + c2 ≤ 0}, {x1, -2, 2}, {x2, -2, 2}, PlotLegends -> {Subscript[𝒬, 1], Subscript[𝒬, 2]}, ImageSize -> 100]]假设集合
是全维的,S-进程表明
当且仅当存在一些非负数
使得
视觉上存在非负
:
m1 = ArrayFlatten[{{a1, {b1}}, {{b1}, {{c1}}}}];
m2 = ArrayFlatten[{{a2, {b2}}, {{b2}, {{c2}}}}];
Plot[Boole[λm1Underscript[, {"SemidefiniteCone", 3}]m2], {λ, 0, 5}, ImageSize -> Small]SemidefiniteOptimization[0, λ(| | |
| -- | -- |
| a1 | b1 |
| b1 | c1 |)Underscript[, {"SemidefiniteCone", 3}](| | |
| -- | -- |
| a2 | b2 |
| b2 | c2 |), λ]最小化
受限于
. 把目标
转换成带有额外约束
的线性函数
,其等于
:
SemidefiniteOptimization[t, {(| | |
| - | - |
| x | 1 |
| 1 | y |)Underscript[, {"SemidefiniteCone", 2}]0, -t ≤ x + y ≤ t}, {x, y, t}]最小化
受限于
. 使用
和额外约束
把目标转换成线性函数:
SemidefiniteOptimization[s1 + s2, {(| | |
| - | - |
| x | 1 |
| 1 | y |)Underscript[, {"SemidefiniteCone", 2}]0, -s1 ≤ x + y ≤ s1, -s2 ≤ x - y ≤ s2}, {x, y, s1, s2}]最小化
受限于
. 把目标转换成带有额外约束
的线性函数
,其等于
:
SemidefiniteOptimization[s, {(| | |
| - | - |
| x | 1 |
| 1 | y |)Underscript[, {"SemidefiniteCone", 2}]0, -s ≤ x + y ≤ s, -s ≤ x - y ≤ s}, {x, y, s}]最小化
受限于
,其中,通过最小化
,
是一个非递减函数. 原始最小化
将保持不变. 考虑最小化
,受限于
:
f = Function[{s}, Sqrt[s]];{minval, Subscript[z, min]} = SemidefiniteOptimization[x + y, {(| | |
| - | - |
| x | 1 |
| 1 | y |)Underscript[, {"SemidefiniteCone", 2}]0, x + y ≥ 0}, {x, y}, {"PrimalMinimumValue", "PrimalMinimizerRules"}]f[minval]数据拟合问题 (5)
data = IconizedObject[«Block»];
dataplot = ListPlot[data, PlotRange -> All]选择多项式基并使用 DesignMatrix 构建输入矩阵和输出向量:
bases = Map[x^#&, Range[0, 5]];
input = DesignMatrix[data, bases, x];
output = data[[All, 2]];使用辅助变量
,目标被转换成最小化
使得
,其等于
如基本模型变换所示:
res = SemidefiniteOptimization[t, {ℐ == IdentityMatrix[Length[input]], a == input, b == output, (| | |
| ------- | ------- |
| t | a.c - b |
| a.c - b | t ℐ |)Underscript[, "SemidefiniteCone"]0}, {t, c}]Show[dataplot, Plot[Evaluate[bases.(c /. res)], {x, 0, 1}]]通过使用切比雪夫基最小化
找到在对数比例上变化的离散数据的近似函数:
data = IconizedObject[«Block»];basis = Table[ChebyshevT[k, s], {k, 0, 5}];
a = DesignMatrix[data, basis, s];
b = data[[All, 2]];因为数据是对数比例,直接数据拟合并不理想. 所以把问题转换成最小化
. 使用辅助变量
,最小化
使得
. 该约束等价于
:
constraints = MapThread[(| | | |
| ------------- | --------- | - |
| t - (#1.x/#2) | 0 | 0 |
| 0 | (#1.x/#2) | 1 |
| 0 | 1 | t |)Underscript[, "SemidefiniteCone"]0&, {a, b}];res = SemidefiniteOptimization[t, constraints, {t, x}]chebyshevFit = (basis.x) /. resShow[ListLogPlot[data], LogPlot[chebyshevFit, {s, -1, 1}]]数据拟合可以直接使用 Fit 获得. 然而,没有对数转换的话在近似函数中会有显著的振荡:
fit1 = basis.Fit[{a, b}, NormFunction -> Infinity];Show[ListLogPlot[data], LogPlot[{chebyshevFit, fit1}, {s, -1, 1}]]poly = 2 + 4x + 6x^2 + 4x^3 + x^4 - 2y + y^2;v = {1, x, y, x^2, y^2, x y};n = Length[v];
mat = Array[Indexed[q, {##}]&, {n, n}];
Q = UpperTriangularize[mat] + Transpose[UpperTriangularize[mat, 1]];coeffs = Map[# == 0&, DeleteCases[Flatten[CoefficientList[v.Q.v - poly, {x, y}]], 0]]res = SemidefiniteOptimization[0, {coeffs, qUnderscript[, {"SemidefiniteCone", n}]0}, q]二次项
,其中,
是从
的 Cholesky 分解获得的下三角矩阵:
L = CholeskyDecomposition[(Q /. res) + 10^-8IdentityMatrix[n]];
g = L.v;
Chop[Expand[Sum[g[[i]]^2, {i, Length[g]}]], 10^-7]Chop[Expand[Total[g ^ 2]] - poly, 10^-7]m = 33;n = 7;k = 4;
SeedRandom[234];
a = RandomReal[{-1, 1}, {m, n}];
b = RandomReal[{-1, 1}, m];decisionConstraints = {Total[z] ≤ k, 0z1, z∈Vectors[n, Integers]};coeffConstraint = -100 zx100z;transformationConstraint = With[{w = Inactive[Plus][a.x, -b]},
(| | |
| - | --------------------- |
| t | w |
| w | t * IdentityMatrix[m] |)Underscript[, "SemidefiniteCone"]0];SemidefiniteOptimization[t, {transformationConstraint,
decisionConstraints, coeffConstraint}, {t, x, z}]也可以用 Fit 通过
正则化更高效地完成子集选择. 首先,找到最多使用
个基函数的正则化参数的范围:
nterms = Table[{λ, Length[Fit[{a, b}, FitRegularization -> {"L1", λ}]
["NonzeroPositions"]]}, {λ, 0.1, 3, 0.02}];
λk = Mean[MinMax[Cases[nterms, {x_, k} -> x]]]fitTerms = Flatten[Fit[{a, b}, FitRegularization -> {"L1", λk}]
["NonzeroPositions"]]Fit[{a[[All, fitTerms]], b}]refFun[x_] := Exp[-(5 * (x - 1 / 2)) ^ 2];
data = Table[{x, refFun[x]}, {x, 0, 1, 0.02}];basis = Join[Cos[Range[10] * Pi * x], Sin[Range[10] * Pi * x]];
qf = DesignMatrix[data, basis, x, IncludeConstantBasis -> False];
cf = data[[All, 2]];
{n, m} = Dimensions[qf];functionConstraint = {Total[z] ≤ 5, 0z1};coeffConstraint = {-10 * zxz * 10};res = SemidefiniteOptimization[t, {ℐ == IdentityMatrix[n], a == qf,
b == cf, (| | |
| ------- | ------- |
| t | a.x - b |
| a.x - b | t ℐ |)Underscript[, "SemidefiniteCone"]0, functionConstraint, coeffConstraint}, {t, x, z∈Vectors[m, Integers]}]{coeffs, chosen} = {x, z} /. res;
fun = Total[Pick[basis * coeffs, chosen, 1]];
Plot[fun, {x, 0, 1}, Epilog -> Point[data], PlotRange -> All]几何问题 (6)
SeedRandom[123];
pts = RandomReal[{-1, 1}, {100, 2}];对于每个点
,必须满足约束条件
. 该约束条件等价于
. 在构建约束条件时使用 Inactive:
ℐ = IdentityMatrix[2, SparseArray];
constraints = Table[(| | |
| ------- | ------- |
| r | -c + pi |
| -c + pi | r ℐ |)Underscript[, "SemidefiniteCone"]0, {pi, pts}];res = SemidefiniteOptimization[r, constraints, {r, c∈Vectors[2]}]Graphics[{Circle[c, r] /. res, {Red, PointSize[0.02], Point[pts]}}]可通过 BoundingRegion 找到面积最小的包围圆盘:
BoundingRegion[pts, "MinDisk"]pts = IconizedObject[«With»];constraints = Table[Norm[a.pi + b] ≤ 1, {pi, pts}];面积与
成正比. 应用单调函数 Log,要最小化的函数变为
. 这相当于最小化
:
res = SemidefiniteOptimization[-Tr[a], {constraints, aUnderscript[, {"SemidefiniteCone", 2}]0}, {a, b∈Vectors[2]}]{Σ, x0} = {Inverse[Transpose[a].a /. res], -LinearSolve[a, b] /. res};
minAreaEllipse = Ellipsoid[x0, Σ]Graphics[{{Opacity[0.5], Red, Ellipsoid[x0, Σ]}, {PointSize[0.025], Point[pts]}}]可以用 BoundingRegion 求边界椭圆(面积不一定最小):
fastEllipse = BoundingRegion[pts, "FastEllipse"]{Area[minAreaEllipse], Area[fastEllipse]}Graphics[{{Lighter[Blue, 0.6], fastEllipse}, {Opacity[0.3], Red, minAreaEllipse}}, ImageSize -> Tiny]pts = IconizedObject[«With»];constraints = Table[Norm[a.pi + b] ≤ 1, {pi, pts}];res = SemidefiniteOptimization[-Tr[a], {constraints, aUnderscript[, {"SemidefiniteCone", 3}]0}, {a, b∈Vectors[3]}]{Σ, x0} = {Inverse[Transpose[a].a /. res], -LinearSolve[a, b] /. res};
minVolEllipsoid = Ellipsoid[x0, Σ]Graphics3D[{{Opacity[0.3], Red, Ellipsoid[x0, Σ]}, {PointSize[0.025], Point[pts]}}]可以用 BoundingRegion 求边界椭球(体积不一定最小):
fastEllipsoid = BoundingRegion[pts, "FastEllipsoid"]{Volume[minVolEllipsoid], Volume[fastEllipsoid]}cmesh = ConvexHullMesh[IconizedObject[«With»]];segs = MeshPrimitives[cmesh, 1][[All, 1]];
a = segs /. {p_, q_} :> {-1, 1} * Reverse[p - q];
b = MapThread[#1.#2&, {a, segs[[All, 1]]}];把参数化应用到半平面给出
. 其中
. 因此,约束条件为
,它等价于
:
ℐ = IdentityMatrix[2];
constraints = MapThread[(| | |
| ---------- | ------------ |
| -#1.d + #2 | c.#1 |
| c.#1 | (#2 - #1.d)ℐ |)Underscript[, "SemidefiniteCone"]0&, {a, b}];res = SemidefiniteOptimization[-Tr[c], {constraints, cUnderscript[, {"SemidefiniteCone", 2}]0}, {c, d∈Vectors[2]}]inscribedEllipse = Ellipsoid[d, Transpose[c].c] /. resShow[cmesh, Graphics[{LightRed, inscribedEllipse}]]求由
给定的包围三个椭圆(形式为
)的圆盘的中心
和半径
:
ellipse[1] = {{{0.13, 0.02}, {0.02, 0.62}}, {.2, .4}, .1};
ellipse[2] = {{{.18, -.16}, {-.16, .35}}, {.1, .2}, 0.1};
ellipse[3] = {{{0.7, 0.68}, {0.68, 0.94}}, {0.4, .3}, 0.12};通过 S-procedure,可得出当且仅当
,圆盘才包含椭圆:
ℐ = IdentityMatrix[2];
ellipseConstraint = Table[{a, b, c} = ellipse[i];(| | |
| -- | -- |
| γ | -p |
| -p | ℐ |)Underscript[, {"SemidefiniteCone", 3}]Indexed[τ, i](| | |
| - | - |
| c | b |
| b | a |), {i, 3}];目的是最小化由
给定的半径
. 使用辅助变量
,目标变为最小化使得
的
,可以写为
:
auxConstraint = (| | |
| ----- | - |
| t + γ | p |
| p | ℐ |)Underscript[, {"SemidefiniteCone", 3}]0;res = SemidefiniteOptimization[t, {auxConstraint, ellipseConstraint, τ0}, {t, γ, p∈Vectors[2], τ∈Vectors[3]}]enclosingDisk = Disk[p, Sqrt[t]] /. resexplicitEllipses = Table[{a, b, c} = ellipse[i];
With[{ai = Inverse[a]}, Ellipsoid[-ai.b, ai(b.ai.b - c)]], {i, 3}];Graphics[{{Lighter[Red, 0.8], enclosingDisk}, {Opacity[0.5], Blue, explicitEllipses}}, Frame -> True]{a1, b1, c1} = {{{0.13, 0.2}, {0.2, 0.62}}, {.2, .4}, .01};
{a2, b2, c2} = {{{0.7, 0.68}, {0.68, 0.94}}, {0.35, .42}, 0.12};通过 S-procedure,可得出当且仅当
,椭圆 2 才是椭圆 1 的子集::
subsetConstraint = (| | |
| -- | -- |
| a1 | b1 |
| b1 | c1 |)Underscript[, {"SemidefiniteCone", 3}]τ(| | |
| -- | -- |
| a2 | b2 |
| b2 | c2 |);SemidefiniteOptimization[0, {subsetConstraint, τ ≥ 0}, τ]ellipse1 = With[{ai = Inverse[a1]}, Ellipsoid[-ai.b1, ai(b1.ai.b1 - c1)]];
ellipse2 = With[{ai = Inverse[a2]}, Ellipsoid[-ai.b2, ai(b2.ai.b2 - c2)]];Graphics[{{Red, Opacity[0.5], ellipse1}, {Blue, Opacity[0.5], ellipse2}}]{a3, b3, c3} = {{{0.7, 0.68}, {0.68, 0.94}}, {0.45, .42}, 0.12};
ellipse3 = With[{ai = Inverse[a3]}, Ellipsoid[-ai.b3, ai(b3.ai.b3 - c3)]];测试显示问题是不可行的,表明椭球 2 不是椭球 1 的子集:
SemidefiniteOptimization[0, {(| | |
| -- | -- |
| a1 | b1 |
| b1 | c1 |)Underscript[, {"SemidefiniteCone", 3}]τ(| | |
| -- | -- |
| a3 | b3 |
| b3 | c3 |), τ ≥ 0}, τ];Graphics[{{Red, Opacity[0.5], ellipse1}, {Blue, Opacity[0.5], ellipse3}}]分类问题 (2)
{set1, set2} = IconizedObject[«Block»];
dataplot = ListPlot[{set1, set2}, PlotMarkers -> {Automatic, PointSize[0.025]}]如果想要分隔两组点,集合 1 必须满足
. 集合 2 必须满足
:
ellipsefun = Function[{x, y}, c + x^2Indexed[a, {1, 1}] + 2x y Indexed[a, {1, 2}] + y^2Indexed[a, {2, 2}] + x Indexed[b, {1}] + y Indexed[b, {2}]];
constraints = {Apply[ellipsefun, Transpose[set1]]0,
Apply[ellipsefun, Transpose[set2]]0, aUnderscript[, {"SemidefiniteCone", 2}]0};res = SemidefiniteOptimization[0, constraints, {a, b∈Vectors[2, Reals], c}]Show[Region[With[{v = {x, y}}, ImplicitRegion@@{v.a.v + b.v + c ≤ 0 /. res, v}]], dataplot]{set1, set2} = IconizedObject[«Block»];
dataplot = ListPlot[{set1, set2}, PlotMarkers -> {Automatic, PointSize[0.025]}]如果想要分隔两组点,集合 1 必须满足
,集合 2 必须满足
:
ellipsefun = Function[{x, y}, c + x^2Indexed[a, {1, 1}] + 2x y Indexed[a, {1, 2}] + y^2Indexed[a, {2, 2}] + x Indexed[b, {1}] + y Indexed[b, {2}]];
constraints = {Apply[ellipsefun, Transpose[set1]]0,
Apply[ellipsefun, Transpose[set2]]0};ℐ = IdentityMatrix[2];
circleConstraints = {ℐUnderscript[, {"SemidefiniteCone", 2}]aUnderscript[, {"SemidefiniteCone", 2}]γ ℐ, γ ≥ 1};res = SemidefiniteOptimization[γ, {constraints, circleConstraints, aUnderscript[, {"SemidefiniteCone", 2}]0}, {a, b∈Vectors[2, Reals], c, γ}]Show[Region[With[{v = {x, y}}, ImplicitRegion@@{v.a.v + b.v + c ≤ 0 /. res, v}]], dataplot]图问题 (3)
使用半定优化可计算的 Lovász 数被用作硬计算图不变量的边界:
{ShannonC, LovaszNum, cliqueNum, cromaticNum} = GraphData[{"Cycle", 5}, {"ShannonCapacity", "LovaszNumber", "CliqueNumber", "ChromaticNumber"}]ShannonC ≤ LovaszNumcliqueNum ≤ LovaszNum ≤ cromaticNum图
的 Lovász 数
由
给出,其中,
,对于
,
且
. 可以写成对偶半定格式:
,
,受限于
和
,否则为 0:
LovaszTheta[g_ ? GraphQ] := Module[{n = VertexCount[g], m = AdjacencyMatrix[g], amats, adjvs},
adjvs = UpperTriangularize[m]["NonzeroPositions"];amats = Join[{ConstantArray[-1, {n, n}], IdentityMatrix[n]}, Apply[Function[SparseArray[{{#1, #2} -> 1, {#2, #1} -> 1}, {n, n}]], adjvs, 1]];
SemidefiniteOptimization[Flatten[{1, ConstantArray[0, Length[adjvs]]}], amats, "DualMaximumValue"]]比较 GraphData 中确切的 Lovász 数值:
{G = CycleGraph[5], N[GraphData[{"Cycle", 5}, "LovaszNumber"]], LovaszTheta[G]}{G = GraphData[{"Complete", 4}], GraphData[{"Complete", 4}, "LovaszNumber"], LovaszTheta[G]}{G = GraphData["PetersenGraph"], GraphData["PetersenGraph", "LovaszNumber"], LovaszTheta[G] }{G = GraphData[{"Rook", {2, 4}}], GraphData[{"Rook", {2, 4}}, "LovaszNumber"], LovaszTheta[G]}{G = RandomGraph[{300, 500}], LovaszTheta[G]}矩阵切割问题确定图的顶点
的子集
,从
跨到补集
的边的权重
之和被最大化. 对于
,让
,对于
,让
. 最大化
,其中,
和
是图的拉普拉斯矩阵:
laplacianMatrix[G_ ? GraphQ] := (DiagonalMatrix[Total[#, {1}]] - #)&[WeightedAdjacencyMatrix[G]]对于较小的情况,最大切割问题可以被精确地解决,但是对于较大的图来说,这是不切实际的,因为一般来说,这个问题具有NP-完备复杂度:
maxCutExact[G_ ? GraphQ] := Module[{L = laplacianMatrix[G], n, x},
n = Length[First[L]];
x = Array["var", n];
MaxValue[{1 / 4x.L.x, x ^ 2 == ConstantArray[1, n]}, x, Integers]
]问题最小化
,其中,
是对称秩-1正半定矩阵,对于每个
,
,等价于
,其中,
是在第
个对角位置为 1 ,其他为 0 的矩阵. 为了使解决方案切实可行,求解松弛问题,其中,秩-1 条件被消除. 对于该
,通过随机舍入构建切割: 分解
,令
是单位范数的均匀分布的随机向量,并且令
. 对于演示,显示松驰值的函数被定义,
中舍入值和带有顶点的图显示为红色:
maxCutRelaxed[G_ ? GraphQ, trials_ : 10] := Module[{L = laplacianMatrix[G], Y, U, n, sdpmax, x},
n = Length[First[L]];{Y, sdpmax} = SemidefiniteOptimization[ConstantArray[1, n], Prepend[Table[SparseArray[{i, i} -> 1., {n, n}, 0.], {i, n}], -L / 4], {"DualMaximizer", "DualMaximumValue"}];
U = CholeskyDecomposition[Y];
x = First[MaximalBy[Table[Sign[RandomPoint[Sphere[n]].U], trials], 1 / 4#.L.#&]];
{sdpmax, 1 / 4x.L.x, HighlightGraph[G, Pick[Range[n], x, 1]]}
]triang = Graph[{12, 23, 31}, EdgeWeight -> {2, 3, 4}, VertexSize -> Small, VertexLabels -> Placed["Name", Center], EdgeLabels -> "EdgeWeight"];
{maxCutExact[triang], maxCutRelaxed[triang]}grid = GridGraph[{3, 4}, PlotLabel -> "SubscriptBox[G, 3, 4]", VertexLabels -> "Name", VertexSize -> Medium];
{maxCutExact[grid], maxCutRelaxed[grid]}g1 = RandomGraph[{15, 24}];
{maxCutExact[g1], maxCutRelaxed[g1]}pet = PetersenGraph[8, 2, VertexSize -> Medium];
AbsoluteTiming[maxCutExact[pet]]AbsoluteTiming[maxCutRelaxed[pet]]求指定的图(顶点为
)的子集
,使得从
到补集
的边的权重
的和最大化. 指定图:
g = PetersenGraph[4, 2, ...]目标是最大化
,其中
是对称的 rank-1 正半定矩阵,
是图的拉普拉斯矩阵:
L = (DiagonalMatrix[Total[#, {1}]] - #)&[WeightedAdjacencyMatrix[g]];
objective = -Total[Inactive[Times][L, Y], 2];n = Length[L];
decisionConstraints = {Table[Indexed[Y, {i, i}] == 1, {i, n}], s == (Y + 1) / 2, 0s1, YUnderscript[, "SemidefiniteCone"]0};去除 rank-1 矩阵的假设,对产生的最大割问题进行求解:
res = SemidefiniteOptimization[objective, decisionConstraints, {Y∈Matrices[{n, n}, Integers], s∈Matrices[{n, n}, Integers]}]subset = First[DeleteDuplicates[Y /. res]]HighlightGraph[g, Pick[Range[n], subset, 1]]控制和动力系统问题 (3)
显示线性动力系统
对任何初始条件都是渐近稳定的. 当且仅当存在一个正定矩阵
使得
,其中,
被称为 Lyapunov 函数,则认为该系统是稳定的:
A = {{-1, 2, 0}, {-3, -4, 1}, {0, 0, -2}};微分 Lyapunov 函数
给出
. 因此,稳定条件是
:
stabilityConditions = {A.P + P.AUnderscript[, {"SemidefiniteCone", 3}]0, PUnderscript[, {"SemidefiniteCone", 3}]0};res = SemidefiniteOptimization[0, stabilityConditions, P]Eigenvalues[A.P + P.A /. res]由于系统的解析解是
,因此在数值上验证任何系统在任何初始条件下都将变为零. 对于此模拟,取
:
ics = RandomReal[{-100, 100}, {3, 100000}];
Norm[MatrixExp[A * 20.].ics, "Frobenius"]A = {{2, -0.1}, {-0.5, 2}};
B = {{1, 1, 0}, {0, 1, 1}};使用 Lyapunov 稳定性定理,目标是找到矩阵
使之满足稳定性约束
. 令
,第一个约束成为适当的半定约束
:
stabilityConditions = {A.P + B.Z + P.A + (B.Z)Underscript[, {"SemidefiniteCone", 2}]0, PUnderscript[, {"SemidefiniteCone", 2}]0};res = SemidefiniteOptimization[0, stabilityConditions, {P, Z∈Matrices[{3, 2}]}]Q = Z.Inverse[P] /. res;Eigenvalues[A + B.Q]sol = NDSolveValue[{x'[t] == (A + B.Q).x[t], x[0] == {1, 1}}, x, {t, 0, 10}];
Plot[sol[t], {t, 0, 10}, PlotRange -> All]f = {-y - (3 / 2)x ^ 2 - (1 / 2)x ^ 3, 3x - y};v = {x, y, x ^ 2, y ^ 2, x y};n = Length[v];
mat = Array[Indexed[p, {##}]&, {n, n}];
P = UpperTriangularize[mat] + Transpose[UpperTriangularize[mat, 1]];V = v.P.v;
Vdot = Expand[D[V, {{x, y}}].f];coeffs1 = Map[# >= 0&, DeleteCases[Flatten[CoefficientList[V - 0.(x ^ 2 + y ^ 2), {x, y}]], 0]];
coeffs2 = Map[# <= 0&, DeleteCases[Flatten[CoefficientList[Vdot, {x, y}]], 0]];res = SemidefiniteOptimization[0, {coeffs1, coeffs2, pUnderscript[, {"SemidefiniteCone", 6}]0}, p];lyap = Expand@Chop[Simplify[V /. res], 10 ^ -9]可视化 Lyapunov 函数. 函数的最小位置与吸引子的位置匹配:
Show[StreamPlot[f, {x, -5, 5}, {y, -5, 5}, StreamStyle -> "Segment"], ContourPlot[lyap, {x, -5, 5}, {y, -5, 5}, Sequence[...]], AspectRatio -> 1 / GoldenRatio, ImageSize -> 350]结构优化问题 (1)
设计一个最小重量的桁架,一端固定在墙上,必须能够承受另一端的负载:
可以用 link 和节点对桁架进行建模. 每个节点通过 link 连接到相邻节点. 指定节点位置
:
nodes = Flatten[Outer[List, {0, 1, 2}, {0, 1, 2}], 1];
nNodes = Length[nodes];anchorPoints = {{0, 0}, {0, 1}, {0, 2}};forcingPoint = {2, 0};指定通过 link 相互连接的节点,并计算每个 link 的长度:
links = {...};
linkLengths = Table[EuclideanDistance@@nodes[[ni]], {ni, links}];
nLinks = Length[links];plot = Show[Graphics[GraphicsComplex[...]], Graphics[...]]link 为圆杆. 每个 link 必须从一组横截面为
的圆杆中选择. 设
为每个link
的决策变量,如果
,则圆杆
被选中. 对于 link
,面积被定义为
. 目标是最小化重量:
areas = {20, 30, 40};
objective = linkLengths.s;barSelectionConstraint = Table[Indexed[s, i] == areas.x[i], {i, nLinks}];binaryConstraint = Table[{Total[x[i]] ≤ 1, 0x[i]1}, {i, nLinks}];anchorIndex = Map[Position[nodes, #][[1, 1]]&, anchorPoints];
freeNodeIndex = Complement[Range[nNodes], anchorIndex];
m = Length[freeNodeIndex];系统的刚度矩阵由
给出,其中
是节点的总数,
是锚定的节点的数量,
是所有 link 的集合. 如果
,向量
;如果
,
,否则为 0:
bEdge[{i_, j_}] := Module[...];设
为整个系统的受力向量. 在每个没有被锚定的节点处,受力为
. 在节点
处施加力:
forceIndex = Position[nodes, forcingPoint][[1, 1]];
forceVector = Flatten[Table[If[s == forceIndex, {0, -1}, {0, 0}],
{s, freeNodeIndex}]];设
为任何节点处允许的最大的挠度. 设
为节点
的位移;那么,如果
,则有
,其中
是与 link
关联的刚度矩阵:
stiffnessMatrices = Sum[...];
stiffnessConstant = With[{γ = 0.1}, {...}];
stiffnessConstraint = Inactive[Plus][stiffnessConstant,
stiffnessMatrices]Underscript[, "SemidefiniteCone"]0;vars = Flatten[{s∈Vectors[nLinks, Reals],
Table[x[i]∈Vectors[Length[areas], Integers], {i, nLinks}]}];res = SemidefiniteOptimization[objective, {barSelectionConstraint,
binaryConstraint, stiffnessConstraint}, vars];optlinkPos = Flatten[Position[s /. res, x_ /; x > 1]]可视化最优桁架. 对于构成最优桁架的 link,基于使用的圆杆的面积对其着色:
colors = {Blue, Purple, Red};
Row[{Graphics[...], LineLegend[...]}]属性和关系 (8)
SemidefiniteOptimization 给出了目标函数的全局最小值:
res = SemidefiniteOptimization[2Subscript[x, 1] + 3Subscript[x, 2], (| | |
| -- | -- |
| x1 | 1 |
| 1 | x2 |)Underscript[, {"SemidefiniteCone", 2}]0, {Subscript[x, 1], Subscript[x, 2]}]Show[Plot3D[2Subscript[x, 1] + 3Subscript[x, 2], {Subscript[x, 1], Subscript[x, 2]}∈ImplicitRegion[...]], Graphics3D[...]]Minimize 为半定问题提供全局精确结果:
Minimize[{2Subscript[x, 1] + 3Subscript[x, 2], (| | |
| -- | -- |
| x1 | 1 |
| 1 | x2 |)Underscript[, {"SemidefiniteCone", 2}]0}, {Subscript[x, 1], Subscript[x, 2]}]%//N与 SemidefiniteOptimization 相比:
SemidefiniteOptimization[2Subscript[x, 1] + 3Subscript[x, 2], (| | |
| -- | -- |
| x1 | 1 |
| 1 | x2 |)Underscript[, {"SemidefiniteCone", 2}]0, {Subscript[x, 1], Subscript[x, 2]}, {"PrimalMinimumValue", "PrimalMinimizerRules"}]NMinimize 用于使用全局方法获得不精确的结果:
NMinimize[{2Subscript[x, 1] + 3Subscript[x, 2], (| | |
| -- | -- |
| x1 | 1 |
| 1 | x2 |)Underscript[, {"SemidefiniteCone", 2}]0}, {Subscript[x, 1], Subscript[x, 2]}]FindMinimum 可用于使用局部方法获取不精确的结果:
FindMinimum[{2x + 3y, (| | |
| - | - |
| x | 1 |
| 1 | y |)Underscript[, {"SemidefiniteCone", 2}]0}, {x, y}]ConicOptimization 比 SemidefiniteOptimization 更通用:
ConicOptimization[2Subscript[x, 1] + 3Subscript[x, 2], (| | |
| -- | -- |
| x1 | 1 |
| 1 | x2 |)Underscript[, {"SemidefiniteCone", 2}]0, {Subscript[x, 1], Subscript[x, 2]}]SemidefiniteOptimization[2Subscript[x, 1] + 3Subscript[x, 2], (| | |
| -- | -- |
| x1 | 1 |
| 1 | x2 |)Underscript[, {"SemidefiniteCone", 2}]0, {Subscript[x, 1], Subscript[x, 2]}]SecondOrderConeOptimization 是 SemidefiniteOptimization 的一个特例:
SecondOrderConeOptimization[10x + 11y, {x + y ≥ 1, {x, y}∈Disk[]}, {x, y}]SemidefiniteOptimization[10x + 11y, {x + y ≥ 1, {x, y}∈Disk[]}, {x, y}]QuadraticOptimization 是 SemidefiniteOptimization 的一个特例:
obj = 2x^2 + 20y^2 + 6x y + 5x;
cons = {-x + y ≥ 2, y ≥ 0};QuadraticOptimization[obj, cons, {x, y}]SemidefiniteOptimization[t, {obj ≤ t, cons}, {x, y, t}]LinearOptimization 是 SemidefiniteOptimization 的一个特例:
LinearOptimization[10.x + 11.y, {x, y}∈RegularPolygon[4], {x, y}]SemidefiniteOptimization[10.x + 11.y, {x, y}∈RegularPolygon[4], {x, y}]可能存在的问题 (5)
res = SemidefiniteOptimization[2Subscript[x, 1] + 3Subscript[x, 2], (| | |
| -- | -- |
| x1 | 1 |
| 1 | x2 |)Underscript[, {"SemidefiniteCone", 2}]0, {Subscript[x, 1], Subscript[x, 2]}](| | |
| -- | -- |
| x1 | 1 |
| 1 | x2 |)Underscript[, {"SemidefiniteCone", 2}]0 /. resEigenvalues[(| | |
| -- | -- |
| x1 | 1 |
| 1 | x2 |) /. res]SemidefiniteOptimization[x, {x ≤ 0, x ≥ 1}, x, "PrimalMinimumValue"]最小值点是 Indeterminate:
SemidefiniteOptimization[x, {x ≤ 0, x ≥ 1}, x]SemidefiniteOptimization[-(x + y), x + y ≥ 1, {x, y}, "PrimalMinimumValue"]最小值点是 Indeterminate:
SemidefiniteOptimization[-(x + y), x + y ≥ 1, {x, y}]SemidefiniteOptimization[x + y, {x + 2y ≥ 3, x ≥ -2}, {x∈Integers, y∈Integers}, {"DualMaximumValue", "DualMaximizer", "DualityGap"}]c = {1, 2};Subscript[a, 0] = (| | |
| ----- | ----- |
| 0 | 1 + I |
| 1 - I | 0 |);Subscript[a, 1] = (| | |
| - | - |
| 1 | 0 |
| 0 | 0 |);Subscript[a, 2] = (| | |
| - | - |
| 0 | 0 |
| 0 | 1 |);SemidefiniteOptimization[c.v, {Subscript[a, 1], Subscript[a, 2]}.vUnderscript[, {"SemidefiniteCone", 2}]-Subscript[a, 0], v∈Vectors[2, Complexes]]Vectors[n] 自动运算为 Vectors[n,Complexes]:
Vectors[n]对于规范中没有复数的问题,向量变量 v ∈Vectors[n] 被认为是实值的;否则,您需要明确地将域指定为 Vectors[n,Reals]:
c = {1, 2};
SemidefiniteOptimization[c.v, {Subscript[a, 1], Subscript[a, 2]}.vUnderscript[, {"SemidefiniteCone", 2}]-Subscript[a, 0], v∈Vectors[2, Reals]]相关指南
-
▪
- 凸优化 ▪
- 基于矩阵的最小化 ▪
- 最优化 ▪
- 符号向量、矩阵和数组
文本
Wolfram Research (2019),SemidefiniteOptimization,Wolfram 语言函数,https://reference.wolfram.com/language/ref/SemidefiniteOptimization.html (更新于 2020 年).
CMS
Wolfram 语言. 2019. "SemidefiniteOptimization." Wolfram 语言与系统参考资料中心. Wolfram Research. 最新版本 2020. https://reference.wolfram.com/language/ref/SemidefiniteOptimization.html.
APA
Wolfram 语言. (2019). SemidefiniteOptimization. Wolfram 语言与系统参考资料中心. 追溯自 https://reference.wolfram.com/language/ref/SemidefiniteOptimization.html 年
BibTeX
@misc{reference.wolfram_2026_semidefiniteoptimization, author="Wolfram Research", title="{SemidefiniteOptimization}", year="2020", howpublished="\url{https://reference.wolfram.com/language/ref/SemidefiniteOptimization.html}", note=[Accessed: 01-November-2026]}
BibLaTeX
@online{reference.wolfram_2026_semidefiniteoptimization, organization={Wolfram Research}, title={SemidefiniteOptimization}, year={2020}, url={https://reference.wolfram.com/language/ref/SemidefiniteOptimization.html}, note=[Accessed: 01-November-2026]}