qiskit 1.3.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/synthesis/cnotdihedral/cnotdihedral_decompose_two_qubits.py

@@ -0,0 +1,266 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2019, 2024.
+#
+# 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.
+"""
+Circuit synthesis for the CNOTDihedral class.
+"""
+
+import numpy as np
+from qiskit.circuit import QuantumCircuit
+from qiskit.exceptions import QiskitError
+from qiskit.quantum_info import CNOTDihedral
+
+
+def synth_cnotdihedral_two_qubits(elem: CNOTDihedral) -> QuantumCircuit:
+    """Decompose a :class:`.CNOTDihedral` element on a single qubit and two
+    qubits into a :class:`.QuantumCircuit`.
+    This decomposition has an optimal number of :class:`.CXGate`\\ s.
+
+    Args:
+        elem: A :class:`.CNOTDihedral` element.
+
+    Returns:
+        A circuit implementation of the :class:`.CNOTDihedral` element.
+
+    Raises:
+        QiskitError: if the element in not 1-qubit or 2-qubit :class:`.CNOTDihedral`.
+
+    References:
+        1. Shelly Garion and Andrew W. Cross, *On the structure of the CNOT-Dihedral group*,
+           `arXiv:2006.12042 [quant-ph] <https://arxiv.org/abs/2006.12042>`_
+    """
+
+    circuit = QuantumCircuit(elem.num_qubits)
+
+    if elem.num_qubits > 2:
+        raise QiskitError(
+            "Cannot decompose a CNOT-Dihedral element with more than 2 qubits. "
+            "use synth_cnotdihedral_full function instead."
+        )
+
+    if elem.num_qubits == 1:
+        if elem.poly.weight_0 != 0 or elem.linear != [[1]]:
+            raise QiskitError("1-qubit element in not CNOT-Dihedral .")
+        tpow0 = elem.poly.weight_1[0]
+        xpow0 = elem.shift[0]
+        if tpow0 > 0:
+            circuit.p((tpow0 * np.pi / 4), [0])
+        if xpow0 == 1:
+            circuit.x(0)
+        if tpow0 == 0 and xpow0 == 0:
+            circuit.id(0)
+        return circuit
+
+    # case elem.num_qubits == 2:
+    if elem.poly.weight_0 != 0:
+        raise QiskitError("2-qubit element in not CNOT-Dihedral .")
+    weight_1 = elem.poly.weight_1
+    weight_2 = elem.poly.weight_2
+    linear = elem.linear
+    shift = elem.shift
+
+    # CS subgroup
+    if (linear == [[1, 0], [0, 1]]).all():
+        [xpow0, xpow1] = shift
+
+        # Dihedral class
+        if weight_2 == [0]:
+            [tpow0, tpow1] = weight_1
+            if tpow0 > 0:
+                circuit.p((tpow0 * np.pi / 4), [0])
+            if xpow0 == 1:
+                circuit.x(0)
+            if tpow1 > 0:
+                circuit.p((tpow1 * np.pi / 4), [1])
+            if xpow1 == 1:
+                circuit.x(1)
+            if tpow0 == 0 and tpow1 == 0 and xpow0 == 0 and xpow1 == 0:
+                circuit.id(0)
+                circuit.id(1)
+
+        # CS-like class
+        if (weight_2 == [2] and xpow0 == xpow1) or (weight_2 == [6] and xpow0 != xpow1):
+            tpow0 = (weight_1[0] - 2 * xpow1 - 4 * xpow0 * xpow1) % 8
+            tpow1 = (weight_1[1] - 2 * xpow0 - 4 * xpow0 * xpow1) % 8
+            if tpow0 > 0:
+                circuit.p((tpow0 * np.pi / 4), [0])
+            if xpow0 == 1:
+                circuit.x(0)
+            if tpow1 > 0:
+                circuit.p((tpow1 * np.pi / 4), [1])
+            if xpow1 == 1:
+                circuit.x(1)
+            # CS gate is implemented using 2 CX gates
+            circuit.p((np.pi / 4), [0])
+            circuit.p((np.pi / 4), [1])
+            circuit.cx(0, 1)
+            circuit.p((7 * np.pi / 4), [1])
+            circuit.cx(0, 1)
+
+        # CSdg-like class
+        if (weight_2 == [6] and xpow0 == xpow1) or (weight_2 == [2] and xpow0 != xpow1):
+            tpow0 = (weight_1[0] - 6 * xpow1 - 4 * xpow0 * xpow1) % 8
+            tpow1 = (weight_1[1] - 6 * xpow0 - 4 * xpow0 * xpow1) % 8
+            if tpow0 > 0:
+                circuit.p((tpow0 * np.pi / 4), [0])
+            if xpow0 == 1:
+                circuit.x(0)
+            if tpow1 > 0:
+                circuit.p((tpow1 * np.pi / 4), [1])
+            if xpow1 == 1:
+                circuit.x(1)
+            # CSdg gate is implemented using 2 CX gates
+            circuit.p((7 * np.pi / 4), [0])
+            circuit.p((7 * np.pi / 4), [1])
+            circuit.cx(0, 1)
+            circuit.p((np.pi / 4), [1])
+            circuit.cx(0, 1)
+
+        # CZ-like class
+        if weight_2 == [4]:
+            tpow0 = (weight_1[0] - 4 * xpow1) % 8
+            tpow1 = (weight_1[1] - 4 * xpow0) % 8
+            if tpow0 > 0:
+                circuit.p((tpow0 * np.pi / 4), [0])
+            if xpow0 == 1:
+                circuit.x(0)
+            if tpow1 > 0:
+                circuit.p((tpow1 * np.pi / 4), [1])
+            if xpow1 == 1:
+                circuit.x(1)
+            # CZ gate is implemented using 2 CX gates
+            circuit.cz(1, 0)
+
+    # CX01-like class
+    if (linear == [[1, 0], [1, 1]]).all():
+        xpow0 = shift[0]
+        xpow1 = (shift[1] + xpow0) % 2
+        if xpow0 == xpow1:
+            m = ((8 - weight_2[0]) / 2) % 4
+            tpow0 = (weight_1[0] - m) % 8
+            tpow1 = (weight_1[1] - m) % 8
+        else:
+            m = (weight_2[0] / 2) % 4
+            tpow0 = (weight_1[0] + m) % 8
+            tpow1 = (weight_1[1] + m) % 8
+        if tpow0 > 0:
+            circuit.p((tpow0 * np.pi / 4), [0])
+        if xpow0 == 1:
+            circuit.x(0)
+        if tpow1 > 0:
+            circuit.p((tpow1 * np.pi / 4), [1])
+        if xpow1 == 1:
+            circuit.x(1)
+        circuit.cx(0, 1)
+        if m > 0:
+            circuit.p((m * np.pi / 4), [1])
+
+    # CX10-like class
+    if (linear == [[1, 1], [0, 1]]).all():
+        xpow1 = shift[1]
+        xpow0 = (shift[0] + xpow1) % 2
+        if xpow0 == xpow1:
+            m = ((8 - weight_2[0]) / 2) % 4
+            tpow0 = (weight_1[0] - m) % 8
+            tpow1 = (weight_1[1] - m) % 8
+        else:
+            m = (weight_2[0] / 2) % 4
+            tpow0 = (weight_1[0] + m) % 8
+            tpow1 = (weight_1[1] + m) % 8
+        if tpow0 > 0:
+            circuit.p((tpow0 * np.pi / 4), [0])
+        if xpow0 == 1:
+            circuit.x(0)
+        if tpow1 > 0:
+            circuit.p((tpow1 * np.pi / 4), [1])
+        if xpow1 == 1:
+            circuit.x(1)
+        circuit.cx(1, 0)
+        if m > 0:
+            circuit.p((m * np.pi / 4), [0])
+
+    # CX01*CX10-like class
+    if (linear == [[0, 1], [1, 1]]).all():
+        xpow1 = shift[0]
+        xpow0 = (shift[1] + xpow1) % 2
+        if xpow0 == xpow1:
+            m = ((8 - weight_2[0]) / 2) % 4
+            tpow0 = (weight_1[0] - m) % 8
+            tpow1 = (weight_1[1] - m) % 8
+        else:
+            m = (weight_2[0] / 2) % 4
+            tpow0 = (weight_1[0] + m) % 8
+            tpow1 = (weight_1[1] + m) % 8
+        if tpow0 > 0:
+            circuit.p((tpow0 * np.pi / 4), [0])
+        if xpow0 == 1:
+            circuit.x(0)
+        if tpow1 > 0:
+            circuit.p((tpow1 * np.pi / 4), [1])
+        if xpow1 == 1:
+            circuit.x(1)
+        circuit.cx(0, 1)
+        circuit.cx(1, 0)
+        if m > 0:
+            circuit.p((m * np.pi / 4), [1])
+
+    # CX10*CX01-like class
+    if (linear == [[1, 1], [1, 0]]).all():
+        xpow0 = shift[1]
+        xpow1 = (shift[0] + xpow0) % 2
+        if xpow0 == xpow1:
+            m = ((8 - weight_2[0]) / 2) % 4
+            tpow0 = (weight_1[0] - m) % 8
+            tpow1 = (weight_1[1] - m) % 8
+        else:
+            m = (weight_2[0] / 2) % 4
+            tpow0 = (weight_1[0] + m) % 8
+            tpow1 = (weight_1[1] + m) % 8
+        if tpow0 > 0:
+            circuit.p((tpow0 * np.pi / 4), [0])
+        if xpow0 == 1:
+            circuit.x(0)
+        if tpow1 > 0:
+            circuit.p((tpow1 * np.pi / 4), [1])
+        if xpow1 == 1:
+            circuit.x(1)
+        circuit.cx(1, 0)
+        circuit.cx(0, 1)
+        if m > 0:
+            circuit.p((m * np.pi / 4), [0])
+
+    # CX01*CX10*CX01-like class
+    if (linear == [[0, 1], [1, 0]]).all():
+        xpow0 = shift[1]
+        xpow1 = shift[0]
+        if xpow0 == xpow1:
+            m = ((8 - weight_2[0]) / 2) % 4
+            tpow0 = (weight_1[0] - m) % 8
+            tpow1 = (weight_1[1] - m) % 8
+        else:
+            m = (weight_2[0] / 2) % 4
+            tpow0 = (weight_1[0] + m) % 8
+            tpow1 = (weight_1[1] + m) % 8
+        if tpow0 > 0:
+            circuit.p((tpow0 * np.pi / 4), [0])
+        if xpow0 == 1:
+            circuit.x(0)
+        if tpow1 > 0:
+            circuit.p((tpow1 * np.pi / 4), [1])
+        if xpow1 == 1:
+            circuit.x(1)
+        circuit.cx(0, 1)
+        circuit.cx(1, 0)
+        if m > 0:
+            circuit.p((m * np.pi / 4), [1])
+        circuit.cx(0, 1)
+
+    return circuit

qiskit/synthesis/discrete_basis/__init__.py

@@ -0,0 +1,16 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2022.
+#
+# 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.
+
+"""Discrete basis synthesis algorithms."""
+
+from .solovay_kitaev import SolovayKitaevDecomposition
+from .generate_basis_approximations import generate_basic_approximations

qiskit/synthesis/discrete_basis/commutator_decompose.py

@@ -0,0 +1,241 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2022.
+#
+# 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.
+
+"""Functions to compute the decomposition of an SO(3) matrix as balanced commutator."""
+
+from __future__ import annotations
+
+import math
+import numpy as np
+from qiskit.quantum_info.operators.predicates import is_identity_matrix
+from .gate_sequence import _check_is_so3, GateSequence
+
+
+def _compute_trace_so3(matrix: np.ndarray) -> float:
+    """Computes trace of an SO(3)-matrix.
+
+    Args:
+        matrix: an SO(3)-matrix
+
+    Returns:
+        Trace of ``matrix``.
+
+    Raises:
+        ValueError: if ``matrix`` is not an SO(3)-matrix.
+    """
+    _check_is_so3(matrix)
+
+    trace = np.matrix.trace(matrix)
+    trace_rounded = min(trace, 3)
+    return trace_rounded
+
+
+def _compute_rotation_axis(matrix: np.ndarray) -> np.ndarray:
+    """Computes rotation axis of SO(3)-matrix.
+
+    Args:
+        matrix: The SO(3)-matrix for which rotation angle needs to be computed.
+
+    Returns:
+        The rotation axis of the SO(3)-matrix ``matrix``.
+
+    Raises:
+        ValueError: if ``matrix`` is not an SO(3)-matrix.
+    """
+    _check_is_so3(matrix)
+
+    trace = _compute_trace_so3(matrix)
+    theta = math.acos(0.5 * (trace - 1))
+    if math.sin(theta) > 1e-10:
+        x = 1 / (2 * math.sin(theta)) * (matrix[2][1] - matrix[1][2])
+        y = 1 / (2 * math.sin(theta)) * (matrix[0][2] - matrix[2][0])
+        z = 1 / (2 * math.sin(theta)) * (matrix[1][0] - matrix[0][1])
+    else:
+        x = 1.0
+        y = 0.0
+        z = 0.0
+    return np.array([x, y, z])
+
+
+def _solve_decomposition_angle(matrix: np.ndarray) -> float:
+    """Computes angle for balanced commutator of SO(3)-matrix ``matrix``.
+
+    Computes angle a so that the SO(3)-matrix ``matrix`` can be decomposed
+    as commutator [v,w] where v and w are both rotations of a about some axis.
+    The computation is done by solving a trigonometric equation using scipy.optimize.fsolve.
+
+    Args:
+        matrix: The SO(3)-matrix for which the decomposition angle needs to be computed.
+
+    Returns:
+        Angle a so that matrix = [v,w] with v and w rotations of a about some axis.
+
+    Raises:
+        ValueError: if ``matrix`` is not an SO(3)-matrix.
+    """
+    from scipy.optimize import fsolve
+
+    _check_is_so3(matrix)
+
+    trace = _compute_trace_so3(matrix)
+    angle = math.acos((1 / 2) * (trace - 1))
+
+    lhs = math.sin(angle / 2)
+
+    def objective(phi):
+        sin_sq = math.sin(phi.item() / 2) ** 2
+        return 2 * sin_sq * math.sqrt(1 - sin_sq**2) - lhs
+
+    decomposition_angle = fsolve(objective, angle)[0]
+    return decomposition_angle
+
+
+def _compute_rotation_from_angle_and_axis(angle: float, axis: np.ndarray) -> np.ndarray:
+    """Computes the SO(3)-matrix corresponding to the rotation of ``angle`` about ``axis``.
+
+    Args:
+        angle: The angle of the rotation.
+        axis: The axis of the rotation.
+
+    Returns:
+        SO(3)-matrix that represents a rotation of ``angle`` about ``axis``.
+
+    Raises:
+        ValueError: if ``axis`` is not a 3-dim unit vector.
+    """
+    if axis.shape != (3,):
+        raise ValueError(f"Axis must be a 1d array of length 3, but has shape {axis.shape}.")
+
+    if abs(np.linalg.norm(axis) - 1.0) > 1e-4:
+        raise ValueError(f"Axis must have a norm of 1, but has {np.linalg.norm(axis)}.")
+
+    res = math.cos(angle) * np.identity(3) + math.sin(angle) * _cross_product_matrix(axis)
+    res += (1 - math.cos(angle)) * np.outer(axis, axis)
+    return res
+
+
+def _compute_rotation_between(from_vector: np.ndarray, to_vector: np.ndarray) -> np.ndarray:
+    """Computes the SO(3)-matrix for rotating ``from_vector`` to ``to_vector``.
+
+    Args:
+        from_vector: unit vector of size 3
+        to_vector: unit vector of size 3
+
+    Returns:
+        SO(3)-matrix that brings ``from_vector`` to ``to_vector``.
+
+    Raises:
+        ValueError: if at least one of ``from_vector`` of ``to_vector`` is not a 3-dim unit vector.
+    """
+    from_vector = from_vector / np.linalg.norm(from_vector)
+    to_vector = to_vector / np.linalg.norm(to_vector)
+
+    dot = np.dot(from_vector, to_vector)
+    cross = _cross_product_matrix(np.cross(from_vector, to_vector))
+    rotation_matrix = np.identity(3) + cross + np.dot(cross, cross) / (1 + dot)
+    return rotation_matrix
+
+
+def _cross_product_matrix(v: np.ndarray) -> np.ndarray:
+    """Computes cross product matrix from vector.
+
+    Args:
+        v: Vector for which cross product matrix needs to be computed.
+
+    Returns:
+        The cross product matrix corresponding to vector ``v``.
+    """
+    return np.array([[0, -v[2], v[1]], [v[2], 0, -v[0]], [-v[1], v[0], 0]])
+
+
+def _compute_commutator_so3(a: np.ndarray, b: np.ndarray) -> np.ndarray:
+    """Computes the commutator of the SO(3)-matrices ``a`` and ``b``.
+
+    The computation uses the fact that the inverse of an SO(3)-matrix is equal to its transpose.
+
+    Args:
+        a: SO(3)-matrix
+        b: SO(3)-matrix
+
+    Returns:
+        The commutator [a,b] of ``a`` and ``b`` w
+
+    Raises:
+        ValueError: if at least one of ``a`` or ``b`` is not an SO(3)-matrix.
+    """
+    _check_is_so3(a)
+    _check_is_so3(b)
+
+    a_dagger = np.conj(a).T
+    b_dagger = np.conj(b).T
+
+    return np.dot(np.dot(np.dot(a, b), a_dagger), b_dagger)
+
+
+def commutator_decompose(
+    u_so3: np.ndarray, check_input: bool = True
+) -> tuple[GateSequence, GateSequence]:
+    r"""Decompose an :math:`SO(3)`-matrix, :math:`U` as a balanced commutator.
+
+    This function finds two :math:`SO(3)` matrices :math:`V, W` such that the input matrix
+    equals
+
+    .. math::
+
+        U = V^\dagger W^\dagger V W.
+
+    For this decomposition, the following statement holds
+
+
+    .. math::
+
+        ||V - I||_F, ||W - I||_F \leq \frac{\sqrt{||U - I||_F}}{2},
+
+    where :math:`I` is the identity and :math:`||\cdot ||_F` is the Frobenius norm.
+
+    Args:
+        u_so3: SO(3)-matrix that needs to be decomposed as balanced commutator.
+        check_input: If True, checks whether the input matrix is actually SO(3).
+
+    Returns:
+        Tuple of GateSequences from SO(3)-matrices :math:`V, W`.
+
+    Raises:
+        ValueError: if ``u_so3`` is not an SO(3)-matrix.
+    """
+    if check_input:
+        # assert that the input matrix is really SO(3)
+        _check_is_so3(u_so3)
+
+        if not is_identity_matrix(u_so3.dot(u_so3.T)):
+            raise ValueError("Input matrix is not orthogonal.")
+
+    angle = _solve_decomposition_angle(u_so3)
+
+    # Compute rotation about x-axis with angle 'angle'
+    vx = _compute_rotation_from_angle_and_axis(angle, np.array([1, 0, 0]))
+
+    # Compute rotation about y-axis with angle 'angle'
+    wy = _compute_rotation_from_angle_and_axis(angle, np.array([0, 1, 0]))
+
+    commutator = _compute_commutator_so3(vx, wy)
+
+    u_so3_axis = _compute_rotation_axis(u_so3)
+    commutator_axis = _compute_rotation_axis(commutator)
+
+    sim_matrix = _compute_rotation_between(commutator_axis, u_so3_axis)
+    sim_matrix_dagger = np.conj(sim_matrix).T
+
+    v = np.dot(np.dot(sim_matrix, vx), sim_matrix_dagger)
+    w = np.dot(np.dot(sim_matrix, wy), sim_matrix_dagger)
+
+    return GateSequence.from_matrix(v), GateSequence.from_matrix(w)