10457190194

Committed 19 Aug 2024 04:26PM UTC coverage: 89.816% (-0.02%) from 89.836%

Build # 10457190194

Build Type

push

github

Committed by

web-flow

Commit Message

adding copy argument to __array__ (#12979) (#12987)

(cherry picked from commit 06392c523)

Co-authored-by: Alexander Ivrii <alexi@il.ibm.com>

Run Details

2 of 3 new or added lines in 1 file covered. (66.67%)

22 existing lines in 2 files now uncovered.

66799 of 74373 relevant lines covered (89.82%)

231298.96 hits per line

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

90.43

/qiskit/circuit/library/basis_change/qft.py

# 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.

"""Define a Quantum Fourier Transform circuit (QFT) and a native gate (QFTGate)."""

from __future__ import annotations
import warnings
import numpy as np

from qiskit.circuit.quantumcircuit import QuantumCircuit, QuantumRegister, CircuitInstruction, Gate
from ..blueprintcircuit import BlueprintCircuit


class QFT(BlueprintCircuit):
    r"""Quantum Fourier Transform Circuit.

    The Quantum Fourier Transform (QFT) on :math:`n` qubits is the operation

    .. math::

        |j\rangle \mapsto \frac{1}{2^{n/2}} \sum_{k=0}^{2^n - 1} e^{2\pi ijk / 2^n} |k\rangle

    The circuit that implements this transformation can be implemented using Hadamard gates
    on each qubit, a series of controlled-U1 (or Z, depending on the phase) gates and a
    layer of Swap gates. The layer of Swap gates can in principle be dropped if the QFT appears
    at the end of the circuit, since then the re-ordering can be done classically. They
    can be turned off using the ``do_swaps`` attribute.

    For 4 qubits, the circuit that implements this transformation is:

    .. plot::

       from qiskit.circuit.library import QFT
       from qiskit.visualization.library import _generate_circuit_library_visualization
       circuit = QFT(4)
       _generate_circuit_library_visualization(circuit)

    The inverse QFT can be obtained by calling the ``inverse`` method on this class.
    The respective circuit diagram is:

    .. plot::

       from qiskit.circuit.library import QFT
       from qiskit.visualization.library import _generate_circuit_library_visualization
       circuit = QFT(4).inverse()
       _generate_circuit_library_visualization(circuit)

    One method to reduce circuit depth is to implement the QFT approximately by ignoring
    controlled-phase rotations where the angle is beneath a threshold. This is discussed
    in more detail in https://arxiv.org/abs/quant-ph/9601018 or
    https://arxiv.org/abs/quant-ph/0403071.

    Here, this can be adjusted using the ``approximation_degree`` attribute: the smallest
    ``approximation_degree`` rotation angles are dropped from the QFT. For instance, a QFT
    on 5 qubits with approximation degree 2 yields (the barriers are dropped in this example):

    .. plot::

       from qiskit.circuit.library import QFT
       from qiskit.visualization.library import _generate_circuit_library_visualization
       circuit = QFT(5, approximation_degree=2)
       _generate_circuit_library_visualization(circuit)

    """

    def __init__(
        self,
        num_qubits: int | None = None,
        approximation_degree: int = 0,
        do_swaps: bool = True,
        inverse: bool = False,
        insert_barriers: bool = False,
        name: str | None = None,
    ) -> None:
        """Construct a new QFT circuit.

        Args:
            num_qubits: The number of qubits on which the QFT acts.
            approximation_degree: The degree of approximation (0 for no approximation).
            do_swaps: Whether to include the final swaps in the QFT.
            inverse: If True, the inverse Fourier transform is constructed.
            insert_barriers: If True, barriers are inserted as visualization improvement.
            name: The name of the circuit.
        """
        if name is None:
            name = "IQFT" if inverse else "QFT"

        super().__init__(name=name)
        self._approximation_degree = approximation_degree
        self._do_swaps = do_swaps
        self._insert_barriers = insert_barriers
        self._inverse = inverse
        self.num_qubits = num_qubits

    @property
    def num_qubits(self) -> int:
        """The number of qubits in the QFT circuit.

        Returns:
            The number of qubits in the circuit.
        """
        # This method needs to be overwritten to allow adding the setter for num_qubits while still
        # complying to pylint.
        return super().num_qubits

    @num_qubits.setter
    def num_qubits(self, num_qubits: int) -> None:
        """Set the number of qubits.

        Note that this changes the registers of the circuit.

        Args:
            num_qubits: The new number of qubits.
        """
        if num_qubits != self.num_qubits:
            self._invalidate()

            self.qregs = []
            if num_qubits is not None and num_qubits > 0:
                self.qregs = [QuantumRegister(num_qubits, name="q")]

    @property
    def approximation_degree(self) -> int:
        """The approximation degree of the QFT.

        Returns:
            The currently set approximation degree.
        """
        return self._approximation_degree

    @approximation_degree.setter
    def approximation_degree(self, approximation_degree: int) -> None:
        """Set the approximation degree of the QFT.

        Args:
            approximation_degree: The new approximation degree.

        Raises:
            ValueError: If the approximation degree is smaller than 0.
        """
        if approximation_degree < 0:
            raise ValueError("Approximation degree cannot be smaller than 0.")

        if approximation_degree != self._approximation_degree:
            self._invalidate()
            self._approximation_degree = approximation_degree

    @property
    def insert_barriers(self) -> bool:
        """Whether barriers are inserted for better visualization or not.

        Returns:
            True, if barriers are inserted, False if not.
        """
        return self._insert_barriers

    @insert_barriers.setter
    def insert_barriers(self, insert_barriers: bool) -> None:
        """Specify whether barriers are inserted for better visualization or not.

        Args:
            insert_barriers: If True, barriers are inserted, if False not.
        """
        if insert_barriers != self._insert_barriers:
            self._invalidate()
            self._insert_barriers = insert_barriers

    @property
    def do_swaps(self) -> bool:
        """Whether the final swaps of the QFT are applied or not.

        Returns:
            True, if the final swaps are applied, False if not.
        """
        return self._do_swaps

    @do_swaps.setter
    def do_swaps(self, do_swaps: bool) -> None:
        """Specify whether to do the final swaps of the QFT circuit or not.

        Args:
            do_swaps: If True, the final swaps are applied, if False not.
        """
        if do_swaps != self._do_swaps:
            self._invalidate()
            self._do_swaps = do_swaps

    def is_inverse(self) -> bool:
        """Whether the inverse Fourier transform is implemented.

        Returns:
            True, if the inverse Fourier transform is implemented, False otherwise.
        """
        return self._inverse

    def inverse(self, annotated: bool = False) -> "QFT":
        """Invert this circuit.

        Args:
            annotated: indicates whether the inverse gate can be implemented
                as an annotated gate. The value of this argument is ignored as the
                inverse of a QFT is an IQFT which is just another instance of
                :class:`.QFT`.

        Returns:
            The inverted circuit.
        """

        if self.name in ("QFT", "IQFT"):
            name = "QFT" if self._inverse else "IQFT"
        else:
            name = self.name + "_dg"

        inverted = self.copy(name=name)

        # data consists of the QFT gate only
        iqft = self.data[0].operation.inverse()
        iqft.name = name

        inverted.data.clear()
        inverted._append(CircuitInstruction(iqft, inverted.qubits, []))

        inverted._inverse = not self._inverse
        return inverted

    def _warn_if_precision_loss(self):
        """Issue a warning if constructing the circuit will lose precision.

        If we need an angle smaller than ``pi * 2**-1022``, we start to lose precision by going into
        the subnormal numbers.  We won't lose _all_ precision until an exponent of about 1075, but
        beyond 1022 we're using fractional bits to represent leading zeros."""
        max_num_entanglements = self.num_qubits - self.approximation_degree - 1
        if max_num_entanglements > -np.finfo(float).minexp:  # > 1022 for doubles.
            warnings.warn(
                "precision loss in QFT."
                f" The rotation needed to represent {max_num_entanglements} entanglements"
                " is smaller than the smallest normal floating-point number.",
                category=RuntimeWarning,
                stacklevel=3,
            )

    def _check_configuration(self, raise_on_failure: bool = True) -> bool:
        """Check if the current configuration is valid."""
        valid = True
        if self.num_qubits is None:
            valid = False
            if raise_on_failure:
                raise AttributeError("The number of qubits has not been set.")
        self._warn_if_precision_loss()
        return valid

    def _build(self) -> None:
        """If not already built, build the circuit."""
        if self._is_built:
            return

        super()._build()

        num_qubits = self.num_qubits

        if num_qubits == 0:
            return

        circuit = QuantumCircuit(*self.qregs, name=self.name)
        for j in reversed(range(num_qubits)):
            circuit.h(j)
            num_entanglements = max(0, j - max(0, self.approximation_degree - (num_qubits - j - 1)))
            for k in reversed(range(j - num_entanglements, j)):
                # Use negative exponents so that the angle safely underflows to zero, rather than
                # using a temporary variable that overflows to infinity in the worst case.
                lam = np.pi * (2.0 ** (k - j))
                circuit.cp(lam, j, k)

            if self.insert_barriers:
                circuit.barrier()

        if self._do_swaps:
            for i in range(num_qubits // 2):
                circuit.swap(i, num_qubits - i - 1)

        if self._inverse:
            circuit = circuit.inverse()

        wrapped = circuit.to_instruction() if self.insert_barriers else circuit.to_gate()
        self.compose(wrapped, qubits=self.qubits, inplace=True)


class QFTGate(Gate):
    r"""Quantum Fourier Transform Gate.

    The Quantum Fourier Transform (QFT) on :math:`n` qubits is the operation

    .. math::

        |j\rangle \mapsto \frac{1}{2^{n/2}} \sum_{k=0}^{2^n - 1} e^{2\pi ijk / 2^n} |k\rangle

    """

    def __init__(
        self,
        num_qubits: int,
    ):
        """
        Args:
            num_qubits: The number of qubits on which the QFT acts.
        """
        super().__init__(name="qft", num_qubits=num_qubits, params=[])

    def __array__(self, dtype=complex, copy=None):
        """Return a numpy array for the QFTGate."""
        if copy is False:
            raise ValueError("unable to avoid copy while creating an array as requested")
        n = self.num_qubits
        nums = np.arange(2**n)
        outer = np.outer(nums, nums)
        return np.exp(2j * np.pi * outer * (0.5**n), dtype=dtype) * (0.5 ** (n / 2))

    def _define(self):
        """Provide a specific decomposition of the QFTGate into a quantum circuit."""
        from qiskit.synthesis.qft import synth_qft_full

        self.definition = synth_qft_full(num_qubits=self.num_qubits)

1	# This code is part of Qiskit.
2	#
3	# (C) Copyright IBM 2017, 2020.
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	"""Define a Quantum Fourier Transform circuit (QFT) and a native gate (QFTGate)."""	1✔
14
15	from __future__ import annotations	1✔
16	import warnings	1✔
17	import numpy as np	1✔
18
19	from qiskit.circuit.quantumcircuit import QuantumCircuit, QuantumRegister, CircuitInstruction, Gate	1✔
20	from ..blueprintcircuit import BlueprintCircuit	1✔
21
22
23	class QFT(BlueprintCircuit):	1✔
24	r"""Quantum Fourier Transform Circuit.	1✔
25
26	The Quantum Fourier Transform (QFT) on :math:`n` qubits is the operation
27
28	.. math::
29
30	\|j\rangle \mapsto \frac{1}{2^{n/2}} \sum_{k=0}^{2^n - 1} e^{2\pi ijk / 2^n} \|k\rangle
31
32	The circuit that implements this transformation can be implemented using Hadamard gates
33	on each qubit, a series of controlled-U1 (or Z, depending on the phase) gates and a
34	layer of Swap gates. The layer of Swap gates can in principle be dropped if the QFT appears
35	at the end of the circuit, since then the re-ordering can be done classically. They
36	can be turned off using the ``do_swaps`` attribute.
37
38	For 4 qubits, the circuit that implements this transformation is:
39
40	.. plot::
41
42	from qiskit.circuit.library import QFT
43	from qiskit.visualization.library import _generate_circuit_library_visualization
44	circuit = QFT(4)
45	_generate_circuit_library_visualization(circuit)
46
47	The inverse QFT can be obtained by calling the ``inverse`` method on this class.
48	The respective circuit diagram is:
49
50	.. plot::
51
52	from qiskit.circuit.library import QFT
53	from qiskit.visualization.library import _generate_circuit_library_visualization
54	circuit = QFT(4).inverse()
55	_generate_circuit_library_visualization(circuit)
56
57	One method to reduce circuit depth is to implement the QFT approximately by ignoring
58	controlled-phase rotations where the angle is beneath a threshold. This is discussed
59	in more detail in https://arxiv.org/abs/quant-ph/9601018 or
60	https://arxiv.org/abs/quant-ph/0403071.
61
62	Here, this can be adjusted using the ``approximation_degree`` attribute: the smallest
63	``approximation_degree`` rotation angles are dropped from the QFT. For instance, a QFT
64	on 5 qubits with approximation degree 2 yields (the barriers are dropped in this example):
65
66	.. plot::
67
68	from qiskit.circuit.library import QFT
69	from qiskit.visualization.library import _generate_circuit_library_visualization
70	circuit = QFT(5, approximation_degree=2)
71	_generate_circuit_library_visualization(circuit)
72
73	"""
74
75	def __init__(	1✔
76	self,
77	num_qubits: int \| None = None,
78	approximation_degree: int = 0,
79	do_swaps: bool = True,
80	inverse: bool = False,
81	insert_barriers: bool = False,
82	name: str \| None = None,
83	) -> None:
84	"""Construct a new QFT circuit.
85
86	Args:
87	num_qubits: The number of qubits on which the QFT acts.
88	approximation_degree: The degree of approximation (0 for no approximation).
89	do_swaps: Whether to include the final swaps in the QFT.
90	inverse: If True, the inverse Fourier transform is constructed.
91	insert_barriers: If True, barriers are inserted as visualization improvement.
92	name: The name of the circuit.
93	"""
94	if name is None:	1✔
95	name = "IQFT" if inverse else "QFT"	1✔
96
97	super().__init__(name=name)	1✔
98	self._approximation_degree = approximation_degree	1✔
99	self._do_swaps = do_swaps	1✔
100	self._insert_barriers = insert_barriers	1✔
101	self._inverse = inverse	1✔
102	self.num_qubits = num_qubits	1✔
103
104	@property	1✔
105	def num_qubits(self) -> int:	1✔
106	"""The number of qubits in the QFT circuit.
107
108	Returns:
109	The number of qubits in the circuit.
110	"""
111	# This method needs to be overwritten to allow adding the setter for num_qubits while still
112	# complying to pylint.
113	return super().num_qubits	1✔
114
115	@num_qubits.setter	1✔
116	def num_qubits(self, num_qubits: int) -> None:	1✔
117	"""Set the number of qubits.
118
119	Note that this changes the registers of the circuit.
120
121	Args:
122	num_qubits: The new number of qubits.
123	"""
124	if num_qubits != self.num_qubits:	1✔
125	self._invalidate()	1✔
126
127	self.qregs = []	1✔
128	if num_qubits is not None and num_qubits > 0:	1✔
129	self.qregs = [QuantumRegister(num_qubits, name="q")]	1✔
130
131	@property	1✔
132	def approximation_degree(self) -> int:	1✔
133	"""The approximation degree of the QFT.
134
135	Returns:
136	The currently set approximation degree.
137	"""
138	return self._approximation_degree	1✔
139
140	@approximation_degree.setter	1✔
141	def approximation_degree(self, approximation_degree: int) -> None:	1✔
142	"""Set the approximation degree of the QFT.
143
144	Args:
145	approximation_degree: The new approximation degree.
146
147	Raises:
148	ValueError: If the approximation degree is smaller than 0.
149	"""
150	if approximation_degree < 0:	1✔
151	raise ValueError("Approximation degree cannot be smaller than 0.")	×
152
153	if approximation_degree != self._approximation_degree:	1✔
154	self._invalidate()	1✔
155	self._approximation_degree = approximation_degree	1✔
156
157	@property	1✔
158	def insert_barriers(self) -> bool:	1✔
159	"""Whether barriers are inserted for better visualization or not.
160
161	Returns:
162	True, if barriers are inserted, False if not.
163	"""
164	return self._insert_barriers	1✔
165
166	@insert_barriers.setter	1✔
167	def insert_barriers(self, insert_barriers: bool) -> None:	1✔
168	"""Specify whether barriers are inserted for better visualization or not.
169
170	Args:
171	insert_barriers: If True, barriers are inserted, if False not.
172	"""
173	if insert_barriers != self._insert_barriers:	×
174	self._invalidate()	×
175	self._insert_barriers = insert_barriers	×
176
177	@property	1✔
178	def do_swaps(self) -> bool:	1✔
179	"""Whether the final swaps of the QFT are applied or not.
180
181	Returns:
182	True, if the final swaps are applied, False if not.
183	"""
184	return self._do_swaps	×
185
186	@do_swaps.setter	1✔
187	def do_swaps(self, do_swaps: bool) -> None:	1✔
188	"""Specify whether to do the final swaps of the QFT circuit or not.
189
190	Args:
191	do_swaps: If True, the final swaps are applied, if False not.
192	"""
193	if do_swaps != self._do_swaps:	1✔
194	self._invalidate()	1✔
195	self._do_swaps = do_swaps	1✔
196
197	def is_inverse(self) -> bool:	1✔
198	"""Whether the inverse Fourier transform is implemented.
199
200	Returns:
201	True, if the inverse Fourier transform is implemented, False otherwise.
202	"""
203	return self._inverse	1✔
204
205	def inverse(self, annotated: bool = False) -> "QFT":	1✔
206	"""Invert this circuit.
207
208	Args:
209	annotated: indicates whether the inverse gate can be implemented
210	as an annotated gate. The value of this argument is ignored as the
211	inverse of a QFT is an IQFT which is just another instance of
212	:class:`.QFT`.
213
214	Returns:
215	The inverted circuit.
216	"""
217
218	if self.name in ("QFT", "IQFT"):	1✔
219	name = "QFT" if self._inverse else "IQFT"	1✔
220	else:
221	name = self.name + "_dg"	×
222
223	inverted = self.copy(name=name)	1✔
224
225	# data consists of the QFT gate only
226	iqft = self.data[0].operation.inverse()	1✔
227	iqft.name = name	1✔
228
229	inverted.data.clear()	1✔
230	inverted._append(CircuitInstruction(iqft, inverted.qubits, []))	1✔
231
232	inverted._inverse = not self._inverse	1✔
233	return inverted	1✔
234
235	def _warn_if_precision_loss(self):	1✔
236	"""Issue a warning if constructing the circuit will lose precision.
237
238	If we need an angle smaller than ``pi * 2**-1022``, we start to lose precision by going into
239	the subnormal numbers. We won't lose _all_ precision until an exponent of about 1075, but
240	beyond 1022 we're using fractional bits to represent leading zeros."""
241	max_num_entanglements = self.num_qubits - self.approximation_degree - 1	1✔
242	if max_num_entanglements > -np.finfo(float).minexp: # > 1022 for doubles.	1✔
243	warnings.warn(	1✔
244	"precision loss in QFT."
245	f" The rotation needed to represent {max_num_entanglements} entanglements"
246	" is smaller than the smallest normal floating-point number.",
247	category=RuntimeWarning,
248	stacklevel=3,
249	)
250
251	def _check_configuration(self, raise_on_failure: bool = True) -> bool:	1✔
252	"""Check if the current configuration is valid."""
253	valid = True	1✔
254	if self.num_qubits is None:	1✔
255	valid = False	×
256	if raise_on_failure:	×
257	raise AttributeError("The number of qubits has not been set.")	×
258	self._warn_if_precision_loss()	1✔
259	return valid	1✔
260
261	def _build(self) -> None:	1✔
262	"""If not already built, build the circuit."""
263	if self._is_built:	1✔
264	return	×
265
266	super()._build()	1✔
267
268	num_qubits = self.num_qubits	1✔
269
270	if num_qubits == 0:	1✔
271	return	1✔
272
273	circuit = QuantumCircuit(*self.qregs, name=self.name)	1✔
274	for j in reversed(range(num_qubits)):	1✔
275	circuit.h(j)	1✔
276	num_entanglements = max(0, j - max(0, self.approximation_degree - (num_qubits - j - 1)))	1✔
277	for k in reversed(range(j - num_entanglements, j)):	1✔
278	# Use negative exponents so that the angle safely underflows to zero, rather than
279	# using a temporary variable that overflows to infinity in the worst case.
280	lam = np.pi * (2.0 ** (k - j))	1✔
281	circuit.cp(lam, j, k)	1✔
282
283	if self.insert_barriers:	1✔
284	circuit.barrier()	1✔
285
286	if self._do_swaps:	1✔
287	for i in range(num_qubits // 2):	1✔
288	circuit.swap(i, num_qubits - i - 1)	1✔
289
290	if self._inverse:	1✔
291	circuit = circuit.inverse()	1✔
292
293	wrapped = circuit.to_instruction() if self.insert_barriers else circuit.to_gate()	1✔
294	self.compose(wrapped, qubits=self.qubits, inplace=True)	1✔
295
296
297	class QFTGate(Gate):	1✔
298	r"""Quantum Fourier Transform Gate.	1✔
299
300	The Quantum Fourier Transform (QFT) on :math:`n` qubits is the operation
301
302	.. math::
303
304	\|j\rangle \mapsto \frac{1}{2^{n/2}} \sum_{k=0}^{2^n - 1} e^{2\pi ijk / 2^n} \|k\rangle
305
306	"""
307
308	def __init__(	1✔
309	self,
310	num_qubits: int,
311	):
312	"""
313	Args:
314	num_qubits: The number of qubits on which the QFT acts.
315	"""
316	super().__init__(name="qft", num_qubits=num_qubits, params=[])	1✔
317
318	def __array__(self, dtype=complex, copy=None):	1✔
319	"""Return a numpy array for the QFTGate."""
320	if copy is False:	1✔
NEW 321	raise ValueError("unable to avoid copy while creating an array as requested")	×
322	n = self.num_qubits	1✔
323	nums = np.arange(2**n)	1✔
324	outer = np.outer(nums, nums)	1✔
325	return np.exp(2j * np.pi * outer * (0.5*n), dtype=dtype) (0.5 ** (n / 2))	1✔
326
327	def _define(self):	1✔
328	"""Provide a specific decomposition of the QFTGate into a quantum circuit."""
329	from qiskit.synthesis.qft import synth_qft_full	1✔
330
331	self.definition = synth_qft_full(num_qubits=self.num_qubits)	1✔

Qiskit / qiskit / 10457190194

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