qiskit 2.1.0rc1__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/synthesis/two_qubit/xx_decompose/polytopes.py

@@ -0,0 +1,262 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021
+#
+# 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.
+
+"""
+Defines bare dataclasses which house polytope information, as well as a specialized data structure
+which describes those two-qubit programs accessible to a given sequence of XX-type interactions.
+"""
+
+from __future__ import annotations
+from copy import copy
+from dataclasses import dataclass, field
+from itertools import combinations
+
+import numpy as np
+
+from qiskit.exceptions import QiskitError
+
+from .utilities import EPSILON
+
+
+@dataclass
+class ConvexPolytopeData:
+    """
+    The raw data underlying a ConvexPolytope.  Describes a single convex
+    polytope, specified by families of `inequalities` and `equalities`, each
+    entry of which respectively corresponds to
+
+        inequalities[j][0] + sum_i inequalities[j][i] * xi >= 0
+
+    and
+
+        equalities[j][0] + sum_i equalities[j][i] * xi == 0.
+    """
+
+    inequalities: list[list[int]]
+    equalities: list[list[int]] = field(default_factory=list)
+    name: str = ""
+
+
+@dataclass
+class PolytopeData:
+    """
+    The raw data of a union of convex polytopes.
+    """
+
+    convex_subpolytopes: list[ConvexPolytopeData]
+
+
+def polytope_has_element(polytope, point):
+    """
+    Tests whether `polytope` contains `point.
+    """
+    return all(
+        -EPSILON <= inequality[0] + sum(x * y for x, y in zip(point, inequality[1:]))
+        for inequality in polytope.inequalities
+    ) and all(
+        abs(equality[0] + sum(x * y for x, y in zip(point, equality[1:]))) <= EPSILON
+        for equality in polytope.equalities
+    )
+
+
+def manual_get_vertex(polytope, seed=42):
+    """
+    Returns a single random vertex from `polytope`.
+    """
+    rng = np.random.default_rng(seed)
+
+    if isinstance(polytope, PolytopeData):
+        paragraphs = copy(polytope.convex_subpolytopes)
+    elif isinstance(polytope, ConvexPolytopeData):
+        paragraphs = [polytope]
+    else:
+        raise TypeError(f"{type(polytope)} is not polytope-like.")
+
+    rng.shuffle(paragraphs)
+    for convex_subpolytope in paragraphs:
+        sentences = convex_subpolytope.inequalities + convex_subpolytope.equalities
+        if len(sentences) == 0:
+            continue
+        dimension = len(sentences[0]) - 1
+        rng.shuffle(sentences)
+        for inequalities in combinations(sentences, dimension):
+            matrix = np.array([x[1:] for x in inequalities])
+            b = np.array([x[0] for x in inequalities])
+            try:
+                vertex = np.linalg.inv(-matrix) @ b
+                if polytope_has_element(convex_subpolytope, vertex):
+                    return vertex
+            except np.linalg.LinAlgError:
+                pass
+
+    raise QiskitError(f"Polytope has no feasible solutions:\n{polytope}")
+
+
+@dataclass
+class XXPolytope:
+    """
+    Describes those two-qubit programs accessible to a given sequence of XX-type interactions.
+
+    NOTE: Strengths are normalized so that CX corresponds to pi / 4, which differs from Qiskit's
+          conventions around RZX elsewhere.
+    """
+
+    # NOTE: This is _not_ a subclass of PolytopeData, because we're never going to call slow,
+    #       generic PolytopeData functions on it.
+
+    total_strength: float = 0.0
+    max_strength: float = 0.0
+    place_strength: float = 0.0
+
+    @classmethod
+    def from_strengths(cls, *strengths):
+        """
+        Constructs an XXPolytope from a sequence of strengths.
+        """
+        total_strength, max_strength, place_strength = 0, 0, 0
+        for strength in strengths:
+            total_strength += strength
+            if strength >= max_strength:
+                max_strength, place_strength = strength, max_strength
+            elif strength >= place_strength:
+                place_strength = strength
+
+        return XXPolytope(
+            total_strength=total_strength, max_strength=max_strength, place_strength=place_strength
+        )
+
+    def add_strength(self, new_strength: float = 0.0):
+        """
+        Returns a new XXPolytope with one new XX interaction appended.
+        """
+        return XXPolytope(
+            total_strength=self.total_strength + new_strength,
+            max_strength=max(self.max_strength, new_strength),
+            place_strength=(
+                self.max_strength
+                if new_strength > self.max_strength
+                else new_strength if new_strength > self.place_strength else self.place_strength
+            ),
+        )
+
+    @property
+    def _offsets(self):
+        """
+        Returns b with A*x + b ≥ 0 iff x belongs to the XXPolytope.
+        """
+        return np.array(
+            [
+                0,
+                0,
+                0,
+                np.pi / 2,
+                self.total_strength,
+                self.total_strength - 2 * self.max_strength,
+                self.total_strength - self.max_strength - self.place_strength,
+            ]
+        )
+
+    def member(self, point):
+        """
+        Returns True when `point` is a member of `self`.
+        """
+
+        reflected_point = point.copy().reshape(-1, 3)
+        rows = reflected_point[:, 0] >= np.pi / 4 + EPSILON
+        reflected_point[rows, 0] = np.pi / 2 - reflected_point[rows, 0]
+        reflected_point = reflected_point.reshape(point.shape)
+
+        return np.all(
+            self._offsets + np.einsum("ij,...j->...i", A, reflected_point) >= -EPSILON, axis=-1
+        )
+
+    def nearest(self, point):
+        """
+        Finds the nearest point (in Euclidean or infidelity distance) to `self`.
+        """
+        # pylint:disable=invalid-name
+
+        # NOTE: A CAS says that there are no degenerate double intersections, and the only
+        #       degenerate triple intersections are
+        #
+        #           (1, -1, 0), (0, 0, 1), (-1, 1, 1) and (1, 1, 0), (0, 0, 1), (1, 1, 1).
+        #
+        #       Skipping this pair won't save much work, so we don't bother.
+
+        # A1, A1inv, A2, A2inv, A3, A3inv
+        # These global variables contain projection matrices, computed once-and-for-all, which
+        # produce the Euclidean-nearest projection.
+
+        if isinstance(point, np.ndarray) and len(point.shape) == 1:
+            y0 = point.copy()
+        elif isinstance(point, list):
+            y0 = np.array(point)
+        else:
+            raise TypeError(f"Can't handle type of point: {point} ({type(point)})")
+
+        reflected_p = y0[0] > np.pi / 4 + EPSILON
+        if reflected_p:
+            y0[0] = np.pi / 2 - y0[0]
+
+        # short circuit in codimension 0
+        if self.member(y0):
+            if reflected_p:
+                y0[0] = np.pi / 2 - y0[0]
+            return y0
+
+        # codimension 1
+        b1 = self._offsets.reshape(7, 1)
+        A1y0 = np.einsum("ijk,k->ij", A1, y0)
+        nearest1 = np.einsum("ijk,ik->ij", A1inv, b1 + A1y0) - y0
+
+        # codimension 2
+        b2 = np.array([*combinations(self._offsets, 2)])
+        A2y0 = np.einsum("ijk,k->ij", A2, y0)
+        nearest2 = np.einsum("ijk,ik->ij", A2inv, b2 + A2y0) - y0
+
+        # codimension 3
+        b3 = np.array([*combinations(self._offsets, 3)])
+        nearest3 = np.einsum("ijk,ik->ij", A3inv, b3)
+
+        # pick the nearest
+        nearest = -np.concatenate([nearest1, nearest2, nearest3])
+        nearest = nearest[self.member(nearest)]
+        smallest_index = np.argmin(np.linalg.norm(nearest - y0, axis=1))
+
+        if reflected_p:
+            nearest[smallest_index][0] = np.pi / 2 - nearest[smallest_index][0]
+        return nearest[smallest_index]
+
+
+A = np.array(
+    [
+        [1, -1, 0],  # a ≥ b
+        [0, 1, -1],  # b ≥ c
+        [0, 0, 1],  # c ≥ 0
+        [-1, -1, 0],  # pi/2 ≥ a + b
+        [-1, -1, -1],  # strength
+        [1, -1, -1],  # slant
+        [0, 0, -1],  # frustrum
+    ]
+)
+A1 = A.reshape(-1, 1, 3)  # pylint:disable=too-many-function-args
+A1inv = np.linalg.pinv(A1)
+A2 = np.array([np.array([x, y], dtype=float) for (x, y) in combinations(A, 2)])
+A2inv = np.linalg.pinv(A2)
+A3 = np.array([np.array([x, y, z], dtype=float) for (x, y, z) in combinations(A, 3)])
+A3inv = np.linalg.pinv(A3)
+"""
+These globals house matrices, computed once-and-for-all, which project onto the Euclidean-nearest
+planes spanned by the planes/points/lines defined by the faces of any XX polytope.
+
+See `XXPolytope.nearest`.
+"""

qiskit/synthesis/two_qubit/xx_decompose/utilities.py

@@ -0,0 +1,40 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021
+#
+# 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.
+
+"""
+Depository for generic utility snippets.
+"""
+
+from __future__ import annotations
+import warnings
+
+import numpy as np
+
+
+EPSILON = 1e-6  # Fraction(1, 1_000_000)
+
+
+# TODO: THIS IS A STOPGAP!!!
+def safe_arccos(numerator, denominator):
+    """
+    Computes arccos(n/d) with different (better?) numerical stability.
+    """
+    threshold = 0.005
+
+    if abs(numerator) > abs(denominator) and abs(numerator - denominator) < threshold:
+        return 0.0
+    elif abs(numerator) > abs(denominator) and abs(numerator + denominator) < threshold:
+        return np.pi
+    else:
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore", category=RuntimeWarning)
+            return np.arccos(numerator / denominator)

qiskit/synthesis/two_qubit/xx_decompose/weyl.py

@@ -0,0 +1,133 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021
+#
+# 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.
+
+"""
+Simple circuit constructors for Weyl reflections.
+"""
+
+from __future__ import annotations
+import numpy as np
+
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit.library.standard_gates import RXGate, RYGate, RZGate
+
+
+reflection_options = {
+    "no reflection": ([1, 1, 1], 1, []),
+    "reflect XX, YY": ([-1, -1, 1], 1, [RZGate]),
+    "reflect XX, ZZ": ([-1, 1, -1], 1, [RYGate]),
+    "reflect YY, ZZ": ([1, -1, -1], 1, [RXGate]),
+}
+"""
+A table of available reflection transformations on canonical coordinates.
+Entries take the form
+
+    readable_name: (reflection scalars, global phase, [gate constructors]),
+
+where reflection scalars (a, b, c) model the map (x, y, z) |-> (ax, by, cz),
+global phase is a complex unit, and gate constructors are applied in sequence
+and by conjugation to the first qubit and are passed pi as a parameter.
+"""
+
+shift_options = {
+    "no shift": ([0, 0, 0], 1, []),
+    "Z shift": ([0, 0, 1], 1j, [RZGate]),
+    "Y shift": ([0, 1, 0], -1j, [RYGate]),
+    "Y,Z shift": ([0, 1, 1], 1, [RYGate, RZGate]),
+    "X shift": ([1, 0, 0], -1j, [RXGate]),
+    "X,Z shift": ([1, 0, 1], 1, [RXGate, RZGate]),
+    "X,Y shift": ([1, 1, 0], -1, [RXGate, RYGate]),
+    "X,Y,Z shift": ([1, 1, 1], -1j, [RXGate, RYGate, RZGate]),
+}
+"""
+A table of available shift transformations on canonical coordinates.  Entries
+take the form
+
+    readable name: (shift scalars, global phase, [gate constructors]),
+
+where shift scalars model the map
+
+    (x, y, z) |-> (x + a pi / 2, y + b pi / 2, z + c pi / 2) ,
+
+global phase is a complex unit, and gate constructors are applied to the first
+and second qubits and are passed pi as a parameter.
+"""
+
+
+def apply_reflection(reflection_name, coordinate):
+    """
+    Given a reflection type and a canonical coordinate, applies the reflection
+    and describes a circuit which enacts the reflection + a global phase shift.
+    """
+    reflection_scalars, reflection_phase_shift, source_reflection_gates = reflection_options[
+        reflection_name
+    ]
+    reflected_coord = [x * y for x, y in zip(reflection_scalars, coordinate)]
+    source_reflection = QuantumCircuit(2)
+    for gate in source_reflection_gates:
+        source_reflection.append(gate(np.pi), [0])
+
+    return reflected_coord, source_reflection, reflection_phase_shift
+
+
+def apply_shift(shift_name, coordinate):
+    """
+    Given a shift type and a canonical coordinate, applies the shift and
+    describes a circuit which enacts the shift + a global phase shift.
+    """
+    shift_scalars, shift_phase_shift, source_shift_gates = shift_options[shift_name]
+    shifted_coord = [np.pi / 2 * x + y for x, y in zip(shift_scalars, coordinate)]
+
+    source_shift = QuantumCircuit(2)
+    for gate in source_shift_gates:
+        source_shift.append(gate(np.pi), [0])
+        source_shift.append(gate(np.pi), [1])
+
+    return shifted_coord, source_shift, shift_phase_shift
+
+
+def canonical_rotation_circuit(first_index, second_index):
+    """
+    Given a pair of distinct indices 0 ≤ (first_index, second_index) ≤ 2,
+    produces a two-qubit circuit which rotates a canonical gate
+
+        a0 XX + a1 YY + a2 ZZ
+
+    into
+
+        a[first] XX + a[second] YY + a[other] ZZ .
+    """
+    conj = QuantumCircuit(2)
+
+    if (0, 1) == (first_index, second_index):
+        pass  # no need to do anything
+    elif (0, 2) == (first_index, second_index):
+        conj.rx(-np.pi / 2, [0])
+        conj.rx(np.pi / 2, [1])
+    elif (1, 0) == (first_index, second_index):
+        conj.rz(-np.pi / 2, [0])
+        conj.rz(-np.pi / 2, [1])
+    elif (1, 2) == (first_index, second_index):
+        conj.rz(np.pi / 2, [0])
+        conj.rz(np.pi / 2, [1])
+        conj.ry(np.pi / 2, [0])
+        conj.ry(-np.pi / 2, [1])
+    elif (2, 0) == (first_index, second_index):
+        conj.rz(np.pi / 2, [0])
+        conj.rz(np.pi / 2, [1])
+        conj.rx(np.pi / 2, [0])
+        conj.rx(-np.pi / 2, [1])
+    elif (2, 1) == (first_index, second_index):
+        conj.ry(np.pi / 2, [0])
+        conj.ry(-np.pi / 2, [1])
+
+    return conj

qiskit/synthesis/unitary/__init__.py

@@ -0,0 +1,13 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2023.
+#
+# 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.
+
+"""Module containing unitary synthesis methods."""

qiskit/synthesis/unitary/aqc/__init__.py

@@ -0,0 +1,177 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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.
+
+r"""
+=====================================================================
+Approximate Quantum Compiler (:mod:`qiskit.synthesis.unitary.aqc`)
+=====================================================================
+
+.. currentmodule:: qiskit.synthesis.unitary.aqc
+
+Implementation of Approximate Quantum Compiler as described in the paper [1].
+
+Interface
+=========
+
+The main public interface of this module is reached by passing ``unitary_synthesis_method='aqc'`` to
+:func:`~.compiler.transpile`.  This will swap the synthesis method to use
+:class:`~.transpiler.passes.synthesis.AQCSynthesisPlugin`.
+The individual classes are:
+
+.. autosummary::
+    :toctree: ../stubs
+    :template: autosummary/class_no_inherited_members.rst
+
+    AQC
+    ApproximateCircuit
+    ApproximatingObjective
+    CNOTUnitCircuit
+    CNOTUnitObjective
+    DefaultCNOTUnitObjective
+    FastCNOTUnitObjective
+
+
+Mathematical Detail
+===================
+
+We are interested in compiling a quantum circuit, which we formalize as finding the best
+circuit representation in terms of an ordered gate sequence of a target unitary matrix
+:math:`U\in U(d)`, with some additional hardware constraints. In particular, we look at
+representations that could be constrained in terms of hardware connectivity, as well
+as gate depth, and we choose a gate basis in terms of CNOT and rotation gates.
+We recall that the combination of CNOT and rotation gates is universal in :math:`SU(d)` and
+therefore it does not limit compilation.
+
+To properly define what we mean by best circuit representation, we define the metric
+as the Frobenius norm between the unitary matrix of the compiled circuit :math:`V` and
+the target unitary matrix :math:`U`, i.e., :math:`\|V - U\|_{\mathrm{F}}`. This choice
+is motivated by mathematical programming considerations, and it is related to other
+formulations that appear in the literature. Let's take a look at the problem in more details.
+
+Let :math:`n` be the number of qubits and :math:`d=2^n`. Given a CNOT structure :math:`ct`
+and a vector of rotation angles :math:`\theta`, the parametric circuit forms a matrix
+:math:`Vct(\theta)\in SU(d)`. If we are given a target circuit forming a matrix
+:math:`U\in SU(d)`, then we would like to compute
+
+.. math::
+
+    \mathrm{argmax}_{\theta}\frac{1}{d}|\langle Vct(\theta),U\rangle|
+
+where the inner product is the Frobenius inner product. Note that
+:math:`|\langle V,U\rangle|\leq d` for all unitaries :math:`U` and :math:`V`, so the objective
+has range in :math:`[0,1]`.
+
+Our strategy is to maximize
+
+.. math::
+
+    \frac{1}{d}\Re \langle Vct(\theta),U\rangle
+
+using its gradient. We will now discuss the specifics by going through an example.
+
+While the range of :math:`Vct` is a subset of :math:`SU(d)` by construction, the target
+circuit may form a general unitary matrix. However, for any :math:`U\in U(d)`,
+
+.. math::
+
+    \frac{\exp(2\pi i k/d)}{\det(U)^{1/d}}U\in SU(d)\text{ for all }k\in\{0,\ldots,d-1\}.
+
+Thus, we should normalize the target circuit by its global phase and then approximately
+compile the normalized circuit. We can add the global phase back in afterwards.
+
+In the algorithm let :math:`U'` denote the un-normalized target matrix and :math:`U`
+the normalized  target matrix. Now that we have :math:`U`, we give the gradient function
+to the Nesterov's method optimizer and compute :math:`\theta`.
+
+To add the global phase back in, we can form the control circuit as
+
+.. math::
+
+    \frac{\langle Vct(\theta),U'\rangle}{|\langle Vct(\theta),U'\rangle|}Vct(\theta).
+
+Note that while we optimized using Nesterov's method in the paper, this was for its convergence
+guarantees, not its speed in practice. It is much faster to use L-BFGS which is used as a
+default optimizer in this implementation.
+
+A basic usage of the AQC algorithm should consist of the following steps::
+
+    # Define a target circuit as a unitary matrix
+    unitary = ...
+
+    # Define a number of qubits for the algorithm, at least 3 qubits
+    num_qubits = round(math.log2(unitary.shape[0]))
+
+    # Choose a layout of the CNOT structure for the approximate circuit, e.g. ``spin`` for
+    # a linear layout.
+    layout = options.get("layout") or "spin"
+
+    # Choose a connectivity type, e.g. ``full`` for full connectivity between qubits.
+    connectivity = options.get("connectivity") or "full"
+
+    # Define a targeted depth of the approximate circuit in the number of CNOT units.
+    depth = int(options.get("depth") or 0)
+
+    # Generate a network made of CNOT units
+    cnots = make_cnot_network(
+        num_qubits=num_qubits,
+        network_layout=layout,
+        connectivity_type=connectivity,
+        depth=depth
+    )
+
+    # Create an optimizer to be used by AQC
+    optimizer = partial(scipy.optimize.minimize, method="L-BFGS-B")
+
+    # Create an instance
+    aqc = AQC(optimizer)
+
+    # Create a template circuit that will approximate our target circuit
+    approximate_circuit = CNOTUnitCircuit(num_qubits=num_qubits, cnots=cnots)
+
+    # Create an objective that defines our optimization problem
+    approximating_objective = DefaultCNOTUnitObjective(num_qubits=num_qubits, cnots=cnots)
+
+    # Run optimization process to compile the unitary
+    aqc.compile_unitary(
+        target_matrix=unitary,
+        approximate_circuit=approximate_circuit,
+        approximating_objective=approximating_objective
+    )
+
+Now ``approximate_circuit`` is a circuit that approximates the target unitary to a certain
+degree and can be used instead of the original matrix.
+
+This uses a helper function, :obj:`make_cnot_network`.
+
+.. autofunction:: make_cnot_network
+
+One can take advantage of accelerated version of objective function. It implements the same
+mathematical algorithm as the default one ``DefaultCNOTUnitObjective`` but runs several times
+faster. Instantiation of accelerated objective function class is similar to the default case:
+
+    # Create an objective that defines our optimization problem
+    approximating_objective = FastCNOTUnitObjective(num_qubits=num_qubits, cnots=cnots)
+
+The rest of the code in the above example does not change.
+
+References:
+
+    [1]: Liam Madden, Andrea Simonetto, Best Approximate Quantum Compiling Problems.
+        `arXiv:2106.05649 <https://arxiv.org/abs/2106.05649>`_
+"""
+
+from .approximate import ApproximateCircuit, ApproximatingObjective
+from .aqc import AQC
+from .cnot_structures import make_cnot_network
+from .cnot_unit_circuit import CNOTUnitCircuit
+from .cnot_unit_objective import CNOTUnitObjective, DefaultCNOTUnitObjective
+from .fast_gradient.fast_gradient import FastCNOTUnitObjective