def mul_Ty(tag, octad, sub, g):
d = m24.octad_to_gcode(octad)
c = m24.suboctad_to_cocode(sub, d)
e = g.pl
c1 = m24.ploop_cap(d, e) ^ c
sub1 = m24.cocode_to_suboctad(c1, d)
s = m24.scalar_prod(e, c)
return s, tag, octad, sub1
def index_suboctad(tag, i, index_type_T=3, a_indices_T=None):
"""Convert an index specifying an suboctad number
0 <= 'i' < 64 is an index specifying the number of a suboctad
in the Golay cocode. Here a suboctad is a Golay cocode word
which can be represented a subset of of an octad. For each
octad there is a lexicographic numbering of its suboctad, and
index 'i' refers to that lexicographic numbering.
This index type occurs as the second index of tag T only,
so the first index of that tag gives us a reference octad.
If 'i' is of type Cocode or GcVector, corresponding to a
Golay cocode word, that cocode word is taken if it fits into
the reference octad; otherwise we raise ValueError.
The function returns triple
(index_type, a_indices, sign).
Here index_type indicates whether the index has been selected
ar random, or whether it refers to a slice, as in function
index_I().
The index or the indices making up the slice are returned in
the numpy array 'a_indices', as in function index_I(). In any
case the numbers in that array are suboctad numbers.
Parameters ('index_type_T', 'a_indices_T') must be the values
(index_type, a_indices) returned by function index_T(), when
called with the first index for tag T.
The second index of tag T is of this type. Parameter 'tag' is
for compatibility with similar functions; it must be 'T'.
"""
if isinstance(i, Integral):
if 0 <= i < 64:
return 0, i, 0
raise IndexError(INDEX_ERROR_RANGE % ("Second ", tag))
elif isinstance(i, str):
if i in ["r", "n"]:
return INDEX_IS_RANDOM, randint(0, 63), 0
raise IndexError(INDEX_ERROR_RAND % tag)
elif isinstance(i, slice):
return INDEX_IS_SLICE, a_slice(i, 64), 0
elif isinstance(i, (GCode, Cocode, GcVector)):
if index_type_T == 0:
gcode = mat24.octad_to_gcode(a_indices_T) & 0xfff
if isinstance(i, GCode):
cocode = mat24.ploop_cap(gcode, i)
else:
cocode = Cocode(i).cocode
sub = mat24.cocode_to_suboctad(cocode, gcode)
return 0, sub, 0
err = "Second vector index for tag T must be integer here"
raise TypeError(err)
elif isinstance(i, Iterable):
return index_iterable(index, 64, tag, 2)
raise TypeError(INDEX_ERROR_TYPE % ("Second ", type(i), tag))
def mul_Tp(tag, octad, sub, g):
d = m24.octad_to_gcode(octad)
c = m24.suboctad_to_cocode(sub, d)
eps, pi, rep = g.cocode, g.perm, g.rep
d1 = m24.op_ploop_autpl(d, rep)
c1 = m24.op_cocode_perm(c, pi)
s = d1 >> 12
s ^= (eps >> 11) & 1 & m24.suboctad_weight(sub)
octad1 = m24.gcode_to_octad(d1)
sub1 = m24.cocode_to_suboctad(c1, d1)
return s, tag, octad1, sub1
def _as_suboctad(v1, o):
d = m24.octad_to_gcode(o)
c = m24.ploop_cap(v1, d)
return m24.cocode_to_suboctad(c, d)
def SubOctad(octad, suboctad=0):
"""Creates a suboctad as instance of class |XLeech2|
:param octad:
The first component of the pair *(octad, suboctad)* to be
created.
:type octad: same as in function
:py:class:`~mmgroup.Octad`
:param suboctad:
The second component of the pair
*(octad, suboctad)* to be created.
:type suboctad: see table below for legal types
:return:
The suboctad given by the pair *(octad, suboctad)*
:rtype: an instance of class |XLeech2|
:raise:
* TypeError if one of the arguments *octad* or *suboctad*
is not of correct type.
* ValueError if argument *octad* or *suboctad* does not
evaluate to an octad or to a correct suboctad,
respectively.
A *suboctad* is an even cocode element that can be represented
as a subset of the octad given by the argument *octad*.
The raison d'etre of function ``SubOctad`` is that pairs
*(octad, suboctad)* are used for indexing vectors in the
representation of the monster group. Here we want to
number the octads from ``0`` to ``758`` and the suboctads
form ``0`` to ``63``, depending on the octad. Note that
every octad has ``64`` suboctads.
Depending on its type parameter **suboctad** is interpreted as follows:
.. table:: Legal types for parameter ``suboctad``
:widths: 20 80
===================== ================================================
type Evaluates to
===================== ================================================
``int`` Here the suboctad with the number given
in the argument is
taken. That numbering depends on the octad
given in the argument ``octad``.
``0 <= suboctad < 64`` must hold.
``list`` of ``int`` Such a list is converted to a bit vector
as in class |GcVector|,
and the cocode element corresponding to that
bit vector is taken.
class |GCode| The intersection of the octad given as the
first argument and the Golay code word given
as the second argument is taken.
class |GcVector| This is converted to a cocode element,
see class |Cocode|, and that cocode element
is taken.
class |Cocode| That cocode element is taken as the suboctad.
``str`` Create random element depending on the string
| ``'r'``: Create arbitrary suboctad
===================== ================================================
The numbering of the suboctads
Suboctads are numbered for 0 to 63. Let ``[b0, b1,..., b7]`` be the
bits set in the octad of the pair ``(octad, suboctad)`` in natural
order. The following table shows the suboctad numbers for some
suboctads given as cocode elements. More suboctad numbers can be
obtained by combining suboctads and their corresponding numbers
with ``XOR``.
.. table:: Suboctad numbers of some cocode elements
:widths: 16 16 16 16 18 18
=========== =========== =========== =========== =========== ===========
``[b0,b1]`` ``[b0,b2]`` ``[b0,b3]`` ``[b0,b4]`` ``[b0,b5]`` ``[b0,b6]``
``s = 1`` ``s = 2`` ``s = 4`` ``s = 8`` ``s = 16`` ``s = 32``
=========== =========== =========== =========== =========== ===========
E.g. ``[b0, b5, b6, b7]`` is equivalent to ``[b1, b2, b3, b4]``
modulo the Golay code and has number ``s = 1 ^ 2 ^ 4 ^ 8 = 15``.
"""
ploop = Octad(octad)
gcode = ploop.value & 0xfff
if isinstance(suboctad, str):
suboctad_ = randint(0, 63)
elif isinstance(suboctad, Integral):
suboctad_ = suboctad & 0x3f
elif isinstance(suboctad, GCode):
value = mat24.ploop_cap(gcode, suboctad.value)
suboctad_ = mat24.cocode_to_suboctad(value, gcode)
else:
value = Cocode(suboctad).cocode
suboctad_ = mat24.cocode_to_suboctad(value, gcode)
cocode = mat24.suboctad_to_cocode(suboctad_, gcode)
if import_pending:
complete_import()
result = XLeech2(ploop, cocode)
subtype = result.xsubtype
assert subtype in [0x22, 0x42], (hex(subtype), hex(ploop), hex(cocode),
hex(result.value))
# complent a complement of an octad
if subtype == 0x42:
result.value ^= 0x800000
return result
def as_suboctad(v1, d):
c = m24.ploop_cap(v1, d)
return m24.cocode_to_suboctad(c, d)