6749032211

Committed 03 Nov 2023 11:42AM UTC coverage: 86.975% (+0.001%) from 86.974%

Build # 6749032211

Build Type

push

github

Committed by

web-flow

Commit Message

Prepare 0.45.0 release (#11169)

* Edit last batch of notes

* Edit notes from rc1

* Remove 0.25 backports from releasenotes/notes/0.45

* Remove 0.25 backports from releasenotes/notes

* Add config for reno sections

* Add reno sections

* Change version number to 0.45.0

* Add prelude

* Add missing sections, order sections alphabetically

* Restore fixes release notes

* Remove fixes_quantum_info

* Minor fixes

* Fix release notes heading level

* Fix indentation

* Apply suggestions from code review

Co-authored-by: Matthew Treinish <mtreinish@kortar.org>

* Apply suggestions from code review

* Attempt to fix sphinx complaint

* Another attempt to fix Sphinx complaint

* Refactor prelude, hopefully fix Sphinx?

* Fix duplicated categories

* Fix typo

* Fixes in the prelude

* Flatten reno subsections

* Apply suggestions from Matt's code review

Co-authored-by: Matthew Treinish <mtreinish@kortar.org>

* Fix config

* Apply suggestions from Matt's code review - part 2

* Correct typos from applying suggestions

* Add gate map viz plot

* Fix some api refs

* Apply suggestions from Matt's code review

Co-authored-by: Matthew Treinish <mtreinish@kortar.org>

* Add suggestions from Matt's code review

* Update qiskit/circuit/__init__.py

Co-authored-by: Matthew Treinish <mtreinish@kortar.org>

* Last try at reno subsections

* Revert "Last try at reno subsections"

This reverts commit 1b8a61066.

* Apply suggestions from Matt's code review

Co-authored-by: Matthew Treinish <mtreinish@kortar.org>

---------

Co-authored-by: Matthew Treinish <mtreinish@kortar.org>

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

6 existing lines in 2 files now uncovered.

74228 of 85344 relevant lines covered (86.98%)

90747.97 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✔
UNCOV 147	gamma = cmath.phase(-u00 / u10)	×
UNCOV 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 / 6749032211

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