从‘旋转时钟’到‘整数模n’：手把手用Python代码验证群同构与同态（附完整代码）

从‘旋转时钟’到‘整数模n’：手把手用Python代码验证群同构与同态

数学中的群论概念常常让人望而生畏，尤其是同构和同态这样的抽象关系。但当我们用代码将它们具象化时，这些概念会突然变得清晰可见。本文将带你用Python构建两个具体的群结构——"旋转时钟"群和"整数模n"群，然后编写函数来验证它们之间的同态和同构关系。

1. 构建基础群结构

在开始验证群关系之前，我们需要先实现两个具体的群结构。第一个是"旋转时钟"群，它模拟了时钟指针旋转的行为；第二个是"整数模n"群，它处理整数在模n下的加法。

1.1 实现旋转时钟群

旋转时钟群可以看作是一个有限循环群，其中每个元素代表时钟的一个旋转位置。对于12小时制的时钟，这个群有12个元素：

class ClockGroup: def __init__(self, hours=12): self.hours = hours self.elements = list(range(hours)) def operation(self, a, b): """ 定义群运算：旋转a后再旋转b """ return (a + b) % self.hours 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: for b in self.elements: for c in self.elements: if self.operation(self.operation(a, b), c) != \ self.operation(a, self.operation(b, c)): return False # 单位元 identity = 0 for a in self.elements: if self.operation(a, identity) != a or \ self.operation(identity, a) != a: return False # 逆元 for a in self.elements: has_inverse = False for b in self.elements: if self.operation(a, b) == identity and \ self.operation(b, a) == identity: has_inverse = True break if not has_inverse: return False return True

1.2 实现整数模n加法群

整数模n加法群是另一个常见的循环群例子，它的元素是0到n-1的整数，运算是模n加法：

class IntegerModGroup: def __init__(self, n): self.n = n self.elements = list(range(n)) def operation(self, a, b): """ 定义群运算：模n加法 """ return (a + b) % self.n def is_group(self): """ 验证是否满足群的定义 """ # 验证过程与ClockGroup类似，此处省略 return True # 假设验证通过

2. 群同态验证

群同态是指两个群之间存在一个保持运算的映射。这个映射不一定是双射，但必须满足f(a·b) = f(a)·f(b)。

2.1 定义同态验证函数

我们可以编写一个通用函数来验证任意两个群之间的给定映射是否是同态：

def is_homomorphism(group1, group2, mapping_func): """ 验证mapping_func是否是group1到group2的同态 :param group1: 第一个群 :param group2: 第二个群 :param mapping_func: 映射函数，接受group1的元素，返回group2的元素 :return: 如果是同态返回True，否则返回False """ for a in group1.elements: for b in group1.elements: # 计算group1中a·b的映射 mapped_ab = mapping_func(group1.operation(a, b)) # 计算group2中f(a)·f(b) mapped_a_mapped_b = group2.operation(mapping_func(a), mapping_func(b)) if mapped_ab != mapped_a_mapped_b: return False return True

2.2 实际同态示例

让我们构造一个具体的同态例子。考虑12小时制时钟群和4小时制时钟群之间的映射：

# 创建12小时和4小时时钟群 clock12 = ClockGroup(12) clock4 = ClockGroup(4) # 定义映射函数：将12小时映射到4小时，每3小时对应1小时 def mapping_12_to_4(hour): return hour // 3 # 验证同态 print("映射是否是同态:", is_homomorphism(clock12, clock4, mapping_12_to_4))

这个映射将12小时制时钟的每3个小时对应到4小时制时钟的1个小时。例如：

• 0,1,2 → 0
• 3,4,5 → 1
• 6,7,8 → 2
• 9,10,11 → 3

3. 群同构验证

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

3.1 定义同构验证函数

def is_isomorphism(group1, group2, mapping_func): """ 验证mapping_func是否是group1到group2的同构 :param group1: 第一个群 :param group2: 第二个群 :param mapping_func: 映射函数，接受group1的元素，返回group2的元素 :return: 如果是同构返回True，否则返回False """ # 首先验证是否是同态 if not is_homomorphism(group1, group2, mapping_func): return False # 检查是否是双射 mapped_elements = [mapping_func(a) for a in group1.elements] # 检查单射：不同的元素映射到不同的元素 if len(set(mapped_elements)) != len(group1.elements): return False # 检查满射：group2的每个元素都被映射到 if set(mapped_elements) != set(group2.elements): return False return True

3.2 实际同构示例

考虑6小时制时钟群和整数模6加法群之间的同构：

# 创建6小时时钟群和整数模6群 clock6 = ClockGroup(6) int_mod6 = IntegerModGroup(6) # 定义同构映射：恒等映射 def identity_mapping(x): return x # 验证同构 print("恒等映射是否是同构:", is_isomorphism(clock6, int_mod6, identity_mapping))

在这个例子中，两个群实际上是相同的数学结构，只是解释不同。恒等映射显然是一个双射，并且保持运算。

4. 更复杂的同构案例

让我们看一个不那么明显的同构例子：3小时制时钟群和整数模3加法群之间的同构，但使用非恒等映射。

4.1 构建非平凡同构

# 创建3小时时钟群和整数模3群 clock3 = ClockGroup(3) int_mod3 = IntegerModGroup(3) # 定义一个非恒等的双射 def non_identity_mapping(x): return (x * 2) % 3 # 0→0, 1→2, 2→1 # 验证同构 print("非恒等映射是否是同构:", is_isomorphism(clock3, int_mod3, non_identity_mapping))

这个映射将：

• 0 → 0
• 1 → 2
• 2 → 1

虽然看起来不同，但它实际上是一个有效的同构，因为运算关系被保持。例如：

• 在clock3中：1 + 2 = 0
• 映射后：f(1)=2, f(2)=1
• 在int_mod3中：2 + 1 = 0
• 直接映射结果：f(0)=0

5. 可视化群关系

为了更直观地理解这些群之间的关系，我们可以使用Python的matplotlib库来可视化群的运算表和映射关系。

5.1 绘制群运算表

import matplotlib.pyplot as plt import numpy as np def plot_group_table(group, title): size = len(group.elements) table = np.zeros((size, size), dtype=int) for i, a in enumerate(group.elements): for j, b in enumerate(group.elements): table[i, j] = group.operation(a, b) fig, ax = plt.subplots() ax.imshow(table, cmap='Blues') # 显示数值 for i in range(size): for j in range(size): ax.text(j, i, table[i, j], ha='center', va='center', color='black') ax.set_xticks(range(size)) ax.set_yticks(range(size)) ax.set_xticklabels(group.elements) ax.set_yticklabels(group.elements) ax.set_xlabel('Second element') ax.set_ylabel('First element') ax.set_title(title) plt.show() # 绘制6小时时钟群的运算表 plot_group_table(clock6, "6-Hour Clock Group Operation Table")

5.2 可视化同构映射

我们可以修改上面的函数来同时显示两个群的运算表，并用箭头表示映射关系：

def plot_isomorphism(group1, group2, mapping_func, title): size = len(group1.elements) # 创建图形 fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 6)) # 绘制第一个群的运算表 table1 = np.zeros((size, size), dtype=int) for i, a in enumerate(group1.elements): for j, b in enumerate(group1.elements): table1[i, j] = group1.operation(a, b) ax1.imshow(table1, cmap='Blues') ax1.set_title(f"{title} - Group 1") # 绘制第二个群的运算表 table2 = np.zeros((size, size), dtype=int) for i, a in enumerate(group2.elements): for j, b in enumerate(group2.elements): table2[i, j] = group2.operation(a, b) ax2.imshow(table2, cmap='Greens') ax2.set_title(f"{title} - Group 2") # 添加映射关系文本 for i in range(size): ax1.text(size+0.5, i, f"→ {mapping_func(group1.elements[i])}", ha='left', va='center', color='red') plt.tight_layout() plt.show() # 可视化同构映射 plot_isomorphism(clock3, int_mod3, non_identity_mapping, "Isomorphism Example")

6. 实际应用与扩展

理解了群同态和同构的概念后，我们可以探索一些实际应用和扩展方向。

6.1 密码学中的应用

群论在密码学中有广泛应用，特别是在构造一些基于离散对数问题的加密系统中。同构的概念可以帮助我们理解不同加密系统之间的等价关系。

例如，考虑以下两个群：

1. 乘法群：{1, 2, 4}，模7，运算为乘法
2. 加法群：{0, 1, 2}，模3，运算为加法

我们可以验证它们之间的同构关系：

# 定义乘法群 class MultiplicativeGroup: def __init__(self, elements, modulus): self.elements = elements self.modulus = modulus def operation(self, a, b): return (a * b) % self.modulus # 创建乘法群和加法群 mult_group = MultiplicativeGroup([1, 2, 4], 7) add_group = IntegerModGroup(3) # 定义对数映射 def log_mapping(x): # 1→0, 2→1, 4→2 return {1:0, 2:1, 4:2}[x] # 验证同构 print("对数映射是否是同构:", is_isomorphism(mult_group, add_group, log_mapping))

6.2 自动验证任意有限群

我们可以扩展我们的代码框架，使其能够处理任意有限群的同态和同构验证。这需要更通用的群表示方法：

class FiniteGroup: def __init__(self, elements, operation_table): """ :param elements: 群元素列表 :param operation_table: 运算表，operation_table[i][j] = elements[i]·elements[j] """ self.elements = elements self.op_table = operation_table self.element_to_index = {e:i for i,e in enumerate(elements)} def operation(self, a, b): a_idx = self.element_to_index[a] b_idx = self.element_to_index[b] return self.elements[self.op_table[a_idx][b_idx]] # 示例：创建对称群S3 # 元素可以表示为排列，这里简化为字符串表示 s3_elements = ['e', 'a', 'b', 'c', 'd', 'f'] s3_table = [ [0, 1, 2, 3, 4, 5], # e [1, 0, 4, 5, 2, 3], # a [2, 5, 0, 4, 3, 1], # b [3, 4, 5, 0, 1, 2], # c [4, 3, 1, 2, 5, 0], # d [5, 2, 3, 1, 0, 4] # f ] s3_group = FiniteGroup(s3_elements, s3_table)

6.3 寻找群之间的所有同态

对于小型群，我们可以编写算法来枚举所有可能的映射，然后检查哪些是同态：

from itertools import product def find_all_homomorphisms(group1, group2): """ 查找从group1到group2的所有可能的同态 :return: 返回所有满足同态条件的映射函数列表 """ homomorphisms = [] # 生成所有可能的映射 for possible_map in product(group2.elements, repeat=len(group1.elements)): mapping = dict(zip(group1.elements, possible_map)) # 定义映射函数 def mapping_func(x, m=mapping): return m[x] # 验证是否是同态 if is_homomorphism(group1, group2, mapping_func): homomorphisms.append(mapping) return homomorphisms # 查找从clock3到int_mod3的所有同态 all_homs = find_all_homomorphisms(clock3, int_mod3) print("从3小时时钟群到整数模3群的所有同态:") for hom in all_homs: print(hom)