6754654159

Committed 04 Nov 2023 10:37AM UTC coverage: 86.948% (-0.001%) from 86.949%

Build # 6754654159

Build Type

push

github

Committed by

web-flow

Commit Message

Formatting and typo issues in qiskit.transpiler.Target (#11164) (#11194)

* formatting and typo issues in qiskit.transpiler.Target

* https://github.com/Qiskit/qiskit/pull/11164#discussion_r1378720534

* https://github.com/Qiskit/qiskit/pull/11164#discussion_r1378719966

(cherry picked from commit 2818cf05b)

Co-authored-by: Luciano Bello <bel@zurich.ibm.com>

Run Details

74205 of 85344 relevant lines covered (86.95%)

90553.36 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

84.15

/qiskit/extensions/quantum_initializer/squ.py

# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2019.
#
# 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.

"""Decompose an arbitrary 2*2 unitary into three rotation gates: U=R_zR_yR_z.

Note that the decomposition is up to a global phase shift.
(This is a well known decomposition, which can be found for example in Nielsen and Chuang's book
"Quantum computation and quantum information".)
"""

import cmath

import numpy as np

from qiskit.circuit import QuantumRegister, QuantumCircuit
from qiskit.circuit.gate import Gate
from qiskit.circuit.exceptions import CircuitError
from qiskit.quantum_info.operators.predicates import is_unitary_matrix
from qiskit.exceptions import QiskitError
from qiskit.utils.deprecation import deprecate_func

_EPS = 1e-10  # global variable used to chop very small numbers to zero


class SingleQubitUnitary(Gate):
    """Single-qubit unitary.

    Args:
            unitary_matrix: :math:`2 \times 2` unitary (given as a (complex) ``numpy.ndarray``).
            mode: determines the used decomposition by providing the rotation axes.
            up_to_diagonal: the single-qubit unitary is decomposed up to a diagonal matrix,
                     i.e. a unitary :math:`U'` is implemented such that there exists a diagonal
                     matrix :math:`D` with :math:`U = D U'`.
    """

    @deprecate_func(
        since="0.45.0",
        additional_msg="Instead, you can use qiskit.circuit.library.UnitaryGate.",
    )
    def __init__(self, unitary_matrix, mode="ZYZ", up_to_diagonal=False):
        """Create a new single qubit gate based on the unitary ``u``."""
        if mode not in ["ZYZ"]:
            raise QiskitError("The decomposition mode is not known.")
        # Check if the matrix u has the right dimensions and if it is a unitary
        if unitary_matrix.shape != (2, 2):
            raise QiskitError("The dimension of the input matrix is not equal to (2,2).")
        if not is_unitary_matrix(unitary_matrix):
            raise QiskitError("The 2*2 matrix is not unitary.")

        self.mode = mode
        self.up_to_diagonal = up_to_diagonal
        self._diag = None

        # Create new gate
        super().__init__("squ", 1, [unitary_matrix])

    def inverse(self):
        """Return the inverse.

        Note that the resulting gate has an empty ``params`` property.
        """
        inverse_gate = Gate(
            name=self.name + "_dg", num_qubits=self.num_qubits, params=[]
        )  # removing the params because arrays are deprecated

        definition = QuantumCircuit(*self.definition.qregs)
        for inst in reversed(self._definition):
            definition._append(inst.replace(operation=inst.operation.inverse()))
        inverse_gate.definition = definition
        return inverse_gate

    @property
    def diag(self):
        """Returns the diagonal gate D up to which the single-qubit unitary u is implemented.

        I.e. u=D.u', where u' is the unitary implemented by the found circuit.
        """
        if self._diag is None:
            self._define()
        return self._diag

    def _define(self):
        """Define the gate using the decomposition."""

        if self.mode == "ZYZ":
            circuit, diag = self._zyz_circuit()
        else:
            raise QiskitError("The decomposition mode is not known.")

        self._diag = diag

        self.definition = circuit

    def _zyz_circuit(self):
        """Get the circuit for the ZYZ decomposition."""
        q = QuantumRegister(self.num_qubits)
        qc = QuantumCircuit(q, name=self.name)

        diag = [1.0, 1.0]
        alpha, beta, gamma, _ = self._zyz_dec()

        if abs(alpha) > _EPS:
            qc.rz(alpha, q[0])
        if abs(beta) > _EPS:
            qc.ry(beta, q[0])
        if abs(gamma) > _EPS:
            if self.up_to_diagonal:
                diag = [np.exp(-1j * gamma / 2.0), np.exp(1j * gamma / 2.0)]
            else:
                qc.rz(gamma, q[0])

        return qc, diag

    def _zyz_dec(self):
        """Finds rotation angles (a,b,c,d) in the decomposition u=exp(id)*Rz(c).Ry(b).Rz(a).

        Note that where "." denotes matrix multiplication.
        """
        unitary = self.params[0]
        u00 = unitary.item(0, 0)
        u01 = unitary.item(0, 1)
        u10 = unitary.item(1, 0)
        u11 = unitary.item(1, 1)
        # Handle special case if the entry (0,0) of the unitary is equal to zero
        if np.abs(u00) < _EPS:
            # Note that u10 can't be zero, since u is unitary (and u00 == 0)
            gamma = cmath.phase(-u01 / u10)
            delta = cmath.phase(u01 * np.exp(-1j * gamma / 2))
            return 0.0, -np.pi, -gamma, delta
        # Handle special case if the entry (0,1) of the unitary is equal to zero
        if np.abs(u01) < _EPS:
            # Note that u11 can't be zero, since u is unitary (and u01 == 0)
            gamma = cmath.phase(u00 / u11)
            delta = cmath.phase(u00 * np.exp(-1j * gamma / 2))
            return 0.0, 0.0, -gamma, delta
        beta = 2 * np.arccos(np.abs(u00))
        if np.sin(beta / 2) - np.cos(beta / 2) > 0:
            gamma = cmath.phase(-u00 / u10)
            alpha = cmath.phase(u00 / u01)
        else:
            gamma = -cmath.phase(-u10 / u00)
            alpha = -cmath.phase(u01 / u00)
        delta = cmath.phase(u00 * np.exp(-1j * (alpha + gamma) / 2))
        # The decomposition works with another convention for the rotation gates
        # (the one using negative angles).
        # Therefore, we have to take the inverse of the angles at the end.
        return -alpha, -beta, -gamma, delta

    def validate_parameter(self, parameter):
        """Single-qubit unitary gate parameter has to be an ndarray."""
        if isinstance(parameter, np.ndarray):
            return parameter
        else:
            raise CircuitError(f"invalid param type {type(parameter)} in gate {self.name}")

1	# This code is part of Qiskit.
2	#
3	# (C) Copyright IBM 2017, 2019.
4	#
5	# This code is licensed under the Apache License, Version 2.0. You may
6	# obtain a copy of this license in the LICENSE.txt file in the root directory
7	# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
8	#
9	# Any modifications or derivative works of this code must retain this
10	# copyright notice, and modified files need to carry a notice indicating
11	# that they have been altered from the originals.
12
13	"""Decompose an arbitrary 2*2 unitary into three rotation gates: U=R_zR_yR_z.	1✔
14
15	Note that the decomposition is up to a global phase shift.
16	(This is a well known decomposition, which can be found for example in Nielsen and Chuang's book
17	"Quantum computation and quantum information".)
18	"""
19
20	import cmath	1✔
21
22	import numpy as np	1✔
23
24	from qiskit.circuit import QuantumRegister, QuantumCircuit	1✔
25	from qiskit.circuit.gate import Gate	1✔
26	from qiskit.circuit.exceptions import CircuitError	1✔
27	from qiskit.quantum_info.operators.predicates import is_unitary_matrix	1✔
28	from qiskit.exceptions import QiskitError	1✔
29	from qiskit.utils.deprecation import deprecate_func	1✔
30
31	_EPS = 1e-10 # global variable used to chop very small numbers to zero	1✔
32
33
34	class SingleQubitUnitary(Gate):	1✔
35	"""Single-qubit unitary.	1✔
36
37	Args:
38	unitary_matrix: :math:`2 \times 2` unitary (given as a (complex) ``numpy.ndarray``).
39	mode: determines the used decomposition by providing the rotation axes.
40	up_to_diagonal: the single-qubit unitary is decomposed up to a diagonal matrix,
41	i.e. a unitary :math:`U'` is implemented such that there exists a diagonal
42	matrix :math:`D` with :math:`U = D U'`.
43	"""
44
45	@deprecate_func(	1✔
46	since="0.45.0",
47	additional_msg="Instead, you can use qiskit.circuit.library.UnitaryGate.",
48	)
49	def __init__(self, unitary_matrix, mode="ZYZ", up_to_diagonal=False):	1✔
50	"""Create a new single qubit gate based on the unitary ``u``."""
51	if mode not in ["ZYZ"]:	1✔
52	raise QiskitError("The decomposition mode is not known.")	×
53	# Check if the matrix u has the right dimensions and if it is a unitary
54	if unitary_matrix.shape != (2, 2):	1✔
55	raise QiskitError("The dimension of the input matrix is not equal to (2,2).")	×
56	if not is_unitary_matrix(unitary_matrix):	1✔
57	raise QiskitError("The 2*2 matrix is not unitary.")	×
58
59	self.mode = mode	1✔
60	self.up_to_diagonal = up_to_diagonal	1✔
61	self._diag = None	1✔
62
63	# Create new gate
64	super().__init__("squ", 1, [unitary_matrix])	1✔
65
66	def inverse(self):	1✔
67	"""Return the inverse.
68
69	Note that the resulting gate has an empty ``params`` property.
70	"""
71	inverse_gate = Gate(	×
72	name=self.name + "_dg", num_qubits=self.num_qubits, params=[]
73	) # removing the params because arrays are deprecated
74
75	definition = QuantumCircuit(*self.definition.qregs)	×
76	for inst in reversed(self._definition):	×
77	definition._append(inst.replace(operation=inst.operation.inverse()))	×
78	inverse_gate.definition = definition	×
79	return inverse_gate	×
80
81	@property	1✔
82	def diag(self):	1✔
83	"""Returns the diagonal gate D up to which the single-qubit unitary u is implemented.
84
85	I.e. u=D.u', where u' is the unitary implemented by the found circuit.
86	"""
87	if self._diag is None:	1✔
88	self._define()	1✔
89	return self._diag	1✔
90
91	def _define(self):	1✔
92	"""Define the gate using the decomposition."""
93
94	if self.mode == "ZYZ":	1✔
95	circuit, diag = self._zyz_circuit()	1✔
96	else:
97	raise QiskitError("The decomposition mode is not known.")	×
98
99	self._diag = diag	1✔
100
101	self.definition = circuit	1✔
102
103	def _zyz_circuit(self):	1✔
104	"""Get the circuit for the ZYZ decomposition."""
105	q = QuantumRegister(self.num_qubits)	1✔
106	qc = QuantumCircuit(q, name=self.name)	1✔
107
108	diag = [1.0, 1.0]	1✔
109	alpha, beta, gamma, _ = self._zyz_dec()	1✔
110
111	if abs(alpha) > _EPS:	1✔
112	qc.rz(alpha, q[0])	1✔
113	if abs(beta) > _EPS:	1✔
114	qc.ry(beta, q[0])	1✔
115	if abs(gamma) > _EPS:	1✔
116	if self.up_to_diagonal:	1✔
117	diag = [np.exp(-1j * gamma / 2.0), np.exp(1j * gamma / 2.0)]	1✔
118	else:
119	qc.rz(gamma, q[0])	1✔
120
121	return qc, diag	1✔
122
123	def _zyz_dec(self):	1✔
124	"""Finds rotation angles (a,b,c,d) in the decomposition u=exp(id)*Rz(c).Ry(b).Rz(a).
125
126	Note that where "." denotes matrix multiplication.
127	"""
128	unitary = self.params[0]	1✔
129	u00 = unitary.item(0, 0)	1✔
130	u01 = unitary.item(0, 1)	1✔
131	u10 = unitary.item(1, 0)	1✔
132	u11 = unitary.item(1, 1)	1✔
133	# Handle special case if the entry (0,0) of the unitary is equal to zero
134	if np.abs(u00) < _EPS:	1✔
135	# Note that u10 can't be zero, since u is unitary (and u00 == 0)
136	gamma = cmath.phase(-u01 / u10)	1✔
137	delta = cmath.phase(u01 * np.exp(-1j * gamma / 2))	1✔
138	return 0.0, -np.pi, -gamma, delta	1✔
139	# Handle special case if the entry (0,1) of the unitary is equal to zero
140	if np.abs(u01) < _EPS:	1✔
141	# Note that u11 can't be zero, since u is unitary (and u01 == 0)
142	gamma = cmath.phase(u00 / u11)	1✔
143	delta = cmath.phase(u00 * np.exp(-1j * gamma / 2))	1✔
144	return 0.0, 0.0, -gamma, delta	1✔
145	beta = 2 * np.arccos(np.abs(u00))	1✔
146	if np.sin(beta / 2) - np.cos(beta / 2) > 0:	1✔
147	gamma = cmath.phase(-u00 / u10)	×
148	alpha = cmath.phase(u00 / u01)	×
149	else:
150	gamma = -cmath.phase(-u10 / u00)	1✔
151	alpha = -cmath.phase(u01 / u00)	1✔
152	delta = cmath.phase(u00 * np.exp(-1j * (alpha + gamma) / 2))	1✔
153	# The decomposition works with another convention for the rotation gates
154	# (the one using negative angles).
155	# Therefore, we have to take the inverse of the angles at the end.
156	return -alpha, -beta, -gamma, delta	1✔
157
158	def validate_parameter(self, parameter):	1✔
159	"""Single-qubit unitary gate parameter has to be an ndarray."""
160	if isinstance(parameter, np.ndarray):	1✔
161	return parameter	1✔
162	else:
163	raise CircuitError(f"invalid param type {type(parameter)} in gate {self.name}")	×

Qiskit / qiskit / 6754654159

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous