qiskit 1.3.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/circuit/library/standard_gates/y.py

@@ -0,0 +1,262 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Y and CY gates."""
+
+from math import pi
+from typing import Optional, Union
+
+# pylint: disable=cyclic-import
+from qiskit.circuit.singleton import SingletonGate, SingletonControlledGate, stdlib_singleton_key
+from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit._utils import with_gate_array, with_controlled_gate_array
+from qiskit._accelerate.circuit import StandardGate
+
+_Y_ARRAY = [[0, -1j], [1j, 0]]
+
+
+@with_gate_array(_Y_ARRAY)
+class YGate(SingletonGate):
+    r"""The single-qubit Pauli-Y gate (:math:`\sigma_y`).
+
+    Can be applied to a :class:`~qiskit.circuit.QuantumCircuit`
+    with the :meth:`~qiskit.circuit.QuantumCircuit.y` method.
+
+    **Matrix Representation:**
+
+    .. math::
+
+        Y = \begin{pmatrix}
+                0 & -i \\
+                i & 0
+            \end{pmatrix}
+
+    **Circuit symbol:**
+
+    .. code-block:: text
+
+             ┌───┐
+        q_0: ┤ Y ├
+             └───┘
+
+    Equivalent to a :math:`\pi` radian rotation about the Y axis.
+
+    .. note::
+
+        A global phase difference exists between the definitions of
+        :math:`RY(\pi)` and :math:`Y`.
+
+        .. math::
+
+            RY(\pi) = \begin{pmatrix}
+                        0 & -1 \\
+                        1 & 0
+                      \end{pmatrix}
+                    = -i Y
+
+    The gate is equivalent to a bit and phase flip.
+
+    .. math::
+
+        |0\rangle \rightarrow i|1\rangle \\
+        |1\rangle \rightarrow -i|0\rangle
+    """
+
+    _standard_gate = StandardGate.YGate
+
+    def __init__(self, label: Optional[str] = None, *, duration=None, unit="dt"):
+        """Create new Y gate."""
+        super().__init__("y", 1, [], label=label, duration=duration, unit=unit)
+
+    _singleton_lookup_key = stdlib_singleton_key()
+
+    def _define(self):
+        # pylint: disable=cyclic-import
+        from qiskit.circuit.quantumcircuit import QuantumCircuit
+        from .u3 import U3Gate
+
+        q = QuantumRegister(1, "q")
+        qc = QuantumCircuit(q, name=self.name)
+        rules = [(U3Gate(pi, pi / 2, pi / 2), [q[0]], [])]
+        for instr, qargs, cargs in rules:
+            qc._append(instr, qargs, cargs)
+
+        self.definition = qc
+
+    def control(
+        self,
+        num_ctrl_qubits: int = 1,
+        label: Optional[str] = None,
+        ctrl_state: Optional[Union[str, int]] = None,
+        annotated: bool = False,
+    ):
+        """Return a (multi-)controlled-Y gate.
+
+        One control returns a CY gate.
+
+        Args:
+            num_ctrl_qubits: number of control qubits.
+            label: An optional label for the gate [Default: ``None``]
+            ctrl_state: control state expressed as integer,
+                string (e.g.``'110'``), or ``None``. If ``None``, use all 1s.
+            annotated: indicates whether the controlled gate should be implemented
+                as an annotated gate.
+
+        Returns:
+            ControlledGate: controlled version of this gate.
+        """
+        if not annotated and num_ctrl_qubits == 1:
+            gate = CYGate(label=label, ctrl_state=ctrl_state, _base_label=self.label)
+        else:
+            gate = super().control(
+                num_ctrl_qubits=num_ctrl_qubits,
+                label=label,
+                ctrl_state=ctrl_state,
+                annotated=annotated,
+            )
+        return gate
+
+    def inverse(self, annotated: bool = False):
+        r"""Return inverted Y gate (:math:`Y^{\dagger} = Y`)
+
+        Args:
+            annotated: when set to ``True``, this is typically used to return an
+                :class:`.AnnotatedOperation` with an inverse modifier set instead of a concrete
+                :class:`.Gate`. However, for this class this argument is ignored as this gate
+                is self-inverse.
+
+        Returns:
+            YGate: inverse gate (self-inverse).
+        """
+        return YGate()  # self-inverse
+
+    def __eq__(self, other):
+        return isinstance(other, YGate)
+
+
+@with_controlled_gate_array(_Y_ARRAY, num_ctrl_qubits=1)
+class CYGate(SingletonControlledGate):
+    r"""Controlled-Y gate.
+
+    Can be applied to a :class:`~qiskit.circuit.QuantumCircuit`
+    with the :meth:`~qiskit.circuit.QuantumCircuit.cy` method.
+
+    **Circuit symbol:**
+
+    .. code-block:: text
+
+        q_0: ──■──
+             ┌─┴─┐
+        q_1: ┤ Y ├
+             └───┘
+
+    **Matrix representation:**
+
+    .. math::
+
+        CY\ q_0, q_1 =
+        I \otimes |0 \rangle\langle 0| + Y \otimes |1 \rangle\langle 1|  =
+            \begin{pmatrix}
+                1 & 0 & 0 & 0 \\
+                0 & 0 & 0 & -i \\
+                0 & 0 & 1 & 0 \\
+                0 & i & 0 & 0
+            \end{pmatrix}
+
+
+    .. note::
+
+        In Qiskit's convention, higher qubit indices are more significant
+        (little endian convention). In many textbooks, controlled gates are
+        presented with the assumption of more significant qubits as control,
+        which in our case would be q_1. Thus a textbook matrix for this
+        gate will be:
+
+        .. code-block:: text
+
+                 ┌───┐
+            q_0: ┤ Y ├
+                 └─┬─┘
+            q_1: ──■──
+
+        .. math::
+
+            CY\ q_1, q_0 =
+                |0 \rangle\langle 0| \otimes I + |1 \rangle\langle 1| \otimes Y =
+                \begin{pmatrix}
+                    1 & 0 & 0 & 0 \\
+                    0 & 1 & 0 & 0 \\
+                    0 & 0 & 0 & -i \\
+                    0 & 0 & i & 0
+                \end{pmatrix}
+
+    """
+
+    _standard_gate = StandardGate.CYGate
+
+    def __init__(
+        self,
+        label: Optional[str] = None,
+        ctrl_state: Optional[Union[str, int]] = None,
+        *,
+        duration=None,
+        unit="dt",
+        _base_label=None,
+    ):
+        """Create new CY gate."""
+        super().__init__(
+            "cy",
+            2,
+            [],
+            num_ctrl_qubits=1,
+            label=label,
+            ctrl_state=ctrl_state,
+            base_gate=YGate(label=_base_label),
+            duration=duration,
+            unit=unit,
+        )
+
+    _singleton_lookup_key = stdlib_singleton_key(num_ctrl_qubits=1)
+
+    def _define(self):
+        """
+        gate cy a,b { sdg b; cx a,b; s b; }
+        """
+        # pylint: disable=cyclic-import
+        from qiskit.circuit.quantumcircuit import QuantumCircuit
+        from .s import SGate, SdgGate
+        from .x import CXGate
+
+        q = QuantumRegister(2, "q")
+        qc = QuantumCircuit(q, name=self.name)
+        rules = [(SdgGate(), [q[1]], []), (CXGate(), [q[0], q[1]], []), (SGate(), [q[1]], [])]
+        for instr, qargs, cargs in rules:
+            qc._append(instr, qargs, cargs)
+
+        self.definition = qc
+
+    def inverse(self, annotated: bool = False):
+        """Return inverted CY gate (itself).
+
+        Args:
+            annotated: when set to ``True``, this is typically used to return an
+                :class:`.AnnotatedOperation` with an inverse modifier set instead of a concrete
+                :class:`.Gate`. However, for this class this argument is ignored as this gate
+                is self-inverse.
+
+        Returns:
+            CYGate: inverse gate (self-inverse).
+        """
+        return CYGate(ctrl_state=self.ctrl_state)  # self-inverse
+
+    def __eq__(self, other):
+        return isinstance(other, CYGate) and self.ctrl_state == other.ctrl_state

qiskit/circuit/library/standard_gates/z.py

@@ -0,0 +1,348 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Z, CZ and CCZ gates."""
+
+from math import pi
+from typing import Optional, Union
+
+import numpy
+
+from qiskit.circuit._utils import with_gate_array, with_controlled_gate_array
+from qiskit.circuit.singleton import SingletonGate, SingletonControlledGate, stdlib_singleton_key
+from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit._accelerate.circuit import StandardGate
+
+from .p import PhaseGate
+
+_Z_ARRAY = [[1, 0], [0, -1]]
+
+
+@with_gate_array(_Z_ARRAY)
+class ZGate(SingletonGate):
+    r"""The single-qubit Pauli-Z gate (:math:`\sigma_z`).
+
+    Can be applied to a :class:`~qiskit.circuit.QuantumCircuit`
+    with the :meth:`~qiskit.circuit.QuantumCircuit.z` method.
+
+    **Matrix Representation:**
+
+    .. math::
+
+        Z = \begin{pmatrix}
+                1 & 0 \\
+                0 & -1
+            \end{pmatrix}
+
+    **Circuit symbol:**
+
+    .. code-block:: text
+
+             ┌───┐
+        q_0: ┤ Z ├
+             └───┘
+
+    Equivalent to a :math:`\pi` radian rotation about the Z axis.
+
+    .. note::
+
+        A global phase difference exists between the definitions of
+        :math:`RZ(\pi)` and :math:`Z`.
+
+        .. math::
+
+            RZ(\pi) = \begin{pmatrix}
+                        -i & 0 \\
+                        0 & i
+                      \end{pmatrix}
+                    = -i Z
+
+    The gate is equivalent to a phase flip.
+
+    .. math::
+
+        |0\rangle \rightarrow |0\rangle \\
+        |1\rangle \rightarrow -|1\rangle
+    """
+
+    _standard_gate = StandardGate.ZGate
+
+    def __init__(self, label: Optional[str] = None, *, duration=None, unit="dt"):
+        """Create new Z gate."""
+        super().__init__("z", 1, [], label=label, duration=duration, unit=unit)
+
+    _singleton_lookup_key = stdlib_singleton_key()
+
+    def _define(self):
+        # pylint: disable=cyclic-import
+        from qiskit.circuit.quantumcircuit import QuantumCircuit
+
+        from .u1 import U1Gate
+
+        q = QuantumRegister(1, "q")
+        qc = QuantumCircuit(q, name=self.name)
+        rules = [(U1Gate(pi), [q[0]], [])]
+        for instr, qargs, cargs in rules:
+            qc._append(instr, qargs, cargs)
+
+        self.definition = qc
+
+    def control(
+        self,
+        num_ctrl_qubits: int = 1,
+        label: Optional[str] = None,
+        ctrl_state: Optional[Union[str, int]] = None,
+        annotated: bool = False,
+    ):
+        """Return a (multi-)controlled-Z gate.
+
+        One control returns a CZ gate.
+
+        Args:
+            num_ctrl_qubits: number of control qubits.
+            label: An optional label for the gate [Default: ``None``]
+            ctrl_state: control state expressed as integer,
+                string (e.g.``'110'``), or ``None``. If ``None``, use all 1s.
+            annotated: indicates whether the controlled gate should be implemented
+                as an annotated gate.
+
+        Returns:
+            ControlledGate: controlled version of this gate.
+        """
+        if not annotated and num_ctrl_qubits == 1:
+            gate = CZGate(label=label, ctrl_state=ctrl_state, _base_label=self.label)
+        else:
+            gate = super().control(
+                num_ctrl_qubits=num_ctrl_qubits,
+                label=label,
+                ctrl_state=ctrl_state,
+                annotated=annotated,
+            )
+        return gate
+
+    def inverse(self, annotated: bool = False):
+        """Return inverted Z gate (itself).
+
+        Args:
+            annotated: when set to ``True``, this is typically used to return an
+                :class:`.AnnotatedOperation` with an inverse modifier set instead of a concrete
+                :class:`.Gate`. However, for this class this argument is ignored as this gate
+                is self-inverse.
+
+        Returns:
+            ZGate: inverse gate (self-inverse).
+        """
+        return ZGate()  # self-inverse
+
+    def power(self, exponent: float, annotated: bool = False):
+        return PhaseGate(numpy.pi * exponent)
+
+    def __eq__(self, other):
+        return isinstance(other, ZGate)
+
+
+@with_controlled_gate_array(_Z_ARRAY, num_ctrl_qubits=1)
+class CZGate(SingletonControlledGate):
+    r"""Controlled-Z gate.
+
+    This is a Clifford and symmetric gate.
+
+    Can be applied to a :class:`~qiskit.circuit.QuantumCircuit`
+    with the :meth:`~qiskit.circuit.QuantumCircuit.cz` method.
+
+    **Circuit symbol:**
+
+    .. code-block:: text
+
+        q_0: ─■─
+              │
+        q_1: ─■─
+
+    **Matrix representation:**
+
+    .. math::
+
+        CZ\ q_0, q_1 =
+            I \otimes |0\rangle\langle 0| + Z \otimes |1\rangle\langle 1| =
+            \begin{pmatrix}
+                1 & 0 & 0 & 0 \\
+                0 & 1 & 0 & 0 \\
+                0 & 0 & 1 & 0 \\
+                0 & 0 & 0 & -1
+            \end{pmatrix}
+
+    In the computational basis, this gate flips the phase of
+    the target qubit if the control qubit is in the :math:`|1\rangle` state.
+    """
+
+    _standard_gate = StandardGate.CZGate
+
+    def __init__(
+        self,
+        label: Optional[str] = None,
+        ctrl_state: Optional[Union[str, int]] = None,
+        *,
+        duration=None,
+        unit="dt",
+        _base_label=None,
+    ):
+        """Create new CZ gate."""
+        super().__init__(
+            "cz",
+            2,
+            [],
+            label=label,
+            num_ctrl_qubits=1,
+            ctrl_state=ctrl_state,
+            base_gate=ZGate(label=_base_label),
+            duration=duration,
+            unit=unit,
+        )
+
+    _singleton_lookup_key = stdlib_singleton_key(num_ctrl_qubits=1)
+
+    def _define(self):
+        """
+        gate cz a,b { h b; cx a,b; h b; }
+        """
+        # pylint: disable=cyclic-import
+        from qiskit.circuit.quantumcircuit import QuantumCircuit
+
+        from .h import HGate
+        from .x import CXGate
+
+        q = QuantumRegister(2, "q")
+        qc = QuantumCircuit(q, name=self.name)
+        rules = [(HGate(), [q[1]], []), (CXGate(), [q[0], q[1]], []), (HGate(), [q[1]], [])]
+        for instr, qargs, cargs in rules:
+            qc._append(instr, qargs, cargs)
+
+        self.definition = qc
+
+    def inverse(self, annotated: bool = False):
+        """Return inverted CZ gate (itself).
+
+        Args:
+            annotated: when set to ``True``, this is typically used to return an
+                :class:`.AnnotatedOperation` with an inverse modifier set instead of a concrete
+                :class:`.Gate`. However, for this class this argument is ignored as this gate
+                is self-inverse.
+
+        Returns:
+            CZGate: inverse gate (self-inverse).
+        """
+        return CZGate(ctrl_state=self.ctrl_state)  # self-inverse
+
+    def __eq__(self, other):
+        return isinstance(other, CZGate) and self.ctrl_state == other.ctrl_state
+
+
+@with_controlled_gate_array(_Z_ARRAY, num_ctrl_qubits=2, cached_states=(3,))
+class CCZGate(SingletonControlledGate):
+    r"""CCZ gate.
+
+    This is a symmetric gate.
+
+    Can be applied to a :class:`~qiskit.circuit.QuantumCircuit`
+    with the :meth:`~qiskit.circuit.QuantumCircuit.ccz` method.
+
+    **Circuit symbol:**
+
+    .. code-block:: text
+
+        q_0: ─■─
+              │
+        q_1: ─■─
+              │
+        q_2: ─■─
+
+    **Matrix representation:**
+
+    .. math::
+
+        CCZ\ q_0, q_1, q_2 =
+            I \otimes I \otimes |0\rangle\langle 0| + CZ \otimes |1\rangle\langle 1| =
+            \begin{pmatrix}
+                1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\
+                0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\
+                0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\
+                0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\
+                0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\
+                0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\
+                0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\
+                0 & 0 & 0 & 0 & 0 & 0 & 0 & -1
+            \end{pmatrix}
+
+    In the computational basis, this gate flips the phase of
+    the target qubit if the control qubits are in the :math:`|11\rangle` state.
+    """
+
+    _standard_gate = StandardGate.CCZGate
+
+    def __init__(
+        self,
+        label: Optional[str] = None,
+        ctrl_state: Optional[Union[str, int]] = None,
+        *,
+        duration=None,
+        unit="dt",
+        _base_label=None,
+    ):
+        """Create new CCZ gate."""
+        super().__init__(
+            "ccz",
+            3,
+            [],
+            label=label,
+            num_ctrl_qubits=2,
+            ctrl_state=ctrl_state,
+            base_gate=ZGate(label=_base_label),
+            duration=duration,
+            unit=unit,
+        )
+
+    _singleton_lookup_key = stdlib_singleton_key(num_ctrl_qubits=2)
+
+    def _define(self):
+        """
+        gate ccz a,b,c { h c; ccx a,b,c; h c; }
+        """
+        # pylint: disable=cyclic-import
+        from qiskit.circuit.quantumcircuit import QuantumCircuit
+
+        from .h import HGate
+        from .x import CCXGate
+
+        q = QuantumRegister(3, "q")
+        qc = QuantumCircuit(q, name=self.name)
+        rules = [(HGate(), [q[2]], []), (CCXGate(), [q[0], q[1], q[2]], []), (HGate(), [q[2]], [])]
+        for instr, qargs, cargs in rules:
+            qc._append(instr, qargs, cargs)
+
+        self.definition = qc
+
+    def inverse(self, annotated: bool = False):
+        """Return inverted CCZ gate (itself).
+
+        Args:
+            annotated: when set to ``True``, this is typically used to return an
+                :class:`.AnnotatedOperation` with an inverse modifier set instead of a concrete
+                :class:`.Gate`. However, for this class this argument is ignored as this gate
+                is self-inverse.
+
+        Returns:
+            CCZGate: inverse gate (self-inverse).
+        """
+        return CCZGate(ctrl_state=self.ctrl_state)  # self-inverse
+
+    def __eq__(self, other):
+        return isinstance(other, CCZGate) and self.ctrl_state == other.ctrl_state

qiskit/circuit/library/templates/__init__.py

@@ -0,0 +1,92 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2020.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""
+A library of template circuits.
+
+Templates are circuits that compute the identity. They find use
+in circuit optimization where matching part of the template allows the compiler
+to replace the match with the inverse of the remainder from the template.
+"""
+from .nct.template_nct_2a_1 import template_nct_2a_1
+from .nct.template_nct_2a_2 import template_nct_2a_2
+from .nct.template_nct_2a_3 import template_nct_2a_3
+from .nct.template_nct_4a_1 import template_nct_4a_1
+from .nct.template_nct_4a_2 import template_nct_4a_2
+from .nct.template_nct_4a_3 import template_nct_4a_3
+from .nct.template_nct_4b_1 import template_nct_4b_1
+from .nct.template_nct_4b_2 import template_nct_4b_2
+from .nct.template_nct_5a_1 import template_nct_5a_1
+from .nct.template_nct_5a_2 import template_nct_5a_2
+from .nct.template_nct_5a_3 import template_nct_5a_3
+from .nct.template_nct_5a_4 import template_nct_5a_4
+from .nct.template_nct_6a_1 import template_nct_6a_1
+from .nct.template_nct_6a_2 import template_nct_6a_2
+from .nct.template_nct_6a_3 import template_nct_6a_3
+from .nct.template_nct_6a_4 import template_nct_6a_4
+from .nct.template_nct_6b_1 import template_nct_6b_1
+from .nct.template_nct_6b_2 import template_nct_6b_2
+from .nct.template_nct_6c_1 import template_nct_6c_1
+from .nct.template_nct_7a_1 import template_nct_7a_1
+from .nct.template_nct_7b_1 import template_nct_7b_1
+from .nct.template_nct_7c_1 import template_nct_7c_1
+from .nct.template_nct_7d_1 import template_nct_7d_1
+from .nct.template_nct_7e_1 import template_nct_7e_1
+from .nct.template_nct_9a_1 import template_nct_9a_1
+from .nct.template_nct_9c_1 import template_nct_9c_1
+from .nct.template_nct_9c_2 import template_nct_9c_2
+from .nct.template_nct_9c_3 import template_nct_9c_3
+from .nct.template_nct_9c_4 import template_nct_9c_4
+from .nct.template_nct_9c_5 import template_nct_9c_5
+from .nct.template_nct_9c_6 import template_nct_9c_6
+from .nct.template_nct_9c_7 import template_nct_9c_7
+from .nct.template_nct_9c_8 import template_nct_9c_8
+from .nct.template_nct_9c_9 import template_nct_9c_9
+from .nct.template_nct_9c_10 import template_nct_9c_10
+from .nct.template_nct_9c_11 import template_nct_9c_11
+from .nct.template_nct_9c_12 import template_nct_9c_12
+from .nct.template_nct_9d_1 import template_nct_9d_1
+from .nct.template_nct_9d_2 import template_nct_9d_2
+from .nct.template_nct_9d_3 import template_nct_9d_3
+from .nct.template_nct_9d_4 import template_nct_9d_4
+from .nct.template_nct_9d_5 import template_nct_9d_5
+from .nct.template_nct_9d_6 import template_nct_9d_6
+from .nct.template_nct_9d_7 import template_nct_9d_7
+from .nct.template_nct_9d_8 import template_nct_9d_8
+from .nct.template_nct_9d_9 import template_nct_9d_9
+from .nct.template_nct_9d_10 import template_nct_9d_10
+
+from .rzx.rzx_yz import rzx_yz
+from .rzx.rzx_xz import rzx_xz
+from .rzx.rzx_cy import rzx_cy
+from .rzx.rzx_zz1 import rzx_zz1
+from .rzx.rzx_zz2 import rzx_zz2
+from .rzx.rzx_zz3 import rzx_zz3
+
+from .clifford.clifford_2_1 import clifford_2_1
+from .clifford.clifford_2_2 import clifford_2_2
+from .clifford.clifford_2_3 import clifford_2_3
+from .clifford.clifford_2_4 import clifford_2_4
+from .clifford.clifford_3_1 import clifford_3_1
+from .clifford.clifford_4_1 import clifford_4_1
+from .clifford.clifford_4_2 import clifford_4_2
+from .clifford.clifford_4_3 import clifford_4_3
+from .clifford.clifford_4_4 import clifford_4_4
+from .clifford.clifford_5_1 import clifford_5_1
+from .clifford.clifford_6_1 import clifford_6_1
+from .clifford.clifford_6_2 import clifford_6_2
+from .clifford.clifford_6_3 import clifford_6_3
+from .clifford.clifford_6_4 import clifford_6_4
+from .clifford.clifford_6_5 import clifford_6_5
+from .clifford.clifford_8_1 import clifford_8_1
+from .clifford.clifford_8_2 import clifford_8_2
+from .clifford.clifford_8_3 import clifford_8_3