从‘旋转魔方’到‘开关电路’：手把手用Python代码验证群同构与同态

群论作为抽象代数的核心分支，其价值不仅体现在数学理论的严谨性上，更在于它能够揭示不同领域之间深层次的结构相似性。本文将带领读者通过Python代码，从具体的群实例出发，亲手验证群同构与同态关系，让抽象概念变得触手可及。

1. 群论基础与Python实现

在开始验证同构与同态之前，我们需要先理解群的基本定义，并用Python代码来表示群。一个群(G, *)由以下四个性质定义：

1. 封闭性 ：对于任意a, b ∈ G，a * b ∈ G
2. 结合律 ：对于任意a, b, c ∈ G，(a * b) * c = a * (b * c)
3. 单位元 ：存在e ∈ G，使得对于任意a ∈ G，e * a = a * e = a
4. 逆元 ：对于任意a ∈ G，存在a⁻¹ ∈ G，使得a * a⁻¹ = a⁻¹ * a = e

让我们用Python定义一个通用的群类：

class Group:
    def __init__(self, elements, operation, identity, inverse_func):
        self.elements = elements
        self.operation = operation
        self.identity = identity
        self.inverse = inverse_func
    
    def is_group(self):
        # 验证封闭性
        for a in self.elements:
            for b in self.elements:
                if self.operation(a, b) not in self.elements:
                    return False
        
        # 验证单位元
        for a in self.elements:
            if self.operation(a, self.identity) != a or self.operation(self.identity, a) != a:
                return False
        
        # 验证逆元
        for a in self.elements:
            a_inv = self.inverse(a)
            if self.operation(a, a_inv) != self.identity or self.operation(a_inv, a) != self.identity:
                return False
        
        # 验证结合律需要检查所有三元组，这里简化验证
        # 实际应用中可能需要更严谨的验证
        return True

2. 构建具体群实例

2.1 正三角形旋转群(D₃)

正三角形的旋转对称群D₃包含6个元素：恒等旋转(0°)、顺时针旋转120°、240°，以及关于三条对称轴的翻转。我们可以用Python表示这个群：

# 定义旋转和翻转操作
identity = lambda x: x  # 恒等变换
rot120 = lambda x: (x + 120) % 360  # 顺时针旋转120°
rot240 = lambda x: (x + 240) % 360  # 顺时针旋转240°
flip1 = lambda x: (-x) % 360  # 关于垂直对称轴翻转
flip2 = lambda x: (120 - x) % 360  # 关于另一对称轴翻转
flip3 = lambda x: (240 - x) % 360  # 关于第三条对称轴翻转

d3_elements = [identity, rot120, rot240, flip1, flip2, flip3]

def d3_operation(f, g):
    return lambda x: f(g(x))  # 函数复合代表群运算

def d3_inverse(f):
    # 找到逆函数
    for g in d3_elements:
        if all(f(g(x)) == identity(x) and g(f(x)) == identity(x) for x in [0, 120, 240]):
            return g
    return None

d3_group = Group(d3_elements, d3_operation, identity, d3_inverse)
print("D₃是一个群:", d3_group.is_group())  # 应输出True

2.2 模3整数加法群(ℤ₃)

模3整数加法群包含元素{0, 1, 2}，群运算为模3加法：

z3_elements = [0, 1, 2]

def z3_operation(a, b):
    return (a + b) % 3

def z3_inverse(a):
    return (3 - a) % 3

z3_group = Group(z3_elements, z3_operation, 0, z3_inverse)
print("ℤ₃是一个群:", z3_group.is_group())  # 应输出True

2.3 电路开关群

考虑一个由三个开关组成的电路系统，每个开关有两种状态(开/关)，群运算为按位异或：

from itertools import product

# 用元组表示三个开关的状态，0表示关，1表示开
switch_elements = list(product([0,1], repeat=3))

def switch_operation(a, b):
    return tuple((x + y) % 2 for x, y in zip(a, b))

def switch_inverse(a):
    return a  # 在这个群中，每个元素都是自己的逆元

switch_group = Group(switch_elements, switch_operation, (0,0,0), switch_inverse)
print("开关电路是一个群:", switch_group.is_group())  # 应输出True

3. 验证群同态

群同态是指两个群之间保持群运算的函数。具体来说，对于群(G, *)和群(H, ·)，函数f: G → H是一个同态，如果对于所有a, b ∈ G，有：

f(a * b) = f(a) · f(b)

让我们编写一个函数来验证两个群之间的同态关系：

def is_homomorphism(G, H, f):
    """验证f是否是G到H的群同态"""
    for a in G.elements:
        for b in G.elements:
            # 检查f(a*b) == f(a)·f(b)
            if H.operation(f(a), f(b)) != f(G.operation(a, b)):
                return False
    return True

3.1 验证D₃到ℤ₂的同态

我们可以定义一个从D₃到ℤ₂的同态，将旋转映射到0，翻转映射到1：

z2_elements = [0, 1]
z2_group = Group(z2_elements, lambda x,y: (x+y)%2, 0, lambda x: x)

def d3_to_z2(f):
    # 如果是旋转(包括恒等)，映射到0；如果是翻转，映射到1
    test_value = 0  # 任意测试值
    result = f(test_value)
    if result == test_value or result == (test_value + 120) % 360 or result == (test_value + 240) % 360:
        return 0
    else:
        return 1

print("D₃到ℤ₂的映射是同态:", is_homomorphism(d3_group, z2_group, d3_to_z2))  # 应输出True

3.2 验证ℤ₃到开关电路群的同态

我们可以定义一个从ℤ₃到三开关电路群的同态：

def z3_to_switch(a):
    # 将0映射到(0,0,0)，1映射到(1,0,0)，2映射到(0,1,0)
    return [(0,0,0), (1,0,0), (0,1,0)][a]

print("ℤ₃到开关电路群的映射是同态:", 
      is_homomorphism(z3_group, switch_group, z3_to_switch))  # 应输出True

4. 验证群同构

群同构是一种特殊的同态，它要求映射是双射（既单射又满射）。我们可以扩展同态验证函数来检查同构：

def is_isomorphism(G, H, f):
    """验证f是否是G到H的群同构"""
    # 首先检查是否是同态
    if not is_homomorphism(G, H, f):
        return False
    
    # 检查单射：不同的元素映射到不同的元素
    images = set()
    for a in G.elements:
        img = f(a)
        if img in images:
            return False
        images.add(img)
    
    # 检查满射：H的每个元素都是某个G元素的像
    if len(images) != len(H.elements):
        return False
    
    return True

4.1 验证ℤ₃与旋转子群的同构

考虑D₃中仅包含旋转的子群（恒等、120°、240°旋转），它与ℤ₃同构：

rotations = [identity, rot120, rot240]
rotation_group = Group(rotations, d3_operation, identity, d3_inverse)

def rotation_to_z3(f):
    # 恒等映射到0，rot120映射到1，rot240映射到2
    if f(0) == 0:
        return 0
    elif f(0) == 120:
        return 1
    else:
        return 2

print("旋转子群与ℤ₃同构:", 
      is_isomorphism(rotation_group, z3_group, rotation_to_z3))  # 应输出True

4.2 验证开关电路群与ℤ₂×ℤ₂×ℤ₂的同构

三开关电路群实际上与三个ℤ₂的直积同构：

# 定义ℤ₂×ℤ₂×ℤ₂群
def z2_product_operation(a, b):
    return tuple((x + y) % 2 for x, y in zip(a, b))

z2_product_elements = list(product([0,1], repeat=3))
z2_product_group = Group(z2_product_elements, z2_product_operation, (0,0,0), lambda x: x)

# 恒等映射
def switch_to_z2product(a):
    return a

print("开关电路群与ℤ₂×ℤ₂×ℤ₂同构:", 
      is_isomorphism(switch_group, z2_product_group, switch_to_z2product))  # 应输出True

5. 应用实例：群论在密码学中的体现

群同构的概念在密码学中有重要应用。例如，Diffie-Hellman密钥交换协议的安全性依赖于特定群的同构性质。让我们看一个简化的例子：

# 定义乘法群ℤ₅* (1,2,3,4，模5乘法)
z5_star_elements = [1, 2, 3, 4]

def z5_star_operation(a, b):
    return (a * b) % 5

def z5_star_inverse(a):
    # 找到乘法逆元
    for x in z5_star_elements:
        if (a * x) % 5 == 1:
            return x
    return None

z5_star_group = Group(z5_star_elements, z5_star_operation, 1, z5_star_inverse)

# 这个群与加法群ℤ₄同构
z4_elements = [0, 1, 2, 3]
z4_group = Group(z4_elements, lambda x,y: (x+y)%4, 0, lambda x: (4 - x)%4)

# 定义同构映射：2是ℤ₅*的生成元
def z5_star_to_z4(a):
    # 计算2的几次方等于a
    power = 0
    current = 1
    while current != a:
        current = (current * 2) % 5
        power += 1
    return power

print("ℤ₅*与ℤ₄同构:", is_isomorphism(z5_star_group, z4_group, z5_star_to_z4))  # 应输出True

这个同构关系说明了为什么离散对数问题在ℤ₅*中是容易计算的（因为与ℤ₄同构），但在更大的群中可能变得困难，这直接影响了密码系统的安全性。