qiskit 1.4.1__cp39-abi3-win_amd64.whl → 2.0.0__cp39-abi3-win_amd64.whl

qiskit/circuit/library/arithmetic/__init__.py

@@ -13,14 +13,22 @@
 """The arithmetic circuit library."""
 
 from .functional_pauli_rotations import FunctionalPauliRotations
-from .integer_comparator import IntegerComparator
-from .linear_pauli_rotations import LinearPauliRotations
-from .piecewise_linear_pauli_rotations import PiecewiseLinearPauliRotations
-from .piecewise_polynomial_pauli_rotations import PiecewisePolynomialPauliRotations
-from .polynomial_pauli_rotations import PolynomialPauliRotations
-from .weighted_adder import WeightedAdder
-from .quadratic_form import QuadraticForm
-from .linear_amplitude_function import LinearAmplitudeFunction
+from .integer_comparator import IntegerComparator, IntegerComparatorGate
+from .linear_pauli_rotations import LinearPauliRotations, LinearPauliRotationsGate
+from .piecewise_linear_pauli_rotations import (
+    PiecewiseLinearPauliRotations,
+    PiecewiseLinearPauliRotationsGate,
+)
+from .piecewise_polynomial_pauli_rotations import (
+    PiecewisePolynomialPauliRotations,
+    PiecewisePolynomialPauliRotationsGate,
+)
+from .polynomial_pauli_rotations import PolynomialPauliRotations, PolynomialPauliRotationsGate
+from .weighted_adder import WeightedAdder, WeightedSumGate
+from .quadratic_form import QuadraticForm, QuadraticFormGate
+from .linear_amplitude_function import LinearAmplitudeFunction, LinearAmplitudeFunctionGate
+from .piecewise_chebyshev import PiecewiseChebyshev, PiecewiseChebyshevGate
+from .exact_reciprocal import ExactReciprocal, ExactReciprocalGate
 from .adders import (
     VBERippleCarryAdder,
     CDKMRippleCarryAdder,
@@ -29,6 +37,4 @@ from .adders import (
     HalfAdderGate,
     FullAdderGate,
 )
-from .piecewise_chebyshev import PiecewiseChebyshev
 from .multipliers import HRSCumulativeMultiplier, RGQFTMultiplier, MultiplierGate
-from .exact_reciprocal import ExactReciprocal

qiskit/circuit/library/arithmetic/adders/cdkm_ripple_carry_adder.py

@@ -84,7 +84,7 @@ class CDKMRippleCarryAdder(Adder):
         :class:`.ModularAdderGate`: A generic inplace adder, modulo :math:`2^n`. This
             is functionally equivalent to ``kind="fixed"``.
 
-        :class:`.HalfAdderGate`: A generic inplace adder. This
+        :class:`.AdderGate`: A generic inplace adder. This
             is functionally equivalent to ``kind="half"``.
 
         :class:`.FullAdderGate`: A generic inplace adder, with a carry-in bit. This

qiskit/circuit/library/arithmetic/adders/draper_qft_adder.py

@@ -15,7 +15,7 @@
 import numpy as np
 
 from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit import QuantumRegister
 from qiskit.circuit.library.basis_change import QFT
 
 from .adder import Adder
@@ -54,7 +54,7 @@ class DraperQFTAdder(Adder):
         :class:`.ModularAdderGate`: A generic inplace adder, modulo :math:`2^n`. This
             is functionally equivalent to ``kind="fixed"``.
 
-        :class:`.HalfAdderGate`: A generic inplace adder. This
+        :class:`.AdderGate`: A generic inplace adder. This
             is functionally equivalent to ``kind="half"``.
 
     **References:**

qiskit/circuit/library/arithmetic/adders/vbe_ripple_carry_adder.py

@@ -60,7 +60,7 @@ class VBERippleCarryAdder(Adder):
         :class:`.ModularAdderGate`: A generic inplace adder, modulo :math:`2^n`. This
             is functionally equivalent to ``kind="fixed"``.
 
-        :class:`.HalfAdderGate`: A generic inplace adder. This
+        :class:`.AdderGate`: A generic inplace adder. This
             is functionally equivalent to ``kind="half"``.
 
         :class:`.FullAdderGate`: A generic inplace adder, with a carry-in bit. This

qiskit/circuit/library/arithmetic/exact_reciprocal.py

@@ -13,7 +13,7 @@
 
 from math import isclose
 import numpy as np
-from qiskit.circuit import QuantumCircuit, QuantumRegister
+from qiskit.circuit import QuantumCircuit, QuantumRegister, Gate
 from qiskit.circuit.library.generalized_gates import UCRYGate
 
 
@@ -46,43 +46,86 @@ class ExactReciprocal(QuantumCircuit):
         """
         qr_state = QuantumRegister(num_state_qubits, "state")
         qr_flag = QuantumRegister(1, "flag")
-        circuit = QuantumCircuit(qr_state, qr_flag, name=name)
+        super().__init__(qr_state, qr_flag, name=name)
+
+        reciprocal = ExactReciprocalGate(num_state_qubits, scaling, neg_vals, label=name)
+        self.append(reciprocal, self.qubits)
+
+
+class ExactReciprocalGate(Gate):
+    r"""Implements an exact reciprocal function.
+
+    For a state :math:`|x\rangle` and a scaling factor :math:`s`, this gate implements the operation
+
+    .. math::
+
+        |x\rangle |0\rangle \mapsto
+            \cos\left(\arcsin\left(s\frac{2^n}{x}\right)\right)|x\rangle|0\rangle +
+            \left(s\frac{2^n}{x}\right)|x\rangle|1\rangle.
+
+    States representing :math:`x = 0` or :math:`s 2^n / x \geq 1` are left unchanged, since
+    this function would not be defined.
+    """
+
+    def __init__(
+        self, num_state_qubits: int, scaling: float, neg_vals: bool = False, label: str = "1/x"
+    ) -> None:
+        r"""
+        Args:
+            num_state_qubits: The number of qubits representing the value to invert.
+            scaling: Scaling factor :math:`s` of the reciprocal function, i.e. to compute
+                :math:`s / x`.
+            neg_vals: Whether :math:`x` might represent negative values. In this case the first
+                qubit is the sign, with :math:`|1\rangle` for negative and :math:`|0\rangle` for
+                positive.  For the negative case it is assumed that the remaining string represents
+                :math:`1 - x`. This is because :math:`e^{-2 \pi i x} = e^{2 \pi i (1 - x)}` for
+                :math:`x \in [0,1)`.
+            label: The label of the object.
+
+        .. note::
+
+            It is assumed that the binary string :math:`x` represents a number < 1.
+        """
+        super().__init__("ExactReciprocal", num_state_qubits + 1, [], label=label)
+
+        self.scaling = scaling
+        self.neg_vals = neg_vals
+
+    def _define(self):
+        num_state_qubits = self.num_qubits - 1
+        qr_state = QuantumRegister(num_state_qubits, "state")
+        qr_flag = QuantumRegister(1, "flag")
+        circuit = QuantumCircuit(qr_state, qr_flag)
 
         angles = [0.0]
-        nl = 2 ** (num_state_qubits - 1) if neg_vals else 2**num_state_qubits
+        nl = 2 ** (num_state_qubits - 1) if self.neg_vals else 2**num_state_qubits
 
         # Angles to rotate by scaling / x, where x = i / nl
         for i in range(1, nl):
-            if isclose(scaling * nl / i, 1, abs_tol=1e-5):
+            if isclose(self.scaling * nl / i, 1, abs_tol=1e-5):
                 angles.append(np.pi)
-            elif scaling * nl / i < 1:
-                angles.append(2 * np.arcsin(scaling * nl / i))
+            elif self.scaling * nl / i < 1:
+                angles.append(2 * np.arcsin(self.scaling * nl / i))
             else:
                 angles.append(0.0)
 
-        circuit.compose(
-            UCRYGate(angles), [qr_flag[0]] + qr_state[: len(qr_state) - neg_vals], inplace=True
-        )
+        circuit.append(UCRYGate(angles), [qr_flag[0]] + qr_state[: len(qr_state) - self.neg_vals])
 
-        if neg_vals:
-            circuit.compose(
+        if self.neg_vals:
+            circuit.append(
                 UCRYGate([-theta for theta in angles]).control(),
                 [qr_state[-1]] + [qr_flag[0]] + qr_state[:-1],
-                inplace=True,
             )
             angles_neg = [0.0]
             for i in range(1, nl):
-                if isclose(scaling * (-1) / (1 - i / nl), -1, abs_tol=1e-5):
+                if isclose(self.scaling * (-1) / (1 - i / nl), -1, abs_tol=1e-5):
                     angles_neg.append(-np.pi)
-                elif np.abs(scaling * (-1) / (1 - i / nl)) < 1:
-                    angles_neg.append(2 * np.arcsin(scaling * (-1) / (1 - i / nl)))
+                elif np.abs(self.scaling * (-1) / (1 - i / nl)) < 1:
+                    angles_neg.append(2 * np.arcsin(self.scaling * (-1) / (1 - i / nl)))
                 else:
                     angles_neg.append(0.0)
-            circuit.compose(
-                UCRYGate(angles_neg).control(),
-                [qr_state[-1]] + [qr_flag[0]] + qr_state[:-1],
-                inplace=True,
+            circuit.append(
+                UCRYGate(angles_neg).control(), [qr_state[-1]] + [qr_flag[0]] + qr_state[:-1]
             )
 
-        super().__init__(*circuit.qregs, name=name)
-        self.compose(circuit.to_gate(), qubits=self.qubits, inplace=True)
+        self.definition = circuit

qiskit/circuit/library/arithmetic/integer_comparator.py

@@ -14,11 +14,13 @@
 """Integer Comparator."""
 
 from __future__ import annotations
-import math
 
-from qiskit.circuit import QuantumCircuit, QuantumRegister, AncillaRegister
+from qiskit.circuit import QuantumRegister, AncillaRegister, Gate
 from qiskit.circuit.exceptions import CircuitError
-from ..boolean_logic import OR
+from qiskit.synthesis.arithmetic.comparators import (
+    synth_integer_comparator_2s,
+    synth_integer_comparator_greedy,
+)
 from ..blueprintcircuit import BlueprintCircuit
 
 
@@ -134,19 +136,6 @@ class IntegerComparator(BlueprintCircuit):
                     qr_ancilla = AncillaRegister(num_ancillas)
                     self.add_register(qr_ancilla)
 
-    def _get_twos_complement(self) -> list[int]:
-        """Returns the 2's complement of ``self.value`` as array.
-
-        Returns:
-             The 2's complement of ``self.value``.
-        """
-        twos_complement = pow(2, self.num_state_qubits) - math.ceil(self.value)
-        twos_complement = f"{twos_complement:b}".rjust(self.num_state_qubits, "0")
-        twos_complement = [
-            1 if twos_complement[i] == "1" else 0 for i in reversed(range(len(twos_complement)))
-        ]
-        return twos_complement
-
     def _check_configuration(self, raise_on_failure: bool = True) -> bool:
         """Check if the current configuration is valid."""
         valid = True
@@ -176,68 +165,36 @@ class IntegerComparator(BlueprintCircuit):
 
         super()._build()
 
-        qr_state = self.qubits[: self.num_state_qubits]
-        q_compare = self.qubits[self.num_state_qubits]
-        qr_ancilla = self.qubits[self.num_state_qubits + 1 :]
-
-        circuit = QuantumCircuit(*self.qregs, name=self.name)
-
-        if self.value <= 0:  # condition always satisfied for non-positive values
-            if self._geq:  # otherwise the condition is never satisfied
-                circuit.x(q_compare)
-        # condition never satisfied for values larger than or equal to 2^n
-        elif self.value < pow(2, self.num_state_qubits):
-
-            if self.num_state_qubits > 1:
-                twos = self._get_twos_complement()
-                for i in range(self.num_state_qubits):
-                    if i == 0:
-                        if twos[i] == 1:
-                            circuit.cx(qr_state[i], qr_ancilla[i])
-                    elif i < self.num_state_qubits - 1:
-                        if twos[i] == 1:
-                            circuit.compose(
-                                OR(2), [qr_state[i], qr_ancilla[i - 1], qr_ancilla[i]], inplace=True
-                            )
-                        else:
-                            circuit.ccx(qr_state[i], qr_ancilla[i - 1], qr_ancilla[i])
-                    else:
-                        if twos[i] == 1:
-                            # OR needs the result argument as qubit not register, thus
-                            # access the index [0]
-                            circuit.compose(
-                                OR(2), [qr_state[i], qr_ancilla[i - 1], q_compare], inplace=True
-                            )
-                        else:
-                            circuit.ccx(qr_state[i], qr_ancilla[i - 1], q_compare)
-
-                # flip result bit if geq flag is false
-                if not self._geq:
-                    circuit.x(q_compare)
-
-                # uncompute ancillas state
-                for i in reversed(range(self.num_state_qubits - 1)):
-                    if i == 0:
-                        if twos[i] == 1:
-                            circuit.cx(qr_state[i], qr_ancilla[i])
-                    else:
-                        if twos[i] == 1:
-                            circuit.compose(
-                                OR(2), [qr_state[i], qr_ancilla[i - 1], qr_ancilla[i]], inplace=True
-                            )
-                        else:
-                            circuit.ccx(qr_state[i], qr_ancilla[i - 1], qr_ancilla[i])
-            else:
-
-                # num_state_qubits == 1 and value == 1:
-                circuit.cx(qr_state[0], q_compare)
-
-                # flip result bit if geq flag is false
-                if not self._geq:
-                    circuit.x(q_compare)
-
-        else:
-            if not self._geq:  # otherwise the condition is never satisfied
-                circuit.x(q_compare)
-
+        circuit = synth_integer_comparator_2s(self.num_state_qubits, self.value, self.geq)
         self.append(circuit.to_gate(), self.qubits)
+
+
+class IntegerComparatorGate(Gate):
+    r"""Perform a :math:`\geq` (or :math:`<`) on a qubit register against a classical integer.
+
+    This operator compares basis states :math:`|i\rangle_n` against a classically given integer
+    :math:`L` of fixed value and flips a target qubit if :math:`i \geq L`
+    (or :math:`<` depending on the parameter ``geq``):
+
+    .. math::
+
+        |i\rangle_n |0\rangle \mapsto |i\rangle_n |i \geq L\rangle
+
+    """
+
+    def __init__(
+        self, num_state_qubits: int, value: int, geq: bool = True, label: str | None = None
+    ):
+        r"""
+        Args:
+            num_state_qubits: The number of qubits in the registers.
+            value: The value :math:`L` to compre to.
+            geq: If ``True`` compute :math:`i \geq L`, otherwise compute :math:`i < L`.
+            label: An optional label for the gate.
+        """
+        super().__init__("IntComp", num_state_qubits + 1, [], label=label)
+        self.value = value
+        self.geq = geq
+
+    def _define(self):
+        self.definition = synth_integer_comparator_greedy(self.num_qubits - 1, self.value, self.geq)

qiskit/circuit/library/arithmetic/linear_amplitude_function.py

@@ -14,9 +14,12 @@
 
 from __future__ import annotations
 import numpy as np
-from qiskit.circuit import QuantumCircuit
+from qiskit.circuit import QuantumCircuit, Gate
 
-from .piecewise_linear_pauli_rotations import PiecewiseLinearPauliRotations
+from .piecewise_linear_pauli_rotations import (
+    PiecewiseLinearPauliRotations,
+    PiecewiseLinearPauliRotationsGate,
+)
 
 
 class LinearAmplitudeFunction(QuantumCircuit):
@@ -173,6 +176,170 @@ class LinearAmplitudeFunction(QuantumCircuit):
         return value
 
 
+class LinearAmplitudeFunctionGate(Gate):
+    r"""A circuit implementing a (piecewise) linear function on qubit amplitudes.
+
+    An amplitude function :math:`F` of a function :math:`f` is a mapping
+
+    .. math::
+
+        F|x\rangle|0\rangle = \sqrt{1 - \hat{f}(x)} |x\rangle|0\rangle + \sqrt{\hat{f}(x)}
+            |x\rangle|1\rangle.
+
+    for a function :math:`\hat{f}: \{ 0, ..., 2^n - 1 \} \rightarrow [0, 1]`, where
+    :math:`|x\rangle` is a :math:`n` qubit state.
+
+    This circuit implements :math:`F` for piecewise linear functions :math:`\hat{f}`.
+    In this case, the mapping :math:`F` can be approximately implemented using a Taylor expansion
+    and linearly controlled Pauli-Y rotations, see [1, 2] for more detail. This approximation
+    uses a ``rescaling_factor`` to determine the accuracy of the Taylor expansion.
+
+    In general, the function of interest :math:`f` is defined from some interval :math:`[a,b]`,
+    the ``domain`` to :math:`[c,d]`, the ``image``, instead of :math:`\{ 1, ..., N \}` to
+    :math:`[0, 1]`. Using an affine transformation we can rescale :math:`f` to :math:`\hat{f}`:
+
+    .. math::
+
+        \hat{f}(x) = \frac{f(\phi(x)) - c}{d - c}
+
+    with
+
+    .. math::
+
+        \phi(x) = a + \frac{b - a}{2^n - 1} x.
+
+    If :math:`f` is a piecewise linear function on :math:`m` intervals
+    :math:`[p_{i-1}, p_i], i \in \{1, ..., m\}` with slopes :math:`\alpha_i` and
+    offsets :math:`\beta_i` it can be written as
+
+    .. math::
+
+        f(x) = \sum_{i=1}^m 1_{[p_{i-1}, p_i]}(x) (\alpha_i x + \beta_i)
+
+    where :math:`1_{[a, b]}` is an indication function that is 1 if the argument is in the interval
+    :math:`[a, b]` and otherwise 0. The breakpoints :math:`p_i` can be specified by the
+    ``breakpoints`` argument.
+
+    References:
+
+        [1]: Woerner, S., & Egger, D. J. (2018).
+             Quantum Risk Analysis.
+             `arXiv:1806.06893 <http://arxiv.org/abs/1806.06893>`_
+
+        [2]: Gacon, J., Zoufal, C., & Woerner, S. (2020).
+             Quantum-Enhanced Simulation-Based Optimization.
+             `arXiv:2005.10780 <http://arxiv.org/abs/2005.10780>`_
+    """
+
+    def __init__(
+        self,
+        num_state_qubits: int,
+        slope: float | list[float],
+        offset: float | list[float],
+        domain: tuple[float, float],
+        image: tuple[float, float],
+        rescaling_factor: float = 1,
+        breakpoints: list[float] | None = None,
+        label: str = "F",
+    ) -> None:
+        r"""
+        Args:
+            num_state_qubits: The number of qubits used to encode the variable :math:`x`.
+            slope: The slope of the linear function. Can be a list of slopes if it is a piecewise
+                linear function.
+            offset: The offset of the linear function. Can be a list of offsets if it is a piecewise
+                linear function.
+            domain: The domain of the function as tuple :math:`(x_\min{}, x_\max{})`.
+            image: The image of the function as tuple :math:`(f_\min{}, f_\max{})`.
+            rescaling_factor: The rescaling factor to adjust the accuracy in the Taylor
+                approximation.
+            breakpoints: The breakpoints if the function is piecewise linear. If None, the function
+                is not piecewise.
+            label: A label for the gate.
+        """
+        if not hasattr(slope, "__len__"):
+            slope = [slope]
+        if not hasattr(offset, "__len__"):
+            offset = [offset]
+
+        # ensure that the breakpoints include the first point of the domain
+        if breakpoints is None:
+            breakpoints = [domain[0]]
+        else:
+            if not np.isclose(breakpoints[0], domain[0]):
+                breakpoints = [domain[0]] + breakpoints
+
+        _check_sizes_match(slope, offset, breakpoints)
+        _check_sorted_and_in_range(breakpoints, domain)
+
+        self.slope = slope
+        self.offset = offset
+        self.domain = domain
+        self.image = image
+        self.rescaling_factor = rescaling_factor
+        self.breakpoints = breakpoints
+
+        num_compare = int(len(breakpoints) > 1)
+        super().__init__("LinFunction", num_state_qubits + num_compare + 1, [], label=label)
+
+    def _define(self):
+        num_compare = int(len(self.breakpoints) > 1)
+        num_state_qubits = self.num_qubits - num_compare - 1
+
+        # do rescaling
+        a, b = self.domain
+        c, d = self.image
+
+        mapped_breakpoints = []
+        mapped_slope = []
+        mapped_offset = []
+        for i, point in enumerate(self.breakpoints):
+            mapped_breakpoint = (point - a) / (b - a) * (2**num_state_qubits - 1)
+            mapped_breakpoints += [mapped_breakpoint]
+
+            # factor (upper - lower) / (2^n - 1) is for the scaling of x to [l,u]
+            # note that the +l for mapping to [l,u] is already included in
+            # the offsets given as parameters
+            mapped_slope += [self.slope[i] * (b - a) / (2**num_state_qubits - 1)]
+            mapped_offset += [self.offset[i]]
+
+        # approximate linear behavior by scaling and contracting around pi/4
+        slope_angles = np.zeros(len(self.breakpoints))
+        offset_angles = np.pi / 4 * (1 - self.rescaling_factor) * np.ones_like(slope_angles)
+        for i, (slope_i, offset_i) in enumerate(zip(mapped_slope, mapped_offset)):
+            slope_angles[i] = np.pi * self.rescaling_factor * slope_i / 2 / (d - c)
+            offset_angles[i] += np.pi * self.rescaling_factor * (offset_i - c) / 2 / (d - c)
+
+        # use PWLPauliRotations to implement the function
+        pwl_pauli_rotation = PiecewiseLinearPauliRotationsGate(
+            num_state_qubits, mapped_breakpoints, 2 * slope_angles, 2 * offset_angles
+        )
+
+        self.definition = QuantumCircuit(pwl_pauli_rotation.num_qubits)
+        self.definition.append(pwl_pauli_rotation, self.definition.qubits)
+
+    def post_processing(self, scaled_value: float) -> float:
+        r"""Map the function value of the approximated :math:`\hat{f}` to :math:`f`.
+
+        Args:
+            scaled_value: A function value from the Taylor expansion of :math:`\hat{f}(x)`.
+
+        Returns:
+            The ``scaled_value`` mapped back to the domain of :math:`f`, by first inverting
+            the transformation used for the Taylor approximation and then mapping back from
+            :math:`[0, 1]` to the original domain.
+        """
+        # revert the mapping applied in the Taylor approximation
+        value = scaled_value - 1 / 2 + np.pi / 4 * self.rescaling_factor
+        value *= 2 / np.pi / self.rescaling_factor
+
+        # map the value from [0, 1] back to the original domain
+        value *= self.image[1] - self.image[0]
+        value += self.image[0]
+
+        return value
+
+
 def _check_sorted_and_in_range(breakpoints, domain):
     if breakpoints is None:
         return

qiskit/circuit/library/arithmetic/linear_pauli_rotations.py

@@ -13,9 +13,10 @@
 
 """Linearly-controlled X, Y or Z rotation."""
 
+from __future__ import annotations
 from typing import Optional
 
-from qiskit.circuit import QuantumRegister, QuantumCircuit
+from qiskit.circuit import QuantumRegister, QuantumCircuit, Gate
 from qiskit.circuit.exceptions import CircuitError
 
 from .functional_pauli_rotations import FunctionalPauliRotations
@@ -164,12 +165,65 @@ class LinearPauliRotations(FunctionalPauliRotations):
             return
 
         super()._build()
+        gate = LinearPauliRotationsGate(self.num_state_qubits, self.slope, self.offset, self.basis)
+        self.append(gate, self.qubits)
 
-        circuit = QuantumCircuit(*self.qregs, name=self.name)
+
+class LinearPauliRotationsGate(Gate):
+    r"""Linearly-controlled X, Y or Z rotation.
+
+    For a register of state qubits :math:`|x\rangle`, a target qubit :math:`|0\rangle` and the
+    basis ``'Y'`` this circuit acts as:
+
+    .. parsed-literal::
+
+            q_0: ─────────────────────────■───────── ... ──────────────────────
+                                          │
+                                          .
+                                          │
+        q_(n-1): ─────────────────────────┼───────── ... ───────────■──────────
+                  ┌────────────┐  ┌───────┴───────┐       ┌─────────┴─────────┐
+            q_n: ─┤ RY(offset) ├──┤ RY(2^0 slope) ├  ...  ┤ RY(2^(n-1) slope) ├
+                  └────────────┘  └───────────────┘       └───────────────────┘
+
+    This can for example be used to approximate linear functions, with :math:`a =` ``slope``:math:`/2`
+    and :math:`b =` ``offset``:math:`/2` and the basis ``'Y'``:
+
+    .. math::
+
+        |x\rangle |0\rangle \mapsto \cos(ax + b)|x\rangle|0\rangle + \sin(ax + b)|x\rangle |1\rangle
+
+    Since for small arguments :math:`\sin(x) \approx x` this operator can be used to approximate
+    linear functions.
+    """
+
+    def __init__(
+        self,
+        num_state_qubits: int,
+        slope: float = 1,
+        offset: float = 0,
+        basis: str = "Y",
+        label: str | None = None,
+    ) -> None:
+        r"""
+        Args:
+            num_state_qubits: The number of qubits representing the state :math:`|x\rangle`.
+            slope: The slope of the controlled rotation.
+            offset: The offset of the controlled rotation.
+            basis: The type of Pauli rotation ('X', 'Y', 'Z').
+            label: The label of the gate.
+        """
+        super().__init__("LinPauliRot", num_state_qubits + 1, [], label=label)
+        self.slope = slope
+        self.offset = offset
+        self.basis = basis.lower()
+
+    def _define(self):
+        circuit = QuantumCircuit(self.num_qubits, name=self.name)
 
         # build the circuit
-        qr_state = self.qubits[: self.num_state_qubits]
-        qr_target = self.qubits[self.num_state_qubits]
+        qr_state = circuit.qubits[: self.num_qubits - 1]
+        qr_target = circuit.qubits[-1]
 
         if self.basis == "x":
             circuit.rx(self.offset, qr_target)
@@ -186,4 +240,4 @@ class LinearPauliRotations(FunctionalPauliRotations):
             else:  # 'Z'
                 circuit.crz(self.slope * pow(2, i), q_i, qr_target)
 
-        self.append(circuit.to_gate(), self.qubits)
+        self.definition = circuit