算法分析与设计学习（3）——代数学

代数学

矩阵

• 基本概念

  • 矩阵定义

    • 一个 $n\times m$的矩阵是 $n$ 行 $m$​ 列的矩形阵列，一般由数组成

    • 矩阵 $\mathbf{A}$ 的第 $i$ 行，第 $j$ 列，通常记为 ${\mathbf{A}}_{ij}$​

    • 单位矩阵：对角线上为 $1$，其他都为 $0$​ 的矩阵。
      $$I\stackrel{def}{=}\left(\begin{array}{ccc}1& \dots & 0\\ ⋮& \ddots & ⋮\\ 0& \dots & 1\end{array}\right)$$

  • 矩阵加法

    • 矩阵的加法定义为每行每列的元素分别相加(减)，即
      $$I=A\pm B=\left(\begin{array}{ccc}{A}_{1,1}\pm B_{1,1}& \dots & A_{1,m}\pm B_{1,m}\\ ⋮& \ddots & ⋮\\ A_{n,1}\pm B_{n,1}& \dots & A_{n,m}\pm B_{n,m}\end{array}\right)$$

  • 矩阵乘法

    • 当一个矩阵的列数等于另一个的行数时，可定义该两个矩阵的乘积。

    • 设 $A$ 是 $n\times m$ 的矩阵，$B$ 是 $m\times p$ 的矩阵，他们的乘积 $C$ 是一个 $n\times p$​ 的矩阵。
      $$C_{i,j}=\sum _{k=1}^m{A}_{i,k}\times B_{k,j}$$

  • 矩阵的幂
    $$\begin{array}{rl}& A^0=I\\ & A^n=A^{N-1}\times A(n>0)\end{array}$$

  • 矩阵的转置

    • $n\times m$ 的矩阵 $A$ 的转置 $A^T$ 是个 $m\times n$ 的矩阵，可以通过 $A$ 交换行列得到，即 $A_{i,j}^T=A_{j,i}$

  • 矩阵的逆

    • 只有 $n\times n$ 的矩阵可能存在逆，矩阵 $A$ 的逆 $B$ 满足 $A\times B=B\times A=I$
    • 如果逆存在，则 $B$ 是唯一的，一般记做 $A^{-1}$ 。

• 性质

  • 矩阵乘法满足分配率、结合律，不一定满足交换率。
  • 矩阵加法满足交换率和结合律。

• 算法

  • 矩阵满足结合律，所以在求矩阵的幂的时候可以使用快速幂加速

• 用途

  • 递推可以表示成向量乘以矩阵，然后用快速幂优化

行列式

• 基本概念

  • 行列式是一个定义域为 $n\times n$ 的矩阵，值域为一个标量的函数，通常记为 $\det (A)$​ 或者 $|A|$。

  • 行列式也可以表示为n维广义欧几里得空间中的有向体积。

  • 一个 $n\times n$​ 的行列式定义为
    $$\det (A)\stackrel{def}{=}\sum _{\sigma \in S_n}(-1{)}^{n(\sigma )}\prod _{i=1}^n{a}_{i,\sigma (i)}$$

    • 其中 $S_n$ 表示集合 { 1 , 2 , … , n } \{1,2,…,n\} {1,2,…,n} 上的置换的全体
    • $n(\sigma )$ 是对于一个置换中逆序对的个数，逆序对的定义为满足 $1\le i<j\le n$ 且 $\sigma (i)>\sigma (j)$ 的 $(i,j)$

• 性质

  • 若矩阵中一行或一列全为 $0$，那么该矩阵行列式为 $0$。

  • 若矩阵中某一行有公因子 $k$，那么可以提出 $k$​
    $$D=\left|\begin{array}{ccc}k{a}_{1,1}& \cdots & k{a}_{1,n}\\ ⋮& \ddots & ⋮\\ a_{n,1}& \cdots & a_{n,n}\end{array}\right|=k\left|\begin{array}{ccc}{a}_{1,1}& \cdots & k{a}_{1,n}\\ ⋮& \ddots & ⋮\\ a_{n,1}& \cdots & a_{n,n}\end{array}\right|=k{D}_1$$

  • 在矩阵中某一行可拆分成两个数和，那么该行列式可拆分成两个行列式相加。

  $$D=\left|\begin{array}{ccc}{a}_{1,1}+b_{1,1}& \cdots & a_{1,n}+b_{1,1}\\ ⋮& \ddots & ⋮\\ a_{n,1}& \cdots & a_{n,n}\end{array}\right|=\left|\begin{array}{ccc}{a}_{1,1}& \cdots & a_{1,n}\\ ⋮& \ddots & ⋮\\ a_{n,1}& \cdots & a_{n,n}\end{array}\right|+\left|\begin{array}{ccc}{b}_{1,1}& \cdots & b_{1,n}\\ ⋮& \ddots & ⋮\\ a_{n,1}& \cdots & a_{n,n}\end{array}\right|$$

  • 交换矩阵的两行，行列式取反。

  $$D=\left|\begin{array}{ccc}{a}_{1,1}& \cdots & a_{1,n}\\ ⋮& \ddots & ⋮\\ a_{n,1}& \cdots & a_{n,n}\end{array}\right|=-\left|\begin{array}{ccc}{a}_{n,1}& \cdots & a_{n,n}\\ ⋮& \ddots & ⋮\\ a_{1,1}& \cdots & a_{1,n}\end{array}\right|$$

  • 将一行的k倍加到另一行上，行列式不变。

  $$D=\left|\begin{array}{ccc}{a}_{1,1}& \cdots & a_{1,n}\\ ⋮& \ddots & ⋮\\ a_{n,1}& \cdots & a_{n,n}\end{array}\right|=\left|\begin{array}{ccc}{a}_{1,1}+k{a}_{n,1}& \cdots & a_{1,1}+k{a}_{n,n}\\ ⋮& \ddots & ⋮\\ a_{n,1}& \cdots & a_{n,n}\end{array}\right|$$

  • 转置，行列式不变，$|A|=|A^T|$

  • 当矩阵是上三角矩阵或者是下三角矩阵时，行列式的值等于对角线的乘积

• 算法

  • 一个常见的求解矩阵行列式的算法是对矩阵做行变换，将矩阵转化成为上三角矩阵，再得出行列式的值。

解线性方程组

• 基本概念

  • 解线性方程组即求解方程组
    $$\{\begin{array}{c}{a}_{1,1}{x}_1+a_{1,2}{x}_2+\cdots +a_{1,n}{x}_n=b_1\\ ⋮\\ a_{m,1}{x}_1+a_{m,2}{x}_2+\cdots +a_{m,n}{x}_n=b_m\end{array}$$

  • 可以表示为 $\mathbf{Ax}=\mathbf{b}$，其中 $\mathbf{A}$ 是 $m\times n$ 的矩阵， $\mathbf{x}$ 是 $n$ 维列向量， $\mathbf{b}$ 是 $m$​ 维列向量，即
    $$\left(\begin{array}{ccc}{a}_{1,1}& \dots & a_{1,n}\\ ⋮& \ddots & ⋮\\ a_{m,1}& \dots & a_{m,n}\end{array}\right)\left(\begin{array}{c}{x}_1\\ ⋮\\ x_n\end{array}\right)=\left(\begin{array}{c}{b}_1\\ ⋮\\ b_m\end{array}\right)$$

• 算法

  • 高斯消元

    • 矩阵的初等变换：

      • 行初等变换：

        • 互换矩阵的两行。
        • 用非零的常数乘矩阵的某一行。
        • 某行的k倍加到另一行。

      • 列初等变换：

        • 互换矩阵的两列。
        • 用非零的常数乘矩阵的某一列。
        • 某行的k倍加到另一列。

    • 用增广矩阵进行高斯消元
      $$\left(\begin{array}{cccc}{a}_{1,1}& \dots & a_{1,n}& b_1\\ ⋮& \ddots & ⋮& ⋮\\ a_{m,1}& \dots & a_{m,n}& b_m\end{array}\right)$$

      • 只需要利用行初等变换，将矩阵消成上三角矩阵，即可简单地计算出线性方程的解。

      $$如:\left(\begin{array}{cccc}1& 1& 1& 1\\ 1& 1& 2& 2\\ 1& 2& 3& 6\end{array}\right)=\left(\begin{array}{cccc}1& 1& 1& 1\\ 0& 0& 1& 1\\ 1& 2& 3& 6\end{array}\right)=\left(\begin{array}{cccc}1& 1& 1& 1\\ 0& 0& 1& 1\\ 0& 1& 2& 5\end{array}\right)\left(\begin{array}{cccc}1& 1& 1& 1\\ 0& 1& 2& 5\\ 0& 0& 1& 1\end{array}\right)\to \mathbf{X}=\left(\begin{array}{c}-3\\ 3\\ 1\end{array}\right)$$

  • 克莱姆法则

    • 当 $\mathbf{A}$ 为 $n\times n$​​ 的矩阵时，可使用克莱姆法则求解，方程的解为：
      $$x_i=\frac{D_i}{D}$$

    • 其中 $D$ 是 $\mathbf{A}$ 的行列式$D=|\mathbf{A}|$，$D_i$ 是将 $\mathbf{A}$ 中第 $i$ 列替换为 $\mathbf{b}$ 后得到的矩阵的行列式。

• 用途

  • 求解可逆矩阵的逆矩阵
    • 对于一个 $n\times n$ 的非奇异矩阵，在矩阵右侧补上一个 $n\times n$ 的单位矩阵。
    • 对于这个 $n\times (2n)$ 的矩阵通过高斯消元，使得这个矩阵左侧变为一个 $n\times n$ 的单位矩阵。
    • 右侧那个 $n\times n$​ 的矩阵即为原矩阵的逆矩阵。
  • 同模方程组也可使用高斯消元，在除法时用乘逆元代替。
    • 由于只有在模为素数情况下，非零数的逆元才唯一，所以，素数模才能保证有唯一解。
  • 求解行列式的值。
    • 通过高斯消元，将矩阵消成上三角。行列式的值即为对角线上所有数的乘积。

• 扩展

  • 使用绝对值较大的主元进行消元，能达到比较好的效果
  • 可以使用辗转相除代替直接除法，这样可以保证系数为整数，保证精度。

多项式

• 基本概念

  • 多项式定义

    • 给定一个数域 $R$，变量 $x$​，一元多项式的形式（$a_i\in R$ 且 $a_n\ne 0$）

    $$f(x)=\sum _{i=0}^n{a}_i{x}^i$$

  • 多项式性质

    • 多项式的项数等于 $a_i$ 中不为 $0$ 的个数。
    • 多项式的次数等于 $n$​。
    • 多项式中次数最高的项成为首项
      • 首项的系数等于一，即 $a_n=1$​ 的多项式称做首一多项式。

  • 多项式运算

    • 多项式加(减)法：对应次数系数相加(减)。
      $$f(x)\pm g(x)=\sum _{i=0}^n{a}_i{x}^i\pm \sum _{i=0}^n{b}_i{x}^i=\sum _{i=0}^n(a_i\pm b_i)x^i$$

    • 多项式乘法：两个多项式的每一项都相乘
      $$f(x)\cdot g(x)=\sum _{i=0}^n{a}_i{x}^i\cdot \sum _{i=0}^n{b}_i{x}^i=\sum _{i=0}^n\sum _{j=0}^n(a_i{b}_j)x^{i+j}$$

    • 多项式除法与整数除法类似

      • 多项式 $g(x)$ 整除 $f(x)$ ,当存在多项式 $h(x)$,$f(x)=g(x)h(x)$, $g(x)$ 称做 $f(x)$ 的因式。同整数的因数分解类似，多项式也可以进行因式分解。
      • 如果多项式 $d(x)$ 是 $f(x)$ 的因式也是 $g(x)$ 的因式，那么称 $d(x)$ 是 $f(x)$ 和 $g(x)$ 的公因式。
      • 多项式 $d(x)$ 称为 $f(x)$ 和 $g(x)$ 的最大公因式如果它满足， $d(x)$ 是 $f(x)$ 和 $g(x)$ 的公因式，且 $f(x)$ 和 $g(x)$ 的所有公因式都是 $d(x)$ 的因式，记作 $gcd(f(x),g(x))$。

• 性质

  • $(1+x{)}^n={\sum }_{i=0}^n{C}_n^i{x}^i$，其中 $C_n^i$ 为组合数
  • $n$ 个点可以唯一确定一个 $n$ 次多项式。
  • 一个 $n$ 次多项式有 $n$ 个复数根。

• • 代码实现

    //多项式中的项数定义
    class Term implements Comparable<Term>
    {
        int degree;
        double coefficient;
        Term(double item_co,int item_de)
        {
            this.degree=item_de;
            this.coefficient=item_co;
        }
        Term()
        {
            this.degree=0;
            this.coefficient=0;
        }
        @Override  
        public int compareTo(Term other) 
        {  
            // 按照degree的升序排序   
            return other.degree - this.degree;  
        } 
    }
    
    //多项式定义
    public class Polynomial
    {
        //通过优先队列保证次数的有序
        PriorityQueue<Term> polynomial;
    
        public Polynomial() 
        {  
            polynomial = new PriorityQueue<>();  
        } 
        
        public Polynomial(Polynomial a) 
        {  
            polynomial = new PriorityQueue<>();
            for(Term term: a.polynomial)
            {
                polynomial.add(term);
            }
        }
    	//通过数组初始化
        public Polynomial(double[] coefficients, int[] degrees) 
        {  
            if (coefficients.length != degrees.length) 
            {  
                throw new IllegalArgumentException("Error Arguments");  
            }  
      
            polynomial = new PriorityQueue<>(); 
            for (int i = 0; i < coefficients.length; i++) 
            {  
                polynomial.add(new Term(coefficients[i], degrees[i]));   
            }  
        } 
        public int getDegree()
        {
            if(!polynomial.isEmpty())
                return polynomial.peek().getDegree();
            else
                return -1;
        }
    }
    
    public class polyCalculation 
    {
        Polynomial add(Polynomial p, Polynomial q)
        {
            Polynomial result = new Polynomial();   
            Polynomial a= new Polynomial(p);
            Polynomial b= new Polynomial(q);
            Term curA=null,curB=null;
            while (!a.polynomial.isEmpty() || !b.polynomial.isEmpty()) 
            {  
                if(a.getDegree()==b.getDegree())
                {
                    curA=a.polynomial.poll();
                    curB=b.polynomial.poll();
                    double res_coe=curA.getcoefficient()+curB.getcoefficient();
                    result.polynomial.add(new Term(res_coe,curA.getDegree()));
                }
                else if(a.getDegree()>b.getDegree())
                {
                    curA=a.polynomial.poll();
                    result.polynomial.add(curA);
                }
                else
                {
                    curB=b.polynomial.poll();
                    result.polynomial.add(curB);
                }
            }
            return result;
        }
    
        Polynomial sub(Polynomial p, Polynomial q)
        {
            Polynomial result = new Polynomial();  
            Polynomial a= new Polynomial(p);
            Polynomial b= new Polynomial(q);  
            Term currentA=null,currentB=null;
            while (!a.polynomial.isEmpty() || !b.polynomial.isEmpty()) 
            {  
                if(a.getDegree()==b.getDegree())
                {
                    currentA=a.polynomial.poll();
                    currentB=b.polynomial.poll();
                    double res_coe=currentA.getcoefficient()-currentB.getcoefficient();
                    result.polynomial.add(new Term(res_coe,currentA.getDegree()));
                }
                else if(a.getDegree()>b.getDegree())
                {
                    currentA=a.polynomial.poll();
                    result.polynomial.add(currentA);
                }
                else
                {
                    currentB=b.polynomial.poll();
                    double res_coe=-currentB.getcoefficient();
                    result.polynomial.add(new Term(res_coe,currentB.getDegree()));
                }
            }
            return result;
        }
    
        //模拟乘法
        Polynomial product_term(Polynomial p, Term q)
        {
            Polynomial result = new Polynomial();  
            Polynomial a= new Polynomial(p);
            while(!a.polynomial.isEmpty())
            {
                Term tmp=a.polynomial.poll();
                double tmp_coe=tmp.getcoefficient()*q.getcoefficient();
                int tmp_degree=tmp.getDegree()+q.getDegree();
                result.polynomial.add(new Term(tmp_coe,tmp_degree));
            }
            return result;
        }
    
        Polynomial product(Polynomial p, Polynomial q)
        {
            Polynomial result = new Polynomial();  
            Polynomial a= new Polynomial(p);
            Polynomial b= new Polynomial(q);
            while(!a.polynomial.isEmpty())
            {
                Term term=a.polynomial.poll();
                Polynomial tmp = product_term(b,term);
                result=add(result,tmp);
            }
            return result;
        }
    
        Polynomial quick_pow(Polynomial p, int time)
        {
            Polynomial result = new Polynomial();  
            Polynomial a= new Polynomial(p);
            if(time==0)
            {
                result.polynomial.add(new Term(1,0));
                return result;
            }
            else if(time==1)
            {
                return a;
            }
            Polynomial temp = quick_pow(p, time / 2);
            if (time % 2 == 1) 
                return product(product(temp, temp),a); 
            else
                return product(temp, temp); 
        }
        
        Polynomial[] divide(Polynomial p, Polynomial q)
        {
            //返回商和余数
            Polynomial quotient = new Polynomial();
            Polynomial remainder = new Polynomial();
    
            Polynomial a= new Polynomial(p);
            Polynomial b= new Polynomial(q);
            
            if(q.polynomial.isEmpty()) //如果除数为0
                return null;
            else if(q.getDegree()>p.getDegree()) //如果除数次数更大
                return new Polynomial[]{new Polynomial(),b};
            
            //做一次模拟多项式除法
            Term cur_A=null,cur_B=null,tmp=null;
            Polynomial storage, tail;
            cur_A=a.polynomial.poll();
            cur_B=b.polynomial.peek();
            double cal_coe=cur_A.coefficient / cur_B.coefficient;
            int cal_degree=cur_A.degree - cur_B.degree;
            Term cal_term = new Term(cal_coe, cal_degree);
            //得到商的第一个项
            quotient.polynomial.add(cal_term);
            
            //计算剩下的项
            Polynomial cal_polynomial=product_term(q,cal_term);
            tmp=cal_polynomial.polynomial.poll();
            storage=sub(a,cal_polynomial);
    
            //递归进行计算
            Polynomial[] tmp_result=divide(storage,b);
            tail = tmp_result[0];
            while(tail!=null&&!tail.polynomial.isEmpty())
            {
                tmp=tail.polynomial.poll();
                quotient.polynomial.add(tmp);
            }
            remainder=storage;
            //返回结果
            return new Polynomial[]{quotient, remainder};
        }
    }
    

• 算法

  • 用牛顿迭代法求解方程的根。

复数

• 基本概念

  • 复数是由实部和虚部组成的数，通常有两种表示方式

    • $z=a+bi$，$a$ 和 $b$ 都是实数，$i$ 是虚单位根，满足$i^2=-1$，$|z|\stackrel{def}{=}\sqrt{x2+y2}$ 表示复数的模长
    • $z=R{e}^{i\phi }=R(\cos (\phi )+i\sin (\phi ))$，其中 $R=|z|$，$e^{i\phi }=\cos (\phi )+i\sin (\phi )$

  • 两复数相等当且仅当它们的实部与虚部分别相等。

  • 复数四则运算

    • 加法：$(a+bi)+(c+di)=(a+c)+(b+d)i$

    • 减法：$(a+bi)-(c+di)=(a-c)+(b-d)i$

    • 乘法

      • $(a+bi)\cdot (c+di)=(ac-bd)+(ad+bc)i$
      • $R_1(\cos (\phi 1)+i\sin (\phi 1))\cdot R_2(\cos (\phi 2)+i\sin (\phi 2))=R_1\times R_2(\cos (\phi 1+\phi 2)+i\sin (\phi 1+\phi 2))$

    • 除法
      $$\frac{(a+bi)}{(c+di)}=\frac{(a+bi)(c-di)}{(c+di)(c-di)}=\frac{(ac+bd)+(bc-ad)i}{c^2+d^2}=\left(\frac{ac+bd}{c^2+d^2}\right)+\left(\frac{bc-ad}{c^2+d^2}\right)i$$

  • 复数旋转

    • 一个向量 $(x,y)$ 旋转 $\phi$，可以视为两个复数， $x+yi$ 乘以 $cos(\phi )+sin(\phi )i$​，等于
      $$xcos(\phi )-ysin(\phi )+(ycos(\phi )+xsin(\phi ))i$$

群

• 群

  • 在数学中，群是一种代数结构，由一个集合 $S$ 与一个二元运算 $\cdot$ 组成（由集合和定义在这个集合上的运算组成）
  • 要成为群，还需要满足一些条件
    • 封闭性，即 $\forall a,b\in S,a\cdot b\in S$
    • 结合律，即 $\forall a,b,c\in S,(a\cdot b)\cdot c=a\cdot (b\cdot c)$
    • 单位元，即有一个元素 $e$，$\forall a\in S,e\cdot a=a\cdot e=a$ )（在群 $\mathrm{G}$ 中常用 $1_{\mathrm{G}}$ 或 $1$​​ 表示单位元）。
    • 逆元，即 $\forall a\in S$，$\exists b\in S,a\cdot b=b\cdot a=e$，记 $b=a^{-1}$
    • 可以定义元素 $a$ 的幂为: $a^0=e$，$a^n=a^{n-1}\cdot a$，$a^{-n}={\left(a^n\right)}^{-1}$​。
  • 特殊的群
    • 整数加法群 $(\mathbb{Z},+,0)$, 是由整数 $\mathbb{Z} $ 和整数加法运算 $+$ 组成。
      • 其单位元 $0$ ;
      • 封闭性: $\forall a,b\in \mathbb{Z},a+b\in \mathbb{Z}$ ;
      • 结合律: $\forall a,b,c\in \mathbb{Z},(a+b)+c=a+(b+c)$;
      • 逆元: $\forall a\in \mathbb{Z},a^{-1}=-a$ 。
    • 群 $\left({\mathbb{R}}^{\ast },\times ,1\right)$ , 它是由非零实数 R ∗ = R \ { 0 } \mathbb{R}^{*}=\mathbb{R} \backslash\{0\} R∗=R\{0} 和实数乘法 $\times $ 组成。
      • 其单位元 1 ;
      • 封闭性: $\forall a,b\in {\mathbb{R}}^{\ast },a\times b\in {\mathbb{R}}^{\ast }$ ;
      • 结合律 : $\forall a,b,c\in {\mathbb{R}}^{\ast },(a\times b)\times c=a\times (b\times c)$ ;
      • 逆元 : $\forall a\in {\mathbb{R}}^{\ast },a^{-1}=1/a$ 。

• 子群

  • 设 $G$ 是群，$\varphi \ne H\subseteq G$，若 $H$ 具封闭性、单位元、逆元，称 $H$ 是 $G$ 的一个子群，记号 $H\le G$。
  • 若 $H$满足以下条件，则 $H$ 是 $G$ 的一个子群
    • $1_G=1_H\in H$;
    • $\forall a,b\in H,a\cdot b\in H$;
    • $\forall a\in H,a^{-1}\in H$。
  • 作为群公理之一的结合律，因为 $H$ 继承了 $G$ 的运算，所以自然成立，因此，子群也是群。

• 元素的阶

  • 在群 $G$ 中，定义元素 $g$ 的阶 $o(g)$，为使 $g^n=1_G$ 成立的最小自然数 $n$
    • 如果此自然数不存在，则记作 $o(g)=\infty$。

• 循环群

  • 设 $g$ 是群 $G$ 中一个取定的元素，若群 $G$ 的任意一个元素 $a$ 可以写成 $a=g^n,n\in Z$ 的形式，则称 $G$ 循环群称 $g$ 为群 $G$ 的一个生成元，可写成 $G=<g>$。

• 交换群

  • 具有交换性的群称为交换群。

    • 交换性：$\forall a,b\in G,ab=ba$。

  • 一般线性群 $GL(n)$ 由所有 $n\times n$ 的可逆矩阵和矩阵乘法组成，它不是交换群，

• 置换群

  • 设 $A$ 是一个非空集合，$A^A$ 是 $A$ 到 $A$ 上的所有的置换的集合，在 $A^A$ 上定义二元运算为映射的复合。

  • 记 $S$ 为 $A$ 上所有可逆映射的集合，则 $S$​ 关于映射的复合构成群。

  • 当 $A$ 是有限集合时，可设 A = { 1 , 2 , … , n } A=\{1,2,…,n\} A={1,2,…,n}，则 $A$ 上的可逆变换可表示
    $$f=\left(\begin{array}{ccccc}1& 2& \dots & n-1& n\\ i_1& i_2& \dots & i_{n-1}& i_n\end{array}\right)$$
    其中 $i_1{i}_2\dots i_n$ 为一个 $n-$排列，$i_j$ 表示将 $j$ 位置上的元素换到 $j$ 位置。这样一个变换称作 $n$ 次置换，形成的群称作 $n$ 次置换群。所有 $n$ 次置换形成的群记做 $S_n$。

  • $(i_1{i}_2\dots i_n)$ 满足 $f(i_1)=i_2,f(i_2)=i_3,\dots ,f(i_{k-1})=i_k,f(i_k)=i_1$，称 $(i_1{i}_2\dots i_n)$ 为一个循环节。显然，一个置换可以拆成若干个循环节，所以可以将置换用循环节表示。

• 群作用

  • 设 $G$ 为群，$S$ 为集合，考虑一个映射 $\circ$​
    $$\begin{gathered} G\times S\to S \\ (g,x)\mapsto g\circ x \end{gathered}$$

  • 若此映射满足

    • $1_G\circ x=x,\forall x\in S$
    • $(gh)\circ =g\circ (h\circ x),\forall x\in S,\forall g,h\in G$​
    • 称映射 $\circ$ 是 $G$ 在 $S$​ 上的一个群作用。

  • 例子：$S_3$ 在 T = { a , b , c } T=\{a,b,c\} T={a,b,c} 上有群作用 $\circ$：$S_3\times T\to T,(f,t)\mapsto f\circ t=f(t)$，$f=\left(\begin{array}{ccc}1& 2& 3\\ 2& 3& 1\end{array}\right)$，可得 $f\circ a=f(a)=b,f\circ b=f(b)=c,f\circ c=f(c)=a$

• 轨道

  • 设 $\circ$ 是 $G$ 在 $S$ 上的一个群作用，对于一个元素 $x\in S$，集合 O x = { g ∘ x ∣ g ∈ G } O_x=\{g \circ x|g∈G\} Ox​={g∘x∣g∈G} 称为 $x$ 所在的轨道，也记为 $G\circ x$ 。

  • 可以从轨道诱导出集合上的一个等价关系。若已知集合 $S$ 和作用在 $S$ 上的群 $G$ ,定义集合 $S$ 上的二元关系 ~ ，$\forall x,y\in S$，$x$~$y$如果 $O_x=O_y$。

• 稳定子

  • 设 $\circ $ 是 $G$ 在 $S$ 上的一个群作用，对于一个元素 $x\in S$，集合 S t a b x = { g ∈ G ∣ g ∘ x = x } \mathrm{Stab}_x=\{g∈G|g\circ x=x\} Stabx​={g∈G∣g∘x=x} 称为 $x$ 在 $G$ 中的稳定子。不难发现，${\mathrm{Stab}}_x$为 $G$ 的一个子群。

  • 一个元素 $x$ 的稳定子 ${\mathrm{Stab}}_x$ 与轨道 $O_x$ 满足
    $$\mathrm{card}(O_x)=\frac{\mathrm{card}(G)}{\mathrm{card}({\mathrm{Stab}}_x)}$$