def test_reduce_n(ntests=100, verbose=0): """Test function ``gen_leech2_reduce_n`` """ for n, v in enumerate(reduce_n_testdata(ntests)): ref_subtype = gen_leech2_subtype(v) if verbose: print(" \nTest %d, v = %s, subtype = %s" % (n + 1, hex(v), hex(ref_subtype))) subtype, op = ref_gen_leech2_reduce_n(v) ok = True err = "Unknown error" ok1 = ref_subtype == subtype if ok and not ok1: err = "Function gen_leech2_reduce_n returns wrong subtype" ok &= ok1 v_mapped = gen_leech2_op_word(v, op, len(op)) ok2 = v_mapped == map_vector(v) if ok and not ok2: err = "Wrong mapping in function gen_leech2_reduce_n" ok &= ok2 ok3 = len(op) == 3 tags = [x >> 28 for x in op] ok3 &= tags[:2] == [0xa, 0xc] and tags[2] in [9, 0xb] if ok and not ok3: err = "Error in computed operation on vector" ok &= ok3 if (op[2] & 0xf0000000) == 0xB and v != 0x18000000: ok4 = op[2] & 0x800 == 0 else: ok4 = True if ok and not ok4: err = "Computed operation on vector must be even" ok &= ok4 op_c = np.zeros(3, dtype=np.uint32) subtype_c = gen_leech2_reduce_n(v, op_c) #op_c[1] &= ~2 # Produce an error for verifying the test ok_C_function = subtype_c == subtype ok_C_function &= (op_c == op).all() if ok and not ok_C_function: err = "Error in C function" ok &= ok_C_function if verbose or not ok: if not ok: print(" \nTest %d, v = %s, subtype = %s" % (n + 1, hex(v), hex(ref_subtype))) print("transformation", op) print("map expected:", hex(map_vector(v)), ", obtained", hex(v_mapped)) if not ok_C_function: print("Subtype from C function is %s, expected %s" % (hex(subtype_c), hex(subtype))) print("Operation from C function:", op_c) print("Expected: ", op) if not ok: raise ValueError(err)
def test_reduce_type_4_std(ntests=500, verbose=0): """Test function ``reduce_type4_std`` """ for n, v in enumerate(type4_testdata(ntests)): if verbose: print(" \nTest %d, v = %s, subtype =%s" % (n + 1, hex(v), hex(gen_leech2_subtype(v)))) op = reduce_type4_std(v, verbose) w = gen_leech2_op_word(v, op, len(op)) assert w & 0xffffff == 0x800000, hex(w)
def test_reduce_type_2_ortho(ntests=500, verbose=0): """Test function ``reduce_type2_ortho`` """ for n, v in enumerate(type2_ortho_testdata(ntests)): if verbose: print(" \nTest %d, v = %s, subtype =%s" % (n + 1, hex(v), hex(gen_leech2_subtype(v)))) op = reduce_type2_ortho(v, verbose) w = gen_leech2_op_word(v, op, len(op)) assert w & 0xffffff == 0x800200, hex(w) b = gen_leech2_op_word(BETA, op, len(op)) assert b == BETA a = np.zeros(6, dtype=np.uint32) l = gen_leech2_reduce_type2_ortho(v, a) if l < 0: err = "Error %s in function gen_leech2_reduce_type2_ortho" raise ValueError(err % hex(l & 0xffffffff)) a = a[:l] assert list(a) == list(op), ((a), (op))
def mul_v2(v2, g): """Multiply vector in Leech lattice mod 2 by element of ``G_x0`` Here parameter ``v2`` is an element of the Leech lattice mod 2 in Leech lattice encoding. Parameter ``g`` is an element of the group ``G_x0`` endodes as an instance of class |MM| or |MM0|. The function returns the product ``v * g`` in Leech lattice encoding. """ result = gen_leech2_op_word(v2, g._data, g.length) assert result & 0xfe000000 == 0, hex(result) return result
def __mul__(self, other): if isinstance(other, XLeech2): return XLeech2(gen_leech2_mul(self.value, other.value)) elif isinstance(other, AbstractMMGroupWord): data = other.mmdata v = gen_leech2_op_word(self.value, data, len(data)) return XLeech2(v) elif isinstance(other, Integral): if abs(other) == 1: return XLeech2(self.value ^ ((other & 2) << 23)) elif other == 0: return XLeech2(0) return NotImplemented else: return NotImplemented
def conj_x_by_word(x, g_mm): """Conugate x ith a word of elments in the Clifford group Here :math:`x` is an element of the normal subgroup :math:`Q_x0` of :math:`G_x0`, and :math:`g_{mm}` is an element of the subgroup :math:`G_x0` of the monster. :math:`x` is given as an integer in **Leech lattice represention** and :math:`g_{mm}` is given as an element of the group object ``mmgroup.MM``, which is the standard instance of the monster group. The function returns :math:`g_{mm}^{-1} x g_{mm}` as an integer in **Leech lattice represention**. """ w_g = g_mm.mmdata return gen_leech2_op_word(x, w_g, len(w_g))
def test_reduce_axis(verbose=0): for i, (v, std_axis) in enumerate(make_axis_testcases()): if verbose: print("\nTest case", i, ", std_axis =", bool(std_axis)) r, axis = reduce_axis(v.copy(), std_axis, verbose) g = MM0('a', r) if std_axis: assert v * g == V_START assert axis == 0x200 else: v1 = v * g assert mm_reduce_2A_axis_type(v1.data) >> 24 == 0x21 a_g = np.zeros(20, dtype=np.uint32) r1 = gen_leech2_reduce_type2(axis, a_g) g2 = MM0('a', a_g[:r1]) v2 = v1 * g2 assert v2 in [V_START, V_OPP] axis2 = gen_leech2_op_word(axis, a_g, r1) assert axis2 & 0xffffff == 0x200 assert v_leech2_adjust_sign(v2.data, axis2) == axis2 g1, axis_found = reduce_v_axis_C(v, std_axis) assert g1 == g assert axis == axis_found
def conjugate_gen_xi(x, elem): data = [(TAGS[tag] << 28) + (d & 0xfffffff) for tag, d in elem] a = np.array(data, dtype = np.uint32) return gen_leech2_op_word(x, a, len(a))
def op_axis(axis, r): transformed_axis = gen_leech2_op_word(axis, r, len(r)) if axis == v_start: assert transformed_axis == axis return transformed_axis