第4章代数结构上机练习答案

应用离散数学代数结构PAGE杭电－周丽、方景龙第四章PAGE3第4章代数结构上机练习编写下列程序并计算至少1个算例给定有限集合上的一个二元运算（给定运算表），判断这个运算是否满足交换律、结合律。程序代码defcheck_commutative(elements,op_table):"""判断二元运算是否满足交换律参数:elements:list，有限集合的元素列表op_table:list[list]，运算表，op_table[i][j]=elements[i]∘elements[j]返回:(bool,tuple)：第一个值为是否满足交换律；不满足时第二个值为反例(a,b)，满足时为None"""n=len(elements)foriinrange(n):forjinrange(n):ifop_table[i][j]!=op_table[j][i]:returnFalse,(elements[i],elements[j])returnTrue,Nonedefcheck_associative(elements,op_table):"""判断二元运算是否满足结合律参数:elements:list，有限集合的元素列表op_table:list[list]，运算表，op_table[i][j]=elements[i]∘elements[j]返回:(bool,tuple)：第一个值为是否满足结合律；不满足时第二个值为反例(a,b,c,左结果,右结果)，满足时为None"""n=len(elements)#建立元素到索引的映射，方便快速查找结果对应的行/列位置elem_to_idx={elem:idxforidx,eleminenumerate(elements)}foriinrange(n):a=elements[i]forjinrange(n):b=elements[j]#计算a∘b的结果及其索引ab_val=op_table[i][j]ab_idx=elem_to_idx[ab_val]forkinrange(n):c=elements[k]#计算(a∘b)∘cleft_val=op_table[ab_idx][k]#计算a∘(b∘c)bc_val=op_table[j][k]bc_idx=elem_to_idx[bc_val]right_val=op_table[i][bc_idx]ifleft_val!=right_val:returnFalse,(a,b,c,left_val,right_val)returnTrue,None#测试算例与运行入口if__name__=="__main__":#==========测试1：模3加法（满足交换律+结合律）==========print("===测试1：集合{0,1,2}上的模3加法===")elements1=[0,1,2]op_table1=[[0,1,2],[1,2,0],[2,0,1]]comm_res1,comm_counter1=check_commutative(elements1,op_table1)assoc_res1,assoc_counter1=check_associative(elements1,op_table1)print(f"交换律：{'满足'ifcomm_res1elsef'不满足，反例：{comm_counter1[0]}∘{comm_counter1[1]}≠{comm_counter1[1]}∘{comm_counter1[0]}'}")print(f"结合律：{'满足'ifassoc_res1elsef'不满足，反例：({assoc_counter1[0]}∘{assoc_counter1[1]})∘{assoc_counter1[2]}={assoc_counter1[3]}，{assoc_counter1[0]}∘({assoc_counter1[1]}∘{assoc_counter1[2]})={assoc_counter1[4]}'}")print()#==========测试2：左投影运算（不满足交换律，满足结合律）==========#运算规则：a∘b=a（取第一个运算元素）print("===测试2：集合{0,1,2}上的左投影运算（a∘b=a）===")elements2=[0,1,2]op_table2=[[0,0,0],[1,1,1],[2,2,2]]comm_res2,comm_counter2=check_commutative(elements2,op_table2)assoc_res2,assoc_counter2=check_associative(elements2,op_table2)print(f"交换律：{'满足'ifcomm_res2elsef'不满足，反例：{comm_counter2[0]}∘{comm_counter2[1]}={op_table2[elements2.index(comm_counter2[0])][elements2.index(comm_counter2[1])]}，{comm_counter2[1]}∘{comm_counter2[0]}={op_table2[elements2.index(comm_counter2[1])][elements2.index(comm_counter2[0])]}'}")print(f"结合律：{'满足'ifassoc_res2elsef'不满足，反例：({assoc_counter2[0]}∘{assoc_counter2[1]})∘{assoc_counter2[2]}={assoc_counter2[3]}，{assoc_counter2[0]}∘({assoc_counter2[1]}∘{assoc_counter2[2]})={assoc_counter2[4]}'}")print()#==========测试3：交换但不结合的运算==========print("===测试3：集合{a,b,c}上的交换但非结合运算===")elements3=['a','b','c']op_table3=[['a','b','c'],['b','a','a'],['c','a','a']]comm_res3,comm_counter3=check_commutative(elements3,op_table3)assoc_res3,assoc_counter3=check_associative(elements3,op_table3)print(f"交换律：{'满足'ifcomm_res3elsef'不满足，反例：{comm_counter3[0]}∘{comm_counter3[1]}≠{comm_counter3[1]}∘{comm_counter3[0]}'}")print(f"结合律：{'满足'ifassoc_res3elsef'不满足，反例：({assoc_counter3[0]}∘{assoc_counter3[1]})∘{assoc_counter3[2]}={assoc_counter3[3]}，{assoc_counter3[0]}∘({assoc_counter3[1]}∘{assoc_counter3[2]})={assoc_counter3[4]}'}")print()#==========测试4：交换律、结合律均不满足==========print("===测试4：集合{0,1,2}上的非交换非结合运算===")elements4=[0,1,2]op_table4=[[1,0,2],[2,1,0],[0,2,1]]comm_res4,comm_counter4=check_commutative(elements4,op_table4)assoc_res4,assoc_counter4=check_associative(elements4,op_table4)print(f"交换律：{'满足'ifcomm_res4elsef'不满足，反例：{comm_counter4[0]}∘{comm_counter4[1]}={op_table4[elements4.index(comm_counter4[0])][elements4.index(comm_counter4[1])]}，{comm_counter4[1]}∘{comm_counter4[0]}={op_table4[elements4.index(comm_counter4[1])][elements4.index(comm_counter4[0])]}'}")print(f"结合律：{'满足'ifassoc_res4elsef'不满足，反例：({assoc_counter4[0]}∘{assoc_counter4[1]})∘{assoc_counter4[2]}={assoc_counter4[3]}，{assoc_counter4[0]}∘({assoc_counter4[1]}∘{assoc_counter4[2]})={assoc_counter4[4]}'}")print()#==========测试5：单元素集合（边界情况，均满足）==========print("===测试5：单元素集合{e}上的运算===")elements5=['e']op_table5=[['e']]comm_res5,comm_counter5=check_commutative(elements5,op_table5)assoc_res5,assoc_counter5=check_associative(elements5,op_table5)print(f"交换律：{'满足'ifcomm_res5else'不满足'}")print(f"结合律：{'满足'ifassoc_res5else'不满足'}")测试算例===测试1：集合{0,1,2}上的模3加法===交换律：满足结合律：满足===测试2：集合{0,1,2}上的左投影运算（a∘b=a）===交换律：不满足，反例：0∘1=0，1∘0=1结合律：满足===测试3：集合{a,b,c}上的交换但非结合运算===交换律：满足结合律：不满足，反例：(b∘b)∘c=c，b∘(b∘c)=b===测试4：集合{0,1,2}上的非交换非结合运算===交换律：不满足，反例：0∘1=0，1∘0=2结合律：不满足，反例：(0∘1)∘2=2，0∘(1∘2)=1===测试5：单元素集合{e}上的运算===交换律：满足结合律：满足给定有限集合上的一个二元运算，求出它的单位元和零元。程序代码deffind_identity(elements,op_table):"""查找有限集合上二元运算的单位元参数:elements:list，有限集合的元素列表op_table:list[list]，运算表，op_table[i][j]=elements[i]∘elements[j]返回:单位元元素；不存在则返回None"""n=len(elements)foriinrange(n):candidate=elements[i]is_identity=Trueforjinrange(n):#验证左单位性：candidate∘x=xifop_table[i][j]!=elements[j]:is_identity=Falsebreak#验证右单位性：x∘candidate=xifop_table[j][i]!=elements[j]:is_identity=Falsebreakifis_identity:returncandidatereturnNonedeffind_zero(elements,op_table):"""查找有限集合上二元运算的零元参数:elements:list，有限集合的元素列表op_table:list[list]，运算表，op_table[i][j]=elements[i]∘elements[j]返回:零元元素；不存在则返回None"""n=len(elements)foriinrange(n):candidate=elements[i]is_zero=Trueforjinrange(n):#验证左零性：candidate∘x=candidateifop_table[i][j]!=candidate:is_zero=Falsebreak#验证右零性：x∘candidate=candidateifop_table[j][i]!=candidate:is_zero=Falsebreakifis_zero:returncandidatereturnNone#测试算例与运行入口if__name__=="__main__":#==========测试1：模4乘法（既有单位元又有零元）==========print("===测试1：集合{0,1,2,3}上的模4乘法===")elements1=[0,1,2,3]op_table1=[[0,0,0,0],[0,1,2,3],[0,2,0,2],[0,3,2,1]]id1=find_identity(elements1,op_table1)zero1=find_zero(elements1,op_table1)print(f"单位元：{id1}")print(f"零元：{zero1}")print()#==========测试2：模3加法（有单位元，无零元）==========print("===测试2：集合{0,1,2}上的模3加法===")elements2=[0,1,2]op_table2=[[0,1,2],[1,2,0],[2,0,1]]id2=find_identity(elements2,op_table2)zero2=find_zero(elements2,op_table2)print(f"单位元：{id2}")print(f"零元：{zero2}")print()#==========测试3：常值0运算（有零元，无单位元）==========#运算规则：对任意a,b，a∘b=0print("===测试3：集合{0,1,2}上的常值0运算===")elements3=[0,1,2]op_table3=[[0,0,0],[0,0,0],[0,0,0]]id3=find_identity(elements3,op_table3)zero3=find_zero(elements3,op_table3)print(f"单位元：{id3}")print(f"零元：{zero3}")print()#==========测试4：左投影运算（无单位元，无零元）==========#运算规则：a∘b=a（取第一个运算元素）print("===测试4：集合{0,1,2}上的左投影运算===")elements4=[0,1,2]op_table4=[[0,0,0],[1,1,1],[2,2,2]]id4=find_identity(elements4,op_table4)zero4=find_zero(elements4,op_table4)print(f"单位元：{id4}")print(f"零元：{zero4}")print()#==========测试5：单元素集合（边界情况，元素既是单位元也是零元）==========print("===测试5：单元素集合{e}上的运算===")elements5=['e']op_table5=[['e']]id5=find_identity(elements5,op_table5)zero5=find_zero(elements5,op_table5)print(f"单位元：{id5}")print(f"零元：{zero5}")测试算例===测试1：集合{0,1,2,3}上的模4乘法===单位元：1零元：0===测试2：集合{0,1,2}上的模3加法===单位元：0零元：None===测试3：集合{0,1,2}上的常值0运算===单位元：None零元：0===测试4：集合{0,1,2}上的左投影运算===单位元：None零元：None===测试5：单元素集合{e}上的运算===单位元：e零元：e给定一个有限半群，判断它是否是有幺半群，是否是群。程序代码defis_closed(elements,op_table):"""检查运算是否封闭：所有运算结果都属于集合"""elem_set=set(elements)forrowinop_table:forvalinrow:ifvalnotinelem_set:returnFalse,valreturnTrue,Nonedefis_associative(elements,op_table):"""检查运算是否满足结合律"""n=len(elements)elem_to_idx={elem:idxforidx,eleminenumerate(elements)}foriinrange(n):a=elements[i]forjinrange(n):b=elements[j]ab_val=op_table[i][j]ab_idx=elem_to_idx[ab_val]forkinrange(n):c=elements[k]#计算(a∘b)∘cleft_val=op_table[ab_idx][k]#计算a∘(b∘c)bc_val=op_table[j][k]bc_idx=elem_to_idx[bc_val]right_val=op_table[i][bc_idx]ifleft_val!=right_val:returnFalse,(a,b,c,left_val,right_val)returnTrue,Nonedeffind_identity(elements,op_table):"""查找运算的单位元，不存在则返回None"""n=len(elements)foriinrange(n):candidate=elements[i]is_identity=Trueforjinrange(n):ifop_table[i][j]!=elements[j]orop_table[j][i]!=elements[j]:is_identity=Falsebreakifis_identity:returncandidatereturnNonedefall_have_inverses(elements,op_table,identity):"""检查所有元素是否都存在双向逆元"""n=len(elements)elem_to_idx={elem:idxforidx,eleminenumerate(elements)}foriinrange(n):a=elements[i]has_inv=Falseforjinrange(n):ifop_table[i][j]==identityandop_table[j][i]==identity:has_inv=Truebreakifnothas_inv:returnFalse,a#返回无逆元的元素returnTrue,Nonedefget_inverse_map(elements,op_table,identity):"""构造每个元素到其逆元的映射"""n=len(elements)inv_map={}foriinrange(n):a=elements[i]forjinrange(n):ifop_table[i][j]==identityandop_table[j][i]==identity:inv_map[a]=elements[j]breakreturninv_mapdefcheck_algebraic_structure(elements,op_table):"""完整判定代数结构：半群？有幺半群？群？返回字典包含判定结果、单位元、逆元映射等信息"""#1.封闭性校验closed,bad_val=is_closed(elements,op_table)ifnotclosed:return{"is_semigroup":False,"is_monoid":False,"is_group":False,"reason":f"运算不封闭，结果{bad_val}不在集合中"}#2.结合律校验（半群核心条件）assoc,counter=is_associative(elements,op_table)ifnotassoc:a,b,c,left,right=counterreturn{"is_semigroup":False,"is_monoid":False,"is_group":False,"reason":f"不满足结合律：({a}∘{b})∘{c}={left}，{a}∘({b}∘{c})={right}"}#3.查找单位元，判定是否为有幺半群identity=find_identity(elements,op_table)is_monoid=identityisnotNone#4.校验逆元，判定是否为群is_group=Falseinverse_map=Noneno_inv_elem=Noneifis_monoid:has_all_inv,bad_elem=all_have_inverses(elements,op_table,identity)ifhas_all_inv:is_group=Trueinverse_map=get_inverse_map(elements,op_table,identity)else:no_inv_elem=bad_elemreturn{"is_semigroup":True,"is_monoid":is_monoid,"is_group":is_group,"identity":identity,"inverse_map":inverse_map,"no_inverse_element":no_inv_elem}#测试算例与运行入口if__name__=="__main__":#辅助打印函数defprint_result(name,res):print(f"==={name}===")ifnotres["is_semigroup"]:print(f"是否为半群：否，原因：{res['reason']}")else:print(f"是否为半群：是")print(f"是否为有幺半群：{'是，单位元='+str(res['identity'])ifres['is_monoid']else'否'}")ifres["is_group"]:print(f"是否为群：是，逆元映射：{res['inverse_map']}")else:ifres["no_inverse_element"]isnotNone:print(f"是否为群：否，元素{res['no_inverse_element']}不存在逆元")else:print("是否为群：否（无单位元）")print()#测试1：模3加法（典型群）elements1=[0,1,2]op_table1=[[0,1,2],[1,2,0],[2,0,1]]print_result("测试1：集合{0,1,2}上的模3加法",check_algebraic_structure(elements1,op_table1))#测试2：模4乘法（有幺半群，但不是群）elements2=[0,1,2,3]op_table2=[[0,0,0,0],[0,1,2,3],[0,2,0,2],[0,3,2,1]]print_result("测试2：集合{0,1,2,3}上的模4乘法",check_algebraic_structure(elements2,op_table2))#测试3：常值0运算（半群，无单位元）elements3=[0,1]op_table3=[[0,0],[0,0]]print_result("测试3：集合{0,1}上的常值0运算",check_algebraic_structure(elements3,op_table3))#测试4：左投影运算（半群，无单位元）elements4=[0,1,2]op_table4=[[0,0,0],[1,1,1],[2,2,2]]print_result("测试4：集合{0,1,2}上的左投影运算",check_algebraic_structure(elements4,op_table4))#测试5：单元素集合（平凡群）elements5=['e']op_table5=[['e']]print_result("测试5：单元素集合{e}",check_algebraic_structure(elements5,op_table5))#测试6：克莱因四元群elements6=['e','a','b','c']op_table6=[['e','a','b','c'],['a','e','c','b'],['b','c','e','a'],['c','b','a','e']]print_result("测试6：克莱因四元群",check_algebraic_structure(elements6,op_table6))测试算例===测试1：集合{0,1,2}上的模3加法===是否为半群：是是否为有幺半群：是，单位元=0是否为群：是，逆元映射：{0:0,1:2,2:1}===测试2：集合{0,1,2,3}上的模4乘法===是否为半群：是是否为有幺半群：是，单位元=1是否为群：否，元素0不存在逆元===测试3：集合{0,1}上的常值0运算===是否为半群：是是否为有幺半群：否是否为群：否（无单位元）===测试4：集合{0,1,2}上的左投影运算===是否为半群：是是否为有幺半群：否是否为群：否（无单位元）===测试5：单元素集合{e}===是否为半群：是是否为有幺半群：是，单位元=e是否为群：是，逆元映射：{'e':'e'}===测试6：克莱因四元群===是否为半群：是是否为有幺半群：是，单位元=e是否为群：是，逆元映射：{'e':'e','a':'a','b':'b','c':'c'}4．给定一个有限群，求每个元素的次数。（1）程序代码deffind_identity(elements,op_table):"""查找群的单位元（群的单位元唯一）"""n=len(elements)foriinrange(n):candidate=elements[i]is_identity=Trueforjinrange(n):ifop_table[i][j]!=elements[j]orop_table[j][i]!=elements[j]:is_identity=Falsebreakifis_identity:returncandidateraiseValueError("输入结构不存在单位元，不是群")defcompute_single_order(a,elements,op_table,identity):"""计算单个元素的阶"""elem_to_idx={elem:idxforidx,eleminenumerate(elements)}current=aorder=1#不断自乘，直到结果等于单位元whilecurrent!=identity:i=elem_to_idx[current]j=elem_to_idx[a]current=op_table[i][j]#current=current∘aorder+=1returnorderdefget_all_element_orders(elements,op_table):"""给定有限群的运算表，求每个元素的阶（次数）参数:elements:list，群的元素列表op_table:list[list]，运算表，op_table[i][j]=elements[i]∘elements[j]返回:dict，键为群元素，值为对应元素的阶"""identity=find_identity(elements,op_table)order_dict={}foreleminelements:order_dict[elem]=compute_single_order(elem,elements,op_table,identity)returnorder_dict#测试算例与运行入口if__name__=="__main__":defprint_orders(name,elements,op_table):print(f"==={name}===")orders=get_all_element_orders(elements,op_table)foreleminelements:print(f"元素{elem:>2}的阶：{orders[elem]}")print()#测试1：模3加法群（循环群Z₃）elements1=[0,1,2]op_table1=[[0,1,2],[1,2,0],[2,0,1]]print_orders("测试1：模3加法群Z₃",elements1,op_table1)#测试2：克莱因四元群K₄elements2=['e','a','b','c']op_table2=[['e','a','b','c'],['a','e','c','b'],['b','c','e','a'],['c','b','a','e']]print_orders("测试2：克莱因四元群K₄",elements2,op_table2)#测试3：模5乘法群（循环群Z₅*）elements3=[1,2,3,4]op_table3=[[1,2,3,4],[2,4,1,3],[3,1,4,2],[4,3,2,1]]print_orders("测试3：模5乘法群Z₅*",elements3,op_table3)#测试4：模4加法群Z₄elements4=[0,1,2,3]op_table4=[[0,1,2,3],[1,2,3,0],[2,3,0,1],[3,0,1,2]]print_orders("测试4：模4加法群Z₄",elements4,op_table4)#测试5：单元素平凡群elements5=['e']op_table5=[['e']]print_orders("测试5：单元素平凡群",elements5,op_table5)（2）测试算例===测试1：模3加法群Z₃===元素0的阶：1元素1的阶：3元素2的阶：3===测试2：克莱因四元群K₄===元素e的阶：1元素a的阶：2元素b的阶：2元素c的阶：2===测试3：模5乘法群Z₅*===元素1的阶：1元素2的阶：4元素3的阶：4元素4的阶：2===测试4：模4加法群Z₄===元素0的阶：1元素1的阶：4元素2的阶：2元素3的阶：4===测试5：单元素平凡群===元素e的阶：15．给定一个有限循环群，求出它的所有生成元。（1）程序代码deffind_identity(elements,op_table):"""查找群的单位元"""n=len(elements)foriinrange(n):candidate=elements[i]is_identity=Trueforjinrange(n):ifop_table[i][j]!=elements[j]orop_table[j][i]!=elements[j]:is_identity=Falsebreakifis_identity:returncandidateraiseValueError("输入结构不存在单位元，不是群")defcompute_single_order(a,elements,op_table,identity):"""计算单个元素的阶"""elem_to_idx={elem:idxforidx,eleminenumerate(elements)}current=aorder=1whilecurrent!=identity:i=elem_to_idx[current]j=elem_to_idx[a]current=op_table[i][j]#current=current∘aorder+=1returnorderdefget_cyclic_generators(elements,op_table):"""给定有限群，求其所有生成元；若不是循环群则返回空列表参数:elements:list，群的元素列表op_table:list[list]，运算表，op_table[i][j]=elements[i]∘elements[j]返回:list，所有生成元组成的列表"""n=len(elements)identity=find_identity(elements,op_table)generators=[]foreleminelements:elem_order=compute_single_order(elem,elements,op_table,identity)#元素阶等于群的阶→是生成元ifelem_order==n:generators.append(elem)returngenerators#测试算例与运行入口if__name__=="__main__":defprint_generators(name,elements,op_table):print(f"==={name}===")gens=get_cyclic_generators(elements,op_table)ifgens:print(f"群的阶：{len(elements)}，生成元共{len(gens)}个：{gens}")else:print(f"群的阶：{len(elements)}，该群不是循环群，无生成元")print()#测试1：模3加法群Z₃（3阶循环群）elements1=[0,1,2]op_table1=[[0,1,2],[1,2,0],[2,0,1]]print_generators("测试1：模3加法群Z₃",elements1,op_table1)#测试2：模4加法群Z₄（4阶循环群）elements2=[0,1,2,3]op_table2=[[0,1,2,3],[1,2,3,0],[2,3,0,1],[3,0,1,2]]print_generators("测试2：模4加法群Z₄",elements2,op_table2)#测试3：模5乘法群Z₅*（4阶循环群）elements3=[1,2,3,4]op_table3=[[1,2,3,4],[2,4,1,3],[3,1,4,2],[4,3,2,1]]print_generators("测试3：模5乘法群Z₅*",elements3,op_table3)#测试4：模6加法群Z₆（6阶循环群）elements4=[0,1,2,3,4,5]op_table4=[[0,1,2,3,4,5],[1,2,3,4,5,0],[2,3,4,5,0,1],[3,4,5,0,1,2],[4,5,0,1,2,3],[5,0,1,2,3,4]]print_generators("测试4：模6加法群Z₆",elements4,op_table4)#测试5：克莱因四元群（非循环群，反例）elements5=['e','a','b','c']op_table5=[['e','a','b','c'],['a','e','c','b'],['b','c','e','a'],['c','b','a','e']]print_generators("测试5：克莱因四元群（非循环群）",elements5,op_table5)#测试6：单元素平凡群（1阶循环群）elements6=['e']op_table6=[['e']]print_generators("测试6：单元素平凡群",elements6,op_table6)（2）测试算例===测试1：模3加法群Z₃===群的阶：3，生成元共2个：[1,2]===测试2：模4加法群Z₄===群的阶：4，生成元共2个：[1,3]===测试3：模5乘法群Z₅*===群的阶：4，生成元共2个：[2,3]===测试4：模6加法群Z₆===群的阶：6，生成元共2个：[1,5]===测试5：克莱因四元群（非循环群）===群的阶：4，该群不是循环群，无生成元===测试6：单元素平凡群===群的阶：1，生成元共1个：['e']6．给定一个有限循环群，求它的所有子群。（1）程序代码deffind_identity(elements,op_table):"""查找群的单位元"""n=len(elements)foriinrange(n):candidate=elements[i]is_identity=Trueforjinrange(n):ifop_table[i][j]!=elements[j]orop_table[j][i]!=elements[j]:is_identity=Falsebreakifis_identity:returncandidateraiseValueError("输入结构不存在单位元，不是群")defgenerate_subgroup(a,elements,op_table,identity):"""生成由元素a生成的循环子群"""elem_to_idx={elem:idxforidx,eleminenumerate(elements)}subgroup=set()current=identity#不断自乘，直到回到单位元，收集所有出现的元素whilecurrentnotinsubgroup:subgroup.add(current)i=elem_to_idx[current]j=elem_to_idx[a]current=op_table[i][j]#current=current∘areturnsubgroupdefget_all_subgroups(elements,op_table):"""给定有限群，求其所有循环子群；若输入为循环群，则返回全部子群参数:elements:list，群的元素列表op_table:list[list]，运算表，op_table[i][j]=elements[i]∘elements[j]返回:list[list]，每个子群以排序后的列表形式返回"""identity=find_identity(elements,op_table)subgroups_set=set()foreleminelements:sg=generate_subgroup(elem,elements,op_table,identity)subgroups_set.add(frozenset(sg))#用frozenset实现子群去重#转为排序后的列表，便于查看result=[sorted(list(sg))forsginsubgroups_set]#按子群大小排序输出result.sort(key=lambdax:len(x))returnresult#测试算例与运行入口if__name__=="__main__":defprint_subgroups(name,elements,op_table):print(f"==={name}===")subgroups=get_all_subgroups(elements,op_table)print(f"群的阶：{len(elements)}，共有{len(subgroups)}个子群：")foridx,sginenumerate(subgroups,1):print(f"子群{idx}（阶{len(sg)}）：{sg}")print()#测试1：模3加法群Z₃（3阶循环群）elements1=[0,1,2]op_table1=[[0,1,2],[1,2,0],[2,0,1]]print_subgroups("测试1：模3加法群Z₃",elements1,op_table1)#测试2：模4加法群Z₄（4阶循环群）elements2=[0,1,2,3]op_table2=[[0,1,2,3],[1,2,3,0],[2,3,0,1],[3,0,1,2]]print_subgroups("测试2：模4加法群Z₄",elements2,op_table2)#测试3：模6加法群Z₆（6阶循环群）elements3=[0,1,2,3,4,5]op_table3=[[0,1,2,3,4,5],[1,2,3,4,5,0],[2,3,4,5,0,1],[3,4,5,0,1,2],[4,5,0,1,2,3],[5,0,1,2,3,4]]print_subgroups("测试3：模6加法群Z₆",elements3,op_table3)#测试4：模5乘法群Z₅*（4阶循环群）elements4=[1,2,3,4]op_table4=[[1,2,3,4],[2,4,1,3],[3,1,4,2],[4,3,2,1]]print_subgroups("测试4：模5乘法群Z₅*",elements4,op_table4)#测试5：单元素平凡群（1阶循环群）elements5=['e']op_table5=[['e']]print_subgroups("测试5：单元素平凡群",elements5,op_table5)（2）算例测试===测试1：模3加法群Z₃===群的阶：3，共有2个子群：子群1（阶1）：[0]子群2（阶3）：[0,1,2]===测试2：模4加法群Z₄===群的阶：4，共有3个子群：子群1（阶1）：[0]子群2（阶2）：[0,2]子群3（阶4）：[0,1,2,3]===测试3：模6加法群Z₆===群的阶：6，共有4个子群：子群1（阶1）：[0]子群2（阶2）：[0,3]子群3（阶3）：[0,2,4]子群4（阶6）：[0,1,2,3,4,5]===测试4：模5乘法群Z₅*===群的阶：4，共有3个子群：子群1（阶1）：[1]子群2（阶2）：[1,4]子群3（阶4）：[1,2,3,4]===测试5：单元素平凡群===群的阶：1，共有1个子群：子群1（阶1）：['e']7．给定一个有限群以及这个有限群集合的一个子集，判断这个子集是否构成子群。（1）程序代码defis_subgroup(group_elements,op_table,subset):"""判断有限群的子集是否构成子群参数:group_elements:list，原有限群的元素列表op_table:list[list]，原群的运算表，op_table[i][j]=group_elements[i]∘group_elements[j]subset:list，待判定的子集返回:(bool,str)：第一个值为是否构成子群；第二个值为判定说明/不满足原因"""#1.校验：子集非空ifnotsubset:returnFalse,"子集为空，不构成子群"group_set=set(group_elements)subset_set=set(subset)#2.校验：子集所有元素都属于原群foreleminsubset_set:ifelemnotingroup_set:returnFalse,f"元素{elem}不属于原群，不是合法子集"#建立元素→索引的映射，用于快速查表elem_to_idx={elem:idxforidx,eleminenumerate(group_elements)}subset_list=list(subset_set)#3.校验：运算封闭性——任意两个元素的运算结果仍在子集中foriinrange(len(subset_list)):a=subset_list[i]a_idx=elem_to_idx[a]forjinrange(len(subset_list)):b=subset_list[j]b_idx=elem_to_idx[b]result=op_table[a_idx][b_idx]ifresultnotinsubset_set:returnFalse,f"运算不封闭：{a}∘{b}={result}，结果不在子集中"#有限群非空+运算封闭→构成子群returnTrue,"满足子群所有条件，构成子群"#测试算例与运行入口if__name__=="__main__":defprint_test(name,group_elems,op_table,subset):res,reason=is_subgroup(group_elems,op_table,subset)print(f"==={name}===")print(f"待判子集：{subset}")print(f"判定结果：{'是子群'ifreselse'不是子群'}")print(f"说明：{reason}")print()#==========公共测试群1：模6加法群Z6==========z6_elems=[0,1,2,3,4,5]z6_table=[[0,1,2,3,4,5],[1,2,3,4,5,0],[2,3,4,5,0,1],[3,4,5,0,1,2],[4,5,0,1,2,3],[5,0,1,2,3,4]]#测试1：3阶子群{0,2,4}print_test("测试1：Z6的子集{0,2,4}",z6_elems,z6_table,[0,2,4])#测试2：2阶子群{0,3}print_test("测试2：Z6的子集{0,3}",z6_elems,z6_table,[0,3])#测试3：不封闭子集{0,1}print_test("测试3：Z6的子集{0,1}",z6_elems,z6_table,[0,1])#测试4：平凡子群（仅单位元）print_test("测试4：Z6的平凡子群{0}",z6_elems,z6_table,[0])#测试5：整个群（非平凡子群）print_test("测试5：Z6的全集",z6_elems,z6_table,z6_elems)#测试6：含非法元素的子集print_test("测试6：含非法元素的子集{0,6}",z6_elems,z6_table,[0,6])#测试7：空集print_test("测试7：空集",z6_elems,z6_table,[])#==========公共测试群2：克莱因四元群K4==========k4_elems=['e','a','b','c']k4_table=[['e','a','b','c'],['a','e','c','b'],['b','c','e','a'],['c','b','a','e']]#测试8：克莱因四元群的2阶子群{e,a}print_test("测试8：K4的子集{e,a}",k4_elems,k4_table,['e','a'])#测试9：克莱因四元群的不封闭子集{e,a,b}print_test("测试9：K4的子集{e,a,b}",k4_elems,k4_table,['e','a','b'])（2）算例测试===测试1：Z6的子集{0,2,4}===待判子集：[0,2,4]判定结果：是子群说明：满足子群所有条件，构成子群===测试2：Z6的子集{0,3}===待判子集：[0,3]判定结果：是子群说明：满足子群所有条件，构成子群===测试3：Z6的子集{0,1}===待判子集：[0,1]判定结果：不是子群说明：运算不封闭：1∘1=2，结果不在子集中===测试4：Z6的平凡子群{0}===待判子集：