qiskit 1.3.0__cp39-abi3-win32.whl → 1.3.0b1__cp39-abi3-win32.whl

qiskit/circuit/library/data_preparation/zz_feature_map.py

@@ -0,0 +1,118 @@
+# 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, Dict, Tuple
+import numpy as np
+from .pauli_feature_map import PauliFeatureMap
+
+
+class ZZFeatureMap(PauliFeatureMap):
+    r"""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 :math:`\varphi` is a classical non-linear function, which defaults to :math:`\varphi(x) = x`
+    if and :math:`\varphi(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,
+            Dict[int, List[Tuple[int]]],
+            Callable[[int], Union[str, Dict[int, List[Tuple[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.PauliFeatureMap` 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/fourier_checking.py

@@ -12,14 +12,13 @@
 
 """Fourier checking circuit."""
 
-from collections.abc import Sequence
-import math
+from typing import List
 
+import math
 from qiskit.circuit import QuantumCircuit
 from qiskit.circuit.exceptions import CircuitError
-from qiskit.utils.deprecation import deprecate_func
 
-from .generalized_gates.diagonal import Diagonal, DiagonalGate
+from .generalized_gates.diagonal import Diagonal
 
 
 class FourierChecking(QuantumCircuit):
@@ -53,12 +52,7 @@ class FourierChecking(QuantumCircuit):
     `arXiv:1411.5729 <https://arxiv.org/abs/1411.5729>`_
     """
 
-    @deprecate_func(
-        since="1.3",
-        additional_msg="Use qiskit.circuit.library.fourier_checking instead.",
-        pending=True,
-    )
-    def __init__(self, f: Sequence[int], g: Sequence[int]) -> None:
+    def __init__(self, f: List[int], g: List[int]) -> None:
         """Create Fourier checking circuit.
 
         Args:
@@ -87,72 +81,17 @@ class FourierChecking(QuantumCircuit):
                 "{1, -1}."
             )
 
-        # This definition circuit is not replaced by the circuit produced by fourier_checking,
-        # as the latter produces a slightly different circuit, with DiagonalGates instead
-        # of Diagonal circuits.
-        circuit = QuantumCircuit(int(num_qubits), name=f"fc: {f}, {g}")
+        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)
-
-
-def fourier_checking(f: Sequence[int], g: Sequence[int]) -> 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 Circuit:**
-
-    .. plot::
-       :include-source:
-
-       from qiskit.circuit.library import fourier_checking
-       circuit = fourier_checking([1, -1, -1, -1], [1, 1, -1, -1])
-       circuit.draw('mpl')
-
-    **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>`_
-    """
-    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}."
-        )
-    num_qubits = int(num_qubits)
-
-    circuit = QuantumCircuit(num_qubits, name=f"fc: {f}, {g}")
-    circuit.h(circuit.qubits)
-    circuit.append(DiagonalGate(f), range(num_qubits))
-    circuit.h(circuit.qubits)
-    circuit.append(DiagonalGate(g), range(num_qubits))
-    circuit.h(circuit.qubits)
-    return circuit

qiskit/circuit/library/generalized_gates/__init__.py

@@ -14,7 +14,7 @@
 
 from .diagonal import Diagonal, DiagonalGate
 from .permutation import Permutation, PermutationGate
-from .mcmt import MCMT, MCMTVChain, MCMTGate
+from .mcmt import MCMT, MCMTVChain
 from .gms import GMS, MSGate
 from .gr import GR, GRX, GRY, GRZ
 from .pauli import PauliGate

qiskit/circuit/library/generalized_gates/diagonal.py

@@ -23,8 +23,6 @@ import numpy as np
 from qiskit.circuit.gate import Gate
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.circuit.exceptions import CircuitError
-from qiskit.circuit.annotated_operation import AnnotatedOperation, InverseModifier
-from qiskit.utils.deprecation import deprecate_func
 
 from .ucrz import UCRZGate
 
@@ -32,28 +30,19 @@ _EPS = 1e-10
 
 
 class Diagonal(QuantumCircuit):
-    """Circuit implementing a diagonal transformation."""
+    r"""Diagonal circuit.
 
-    @deprecate_func(since="1.3", additional_msg="Use DiagonalGate instead.", pending=True)
-    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.
-        """
-        DiagonalGate._check_input(diag)
-        num_qubits = int(math.log2(len(diag)))
-
-        super().__init__(num_qubits, name="Diagonal")
-        self.append(DiagonalGate(diag), self.qubits)
+    Circuit symbol:
 
+    .. parsed-literal::
 
-class DiagonalGate(Gate):
-    r"""A generic diagonal quantum gate.
+             ┌───────────┐
+        q_0: ┤0          ├
+             │           │
+        q_1: ┤1 Diagonal ├
+             │           │
+        q_2: ┤2          ├
+             └───────────┘
 
     Matrix form:
 
@@ -91,28 +80,30 @@ class DiagonalGate(Gate):
     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).
+            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(math.log2(len(diag)))
 
-        super().__init__("diagonal", num_qubits, diag)
+        circuit = QuantumCircuit(num_qubits, name="Diagonal")
 
-    def _define(self):
         # 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 self.params]
-        n = len(diag_phases)
-        circuit = QuantumCircuit(self.num_qubits)
-
+        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(math.log2(n))
-            ctrl_qubits = list(range(self.num_qubits - num_act_qubits + 1, self.num_qubits))
-            target_qubit = self.num_qubits - num_act_qubits
+            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)
@@ -120,7 +111,36 @@ class DiagonalGate(Gate):
             n //= 2
         circuit.global_phase += diag_phases[0]
 
-        self.definition = circuit
+        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 = math.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(math.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
@@ -132,22 +152,8 @@ class DiagonalGate(Gate):
 
     def inverse(self, annotated: bool = False):
         """Return the inverse of the diagonal gate."""
-        if annotated:
-            return AnnotatedOperation(self.copy(), InverseModifier)
-
         return DiagonalGate([np.conj(entry) for entry in self.params])
 
-    @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 = math.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.")
-
 
 def _extract_rz(phi1, phi2):
     """

qiskit/circuit/library/generalized_gates/gms.py

@@ -15,16 +15,13 @@
 Global Mølmer–Sørensen gate.
 """
 
-from __future__ import annotations
-from collections.abc import Sequence
+from typing import Union, List
 
 import numpy as np
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.circuit.quantumregister import QuantumRegister
-from qiskit.circuit.parameterexpression import ParameterValueType
 from qiskit.circuit.library.standard_gates import RXXGate
 from qiskit.circuit.gate import Gate
-from qiskit.utils.deprecation import deprecate_func
 
 
 class GMS(QuantumCircuit):
@@ -32,7 +29,7 @@ class GMS(QuantumCircuit):
 
     **Circuit symbol:**
 
-    .. code-block:: text
+    .. parsed-literal::
 
              ┌───────────┐
         q_0: ┤0          ├
@@ -77,8 +74,7 @@ class GMS(QuantumCircuit):
     `arXiv:1707.06356 <https://arxiv.org/abs/1707.06356>`_
     """
 
-    @deprecate_func(since="1.3", additional_msg="Use the MSGate instead.", pending=True)
-    def __init__(self, num_qubits: int, theta: list[list[float]] | np.ndarray) -> None:
+    def __init__(self, num_qubits: int, theta: Union[List[List[float]], np.ndarray]) -> None:
         """Create a new Global Mølmer–Sørensen (GMS) gate.
 
         Args:
@@ -98,77 +94,28 @@ class GMS(QuantumCircuit):
 
 
 class MSGate(Gate):
-    r"""The Mølmer–Sørensen gate.
+    """MSGate has been deprecated.
+    Please use ``GMS`` in ``qiskit.circuit.generalized_gates`` instead.
 
-    The Mølmer–Sørensen gate is native to ion-trap systems. The global MS
-    can be applied to multiple ions to entangle multiple qubits simultaneously [1].
-
-    In the two-qubit case, this is equivalent to an XX interaction,
-    and is thus reduced to the :class:`.RXXGate`. The global MS gate is a sum of XX
-    interactions on all pairs [2].
-
-    .. math::
-
-        MS(\chi_{12}, \chi_{13}, ..., \chi_{n-1 n}) =
-        exp(-i \sum_{i=1}^{n} \sum_{j=i+1}^{n} X{\otimes}X \frac{\chi_{ij}}{2})
-
-    Example::
-
-        import numpy as np
-        from qiskit.circuit.library import MSGate
-        from qiskit.quantum_info import Operator
-
-        gate = MSGate(num_qubits=3, theta=[[0, np.pi/4, np.pi/8],
-                                           [0, 0, np.pi/2],
-                                           [0, 0, 0]])
-        print(Operator(gate))
-
-
-    **References:**
+    Global Mølmer–Sørensen gate.
 
-    [1] Sørensen, A. and Mølmer, K., Multi-particle entanglement of hot trapped ions.
-    Physical Review Letters. 82 (9): 1835–1838.
-    `arXiv:9810040 <https://arxiv.org/abs/quant-ph/9810040>`_
+    The Mølmer–Sørensen gate is native to ion-trap systems. The global MS can be
+    applied to multiple ions to entangle multiple qubits simultaneously.
 
-    [2] Maslov, D. and Nam, Y., Use of global interactions in efficient quantum circuit
-    constructions. New Journal of Physics, 20(3), p.033018.
-    `arXiv:1707.06356 <https://arxiv.org/abs/1707.06356>`_
+    In the two-qubit case, this is equivalent to an XX(theta) interaction,
+    and is thus reduced to the RXXGate.
     """
 
-    def __init__(
-        self,
-        num_qubits: int,
-        theta: ParameterValueType | Sequence[Sequence[ParameterValueType]],
-        label: str | None = None,
-    ):
-        """
-        Args:
-            num_qubits: The number of qubits the MS gate acts on.
-            theta: The XX rotation angles. If a single value, the same angle is used on all
-                interactions. Alternatively an upper-triangular, square matrix with width
-                ``num_qubits`` can be provided with interaction angles for each qubit pair.
-            label: A gate label.
-        """
+    def __init__(self, num_qubits, theta, label=None):
+        """Create new MS gate."""
         super().__init__("ms", num_qubits, [theta], label=label)
 
     def _define(self):
-        thetas = self.params[0]
-        q = QuantumRegister(self.num_qubits, name="q")
+        theta = self.params[0]
+        q = QuantumRegister(self.num_qubits, "q")
         qc = QuantumCircuit(q, name=self.name)
         for i in range(self.num_qubits):
             for j in range(i + 1, self.num_qubits):
-                # if theta is just a single angle, use that, otherwise use the correct index
-                theta = thetas if not isinstance(thetas, Sequence) else thetas[i][j]
                 qc._append(RXXGate(theta), [q[i], q[j]], [])
 
         self.definition = qc
-
-    def validate_parameter(self, parameter):
-        if isinstance(parameter, Sequence):
-            # pylint: disable=super-with-arguments
-            return [
-                [super(MSGate, self).validate_parameter(theta) for theta in row]
-                for row in parameter
-            ]
-
-        return super().validate_parameter(parameter)

qiskit/circuit/library/generalized_gates/gr.py

@@ -21,7 +21,7 @@ class GR(QuantumCircuit):
 
     **Circuit symbol:**
 
-    .. code-block:: text
+    .. parsed-literal::
 
              ┌──────────┐
         q_0: ┤0         ├
@@ -75,7 +75,7 @@ class GRX(GR):
 
     **Circuit symbol:**
 
-    .. code-block:: text
+    .. parsed-literal::
 
              ┌──────────┐
         q_0: ┤0         ├
@@ -123,7 +123,7 @@ class GRY(GR):
 
     **Circuit symbol:**
 
-    .. code-block:: text
+    .. parsed-literal::
 
              ┌──────────┐
         q_0: ┤0         ├
@@ -171,7 +171,7 @@ class GRZ(QuantumCircuit):
 
     **Circuit symbol:**
 
-    .. code-block:: text
+    .. parsed-literal::
 
              ┌──────────┐
         q_0: ┤0         ├

qiskit/circuit/library/generalized_gates/isometry.py

@@ -31,7 +31,7 @@ from qiskit.exceptions import QiskitError
 from qiskit.quantum_info.operators.predicates import is_isometry
 from qiskit._accelerate import isometry as isometry_rs
 
-from .diagonal import DiagonalGate
+from .diagonal import Diagonal
 from .uc import UCGate
 from .mcg_up_to_diagonal import MCGupDiag
 
@@ -167,7 +167,7 @@ class Isometry(Instruction):
         if len(diag) > 1 and not isometry_rs.diag_is_identity_up_to_global_phase(
             diag, self._epsilon
         ):
-            diagonal = DiagonalGate(np.conj(diag))
+            diagonal = Diagonal(np.conj(diag))
             circuit.append(diagonal, q_input)
         return circuit
 

qiskit/circuit/library/generalized_gates/linear_function.py

@@ -17,7 +17,6 @@ import numpy as np
 from qiskit.circuit.quantumcircuit import QuantumCircuit, Gate
 from qiskit.circuit.exceptions import CircuitError
 from qiskit.circuit.library.generalized_gates.permutation import PermutationGate
-from qiskit.utils.deprecation import deprecate_func
 
 # pylint: disable=cyclic-import
 from qiskit.quantum_info import Clifford
@@ -38,7 +37,7 @@ class LinearFunction(Gate):
 
     **Example:** the circuit
 
-    .. code-block:: text
+    .. parsed-literal::
 
         q_0: ──■──
              ┌─┴─┐
@@ -68,7 +67,7 @@ class LinearFunction(Gate):
     def __init__(
         self,
         linear: (
-            list[list[bool]]
+            list[list]
             | np.ndarray[bool]
             | QuantumCircuit
             | LinearFunction
@@ -222,22 +221,17 @@ class LinearFunction(Gate):
 
     def _define(self):
         """Populates self.definition with a decomposition of this gate."""
-        from qiskit.synthesis.linear import synth_cnot_count_full_pmh
-
-        self.definition = synth_cnot_count_full_pmh(self.linear)
+        self.definition = self.synthesize()
 
-    @deprecate_func(
-        since="1.3",
-        pending=True,
-        additional_msg="Call LinearFunction.definition instead, or compile the circuit.",
-    )
     def synthesize(self):
         """Synthesizes the linear function into a quantum circuit.
 
         Returns:
             QuantumCircuit: A circuit implementing the evolution.
         """
-        return self.definition
+        from qiskit.synthesis.linear import synth_cnot_count_full_pmh
+
+        return synth_cnot_count_full_pmh(self.linear)
 
     @property
     def linear(self):