def display_norm_A(axis):
"""Display additional information of a 2A axis
"""
#sample_axes = import_sample_axes()
norm_A = axis.norm15
s = "norm(A) = %d (mod 15)" % (norm_A)
common = [
a.g_class for a in get_axes().values()
if a.norm15 == norm_A and a.g_class != axis.g_class
]
if len(common) == 0:
return s + "\n"
s += ", same norm for class " + " and ".join(map(str, common))
d = 2 if norm_A == 4 else 0
V15 = MMV(15)
v = axis.v15
r = mm_op15_eval_A_rank_mod3(v.data, d)
rank = r >> 48
v3 = r & 0xffffffffffff
s_A = "(A - %d * 1)" % d if d else "A"
s += "\nMatrix U = %s (mod 3) has rank %d" % (s_A, rank)
if (rank != 23):
return s + "\n"
v2 = gen_leech3to2_short(v3)
if v2:
f = "Kernel of U is spanned by a short vector v with A(v) ="
a2 = mm_op15_eval_A(v.data, v2)
s += "\n%s %d (mod 15)" % (f, a2)
if gen_leech3to2_type4(v3):
f = "Kernel of U is spanned by a vector of type 4"
s += "\n" + f
return s + "\n"
def test_mul(ncases=20):
vtest = MMV(127)('R')
indices, glist = make_mul_samples()
for n in range(ncases):
i, j = sample(indices, 2)
vt1 = vtest * glist[i] * glist[j]
glist[i] *= glist[j]
vt2 = vtest * glist[i]
assert vt1 == vt2
def test_mul_MM():
print("Test multiplcation in monster group in class MM")
V = MMV(3)
for g1 in mul_testcases():
v = V("R")
for g2 in mul_testcases():
v1 = (v * g1) * g2
v2 = v * (g1 * g2)
assert v1 == v2
def kernel_testmatrix(p, tags="dxypt" * 3, diag=0):
space = MMV(p)
a = space()
diag %= 3
for i in range(24):
d = diag + randint(1, 2) + 3 * randint(0, 4)
a['A', i, i] = d % p if i else diag
# Now ``a`` encodes the tag A part of the rep of the monster mod p
# It encodes a symmetric matrix with kernel :math:`\Omega`.
v3 = 1 # \Omega in Leech lattice mod 3 encoding
g = MM0([(t, 'r') for t in tags])
a.ops.op_word_tag_A(a.data, g.mmdata, len(g.mmdata), 1)
v3_kernel = gen_leech3_op_vector_word(v3, g.mmdata, len(g.mmdata))
return a, v3_kernel
def norm_A_mod15(i):
"""Return norm(A) mod 15 for entry i in the list in sample_axes.py
The lists in file sample_axes.py refer to a collection of 12-axes
of different types.
"""
global norms_A_mod15
try:
return norms_A_mod15[i]
except:
norms_A_mod15 = []
sample_axes = import_sample_axes()
V15 = MMV(15)
for g in sample_axes.g_strings:
v = v_axis * MM0(g)
norms_A_mod15.append(mm_op15_norm_A(v.data))
return norms_A_mod15[i]
def display_norm_A(i):
"""Display additional information of a 2A axis
"""
sample_axes = import_sample_axes()
if isinstance(i, str): i = axis_index(i)
norm_A = norm_A_mod15(i)
s = "norm(A) = %d (mod 15)" % (norm_A)
common = [
s for j, s in enumerate(sample_axes.g_classes)
if norm_A_mod15(j) == norm_A and j != i
]
if len(common) == 0:
return s + "\n"
s += ", same norm for class " + " and ".join(map(str, common))
d = 2 if norm_A == 4 else 0
V15 = MMV(15)
v = V15(sample_axes.v_start) * MM0(sample_axes.g_strings[i])
r = mm_op15_eval_A_rank_mod3(v.data, d)
rank = r >> 48
v3 = r & 0xffffffffffff
s_A = "(A - %d * 1)" % d if d else "A"
s += "\nMatrix U = %s (mod 3) has rank %d" % (s_A, rank)
if (rank != 23):
return s + "\n"
v2 = gen_leech3to2_short(v3)
if v2:
f = "Kernel of U is spanned by a short vector v with A(v) ="
a2 = mm_op15_eval_A(v.data, v2)
s += "\n%s %d (mod 15)" % (f, a2)
if gen_leech3to2_type4(v3):
f = "Kernel of U is spanned by a vector of type 4"
s += "\n" + f
return s + "\n"
print(s % n)
return result
n += chunksize
if verbose:
print("\r%5d candidates tested " % n, end="")
if verbose:
print("\n")
err = "No suitable candidate found"
raise ValueError(err)
#######################################################################
# Find an element of the monster of a given order
#######################################################################
MMV3 = MMV(3)
MMV15 = MMV(15)
def get_factors(n):
"""Return sorted list of factors of n, for n <= 120"""
assert 1 <= n < 121, "Number too large"
return [i for i in range(1, n + 1) if n % i == 0]
def rand_mm_element(size=1):
"""Return a random element ``g`` of the monster group
Here ``size`` is a measure for the requested word length.
of ``g``. The returned random element is not uniform
distrbuted. It is just sufficiently random, so that
from __future__ import absolute_import, division, print_function
from __future__ import unicode_literals
import numpy as np
from numbers import Integral
from random import randint, sample
import pytest
from mmgroup import MMV, MM0
ref_space = MMV(3)
ref_group = MM0
from mmgroup.structures import mm_order
#from mmgroup.structures.mm_order import reduce_mm
########################################################################
# Computing the order of a group element using a random vector
########################################################################
def ref_order_random_v(g):
g1 = ref_group(g)
v = ref_space("R")
w = v.copy()
for i in range(1, 120):
w = w * g1
if w == v:
return i
err = "Error in computation reference order of group element"
from collections import OrderedDict
import numpy as np
import pytest
from mmgroup import MM0, MMV
from mmgroup.mat24 import MAT24_ORDER
from mmgroup.mm15 import op_word_tag_A
from mmgroup.mm15 import op_watermark_A
from mmgroup.mm15 import op_watermark_A_perm_num
#######################################################################
# Test leech3matrix_watermark and leech3matrix_watermark_perm_num
#######################################################################
MMV15 = MMV(15)
MM = MM0
def one_test_watermark(verbose=0):
v0 = MMV15('R')
v = v0.data[:48]
w0 = np.zeros(24, dtype=np.uint32)
result = op_watermark_A(v, w0)
if result < 0:
return 0
pi_num = randint(0, MAT24_ORDER - 1)
TAG_y, TAG_p = 0x40000000, 0x20000000
y1, y2 = randint(0, 0xfff), randint(0, 0xfff)
op = np.array([TAG_y + y1, TAG_p + pi_num, TAG_y + y2], dtype=np.uint32)
op_word_tag_A(v, op, len(op), 1)
from mmgroup.tests.test_axes.get_sample_axes import V_AXIS_OPP
from mmgroup.tests.test_axes.get_sample_axes import g_axis, v_axis
from mmgroup.tests.test_axes.get_sample_axes import g_axis_opp
from mmgroup.tests.test_axes.get_sample_axes import v_axis_opp
from mmgroup.tests.test_axes.get_sample_axes import g_central, GVector
from mmgroup.tests.test_axes.get_sample_axes import next_generation_pool
from mmgroup.tests.test_axes.get_sample_axes import axis_type
########################################################################
########################################################################
# The group and the vector space to be used
########################################################################
########################################################################
G = MM0 # The monster group
V15 = MMV(15) # Its representation space
PROCESSES = 0
########################################################################
########################################################################
# Obtaining samples of transformed axes
########################################################################
########################################################################
########################################################################
# Generate a random element of Co_2
########################################################################
FIXED_PAIR = [3, 2]
FIXED_TUPLE = ("I", 3, 2)
from __future__ import unicode_literals
import sys
import os
import collections
import re
import warnings
from random import randint, shuffle
import pytest
import numpy as np
from mmgroup import MMSpace, MMGroup, MM0, MMV
from mmgroup.tests.spaces.leech_space import mul24_mmgroup
M = MM0
V = MMV(3)
def check_abs_equal(v, v_ref):
if (v == v_ref).all():
return
if (v == -v_ref).all():
return
print("Leech lattice vector expected:")
print(v_ref)
print("Leech lattice vector obtained:")
print(v)
raise ValueError("Leech vectors are not equal or opposite")
def do_test_leech_variants(v, v_leech):
from __future__ import absolute_import, division, print_function
from __future__ import unicode_literals
from random import randint #, shuffle, sample
import numpy as np
import pytest
from mmgroup import MM0, MMSpace, Cocode, MMV
from mmgroup.mm import mm_aux_index_extern_to_sparse
from mmgroup.mm import mm_aux_index_leech2_to_sparse
from mmgroup.mm import mm_aux_index_sparse_to_leech2
from mmgroup.mm import mm_aux_index_sparse_to_leech
V = MMV(15)
START_AXIS = ('I', 3, 2)
from mmgroup.tests.test_axes.get_sample_axes import import_sample_axes
sample_axes = import_sample_axes()
from mmgroup.tests.test_axes.test_import import AXES, BABY_AXES
# We have(V(START_AXIS) * MM(AXES[key]).axis_type() == key
# for all kes in the dictionar AXES
@pytest.mark.axes
def test_axes():
for key in AXES:
v = V(*START_AXIS) * MM0(AXES[key])
assert v.axis_type() == key
for i in range(20):
def bench(p, operation = [], iterations = ITERATIONS, break_g = True):
v = MMV(p)('R')
#print(operation)
g = MM0(operation)
v.mul_exp(g, iterations, break_g = break_g)
return v.last_timing, iterations
return eval(s[copen:cclose + 1])
ClassNames = find_table("Classes")
ClassOrders = [int(s[:-1]) for s in ClassNames]
CharacterValues = find_table("Character")
SizesCentralizers = find_table("Sizes of the centralizers")
assert len(ClassNames) == len(CharacterValues) == len(SizesCentralizers)
################################################################
# Check that monster group elements have coorect orders
################################################################
p = 3
space = MMV(3)
group = MM0
good_mm_orders = set(ClassOrders)
max_mm_order = max(good_mm_orders)
def one_test_mm_order(v, m, verbose=0):
v = v.copy()
v1, n = v.copy(), 0
while n <= max_mm_order:
v1, n = v1 * m, n + 1
if v1 == v:
return n
return None
