1. 正交矩阵Q

1.1 矩阵Q的推导

方阵A正交的充要条件是A的行（列）向量组是单位正交向量组. 我们定义正交矩阵Q表示如下：
$$\begin{array}{c}Q=\left[\begin{array}{cccc}{q}_1& q_2& \cdots & q_n\end{array}\right]；q_i^T{q}_j=\{\begin{array}{rl}1& ,i=j\\ 0& ,i\ne j\end{array}\end{array}$$

• 对矩阵Q展开可得：
  $$\begin{array}{c}{Q}^{T}Q=\left[\begin{array}{c}{q}_1^T\\ \\ q_2^T\\ \\ ⋮\\ \\ q_n^T\end{array}\right]\left[\begin{array}{cccc}{q}_1& q_2& \cdots & q_n\end{array}\right]=\left[\begin{array}{cccc}{q}_1^T{q}_1& q_1^T{q}_2& \cdots & q_1^T{q}_n\\ & & & \\ q_2^T{q}_1& q_2^T{q}_2& \cdots & q_2^T{q}_n\\ & & & \\ ⋮& ⋮& ⋮& ⋮\\ & & & \\ q_n^T{q}_1& q_n^T{q}_2& \cdots & q_n^T{q}_n\end{array}\right]=\left[\begin{array}{cccc}1& 0& \cdots & 0\\ & & & \\ 0& 1& \cdots & 0\\ & & & \\ ⋮& ⋮& ⋮& ⋮\\ & & & \\ 0& 0& \cdots & 1\end{array}\right]\end{array}$$

1.2 |Qx|=|x|

首先我们知道对于一个正交矩阵Q来说，满足:$Q^{T}Q=I$

• 两边分别乘以 $x^T,x$
  $$\begin{array}{c}{x}^T{Q}^{T}Qx=x^{T}x\to (Qx{)}^T(Qx)=x^{T}x\to |Qx{|}^2=|x{|}^2\to |Qx|=|x|\end{array}$$
• 小结：也就是说，对于任意向量x来说，我们设计一个正交矩阵Q，在不断地左乘矩阵Q的时候，因为$|Qx|=|x|$的原因，所以矩阵大小值不会变，这点在计算编程中至关重要，这样的话，我们就可以保证矩阵相乘的时候值不会溢出。
• Python 代码：

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# @FileName  :L2Norm.py
# @Time      :2024/10/18 4:44
# @Author    :Jason Zhang
import numpy as np

np.set_printoptions(suppress=True, precision=3)


class L2Norm(object):
    def __init__(self, matrix, vector):
        self.matrix = matrix
        self.L2VectorNorm = 0
        self.L2MatrixNorm = 0
        self.vector = vector
        self.matrixQ = np.zeros_like(self.matrix)
        self.result = np.zeros_like(self.vector)
        self.init_method()

    def init_method(self):
        self.get_MatrixQ()
        self.get_L2VectorNorm()
        self.get_L2MatrixNorm()
        self.get_result()

    def get_MatrixQ(self):
        my_matrix = np.zeros_like(self.matrix)
        my_matrix, _ = np.linalg.qr(self.matrix)
        self.matrixQ = my_matrix
        return my_matrix

    def get_L2VectorNorm(self):
        my_L2VectorNorm = np.linalg.norm(self.vector, ord=2)
        self.L2VectorNorm = my_L2VectorNorm
        return my_L2VectorNorm

    def get_result(self):
        my_result = np.zeros_like(self.vector)
        my_result = self.matrixQ @ self.vector
        my_result = np.linalg.norm(my_result, ord=2)
        self.result = my_result
        return my_result

    def get_L2MatrixNorm(self):
        my_L2MatrixNorm = np.linalg.norm(self.matrixQ, ord=2)
        self.L2MatrixNorm = my_L2MatrixNorm
        return my_L2MatrixNorm

    def __repr__(self):
        return f"************************\n" \
               f"Matrix = \n{self.matrix}\n" \
               f"MatrixQ = \n{self.matrixQ}\n" \
               f"vector = \n{self.vector}\n" \
               f"vectorL2 = \n{self.get_L2VectorNorm()}\n" \
               f"result_|QX| = \n{self.get_result()}\n" \
               f"************************\n"


if __name__ == "__main__":
    run_code = 0
    Matrix = np.arange(9).reshape((3, 3))
    vector = np.array([1, 2, 3])
    MyQX = L2Norm(Matrix, vector)
    print(MyQX)

• 结果：

************************
Matrix = 
[[0 1 2]
 [3 4 5]
 [6 7 8]]
MatrixQ = 
[[ 0.     0.913  0.408]
 [-0.447  0.365 -0.816]
 [-0.894 -0.183  0.408]]
vector = 
[1 2 3]
vectorL2 = 
3.7416573867739413
result_|QX| = 
3.7416573867739413
************************

2. 常见正交矩阵

对称矩阵和正交矩阵的特征向量组为正交单位向量，所以我们为了方便后续的快速计算，我们希望直接找正交矩阵和对称矩阵。

2.1 旋转矩阵

• 我们将向量在保持大小不变的情况下，逆时针旋转 $\theta$, 我们分别看看向量$x_1=[0,1{]}^T,x_2=[1,0{]}^T$变化结果，如图所述：
  $$\begin{array}{c}A=\left[\begin{array}{c}1\\ \\ 0\end{array}\right]\to A_1=\left[\begin{array}{c}\cos \theta \\ \\ \sin \theta \end{array}\right];B=\left[\begin{array}{c}0\\ \\ 1\end{array}\right]\to B_1=\left[\begin{array}{c}-\sin \theta \\ \\ \cos \theta \end{array}\right]\end{array}$$
• 可得旋转矩阵Q表示如下：
  $$\begin{array}{c}Q=\left[\begin{array}{cc}\cos \theta & -\sin \theta \\ & \\ \sin \theta & \cos \theta \end{array}\right]\end{array}$$
  

2.2 镜像矩阵

• 我们将向量在保持大小不变的情况下，沿着$\frac{1}{2}\theta$镜像, 我们分别看看向量$x_1=[0,1{]}^T,x_2=[1,0{]}^T$变化结果，如图所述：
  $$\begin{array}{c}A=\left[\begin{array}{c}1\\ \\ 0\end{array}\right]\to A_1=\left[\begin{array}{c}\cos \theta \\ \\ \sin \theta \end{array}\right];B=\left[\begin{array}{c}0\\ \\ 1\end{array}\right]\to B_1=\left[\begin{array}{c}\sin \theta \\ \\ -\cos \theta \end{array}\right]\end{array}$$
• 可得旋转矩阵Q表示如下：
  $$\begin{array}{c}Reflection=\left[\begin{array}{cc}\cos \theta & \sin \theta \\ & \\ \sin \theta & -\cos \theta \end{array}\right]\end{array}$$
  
• python 代码，旋转矩阵和镜像矩阵

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# @FileName  :Orthogonal_Matrix.py
# @Time      :2024/10/18 5:17
# @Author    :Jason Zhang
import numpy as np

np.set_printoptions(suppress=True, precision=3)


class RotationMatrix(object):
    def __init__(self, theta):
        self.theta = theta * 1.0 / 360.0 * 2 * np.pi
        self.RotationMatrix = np.zeros((2, 2))

    def get_RotationMatrix(self):
        self.RotationMatrix = np.array([[np.cos(self.theta), -np.sin(self.theta)],
                                        [np.sin(self.theta), np.cos(self.theta)]])
        return self.RotationMatrix


class ReflectionMatrix(object):
    def __init__(self, theta):
        self.theta = theta * 1.0 / 360.0 * 2 * np.pi
        self.ReflectionMatrix = np.zeros((2, 2))

    def get_ReflectionMatrix(self):
        self.ReflectionMatrix = np.array([[np.cos(self.theta), np.sin(self.theta)],
                                          [np.sin(self.theta), -np.cos(self.theta)]])

        return self.ReflectionMatrix


if __name__ == "__main__":
    run_code = 0
    my_theta = 45
    MyRotationMatrix = RotationMatrix(my_theta)
    MyNewRoationMatrix = MyRotationMatrix.get_RotationMatrix()
    vector = np.array([1, 0])
    Rotationresult = MyNewRoationMatrix @ vector
    print(f"theta={my_theta}\nMyNewRoationMatrix=\n{MyNewRoationMatrix}")
    print(f"vector={vector}")
    print(f"Rotationresult={Rotationresult}")
    MyReflectionMatrix = ReflectionMatrix(my_theta)
    MyNewReflectionMatrix = MyReflectionMatrix.get_ReflectionMatrix()
    ReflectionResult = MyNewReflectionMatrix @ vector
    print(f"theta={my_theta}\nMyNewReflectionMatrix=\n{MyNewReflectionMatrix}")
    print(f"vector={vector}")
    print(f"ReflectionResult={ReflectionResult}")

• 结果：

theta=45
MyNewRoationMatrix=
[[ 0.707 -0.707]
 [ 0.707  0.707]]
vector=[1 0]
Rotationresult=[0.707 0.707]
theta=45
MyNewReflectionMatrix=
[[ 0.707  0.707]
 [ 0.707 -0.707]]
vector=[1 0]
ReflectionResult=[0.707 0.707]

2.3 Householder矩阵

• 主要链接如下：householder进行矩阵QR分解
  householder变换的作用是将向量x的第一项值为|x|,其他值不变，相当于将x通过镜面反射得到y

• x：为我们输入的向量x

• y：为经过householder变换后向量y

• w: x-y=2w,等腰三角形底边相等

• u：定义跟w平行的单位向量u,|u|=1;
  

• 根据 $u^{T}x$公式可得,|u|=1
  $$\begin{array}{c}{u}^{T}x=|x||u^T|\cos \alpha =|x|\cos \alpha =|w|\end{array}$$

• 向量w,x,y之间的关系如下：
  $$\begin{array}{c}y+2w=x,2w=2|w|u=2u^{T}xu\end{array}$$

• 因为$u^{T}x$为一个数，可以任意放位置
  $$\begin{array}{c}y+2u{u}^{T}x=x\to y=(I-2u{u}^T)x\end{array}$$

• 这里我们可以将H定义为如下：
  $$\begin{array}{c}y=Hx;H=I-2u{u}^T;y=(I-2u{u}^T)x\end{array}$$

• Householder矩阵,对称性，正交性。
  $$\begin{array}{c}H=I-2u{u}^T\to H^T=I-2u{u}^T=H,H^{T}H=I-2u{u}^T-2u{u}^T+4u{u}^{T}u{u}^T=I\end{array}$$

2.4 Hadamard矩阵

哈达玛（Hadamard）矩阵;

• $H_2,H_4$
  $$\begin{array}{c}{H}_2=\left[\begin{array}{cc}1& 1\\ & \\ 1& -1\end{array}\right];H_4=\left[\begin{array}{cc}{H}_2& H_2\\ & \\ H_2& -H_2\end{array}\right]=\left[\begin{array}{cccc}1& 1& 1& 1\\ & & & \\ 1& -1& 1& -1\\ & & & \\ 1& 1& -1& -1\\ & & & \\ 1& -1& -1& 1\\ & & & \end{array}\right]\end{array}$$

2.4 小波矩阵

我们知道小波矩阵也是一个正交矩阵

2.5 傅里叶级数矩阵

我们这里要引入复数i，这里先定义，后面再详细展开
$$\begin{array}{c}{F}_4=\left[\begin{array}{cccc}1& 1& 1& 1\\ & & & \\ 1& i& i^2& i^3\\ & & & \\ 1& i^2& i^4& i^6\\ & & & \\ 1& i^3& i^6& i^9\end{array}\right]\end{array}$$

• 注意，这里第二列和第四列之间正交需要取共轭复数，具体如下：
  $$\begin{array}{c}{f}_1=\left[\begin{array}{c}1\\ \\ i\\ \\ i^2\\ \\ i^3\end{array}\right]=\left[\begin{array}{c}1\\ \\ i\\ \\ -1\\ \\ -i\end{array}\right]\to f_1^H=\left[\begin{array}{cccc}1& -i& -1& i\end{array}\right]\end{array}$$
  $$\begin{array}{c}{f}_4=\left[\begin{array}{c}1\\ \\ i^3\\ \\ i^6\\ \\ i^9\end{array}\right]=\left[\begin{array}{c}1\\ \\ -i\\ \\ 1\\ \\ -i\end{array}\right]\to f_1^H{f}_4=\left[\begin{array}{cccc}1& -i& -1& i\end{array}\right]\left[\begin{array}{c}1\\ \\ -i\\ \\ 1\\ \\ -i\end{array}\right]=1+i^2-1-i^2=0\end{array}$$
• 同理，可以逐个计算得到$F_4$的列向量相互正交。

3. python 代码

import numpy as np
from scipy.linalg import hadamard

np.set_printoptions(suppress=True, precision=3)


class FourierMatrix(object):
    def __init__(self, N):
        self.N = N
        self.result = np.zeros((self.N, self.N))
        self.get_result()

    def get_result(self):
        self.result = np.fft.fft(np.eye(self.N))
        return self.result


if __name__ == "__main__":
    my_code = 0
    H2 = hadamard(2)
    H4 = hadamard(4)
    print(f"H2=\n{H2}")
    print(f"H4=\n{H4}")
    N = 4
    F4 = FourierMatrix(N)
    print(f"F4=\n{F4.result}")

• 结果：

H2=
[[ 1  1]
 [ 1 -1]]
H4=
[[ 1  1  1  1]
 [ 1 -1  1 -1]
 [ 1  1 -1 -1]
 [ 1 -1 -1  1]]
F4=
[[ 1.+0.j  1.+0.j  1.+0.j  1.+0.j]
 [ 1.+0.j  0.-1.j -1.+0.j  0.+1.j]
 [ 1.+0.j -1.+0.j  1.+0.j -1.+0.j]
 [ 1.+0.j  0.+1.j -1.+0.j  0.-1.j]]