5882048783

Committed 16 Aug 2023 05:37PM UTC coverage: 87.264% (+0.01%) from 87.254%

Build # 5882048783

Build Type

push

github

Committed by

web-flow

Commit Message

Add GitHub Actions documentation-deployment pipeline (backport #10610) (#10638)

* Add GitHub Actions documentation-deployment pipeline (#10610)

* Add GitHub Actions documentation-deployment pipeline

This brings a documentation-deployment pipeline into the Qiskit/Terra
repository, allowing it to fully deploy its documentation to
`qiskit.org`, a task previously only the metapackage could perform.
This does not fully unify the documentation with files from the
metapackage, it just adds a pipeline to do the final deployment.

This includes a revitalised translatable-strings pipeline, which was
previously broken on the metapackage for the last month or two. It also
previously included a fair amount of legacy weight that was no longer
relevant.

* Add missing secret insertions

* Improve logic for deployments

This changes the logic for the deployments so that pushes to 'stable/*'
no longer trigger any deployment to qiskit.org.  Instead, tag events
trigger a deployment to the relevant stable branch, and a tag event of
the _latest_ tag triggers a deployment to the documentation root.

The translatables logic is modified to push only the latest full-release
tag.

(cherry picked from commit 80e95d11c)

# Conflicts:
#	docs/conf.py

* Fix bad merge conflict

* Hardcode publish path from tags

For any tag we publish from the `stable/0.25` branch the publish path
should be both `stable/0.44` (which matches the qiskit package version) 
and the root as it's the current release. When we stop publishing from
the stable/0.25 branch after the release of 0.45.0rc1 the existing logic 
will work and we'll no longer have any 0.25.x releases. But for the
0.25.x release series only the version numbers are not unified so we
need to manually ensure we're publishing to the right paths.

---------

Co-authored-by: Jake Lishman <jake.lishman@ibm.com>
Co-authored-by: Luciano Bello <bel@zurich.ibm.com>
Co-authored-by: Eric Arellano <14852634... (continued)

Run Details

74106 of 84922 relevant lines covered (87.26%)

60952.41 hits per line

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

80.0

/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, Qubit, 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

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


class SingleQubitUnitary(Gate):
    """
    u = 2*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 u' is implemented such that there exists a 2*2 diagonal
                     gate d with u = d.dot(u').
    """

    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}")


def squ(
    self,
    unitary_matrix,
    qubit,
    mode="ZYZ",
    up_to_diagonal=False,
):
    """Decompose an arbitrary 2*2 unitary into three rotation gates.

    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".)

    Args:
        unitary_matrix (ndarray): 2*2 unitary (given as a (complex) ndarray).
        qubit (QuantumRegister or Qubit): The qubit which the gate is acting on.
        mode (string): determines the used decomposition by providing the rotation axes.
            The allowed modes are: "ZYZ" (default)
        up_to_diagonal (bool):  if set to True, the single-qubit unitary is decomposed up to
            a diagonal matrix, i.e. a unitary u' is implemented such that there exists a 2*2
            diagonal gate d with u = d.dot(u')

    Returns:
        InstructionSet: The single-qubit unitary instruction attached to the circuit.

    Raises:
        QiskitError: if the format is wrong; if the array u is not unitary
    """

    if isinstance(qubit, QuantumRegister):
        qubit = qubit[:]
        if len(qubit) == 1:
            qubit = qubit[0]
        else:
            raise QiskitError(
                "The target qubit is a QuantumRegister containing more than one qubit."
            )
    # Check if there is one target qubit provided
    if not isinstance(qubit, Qubit):
        raise QiskitError("The target qubit is not a single qubit from a QuantumRegister.")
    return self.append(SingleQubitUnitary(unitary_matrix, mode, up_to_diagonal), [qubit], [])


QuantumCircuit.squ = squ

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, Qubit, 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
30	_EPS = 1e-10 # global variable used to chop very small numbers to zero	1✔
31
32
33	class SingleQubitUnitary(Gate):	1✔
34	"""	1✔
35	u = 2*2 unitary (given as a (complex) numpy.ndarray)
36
37	mode - determines the used decomposition by providing the rotation axes
38
39	up_to_diagonal - the single-qubit unitary is decomposed up to a diagonal matrix,
40	i.e. a unitary u' is implemented such that there exists a 2*2 diagonal
41	gate d with u = d.dot(u').
42	"""
43
44	def __init__(self, unitary_matrix, mode="ZYZ", up_to_diagonal=False):	1✔
45	"""Create a new single qubit gate based on the unitary ``u``."""
46	if mode not in ["ZYZ"]:	1✔
47	raise QiskitError("The decomposition mode is not known.")	×
48	# Check if the matrix u has the right dimensions and if it is a unitary
49	if unitary_matrix.shape != (2, 2):	1✔
50	raise QiskitError("The dimension of the input matrix is not equal to (2,2).")	×
51	if not is_unitary_matrix(unitary_matrix):	1✔
52	raise QiskitError("The 2*2 matrix is not unitary.")	×
53
54	self.mode = mode	1✔
55	self.up_to_diagonal = up_to_diagonal	1✔
56	self._diag = None	1✔
57
58	# Create new gate
59	super().__init__("squ", 1, [unitary_matrix])	1✔
60
61	def inverse(self):	1✔
62	"""Return the inverse.
63
64	Note that the resulting gate has an empty ``params`` property.
65	"""
66	inverse_gate = Gate(	×
67	name=self.name + "_dg", num_qubits=self.num_qubits, params=[]
68	) # removing the params because arrays are deprecated
69
70	definition = QuantumCircuit(*self.definition.qregs)	×
71	for inst in reversed(self._definition):	×
72	definition._append(inst.replace(operation=inst.operation.inverse()))	×
73	inverse_gate.definition = definition	×
74	return inverse_gate	×
75
76	@property	1✔
77	def diag(self):	1✔
78	"""Returns the diagonal gate D up to which the single-qubit unitary u is implemented.
79
80	I.e. u=D.u', where u' is the unitary implemented by the found circuit.
81	"""
82	if self._diag is None:	1✔
83	self._define()	1✔
84	return self._diag	1✔
85
86	def _define(self):	1✔
87	"""Define the gate using the decomposition."""
88
89	if self.mode == "ZYZ":	1✔
90	circuit, diag = self._zyz_circuit()	1✔
91	else:
92	raise QiskitError("The decomposition mode is not known.")	×
93
94	self._diag = diag	1✔
95
96	self.definition = circuit	1✔
97
98	def _zyz_circuit(self):	1✔
99	"""Get the circuit for the ZYZ decomposition."""
100	q = QuantumRegister(self.num_qubits)	1✔
101	qc = QuantumCircuit(q, name=self.name)	1✔
102
103	diag = [1.0, 1.0]	1✔
104	alpha, beta, gamma, _ = self._zyz_dec()	1✔
105
106	if abs(alpha) > _EPS:	1✔
107	qc.rz(alpha, q[0])	1✔
108	if abs(beta) > _EPS:	1✔
109	qc.ry(beta, q[0])	1✔
110	if abs(gamma) > _EPS:	1✔
111	if self.up_to_diagonal:	1✔
112	diag = [np.exp(-1j * gamma / 2.0), np.exp(1j * gamma / 2.0)]	1✔
113	else:
114	qc.rz(gamma, q[0])	1✔
115
116	return qc, diag	1✔
117
118	def _zyz_dec(self):	1✔
119	"""Finds rotation angles (a,b,c,d) in the decomposition u=exp(id)*Rz(c).Ry(b).Rz(a).
120
121	Note that where "." denotes matrix multiplication.
122	"""
123	unitary = self.params[0]	1✔
124	u00 = unitary.item(0, 0)	1✔
125	u01 = unitary.item(0, 1)	1✔
126	u10 = unitary.item(1, 0)	1✔
127	u11 = unitary.item(1, 1)	1✔
128	# Handle special case if the entry (0,0) of the unitary is equal to zero
129	if np.abs(u00) < _EPS:	1✔
130	# Note that u10 can't be zero, since u is unitary (and u00 == 0)
131	gamma = cmath.phase(-u01 / u10)	1✔
132	delta = cmath.phase(u01 * np.exp(-1j * gamma / 2))	1✔
133	return 0.0, -np.pi, -gamma, delta	1✔
134	# Handle special case if the entry (0,1) of the unitary is equal to zero
135	if np.abs(u01) < _EPS:	1✔
136	# Note that u11 can't be zero, since u is unitary (and u01 == 0)
137	gamma = cmath.phase(u00 / u11)	1✔
138	delta = cmath.phase(u00 * np.exp(-1j * gamma / 2))	1✔
139	return 0.0, 0.0, -gamma, delta	1✔
140	beta = 2 * np.arccos(np.abs(u00))	1✔
141	if np.sin(beta / 2) - np.cos(beta / 2) > 0:	1✔
142	gamma = cmath.phase(-u00 / u10)	×
143	alpha = cmath.phase(u00 / u01)	×
144	else:
145	gamma = -cmath.phase(-u10 / u00)	1✔
146	alpha = -cmath.phase(u01 / u00)	1✔
147	delta = cmath.phase(u00 * np.exp(-1j * (alpha + gamma) / 2))	1✔
148	# The decomposition works with another convention for the rotation gates
149	# (the one using negative angles).
150	# Therefore, we have to take the inverse of the angles at the end.
151	return -alpha, -beta, -gamma, delta	1✔
152
153	def validate_parameter(self, parameter):	1✔
154	"""Single-qubit unitary gate parameter has to be an ndarray."""
155	if isinstance(parameter, np.ndarray):	1✔
156	return parameter	1✔
157	else:
158	raise CircuitError(f"invalid param type {type(parameter)} in gate {self.name}")	×
159
160
161	def squ(	1✔
162	self,
163	unitary_matrix,
164	qubit,
165	mode="ZYZ",
166	up_to_diagonal=False,
167	):
168	"""Decompose an arbitrary 2*2 unitary into three rotation gates.
169
170	Note that the decomposition is up to a global phase shift.
171	(This is a well known decomposition which can be found for example in Nielsen and Chuang's book
172	"Quantum computation and quantum information".)
173
174	Args:
175	unitary_matrix (ndarray): 2*2 unitary (given as a (complex) ndarray).
176	qubit (QuantumRegister or Qubit): The qubit which the gate is acting on.
177	mode (string): determines the used decomposition by providing the rotation axes.
178	The allowed modes are: "ZYZ" (default)
179	up_to_diagonal (bool): if set to True, the single-qubit unitary is decomposed up to
180	a diagonal matrix, i.e. a unitary u' is implemented such that there exists a 2*2
181	diagonal gate d with u = d.dot(u')
182
183	Returns:
184	InstructionSet: The single-qubit unitary instruction attached to the circuit.
185
186	Raises:
187	QiskitError: if the format is wrong; if the array u is not unitary
188	"""
189
190	if isinstance(qubit, QuantumRegister):	1✔
191	qubit = qubit[:]	×
192	if len(qubit) == 1:	×
193	qubit = qubit[0]	×
194	else:
195	raise QiskitError(	×
196	"The target qubit is a QuantumRegister containing more than one qubit."
197	)
198	# Check if there is one target qubit provided
199	if not isinstance(qubit, Qubit):	1✔
200	raise QiskitError("The target qubit is not a single qubit from a QuantumRegister.")	×
201	return self.append(SingleQubitUnitary(unitary_matrix, mode, up_to_diagonal), [qubit], [])	1✔
202
203
204	QuantumCircuit.squ = squ	1✔

Qiskit / qiskit-terra / 5882048783

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