def classical_groups(m):
"""Returns list of classical groups, such that \pi(G) is contained in the
set of first m primes.
"""
ret = []
primes = first_primes(m)
set_primes = set(primes)
for p in primes:
for n in range(1, m + 2):
t = _min_power(p, n, primes)
for alpha in range(1, t + 1):
field = Field(p, alpha)
to_check = []
if n >= 2 and (n, field.order) not in [(2, 2), (2, 3)]:
to_check.append(ClassicalGroup("PSL", n, field))
if (n, field.order) != (1, 2):
if n > 1:
to_check.append(ClassicalGroup("PSU", 2 * n, field))
to_check.append(ClassicalGroup("PSU", 2 * n + 1, field))
if n >= 2 and field.char % 2 == 1:
to_check.append(ClassicalGroup("Omega", 2 * n + 1, field))
if n >= 3:
to_check.append(
ClassicalGroup("POmega+", 2 * (n + 1), field))
to_check.append(
ClassicalGroup("POmega-", 2 * (n + 1), field))
if n >= 2:
to_check.append(ClassicalGroup("PSp", 2 * n, field))
valid = lambda group: _prime_factors(group.order()
) <= set_primes
ret.extend(filter(valid, to_check))
ret.sort(
key=lambda group: (max(group.order().factors.keys()), group.order()))
return ret
def print_max_elems():
for dimension in xrange(4, 36):
group = ClassicalGroup("Omega+", 2 * dimension, 4)
dim_expansion = " + ".join(
[str(x) for x in numeric.binary_expansion(dimension)])
print "{}:".format(group).ljust(12),
print "n = {} = {}".format(dimension, dim_expansion).ljust(30)
print
for elem in max_orders_wrapped(group, StringViewFormatter.VERBOSE):
print str(elem).ljust(len(str(elem)) + 5).rjust(60), sorted(
elem.object.partition, reverse=True)
print
def selected_group(self):
"""Returns currently selected group
"""
if self._group_type.get() == "Alternating":
self._alt_degree.refresh_input()
return AlternatingGroup(self._alt_degree.get_number())
if self._group_type.get() == "Classical":
self._clas_dim.refresh_input()
self._clas_field.refresh_input()
return ClassicalGroup(self._clas_type.variable.get(),
self._clas_dim.get_number(), self._clas_field.get_number())
if self._group_type.get() == "Sporadic":
return SporadicGroup(self._sporadic_group.variable.get())
if self._group_type.get() == "Exceptional":
self._ex_field.refresh_input()
return ExceptionalGroup(self._ex_type.variable.get(), self._ex_field.get_number())
def test_symplectic(self, n):
group = ClassicalGroup("Sp", 2 * n, 2)
max_elems = max_orders.maximal_orders(group)
max_elems_2 = maximal_orders(group, 2)
self.assertEqual(max_elems[0], max_elems_2[0])
self.assertEqual(max_elems[1], max_elems_2[1])
def test_classical_orders(self, params):
g = ClassicalGroup(*params)
order = orders_data.classical_orders_data[params]
self.assertEqual(order, g.order())
def test_classical_field(self):
for g in (ClassicalGroup("PSp", 4, Field(2, 3)),
ClassicalGroup("PSp", 4, 2, 3),
ClassicalGroup("PSp", 4, 8)):
self.assertEqual(2, g.field.char)
self.assertEqual(3, g.field.pow)
def test_classical_str(self):
g = ClassicalGroup("PSp", 4, Field(2, 3))
self.assertEqual("PSp(4, 8)", str(g))
def test_classical_spectra(self, params):
g = ClassicalGroup(*params)
apex = spectra_data.classical[params]
self.assertSetEqual(set(apex), set(g.apex()))
def test_apex_nums_are_integers(self, params):
g = ClassicalGroup(*params)
self.assertTrue(all(isinstance(i, int) for i in g.apex()), g.apex())
