class PGL2PrincipalRepresentation(Representation):
def __init__(self, pgl2, k):
self._pgl2 = pgl2
self._pf2 = pgl2.get_pf()
self._action = PGLGroupAction(pgl2)
self._q = pgl2.q()
self._base_character = FieldCharacter(self._pgl2.get_field(), k, self._q - 1)
def apply(self, g) -> np.ndarray:
result = np.zeros((self.dim(), self.dim()), dtype=complex)
infinity = self._pf2.infinity()
g2 = self._pgl2.create([[g.d, g.c], [g.b, g.a]])
for x in self._action.get_acted_upon_elements():
x2 = self._pf2.create([x[1], x[0]])
y2 = self._action.apply(g2, x2)
y = self._pf2.create([y2[1], y2[0]])
s = g.a + g.b * x[1]/x[0] if x[0] != 0 else g.b
if y2 != infinity:
value = self._base_character.apply(s * s / g.det())
else:
if x2 != infinity:
value = self._base_character.apply(g.det() / (g.b * g.b))
else:
value = self._base_character.apply(g.d/g.a)
i = self._action.get_integral_value(x)
j = self._action.get_integral_value(y)
result[i, j] = value
return result
def dim(self) -> int:
return self._q+1
def get_character(self) -> Character:
return PGL2DiagonalizableCharacter(self._q, self._base_character)
def __str__(self):
return 'ρ%s' % str(self._base_character.i)
def get_action_average_polynomial(action, conjugation_classes):
orbit_lengths = find_orbits(action, conjugation_classes)
return get_average_polynomial(orbit_lengths)
def pop_if_found(dict, key):
if key in dict:
dict.pop(key)
qs = [11]
for q in qs:
print('q = %d' % q)
group = PGL2(q)
action = PGLGroupAction(group)
conjugation_classes = group.get_conjugation_classes()
sn_average_polynomial = get_action_average_polynomial(
SNGroupAction(q + 1), get_sn_conjugation_classes(q + 1))
orbit_lengths = find_orbits(action, conjugation_classes)
polynomials = get_polynomials(orbit_lengths)
polynomials2 = np.asarray(polynomials)
polynomials.append(sn_average_polynomial)
polynomials3 = np.asarray(polynomials)
r1 = matrix_rank(polynomials2)
r2 = matrix_rank(polynomials3)
poly_number = len(polynomials2)
print(poly_number, r1, r2)
print(orbit_lengths)
e3 = pgl.create([
[one, zero, zero],
[zero, one, zero],
[extension_element, one, one]
])
e4 = pgl.create([
[one, zero, zero],
[one, one, zero],
[zero, zero, one]
])
members = {pgl.identity()}
for k in range(8):
for x in product([e1, e2, e3, e4], members):
res = x[0] * x[1]
members.add(res)
if len(members) == 360:
break
return members
pgl = PGL(3, 4)
action = PGLGroupAction(pgl)
members = a6_in_psl3_4(pgl)
vector_space = action.get_acted_upon_elements()
orbit_elements = [action.apply(g, vector_space[0]) for g in members]
orbit = list(set(orbit_elements))
print(len(orbit))
from projective_sets.pgl2 import PGL2
from utilities.my_polynomial import MyPolynomial
from copy import copy
from itertools import product, combinations, combinations_with_replacement
from operator import mul
from functools import reduce
from math import log
from representations.characters.wedge_character import WedgeCharacter
q = 5
graph = nx.configuration_model((2, ))
graph2 = nx.configuration_model((4, ))
pgl2 = PGL2(q)
action = PGLGroupAction(pgl2)
representation = TransitiveActionUnitaryStandardRepresentation(
action,
pgl2.get_pf().infinity())
characters = [
WedgeCharacter.create_wedge_character(representation, i)
for i in range(q + 1)
]
conjugation_classes = list(pgl2.get_conjugation_classes().keys())
graph_covering = GraphCovering(graph, representation)
graph_covering2 = GraphCovering(graph2, representation)
graph_labelling = UpToConjugationGraphLabelling(pgl2.get_conjugation_classes(),
pgl2)
def __init__(self, pgl2, k):
self._pgl2 = pgl2
self._pf2 = pgl2.get_pf()
self._action = PGLGroupAction(pgl2)
self._q = pgl2.q()
self._base_character = FieldCharacter(self._pgl2.get_field(), k, self._q - 1)