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))