公告:1)网站程序升级:Q2A升级到1.8.6,Wordpress升级到5.7.2
2)修复了头像加载慢与提交问题反应慢等问题
2021-06-16

欢迎来到 Mathematica 问答社区

提问时请贴上文本代码

语法高亮:在编辑器中点击

被禁止的话题:广告破解

请阅读:《提问的智慧》

备用域名:mma.ooo

支持LaTex数学公式
行内公式标识符:\$ 或“$\backslash ($”+“$\backslash )$”,
行间公式标识符:\$\$ 或 “$\backslash [$”+“$\backslash ]$”

社区建议QQ群:365716997

分类

+1 投票
2.3k 浏览

永 提供的方法可以判断两个函数相似,但是对若尔当块顺序不同但是依然相似的矩阵判别失效

SimilarQ[a_, b_] := Equal @@ Last@*JordanDecomposition /@ {a, b}
A = {{1, 1, 0, 0, 0}, {0, 1, 0, 0, 0}, {0, 0, 1, 1, 0}, {0, 0, 0, 1, 
    0}, {0, 0, 0, 0, 1}};
B = {{1, 0, 0, 0, 0}, {0, 1, 1, 0, 0}, {0, 0, 1, 0, 0}, {0, 0, 0, 1, 
    1}, {0, 0, 0, 0, 1}};
SimilarQ[A, B]

这个函数对若尔当块顺序不一致的情况判断失败,实际上他们依然相似 只是若尔当块顺序不一致,如图:


也就是说,能否编写一个函数,对若尔当矩阵按一定规则排列且唯一,然后再比较...

也就是用Sort或者SortBy函数按照特征值由小到大排列若当块,要是特征值相同,按照若当块阶数由小到大排列...

 

 

分类:函数 | 用户: mma-2-2-2 (1.3k 分)
修改于 用户:mma-2-2-2

4 个回答

+1 投票
 
已采纳

好吧,我知道你想干什么了。

1、判断同阶方阵是否相似(程序中没有判断矩阵是否是方阵,也没有判断两矩阵是否同阶)

2、如果两矩阵相似($A={{P}^{-1}}BP$),给出变换矩阵$P$

代码如下:

1、判断相似,在之前的问题中回答过了,再整理一下:

(*定义函数*)
(*返回一个方阵的初等因子*)
cdyz[m_] := 
 Module[{r = Length[m], list = {}, n = 1, 
   j = JordanDecomposition[m][[2]]}, 
  Do[If[j[[k, k + 1]] == 1, n++, AppendTo[list, {j[[k, k]], n}];
     n = 1;];, {k, r - 1}];
  Sort@AppendTo[list, {j[[r, r]], n}]]
(*如果两的初等因子一样,则两矩阵相似*)
SimilarityMatrixQ[m1_, m2_] := cdyz[m1] === cdyz[m2]

(*例*)
A = {{1, 1, 0, 0, 0}, {0, 1, 0, 0, 0}, {0, 0, 1, 1, 0}, {0, 0, 0, 1, 
    0}, {0, 0, 0, 0, 1}};
B = {{1, 0, 0, 0, 0}, {0, 1, 1, 0, 0}, {0, 0, 1, 0, 0}, {0, 0, 0, 1, 
    1}, {0, 0, 0, 0, 1}};
SimilarityMatrixQ[A, B]

2、如果两矩阵相似,给出变换矩阵:

(*返回两个相似矩阵的变换矩阵T,其中B=Inverse[T].A.T,A=T.B.Inverse[T]*)
SimilarityMatrixT[m1_, m2_] := Module[{sa, ja, sb, jb, n, ret,kk},
   {sa, ja} = JordanDecomposition[m1];
   {sb, jb} = JordanDecomposition[m2];
   n = Length[A];
   ret = Normal[SparseArray[# -> 1 & /@ Transpose[{Range[n], #}]]] & /@
      Permutations[Range[n]];(*所有可能的行初等变换*)
   kk = FirstPosition[
      Table[ret[[k]].ja.Inverse[ret[[k]]] === jb, {k, Length[ret]}], 
      True][[1]];
   sa.Inverse[ret[[kk]]].Inverse[sb]
   ];

(*例*)
A = {{1, 1, 0, 0, 0}, {0, 1, 0, 0, 0}, {0, 0, 1, 1, 0}, {0, 0, 0, 1, 
    0}, {0, 0, 0, 0, 1}};
B = {{1, 0, 0, 0, 0}, {0, 1, 1, 0, 0}, {0, 0, 1, 0, 0}, {0, 0, 0, 1, 
    1}, {0, 0, 0, 0, 1}};
T = SimilarityMatrixT[A, B]
B === Inverse[T].A.T
A === T.B.Inverse[T]

其中2的大致思路如下:

由JordanDecomposition得:

{${{S}_{a}}$, ${{J}_{a}}$ } = JordanDecomposition[$A$];

{${{S}_{b}}$ , ${{J}_{b}}$ } = JordanDecomposition[$B$];

其中,$A={{S}_{a}}{{J}_{a}}S_{a}^{-1}$,$B={{S}_{b}}{{J}_{b}}S_{b}^{-1}$,

令$P$使得${{J}_{b}}=P{{J}_{a}}{{P}^{-1}}$,则

$B={{S}_{b}}{{J}_{b}}S_{b}^{-1}={{S}_{b}}P{{J}_{a}}{{P}^{-1}}S_{b}^{-1}={{S}_{b}}PS_{a}^{-1}A{{S}_{a}}{{P}^{-1}}S_{b}^{-1}$

所以变换矩阵$T={{S}_{a}}{{P}^{-1}}S_{b}^{-1}$

用户: 野鹤 (5.1k 分)
采纳于 用户:mma-2-2-2
主要是永的那个若尔当矩阵方法存在缺陷,比如我问题描述的两个矩阵是相似的,但是永的代码会认为不相似,因为相似与若尔当块的排列顺序无关的,所以要用永的思路的话,需要加一个函数,把若尔当矩阵的若尔当块排列规则话,这样就可以用相等比较了,主要是这个原因;谢谢你完善的代码,确实很好用。
嗯。
又补了一下数学推导。
若尔当块排序问题我已经又开了新帖,Happyfish解决了把若尔当矩阵的若尔当块按一定规则排序的问题,谢谢野鹤和Happyfish的指导。
1),运行程序的时候提示没有定义etm,宣哥的命名方式有点深奥哈。2),推导过程建议加上求$P$的过程,要不然在我看来问题相当于把求$T^{-1}AT=B$里的$T$,转化成了求$P^{-1}J_aP=J_b$里的$P$,而$J_a$和$J_b$的已经不能再若尔当分解了
1),etm是之前试程序的时候随便写的,现在已经改过来了,ret。
2),求P的过程,哈哈,穷举。
+2 投票

假如两个矩阵判断是否相等的标准是,按照分块以后再重排列再判断是否相等。

A = {{a, 0, 0, 0, 0}, {0, b, c, 0, 0}, {0, 0, d, 0, 0}, {0, 0, 0, e, 
    f}, {0, 0, 0, 0, g}};
B = {{b, c, 0, 0, 0}, {0, d, 0, 0, 0}, {0, 0, e, f, 0}, {0, 0, 0, g, 
    0}, {0, 0, 0, 0, a}};
split[list_] := 
 Flatten@MapAt[If[AllTrue[#, # === 0 &], Nothing, #] &, 
   Split[list], {{1}, {-1}}]
split2[list_] := Sort@Split[split /@ list, Length[#] =!= 1 &]
SameQ @@ (split2 /@ {A, B})

其中split函数,是寻找非0元素,split2函数是寻找分块矩阵,并排序,最后判断。

用户: 苹果 (2.2k 分)
重新显示 用户:野鹤
特征值相同是矩阵相似的必要条件,而非充分。
谢谢苹果,感觉这个排序很简洁高效,最后的结果和不变因子的形式差不多...
+1 投票

还是换成Rational Canonical Form吧。

CompanionMatrix[p_, x_] := 
 Module[{n, w = CoefficientList[p, x]}, w = -w/Last[w];
  n = Length[w] - 1;
  SparseArray[{{i_, n} :> w[[i]], {i_, j_} /; i == j + 1 -> 1}, {n, 
    n}]]

MatrixMinimalPolynomial[a_List?MatrixQ, x_] := 
 Module[{i, n = 1, qu = {}, 
   mnm = {Flatten[IdentityMatrix[Length[a]]]}}, 
  While[Length[qu] == 0, AppendTo[mnm, Flatten[MatrixPower[a, n]]];
   qu = NullSpace[Transpose[mnm]];
   n++];
  First[qu].Table[x^i, {i, 0, n - 1}]]

rationalMatrixForm[a_?(MatrixQ[#, NumericQ] &)] := 
 Module[(*version 8/24/
  13 2PM*){p, q, min, c = {}, moreFactors = True, z, x}, 
  p = CharacteristicPolynomial[a, x];
  min = MatrixMinimalPolynomial[a, x];
  While[moreFactors, q = PolynomialQuotient[p, min, x];
   If[q === 0, moreFactors = False;
    If[Not[FreeQ[p, x]], z = CompanionMatrix[p, x];
     AppendTo[c, z]], z = CompanionMatrix[min, x];
    AppendTo[c, z];
    p = q] (*if*)];(*end WHILE more factorization needed*)
  SparseArray[Band[{1, 1}] -> c]]

SimilarQ[a_, b_] := Equal @@ Last@*rationalMatrixForm /@ {a, b}

代码来源:http://mathematica.stackexchange.com/questions/30949/matrix-rational-canonical-form

用户: happyfish (1.8k 分)
+1 投票

抱歉,当时蹭课的时候教授并没有提及这种若尔当型不想等的情况,下面是从定义入手判断矩阵A和B是否相似, 如果存在一个可逆矩阵P使得$P^{-1}AP=B$,则矩阵A和B相似,否则不相似。如果相似,返回Ture,如果设置选项ShowP -> True,会返回一个满足条件的$P$矩阵,形如{Ture,P},否则返回False

BeginPackage["Numbers`"];
SimilarQ; ShowP;
Begin["`Private`"];
SyntaxInformation[
   SimilarQ] = {"ArgumentsPattern" -> {_, _, OptionsPattern[]}};
Options[SimilarQ] = {ShowP -> False};
SimilarQ[x_, OptionsPattern[]] := {x, OptionValue[ShowP]}
SimilarQ[A_, B_, OptionsPattern[]] :=
 Module[{P, Pele, nullP, linearP, co, state},
  P = Array[Pele, Dimensions[A]];
  nullP = NullSpace[
    Catenate[Normal@Last@CoefficientArrays[A.P - P.B, Flatten[P]]]];
  linearP =
   ArrayReshape[Array[co, Length[nullP]].nullP, Dimensions[P]];
  state = Resolve[
    Exists[Array[co, Length[nullP]], Det[linearP] =!= 0]];
  If[OptionValue[ShowP],
   If[state, {state,
     linearP /.
      First@FindInstance[Det[linearP] != 0,
        Array[co, Length[nullP]]]}, state], state]]
End[];
EndPackage[];

用法:

A = {{1, 1, 0, 0, 0}, {0, 1, 0, 0, 0}, {0, 0, 1, 1, 0}, {0, 0, 0, 1, 
    0}, {0, 0, 0, 0, 1}};
B = {{1, 0, 0, 0, 0}, {0, 1, 1, 0, 0}, {0, 0, 1, 0, 0}, {0, 0, 0, 1, 
    1}, {0, 0, 0, 0, 1}};
SimilarQ[A, B]
True

显示一个满足$P^{-1}AP=B$的变换矩阵$P$

{s, P} = SimilarQ[A, B, ShowP -> True]
{True, {{2, 2, 1, -2, -2}, {0, 0, 2, 0, -2}, {2, 1, -1, 2, -2}, {0, 0,
    1, 0, 2}, {-2, 0, -2, 0, 0}}}

验证$P$是否满足条件

Inverse[P].A.P == B
True

当不相似的时候

SimilarQ[A, B + 1]
False
用户: Lozmlve*永 (1.2k 分)
修改于 用户:Lozmlve*永
谢谢永,我认真学习一下,说实话看你们写的代码我很吃力,这么多人回复都这么好,谢谢大家,我一定认真理解透彻,争取为别人回答问题。
...