def generate_d4():
return CoxeterGroup.generate({
'r': p.Permutation([2, 1, 3, 4]),
's': p.Permutation([1, 3, 2, 4]),
't': p.Permutation([1, 2, 4, 3]),
'u': p.Permutation([1, 2, -4, -3])
})
def generate_d5():
return CoxeterGroup.generate({
'r': p.Permutation([2, 1, 3, 4, 5]),
's': p.Permutation([1, 3, 2, 4, 5]),
't': p.Permutation([1, 2, 4, 3, 5]),
'u': p.Permutation([1, 2, 3, 5, 4]),
'v': p.Permutation([1, 2, 3, -5, -4])
})
def testGeneratesAllElementsA1(self):
group = c.generate_a1()
expected_lookup = {
p.Permutation([1, 2]): 'e',
p.Permutation([2, 1]): 's'
}
self.assertEqual(group.name_lookup, expected_lookup)
def generate_g2():
return CoxeterGroup.generate({
'r': p.Permutation([1, 1]),
's': p.Permutation([1, -2])
})
# G_2
# Coxeter.set_identity(CoxeterTypeGRepresentation.new([0, 1]), "e")
# r = Coxeter.add_generator(CoxeterTypeGRepresentation.new([0, -1]), "r")
# s = Coxeter.add_generator(CoxeterTypeGRepresentation.new([1, -1]), "s")
def testGeneratesAllElementsA2(self):
group = c.generate_a2()
expected_lookup = {
p.Permutation([1, 2, 3]): 'e',
p.Permutation([2, 1, 3]): 'r',
p.Permutation([1, 3, 2]): 's',
p.Permutation([2, 3, 1]): 'rs',
p.Permutation([3, 1, 2]): 'sr',
p.Permutation([3, 2, 1]): 'rsr'
}
self.assertEqual(group.name_lookup, expected_lookup)
e = group['e']
r = group['r']
s = group['s']
rs = group['rs']
sr = group['sr']
rsr = group['rsr']
self.assertEqual(r * r, e)
self.assertEqual(s * s, e)
self.assertEqual(r * s, rs)
self.assertEqual(s * r, sr)
self.assertEqual(sr * r, s)
self.assertEqual(rs * s, r)
self.assertEqual(s * sr, r)
self.assertEqual(r * rs, s)
self.assertEqual(r * s * r, rsr)
self.assertEqual(s * r * s, rsr)
self.assertEqual(rs * r, rsr)
self.assertEqual(r * sr, rsr)
self.assertEqual(s * rs, rsr)
self.assertEqual(sr * s, rsr)
def testInverse(self):
identity = p.Permutation([1, 2, 3])
permutation = p.Permutation([1, 2, 3])
self.assertEqual(permutation * permutation.inverse(), identity)
permutation = p.Permutation([3, 2, 1])
self.assertEqual(permutation * permutation.inverse(), identity)
permutation = p.Permutation([2, 3, 1])
self.assertEqual(permutation * permutation.inverse(), identity)
identity = p.Permutation([1, 2, 3, 4, 5, 6, 7, 8])
permutation = p.Permutation([5, 6, 3, 1, 2, 8, 4, 7])
self.assertEqual(permutation * permutation.inverse(), identity)
def testEquality(self):
self.assertEqual(p.Permutation([3, 2, 1]), p.Permutation([3, 2, 1]))
self.assertNotEqual(p.Permutation([3, 2, 1]), p.Permutation([3, 1, 2]))
self.assertNotEqual(p.Permutation([3, 2, 1]), p.Permutation([2, 1]))
def testHash(self):
# Crappy test, but still
self.assertNotEqual(hash(p.Permutation([1, 2, 3])),
hash(p.Permutation([3, 2, 1])))
def testLen(self):
self.assertEqual(len(p.Permutation([3, 4, 2, 1])), 4)
def testComposition(self):
result = (p.Permutation([2, 1, 3]) * p.Permutation([1, 3, 2]))
self.assertEqual(result, p.Permutation([2, 3, 1]))
def testGenerateFailsOnBadInput(self):
self.assertRaises(Exception, c.CoxeterGroup.generate, {
'a': p.Permutation([1]),
'b': p.Permutation([2, 1])
})
def testGenerateReturnsIdentity(self):
group = c.generate_a1()
self.assertTrue('e' in group.elements)
self.assertEquals(group.name_lookup[p.Permutation([1, 2])], 'e')
def generate(generators):
"""
Generates a group from a dictionary of generators
{ name: permutation }.
:param generators:
:return:
"""
sorted_generators = sc.SortedDict(generators)
elements = dict()
permutations = dict()
name_lookup = dict()
inverses = dict()
group = CoxeterGroup(generators, elements, permutations, name_lookup,
inverses)
lengths = set([len(v) for v in generators.values()])
if len(lengths) != 1:
raise Exception(
f'Generators should all have the same length (lengths: {lengths})'
)
seen_permutations = set()
# Add identity
identity_permutation = p.Permutation(
list(range(1,
list(lengths)[0] + 1)))
elements['e'] = CoxeterElement(group, 'e', 0)
group.identity = elements['e']
permutations['e'] = identity_permutation
seen_permutations.add(identity_permutation)
# Add generators
for name, permutation in sorted_generators.items():
elements[name] = CoxeterElement(group, name, len(elements))
seen_permutations.add(permutation)
permutations[name] = permutation
# Generate the rest of the elements
last_layer = generators
nrloops = 0
while len(last_layer) > 0:
new_permutations = dict()
for name, permutation in last_layer.items():
for gname, generator in sorted_generators.items():
new_name = name + gname
new_permutation = permutation * generator
if not new_permutation in seen_permutations:
permutations[new_name] = new_permutation
seen_permutations.add(new_permutation)
elements[new_name] = CoxeterElement(
group, new_name, len(elements))
new_permutations[new_name] = new_permutation
last_layer = new_permutations
nrloops += 1
for name, permutation in permutations.items():
name_lookup[permutation] = name
# Calculate inverses
for name, permutation in permutations.items():
inverse = identity_permutation
inverse_name = name[::-1] # Reversed string
for generator in inverse_name:
inverse = inverse * permutations[generator]
inverses[name] = elements[name_lookup[inverse]]
# Add identity and longest element
group.identity = elements['e']
longest_name = sorted(elements.keys(), key=lambda x: (len(x), x))[-1]
group.longest = elements[longest_name]
return group
def generate_b3():
return CoxeterGroup.generate({
'r': p.Permutation([2, 1, 3]),
's': p.Permutation([1, 3, 2]),
't': p.Permutation([1, 2, -3])
})
def generate_b2():
return CoxeterGroup.generate({
'r': p.Permutation([2, 1]),
's': p.Permutation([1, -2])
})
def generate_a1():
return CoxeterGroup.generate({'s': p.Permutation([2, 1])})
