1

假设我有一个组 G={a,b,e} 其中 a,b 是任意元素，e 表示中性元素。我想出了一个特定的 Cayley 表，并想通过检查关联性来验证我所做的是否正确。

这意味着我想检查 G 中 x(yz)=(xy)z 的任意 x,y,z，因为我必须手动检查 3*3*3 = 27 个案例，这简直是疯了。

到目前为止，我的编码工作并没有走得太远，我很感激一些提示或优雅的方法来解决这个问题。我是 python 的初学者，但对循环和函数有基本的了解。

我对程序的想法：

我定义了一个函数，可以说组，它将字符串作为输入。我通过 .extend(string) 函数将字符串添加到某个列表中，这使我可以一一分析给定的输入。

通过 if 语句让我们说：

if checklist[0] == "a" and checklist[1] == "b":
    checklist.pop[0]
    checklist[0] = "e"

我可以先删除列表的第一个条目，然后用所需的新值替换它。我确实继续这样添加越来越多的 if 语句，最后递归地再次调用我的函数，如果我的清单的长度等于 1，它将终止。

然而，这不是一个非常优雅的代码，它也会遇到特殊情况的问题。因此，我相信我的努力是徒劳的，我应该相信有一个更简单、更优雅的解决方案来解决这个问题。我希望你能帮助我引导我找到正确的方向。

代码示例（不完整但概念性）：

checklist = []

def group(abc):
    if len(checklist) == 1:
        return checklist
    else:
        checklist.extend(abc)
        if (checklist[0] == "a" and checklist[1] == "a"):
            checklist.pop(0)
            checklist[0] = "b"
        if (checklist[0] == "a" and checklist[1] == "b"):
            checklist.pop(0)
            checklist[0] = "e"
        if (checklist[0] == "a" and checklist[1] == "e"):
            checklist.pop(0)
            checklist[0] = "a"
        if (checklist[0] == "b" and checklist[1] == "a"):
            checklist.pop(0)
            checklist[0] == "e"
        if (checklist[0] == "b" and checklist[1] == "b"):
            checklist.pop(0)
            checklist[0] = "a"
        if (checklist[0] == "b" and checklist[1] == "e"):
            checklist.pop(0)
            checklist[0] = "b"
        if (checklist[0] == "e" and checklist[1] == "a"):
            checklist.pop(0)
            checklist[0] = "a"
        if (checklist[0] == "e" and checklist[1] == "b"):
            checklist.pop(0)
            checklist[0] = "b"
        if (checklist[0] == "e" and checklist[1] == "e"):
            checklist.pop(0)
            checklist[0] = "e"
        group(checklist)
        return checklist
4

2 回答 2

2

我只是itertools.product用来生成组中的每个三元组元素并检查三元组是否具有关联性x, y, z。G

您可以定义一个函数来检查您对特定三元组的组操作是否是关联的，然后依次检查组中每个可能的三元组。如果"associativity fails..."打印，则G在您的组操作下不关联。

import itertools

G = [0, 1, 2, 3, 4, 5] # or whatever your group might be

def is_associative(x, y, z):
    if (x*y)*z == x*(y*z):
        return True
    return False

xyz = itertools.product(G, repeat=3)

for three in xyz:
    if not is_associative(*three):
         print("associativity fails for %s, %s, %s") % three

显然，在 的定义中is_associative，您希望替换*为您的组操作。

于 2014-10-12T18:08:31.437 回答
1

你想要的看起来像这样：

def is_associative(m, G):
    return sum( [m(m(a,b),c)!=m(a,m(b,c)) for a in G for b in G for c in G])==0

你给它一个函数 m 和一个列表 G，其中 m:(G,G)-->G

如果使用任意 m 和 G 在（不）等于测试中，这可能会变坏。

让我们看看我们是否可以使用R ^3中的 (i,j,k) 向量和叉积来完成这项工作

import numpy

def is_associative(m, equals, G):
    # count the unassociative triplets, return true if count is zero
    return sum( [\
                     not equals(m(m(a,b),c), m(a,m(b,c)) ) \
                     for a in G for b in G for c in G\
                 ])==0


# classic non-associative example in R^3

# G is 0 vector and unit vectors
G = [ [0,0,0], [1,0,0], [0,1,0], [0,0,1] ]

# m is cross product 
def m(a,b):
    return numpy.cross(a,b)

def vector_equals(a,b):
    return (a[0]==b[0]) and (a[1]==b[1]) and (a[2]==b[2])

for a in G:
    print a

print "Associative: "+str(is_associative(m, vector_equals, G))

输出：[0, 0, 0] [1, 0, 0] [0, 1, 0] [0, 0, 1] 关联：假

你可能想知道为什么一个有限群是非关联的，所以我们可以稍微改变一下来完成它，如下所示：

首先，我们将定义一个 test_associative 函数，它不仅返回真/假，还返回导致它为假的三元组。然后，我们将调用它并解压缩结果。

导入 numpy

def test_associative(m, equals, G):
    # find the unassociative triplets
    # return (true,[]) if count is zero
    # return (false, array_of_unassociative_triplets)
    unassociative_triplets = [ (a,b,c)\
                     for a in G for b in G for c in G\
                     if not equals(m(m(a,b),c), m(a,m(b,c)) ) \
                 ]
    return (len(unassociative_triplets)==0, unassociative_triplets)


# classic non-associative example in R^3

# G is 0 vector and unit vectors
G = [ [0,0,0], [1,0,0], [0,1,0], [0,0,1] ]

# m is cross product 
def m(a,b):
    return numpy.cross(a,b)

def vector_equals(a,b):
    return (a[0]==b[0]) and (a[1]==b[1]) and (a[2]==b[2])

print "Elements of G:"

for a in G:
    print a

print "m() is the vector cross product x"

(is_associative, whynot) = test_associative(m, vector_equals, G)

print "Associative: "+str(is_associative)

if not is_associative:
    print "Non-associative triplets:"
    for triplet in whynot:
        print str(triplet)+\
            " (a*b)*c : "+str(m(m(triplet[0],triplet[1]), triplet[2]))+\
            " a*(b*c) : "+str(m(triplet[0],m(triplet[1], triplet[2])))

输出：

Elements of G:
[0, 0, 0]
[1, 0, 0]
[0, 1, 0]
[0, 0, 1]
m() is the vector cross product x
Associative: False
Non-associative triplets:
([1, 0, 0], [1, 0, 0], [0, 1, 0]) (a*b)*c : [0 0 0] a*(b*c) : [ 0 -1  0]
([1, 0, 0], [1, 0, 0], [0, 0, 1]) (a*b)*c : [0 0 0] a*(b*c) : [ 0  0 -1]
([1, 0, 0], [0, 1, 0], [0, 1, 0]) (a*b)*c : [-1  0  0] a*(b*c) : [0 0 0]
([1, 0, 0], [0, 0, 1], [0, 0, 1]) (a*b)*c : [-1  0  0] a*(b*c) : [0 0 0]
([0, 1, 0], [1, 0, 0], [1, 0, 0]) (a*b)*c : [ 0 -1  0] a*(b*c) : [0 0 0]
([0, 1, 0], [0, 1, 0], [1, 0, 0]) (a*b)*c : [0 0 0] a*(b*c) : [-1  0  0]
([0, 1, 0], [0, 1, 0], [0, 0, 1]) (a*b)*c : [0 0 0] a*(b*c) : [ 0  0 -1]
([0, 1, 0], [0, 0, 1], [0, 0, 1]) (a*b)*c : [ 0 -1  0] a*(b*c) : [0 0 0]
([0, 0, 1], [1, 0, 0], [1, 0, 0]) (a*b)*c : [ 0  0 -1] a*(b*c) : [0 0 0]
([0, 0, 1], [0, 1, 0], [0, 1, 0]) (a*b)*c : [ 0  0 -1] a*(b*c) : [0 0 0]
([0, 0, 1], [0, 0, 1], [1, 0, 0]) (a*b)*c : [0 0 0] a*(b*c) : [-1  0  0]
([0, 0, 1], [0, 0, 1], [0, 1, 0]) (a*b)*c : [0 0 0] a*(b*c) : [ 0 -1  0]

使用乘法表而不是函数只是将表表示为 python 数组并让 m 在数组中查找结果。Python 索引具有从 0 到 length-1 的整数的数组，并且您可以在数组中包含数组。您将需要有限群 G 和 {0,1,..., ||G||-1} 之间的同构

于 2014-10-12T18:26:06.890 回答