【群论】群论入门

一、什么是群论？

群论（Group Theory）是抽象代数（Abstract Algebra）的核心分支，研究一种代数结构——群（Group）。它起源于对多项式方程求解的对称性研究，由数学家伽罗瓦（Évariste Galois）在19世纪创立，如今广泛应用于密码学、编码理论、量子物理、计算机科学、图形学、组合数学等领域。

---

二、群的定义（Group）

2.1 形式化定义

一个群是一个二元组 $(G,\ast )$，其中：

• $G$ 是一个非空集合
• $\ast$ 是定义在 $G$ 上的一个二元运算（称为“群运算”）

并且满足以下四个公理（Axioms）：

公理	数学表达	说明
1. 封闭性（Closure）	$\forall a,b\in G,a\ast b\in G$	运算结果仍在集合内
2. 结合律（Associativity）	$\forall a,b,c\in G,(a\ast b)\ast c=a\ast (b\ast c)$	运算顺序不影响结果
3. 单位元（Identity）	$\exists e\in G,\forall a\in G,a\ast e=e\ast a=a$	存在“0”或“1”类元素
4. 逆元（Inverse）	$\forall a\in G,\exists a^{-1}\in G,a\ast a^{-1}=a^{-1}\ast a=e$	每个元素都有“相反数”

✅ 如果还满足交换律（$\forall a,b\in G,a\ast b=b\ast a$），则称为阿贝尔群（Abelian Group）或交换群。

---

三、经典群的例子

3.1 整数加法群 $(\mathbb{Z},+)$

• 集合：所有整数 $\mathbb{Z}$
• 运算：加法 $+$
• 单位元：$0$
• 逆元：$a$ 的逆元是 $-a$
• 是阿贝尔群 ✅

3.2 非零实数乘法群 $({\mathbb{R}}^{\ast },\times )$

• 集合：R∖{0}\mathbb{R} \setminus \{0\}R∖{0}
• 运算：乘法 $\times$
• 单位元：$1$
• 逆元：$a$ 的逆元是 $1/a$
• 是阿贝尔群 ✅

3.3 模 $n$ 加法群 $({\mathbb{Z}}_n,{+}_n)$

• 集合：{0,1,2,…,n−1}\{0, 1, 2, \dots, n-1\}{0,1,2,…,n−1}
• 运算：模 $n$ 加法，$a{+}_{n}b=(a+b)\mathrm{mod}n$
• 单位元：$0$
• 逆元：$a$ 的逆元是 $n-a$（当 $a\ne 0$）
• 是阿贝尔群 ✅

3.4 置换群（Symmetric Group $S_n$）

• 集合：所有 $n$ 个元素的排列（双射函数）
• 运算：函数复合 $\circ$
• 单位元：恒等排列 $(1,2,3,\dots ,n)$
• 逆元：排列的逆排列
• 当 $n\ge 3$ 时，不是阿贝尔群 ❌

例如 $S_3$ 有 $3!=6$ 个元素。

---

四、群的阶（Order）

• 群的阶：群 $G$ 中元素的个数，记作 $|G|$。

  • 若 $|G|$ 有限，称为有限群。
  • 否则称为无限群。

• 元素的阶：元素 $a\in G$ 的阶是最小正整数 $k$，使得 $a^k=e$（$a^k$ 表示 $a$ 自运算 $k$ 次）。

---

五、子群（Subgroup）

如果 $H\subseteq G$ 且 $(H,\ast )$ 本身也构成一个群，则称 $H$ 是 $G$ 的子群，记作 $H\le G$。

判定定理（One-Step Subgroup Test）

$H\subseteq G$ 是子群 iff：

• $H$ 非空
• $\forall a,b\in H,a\ast b^{-1}\in H$

---

六、循环群（Cyclic Group）

如果存在一个元素 $g\in G$，使得 G={gk∣k∈Z}G = \{g^k \mid k \in \mathbb{Z}\}G={gk∣k∈Z}，则称 $G$ 是循环群，$g$ 称为生成元。

• 所有循环群都是阿贝尔群。
• 有限循环群同构于 $({\mathbb{Z}}_n,{+}_n)$。

---

七、群同构（Group Isomorphism）

两个群 $(G,\ast )$ 和 $(H,\cdot )$ 是同构的，如果存在一个双射函数 $\varphi :G\to H$，满足：
$$\varphi (a\ast b)=\varphi (a)\cdot \varphi (b),\forall a,b\in G$$
这表示两个群在代数结构上“完全一样”。

---

八、C++ 实现：有限群的抽象与操作

我们将用 C++ 实现一个有限群的通用框架，支持：

• 定义群元素
• 定义群运算
• 查找单位元、逆元
• 计算元素阶
• 验证是否为群

#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <functional>
#include <algorithm>
using namespace std;

// ============ 群模板类 ============
template<typename T>
class Group {
public:
    vector<T> elements;                      // 群元素
    function<T(T, T)> op;                    // 群运算
    T identity;                              // 单位元
    function<T(T)> inverse;                  // 求逆函数

    // 构造函数
    Group(const vector<T>& elems,
          const function<T(T, T)>& operation,
          const T& id,
          const function<T(T)>& inv)
        : elements(elems), op(operation), identity(id), inverse(inv) {}

    // ============ 公理验证 ============

    // 1. 验证封闭性
    bool check_closure() {
        for (const T& a : elements) {
            for (const T& b : elements) {
                T result = op(a, b);
                if (find(elements.begin(), elements.end(), result) == elements.end()) {
                    return false;
                }
            }
        }
        return true;
    }

    // 2. 验证结合律
    bool check_associativity() {
        for (const T& a : elements) {
            for (const T& b : elements) {
                for (const T& c : elements) {
                    T left  = op(op(a, b), c);
                    T right = op(a, op(b, c));
                    if (left != right) return false;
                }
            }
        }
        return true;
    }

    // 3. 验证单位元
    bool check_identity() {
        for (const T& a : elements) {
            if (op(a, identity) != a || op(identity, a) != a) {
                return false;
            }
        }
        return true;
    }

    // 4. 验证逆元
    bool check_inverses() {
        for (const T& a : elements) {
            T inv_a = inverse(a);
            if (find(elements.begin(), elements.end(), inv_a) == elements.end()) {
                return false; // 逆元不在群中
            }
            if (op(a, inv_a) != identity || op(inv_a, a) != identity) {
                return false;
            }
        }
        return true;
    }

    // 验证是否为群
    bool is_group() {
        return check_closure() &&
               check_associativity() &&
               check_identity() &&
               check_inverses();
    }

    // ============ 群操作 ============

    // 计算元素 a 的阶
    int order_of_element(const T& a) {
        if (a == identity) return 1;
        T current = a;
        int k = 1;
        while (current != identity) {
            current = op(current, a);
            k++;
            if (k > elements.size()) break; // 防止无限循环
        }
        return (current == identity) ? k : -1; // -1 表示未找到
    }

    // 判断是否为阿贝尔群
    bool is_abelian() {
        for (const T& a : elements) {
            for (const T& b : elements) {
                if (op(a, b) != op(b, a)) {
                    return false;
                }
            }
        }
        return true;
    }

    // 判断是否为循环群（暴力搜索生成元）
    bool is_cyclic() {
        for (const T& g : elements) {
            set<T> generated;
            T current = g;
            do {
                generated.insert(current);
                current = op(current, g);
            } while (current != g && generated.size() <= elements.size());

            if (generated.size() == elements.size()) {
                cout << "生成元: " << g << endl;
                return true;
            }
        }
        return false;
    }

    // 打印乘法表（Cayley Table）
    void print_cayley_table() {
        int width = 5;
        cout << "\n群乘法表:\n";
        // 打印表头
        cout << setw(width) << "*";
        for (const T& e : elements) {
            cout << setw(width) << e;
        }
        cout << endl;

        for (const T& a : elements) {
            cout << setw(width) << a;
            for (const T& b : elements) {
                cout << setw(width) << op(a, b);
            }
            cout << endl;
        }
    }
};

---

九、实例：模 5 加法群 $({\mathbb{Z}}_5,{+}_5)$

int main() {
    // 定义 Z_5 = {0,1,2,3,4} under mod 5 addition
    vector<int> z5 = {0, 1, 2, 3, 4};

    auto add_mod5 = [](int a, int b) -> int {
        return (a + b) % 5;
    };

    int id = 0;

    auto inv_mod5 = [](int a) -> int {
        return (5 - a) % 5;
    };

    Group<int> Z5(z5, add_mod5, id, inv_mod5);

    cout << "Z_5 是群: " << (Z5.is_group() ? "是" : "否") << endl;
    cout << "是阿贝尔群: " << (Z5.is_abelian() ? "是" : "否") << endl;
    cout << "是循环群: " << (Z5.is_cyclic() ? "是" : "否") << endl;

    Z5.print_cayley_table();

    cout << "\n元素阶:\n";
    for (int x : z5) {
        cout << "ord(" << x << ") = " << Z5.order_of_element(x) << endl;
    }

    return 0;
}

输出：

Z_5 是群: 是
是阿贝尔群: 是
是循环群: 是
生成元: 1
生成元: 2
生成元: 3
生成元: 4

群乘法表:
    *    0    1    2    3    4
    0    0    1    2    3    4
    1    1    2    3    4    0
    2    2    3    4    0    1
    3    3    4    0    1    2
    4    4    0    1    2    3

元素阶:
ord(0) = 1
ord(1) = 5
ord(2) = 5
ord(3) = 5
ord(4) = 5

---

十、群论在计算机科学中的应用

应用领域	群论作用
密码学	RSA、椭圆曲线密码学（ECC）基于有限域和群的离散对数问题
编码理论	纠错码（如BCH码）利用有限域上的群结构
算法设计	Burnside 引理、Pólya 计数用于计算对称性下的组合方案数
图形学	三维旋转群 $SO(3)$ 描述物体旋转
量子计算	量子门操作构成酉群（Unitary Group）

---

十一、Burnside 引理（应用实例）

用于计算在群作用下的轨道数（不同构对象数）。

Burnside 引理：
$$\text{轨道数}=\frac{1}{|G|}\sum _{g\in G}|\text{Fix}(g)|$$
其中 $\text{Fix}(g)$ 是在置换 $g$ 下保持不变的对象数。

可用于解决“用 $k$ 种颜色给 $n$ 个珠子的项链染色，考虑旋转对称，有多少种不同方案？”等问题。

---

十二、总结

• 群是满足封闭性、结合律、单位元、逆元的代数结构。
• 有限群可用 C++ 建模，支持公理验证、阶计算、同构判断。
• 循环群、阿贝尔群、置换群是重要特例。
• 群论在密码学、算法、物理等领域有深刻应用。
• C++ 实现展示了如何将抽象数学结构转化为可计算对象。