def membership_index(candidate, schreier_graphs, base, identity, key = None):
if key is None:
ordering = base + [x for x in range(1, len(identity) + 1) if x not in base]
key = ordering_to_key(ordering)
index = 0
siftee = candidate
total = group_size(schreier_graphs)
for num, schreier_graph in zip(base, schreier_graphs):
image = num**siftee
des = 0
orbit_size = 0
for graph_index, group_ele in enumerate(schreier_graph):
set_ele = graph_index + 1
if group_ele is not None:
orbit_size += 1
if key(set_ele**(candidate)) < key(num**candidate):
des += 1
coset_size = total // orbit_size
index += coset_size * des
total = total // orbit_size
coset_rep = _coset_rep_inverse(image, schreier_graph, identity)
if coset_rep is None:
break
siftee = siftee * coset_rep
if siftee != identity:
return -1
else:
return index
def min_gen_group(cls, gens, ordering=None):
size = len(gens[0])
if ordering is None or len(ordering) < size:
ordering = list(range(1, size + 1))
G = Group.fixed_base_group(gens, ordering)
eles = G._list_elements(key=ordering_to_key(ordering))
cur_gens = [eles[1]]
cur_G = Group.fixed_base_group(cur_gens, ordering)
for ele in eles:
if ele not in cur_G:
cur_gens.append(ele)
cur_G = Group.fixed_base_group(cur_gens, ordering)
if cur_G.order() == G.order():
break
return cls(cur_gens)
def test_element_at_index(self):
cf = Permutation.read_cycle_form
a = cf([[1, 2, 3,4,5]],5)
b = cf([[1,2,3]], 5)
e = cf([],5)
ordering = [3,5,2,1,4]
base, _, _, graphs = schreier_sims_algorithm_fixed_base([a,b], ordering, e)
full_group = []
ele_key = ordering_to_key(ordering)
perm_key = ordering_to_perm_key(ordering)
for index in range(group_size(graphs)):
full_group.append(element_at_index(base, graphs, index, e, key=ele_key))
ordered_group = sorted(full_group, key = perm_key)
#for x,y in zip(full_group, ordered_group):
#print("{!s:<20} {!s:<20}".format(x,y))
self.assertEqual(full_group, ordered_group)
def element_at_index(base, schreier_graphs, index, identity, key = None):
if key is None:
ordering = base + [x for x in range(1, len(identity) + 1) if x not in base]
key = ordering_to_key(ordering)
cand = identity
total = group_size(schreier_graphs)
for schreier_graph in schreier_graphs:
image_cands = [((i+1) ** (cand ** -1), i+1) for i, g in enumerate(schreier_graph) if g is not None]
image_cands.sort(key = lambda x: key(x[0]))#should be quickselect instead but may be over engeneered?!
num_cands = len(image_cands)
des = (index * num_cands)//total
total = total // num_cands
index = index % total
coset_rep = _coset_rep_inverse(image_cands[des][1], schreier_graph, identity)
cand = cand * coset_rep
return cand**-1
def test_memebership_index(self):
cf = Permutation.read_cycle_form
a = cf([[1, 2, 3,4,5]],5)
b = cf([[1,2,3]], 5)
c = cf([[1,2]], 5)
e = cf([],5)
ordering = [3,5,2,1,4]
base, _, _, graphs = schreier_sims_algorithm_fixed_base([a,b], ordering, e)
S5_base, _, _, S5_graphs = schreier_sims_algorithm_fixed_base([a,c], ordering, e)
real_group = []
S5_group = []
ele_key = ordering_to_key(ordering)
perm_key = ordering_to_perm_key(ordering)
for index in range(group_size(S5_graphs)):
S5_group.append(element_at_index(S5_base, S5_graphs, index, e, key=ele_key))
self.assertEquals(len(S5_group), 120)
self.assertEquals(S5_group, sorted(S5_group, key = perm_key))
for index in range(group_size(graphs)):
real_group.append(element_at_index(base, graphs, index, e, key=ele_key))
self.assertEquals(len(real_group), 60)
self.assertEquals(real_group, sorted(real_group, key = perm_key))
for ele in S5_group:
cand_index = membership_index(ele, graphs, base, e, key = ele_key)
if cand_index > -1:
#print("{}: {} {}?".format(cand_index, ele, real_group[cand_index]))
self.assertTrue(ele in real_group)
self.assertEquals(real_group[cand_index], ele)
else:
self.assertFalse(ele in real_group)
from group import PermGroup as Group
from coset_property import CosetProperty as Prop
from coset_property import PermutationCommuterProperty
import sims_search
from ordering import ordering_to_key, ordering_to_perm_key
#Set up group generators
cf = Permutation.read_cycle_form
a = cf([[2,3],[4,6],[5,8],[9,11]], 13)
b = cf([[1,2,4,7,9,3,5,6,8,10,11,12,13]], 13)
#Define ordering of base elements
fix = [1,3,5,9,7,11,2,12,4,6,8,10,13]
#Define corresponding key functions on numbers and perms based on base element ordering
key_single = ordering_to_key(fix)
key_perm = ordering_to_perm_key(fix)
#Construct group
G = Group.fixed_base_group([a,b],fix)
#Find all elements in order
#Print the base and stab orbits of G.
print(G.base)
level_orbits = []
for level in range(len(G.base)):
to_check = sorted(G.orbit(G.base[level],level), key = key_single)
level_orbits.append(to_check)
print(to_check)
#Set up the modulo values for a naive traversal.
