def autpl_to_xsp2co1(g, aut): res = g.word_type(group=g) a = np.zeros(2, dtype=uint32) a[0] = 0x10000000 + (aut._cocode & 0xfff) # tag 'd' a[1] = 0x20000000 + aut._perm_num # tag 'p' chk_qstate12(xsp2co1_set_elem_word(res._data, a, 2)) return res
def xsp_conjugate(self, v, sign=True): v = np.array(v, dtype=np.uint64, copy=True) shape = v.shape assert len(shape) <= 1 v = np.ravel(v) chk_qstate12(xsp2co1_xspecial_conjugate(self._data, len(v), v, sign)) if len(shape): return list(map(int, v)) else: return int(v[0])
def as_mmspace_vector(self, v1): vm = self.mmspace(0) assert v1.qs.shape == (12, 12) if INT_BITS == 64: START = 116416 // 32 assert len(vm.data) >= START + 4096 chk_qstate12(xsp2co1_elem_row_mod3(v1._data, 0, vm.data[START:])) return vm ERR = "Function not supported on %d-bit systems" raise NotImplementedError(ERR % INT_BITS)
def xsp2co1_fast_half_order(wx): assert isinstance(wx, Xsp2_Co1) buf = np.zeros(10, dtype=np.uint32) m = MM0(wx) res = chk_qstate12(xsp2co1_half_order_word(m._data, m.length, buf)) o, l = divmod(res, 256) assert 0 <= l <= 10 out = Xsp2_Co1() chk_qstate12(xsp2co1_mul_elem_word(out._data, buf, l)) return o, out
def dump_vector(self, v1): a = np.zeros(4096, dtype=np.uint64) chk_qstate12(xsp2co1_elem_row_mod3(v1._data, 0, a)) or_sum = 0 print("Xsp2_Co1 vector:") for i, x in enumerate(a): x = int(x) & 0xffffffffffff if (x): print("0x%04x: 0x%012x" % (i, x)) or_sum |= x if not or_sum: print("Vector is equal to 0")
def conj_G_x0_to_Q_x0(g): gg = Xsp2_Co1(g) a = np.zeros(7, dtype=np.uint32) lv = chk_qstate12(xsp2co1_elem_conj_G_x0_to_Q_x0(gg._data, a)) length, q = lv >> 25, lv & 0x1ffffff h = MM0('a', a[:length]) gh = MM0(g)**h assert gh.in_Q_x0() assert gh == MM0('q', q) return h
def conjugate_involution(self, mmgroup=None): r"""Find an element conjugating an involution standard element If the element :math:`g` given by ``self`` is an involution in the monster then the method computes an element :math:`h` of the monster with :math:`h^{-1} g h = z`, where :math:`z` is define as follows: If :math:`g = 1`, we put :math:`h = z = 1` if :math:`g` is a 2A involution (in the monster) then we let :math:`z` be the involution in :math:`Q_{x0}` corresponding to the Golay cocode word with entries :math:`2,3` being set. if :math:`g` is a 2B involution (in the monster) then we let :math:`z` be the central involution in :math:`G_{x0}` The function returns a pair ``(I, h)``, where :math:`h` as an element of the instance ``MM`` of class ``MMGroup``. We put ``I = 0`` if :math:`g = 1`. We put ``I = 1, 2`` if :math:`g` is a 2A or 2B involution, respectively. The function raises ``ValueError`` if :math:`g` is not an involution. This is a wrapper for the C function ``xsp2co1_elem_conjugate_involution``. Parameter ``mmgroup`` is not for public use. In special cases it may specify an alternative class implementing the monster group. Then the function returns :math:`h` as an instance of that class. """ if mmgroup is None: mmgroup = MM if MM is not None else import_MM() a = np.zeros(15, dtype=np.uint32) len_a = xsp2co1_elem_conjugate_involution(self._data, a) chk_qstate12(len_a) return (len_a >> 8), mmgroup('a', a[:len_a & 0xff])
def from_xsp(self, x): w = self.word_type() chk_qstate12(xsp2co1_elem_xspecial(w._data, x)) return w
def _equal_words(self, g1, g2): chk_qstate12(xsp2co1_reduce_elem(g1._data)) chk_qstate12(xsp2co1_reduce_elem(g2._data)) return (g1._data == g2._data).all()
def reduce(self, g1, copy=False): if copy: g1 = self.copy_word(g1) chk_qstate12(xsp2co1_reduce_elem(g1._data)) return self
def _invert(self, g1): w = self.word_type() chk_qstate12(xsp2co1_inv_elem(g1._data, w._data)) return w
def _imul(self, g1, g2): chk_qstate12(xsp2co1_mul_elem(g1._data, g2._data, g1._data)) return g1
def xsp2co1_fast_order(wx, via_word=True): assert isinstance(wx, Xsp2_Co1) if not via_word: return chk_qstate12(xsp2co1_order_elem(wx._data)) m = MM0(wx) return xsp2co1_order_word(m._data, m.length)
def reduce_word_C(w): a = np.array(w, dtype=np.uint32) a1 = np.zeros(10, dtype=np.uint32) len_a1 = chk_qstate12(xsp2co1_reduce_word(a, len(a), a1)) return a1[:len_a1]
def xsp2co1_fast_power(wx, e): """The safe exponentiation in G_x0 to be tested""" assert isinstance(wx, Xsp2_Co1) power = Xsp2_Co1() chk_qstate12(xsp2co1_power_elem(wx._data, e, power._data)) return power
def ploop_to_xsp2co1(g, pl): res = g.word_type(group=g) value = (c.value & 0x1fff) value = (value << 12) ^ mat24.ploop_theta(value) chk_qstate12(xsp2co1_elem_xspecial(res._data, value)) return res
def cocode_to_xsp2co1(g, c): res = g.word_type(group=g) chk_qstate12(xsp2co1_elem_xspecial(res._data, c.value & 0xfff)) return res
def mmdata(self): a = np.zeros(10, dtype=np.uint32) length = chk_qstate12(xsp2co1_elem_to_word(self._data, a)) return a[:length]
def imul_group_word(self, v1, g): if v1.is_zero: return v1 chk_qstate12(xsp2co1_mul_elem(v1._data, g._data, v1._data)) return v1
def xsp2co1_to_mm(mmgroup, xsp): g = mmgroup() g._extend(10) g.length = chk_qstate12(xsp2co1_elem_to_word(xsp._data, g._data)) g.reduced = 0 return g
def reduce(self, v): if not v.is_zero: chk_qstate12(xsp2co1_reduce_elem(v._data)) return v
def as_xsp(self): return chk_qstate12(xsp2co1_xspecial_vector(self._data))
def mmgroup_to_xsp2co1(g, mm): res = g.word_type(group=g) chk_qstate12(xsp2co1_set_elem_word(res._data, mm._data, mm.length)) return res
def elem_to_word_C(elem): a = np.zeros(10, dtype=np.uint32) elem_data = np.array(elem.data, dtype=np.uint64) len_a = chk_qstate12(xsp2co1_elem_to_word(elem_data, a)) return a[:len_a]