跳转至

特征多项式

特征的这部分只研究方阵，即矩阵 对应的线性变换将 个向量映射到 个向量。

由于在实际问题中，经常要考虑连续进行重复的变换，如果只用「矩阵 对应的线性变换将单位阵 变换为 」的描述，就会很抽象。此时最好的办法是找「不动点」，即变换当中不动的部分。

然而事实上，矩阵 对应的线性变换很可能没有不动点，于是退而求其次，寻找共线或者类似于简单变形的部分。

特征值与特征向量

在矩阵 对应的线性变换作用下，一些向量的方向不改变，只是伸缩了。

设 是 上的线性空间， 是 上的线性变换。若存在 中的 与 中的 非零向量 ，使得：

则称 为 的一个 特征值，而 为 的 属于特征值 的一个特征向量。

特征向量在同一直线上，在线性变换作用下保持方向不改变（压缩到零也认为是方向不改变）。特征向量不唯一，与特征向量共线的向量都是特征向量，但是规定零向量不是特征向量，拥有方向的向量自然是非零向量。特征向量的特征值就是它伸缩的倍数。

在实际应用中，一般对于拥有相同特征值的特征向量，会选取一组基作为它们全体的代表。

设 是 的一组基， 在这组基下的矩阵为 ，即：

设 是 的一个特征值， 为 的属于特征值 的一个特征向量，且有非零向量 满足：

于是有：

所以相应的行列式也为 。

特征多项式

考虑一个 的矩阵 ，其中 。设 为一个参量，矩阵 称为 的 特征矩阵。

特征矩阵的行列式称为 的 特征多项式，展开为一个 次多项式，根为 的特征值，记为 ：

其中 为一个 的单位矩阵。一些地方会定义为 与我们的定义仅相差了一个符号 ，但采用这种定义得到的 一定为首一多项式，而另外的定义则仅当 为偶数时才是首一多项式。需要注意的是 的矩阵行列式为 是良定义的。

相应于 的非零解向量 ，称为 的属于 的特征向量。

线性变换 有特征值 等价于矩阵 有特征值 。

线性变换 有特征向量 等价于矩阵 有特征向量 ，其中有：

根据代数基本定理，特征多项式可以分解为：

称 为特征值 的 代数重数。全体代数重数的和为空间维数 。

求解矩阵的全部特征值及特征向量

分为以下步骤：

  • 计算行列式 。
  • 求出多项式 在域 中的全部根，即 的特征值。
  • 对 的每个特征值 ，解齐次线性方程组 ，求出它的一组基础解系 ，则 的属于 的全部特征向量为：

该表达式中的 不全为零。

  • 线性变换 的属于 的特征向量为：

因此，属于 的全部特征向量为：

该表达式中的 不全为零。

特征值与特征向量是否存在，依赖于 所在的域。

相似变换

引入

若 的矩阵 为上三角矩阵如

那么

可轻松求得，下三角矩阵也是类似的。但如果 不属于这两种矩阵，则需要使用相似变换，使得矩阵变为容易求得特征多项式的形式。

定义

对于 的矩阵 和 ，当存在 的可逆矩阵 满足

则矩阵 和 相似，记变换 为相似变换。且 和 有相同的特征多项式。

考虑

得证，对于 也是一样的。另外 ，因为 故 。

定理：相似矩阵有相同的特征多项式及特征值，反之不然。

定理表明，线性变换的矩阵的特征多项式与基的选取无关，而直接由线性变换决定，故可称之为线性变换的特征多项式。

矩阵 的特征多项式 是一个首一的多项式。根据韦达定理，它的 次系数为：

其中 称为 的迹，为 的主对角线元素之和。

根据韦达定理，特征多项式的常数项为：

定理：相似的矩阵有相同的迹。

换位公式

定理：无论矩阵 和矩阵 是否方阵，只要乘法能进行，则矩阵 的迹等于矩阵 的迹。

一种证法是直接展开，即证毕。另一种证法用到换位公式。

定理：设 为 行 列矩阵，设 为 行 列矩阵，则有：

该公式表明 与 有相同的非零特征值。

舒尔（Schur）引理

任意的 阶矩阵 都相似于一个上三角阵，即存在满秩阵 ，使得 为上三角阵，它的主对角线上元素为 的全部特征值。

推论：设 的 个特征值为 ， 为任一多项式，则矩阵多项式 的 个特征值为：

特别地， 的特征值为 ， 的特征值为 。

使用高斯消元进行相似变换

对 的矩阵 可以进行高斯消元，其基本操作为初等行变换。

在对矩阵使用上述操作（左乘初等矩阵）后再右乘其逆矩阵即相似变换，左乘为行变换，易发现右乘即列变换。

若能将矩阵通过相似变换变为上三角或下三角的形式，那么可以轻松求出其特征多项式。但若对主对角线上的元素应用变换 后会导致原本通过 将第 行第 列的元素消为零后右乘 即将 的第 列的 倍加到第 列这一操作使得之前消为零的元素现在可能不为零，可能不能将其变为上三角或下三角形式。

后文将说明对次对角线上的元素应用变换后得到的矩阵依然可以轻松得到其特征多项式。

上 Hessenberg 矩阵

对于 的形如

的矩阵我们称为上 Hessenberg 矩阵，其中 为次对角线。

我们使用相似变换将次对角线以下的元素消为零后即能得到上 Hessenberg 矩阵，而求出一个 上 Hessenberg 矩阵的特征多项式则可在 时间完成。

我们记 为只保留 的前 行和前 列的矩阵，记 那么

在计算行列式时我们一般选择按零最多的行或列余子式展开，余子式即删除了当前选择的元素所在行和列之后的矩阵，在这里我们选择按最后一行进行展开，有

观察并归纳，对 有

至此完成了整个算法，该算法一般被称为 Hessenberg 算法。

Cayley–Hamilton 定理

对于任意的 阶矩阵 ，特征多项式为 ，则必有 。

对于线性变换 有平行的结果：如果 为 的特征多项式，则 为零变换。

由本定理可知，对于任意的矩阵 ，必有可以使其零化的多项式。

最小多项式

设 是一个 维向量空间，由于线性变换对应的矩阵有 个元素，一切线性变换构成 维线性空间。

对于一个特定的线性变换 ，从作用 次到作用 次，总共 个线性变换，它们对应的矩阵一定线性相关。于是存在非零多项式 ，使得 为零变换，称变换 满足多项式 。在 满足的所有多项式 中，存在次数最低的。

可以将矩阵 零化的最小次数的首一多项式称为 的最小多项式，记为 。

根据多项式的辗转相除法，最小多项式是唯一的，且可整除任一 的零化多项式。特别地，最小多项式整除特征多项式。

定理：在不计重数的情况下，矩阵 的特征多项式 与最小多项式 有相同的根。

定理：矩阵 的属于不同特征值的特征向量线性无关。

应用

在信息学中我们一般考虑 上的矩阵，通常 为素数，进行上述相似变换是简单的，当 为合数时，我们可以考虑类似辗转相除的方法来进行。

实现 
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
#include <cassert>
#include <iostream>
#include <random>
#include <vector>

using Matrix = std::vector<std::vector<int>>;
using i64 = int64_t;

Matrix to_upper_Hessenberg(const Matrix &M, int mod) {
  Matrix H(M);
  int n = H.size();
  for (int i = 0; i < n; ++i) {
    for (int j = 0; j < n; ++j) {
      if ((H[i][j] %= mod) < 0) H[i][j] += mod;
    }
  }
  for (int i = 0; i < n - 1; ++i) {
    int pivot = i + 1;
    for (; pivot < n; ++pivot) {
      if (H[pivot][i] != 0) break;
    }
    if (pivot == n) continue;
    if (pivot != i + 1) {
      for (int j = i; j < n; ++j) std::swap(H[i + 1][j], H[pivot][j]);
      for (int j = 0; j < n; ++j) std::swap(H[j][i + 1], H[j][pivot]);
    }
    for (int j = i + 2; j < n; ++j) {
      for (;;) {
        if (H[j][i] == 0) break;
        if (H[i + 1][i] == 0) {
          for (int k = i; k < n; ++k) std::swap(H[i + 1][k], H[j][k]);
          for (int k = 0; k < n; ++k) std::swap(H[k][i + 1], H[k][j]);
          break;
        }
        if (H[j][i] >= H[i + 1][i]) {
          int q = H[j][i] / H[i + 1][i], mq = mod - q;
          for (int k = i; k < n; ++k)
            H[j][k] = (H[j][k] + i64(mq) * H[i + 1][k]) % mod;
          for (int k = 0; k < n; ++k)
            H[k][i + 1] = (H[k][i + 1] + i64(q) * H[k][j]) % mod;
        } else {
          int q = H[i + 1][i] / H[j][i], mq = mod - q;
          for (int k = i; k < n; ++k)
            H[i + 1][k] = (H[i + 1][k] + i64(mq) * H[j][k]) % mod;
          for (int k = 0; k < n; ++k)
            H[k][j] = (H[k][j] + i64(q) * H[k][i + 1]) % mod;
        }
      }
    }
  }
  return H;
}

std::vector<int> get_charpoly(const Matrix &M, int mod) {
  Matrix H(to_upper_Hessenberg(M, mod));
  int n = H.size();
  std::vector<std::vector<int>> p(n + 1);
  p[0] = {1 % mod};
  for (int i = 1; i <= n; ++i) {
    const std::vector<int> &pi_1 = p[i - 1];
    std::vector<int> &pi = p[i];
    pi.resize(i + 1, 0);
    int v = mod - H[i - 1][i - 1];
    if (v == mod) v -= mod;
    for (int j = 0; j < i; ++j) {
      pi[j] = (pi[j] + i64(v) * pi_1[j]) % mod;
      if ((pi[j + 1] += pi_1[j]) >= mod) pi[j + 1] -= mod;
    }
    int t = 1;
    for (int j = 1; j < i; ++j) {
      t = i64(t) * H[i - j][i - j - 1] % mod;
      int prod = i64(t) * H[i - j - 1][i - 1] % mod;
      if (prod == 0) continue;
      prod = mod - prod;
      for (int k = 0; k <= i - j - 1; ++k)
        pi[k] = (pi[k] + i64(prod) * p[i - j - 1][k]) % mod;
    }
  }
  return p[n];
}

bool verify(const Matrix &M, const std::vector<int> &charpoly, int mod) {
  if (mod == 1) return true;
  int n = M.size();
  std::vector<int> randvec(n), sum(n, 0);
  std::mt19937 gen(std::random_device{}());
  std::uniform_int_distribution<int> dis(1, mod - 1);
  for (int i = 0; i < n; ++i) randvec[i] = dis(gen);
  for (int i = 0; i <= n; ++i) {
    int v = charpoly[i];
    for (int j = 0; j < n; ++j) sum[j] = (sum[j] + i64(v) * randvec[j]) % mod;
    std::vector<int> prod(n, 0);
    for (int j = 0; j < n; ++j) {
      for (int k = 0; k < n; ++k) {
        prod[j] = (prod[j] + i64(M[j][k]) * randvec[k]) % mod;
      }
    }
    randvec.swap(prod);
  }
  for (int i = 0; i < n; ++i)
    if (sum[i] != 0) return false;
  return true;
}

int main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(nullptr);
  int n, mod;
  std::cin >> n >> mod;
  Matrix M(n, std::vector<int>(n));
  for (int i = 0; i < n; ++i)
    for (int j = 0; j < n; ++j) std::cin >> M[i][j];
  std::vector<int> charpoly(get_charpoly(M, mod));
  for (int i = 0; i <= n; ++i) std::cout << charpoly[i] << ' ';
  assert(verify(M, charpoly, mod));
  return 0;
}

上述 Hessenberg 算法不具有数值的稳定性，所以 上的矩阵在使用前需要其他算法进行调整或改用其他具有数值稳定性的算法。

我们可以将特征多项式与常系数齐次线性递推联系起来，也可结合 Cayley–Hamilton 定理、多项式取模加速一些域上求矩阵幂次的算法。

Cayley–Hamilton 定理指出

其中 为 的零矩阵， 且 为 的特征多项式。

若我们要求 其中 较大，那么可以求出 后利用 。

而 显然。我们令 且 那么

令 可以发现计算 大约需要 次矩阵与矩阵的乘法。

参考文献

本页面最近更新：2024/10/9 22:38:42，更新历史
发现错误？想一起完善？ 在 GitHub 上编辑此页！
本页面贡献者：hly1204, CCXXXI, Great-designer, iamtwz, lyccrius, Tiphereth-A, Xeonacid
本页面的全部内容在 CC BY-SA 4.0 和 SATA 协议之条款下提供，附加条款亦可能应用