行列式（英語：Determinant），记作
  
    
      
        det
        (
        A
        )
      
    
    {\displaystyle \det(A)}
  
或
  
    
      
        
          |
        
        A
        
          |
        
      
    
    {\displaystyle |A|}
  
，是一个在方块矩阵上计算得到的标量。行列式可以看作是有向面积或体积的概念在一般的欧几里得空间中的推广。或者说，在欧几里得空间中，行列式描述的是一个线性变换对“体积”所造成的影响。无论是在线性代数、多项式理论，还是在微积分学中（比如说换元积分法中），行列式作为基本的数学工具，都有着重要的应用。
行列式概念最早出现在解线性方程组的过程中。十七世纪晚期，关孝和与莱布尼茨的著作中已经使用行列式来确定线性方程组解的个数以及形式。十八世纪开始，行列式开始作为独立的数学概念被研究。十九世纪以后，行列式理论进一步得到发展和完善。矩阵概念的引入使得更多有关行列式的性质被发现，行列式在许多领域都逐渐显现出重要的意义和作用，其定义也被推广到诸如线性自同态和向量组等结构上。
行列式的特性可以被概括为一个交替多线性形式，这个本质使得行列式在欧几里德空间中可以成为描述“体积”的函数。


记法 矩陣
  
    
      
        A
      
    
    {\displaystyle A}
  
的行列式記作
  
    
      
        det
        (
        A
        )
      
    
    {\displaystyle \det(A)}
  
。行列式經常使用竖直線記法（例如：克萊姆法則和子式）。例如，对于一個矩陣：

  
    
      
        A
        =
        
          
            [
            
              
                
                  a
                
                
                  b
                
                
                  c
                
              
              
                
                  d
                
                
                  e
                
                
                  f
                
              
              
                
                  g
                
                
                  h
                
                
                  i
                
              
            
            ]
          
        
      
    
    {\displaystyle A={\begin{bmatrix}a&b&c\\d&e&f\\g&h&i\end{bmatrix}}}
  

  
    
      
        det
        (
        A
        )
      
    
    {\displaystyle \det(A)}
  
也记作
  
    
      
        
          |
        
        A
        
          |
        
      
    
    {\displaystyle |A|}
  
，或以細長的垂直線取代矩陣的方括號，明確的寫为：

  
    
      
        det
        (
        A
        )
        =
        
          |
        
        A
        
          |
        
        =
        
          
            |
            
              
                
                  a
                
                
                  b
                
                
                  c
                
              
              
                
                  d
                
                
                  e
                
                
                  f
                
              
              
                
                  g
                
                
                  h
                
                
                  i
                
              
            
            |
          
        
      
    
    {\displaystyle \det(A)=|A|={\begin{vmatrix}a&b&c\\d&e&f\\g&h&i\end{vmatrix}}}
  

当这个记法用于絕對值时，其作用对象为数，矩陣的絕對值是无定義的。矩陣範數通常以雙垂直線來表示（如：
  
    
      
        ‖
        ⋅
        ‖
      
    
    {\displaystyle \|\cdot \|}
  
），且可以使用下標。故不会与二者造成混淆。


直观定义 一个
  
    
      
        n
      
    
    {\displaystyle n}
  
阶方块矩阵
  
    
      
        A
      
    
    {\displaystyle A}
  
的行列式可直观地定义如下：

  
    
      
        det
        (
        A
        )
        =
        
          ∑
          
            σ
            ∈
            
              S
              
                n
              
            
          
        
        sgn
        ⁡
        (
        σ
        )
        
          ∏
          
            i
            =
            1
          
          
            n
          
        
        
          a
          
            i
            ,
            σ
            (
            i
            )
          
        
      
    
    {\displaystyle \det(A)=\sum _{\sigma \in S_{n}}\operatorname {sgn}(\sigma )\prod _{i=1}^{n}a_{i,\sigma (i)}}
  

其中，
  
    
      
        
          S
          
            n
          
        
      
    
    {\displaystyle S_{n}}
  
是集合
  
    
      
        
          {
          
            1
            ,
            2
            ,
            .
            .
            .
            ,
            n
          
          }
        
      
    
    {\displaystyle \left\{1,2,...,n\right\}}
  
上置换的全体，即集合
  
    
      
        
          {
          
            1
            ,
            2
            ,
            .
            .
            .
            ,
            n
          
          }
        
      
    
    {\displaystyle \left\{1,2,...,n\right\}}
  
到自身上的一一映射（双射）的全体；

  
    
      
        
          ∑
          
            σ
            ∈
            
              S
              
                n
              
            
          
        
      
    
    {\displaystyle \sum _{\sigma \in S_{n}}}
  
表示对
  
    
      
        
          S
          
            n
          
        
      
    
    {\displaystyle S_{n}}
  
全部元素的求和，即对于每个
  
    
      
        σ
        ∈
        
          S
          
            n
          
        
      
    
    {\displaystyle \sigma \in S_{n}}
  
，
  
    
      
        sgn
        ⁡
        (
        σ
        )
        
          ∏
          
            i
            =
            1
          
          
            n
          
        
        
          a
          
            i
            ,
            σ
            (
            i
            )
          
        
      
    
    {\displaystyle \operatorname {sgn}(\sigma )\prod _{i=1}^{n}a_{i,\sigma (i)}}
  
在加法算式中出现一次；对每一个满足
  
    
      
        1
        ≤
        i
        ,
        j
        ≤
        n
      
    
    {\displaystyle 1\leq i,j\leq n}
  
的数对
  
    
      
        
          (
          
            i
            ,
            j
          
          )
        
      
    
    {\displaystyle \left(i,j\right)}
  
，
  
    
      
        
          a
          
            i
            ,
            j
          
        
      
    
    {\displaystyle a_{i,j}}
  
是矩阵
  
    
      
        A
      
    
    {\displaystyle A}
  
的第
  
    
      
        i
      
    
    {\displaystyle i}
  
行第
  
    
      
        j
      
    
    {\displaystyle j}
  
列的元素。

  
    
      
        sgn
        ⁡
        (
        σ
        )
      
    
    {\displaystyle \operatorname {sgn}(\sigma )}
  
表示置换
  
    
      
        σ
        ∈
        
          S
          
            n
          
        
      
    
    {\displaystyle \sigma \in S_{n}}
  
的符号差，具体地说，满足
  
    
      
        1
        ≤
        i
        ≤
        j
        ≤
        n
      
    
    {\displaystyle 1\leq i\leq j\leq n}
  
但
  
    
      
        σ
        (
        i
        )
        >
        σ
        (
        j
        )
      
    
    {\displaystyle \sigma (i)>\sigma (j)}
  
的有序数对
  
    
      
        
          (
          
            i
            ,
            j
          
          )
        
      
    
    {\displaystyle \left(i,j\right)}
  
称为
  
    
      
        σ
      
    
    {\displaystyle \sigma }
  
的一个逆序。
如果
  
    
      
        σ
      
    
    {\displaystyle \sigma }
  
的逆序共有偶数个，则
  
    
      
        sgn
        ⁡
        σ
        =
        1
      
    
    {\displaystyle \operatorname {sgn} \sigma =1}
  
，如果共有奇数个，则
  
    
      
        sgn
        ⁡
        σ
        =
        −
        1
      
    
    {\displaystyle \operatorname {sgn} \sigma =-1}
  
。
举例来说，对于3元置换
  
    
      
        σ
        =
        
          (
          
            2
            ,
            3
            ,
            1
          
          )
        
      
    
    {\displaystyle \sigma =\left(2,3,1\right)}
  
（即是说
  
    
      
        σ
        (
        1
        )
        =
        2
      
    
    {\displaystyle \sigma (1)=2}
  
，
  
    
      
        σ
        (
        2
        )
        =
        3
      
    
    {\displaystyle \sigma (2)=3}
  
，
  
    
      
        σ
        (
        3
        )
        =
        1
      
    
    {\displaystyle \sigma (3)=1}
  
）而言，由于1在2后，1在3后，所以共有2个逆序（偶数个），因此
  
    
      
        sgn
        ⁡
        (
        σ
        )
        =
        1
      
    
    {\displaystyle \operatorname {sgn}(\sigma )=1}
  
，从而3阶行列式中项
  
    
      
        
          a
          
            1
            ,
            2
          
        
        
          a
          
            2
            ,
            3
          
        
        
          a
          
            3
            ,
            1
          
        
      
    
    {\displaystyle a_{1,2}a_{2,3}a_{3,1}}
  
的符号是正的。但对于三元置换
  
    
      
        σ
        =
        
          (
          
            3
            ,
            2
            ,
            1
          
          )
        
      
    
    {\displaystyle \sigma =\left(3,2,1\right)}
  
（即是说
  
    
      
        σ
        (
        1
        )
        =
        3
      
    
    {\displaystyle \sigma (1)=3}
  
，
  
    
      
        σ
        (
        2
        )
        =
        2
      
    
    {\displaystyle \sigma (2)=2}
  
，
  
    
      
        σ
        (
        3
        )
        =
        1
      
    
    {\displaystyle \sigma (3)=1}
  
）而言，可以数出共有3个逆序（奇数个），因此
  
    
      
        sgn
        ⁡
        σ
        =
        −
        1
      
    
    {\displaystyle \operatorname {sgn} \sigma =-1}
  
，从而3阶行列式中项
  
    
      
        
          a
          
            1
            ,
            3
          
        
        
          a
          
            2
            ,
            2
          
        
        
          a
          
            3
            ,
            1
          
        
      
    
    {\displaystyle a_{1,3}a_{2,2}a_{3,1}}
  
的符号是负号。
注意到对于任意正整数
  
    
      
        n
      
    
    {\displaystyle n}
  
，
  
    
      
        
          S
          
            n
          
        
      
    
    {\displaystyle S_{n}}
  
共拥有n!个元素，因此上式中共有
  
    
      
        n
        !
      
    
    {\displaystyle n!}
  
个求和项，即这是一个有限多次的求和。
对于简单的2阶和3阶的矩阵，行列式的表达式相对简单，而且恰好是每条主对角线（左上至右下）元素乘积之和减去每条副对角线（右上至左下）元素乘积之和（见图中红线和蓝线）。

2阶矩阵的行列式：
  
    
      
        
          
            |
            
              
                
                  
                    a
                    
                      1
                      ,
                      1
                    
                  
                
                
                  
                    a
                    
                      1
                      ,
                      2
                    
                  
                
              
              
                
                  
                    a
                    
                      2
                      ,
                      1
                    
                  
                
                
                  
                    a
                    
                      2
                      ,
                      2
                    
                  
                
              
            
            |
          
        
        =
        
          a
          
            1
            ,
            1
          
        
        
          a
          
            2
            ,
            2
          
        
        −
        
          a
          
            1
            ,
            2
          
        
        
          a
          
            2
            ,
            1
          
        
      
    
    {\displaystyle {\begin{vmatrix}a_{1,1}&a_{1,2}\\a_{2,1}&a_{2,2}\end{vmatrix}}=a_{1,1}a_{2,2}-a_{1,2}a_{2,1}}
  

3阶矩阵的行列式：
  
    
      
        
          
            
              |
              
                
                  
                    
                      a
                      
                        1
                        ,
                        1
                      
                    
                  
                  
                    
                      a
                      
                        1
                        ,
                        2
                      
                    
                  
                  
                    
                      a
                      
                        1
                        ,
                        3
                      
                    
                  
                
                
                  
                    
                      a
                      
                        2
                        ,
                        1
                      
                    
                  
                  
                    
                      a
                      
                        2
                        ,
                        2
                      
                    
                  
                  
                    
                      a
                      
                        2
                        ,
                        3
                      
                    
                  
                
                
                  
                    
                      a
                      
                        3
                        ,
                        1
                      
                    
                  
                  
                    
                      a
                      
                        3
                        ,
                        2
                      
                    
                  
                  
                    
                      a
                      
                        3
                        ,
                        3
                      
                    
                  
                
              
              |
            
          
          =
          
            a
            
              1
              ,
              1
            
          
          
            a
            
              2
              ,
              2
            
          
          
            a
            
              3
              ,
              3
            
          
          +
          
            a
            
              1
              ,
              2
            
          
          
            a
            
              2
              ,
              3
            
          
          
            a
            
              3
              ,
              1
            
          
          +
          
            a
            
              1
              ,
              3
            
          
          
            a
            
              2
              ,
              1
            
          
          
            a
            
              3
              ,
              2
            
          
          −
          
            a
            
              1
              ,
              3
            
          
          
            a
            
              2
              ,
              2
            
          
          
            a
            
              3
              ,
              1
            
          
          −
          
            a
            
              1
              ,
              1
            
          
          
            a
            
              2
              ,
              3
            
          
          
            a
            
              3
              ,
              2
            
          
          −
          
            a
            
              1
              ,
              2
            
          
          
            a
            
              2
              ,
              1
            
          
          
            a
            
              3
              ,
              3
            
          
        
      
    
    {\displaystyle \displaystyle {\begin{vmatrix}a_{1,1}&a_{1,2}&a_{1,3}\\a_{2,1}&a_{2,2}&a_{2,3}\\a_{3,1}&a_{3,2}&a_{3,3}\end{vmatrix}}=a_{1,1}a_{2,2}a_{3,3}+a_{1,2}a_{2,3}a_{3,1}+a_{1,3}a_{2,1}a_{3,2}-a_{1,3}a_{2,2}a_{3,1}-a_{1,1}a_{2,3}a_{3,2}-a_{1,2}a_{2,1}a_{3,3}}
  

但对于阶数
  
    
      
        n
        ≥
        4
      
    
    {\displaystyle n\geq 4}
  
的方阵
  
    
      
        A
      
    
    {\displaystyle A}
  
，这样的主对角线和副对角线分别只有
  
    
      
        n
      
    
    {\displaystyle n}
  
条，由于
  
    
      
        A
      
    
    {\displaystyle A}
  
的主、副对角线总条数
  
    
      
        =
        2
        n
        <
        
          (
          
            n
            −
            1
          
          )
        
        n
        <
        n
        !
        =
        
          S
          
            n
          
        
      
    
    {\displaystyle =2n<\left(n-1\right)n<n!=S_{n}}
  
的元素个数
因此，行列式的相加项中除了这样的对角线乘积之外，还有其他更多的项。例如4阶行列式中，项
  
    
      
        
          a
          
            1
            ,
            2
          
        
        
          a
          
            2
            ,
            3
          
        
        
          a
          
            3
            ,
            1
          
        
        
          a
          
            4
            ,
            4
          
        
      
    
    {\displaystyle a_{1,2}a_{2,3}a_{3,1}a_{4,4}}
  
就不是任何对角线的元素乘积。不过，和2、3阶行列式情况相同的是，n阶行列式中的每一项仍然是从矩阵中选取n个元素相乘得到，且保证在每行和每列中都恰好只选取一个元素，而整个行列式恰好将所有这样的选取方法遍历一次。
另外，
  
    
      
        n
        ×
        n
      
    
    {\displaystyle n\times n}
  
矩阵的每一行或每一列也可以看成是一个
  
    
      
        n
      
    
    {\displaystyle n}
  
元向量，这时矩阵的行列式也被称为这
  
    
      
        n
      
    
    {\displaystyle n}
  
个
  
    
      
        n
      
    
    {\displaystyle n}
  
元向量组成的向量组的行列式。


几何意义：二维和三维欧氏空间中的例子 行列式的一个自然的源起是n维平行体的体积。行列式的定义和n维平行体的体积有着本质上的关联。


= 二维向量组的行列式 =

在一个二维平面上，两个向量
  
    
      
        X
        =
        
          (
          
            a
            ,
            c
          
          )
        
      
    
    {\displaystyle X=\left(a,c\right)}
  
和
  
    
      
        
          X
          ′
        
        =
        
          (
          
            b
            ,
            d
          
          )
        
      
    
    {\displaystyle X'=\left(b,d\right)}
  
的行列式是：

  
    
      
        det
        (
        X
        ,
        
          X
          ′
        
        )
        =
        
          
            |
            
              
                
                  a
                
                
                  b
                
              
              
                
                  c
                
                
                  d
                
              
            
            |
          
        
        =
        a
        d
        −
        b
        c
      
    
    {\displaystyle \det(X,X')={\begin{vmatrix}a&b\\c&d\end{vmatrix}}=ad-bc}
  

比如说，两个向量
  
    
      
        X
        =
        
          (
          
            2
            ,
            1
          
          )
        
      
    
    {\displaystyle X=\left(2,1\right)}
  
和
  
    
      
        
          X
          ′
        
        =
        
          (
          
            3
            ,
            4
          
          )
        
      
    
    {\displaystyle X'=\left(3,4\right)}
  
的行列式是：

  
    
      
        det
        (
        X
        ,
        
          X
          ′
        
        )
        =
        
          
            |
            
              
                
                  2
                
                
                  3
                
              
              
                
                  1
                
                
                  4
                
              
            
            |
          
        
        =
        2
        ⋅
        4
        −
        3
        ⋅
        1
        =
        5
      
    
    {\displaystyle \det(X,X')={\begin{vmatrix}2&3\\1&4\end{vmatrix}}=2\cdot 4-3\cdot 1=5}
  

经计算可知，当系数是实数时，行列式表示的是向量
  
    
      
        X
      
    
    {\displaystyle X}
  
和
  
    
      
        
          X
          ′
        
      
    
    {\displaystyle X'}
  
形成的平行四边形的有向面积，并有如下性质：

行列式为零当且仅当两个向量共线（线性相关），这时平行四边形退化成一条直线。
如果以逆时针方向为正向的话，有向面积的意义是：平行四边形面积为正当且仅当以原点为不动点将
  
    
      
        X
      
    
    {\displaystyle X}
  
逆时针“转到”
  
    
      
        
          X
          ′
        
      
    
    {\displaystyle X'}
  
处时，扫过的地方在平行四边形裡，否则的话面积就是负的。如右图中，
  
    
      
        X
      
    
    {\displaystyle X}
  
和
  
    
      
        
          X
          ′
        
      
    
    {\displaystyle X'}
  
所构成的平行四边形的面积就是正的。
行列式是一个双线性映射。也就是说，
  
    
      
        det
        (
        λ
        X
        +
        μ
        Y
        ,
        
          X
          ′
        
        )
        =
        λ
        det
        (
        X
        ,
        
          X
          ′
        
        )
        +
        μ
        det
        (
        Y
        ,
        
          X
          ′
        
        )
        
      
    
    {\displaystyle \det(\lambda X+\mu Y,X')=\lambda \det(X,X')+\mu \det(Y,X')\;}
  
，
并且

  
    
      
        det
        (
        X
        ,
        λ
        
          X
          ′
        
        +
        μ
        
          Y
          ′
        
        )
        =
        λ
        det
        (
        X
        ,
        
          X
          ′
        
        )
        +
        μ
        det
        (
        X
        ,
        
          Y
          ′
        
        )
        
      
    
    {\displaystyle \det(X,\lambda X'+\mu Y')=\lambda \det(X,X')+\mu \det(X,Y')\;}
  
。

其几何意义是：以同一个向量
  
    
      
        v
      
    
    {\displaystyle v}
  
作为一条边的两个平行四边形的面积之和，等于它们各自另一边的向量
  
    
      
        u
      
    
    {\displaystyle u}
  
和
  
    
      
        
          u
          ′
        
      
    
    {\displaystyle u'}
  
加起来后的向量：
  
    
      
        u
        +
        
          u
          ′
        
      
    
    {\displaystyle u+u'}
  
和
  
    
      
        v
      
    
    {\displaystyle v}
  
所构成的平行四边形的面积，如左图中所示。


= 三维向量组的行列式 =
在三维的有向空间中，三个三维向量的行列式是：

  
    
      
        det
        (
        X
        ,
        
          X
          ′
        
        ,
        
          X
          ″
        
        )
        =
        
          
            |
            
              
                
                  x
                
                
                  
                    x
                    ′
                  
                
                
                  
                    x
                    ″
                  
                
              
              
                
                  y
                
                
                  
                    y
                    ′
                  
                
                
                  
                    y
                    ″
                  
                
              
              
                
                  z
                
                
                  
                    z
                    ′
                  
                
                
                  
                    z
                    ″
                  
                
              
            
            |
          
        
        =
        x
        
          y
          ′
        
        
          z
          ″
        
        +
        
          x
          ′
        
        
          y
          ″
        
        z
        +
        
          x
          ″
        
        y
        
          z
          ′
        
        −
        x
        
          y
          ″
        
        
          z
          ′
        
        −
        
          x
          ′
        
        y
        
          z
          ″
        
        −
        
          x
          ″
        
        
          y
          ′
        
        z
      
    
    {\displaystyle \det(X,X',X'')={\begin{vmatrix}x&x'&x''\\y&y'&y''\\z&z'&z''\end{vmatrix}}=xy'z''+x'y''z+x''yz'-xy''z'-x'yz''-x''y'z}
  
。
比如说，三个向量
  
    
      
        
          (
          
            2
            ,
            1
            ,
            5
          
          )
        
      
    
    {\displaystyle \left(2,1,5\right)}
  
、
  
    
      
        
          (
          
            6
            ,
            0
            ,
            8
          
          )
        
      
    
    {\displaystyle \left(6,0,8\right)}
  
和
  
    
      
        
          (
          
            3
            ,
            2
            ,
            4
          
          )
        
      
    
    {\displaystyle \left(3,2,4\right)}
  
的行列式是：

  
    
      
        det
        (
        X
        ,
        
          X
          ′
        
        ,
        
          X
          ″
        
        )
        =
        
          
            |
            
              
                
                  2
                
                
                  6
                
                
                  3
                
              
              
                
                  1
                
                
                  0
                
                
                  2
                
              
              
                
                  5
                
                
                  8
                
                
                  4
                
              
            
            |
          
        
        =
        2
        ⋅
        0
        ⋅
        4
        +
        6
        ⋅
        2
        ⋅
        5
        +
        3
        ⋅
        1
        ⋅
        8
        −
        2
        ⋅
        2
        ⋅
        8
        −
        6
        ⋅
        1
        ⋅
        4
        −
        3
        ⋅
        0
        ⋅
        5
        =
        28
      
    
    {\displaystyle \det(X,X',X'')={\begin{vmatrix}2&6&3\\1&0&2\\5&8&4\end{vmatrix}}=2\cdot 0\cdot 4+6\cdot 2\cdot 5+3\cdot 1\cdot 8-2\cdot 2\cdot 8-6\cdot 1\cdot 4-3\cdot 0\cdot 5=28}
  

当系数是实数时，行列式表示
  
    
      
        X
      
    
    {\displaystyle X}
  
、
  
    
      
        
          X
          ′
        
      
    
    {\displaystyle X'}
  
和
  
    
      
        
          X
          ″
        
      
    
    {\displaystyle X''}
  
三个向量形成的平行六面体的有向体积，也叫做这三个向量的混合积。同样的，可以观察到如下性质：

行列式为零当且仅当三个向量共线或者共面（三者线性相关），这时平行六面体退化为平面图形，体积为零。

三维空间中有向体积的定义要比二维空间中复杂，一般是根据右手定则来约定。比如右图中(
  
    
      
        u
        ,
        v
        ,
        w
      
    
    {\displaystyle u,v,w}
  
)所形成的平行六面体的体积是正的，而(
  
    
      
        u
        ,
        w
        ,
        v
      
    
    {\displaystyle u,w,v}
  
)所形成的平行六面体的体积是负的。这个定义和行列式的计算并不矛盾，因为行列式中向量的坐标都是在取好坐标系后才决定的，而坐标系的三个方向一般也是按照右手规则来设定的。如果计算开始时坐标系的定向反过来的话，有向体积的定义也要跟着反过来，这样行列式才能代表有向体积。
这时行列式是一个“三线性映射”，也就是说，对第一个向量有
  
    
      
        det
        (
        a
        X
        +
        b
        Y
        ,
        
          X
          ′
        
        ,
        
          X
          ″
        
        )
        =
        a
        det
        (
        X
        ,
        
          X
          ′
        
        ,
        
          X
          ″
        
        )
        +
        b
        det
        (
        Y
        ,
        
          X
          ′
        
        ,
        
          X
          ″
        
        )
        
      
    
    {\displaystyle \det(aX+bY,X',X'')=a\det(X,X',X'')+b\det(Y,X',X'')\;}
  
，对第二、第三个向量也是如此。其几何意义和二维时基本相同，是指当生成两个平行六面体的每组三个向量中如果有两个是重合的，比如分别是：(
  
    
      
        u
        ,
        v
        ,
        w
      
    
    {\displaystyle u,v,w}
  
)和(
  
    
      
        
          u
          ′
        
        ,
        v
        ,
        w
      
    
    {\displaystyle u',v,w}
  
)，那么它们的体积之总和等于将
  
    
      
        u
      
    
    {\displaystyle u}
  
和
  
    
      
        
          u
          ′
        
      
    
    {\displaystyle u'}
  
加起来后的向量
  
    
      
        u
        +
        
          u
          ′
        
      
    
    {\displaystyle u+u'}
  
和
  
    
      
        v
      
    
    {\displaystyle v}
  
, 
  
    
      
        w
      
    
    {\displaystyle w}
  
所形成的平行六面体的体积，如右图所示。


= 基底的选择 =
在以上的行列式中，我们不加选择地将向量在所谓的正交基（即直角坐标系）下分解，实际上在不同的基底之下，行列式的值并不相同。这并不是说平行六面体的体积不唯一。恰恰相反，这说明体积的概念依赖于衡量空间的尺度，也就是基底的取法。用基底的变换可以看作线性映射对基底的作用，而不同基底下的行列式代表了基变换对“体积”的影响。可以证明，对于所有同定向的标准正交基，向量组的行列式的值在绝对值意义上是一样的。也就是说，如果我们选择的基底都是“单位长度”，并且两两正交，那么在这样的基之下，平行六面体的体积的绝对值是唯一的。


= 线性变换 =

设E是一个一般的n维的有向欧几里得空间。一个线性变换把一个向量线性地变为另一个向量。比如说，在三维空间中，向量(
  
    
      
        x
        ,
        y
        ,
        z
      
    
    {\displaystyle x,y,z}
  
)被映射到向量(
  
    
      
        
          x
          ′
        
        ,
        
          y
          ′
        
        ,
        
          z
          ′
        
      
    
    {\displaystyle x',y',z'}
  
)：

  
    
      
        
          
            
              
                
                  x
                  ′
                
                =
                
                  a
                  
                    1
                  
                
                x
                +
                
                  b
                  
                    1
                  
                
                y
                +
                
                  c
                  
                    1
                  
                
                z
              
            
            
              
                
                  y
                  ′
                
                =
                
                  a
                  
                    2
                  
                
                x
                +
                
                  b
                  
                    2
                  
                
                y
                +
                
                  c
                  
                    2
                  
                
                z
              
            
            
              
                
                  z
                  ′
                
                =
                
                  a
                  
                    3
                  
                
                x
                +
                
                  b
                  
                    3
                  
                
                y
                +
                
                  c
                  
                    3
                  
                
                z
              
            
          
        
      
    
    {\displaystyle {\begin{matrix}x'=a_{1}x+b_{1}y+c_{1}z\\y'=a_{2}x+b_{2}y+c_{2}z\\z'=a_{3}x+b_{3}y+c_{3}z\end{matrix}}}
  

其中
  
    
      
        a
      
    
    {\displaystyle a}
  
、
  
    
      
        b
      
    
    {\displaystyle b}
  
、
  
    
      
        c
      
    
    {\displaystyle c}
  
是系数。如右图，正方体（可以看作原来的一组基形成的）经线性变换后可以变成一个普通的平行六面体，或变成一个平行四边形（没有体积）。这两种情况表示了两种不同的线性变换，行列式可以将其很好地分辨出来（为零或不为零）。
更详细地说，行列式表示的是线性变换前后平行六面体的体积的变化系数。如果设左边的正方体体积是一，那么中间的平行六面体的（有向）体积就是线性变换的行列式的值，右边的平行四边形体积为零，因为线性变换的行列式为零。这里我们混淆了线性变换的行列式和向量组的行列式，但两者是一样的，因为我们在对一组基作变换。


行列式与空间定向 以上二维和三维行列式的例子中，行列式被解释为向量形成的图形的面积或体积。面积或体积的定义是恒正的，而行列式是有正有负的，因此需要引入有向面积和有向体积的概念。负的面积或体积在物理学中可能难以理解，但在数学中，它们和有向角的概念类似，都是对空间镜面对称特性的一种刻画。如果行列式表示的是线性变换对体积的影响，那么行列式的正负就表示了空间的定向。
如上图中，左边的黄色骰子（可以看成有单位的有向体积的物体）在经过了线性变换后变成中间绿色的平行六面体，这时行列式为正，两者是同定向的，可以通过旋转和拉伸从一个变成另一个。而骰子和右边的红色平行六面体之间也是通过线性变换得到的，但是无论怎样旋转和拉伸，都无法使一个变成另一个，一定要通过镜面反射才行。这时两者之间的线性变换的行列式是负的。可以看出，线性变换可以分为两类，一类对应着正的行列式，保持空间的定向不变，另一类对应负的行列式，颠倒空间的定向。


一般域上的行列式：严格的定义 由二维及三维的例子，可以看到一般的行列式应该具有怎样的性质。在
  
    
      
        n
      
    
    {\displaystyle n}
  
维欧几里得空间中，作为“平行多面体”的“体积”的概念的推广，行列式继承了“体积”函数的性质。首先，行列式需要是线性的，这可以由面积的性质类比得到。这裡的线性是对于每一个向量来说的，因为当一个向量变为原来的
  
    
      
        a
      
    
    {\displaystyle a}
  
倍时，“平行多面体”的“体积”也变为原来的
  
    
      
        a
      
    
    {\displaystyle a}
  
倍。其次，当一个向量在其它向量组成的“超平面”上时，
  
    
      
        n
      
    
    {\displaystyle n}
  
维“平行多面体”的“体积”是零（可以想像三维空间的例子）。也就是说，当向量线性相关时，行列式为零。在一般系数域上的线性空间中，行列式也正是由这样的特性所刻划的：


= 交替多线性形式（多重线性函数） =
行列式是系数域为
  
    
      
        K
      
    
    {\displaystyle K}
  
的有限维线性空间
  
    
      
        E
      
    
    {\displaystyle E}
  
上射到
  
    
      
        K
      
    
    {\displaystyle K}
  
的交替n-线性形式。
具体来说，设
  
    
      
        E
      
    
    {\displaystyle E}
  
是一个系数在域
  
    
      
        K
      
    
    {\displaystyle K}
  
上的有限维线性空间，维数为
  
    
      
        n
      
    
    {\displaystyle n}
  
。一个
  
    
      
        E
      
    
    {\displaystyle E}
  
上的交替
  
    
      
        n
        −
      
    
    {\displaystyle n-}
  
线性形式是指满足以下性质的函数
  
    
      
        D
        :
        
          E
          
            n
          
        
        →
        K
      
    
    {\displaystyle D:E^{n}\to K}
  
：

  
    
      
        n
      
    
    {\displaystyle n}
  
重線性：
  
    
      
        D
        (
        
          a
          
            1
          
        
        ,
        …
        ,
        c
        
          a
          
            i
          
        
        +
        
          a
          
            i
          
          ′
        
        ,
        …
        ,
        
          a
          
            n
          
        
        )
        =
        c
        D
        (
        
          a
          
            1
          
        
        ,
        …
        ,
        
          a
          
            i
          
        
        ,
        …
        ,
        
          a
          
            n
          
        
        )
        +
        D
        (
        
          a
          
            1
          
        
        ,
        …
        ,
        
          a
          
            i
          
          ′
        
        ,
        …
        ,
        
          a
          
            n
          
        
        )
      
    
    {\displaystyle D(a_{1},\ldots ,ca_{i}+a_{i}',\ldots ,a_{n})=cD(a_{1},\ldots ,a_{i},\ldots ,a_{n})+D(a_{1},\ldots ,a_{i}',\ldots ,a_{n})}
  

交替性：
  
    
      
        D
        (
        
          a
          
            1
          
        
        ,
        
          a
          
            2
          
        
        ,
        …
        ,
        
          a
          
            n
          
        
        )
        =
        −
        D
        (
        
          a
          
            2
          
        
        ,
        
          a
          
            1
          
        
        ,
        …
        ,
        
          a
          
            n
          
        
        )
      
    
    {\displaystyle D(a_{1},a_{2},\ldots ,a_{n})=-D(a_{2},a_{1},\ldots ,a_{n})}
  
或者说，当
  
    
      
        
          a
          
            i
          
        
        =
        
          a
          
            j
          
        
      
    
    {\displaystyle a_{i}=a_{j}}
  
的时候
  
    
      
        D
        (
        
          a
          
            1
          
        
        ,
        …
        ,
        
          a
          
            i
          
        
        ,
        …
        ,
        
          a
          
            j
          
        
        ,
        …
        ,
        
          a
          
            n
          
        
        )
        =
        0
      
    
    {\displaystyle D(a_{1},\ldots ,a_{i},\ldots ,a_{j},\ldots ,a_{n})=0}
  

所有E上的交替
  
    
      
        n
        −
      
    
    {\displaystyle n-}
  
线性形式的集合记作
  
    
      
        
          A
          
            n
          
        
        (
        E
        )
      
    
    {\displaystyle A_{n}(E)}
  
。


= 向量组的行列式 =
设
  
    
      
        B
        =
        (
        
          e
          
            1
          
        
        ,
        …
        ,
        
          e
          
            n
          
        
        )
      
    
    {\displaystyle B=(e_{1},\dots ,e_{n})}
  
是
  
    
      
        E
      
    
    {\displaystyle E}
  
的一组基，根据上面的定理和线性形式的性质，可以定义
  
    
      
        B
      
    
    {\displaystyle B}
  
下的行列式。

其中的唯一性是因为如果有两个交替
  
    
      
        n
        −
      
    
    {\displaystyle n-}
  
线性形式满足条件，则它们的差在一组基上为0，从而恒等于0。于是，一组基上的一个向量组的行列式就是：

可以见到这个定义与之前直观的定义是吻合的，它有时也被称作莱布尼兹公式。


 基变更公式  设
  
    
      
        B
      
    
    {\displaystyle B}
  
与
  
    
      
        
          B
          ′
        
      
    
    {\displaystyle B'}
  
是向量空间中的两组基，则将上面定理中的
  
    
      
        f
      
    
    {\displaystyle f}
  
改为
  
    
      
        det
        
          

          
          
            B
          
        
      
    
    {\displaystyle \det {}_{B}}
  
就得到向量组在两组基下的行列式之间的关系：

  
    
      
        det
        
          

          
          
            
              B
              ′
            
          
        
        (
        
          a
          
            1
          
        
        ,
        …
        ,
        
          a
          
            n
          
        
        )
        =
        det
        
          

          
          
            
              B
              ′
            
          
        
        (
        B
        )
        ×
        det
        
          

          
          
            B
          
        
        (
        
          a
          
            1
          
        
        ,
        …
        ,
        
          a
          
            n
          
        
        )
      
    
    {\displaystyle \det {}_{B'}(a_{1},\dots ,a_{n})=\det {}_{B'}(B)\times \det {}_{B}(a_{1},\dots ,a_{n})}
  
，


= 矩阵的行列式 =
設
  
    
      
        
          
            
              
                M
              
            
            
              n
            
          
          (
          K
          )
        
      
    
    {\displaystyle \displaystyle {\mathit {M}}_{n}(K)}
  
為所有定義在系数域
  
    
      
        K
      
    
    {\displaystyle K}
  
上的
  
    
      
        n
        ×
        n
      
    
    {\displaystyle n\times n}
  
矩陣的集合。將
  
    
      
        n
        ×
        n
      
    
    {\displaystyle n\times n}
  
矩陣
  
    
      
        M
      
    
    {\displaystyle M}
  
（
  
    
      
        M
      
    
    {\displaystyle M}
  
的元素记为
  
    
      
        
          
            m
            
              i
              ,
              j
            
          
        
      
    
    {\displaystyle \displaystyle m_{i,j}}
  
 )的
  
    
      
        n
      
    
    {\displaystyle n}
  
列寫成
  
    
      
        
          m
          
            1
          
        
        ,
        …
        ,
        
          m
          
            n
          
        
      
    
    {\displaystyle m_{1},\ldots ,m_{n}}
  
，
  
    
      
        
          
            m
            
              j
            
          
        
      
    
    {\displaystyle \displaystyle m_{j}}
  
可以看作是
  
    
      
        
          
            R
          
          
            n
          
        
      
    
    {\displaystyle \mathbb {R} ^{n}}
  
的正则基上的向量。矩阵
  
    
      
        M
      
    
    {\displaystyle M}
  
的行列式定义为向量组
  
    
      
        
          m
          
            1
          
        
        ,
        …
        ,
        
          m
          
            n
          
        
      
    
    {\displaystyle m_{1},\ldots ,m_{n}}
  
的行列式。这裡的向量都在
  
    
      
        
          
            R
          
          
            n
          
        
      
    
    {\displaystyle \mathbb {R} ^{n}}
  
的正则基上展开，因此矩阵的行列式不依赖于基的选择。

这样定义的矩阵
  
    
      
        M
      
    
    {\displaystyle M}
  
的行列式与向量组的行列式有同样的性质。单位矩阵的行列式为1，若矩阵的某几行线性相关，则它的行列式为零。
由莱布尼兹公式，可以证明矩阵行列式的一个重要性质：

也就是说矩阵的行列式既可以看作
  
    
      
        n
      
    
    {\displaystyle n}
  
个行向量的行列式，也可以看作
  
    
      
        n
      
    
    {\displaystyle n}
  
个列向量的行列式。因此也可以通过行向量组来定义矩阵行列式，并且得到的定义是等价的。


= 线性变换的行列式 =
设
  
    
      
        f
      
    
    {\displaystyle f}
  
是
  
    
      
        n
      
    
    {\displaystyle n}
  
维线性空间
  
    
      
        E
      
    
    {\displaystyle E}
  
到自身的线性变换（自同态），对于给定的一组基，可以定义线性变换在这组基下的行列式。

f的变换矩阵满足
  
    
      
        
          [
          
            f
            (
            
              x
              
                1
              
            
            )
            ,
            …
            ,
            f
            (
            
              x
              
                n
              
            
            )
          
          ]
        
        =
        
          
            [
            f
            ]
          
          
            B
          
        
        ⋅
        
          [
          
            
              x
              
                1
              
            
            ,
            …
            ,
            
              x
              
                n
              
            
          
          ]
        
      
    
    {\displaystyle \left[f(x_{1}),\dots ,f(x_{n})\right]=\left[f\right]_{B}\cdot \left[x_{1},\dots ,x_{n}\right]}
  

也就是说对所有的向量组
  
    
      
        (
        
          x
          
            1
          
        
        ,
        …
        ,
        
          x
          
            n
          
        
        )
      
    
    {\displaystyle (x_{1},\dots ,x_{n})}
  
，

  
    
      
        det
        
          

          
          
            B
          
        
        (
        f
        (
        
          x
          
            1
          
        
        )
        ,
        …
        ,
        f
        (
        
          x
          
            n
          
        
        )
        )
        =
        det
        
          (
          
            [
            f
            
              ]
              
                B
              
            
          
          )
        
        ×
        det
        
          

          
          
            B
          
        
        (
        
          x
          
            1
          
        
        ,
        …
        ,
        
          x
          
            n
          
        
        )
      
    
    {\displaystyle \det {}_{B}(f(x_{1}),\dots ,f(x_{n}))=\det \left([f]_{B}\right)\times \det {}_{B}(x_{1},\dots ,x_{n})}
  

  
    
      
        =
        det
        f
        ×
        det
        
          

          
          
            B
          
        
        (
        
          x
          
            1
          
        
        ,
        ⋯
        ,
        
          x
          
            n
          
        
        )
      
    
    {\displaystyle =\det f\times \det {}_{B}(x_{1},\cdots ,x_{n})}
  
。
可以证明，f在E的任意一组基下的变换矩阵的行列式都是相等的。

因此线性变换的行列式定义可以修改为不依赖于基的形式：

前一节里对正方体做线性变换时，
  
    
      
        (
        
          x
          
            1
          
        
        ,
        ⋯
        ,
        
          x
          
            n
          
        
        )
      
    
    {\displaystyle (x_{1},\cdots ,x_{n})}
  
是原来的基，
  
    
      
        det
        
          

          
          
            B
          
        
        (
        
          x
          
            1
          
        
        ,
        …
        ,
        
          x
          
            n
          
        
        )
        =
        1
      
    
    {\displaystyle \det {}_{B}(x_{1},\dots ,x_{n})=1}
  
，因此可以混淆向量组的行列式和线性变换的行列式。
特别地，行列式为1的线性变换保持向量组的行列式，它们构成一般线性群
  
    
      
        G
        L
        (
        E
        )
      
    
    {\displaystyle GL(E)}
  
的一个子群
  
    
      
        S
        L
        (
        E
        )
      
    
    {\displaystyle SL(E)}
  
，称作特殊线性群。可以证明，
  
    
      
        S
        L
        (
        E
        )
      
    
    {\displaystyle SL(E)}
  
是由所有的错切生成的，即所有具有如下形式的矩阵代表的线性变换：

  
    
      
        
          
            [
            
              
                
                  1
                
                
                
                
                
              
              
                
                
                  1
                
                
                
                
              
              
                
                
                
                  λ
                
                
                
              
              
                
                
                
                
                  1
                
                
              
              
                
                
                
                
                
                  1
                
              
            
            ]
          
        
        =
        
          I
          
            n
          
        
        +
        λ
        
          E
          
            i
            j
          
        
      
    
    {\displaystyle {\begin{bmatrix}1&&&&\\&1&&&\\&&\lambda &&\\&&&1&\\&&&&1\end{bmatrix}}=I_{n}+\lambda E_{ij}}
  

其中
  
    
      
        
          E
          
            i
            j
          
        
      
    
    {\displaystyle E_{ij}}
  
是只在第
  
    
      
        i
      
    
    {\displaystyle i}
  
行第
  
    
      
        j
      
    
    {\displaystyle j}
  
列处系数取1，其余系数为0的矩阵。也就是说，错切变换保持向量组形成的“平行多面体”的体积。同样，可以证明两个相似矩阵有相等的行列式。


系数的取值 以上的定义中都假设矩阵的系数取自域
  
    
      
        
          K
        
      
    
    {\displaystyle \mathbb {K} }
  
中，实际上矩阵的系数可以是任意的交换环
  
    
      
        k
      
    
    {\displaystyle k}
  
，这时有限维线性空间变为以
  
    
      
        B
        =
        (
        
          e
          
            1
          
        
        ,
        …
        ,
        
          e
          
            n
          
        
        )
      
    
    {\displaystyle B=(e_{1},\dots ,e_{n})}
  
为基的自由
  
    
      
        k
        −
      
    
    {\displaystyle k-}
  
模，而相应的关于行列式的定义和性质依然成立（在可定义的范畴内）。如果矩阵系数是非交换环的话，以上的行列式定义将不再唯一。1845年，阿瑟·凯莱首次开始研究非交换环上行列式定义的问题。他注意到，对于系数是四元数（不可交换）的二阶行列式

  
    
      
        
          
            |
            
              
                
                  
                    a
                    
                      11
                    
                  
                
                
                  
                    a
                    
                      12
                    
                  
                
              
              
                
                  
                    a
                    
                      21
                    
                  
                
                
                  
                    a
                    
                      22
                    
                  
                
              
            
            |
          
        
      
    
    {\displaystyle {\begin{vmatrix}a_{11}&a_{12}\\a_{21}&a_{22}\\\end{vmatrix}}}
  

表达式
  
    
      
        
          a
          
            11
          
        
        
          a
          
            22
          
        
        −
        
          a
          
            12
          
        
        
          a
          
            21
          
        
      
    
    {\displaystyle a_{11}a_{22}-a_{12}a_{21}}
  
和
  
    
      
        
          a
          
            11
          
        
        
          a
          
            22
          
        
        −
        
          a
          
            21
          
        
        
          a
          
            12
          
        
      
    
    {\displaystyle a_{11}a_{22}-a_{21}a_{12}}
  
是不一样的。1926年，阿兰德·海廷和A.理查德森提出了非交换环上的行列式的不同定义。理查德森将二阶行列式定义为：
  
    
      
        (
        
          a
          
            11
          
        
        −
        
          a
          
            12
          
        
        
          a
          
            22
          
          
            −
            1
          
        
        
          a
          
            21
          
        
        )
        
          a
          
            22
          
        
      
    
    {\displaystyle (a_{11}-a_{12}a_{22}^{-1}a_{21})a_{22}}
  
，而海廷则提倡使用
  
    
      
        (
        
          a
          
            11
          
        
        −
        
          a
          
            12
          
        
        
          a
          
            22
          
          
            −
            1
          
        
        
          a
          
            21
          
        
        )
      
    
    {\displaystyle (a_{11}-a_{12}a_{22}^{-1}a_{21})}
  
。两人都用归纳法定义了更高阶矩阵的行列式。1931年，奥斯丁·欧尔在一大类非交换环（后来命名为欧尔环）上定义了行列式的概念。最著名的非交换环上的行列式的定义当属让·迪厄多内的定义。迪厄多内是布尔巴基学派的代表成员之一，他将除环
  
    
      
        
          K
        
      
    
    {\displaystyle \mathbb {K} }
  
中的行列式定义在商域
  
    
      
        
          K
        
        
          /
        
        [
        
          K
        
        ,
        
          K
        
        ]
      
    
    {\displaystyle \mathbb {K} /[\mathbb {K} ,\mathbb {K} ]}
  
上，而不是在
  
    
      
        
          K
        
      
    
    {\displaystyle \mathbb {K} }
  
中。这个定义下的行列式有接近交换环中行列式的性质。例如，迪尔多内的行列式可以保持行列式的乘法定理。而这种行列式与交换环中行列式的区别是：将矩阵的两行或两列互换后，行列式的值不变。之后菲列克斯·别列金（Березин, Феликс Александрович）、佐藤幹夫等人对迪厄多内的定义进行了探究和扩展。


行列式的性質 行列式的一些基本性质，可以由它的多线性以及交替性推出。

在行列式中，一行（列）元素全為0，則此行列式的值為0。

  
    
      
        
          
            |
            
              
                
                  
                    
                      0
                    
                  
                
                
                  
                    
                      0
                    
                  
                
                
                  …
                
                
                  
                    
                      0
                    
                  
                
              
              
                
                  
                    a
                    
                      21
                    
                  
                
                
                  
                    a
                    
                      22
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      2
                      n
                    
                  
                
              
              
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋱
                
                
                  ⋮
                
              
              
                
                  
                    a
                    
                      n
                      1
                    
                  
                
                
                  
                    a
                    
                      n
                      2
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      n
                      n
                    
                  
                
              
            
            |
          
        
        =
        
          
            |
            
              
                
                  
                    
                      0
                    
                  
                
                
                  
                    a
                    
                      12
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      1
                      n
                    
                  
                
              
              
                
                  
                    
                      0
                    
                  
                
                
                  
                    a
                    
                      22
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      2
                      n
                    
                  
                
              
              
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋱
                
                
                  ⋮
                
              
              
                
                  
                    
                      0
                    
                  
                
                
                  
                    a
                    
                      n
                      2
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      n
                      n
                    
                  
                
              
            
            |
          
        
        =
        0
      
    
    {\displaystyle {\begin{vmatrix}{\color {blue}0}&{\color {blue}0}&\dots &{\color {blue}0}\\a_{21}&a_{22}&\dots &a_{2n}\\\vdots &\vdots &\ddots &\vdots \\a_{n1}&a_{n2}&\dots &a_{nn}\end{vmatrix}}={\begin{vmatrix}{\color {blue}0}&a_{12}&\dots &a_{1n}\\{\color {blue}0}&a_{22}&\dots &a_{2n}\\\vdots &\vdots &\ddots &\vdots \\{\color {blue}0}&a_{n2}&\dots &a_{nn}\end{vmatrix}}=0}
  

在行列式中，某一行（列）有公因子
  
    
      
        k
      
    
    {\displaystyle k}
  
，則可以提出
  
    
      
        k
      
    
    {\displaystyle k}
  
。

  
    
      
        D
        =
        
          
            |
            
              
                
                  
                    a
                    
                      11
                    
                  
                
                
                  
                    a
                    
                      12
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      1
                      n
                    
                  
                
              
              
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋱
                
                
                  ⋮
                
              
              
                
                  
                    
                      k
                    
                  
                  
                    a
                    
                      i
                      1
                    
                  
                
                
                  
                    
                      k
                    
                  
                  
                    a
                    
                      i
                      2
                    
                  
                
                
                  …
                
                
                  
                    
                      k
                    
                  
                  
                    a
                    
                      i
                      n
                    
                  
                
              
              
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋱
                
                
                  ⋮
                
              
              
                
                  
                    a
                    
                      n
                      1
                    
                  
                
                
                  
                    a
                    
                      n
                      2
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      n
                      n
                    
                  
                
              
            
            |
          
        
        =
        
          
            k
          
        
        
          
            |
            
              
                
                  
                    a
                    
                      11
                    
                  
                
                
                  
                    a
                    
                      12
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      1
                      n
                    
                  
                
              
              
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋱
                
                
                  ⋮
                
              
              
                
                  
                    a
                    
                      i
                      1
                    
                  
                
                
                  
                    a
                    
                      i
                      2
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      i
                      n
                    
                  
                
              
              
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋱
                
                
                  ⋮
                
              
              
                
                  
                    a
                    
                      n
                      1
                    
                  
                
                
                  
                    a
                    
                      n
                      2
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      n
                      n
                    
                  
                
              
            
            |
          
        
        =
        
          
            k
          
        
        
          D
          
            1
          
        
      
    
    {\displaystyle D={\begin{vmatrix}a_{11}&a_{12}&\dots &a_{1n}\\\vdots &\vdots &\ddots &\vdots \\{\color {blue}k}a_{i1}&{\color {blue}k}a_{i2}&\dots &{\color {blue}k}a_{in}\\\vdots &\vdots &\ddots &\vdots \\a_{n1}&a_{n2}&\dots &a_{nn}\end{vmatrix}}={\color {blue}k}{\begin{vmatrix}a_{11}&a_{12}&\dots &a_{1n}\\\vdots &\vdots &\ddots &\vdots \\a_{i1}&a_{i2}&\dots &a_{in}\\\vdots &\vdots &\ddots &\vdots \\a_{n1}&a_{n2}&\dots &a_{nn}\end{vmatrix}}={\color {blue}k}D_{1}}
  

在行列式中，某一行（列）的每個元素是兩數之和，則此行列式可拆分為兩個相加的行列式。

  
    
      
        
          
            |
            
              
                
                  
                    a
                    
                      11
                    
                  
                
                
                  
                    a
                    
                      12
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      1
                      n
                    
                  
                
              
              
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋱
                
                
                  ⋮
                
              
              
                
                  
                    
                      
                        a
                        
                          i
                          1
                        
                      
                    
                  
                  +
                  
                    
                      
                        b
                        
                          i
                          1
                        
                      
                    
                  
                
                
                  
                    
                      
                        a
                        
                          i
                          2
                        
                      
                    
                  
                  +
                  
                    
                      
                        b
                        
                          i
                          2
                        
                      
                    
                  
                
                
                  …
                
                
                  
                    
                      
                        a
                        
                          i
                          n
                        
                      
                    
                  
                  +
                  
                    
                      
                        b
                        
                          i
                          n
                        
                      
                    
                  
                
              
              
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋱
                
                
                  ⋮
                
              
              
                
                  
                    a
                    
                      n
                      1
                    
                  
                
                
                  
                    a
                    
                      n
                      2
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      n
                      n
                    
                  
                
              
            
            |
          
        
        =
        
          
            |
            
              
                
                  
                    a
                    
                      11
                    
                  
                
                
                  
                    a
                    
                      12
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      1
                      n
                    
                  
                
              
              
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋱
                
                
                  ⋮
                
              
              
                
                  
                    
                      
                        a
                        
                          i
                          1
                        
                      
                    
                  
                
                
                  
                    
                      
                        a
                        
                          i
                          2
                        
                      
                    
                  
                
                
                  …
                
                
                  
                    
                      
                        a
                        
                          i
                          n
                        
                      
                    
                  
                
              
              
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋱
                
                
                  ⋮
                
              
              
                
                  
                    a
                    
                      n
                      1
                    
                  
                
                
                  
                    a
                    
                      n
                      2
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      n
                      n
                    
                  
                
              
            
            |
          
        
        +
        
          
            |
            
              
                
                  
                    a
                    
                      11
                    
                  
                
                
                  
                    a
                    
                      12
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      1
                      n
                    
                  
                
              
              
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋱
                
                
                  ⋮
                
              
              
                
                  
                    
                      
                        b
                        
                          i
                          1
                        
                      
                    
                  
                
                
                  
                    
                      
                        b
                        
                          i
                          2
                        
                      
                    
                  
                
                
                  …
                
                
                  
                    
                      
                        b
                        
                          i
                          n
                        
                      
                    
                  
                
              
              
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋱
                
                
                  ⋮
                
              
              
                
                  
                    a
                    
                      n
                      1
                    
                  
                
                
                  
                    a
                    
                      n
                      2
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      n
                      n
                    
                  
                
              
            
            |
          
        
      
    
    {\displaystyle {\begin{vmatrix}a_{11}&a_{12}&\dots &a_{1n}\\\vdots &\vdots &\ddots &\vdots \\{\color {blue}a_{i1}}+{\color {OliveGreen}b_{i1}}&{\color {blue}a_{i2}}+{\color {OliveGreen}b_{i2}}&\dots &{\color {blue}a_{in}}+{\color {OliveGreen}b_{in}}\\\vdots &\vdots &\ddots &\vdots \\a_{n1}&a_{n2}&\dots &a_{nn}\end{vmatrix}}={\begin{vmatrix}a_{11}&a_{12}&\dots &a_{1n}\\\vdots &\vdots &\ddots &\vdots \\{\color {blue}a_{i1}}&{\color {blue}a_{i2}}&\dots &{\color {blue}a_{in}}\\\vdots &\vdots &\ddots &\vdots \\a_{n1}&a_{n2}&\dots &a_{nn}\end{vmatrix}}+{\begin{vmatrix}a_{11}&a_{12}&\dots &a_{1n}\\\vdots &\vdots &\ddots &\vdots \\{\color {OliveGreen}b_{i1}}&{\color {OliveGreen}b_{i2}}&\dots &{\color {OliveGreen}b_{in}}\\\vdots &\vdots &\ddots &\vdots \\a_{n1}&a_{n2}&\dots &a_{nn}\end{vmatrix}}}
  

行列式中的兩行（列）互換，改變行列式正負符號。

  
    
      
        
          
            |
            
              
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋮
                
              
              
                
                  
                    
                      
                        a
                        
                          i
                          1
                        
                      
                    
                  
                
                
                  
                    
                      
                        a
                        
                          i
                          2
                        
                      
                    
                  
                
                
                  …
                
                
                  
                    
                      
                        a
                        
                          i
                          n
                        
                      
                    
                  
                
              
              
                
                  
                    
                      
                        a
                        
                          j
                          1
                        
                      
                    
                  
                
                
                  
                    
                      
                        a
                        
                          j
                          2
                        
                      
                    
                  
                
                
                  …
                
                
                  
                    
                      
                        a
                        
                          j
                          n
                        
                      
                    
                  
                
              
              
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋮
                
              
            
            |
          
        
        =
        −
        
          
            |
            
              
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋮
                
              
              
                
                  
                    
                      
                        a
                        
                          j
                          1
                        
                      
                    
                  
                
                
                  
                    
                      
                        a
                        
                          j
                          2
                        
                      
                    
                  
                
                
                  …
                
                
                  
                    
                      
                        a
                        
                          j
                          n
                        
                      
                    
                  
                
              
              
                
                  
                    
                      
                        a
                        
                          i
                          1
                        
                      
                    
                  
                
                
                  
                    
                      
                        a
                        
                          i
                          2
                        
                      
                    
                  
                
                
                  …
                
                
                  
                    
                      
                        a
                        
                          i
                          n
                        
                      
                    
                  
                
              
              
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋮
                
              
            
            |
          
        
      
    
    {\displaystyle {\begin{vmatrix}\vdots &\vdots &\vdots &\vdots \\{\color {blue}a_{i1}}&{\color {blue}a_{i2}}&\dots &{\color {blue}a_{in}}\\{\color {OliveGreen}a_{j1}}&{\color {OliveGreen}a_{j2}}&\dots &{\color {OliveGreen}a_{jn}}\\\vdots &\vdots &\vdots &\vdots \\\end{vmatrix}}=-{\begin{vmatrix}\vdots &\vdots &\vdots &\vdots \\{\color {OliveGreen}a_{j1}}&{\color {OliveGreen}a_{j2}}&\dots &{\color {OliveGreen}a_{jn}}\\{\color {blue}a_{i1}}&{\color {blue}a_{i2}}&\dots &{\color {blue}a_{in}}\\\vdots &\vdots &\vdots &\vdots \\\end{vmatrix}}}
  

在行列式中，有兩行（列）對應成比例或相同，則此行列式的值為0。

  
    
      
        
          
            |
            
              
                
                  
                    
                      2
                    
                  
                
                
                  
                    
                      2
                    
                  
                
                
                  …
                
                
                  
                    
                      2
                    
                  
                
              
              
                
                  
                    
                      8
                    
                  
                
                
                  
                    
                      8
                    
                  
                
                
                  …
                
                
                  
                    
                      8
                    
                  
                
              
              
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋱
                
                
                  ⋮
                
              
              
                
                  
                    a
                    
                      n
                      1
                    
                  
                
                
                  
                    a
                    
                      n
                      2
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      n
                      n
                    
                  
                
              
            
            |
          
        
        =
        0
      
    
    {\displaystyle {\begin{vmatrix}{\color {blue}2}&{\color {blue}2}&\dots &{\color {blue}2}\\{\color {blue}8}&{\color {blue}8}&\dots &{\color {blue}8}\\\vdots &\vdots &\ddots &\vdots \\a_{n1}&a_{n2}&\dots &a_{nn}\end{vmatrix}}=0}
  

將一行（列）的
  
    
      
        k
      
    
    {\displaystyle k}
  
倍加進另一行（列）裡，行列式的值不變。

  
    
      
        
          
            |
            
              
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋮
                
              
              
                
                  
                    a
                    
                      i
                      1
                    
                  
                
                
                  
                    a
                    
                      i
                      2
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      i
                      n
                    
                  
                
              
              
                
                  
                    a
                    
                      j
                      1
                    
                  
                
                
                  
                    a
                    
                      j
                      2
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      j
                      n
                    
                  
                
              
              
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋮
                
              
            
            |
          
        
        =
        
          
            |
            
              
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋮
                
              
              
                
                  
                    a
                    
                      i
                      1
                    
                  
                
                
                  
                    a
                    
                      i
                      2
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      i
                      n
                    
                  
                
              
              
                
                  
                    a
                    
                      j
                      1
                    
                  
                  
                    
                      +
                      k
                      
                        a
                        
                          i
                          1
                        
                      
                    
                  
                
                
                  
                    a
                    
                      j
                      2
                    
                  
                  
                    
                      +
                      k
                      
                        a
                        
                          i
                          2
                        
                      
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      j
                      n
                    
                  
                  
                    
                      +
                      k
                      
                        a
                        
                          i
                          n
                        
                      
                    
                  
                
              
              
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋮
                
              
            
            |
          
        
      
    
    {\displaystyle {\begin{vmatrix}\vdots &\vdots &\vdots &\vdots \\a_{i1}&a_{i2}&\dots &a_{in}\\a_{j1}&a_{j2}&\dots &a_{jn}\\\vdots &\vdots &\vdots &\vdots \\\end{vmatrix}}={\begin{vmatrix}\vdots &\vdots &\vdots &\vdots \\a_{i1}&a_{i2}&\dots &a_{in}\\a_{j1}{\color {blue}+ka_{i1}}&a_{j2}{\color {blue}+ka_{i2}}&\dots &a_{jn}{\color {blue}+ka_{in}}\\\vdots &\vdots &\vdots &\vdots \\\end{vmatrix}}}
  

注意：一行（列）的
  
    
      
        k
      
    
    {\displaystyle k}
  
倍加上另一行（列），行列式的值改變。

  
    
      
        
          
            |
            
              
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋮
                
              
              
                
                  
                    a
                    
                      i
                      1
                    
                  
                
                
                  
                    a
                    
                      i
                      2
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      i
                      n
                    
                  
                
              
              
                
                  
                    a
                    
                      j
                      1
                    
                  
                
                
                  
                    a
                    
                      j
                      2
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      j
                      n
                    
                  
                
              
              
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋮
                
              
            
            |
          
        
        
          
            =
          
        
        
          
            |
            
              
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋮
                
              
              
                
                  
                    a
                    
                      i
                      1
                    
                  
                
                
                  
                    a
                    
                      i
                      2
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      i
                      n
                    
                  
                
              
              
                
                  
                    
                      k
                    
                  
                  
                    a
                    
                      j
                      1
                    
                  
                  
                    
                      +
                      
                        a
                        
                          i
                          1
                        
                      
                    
                  
                
                
                  
                    
                      k
                    
                  
                  
                    a
                    
                      j
                      2
                    
                  
                  
                    
                      +
                      
                        a
                        
                          i
                          2
                        
                      
                    
                  
                
                
                  …
                
                
                  
                    
                      k
                    
                  
                  
                    a
                    
                      j
                      n
                    
                  
                  
                    
                      +
                      
                        a
                        
                          i
                          n
                        
                      
                    
                  
                
              
              
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋮
                
              
            
            |
          
        
      
    
    {\displaystyle {\begin{vmatrix}\vdots &\vdots &\vdots &\vdots \\a_{i1}&a_{i2}&\dots &a_{in}\\a_{j1}&a_{j2}&\dots &a_{jn}\\\vdots &\vdots &\vdots &\vdots \\\end{vmatrix}}{\color {red}\neq }{\begin{vmatrix}\vdots &\vdots &\vdots &\vdots \\a_{i1}&a_{i2}&\dots &a_{in}\\{\color {red}k}a_{j1}{\color {red}+a_{i1}}&{\color {red}k}a_{j2}{\color {red}+a_{i2}}&\dots &{\color {red}k}a_{jn}{\color {red}+a_{in}}\\\vdots &\vdots &\vdots &\vdots \\\end{vmatrix}}}
  

將行列式的行列互換，行列式的值不變，其中行列互換相當於轉置。这个性质可以简单地记作

  
    
      
        D
        =
        
          
            |
            
              
                
                  
                    a
                    
                      i
                      j
                    
                  
                
              
            
            |
          
        
        =
        
          
            |
            
              
                
                  
                    a
                    
                      j
                      i
                    
                  
                
              
            
            |
          
        
        =
        
          D
          
            
              T
            
          
        
      
    
    {\displaystyle D={\begin{vmatrix}a_{ij}\end{vmatrix}}={\begin{vmatrix}a_{ji}\end{vmatrix}}=D^{\textrm {T}}}
  

例如

  
    
      
        
          
            |
            
              
                
                  
                    a
                    
                      11
                    
                  
                
                
                  
                    a
                    
                      12
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      1
                      n
                    
                  
                
              
              
                
                  
                    a
                    
                      21
                    
                  
                
                
                  
                    a
                    
                      22
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      2
                      n
                    
                  
                
              
              
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋱
                
                
                  ⋮
                
              
              
                
                  
                    a
                    
                      n
                      1
                    
                  
                
                
                  
                    a
                    
                      n
                      2
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      n
                      n
                    
                  
                
              
            
            |
          
        
        =
        
          
            |
            
              
                
                  
                    a
                    
                      11
                    
                  
                
                
                  
                    a
                    
                      21
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      n
                      1
                    
                  
                
              
              
                
                  
                    a
                    
                      12
                    
                  
                
                
                  
                    a
                    
                      22
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      n
                      2
                    
                  
                
              
              
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋱
                
                
                  ⋮
                
              
              
                
                  
                    a
                    
                      1
                      n
                    
                  
                
                
                  
                    a
                    
                      2
                      n
                    
                  
                
                
                  …
                
                
                  
                    a
                    
                      n
                      n
                    
                  
                
              
            
            |
          
        
      
    
    {\displaystyle {\begin{vmatrix}a_{11}&a_{12}&\dots &a_{1n}\\a_{21}&a_{22}&\dots &a_{2n}\\\vdots &\vdots &\ddots &\vdots \\a_{n1}&a_{n2}&\dots &a_{nn}\end{vmatrix}}={\begin{vmatrix}a_{11}&a_{21}&\dots &a_{n1}\\a_{12}&a_{22}&\dots &a_{n2}\\\vdots &\vdots &\ddots &\vdots \\a_{1n}&a_{2n}&\dots &a_{nn}\end{vmatrix}}}
  

行列式的乘法定理：方块矩陣的乘積的行列式等於行列式的乘積。
  
    
      
        
          det
          (
          A
          B
          )
          =
          det
          (
          A
          )
          det
          (
          B
          )
        
      
    
    {\displaystyle \displaystyle \det(AB)=\det(A)\det(B)}
  
。特别的，若将矩阵中的每一行每一列上的数都乘以一个常数
  
    
      
        r
      
    
    {\displaystyle r}
  
，那么所得到的行列式不是原来的
  
    
      
        r
      
    
    {\displaystyle r}
  
倍，而是
  
    
      
        
          r
          
            n
          
        
      
    
    {\displaystyle r^{n}}
  
倍：

  
    
      
        det
        (
        r
        A
        )
        =
        det
        (
        r
        
          I
          
            n
          
        
        ⋅
        A
        )
        =
        det
        (
        r
        
          I
          
            n
          
        
        )
        ⋅
        det
        (
        A
        )
        =
        
          r
          
            n
          
        
        det
        (
        A
        )
      
    
    {\displaystyle \det(rA)=\det(rI_{n}\cdot A)=\det(rI_{n})\cdot \det(A)=r^{n}\det(A)}
  
。
以上的乘法公式还可以进一步推广为所谓柯西–比内公式，从而使得只要两个矩阵的乘积是方块矩阵，就有类似于以上的结果：假设
  
    
      
        A
      
    
    {\displaystyle A}
  
是一个
  
    
      
        m
        ×
        n
      
    
    {\displaystyle m\times n}
  
矩阵，而
  
    
      
        B
      
    
    {\displaystyle B}
  
是一个
  
    
      
        n
        ×
        m
      
    
    {\displaystyle n\times m}
  
矩阵。如果
  
    
      
        S
      
    
    {\displaystyle S}
  
是
  
    
      
        
          {
          
            1
            ,
            ⋯
            ,
            n
          
          }
        
      
    
    {\displaystyle \left\{1,\cdots ,n\right\}}
  
中具有
  
    
      
        m
      
    
    {\displaystyle m}
  
个元素的子集
  
    
      
        
          {
          
            
              S
              
                1
              
            
            ,
            ⋯
            ,
            
              S
              
                m
              
            
          
          }
        
      
    
    {\displaystyle \left\{S_{1},\cdots ,S_{m}\right\}}
  
，我们记
  
    
      
        
          A
          
            S
          
        
      
    
    {\displaystyle A_{S}}
  
为
  
    
      
        A
      
    
    {\displaystyle A}
  
中列指标位于
  
    
      
        S
      
    
    {\displaystyle S}
  
中的
  
    
      
        m
        ×
        m
      
    
    {\displaystyle m\times m}
  
子矩阵。类似地，记
  
    
      
        
          B
          
            S
          
        
      
    
    {\displaystyle B_{S}}
  
为
  
    
      
        B
      
    
    {\displaystyle B}
  
中行指标位于
  
    
      
        S
      
    
    {\displaystyle S}
  
中的
  
    
      
        m
        ×
        m
      
    
    {\displaystyle m\times m}
  
子矩阵。那么

  
    
      
        det
        (
        A
        B
        )
        =
        
          ∑
          
            S
          
        
        det
        (
        
          A
          
            S
          
        
        )
        det
        (
        
          B
          
            S
          
        
        )
        
      
    
    {\displaystyle \det(AB)=\sum _{S}\det(A_{S})\det(B_{S})\,}
  

这里求遍
  
    
      
        
          {
          
            1
            ,
            ⋯
            ,
            n
          
          }
        
      
    
    {\displaystyle \left\{1,\cdots ,n\right\}}
  
中
  
    
      
        m
      
    
    {\displaystyle m}
  
个元素的所有可能子集
  
    
      
        S
      
    
    {\displaystyle S}
  
（共有C(n,m)个）。
如果
  
    
      
        m
        =
        n
      
    
    {\displaystyle m=n}
  
，即
  
    
      
        A
      
    
    {\displaystyle A}
  
与
  
    
      
        B
      
    
    {\displaystyle B}
  
是同样大小的方块矩阵，则只有一个容许集合
  
    
      
        S
      
    
    {\displaystyle S}
  
，柯西–比内公式退化为通常行列式的乘法公式。如过
  
    
      
        m
        =
        1
      
    
    {\displaystyle m=1}
  
则有
  
    
      
        n
      
    
    {\displaystyle n}
  
容许集合
  
    
      
        S
      
    
    {\displaystyle S}
  
，这个公式退化为点积。如果
  
    
      
        m
        >
        n
      
    
    {\displaystyle m>n}
  
，没有容许集合
  
    
      
        S
      
    
    {\displaystyle S}
  
，约定行列式
  
    
      
        det
        (
        A
        B
        )
      
    
    {\displaystyle \det(AB)}
  
是零。
若
  
    
      
        A
      
    
    {\displaystyle A}
  
是可逆矩陣，
  
    
      
        
          det
          (
          
            A
            
              −
              1
            
          
          )
          =
          (
          det
          (
          A
          )
          
            )
            
              −
              1
            
          
        
      
    
    {\displaystyle \displaystyle \det(A^{-1})=(\det(A))^{-1}}
  
。
由行列式的乘法定理以及
  
    
      
        
          det
          (
          
            A
            
              −
              1
            
          
          )
          =
          (
          det
          (
          A
          )
          
            )
            
              −
              1
            
          
        
      
    
    {\displaystyle \displaystyle \det(A^{-1})=(\det(A))^{-1}}
  
可以知道，行列式定义了一个从一般线性群
  
    
      
        (
        G
        
          L
          
            n
          
        
        (
        
          F
        
        )
        ,
        ×
        )
      
    
    {\displaystyle (GL_{n}(\mathbb {F} ),\times )}
  
到
  
    
      
        (
        
          
            F
          
          
            ∗
          
        
        ,
        ×
        )
      
    
    {\displaystyle (\mathbb {F} ^{*},\times )}
  
上的群同态。
若将方块矩阵中的元素取共轭，得到的是矩阵的共轭矩阵。共轭矩阵的行列式值等於矩阵行列式值的共軛：
  
    
      
        det
        (
        
          
            A
            ¯
          
        
        )
        =
        
          
            
              det
              (
              A
              )
            
            ¯
          
        
      
    
    {\displaystyle \det({\overline {A}})={\overline {\det(A)}}}
  

若兩個矩陣相似，那麼它們的行列式相同。这是因为两个相似的矩阵之间只相差一个基底变换，而行列式描述的是矩阵对应的线性映射对体积的影响，而不是体积，所以基底变换并不会影响行列式的值。用数学语言来说，就是：
如果兩個矩陣
  
    
      
        
          A
        
      
    
    {\displaystyle \mathbf {A} }
  
与
  
    
      
        
          B
        
      
    
    {\displaystyle \mathbf {B} }
  
相似，那麼存在可逆矩阵
  
    
      
        
          P
        
      
    
    {\displaystyle \mathbf {P} }
  
使得

  
    
      
        
          A
        
        =
        
          P
          B
        
        
          
            P
          
          
            −
            1
          
        
      
    
    {\displaystyle \mathbf {A} =\mathbf {PB} \mathbf {P} ^{-1}}
  
，所以

  
    
      
        det
        (
        
          A
        
        )
        =
        det
        (
        
          P
          B
        
        
          
            P
          
          
            −
            1
          
        
        )
        =
        det
        (
        
          P
        
        )
        ⋅
        det
        (
        
          B
        
        )
        ⋅
        det
        (
        
          
            P
          
          
            −
            1
          
        
        )
        =
        det
        (
        
          B
        
        )
        ⋅
        det
        (
        
          P
        
        )
        ⋅
        det
        (
        
          P
        
        
          )
          
            −
            1
          
        
        =
        det
        (
        
          B
        
        )
      
    
    {\displaystyle \det(\mathbf {A} )=\det(\mathbf {PB} \mathbf {P} ^{-1})=\det(\mathbf {P} )\cdot \det(\mathbf {B} )\cdot \det(\mathbf {P} ^{-1})=\det(\mathbf {B} )\cdot \det(\mathbf {P} )\cdot \det(\mathbf {P} )^{-1}=\det(\mathbf {B} )}
  

行列式是所有特徵值（按代数重数计）的乘积。這可由矩陣必和其若尔当标准型相似推導出。特殊地，三角矩阵的行列式等于其对角线上所有元素的乘积。
由于三角矩阵的行列式计算简便，当矩阵的系数为域时，可以通过高斯消去法将矩阵变换成三角矩阵，或者将矩阵分解成三角矩阵的乘积之后再利用行列式的乘法定理进行计算。可以证明，所有的矩阵
  
    
      
        A
      
    
    {\displaystyle A}
  
都可以分解成一个上三角矩阵
  
    
      
        U
      
    
    {\displaystyle U}
  
、一个下三角矩阵
  
    
      
        L
      
    
    {\displaystyle L}
  
以及一个置换矩阵
  
    
      
        P
      
    
    {\displaystyle P}
  
的乘积：
  
    
      
        A
        =
        P
        ⋅
        L
        ⋅
        U
      
    
    {\displaystyle A=P\cdot L\cdot U}
  
。这时，矩阵
  
    
      
        A
      
    
    {\displaystyle A}
  
的行列式可以写成：

  
    
      
        det
        (
        A
        )
        =
        det
        (
        P
        )
        ⋅
        det
        (
        L
        )
        ⋅
        det
        (
        U
        )
      
    
    {\displaystyle \det(A)=\det(P)\cdot \det(L)\cdot \det(U)}
  

分块矩阵的行列式并不能简单地表示成每个分块的行列式的乘积组合。对于分块的三角矩阵，仍然有类似的结论：

  
    
      
        
          
            |
            
              
                
                  A
                
                
                  0
                
              
              
                
                  C
                
                
                  D
                
              
            
            |
          
        
        =
        
          
            |
            
              
                
                  A
                
                
                  B
                
              
              
                
                  0
                
                
                  D
                
              
            
            |
          
        
        =
        det
        (
        A
        )
        det
        (
        D
        )
      
    
    {\displaystyle {\begin{vmatrix}A&0\\C&D\end{vmatrix}}={\begin{vmatrix}A&B\\0&D\end{vmatrix}}=\det(A)\det(D)}
  
，矩阵的行列式等于对角元素的行列式之乘积。
对于一般情况，若对角元素中有一个是可逆矩阵，比如说
  
    
      
        A
      
    
    {\displaystyle A}
  
可逆，那么矩阵的行列式可以写做

  
    
      
        
          
            |
            
              
                
                  A
                
                
                  B
                
              
              
                
                  C
                
                
                  D
                
              
            
            |
          
        
        =
        det
        (
        A
        )
        det
        (
        D
        −
        C
        
          A
          
            −
            1
          
        
        B
        )
      
    
    {\displaystyle {\begin{vmatrix}A&B\\C&D\end{vmatrix}}=\det(A)\det(D-CA^{-1}B)}
  
。
矩阵的行列式和矩阵的迹数有一定的关联，当矩阵的系数为域时，在定义了矩阵的指数函数后，有如下的恒等式：

  
    
      
        det
        (
        exp
        ⁡
        (
        A
        )
        )
        =
        exp
        ⁡
        (
        
          t
          r
        
        (
        A
        )
        )
      
    
    {\displaystyle \det(\exp(A))=\exp(\mathrm {tr} (A))}
  


行列式的展开 = 餘因式 =

对一个
  
    
      
        n
      
    
    {\displaystyle n}
  
阶的行列式
  
    
      
        M
      
    
    {\displaystyle M}
  
，去掉
  
    
      
        M
      
    
    {\displaystyle M}
  
的第
  
    
      
        i
      
    
    {\displaystyle i}
  
行第
  
    
      
        j
      
    
    {\displaystyle j}
  
列后形成的
  
    
      
        n
        −
        1
      
    
    {\displaystyle n-1}
  
阶的行列式叫做
  
    
      
        M
      
    
    {\displaystyle M}
  
关于元素
  
    
      
        
          m
          
            i
            j
          
        
      
    
    {\displaystyle m_{ij}}
  
的餘因式。记作
  
    
      
        
          M
          
            i
            j
          
        
      
    
    {\displaystyle M_{ij}}
  
。

  
    
      
        
          M
          
            i
            j
          
        
        =
        
          
            |
            
              
                
                  
                    m
                    
                      1
                      ,
                      1
                    
                  
                
                
                  …
                
                
                  
                    m
                    
                      1
                      ,
                      j
                      −
                      1
                    
                  
                
                
                  
                    m
                    
                      1
                      ,
                      j
                      +
                      1
                    
                  
                
                
                  …
                
                
                  
                    m
                    
                      1
                      ,
                      n
                    
                  
                
              
              
                
                  ⋮
                
                
                
                  ⋮
                
                
                  ⋮
                
                
                
                  ⋮
                
              
              
                
                  
                    m
                    
                      i
                      −
                      1
                      ,
                      1
                    
                  
                
                
                  …
                
                
                  
                    m
                    
                      i
                      −
                      1
                      ,
                      j
                      −
                      1
                    
                  
                
                
                  
                    m
                    
                      i
                      −
                      1
                      ,
                      j
                      +
                      1
                    
                  
                
                
                  …
                
                
                  
                    m
                    
                      i
                      −
                      1
                      ,
                      n
                    
                  
                
              
              
                
                  
                    m
                    
                      i
                      +
                      1
                      ,
                      1
                    
                  
                
                
                  …
                
                
                  
                    m
                    
                      i
                      +
                      1
                      ,
                      j
                      −
                      1
                    
                  
                
                
                  
                    m
                    
                      i
                      +
                      1
                      ,
                      j
                      +
                      1
                    
                  
                
                
                  …
                
                
                  
                    m
                    
                      i
                      +
                      1
                      ,
                      n
                    
                  
                
              
              
                
                  ⋮
                
                
                
                  ⋮
                
                
                  ⋮
                
                
                
                  ⋮
                
              
              
                
                  
                    m
                    
                      n
                      ,
                      1
                    
                  
                
                
                  …
                
                
                  
                    m
                    
                      n
                      ,
                      j
                      −
                      1
                    
                  
                
                
                  
                    m
                    
                      n
                      ,
                      j
                      +
                      1
                    
                  
                
                
                  …
                
                
                  
                    m
                    
                      n
                      ,
                      n
                    
                  
                
              
            
            |
          
        
      
    
    {\displaystyle M_{ij}={\begin{vmatrix}m_{1,1}&\dots &m_{1,j-1}&m_{1,j+1}&\dots &m_{1,n}\\\vdots &&\vdots &\vdots &&\vdots \\m_{i-1,1}&\dots &m_{i-1,j-1}&m_{i-1,j+1}&\dots &m_{i-1,n}\\m_{i+1,1}&\dots &m_{i+1,j-1}&m_{i+1,j+1}&\dots &m_{i+1,n}\\\vdots &&\vdots &\vdots &&\vdots \\m_{n,1}&\dots &m_{n,j-1}&m_{n,j+1}&\dots &m_{n,n}\end{vmatrix}}}
  


= 代数余子式 =

  
    
      
        M
      
    
    {\displaystyle M}
  
关于元素
  
    
      
        
          m
          
            i
            j
          
        
      
    
    {\displaystyle m_{ij}}
  
的代数余子式记作
  
    
      
        
          C
          
            i
            j
          
        
      
    
    {\displaystyle C_{ij}}
  
。
  
    
      
        
          C
          
            i
            j
          
        
        =
        (
        −
        1
        
          )
          
            (
            i
            +
            j
            )
          
        
        ⋅
        
          M
          
            i
            j
          
        
      
    
    {\displaystyle C_{ij}=(-1)^{(i+j)}\cdot M_{ij}}
  
。


= 行列式关于行和列的展开 =
一个
  
    
      
        n
      
    
    {\displaystyle n}
  
阶的行列式
  
    
      
        M
      
    
    {\displaystyle M}
  
可以写成一行（或一列）的元素与对应的代数余子式的乘积之和，叫作行列式按一行（或一列）的展开。

  
    
      
        det
        
          M
        
        =
        
          ∑
          
            i
            =
            1
          
          
            n
          
        
        
          m
          
            i
            ;
            j
          
        
        
          C
          
            i
            ,
            j
          
        
      
    
    {\displaystyle \det {M}=\sum _{i=1}^{n}m_{i;j}C_{i,j}}
  

  
    
      
        det
        
          M
        
        =
        
          ∑
          
            j
            =
            1
          
          
            n
          
        
        
          m
          
            i
            ;
            j
          
        
        
          C
          
            i
            ,
            j
          
        
      
    
    {\displaystyle \det {M}=\sum _{j=1}^{n}m_{i;j}C_{i,j}}
  

这个公式又称拉普拉斯公式，把
  
    
      
        n
      
    
    {\displaystyle n}
  
维矩阵的行列式计算变为了
  
    
      
        n
      
    
    {\displaystyle n}
  
个
  
    
      
        n
        −
        1
      
    
    {\displaystyle n-1}
  
维的行列式的计算。另一方面，拉普拉斯公式可以作为行列式的一种归纳定义：在定义了二维行列式后，
  
    
      
        n
      
    
    {\displaystyle n}
  
维矩阵的行列式可以借助拉普拉斯公式用
  
    
      
        n
        −
        1
      
    
    {\displaystyle n-1}
  
维的行列式来定义。这样定义的行列式与前面的定义是等价的。


行列式的计算 计算行列式的值是一个常见的问题。最简单的方法是按照定义
  
    
      
        det
        (
        A
        )
        =
        
          ∑
          
            σ
            ∈
            
              S
              
                n
              
            
          
        
        sgn
        ⁡
        (
        σ
        )
        
          ∏
          
            i
            =
            1
          
          
            n
          
        
        
          a
          
            i
            ,
            σ
            (
            i
            )
          
        
      
    
    {\displaystyle \det(A)=\sum _{\sigma \in S_{n}}\operatorname {sgn}(\sigma )\prod _{i=1}^{n}a_{i,\sigma (i)}}
  
计算或按照拉普拉斯公式进行递归运算。这样的算法需要计算
  
    
      
        n
        !
      
    
    {\displaystyle n!}
  
次的加法，复杂度是指数函数。在实际的计算中只能用于计算阶数很小的行列式。注意到拉普拉斯公式的性质，如果一行或一列里面有很多个0，那么就可以把行列式按这一行或一列展开，这时数值为零的系数所对应的代数余子式就不必计算了，因为最后要乘以0，这样就可以简化计算。然而更加简便的算法是利用高斯消去法或LU分解法，把矩阵通过初等变换变成三角矩阵或三角矩阵的乘积来计算行列式的值。这些算法的复杂度都是
  
    
      
        
          n
          
            3
          
        
      
    
    {\displaystyle n^{3}}
  
级别，远远小于直接计算的复杂度。
如果一个算法可以在
  
    
      
        
          
            O
          
        
        (
        
          n
          
            s
          
        
        )
      
    
    {\displaystyle {\mathit {O}}(n^{s})}
  
时间内算出矩阵乘法，那么可以构造出一种
  
    
      
        
          
            O
          
        
        (
        
          n
          
            s
          
        
        )
      
    
    {\displaystyle {\mathit {O}}(n^{s})}
  
时间内的行列式求值算法。这说明求矩阵的行列式的值和矩阵的乘法有相同的复杂度。于是，通过分治算法或者其它的方法，可以达到比
  
    
      
        
          
            O
          
        
        (
        
          n
          
            3
          
        
        )
      
    
    {\displaystyle {\mathit {O}}(n^{3})}
  
更好的结果。比如，存在复杂度
  
    
      
        
          
            O
          
        
        (
        
          n
          
            2.376
          
        
        )
      
    
    {\displaystyle {\mathit {O}}(n^{2.376})}
  
的行列式求值算法。


行列式函数 由行列式的一般表达形式中可以看出，矩阵
  
    
      
        A
      
    
    {\displaystyle A}
  
的行列式是关于其系数的多项式。因此行列式函数具有良好的光滑性质。


= 单变量的行列式函数 =
设矩阵函数
  
    
      
        t
        ↦
        A
        (
        t
        )
      
    
    {\displaystyle t\mapsto A(t)}
  
为
  
    
      
        
          
            
              C
            
          
          
            k
          
        
      
    
    {\displaystyle {\mathcal {C}}^{k}}
  
（k阶连续可导）的函数，则由于行列式函数
  
    
      
        t
        ↦
        det
        A
        (
        t
        )
      
    
    {\displaystyle t\mapsto \det A(t)}
  
只不过是矩阵
  
    
      
        A
        (
        t
        )
      
    
    {\displaystyle A(t)}
  
的某些系数的乘积，所以也是
  
    
      
        
          
            
              C
            
          
          
            k
          
        
      
    
    {\displaystyle {\mathcal {C}}^{k}}
  
的。其对t的导数为

  
    
      
        
          
            
              d
            
            
              
                
                  d
                
              
              t
            
          
        
        
          (
          
            det
            (
            
              A
              
                1
              
            
            (
            t
            )
            ,
            …
            ,
            
              A
              
                n
              
            
            (
            t
            )
            )
          
          )
        
        =
        
          ∑
          
            i
            =
            1
          
          
            n
          
        
        det
        (
        
          A
          
            1
          
        
        (
        t
        )
        ,
        …
        ,
        
          A
          
            i
            −
            1
          
        
        (
        t
        )
        ,
        
          A
          
            i
          
          ′
        
        (
        t
        )
        ,
        
          A
          
            i
            +
            1
          
        
        (
        t
        )
        ,
        …
        ,
        
          A
          
            n
          
        
        (
        t
        )
        )
      
    
    {\displaystyle {\frac {\rm {d}}{{\rm {d}}t}}\left(\det(A_{1}(t),\dots ,A_{n}(t))\right)=\sum _{i=1}^{n}\det(A_{1}(t),\dots ,A_{i-1}(t),A'_{i}(t),A_{i+1}(t),\dots ,A_{n}(t))}
  
，其中的每个
  
    
      
        
          A
          
            i
          
        
        (
        t
        )
      
    
    {\displaystyle A_{i}(t)}
  
是矩阵
  
    
      
        A
        (
        t
        )
      
    
    {\displaystyle A(t)}
  
的第i个行向量（也可以全部是列向量）。


= 矩阵的行列式函数 =
函数
  
    
      
        A
        ↦
        det
        A
      
    
    {\displaystyle A\mapsto \det A}
  
是连续的。由此，n阶一般线性群是一个开集，因为是开区间
  
    
      
        
          R
        
        −
        
          {
          0
          }
        
      
    
    {\displaystyle \mathbb {R} -\left\{0\right\}}
  
的原像，而特殊线性群则是一个闭集，因为是闭集合
  
    
      
        
          {
          
            1
            ,
            −
            1
          
          }
        
      
    
    {\displaystyle \left\{1,-1\right\}}
  
的原像。
函数
  
    
      
        A
        ↦
        det
        A
      
    
    {\displaystyle A\mapsto \det A}
  
也是可微的，甚至是光滑的（
  
    
      
        
          
            
              C
            
          
          
            ∞
          
        
      
    
    {\displaystyle {\mathcal {C}}^{\infty }}
  
）。它在某个矩阵
  
    
      
        A
      
    
    {\displaystyle A}
  
处的展开为

  
    
      
        det
        (
        A
        +
        H
        )
        =
        det
        A
        +
        
          
            t
            r
          
        
        (
        
          

          
          
            t
          
        
        
          
            C
            o
            m
          
        
        (
        A
        )
        .
        H
        )
        +
        o
        (
        ‖
        H
        ‖
        )
      
    
    {\displaystyle \det(A+H)=\det A+{\rm {tr}}({}^{t}{\rm {Com}}(A).H)+o(\|H\|)}
  

也就是说，在装备正则范数的矩阵空间
  
    
      
        
          M
          
            n
          
        
        (
        
          R
        
        )
      
    
    {\displaystyle M_{n}(\mathbb {R} )}
  
中，伴随矩阵是行列式函数的梯度

  
    
      
        ∇
        det
        (
        A
        )
        =
        
          
            C
            o
            m
          
        
        (
        A
        )
      
    
    {\displaystyle \nabla \det(A)={\rm {Com}}(A)}
  
特别当
  
    
      
        A
      
    
    {\displaystyle A}
  
为单位矩阵时，

  
    
      
        det
        (
        I
        +
        H
        )
        =
        1
        +
        
          
            t
            r
          
        
        (
        H
        )
        +
        o
        (
        ‖
        H
        ‖
        )
        ,
        
        ∇
        det
        (
        I
        )
        =
        I
      
    
    {\displaystyle \det(I+H)=1+{\rm {tr}}(H)+o(\|H\|),\qquad \nabla \det(I)=I}
  

可逆矩阵的可微性说明一般线性群
  
    
      
        G
        
          L
          
            n
          
        
        (
        
          R
        
        )
      
    
    {\displaystyle GL_{n}(\mathbb {R} )}
  
是一个李群。


与外代数的关系 行列式与外代数有密切的关系，因为外代数正是在给定的交换环
  
    
      
        
          K
        
      
    
    {\displaystyle \mathbb {K} }
  
上的自由
  
    
      
        
          K
        
      
    
    {\displaystyle \mathbb {K} }
  
-模
  
    
      
        V
      
    
    {\displaystyle V}
  
上最“一般性”的有交替性质的结合代数，记为
  
    
      
        ∧
        (
        V
        )
      
    
    {\displaystyle \wedge (V)}
  
。外代数是由楔积构造而成的，而楔积在
  
    
      
        V
      
    
    {\displaystyle V}
  
上的交替性质表现如下（定义）：

楔积是满足结合律的双线性的二元运算，使得對於所有向量
  
    
      
        v
        ∈
        V
      
    
    {\displaystyle v\in V}
  
，
  
    
      
        v
        ∧
        v
        =
        0
      
    
    {\displaystyle v\wedge v=0}
  

这表示

對於所有向量
  
    
      
        u
        ,
        v
        ∈
        V
      
    
    {\displaystyle u,v\in V}
  
，
  
    
      
        u
        ∧
        v
        =
        −
        v
        ∧
        u
      
    
    {\displaystyle u\wedge v=-v\wedge u}
  
，以及
當
  
    
      
        
          v
          
            1
          
        
        ,
        …
        ,
        
          v
          
            k
          
        
        ∈
        V
      
    
    {\displaystyle v_{1},\ldots ,v_{k}\in V}
  
 线性相关时，
  
    
      
        
          v
          
            1
          
        
        ∧
        
          v
          
            2
          
        
        ∧
        ⋯
        ∧
        
          v
          
            k
          
        
        =
        0
      
    
    {\displaystyle v_{1}\wedge v_{2}\wedge \cdots \wedge v_{k}=0}
  
。所有形同
  
    
      
        
          v
          
            1
          
        
        ∧
        
          v
          
            2
          
        
        ∧
        ⋯
        ∧
        
          v
          
            k
          
        
      
    
    {\displaystyle v_{1}\wedge v_{2}\wedge \cdots \wedge v_{k}}
  
的元素称为
  
    
      
        k
        −
      
    
    {\displaystyle k-}
  
向量。所有
  
    
      
        k
        −
      
    
    {\displaystyle k-}
  
向量构成了
  
    
      
        ∧
        (
        V
        )
      
    
    {\displaystyle \wedge (V)}
  
的一个子空间，称为
  
    
      
        V
      
    
    {\displaystyle V}
  
的
  
    
      
        k
        −
      
    
    {\displaystyle k-}
  
阶外幂，记为
  
    
      
        
          ∧
          
            k
          
        
        (
        V
        )
      
    
    {\displaystyle \wedge ^{k}(V)}
  
。行列式函数是
  
    
      
        n
      
    
    {\displaystyle n}
  
重交替线性形式，所以可以看成是将
  
    
      
        n
      
    
    {\displaystyle n}
  
个
  
    
      
        
          
            K
          
          
            n
          
        
      
    
    {\displaystyle \mathbb {K} ^{n}}
  
裡面的向量映射到它们对应的
  
    
      
        n
        −
      
    
    {\displaystyle n-}
  
阶外幂
  
    
      
        
          ∧
          
            n
          
        
        (
        
          
            K
          
          
            n
          
        
        )
      
    
    {\displaystyle \wedge ^{n}(\mathbb {K} ^{n})}
  
这样一个映射。由于
  
    
      
        
          
            K
          
          
            n
          
        
      
    
    {\displaystyle \mathbb {K} ^{n}}
  
的
  
    
      
        k
        −
      
    
    {\displaystyle k-}
  
阶外幂
  
    
      
        
          ∧
          
            k
          
        
        (
        
          
            K
          
          
            n
          
        
        )
      
    
    {\displaystyle \wedge ^{k}(\mathbb {K} ^{n})}
  
的维数等于组合数
  
    
      
        
          
            
              (
            
            
              n
              k
            
            
              )
            
          
        
      
    
    {\displaystyle {\binom {n}{k}}}
  
，
  
    
      
        
          ∧
          
            n
          
        
        (
        
          
            R
          
          
            n
          
        
        )
      
    
    {\displaystyle \wedge ^{n}(\mathbb {R} ^{n})}
  
的维数是
  
    
      
        
          
            
              (
            
            
              n
              n
            
            
              )
            
          
        
        =
        1
      
    
    {\displaystyle {\binom {n}{n}}=1}
  
，因此
  
    
      
        
          ∧
          
            n
          
        
        (
        
          
            K
          
          
            n
          
        
        )
      
    
    {\displaystyle \wedge ^{n}(\mathbb {K} ^{n})}
  
实际上同构于
  
    
      
        
          K
        
      
    
    {\displaystyle \mathbb {K} }
  
，所以将行列式看做
  
    
      
        n
      
    
    {\displaystyle n}
  
个
  
    
      
        
          
            K
          
          
            n
          
        
      
    
    {\displaystyle \mathbb {K} ^{n}}
  
裡面的向量映射到它们对应的
  
    
      
        n
        −
      
    
    {\displaystyle n-}
  
阶外幂
  
    
      
        
          ∧
          
            n
          
        
        (
        
          
            K
          
          
            n
          
        
        )
      
    
    {\displaystyle \wedge ^{n}(\mathbb {K} ^{n})}
  
的映射与之前的行列式定义并没有冲突。外代数理论实际上涵盖了行列式理论。
对三维欧几里得空间中
  
    
      
        
          
            R
          
          
            3
          
        
      
    
    {\displaystyle \mathbb {R} ^{3}}
  
可以建立一个线性同构
  
    
      
        ϕ
        :
        
          Λ
          
            2
          
        
        (
        
          
            R
          
          
            3
          
        
        )
        →
        
          
            R
          
          
            3
          
        
      
    
    {\displaystyle \phi :\Lambda ^{2}(\mathbb {R} ^{3})\rightarrow \mathbb {R} ^{3}}
  
如下：任取
  
    
      
        
          
            R
          
          
            3
          
        
      
    
    {\displaystyle \mathbb {R} ^{3}}
  
的右手的标准正交基
  
    
      
        
          i
        
      
    
    {\displaystyle {\boldsymbol {i}}}
  
，
  
    
      
        
          j
        
      
    
    {\displaystyle {\boldsymbol {j}}}
  
，
  
    
      
        
          k
        
      
    
    {\displaystyle {\boldsymbol {k}}}
  
，规定
  
    
      
        ϕ
      
    
    {\displaystyle \phi }
  
把
  
    
      
        
          i
        
        ∧
        
          j
        
      
    
    {\displaystyle {\boldsymbol {i}}\wedge \mathbf {j} }
  
，
  
    
      
        
          j
        
        ∧
        
          k
        
      
    
    {\displaystyle {\boldsymbol {j}}\wedge {\boldsymbol {k}}}
  
，
  
    
      
        
          k
        
        ∧
        
          i
        
      
    
    {\displaystyle {\boldsymbol {k}}\wedge {\boldsymbol {i}}}
  
分别映射为
  
    
      
        
          k
        
      
    
    {\displaystyle {\boldsymbol {k}}}
  
，
  
    
      
        
          i
        
      
    
    {\displaystyle {\boldsymbol {i}}}
  
，
  
    
      
        
          j
        
      
    
    {\displaystyle {\boldsymbol {j}}}
  
，则
  
    
      
        ϕ
      
    
    {\displaystyle \phi }
  
的定义与右手的标准正交基如何选取无关。
不难看出，对任意向量
  
    
      
        
          u
        
      
    
    {\displaystyle {\boldsymbol {u}}}
  
和
  
    
      
        
          v
        
      
    
    {\displaystyle {\boldsymbol {v}}}
  
，这个线性同构把楔积
  
    
      
        
          u
        
        ∧
        
          v
        
      
    
    {\displaystyle {\boldsymbol {u}}\wedge {\boldsymbol {v}}}
  
映射为叉积
  
    
      
        
          u
        
        ×
        
          v
        
      
    
    {\displaystyle {\boldsymbol {u}}\times {\boldsymbol {v}}}
  
。这就是叉乘（向量积）的实质。叉积可以用带向量的行列式：

  
    
      
        
          a
        
        ×
        
          b
        
        =
         
        
          
            |
            
              
                
                  
                    i
                  
                
                
                  
                    j
                  
                
                
                  
                    k
                  
                
              
              
                
                  
                    a
                    
                      1
                    
                  
                
                
                  
                    a
                    
                      2
                    
                  
                
                
                  
                    a
                    
                      3
                    
                  
                
              
              
                
                  
                    b
                    
                      1
                    
                  
                
                
                  
                    b
                    
                      2
                    
                  
                
                
                  
                    b
                    
                      3
                    
                  
                
              
            
            |
          
        
      
    
    {\displaystyle \mathbf {a} \times \mathbf {b} =\ {\begin{vmatrix}\mathbf {i} &\mathbf {j} &\mathbf {k} \\a_{1}&a_{2}&a_{3}\\b_{1}&b_{2}&b_{3}\\\end{vmatrix}}}
  

来表示，但要注意这个行列式形式并不代表一个“真正”的行列式，因为第一行的分量不是数，而是向量。这个计算之所以正确是得益于线性同构
  
    
      
        ϕ
      
    
    {\displaystyle \phi }
  
。


历史 行列式的概念最初是伴随着方程组的求解而发展起来的。行列式的提出可以追溯到十七世纪，最初的雏形由日本数学家关孝和与德国数学家戈特弗里德·莱布尼茨各自独立得出，时间相差132年。


= 早期研究 =

1545年，吉罗拉莫·卡尔达诺在著作《大术》（Ars Magna）中给出了一种解两个一次方程组的方法。他把这种方法称为“母法”（regula de modo）。这种方法和后来的克莱姆法则已经很相似了，但卡尔达诺并没有给出行列式的概念。
1683年，日本数学家关孝和在其著作《解伏题之法》中首次引进了行列式的概念。书中出现了
  
    
      
        2
        ×
        2
      
    
    {\displaystyle 2\times 2}
  
、
  
    
      
        3
        ×
        3
      
    
    {\displaystyle 3\times 3}
  
乃至
  
    
      
        5
        ×
        5
      
    
    {\displaystyle 5\times 5}
  
的行列式，行列式被用来求解高次方程组。
1693年，德国数学家莱布尼茨开始使用指标数的系统集合来表示有三个未知数的三个一次方程组的系数。他从三个方程的系统中消去了两个未知量后得到一个行列式。这个行列式不等于零，就意味着有一组解同时满足三个方程。由于当时没有矩阵的概念，莱布尼茨将行列式中元素的位置用数对来表示：ij代表第i行第j列。莱布尼茨对行列式的研究成果中已经包括了行列式的展开和克莱姆法则，但这些结果在当时并不为人所知。


= 任意阶数的行列式 =
1730年，苏格兰数学家科林·麦克劳林在他的《论代数》中已经开始阐述行列式的理论，记载了用行列式解二元、三元和四元一次方程的方法，并给出了四元一次方程组的一般解的正确形式，尽管这本书直到麦克劳林逝世两年后（1748年）才得以出版。

1750年，瑞士的加布里尔·克莱姆首先在他的《代数曲线分析引论》给出了n元一次方程组求解的法则，用于确定经过五个点的一般二次曲线的系数，但并没有给出证明。其中行列式的计算十分复杂，因为是定义在奇置换和偶置换上的。
此后，关于行列式的研究逐渐增多。1764年，法国的艾蒂安·裴蜀的论文中关于行列式的计算方法的研究简化了克莱姆法则，给出了用结式来判别线性方程组的方法。同是法国人的范德蒙德则在1771年的论著中第一个将行列式和解方程理论分离，对行列式单独作出阐述。这是数学家们开始对行列式本身进行研究的开端。
1772年，皮埃尔-西蒙·拉普拉斯在论文《对积分和世界体系的探讨》中推广了范德蒙德著作裡面将行列式展开为若干个较小的行列式之和的方法，发展出子式的概念。一年后，约瑟夫·拉格朗日发现了
  
    
      
        3
        ×
        3
      
    
    {\displaystyle 3\times 3}
  
的行列式与空间中体积的联系。他发现：原点和空间中三个点所构成的四面体的体积，是它们的坐标所组成的行列式的六分之一。
行列式在大部分欧洲语言中被称为“determinant”（某些语言中词尾加e或o，或变成s），这个称呼最早是由卡爾·弗里德里希·高斯在他的《算术研究》中引入的。这个称呼的词根有“决定”意思，因为在高斯的使用中，行列式能够决定二次曲线的性质。在同一本著作中，高斯还叙述了一种通过系数之间加减来求解多元一次方程组的方法，也就是现在的高斯消元法。


= 行列式的现代概念 =

进入十九世纪后，行列式理论进一步得到发展和完善。奧古斯丁·路易·柯西在1812年首先将“determinant”一词用来表示十八世纪出现的行列式，此前高斯只不过将这个词限定在二次曲线所对应的系数行列式中。柯西也是最早将行列式排成方阵并将其元素用双重下标表示的数学家（垂直线记法是阿瑟·凯莱在1841年率先使用的）。柯西还证明了行列式的乘法定理（实际上是矩阵乘法），这个定理曾经在雅克·菲利普·玛利·比内（Jacque Philippe Marie Binet）的书中出现过，但没有证明。
十九世纪五十年代，凯莱和詹姆斯·约瑟夫·西尔维斯特将矩阵的概念引入数学研究中。行列式和矩阵之间的密切关系使得矩阵论蓬勃发展的同时也带来了许多关于行列式的新结果，例如阿达马不等式、正交行列式、对称行列式等等。
与此同时，行列式也被应用于各种领域中。高斯在二次曲线和二次型的研究中使用行列式作为二次曲线和二次型划归为标准型时的判别依据。之后，卡尔·魏尔斯特拉斯和西尔维斯特又完善了二次型理论，研究了
  
    
      
        λ
      
    
    {\displaystyle \lambda }
  
-矩阵的行列式以及初等因子。行列式被用于多重函数的积分大约始于十九世纪三十年代。1832年至1833年间卡尔·雅可比发现了一些特殊结果，1839年，欧仁·夏尔·卡塔兰（Eugene Charles Catalan）发现了所谓的雅可比行列式。1841年，雅可比发表了一篇关于函数行列式的论文，讨论函数的线性相关性与雅可比行列式的关系。


应用 = 行列式与线性方程组 =

行列式的一个主要应用是解线性方程组。当线性方程组的方程个数与未知数个数相等时，方程组不一定总是有唯一解。对一个有n个方程和n个未知数的线性方程组，我们研究未知数系数所对应的行列式。这个线性方程组有唯一解当且仅当它对应的行列式不为零。这也是行列式概念出现的根源。
当线性方程组对应的行列式不为零时，由克萊姆法則，可以直接以行列式的形式写出方程组的解。但用克萊姆法則求解计算量巨大，因此并没有实际应用价值，一般用于理论上的推导。


= 行列式与矩阵 =

矩阵的概念出现得比行列式晚，直到十九世纪中期才被引入，然而两者在本质上仍然有密切关系。通过矩阵，线性方程组可以表示为

  
    
      
        
          A
        
        x
        =
        b
      
    
    {\displaystyle \mathbf {A} x=b}
  

其中
  
    
      
        
          A
        
      
    
    {\displaystyle \mathbf {A} }
  
是由方程组中未知数的系数构成的方块矩阵，
  
    
      
        x
        =
        (
        
          x
          
            1
          
        
        ,
        
          x
          
            2
          
        
        ,
        ⋯
        ,
        
          x
          
            n
          
        
        
          )
          
            
              T
            
          
        
      
    
    {\displaystyle x=(x_{1},x_{2},\cdots ,x_{n})^{\mathbf {T} }}
  
是未知数，而
  
    
      
        b
        =
        (
        
          b
          
            1
          
        
        ,
        
          b
          
            2
          
        
        ,
        ⋯
        ,
        
          b
          
            n
          
        
        
          )
          
            
              T
            
          
        
      
    
    {\displaystyle b=(b_{1},b_{2},\cdots ,b_{n})^{\mathbf {T} }}
  
。
在矩阵理论中，行列式也有各种用途。多項式
  
    
      
        p
        (
        x
        )
        =
        det
        (
        x
        I
        −
        A
        )
      
    
    {\displaystyle p(x)=\det(xI-A)}
  
称为方块矩陣
  
    
      
        A
      
    
    {\displaystyle A}
  
的特徵值多項式。这是一个由行列式定义的多项式，它的解是矩阵所有的特征值。换句话说，
  
    
      
        x
      
    
    {\displaystyle x}
  
是矩阵
  
    
      
        A
      
    
    {\displaystyle A}
  
的特征值当且仅当
  
    
      
        x
        I
        −
        A
      
    
    {\displaystyle xI-A}
  
不是可逆矩阵。特征值多项式在矩阵理论中有重要的应用。


= 行列式与多项式 =
早在高斯的时代，行列式就和多项式的研究联系在一起。行列式的一个应用是在所谓的“结式”上。结式是两个多项式
  
    
      
        
          p
        
      
    
    {\displaystyle \displaystyle p}
  
和
  
    
      
        
          q
        
      
    
    {\displaystyle \displaystyle q}
  
的西尔维斯特矩阵的行列式。两个多项式的结式等于0当且仅当它们有高于或等于一次的公因子多项式。结式还可以判断多项式是否有重根：如果多项式
  
    
      
        
          p
        
      
    
    {\displaystyle \displaystyle p}
  
和它的微分多项式
  
    
      
        
          
            p
            
              ′
            
          
        
      
    
    {\displaystyle \displaystyle p^{\prime }}
  
的结式不为零，那么这个多项式没有重根，否则有重根。
行列式在多项式逼近理论中也有出现。给定一组插值点，判别插值多项式的存在性需要看所谓的范德蒙矩阵，而由于范德蒙矩阵的行列式不为零，因此根据克莱姆法则，插值多项式唯一存在（次数小于插值点个数）。


= 朗斯基行列式 =

朗斯基行列式是函数矩阵的行列式，因此本身也是一个函数。给定n个n-1次连续可微函数，f1、...、fn，它们的朗斯基行列式W(f1, ..., fn)为：

  
    
      
        W
        (
        
          f
          
            1
          
        
        ,
        …
        ,
        
          f
          
            n
          
        
        )
        (
        t
        )
        =
        
          
            |
            
              
                
                  
                    f
                    
                      1
                    
                  
                  (
                  t
                  )
                
                
                  
                    f
                    
                      2
                    
                  
                  (
                  t
                  )
                
                
                  ⋯
                
                
                  
                    f
                    
                      n
                    
                  
                  (
                  t
                  )
                
              
              
                
                  
                    f
                    
                      1
                    
                    ′
                  
                  (
                  t
                  )
                
                
                  
                    f
                    
                      2
                    
                    ′
                  
                  (
                  t
                  )
                
                
                  ⋯
                
                
                  
                    f
                    
                      n
                    
                    ′
                  
                  (
                  t
                  )
                
              
              
                
                  ⋮
                
                
                  ⋮
                
                
                  ⋱
                
                
                  ⋮
                
              
              
                
                  
                    f
                    
                      1
                    
                    
                      (
                      n
                      −
                      1
                      )
                    
                  
                  (
                  t
                  )
                
                
                  
                    f
                    
                      2
                    
                    
                      (
                      n
                      −
                      1
                      )
                    
                  
                  (
                  t
                  )
                
                
                  ⋯
                
                
                  
                    f
                    
                      n
                    
                    
                      (
                      n
                      −
                      1
                      )
                    
                  
                  (
                  t
                  )
                
              
            
            |
          
        
      
    
    {\displaystyle W(f_{1},\ldots ,f_{n})(t)={\begin{vmatrix}f_{1}(t)&f_{2}(t)&\cdots &f_{n}(t)\\f_{1}'(t)&f_{2}'(t)&\cdots &f_{n}'(t)\\\vdots &\vdots &\ddots &\vdots \\f_{1}^{(n-1)}(t)&f_{2}^{(n-1)}(t)&\cdots &f_{n}^{(n-1)}(t)\end{vmatrix}}}
  

可以证明，如果f1、...、fn线性相关，那么它们的朗斯基行列式恒等于零。
在线性微分动力系统理论中，朗斯基行列式用来判别若干个解的线性相关性。如果n个解f1、...、fn线性无关，那么它们的朗斯基行列式将总不为零。根据刘维尔定理，n维空间上的线性微分方程：

  
    
      
        
          Y
          
            ′
          
        
        =
        A
        (
        t
        )
        Y
      
    
    {\displaystyle Y^{\prime }=A(t)Y}
  

的基础解系所构成的朗斯基行列式
  
    
      
        W
        (
        t
        )
      
    
    {\displaystyle W(t)}
  
满足：

  
    
      
        
          W
          ′
        
        (
        t
        )
        =
        
          
            t
            r
          
        
        
        A
        (
        t
        )
        W
        (
        t
        )
      
    
    {\displaystyle W'(t)={\rm {tr}}\,A(t)W(t)}
  
，
同样地，线性微分方程：

  
    
      
        
          y
          
            (
            n
            )
          
        
        =
        
          a
          
            0
          
        
        (
        t
        )
        y
        +
        
          a
          
            1
          
        
        (
        t
        )
        
          y
          ′
        
        +
        
          a
          
            2
          
        
        (
        t
        )
        
          y
          ″
        
        +
        .
        .
        .
        +
        
          a
          
            n
            −
            1
          
        
        (
        t
        )
        
          y
          
            (
            n
            −
            1
            )
          
        
        
      
    
    {\displaystyle y^{(n)}=a_{0}(t)y+a_{1}(t)y'+a_{2}(t)y''+...+a_{n-1}(t)y^{(n-1)}\,}
  
的基础解系所构成的朗斯基行列式
  
    
      
        W
        (
        t
        )
      
    
    {\displaystyle W(t)}
  
满足：

  
    
      
        
          W
          ′
        
        (
        t
        )
        =
        
          a
          
            n
            −
            1
          
        
        (
        t
        )
        W
        (
        t
        )
      
    
    {\displaystyle W'(t)=a_{n-1}(t)W(t)}
  


= 行列式与多重积分 =

行列式体现了线性变换对于空间体积的作用，对于非线性的函数，其对体积的影响更为复杂，但对于足够“良好”的函数，在一个微小的范围内，比如说在空间中一点的附近，可以将函数的效果近似地用线性的变换来代替。由此，对于某些函数，也可以将它在某一点附近的作用效果用它在这一点上的偏导数构成的矩阵（称为雅可比矩阵）来表示。这类行列式被称为“雅可比行列式”，即是雅可比矩阵的行列式，只对连续可微的函数有定义。
在计算“体积”的多重积分中，雅可比行列式应用于换元积分的时候。积分的思想是将空间割成许多个微小的体积元，称为积分元素，再将每个体积元上的函数值乘以体积元的体积后相加。将一个积分元素换为另一个积分元素时，实际上作了一次对空间中体积的度量方式的改变：分划体积元的方式不同了。譬如在二维空间中，将直角坐标积分换为极坐标积分时，面积元素由方块区域变成扇形区域。因此，要测量这种体积度量方式的改变，可以将这种变换看成一个非线性的变换函数（实际上是一个微分同胚）：
  
    
      
        φ
        :
        
          
            R
          
          
            n
          
        
        ⟶
        
          
            R
          
          
            n
          
        
      
    
    {\displaystyle \varphi :\mathbb {R} ^{n}\longrightarrow \mathbb {R} ^{n}}
  
。而它在每一点的影响可以通过雅可比行列式来体现。


= 行列式与非线性方程组及分枝理论 =

运用雅可比行列式的还有非线性方程组的数值求解。对于一般的非线性方程组，不存在求解公式，只能够用数值分析的方法求近似解。求近似解的基本思想也是将非线性问题在局部的地方逐步线性化，化归为线性方程组来求解。设有方程组：

  
    
      
        
          
            {
            
              
                
                  
                    f
                    
                      1
                    
                  
                  (
                  
                    x
                    
                      1
                    
                  
                  ,
                  
                    x
                    
                      2
                    
                  
                  ,
                  ⋯
                  ,
                  
                    x
                    
                      n
                    
                  
                  )
                  =
                  0
                
              
              
                
                  
                  ⋮
                  
                  
                  
                  ⋮
                  
                
              
              
                
                  
                    f
                    
                      n
                    
                  
                  (
                  
                    x
                    
                      1
                    
                  
                  ,
                  
                    x
                    
                      2
                    
                  
                  ,
                  ⋯
                  ,
                  
                    x
                    
                      n
                    
                  
                  )
                  =
                  0
                
              
            
            
          
        
      
    
    {\displaystyle {\begin{cases}f_{1}(x_{1},x_{2},\cdots ,x_{n})=0\\\quad \vdots \qquad \qquad \qquad \vdots \quad \\f_{n}(x_{1},x_{2},\cdots ,x_{n})=0\end{cases}}}
  

其中
  
    
      
        f
        =
        (
        
          f
          
            1
          
        
        ,
        ⋯
        ,
        
          f
          
            n
          
        
        )
      
    
    {\displaystyle f=(f_{1},\cdots ,f_{n})}
  
是连续可微函数，并在解的附近雅可比行列式不为零，那么可以用牛顿法迭代求得近似解。迭代程序为：

  
    
      
        f
        (
        
          x
          
            (
            k
            +
            1
            )
          
        
        )
        =
        
          x
          
            (
            k
            )
          
        
        −
        det
        (
        
          
            J
          
          
            f
          
        
        (
        
          x
          
            (
            k
            )
          
        
        )
        
          )
          
            −
            1
          
        
        f
        (
        
          x
          
            (
            k
            )
          
        
        )
        
        (
        k
        =
        0
        ,
        1
        ,
        ⋯
        )
      
    
    {\displaystyle f(x^{(k+1)})=x^{(k)}-\det(\mathbf {J} _{f}(x^{(k)}))^{-1}f(x^{(k)})\qquad (k=0,1,\cdots )}
  

其中的
  
    
      
        
          x
          
            (
            k
            )
          
        
        =
        (
        
          x
          
            1
          
          
            (
            k
            )
          
        
        ,
        
          x
          
            2
          
          
            (
            k
            )
          
        
        ,
        ⋯
        ,
        
          x
          
            n
          
          
            (
            k
            )
          
        
        )
      
    
    {\displaystyle x^{(k)}=(x_{1}^{(k)},x_{2}^{(k)},\cdots ,x_{n}^{(k)})}
  
是第
  
    
      
        k
      
    
    {\displaystyle k}
  
次迭代时的解的近似数值。每次迭代时先求解关于线性方程组

  
    
      
        
          
            J
          
          
            f
          
        
        (
        
          x
          
            (
            k
            )
          
        
        )
        Δ
        
          x
          
            (
            k
            )
          
        
        =
        f
        (
        
          x
          
            (
            k
            )
          
        
        )
      
    
    {\displaystyle \mathbf {J} _{f}(x^{(k)})\Delta x^{(k)}=f(x^{(k)})}
  

然后计算新的近似值

  
    
      
        
          x
          
            (
            k
            +
            1
            )
          
        
        =
        
          x
          
            (
            k
            )
          
        
        −
        Δ
        
          x
          
            (
            k
            )
          
        
      
    
    {\displaystyle x^{(k+1)}=x^{(k)}-\Delta x^{(k)}}
  

在实际应用中，还需要考虑带有参数的非线性方程组：

  
    
      
        
          
            {
            
              
                
                  
                    f
                    
                      1
                    
                  
                  (
                  
                    x
                    
                      1
                    
                  
                  ,
                  
                    x
                    
                      2
                    
                  
                  ,
                  ⋯
                  ,
                  
                    x
                    
                      n
                    
                  
                  ,
                  λ
                  )
                  =
                  0
                
              
              
                
                  
                  ⋮
                  
                  
                  
                  ⋮
                  
                
              
              
                
                  
                    f
                    
                      n
                    
                  
                  (
                  
                    x
                    
                      1
                    
                  
                  ,
                  
                    x
                    
                      2
                    
                  
                  ,
                  ⋯
                  ,
                  
                    x
                    
                      n
                    
                  
                  ,
                  λ
                  )
                  =
                  0
                
              
            
            
          
        
      
    
    {\displaystyle {\begin{cases}f_{1}(x_{1},x_{2},\cdots ,x_{n},\lambda )=0\\\quad \vdots \qquad \qquad \qquad \vdots \quad \\f_{n}(x_{1},x_{2},\cdots ,x_{n},\lambda )=0\end{cases}}}
  

其中的
  
    
      
        λ
      
    
    {\displaystyle \lambda }
  
可以代表温度、外力等环境因素。当环境改变时，方程解上的雅可比行列式可能从非零变为零。雅可比行列式为零的点称为临界点或分支点，是方程的解改变性质的地方。和线性方程组类似，当雅可比行列式的值为零时，方程组会出现局部多值的情况。寻找分支点和分支方向的研究是非线性方程求解的一大问题。


参见 参考文献 = 註釋 =


= 引用 =


= 来源 =
书籍
（英文）Michael Artin. Algebra. Prentice Hall. 2004. ISBN 7-111-13913-5. 
（法文）Henri Cartan. Cours de calcul differentiel. Paris, Hermann. 2007. ISBN 978-2-7056-6702-3. 
（英文）Harold M. Edwards. Linear Algebra. Springer-Verlag New York. 2004. ISBN 978-0-817-63731-6. 
（法文）Pierre Gabriel. Matrices, geometrie, algebre lineaire. Cassini. 2001. ISBN 2-842-25018-4. 
（中文）莫里斯·克莱因. 《古今数学思想》 第二卷. 由张理京、张锦炎、江泽涵翻译. 上海科学技术出版社. 2002. ISBN 7-5323-6172-1. 
（中文）莫里斯·克莱因. 《古今数学思想》 第三卷. 由张理京、张锦炎、江泽涵翻译. 上海科学技术出版社. 2002. ISBN 7-5323-6172-1. 
（英文）David Poole. Linear algebra: a modern introduction. Brooks Cole. 2005. ISBN 978-0-534-34174-9. 
（英文）Werner Hildbert Greub. linear algebra. Springer Verlag. 1975. ISBN 978-0-387-90110-7. 
（中文）居余马、林翠琴. 线性代数. 清华大学出版社. 2002. ISBN 978-7-302-06507-4. 
（中文）张贤科. 《高等代数学》 第二版. 清华大学出版社. 2002. ISBN 978-7-302-11088-0. 
（中文）胡冠章、王殿军. 《应用近世代数》. 清华大学出版社. 2006. ISBN 7-302-12566-X. 
（英文）Steven Roman. Advanced Linear Algebra. Springer. 2005. ISBN 0-387-24766-1. 
（中文）项武义. 基础代数学. 人民教育出版社. 2004. ISBN 7-107-17679-X. 
（英文）Gilbert Strang. Linear algebra and its applications. Thomson, Brooks/Cole, Belmont, CA. 2006. ISBN 9780534422004. 


外部連結 Online Matrix Calculator線上行列式計算器
Online Matrix Calculator （页面存档备份，存于互联网档案馆）線上矩陣計算器
《新理解矩阵5》：体积=行列式 （页面存档备份，存于互联网档案馆）来自科学空间