qiskit 1.0.0b1__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

qiskit/circuit/library/data_preparation/zz_feature_map.py

@@ -0,0 +1,114 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 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.
+
+"""Second-order Pauli-Z expansion circuit."""
+
+from typing import Callable, List, Union, Optional
+import numpy as np
+from .pauli_feature_map import PauliFeatureMap
+
+
+class ZZFeatureMap(PauliFeatureMap):
+    """Second-order Pauli-Z evolution circuit.
+
+    For 3 qubits and 1 repetition and linear entanglement the circuit is represented by:
+
+    .. parsed-literal::
+
+        ┌───┐┌─────────────────┐
+        ┤ H ├┤ U1(2.0*φ(x[0])) ├──■────────────────────────────■────────────────────────────────────
+        ├───┤├─────────────────┤┌─┴─┐┌──────────────────────┐┌─┴─┐
+        ┤ H ├┤ U1(2.0*φ(x[1])) ├┤ X ├┤ U1(2.0*φ(x[0],x[1])) ├┤ X ├──■────────────────────────────■──
+        ├───┤├─────────────────┤└───┘└──────────────────────┘└───┘┌─┴─┐┌──────────────────────┐┌─┴─┐
+        ┤ H ├┤ U1(2.0*φ(x[2])) ├──────────────────────────────────┤ X ├┤ U1(2.0*φ(x[1],x[2])) ├┤ X ├
+        └───┘└─────────────────┘                                  └───┘└──────────────────────┘└───┘
+
+    where ``φ`` is a classical non-linear function, which defaults to ``φ(x) = x`` if and
+    ``φ(x,y) = (pi - x)(pi - y)``.
+
+    Examples:
+
+        >>> from qiskit.circuit.library import ZZFeatureMap
+        >>> prep = ZZFeatureMap(2, reps=1)
+        >>> print(prep)
+             ┌───┐┌──────────────┐
+        q_0: ┤ H ├┤ U1(2.0*x[0]) ├──■───────────────────────────────────────■──
+             ├───┤├──────────────┤┌─┴─┐┌─────────────────────────────────┐┌─┴─┐
+        q_1: ┤ H ├┤ U1(2.0*x[1]) ├┤ X ├┤ U1(2.0*(pi - x[0])*(pi - x[1])) ├┤ X ├
+             └───┘└──────────────┘└───┘└─────────────────────────────────┘└───┘
+
+        >>> from qiskit.circuit.library import EfficientSU2
+        >>> classifier = ZZFeatureMap(3) + EfficientSU2(3)
+        >>> classifier.num_parameters
+        15
+        >>> classifier.parameters  # 'x' for the data preparation, 'θ' for the SU2 parameters
+        ParameterView([
+            ParameterVectorElement(x[0]), ParameterVectorElement(x[1]),
+            ParameterVectorElement(x[2]), ParameterVectorElement(θ[0]),
+            ParameterVectorElement(θ[1]), ParameterVectorElement(θ[2]),
+            ParameterVectorElement(θ[3]), ParameterVectorElement(θ[4]),
+            ParameterVectorElement(θ[5]), ParameterVectorElement(θ[6]),
+            ParameterVectorElement(θ[7]), ParameterVectorElement(θ[8]),
+            ParameterVectorElement(θ[9]), ParameterVectorElement(θ[10]),
+            ParameterVectorElement(θ[11]), ParameterVectorElement(θ[12]),
+            ParameterVectorElement(θ[13]), ParameterVectorElement(θ[14]),
+            ParameterVectorElement(θ[15]), ParameterVectorElement(θ[16]),
+            ParameterVectorElement(θ[17]), ParameterVectorElement(θ[18]),
+            ParameterVectorElement(θ[19]), ParameterVectorElement(θ[20]),
+            ParameterVectorElement(θ[21]), ParameterVectorElement(θ[22]),
+            ParameterVectorElement(θ[23])
+        ])
+        >>> classifier.count_ops()
+        OrderedDict([('ZZFeatureMap', 1), ('EfficientSU2', 1)])
+    """
+
+    def __init__(
+        self,
+        feature_dimension: int,
+        reps: int = 2,
+        entanglement: Union[str, List[List[int]], Callable[[int], List[int]]] = "full",
+        data_map_func: Optional[Callable[[np.ndarray], float]] = None,
+        parameter_prefix: str = "x",
+        insert_barriers: bool = False,
+        name: str = "ZZFeatureMap",
+    ) -> None:
+        """Create a new second-order Pauli-Z expansion.
+
+        Args:
+            feature_dimension: Number of features.
+            reps: The number of repeated circuits, has a min. value of 1.
+            entanglement: Specifies the entanglement structure. Refer to
+                :class:`~qiskit.circuit.library.NLocal` for detail.
+            data_map_func: A mapping function for data x.
+            parameter_prefix: The prefix used if default parameters are generated.
+            insert_barriers: If True, barriers are inserted in between the evolution instructions
+                and hadamard layers.
+
+        Raises:
+            ValueError: If the feature dimension is smaller than 2.
+        """
+        if feature_dimension < 2:
+            raise ValueError(
+                "The ZZFeatureMap contains 2-local interactions and cannot be "
+                f"defined for less than 2 qubits. You provided {feature_dimension}."
+            )
+
+        super().__init__(
+            feature_dimension=feature_dimension,
+            reps=reps,
+            entanglement=entanglement,
+            paulis=["Z", "ZZ"],
+            data_map_func=data_map_func,
+            parameter_prefix=parameter_prefix,
+            insert_barriers=insert_barriers,
+            name=name,
+        )

qiskit/circuit/library/evolved_operator_ansatz.py

@@ -0,0 +1,245 @@
+# 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.
+
+"""The evolved operator ansatz."""
+
+from __future__ import annotations
+from collections.abc import Sequence
+
+import numpy as np
+
+from qiskit.circuit.parameter import Parameter
+from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.quantum_info import Operator, Pauli, SparsePauliOp
+from qiskit.synthesis.evolution import LieTrotter
+
+from .pauli_evolution import PauliEvolutionGate
+from .n_local.n_local import NLocal
+
+
+class EvolvedOperatorAnsatz(NLocal):
+    """The evolved operator ansatz."""
+
+    def __init__(
+        self,
+        operators=None,
+        reps: int = 1,
+        evolution=None,
+        insert_barriers: bool = False,
+        name: str = "EvolvedOps",
+        parameter_prefix: str | Sequence[str] = "t",
+        initial_state: QuantumCircuit | None = None,
+        flatten: bool | None = None,
+    ):
+        """
+        Args:
+            operators (BaseOperator | QuantumCircuit | list | None): The operators
+                to evolve. If a circuit is passed, we assume it implements an already evolved
+                operator and thus the circuit is not evolved again. Can be a single operator
+                (circuit) or a list of operators (and circuits).
+            reps: The number of times to repeat the evolved operators.
+            evolution (EvolutionBase | EvolutionSynthesis | None):
+                A specification of which evolution synthesis to use for the
+                :class:`.PauliEvolutionGate`.
+                Defaults to first order Trotterization.
+            insert_barriers: Whether to insert barriers in between each evolution.
+            name: The name of the circuit.
+            parameter_prefix: Set the names of the circuit parameters. If a string, the same prefix
+                will be used for each parameters. Can also be a list to specify a prefix per
+                operator.
+            initial_state: A :class:`.QuantumCircuit` object to prepend to the circuit.
+            flatten: Set this to ``True`` to output a flat circuit instead of nesting it inside multiple
+                layers of gate objects. By default currently the contents of
+                the output circuit will be wrapped in nested objects for
+                cleaner visualization. However, if you're using this circuit
+                for anything besides visualization its **strongly** recommended
+                to set this flag to ``True`` to avoid a large performance
+                overhead for parameter binding.
+        """
+        super().__init__(
+            initial_state=initial_state,
+            parameter_prefix=parameter_prefix,
+            reps=reps,
+            insert_barriers=insert_barriers,
+            name=name,
+            flatten=flatten,
+        )
+        self._operators = None
+
+        if operators is not None:
+            self.operators = operators
+
+        self._evolution = evolution
+
+        # a list of which operators are parameterized, used for internal settings
+        self._ops_are_parameterized = None
+
+    def _check_configuration(self, raise_on_failure: bool = True) -> bool:
+        """Check if the current configuration is valid."""
+        if not super()._check_configuration(raise_on_failure):
+            return False
+
+        if self.operators is None:
+            if raise_on_failure:
+                raise ValueError("The operators are not set.")
+            return False
+
+        return True
+
+    @property
+    def num_qubits(self) -> int:
+        if self.operators is None:
+            return 0
+
+        if isinstance(self.operators, list) and len(self.operators) > 0:
+            return self.operators[0].num_qubits
+
+        return self.operators.num_qubits
+
+    @property
+    def evolution(self):
+        """The evolution converter used to compute the evolution.
+
+        Returns:
+            EvolutionSynthesis: The evolution converter used to compute the evolution.
+        """
+
+        return self._evolution
+
+    @evolution.setter
+    def evolution(self, evol) -> None:
+        """Sets the evolution converter used to compute the evolution.
+
+        Args:
+            evol (EvolutionSynthesis): An evolution synthesis object
+        """
+        self._invalidate()
+        self._evolution = evol
+
+    @property
+    def operators(self):
+        """The operators that are evolved in this circuit.
+
+        Returns:
+            list: The operators to be evolved (and circuits) contained in this ansatz.
+        """
+        return self._operators
+
+    @operators.setter
+    def operators(self, operators=None) -> None:
+        """Set the operators to be evolved.
+
+        operators (Optional[Union[QuantumCircuit, list]]): The operators to evolve.
+            If a circuit is passed, we assume it implements an already evolved operator and thus
+            the circuit is not evolved again. Can be a single operator (circuit) or a list of
+            operators (and circuits).
+        """
+        operators = _validate_operators(operators)
+        self._invalidate()
+        self._operators = operators
+        self.qregs = [QuantumRegister(self.num_qubits, name="q")]
+
+    # TODO: the `preferred_init_points`-implementation can (and should!) be improved!
+    @property
+    def preferred_init_points(self):
+        """Getter of preferred initial points based on the given initial state."""
+        if self._initial_state is None:
+            return None
+        else:
+            # If an initial state was set by the user, then we want to make sure that the VQE does
+            # not start from a random point. Thus, we return an all-zero initial point for the
+            # optimizer which is used (unless it gets overwritten by a higher-priority setting at
+            # runtime of the VQE).
+            # However, in order to determine the correct length, we must build the QuantumCircuit
+            # first, because otherwise the operators may not be set yet.
+            self._build()
+            return np.zeros(self.reps * len(self.operators), dtype=float)
+
+    def _evolve_operator(self, operator, time):
+
+        # pylint: disable=cyclic-import
+        from qiskit.circuit.library.hamiltonian_gate import HamiltonianGate
+
+        # if the operator is specified as matrix use exact matrix exponentiation
+        if isinstance(operator, Operator):
+            gate = HamiltonianGate(operator, time)
+        # otherwise, use the PauliEvolutionGate
+        else:
+            evolution = LieTrotter() if self._evolution is None else self._evolution
+            gate = PauliEvolutionGate(operator, time, synthesis=evolution)
+
+        evolved = QuantumCircuit(operator.num_qubits)
+        if not self.flatten:
+            evolved.append(gate, evolved.qubits)
+        else:
+            evolved.compose(gate.definition, evolved.qubits, inplace=True)
+        return evolved
+
+    def _build(self):
+        if self._is_built:
+            return
+
+        # need to check configuration here to ensure the operators are not None
+        self._check_configuration()
+
+        coeff = Parameter("c")
+        circuits = []
+
+        for op in self.operators:
+            # if the operator is already the evolved circuit just append it
+            if isinstance(op, QuantumCircuit):
+                circuits.append(op)
+            else:
+                # check if the operator is just the identity, if yes, skip it
+                if _is_pauli_identity(op):
+                    continue
+
+                evolved = self._evolve_operator(op, coeff)
+                circuits.append(evolved)
+
+        self.rotation_blocks = []
+        self.entanglement_blocks = circuits
+
+        super()._build()
+
+
+def _validate_operators(operators):
+    if not isinstance(operators, list):
+        operators = [operators]
+
+    if len(operators) > 1:
+        num_qubits = operators[0].num_qubits
+        if any(operators[i].num_qubits != num_qubits for i in range(1, len(operators))):
+            raise ValueError("All operators must act on the same number of qubits.")
+
+    return operators
+
+
+def _validate_prefix(parameter_prefix, operators):
+    if isinstance(parameter_prefix, str):
+        return len(operators) * [parameter_prefix]
+    if len(parameter_prefix) != len(operators):
+        raise ValueError("The number of parameter prefixes must match the operators.")
+
+    return parameter_prefix
+
+
+def _is_pauli_identity(operator):
+    if isinstance(operator, SparsePauliOp):
+        if len(operator.paulis) == 1:
+            operator = operator.paulis[0]  # check if the single Pauli is identity below
+        else:
+            return False
+    if isinstance(operator, Pauli):
+        return not np.any(np.logical_or(operator.x, operator.z))
+    return False

qiskit/circuit/library/fourier_checking.py

@@ -0,0 +1,97 @@
+# 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.
+
+"""Fourier checking circuit."""
+
+from typing import List
+
+import math
+from qiskit.circuit import QuantumCircuit
+from qiskit.circuit.exceptions import CircuitError
+
+from .generalized_gates.diagonal import Diagonal
+
+
+class FourierChecking(QuantumCircuit):
+    """Fourier checking circuit.
+
+    The circuit for the Fourier checking algorithm, introduced in [1],
+    involves a layer of Hadamards, the function :math:`f`, another layer of
+    Hadamards, the function :math:`g`, followed by a final layer of Hadamards.
+    The functions :math:`f` and :math:`g` are classical functions realized
+    as phase oracles (diagonal operators with {-1, 1} on the diagonal).
+
+    The probability of observing the all-zeros string is :math:`p(f,g)`.
+    The algorithm solves the promise Fourier checking problem,
+    which decides if f is correlated with the Fourier transform
+    of g, by testing if :math:`p(f,g) <= 0.01` or :math:`p(f,g) >= 0.05`,
+    promised that one or the other of these is true.
+
+    The functions :math:`f` and :math:`g` are currently implemented
+    from their truth tables but could be represented concisely and
+    implemented efficiently for special classes of functions.
+
+    Fourier checking is a special case of :math:`k`-fold forrelation [2].
+
+    **Reference:**
+
+    [1] S. Aaronson, BQP and the Polynomial Hierarchy, 2009 (Section 3.2).
+    `arXiv:0910.4698 <https://arxiv.org/abs/0910.4698>`_
+
+    [2] S. Aaronson, A. Ambainis, Forrelation: a problem that
+    optimally separates quantum from classical computing, 2014.
+    `arXiv:1411.5729 <https://arxiv.org/abs/1411.5729>`_
+    """
+
+    def __init__(self, f: List[int], g: List[int]) -> None:
+        """Create Fourier checking circuit.
+
+        Args:
+            f: truth table for f, length 2**n list of {1,-1}.
+            g: truth table for g, length 2**n list of {1,-1}.
+
+        Raises:
+            CircuitError: if the inputs f and g are not valid.
+
+        Reference Circuit:
+            .. plot::
+
+               from qiskit.circuit.library import FourierChecking
+               from qiskit.tools.jupyter.library import _generate_circuit_library_visualization
+               f = [1, -1, -1, -1]
+               g = [1, 1, -1, -1]
+               circuit = FourierChecking(f, g)
+               _generate_circuit_library_visualization(circuit)
+        """
+        num_qubits = math.log2(len(f))
+
+        if len(f) != len(g) or num_qubits == 0 or not num_qubits.is_integer():
+            raise CircuitError(
+                "The functions f and g must be given as truth "
+                "tables, each as a list of 2**n entries of "
+                "{1, -1}."
+            )
+
+        circuit = QuantumCircuit(num_qubits, name=f"fc: {f}, {g}")
+
+        circuit.h(circuit.qubits)
+
+        circuit.compose(Diagonal(f), inplace=True)
+
+        circuit.h(circuit.qubits)
+
+        circuit.compose(Diagonal(g), inplace=True)
+
+        circuit.h(circuit.qubits)
+
+        super().__init__(*circuit.qregs, name=circuit.name)
+        self.compose(circuit.to_gate(), qubits=self.qubits, inplace=True)

qiskit/circuit/library/generalized_gates/__init__.py

@@ -0,0 +1,30 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 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.
+
+"""The circuit library module on generalized gates."""
+
+from .diagonal import Diagonal, DiagonalGate
+from .permutation import Permutation, PermutationGate
+from .mcmt import MCMT, MCMTVChain
+from .gms import GMS, MSGate
+from .gr import GR, GRX, GRY, GRZ
+from .pauli import PauliGate
+from .rv import RVGate
+from .linear_function import LinearFunction
+from .isometry import Isometry
+from .uc import UCGate
+from .uc_pauli_rot import UCPauliRotGate
+from .ucrx import UCRXGate
+from .ucry import UCRYGate
+from .ucrz import UCRZGate
+from .unitary import UnitaryGate
+from .mcg_up_to_diagonal import MCGupDiag

qiskit/circuit/library/generalized_gates/diagonal.py

@@ -0,0 +1,164 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 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.
+
+
+"""Diagonal matrix circuit."""
+
+from __future__ import annotations
+from collections.abc import Sequence
+
+import cmath
+import numpy as np
+
+from qiskit.circuit.gate import Gate
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit.exceptions import CircuitError
+
+from .ucrz import UCRZGate
+
+_EPS = 1e-10
+
+
+class Diagonal(QuantumCircuit):
+    r"""Diagonal circuit.
+
+    Circuit symbol:
+
+    .. parsed-literal::
+
+             ┌───────────┐
+        q_0: ┤0          ├
+             │           │
+        q_1: ┤1 Diagonal ├
+             │           │
+        q_2: ┤2          ├
+             └───────────┘
+
+    Matrix form:
+
+    .. math::
+        \text{DiagonalGate}\ q_0, q_1, .., q_{n-1} =
+            \begin{pmatrix}
+                D[0]    & 0         & \dots     & 0 \\
+                0       & D[1]      & \dots     & 0 \\
+                \vdots  & \vdots    & \ddots    & 0 \\
+                0       & 0         & \dots     & D[n-1]
+            \end{pmatrix}
+
+    Diagonal gates are useful as representations of Boolean functions,
+    as they can map from :math:`\{0,1\}^{2^n}` to :math:`\{0,1\}^{2^n}` space. For example a phase
+    oracle can be seen as a diagonal gate with :math:`\{1, -1\}` on the diagonals. Such
+    an oracle will induce a :math:`+1` or :math`-1` phase on the amplitude of any corresponding
+    basis state.
+
+    Diagonal gates appear in many classically hard oracular problems such as
+    Forrelation or Hidden Shift circuits.
+
+    Diagonal gates are represented and simulated more efficiently than a dense
+    :math:`2^n \times 2^n` unitary matrix.
+
+    The reference implementation is via the method described in
+    Theorem 7 of [1]. The code is based on Emanuel Malvetti's semester thesis
+    at ETH in 2018, supervised by Raban Iten and Prof. Renato Renner.
+
+    **Reference:**
+
+    [1] Shende et al., Synthesis of Quantum Logic Circuits, 2009
+    `arXiv:0406176 <https://arxiv.org/pdf/quant-ph/0406176.pdf>`_
+    """
+
+    def __init__(self, diag: Sequence[complex]) -> None:
+        r"""
+        Args:
+            diag: List of the :math:`2^k` diagonal entries (for a diagonal gate on :math:`k` qubits).
+
+        Raises:
+            CircuitError: if the list of the diagonal entries or the qubit list is in bad format;
+                if the number of diagonal entries is not :math:`2^k`, where :math:`k` denotes the
+                number of qubits.
+        """
+        self._check_input(diag)
+        num_qubits = int(np.log2(len(diag)))
+
+        circuit = QuantumCircuit(num_qubits, name="Diagonal")
+
+        # Since the diagonal is a unitary, all its entries have absolute value
+        # one and the diagonal is fully specified by the phases of its entries.
+        diag_phases = [cmath.phase(z) for z in diag]
+        n = len(diag)
+        while n >= 2:
+            angles_rz = []
+            for i in range(0, n, 2):
+                diag_phases[i // 2], rz_angle = _extract_rz(diag_phases[i], diag_phases[i + 1])
+                angles_rz.append(rz_angle)
+            num_act_qubits = int(np.log2(n))
+            ctrl_qubits = list(range(num_qubits - num_act_qubits + 1, num_qubits))
+            target_qubit = num_qubits - num_act_qubits
+
+            ucrz = UCRZGate(angles_rz)
+            circuit.append(ucrz, [target_qubit] + ctrl_qubits)
+
+            n //= 2
+        circuit.global_phase += diag_phases[0]
+
+        super().__init__(num_qubits, name="Diagonal")
+        self.append(circuit.to_gate(), self.qubits)
+
+    @staticmethod
+    def _check_input(diag):
+        """Check if ``diag`` is in valid format."""
+        if not isinstance(diag, (list, np.ndarray)):
+            raise CircuitError("Diagonal entries must be in a list or numpy array.")
+        num_qubits = np.log2(len(diag))
+        if num_qubits < 1 or not num_qubits.is_integer():
+            raise CircuitError("The number of diagonal entries is not a positive power of 2.")
+        if not np.allclose(np.abs(diag), 1, atol=_EPS):
+            raise CircuitError("A diagonal element does not have absolute value one.")
+
+
+class DiagonalGate(Gate):
+    """Gate implementing a diagonal transformation."""
+
+    def __init__(self, diag: Sequence[complex]) -> None:
+        r"""
+        Args:
+            diag: list of the :math:`2^k` diagonal entries (for a diagonal gate on :math:`k` qubits).
+        """
+        Diagonal._check_input(diag)
+        num_qubits = int(np.log2(len(diag)))
+
+        super().__init__("diagonal", num_qubits, diag)
+
+    def _define(self):
+        self.definition = Diagonal(self.params).decompose()
+
+    def validate_parameter(self, parameter):
+        """Diagonal Gate parameter should accept complex
+        (in addition to the Gate parameter types) and always return build-in complex."""
+        if isinstance(parameter, complex):
+            return complex(parameter)
+        else:
+            return complex(super().validate_parameter(parameter))
+
+    def inverse(self):
+        """Return the inverse of the diagonal gate."""
+        return DiagonalGate([np.conj(entry) for entry in self.params])
+
+
+def _extract_rz(phi1, phi2):
+    """
+    Extract a Rz rotation (angle given by first output) such that exp(j*phase)*Rz(z_angle)
+    is equal to the diagonal matrix with entires exp(1j*ph1) and exp(1j*ph2).
+    """
+    phase = (phi1 + phi2) / 2.0
+    z_angle = phi2 - phi1
+    return phase, z_angle