def test_cocode():
print("")
for i in range(200):
# Test power map, inveriosn, sign, theta, and conversion to GCode
n1 = randint(0, 0x1fff)
p1 = PLoop(n1)
ccvector = randint(0, 0xffffff)
coc = mat24.vect_to_cocode(ccvector)
cclist = [i for i in range(24) if (ccvector >> i) & 1]
cc1 = Cocode(cclist)
cc2 = Cocode(coc)
if i < 1:
print("\nTesting", GcVector(ccvector), ", cocode =", cc1)
assert cc1 == cc2
u = Parity(mat24.scalar_prod(p1.value, cc1.value))
assert p1 & cc1 == u == cc1 & p1 == u * 1 == u + 0
par = Parity(randint(0, 1))
assert cc1 + par == par + cc1 == cc1.value // 0x800 + par
assert cc1 % 2 == Parity(cc1)
assert len(cc1) == mat24.cocode_weight(cc1.value)
if len(cc1) < 4:
syndrome = mat24.cocode_syndrome(cc1.value)
assert cc1.syndrome().value == syndrome
syn_from_list = sum(1 << i
for i in GcVector(ccvector).syndrome_list())
assert syn_from_list == syndrome
i = randint(0, 23)
assert cc1.syndrome(i).value == mat24.cocode_syndrome(cc1.value, i)
syndrome_list = cc1.syndrome(i).bit_list
assert len(cc1) == len(syndrome_list)
assert syndrome_list == mat24.cocode_to_bit_list(cc1.value, i)
def beautify_large_block(A):
"""Beautify block matrix ``A`` acting on the Leech lattice
The function tries to find a permutation ``g`` in the group
``M_24`` that beautifies a 24 times 24 matrix ``A`` acting on
the Leech lattice. The objective of that beautification is to
bring the lines and columns of ``A`` coressponding to the
largest block in the matrix together.
Here a block is a collection of sets of indices. Two indices
``i, j`` belong to the same block if ``A[i,j] != 0``. The
function processes the largest block, provided that this
block has size at least 3.
Element ``g`` is returned and an instance of class ``MM``
corresponding to an element of the monster group. The function
returns the neutral element of the monster if beautification is
not possible.
"""
bl = blocks(A)[0]
v = GcVector(bl)
if len(v) < 3:
return MM0()
if len(v) <= 5:
b = v.bit_list
pi = AutPL(0, zip(b, range(len(v))), 0)
return MM0('p', pi)
try:
syn = v.syndrome()
except:
return MM0()
single = (v & syn).bit_list
v &= ~syn
if len(v) > 8:
return MM0()
v_list = v.bit_list
if len(single):
r_list = [7 - x for x in range(len(v_list))]
else:
r_list = list(range(len(v_list)))
if len(single):
v_list += single
r_list.append(8)
for i in range(2000):
shuffle(v_list)
try:
pi = AutPL(0, zip(v_list, r_list), 0)
return MM0('p', pi)
except:
pass
return MM0()
def rand_pi_m22():
r = randint(0, 1)
img = [2 + r, 3 - r] + sample(PI22, 3)
syn = GcVector(img).syndrome_list()
compl = set(range(24)) - set(img + syn)
img += sample(syn, 1) + sample(compl, 1)
result = AutPL('r', zip(PI7, img))
return result
def test_ABC(n_cases):
for p in characteristics():
sp = space(p)
for _ in range(n_cases):
i1 = i0 = randint(0, 23)
while i1 == i0:
i1 = randint(0, 23)
scalar = randint(1, p-1) + p * randint(-5, 5)
for tag in "ABC":
c0 = Cocode([i0])
c1 = Cocode([i1])
v0 = GcVector([i0])
v1 = GcVector([i1])
ref = sp(tag, i0, i1)
for j0 in [i0, c0, v0]:
for j1 in [i1, c1, v1]:
assert sp(tag, j0, j1) == ref
mmv = sp()
mmv[tag, j0, j1] = scalar
assert mmv == scalar * ref
assert mmv[tag, j0, j1] == scalar % p
def test_create_Parker_loop():
print("\nTesting creation of Parker loop elements")
for sign, v, syn in ploop_creation_testvectors():
# Test power map, inveriosn, sign, theta, and conversion to GCode
vlist = [i for i in range(24) if (v >> i) & 1]
shuffle(vlist)
p1 = (-1)**sign * PLoop(vlist)
ploop = mat24.vect_to_gcode(v ^ syn) + (sign << 12)
p2 = PLoop(ploop)
assert p1 == p2
g1 = GCode(ploop)
p3 = (-1)**sign * PLoop(g1)
assert p1 == p3
assert p1 == PLoop(p3)
assert abs(p1) == PLoop(GCode(vlist))
assert abs(p1) == PLoop(GcVector(vlist))
print("Parker Loop creation test passed")
def test_group_ploop(n_cases):
print("")
for i, (c, v, g) in enumerate(
zip(cocode_testvectors(n_cases), get_testvectors(n_cases),
autpl_testwords(n_cases))):
cg = c * g
vg = v * g
if i < 1:
print(c, "*", g, "=", cg)
print(v, "*", g, "=", vg)
cg_ref = Cocode(mat24.op_cocode_perm(c.ord, g.perm))
assert cg == cg_ref
assert len(cg) == len(c)
vg_ref = GcVector(mat24.op_vect_perm(v.ord, g.perm))
assert vg == vg_ref
assert len(vg) == len(v)
if len(v) & 1 == 0:
assert v / 2 == vg / 2 == Parity(len(v) >> 1)
if len(v) & 3 == 0:
assert v / 4 == vg / 4 == Parity(len(v) >> 2)
assert v % 2 == vg % 2 == Parity(len(v))
def test_T(n_cases):
for p in characteristics():
sp = space(p)
for _ in range(n_cases):
o = randint(0, 758)
so = randint(0, 63)
coc = Cocode(SubOctad(o, so))
v = GcVector (coc.syndrome(randint(0,23)))
sgn = randint(0, 1)
pl = PLoopZ(sgn) * Octad(o)
gc = GCode(pl)
scalar = randint(1, p-1) + p * randint(-5, 5)
assert gc == GCode(pl)
ref = (-1)**sgn * sp('T', o, so)
for sign, d in ((sgn,o), (sgn,gc), (0, pl)):
for par2 in (so, coc, v):
assert (-1)**sign * sp('T', d, par2) == ref
mmv = sp()
mmv['T', d, par2] = (-1)**sign * scalar
assert mmv == scalar * ref
signed_scalar = (-1)**sign * scalar % p
assert mmv['T', d, par2] == signed_scalar
def test_AD(n_cases):
for p in characteristics():
sp = space(p)
for _ in range(n_cases):
i0 = randint(0, 23)
scalar = randint(1, p-1) + p * randint(-5, 5)
c0 = Cocode([i0])
v0 = GcVector([i0])
ref = sp('A', i0, i0)
for j0 in [i0, c0, v0]:
for j1 in [i0, c0, v0]:
assert sp('A', j0, j1) == ref
mmv = sp()
mmv['A', j0, j1] = scalar
assert mmv == scalar * ref
assert mmv['A', j0, j1] == scalar % p
d1 = sp('D', j0)
assert sp('D', j0) == ref
mmv = sp()
mmv['D', j0] = scalar
assert mmv == scalar * ref
assert mmv['D', j0] == scalar % p
def test_XYZ(n_cases):
for p in characteristics():
sp = space(p)
for _ in range(n_cases):
d = randint(0, 0x1fff)
i = randint(0, 23)
c = Cocode([i])
v = GcVector([i])
pl = PLoop(d)
gc = GCode(d & 0xfff)
d0 = d & 0x7ff
scalar = randint(1, p-1) + p * randint(-5, 5)
for tag in "XYZ":
s2 = s1 = d >> 12
if tag == "Y": s1 ^= d >> 11
ref = (-1)**s1 * sp(tag, d0, i)
for sign, dd in ((s1, d0), (s2, gc), (0, pl)):
for j in [i, c, v]:
assert (-1)**sign * sp(tag, dd, j) == ref
mmv = sp()
mmv[tag, dd, j] = (-1)**sign * scalar
assert mmv == scalar * ref
signed_scalar = (-1)**sign * scalar % p
assert mmv[tag, dd, j] == signed_scalar
from mmgroup import mat24
from mmgroup.generators import gen_leech2_type
from mmgroup.generators import gen_leech2_subtype
from mmgroup.generators import gen_leech2_op_atom
from mmgroup.generators import gen_leech2_reduce_type4
from mmgroup.generators import gen_leech2_op_word
from mmgroup.generators import gen_leech2_start_type4
from mmgroup.generators import gen_leech2_start_type24
# Standard vector in the Leech lattice mod 2 in Leech lattice encoding
# The standard fram \Omega
OMEGA = 0x800000
# The standard type-2 vector \beta
BETA = 0x200
assert Cocode(BETA).syndrome() == GcVector(0xC)
#####################################################################
# Test function gen_leech2_start_type4
#####################################################################
#####################################################################
# Reference implementation of gen_leech2_start_type4()
def ref_leech2_start_type4(v):
"""Reference implementation for function gen_leech2_start_type4
This is equivalent to function ``leech2_start_type4```.
"""
v &= 0xffffff
def test_Parker_loop():
print("\nTesting operation on Parker loop")
for i in range(200):
# Test power map, inveriosn, sign, theta, and conversion to GCode
n1 = randint(0, 0x1fff)
p1 = PLoop(n1)
assert p1.ord == n1 == p1.gcode + 0x1000 * (1 - p1.sign) / 2
if (i < 2):
print("Testing Parker loop element", p1, ", GCode = ", GCode(p1))
assert len(p1) == mat24.gcode_weight(n1) << 2
assert p1.theta() == Cocode(mat24.ploop_theta(n1))
assert p1 / 4 == p1.theta(p1) == Parity(mat24.ploop_cocycle(n1, n1))
assert p1**2 == PLoopZ(p1 / 4) == (-PLoopZ())**(p1 / 4)
assert p1**(-5) == PLoopZ(p1 / 4) * p1 == (-1)**(p1 / 4) * p1 == 1 / p1
assert (1 / p1).ord ^ n1 == (mat24.gcode_weight(n1) & 1) << 12
assert -1 / p1 == -p1**3 == -(1 / p1)
assert p1 * (-1 / p1) == PLoopZ(1) == -PLoopZ()
assert abs(p1).ord == GCode(p1).ord == p1.ord & 0xfff
assert p1 != GCode(p1)
assert +p1 == 1 * p1 == p1 * 1 == p1
assert p1 != -p1 and p1 != ~p1
assert (-p1).ord == p1.ord ^ 0x1000
assert (~p1).ord == p1.ord ^ 0x800
s, o, p1_pos = p1.split()
assert s == (p1.ord >> 12) & 1
assert o == (p1.ord >> 11) & 1
assert p1.sign == (-1)**s
assert p1_pos.ord == p1.ord & 0x7ff
assert PLoopZ(s, o) * p1_pos == p1
assert PLoopZ(0, o) * p1_pos == abs(p1)
assert PLoopZ(s + 1, o) * p1_pos == -p1
assert -p1 == -1 * p1 == p1 * -1 == p1 / -1 == -1 / p1**-5
assert PLoopZ(s, 1 + o) * p1_pos == ~p1
assert PLoopZ(1 + s, 1 + o) * p1_pos == ~-p1 == -~p1 == ~p1 / -1
assert 2 * p1 == GCode(0) == -2 * GCode(p1)
assert -13 * p1 == GCode(p1) == 7 * GCode(p1)
if len(p1) & 7 == 0:
assert p1**Parity(1) == p1
assert p1**Parity(0) == PLoop(0)
else:
with pytest.raises(ValueError):
p1**Parity(randint(0, 1))
assert p1.bit_list == mat24.gcode_to_bit_list(p1.value & 0xfff)
assert p1.bit_list == GcVector(p1).bit_list
assert p1.bit_list == GCode(p1).bit_list
assert PLoop(GcVector(p1) + 0) == PLoop(GCode(p1) + 0) == abs(p1)
assert p1 + 0 == 0 + p1 == GCode(p1) + 0 == 0 + GCode(p1)
assert Cocode(GcVector(p1)) == Cocode(0)
assert p1 / 2 == Parity(0)
# Test Parker loop multiplication and commutator
n2 = randint(0, 0x1fff)
p2 = PLoop(n2)
coc = Cocode(mat24.ploop_cap(n1, n2))
if (i < 1):
print("Intersection with", p2, "is", coc)
p2inv = p2**-1
assert p1 * p2 == PLoop(mat24.mul_ploop(p1.ord, p2.ord))
assert p1 / p2 == p1 * p2**(-1)
assert p1 + p2 == p1 - p2 == GCode(p1 * p2) == GCode(n1 ^ n2)
assert (p1 * p2) / (p2 * p1) == PLoopZ((p1 & p2) / 2)
assert p1 & p2 == coc
assert p1.theta() == Cocode(mat24.ploop_theta(p1.ord))
assert p1.theta(p2) == Parity(mat24.ploop_cocycle(p1.ord, p2.ord))
assert (p1 & p2) / 2 == p1.theta(p2) + p2.theta(p1)
assert p1 & p2 == p1.theta() + p2.theta() + (p1 + p2).theta()
assert int((p1 & p2) / 2) == mat24.ploop_comm(p1.ord, p2.ord)
assert GcVector(p1 & p2) == GcVector(p1) & GcVector(p2)
assert ~GcVector(p1 & p2) == ~GcVector(p1) | ~GcVector(p2)
assert Cocode(GcVector(p1 & p2)) == p1 & p2
# Test associator
n3 = randint(0, 0x1fff)
p3 = PLoop(n3)
assert p1 * p2 * p3 / (p1 * (p2 * p3)) == PLoopZ(p1 & p2 & p3)
assert int(p1 & p2 & p3) == mat24.ploop_assoc(p1.ord, p2.ord, p3.ord)
i = randint(-1000, 1000)
par = Parity(i)
s3 = ((p3 & p1) & p2) + par
assert s3 == ((p3 & p1) & p2) + par
assert s3 == i + (p1 & (p2 & p3))
assert s3 == par + (p1 & (p2 & p3))
# Test some operations leading to a TypeError
with pytest.raises(TypeError):
p1 & p2 & p3 & p1
with pytest.raises(TypeError):
coc & coc
with pytest.raises(TypeError):
GCode(p1) * GCode(p2)
with pytest.raises(TypeError):
1 / GCode(p2)
with pytest.raises(ValueError):
coc / 4
with pytest.raises(TypeError):
p1 * coc
with pytest.raises(TypeError):
coc * p1
types = [GcVector, GCode, Cocode, PLoop]
for type_ in types:
with pytest.raises(TypeError):
int(type_(0))
print("Parker Loop test passed")
def get_testvectors(n_cases=50):
for i in range(n_cases):
yield GcVector(randint(0, 0xffffff))