qiskit 1.3.0b1__cp39-abi3-macosx_10_9_x86_64.whl

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

@@ -0,0 +1,159 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2021.
+#
+# 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.
+
+"""Compute the sum of two qubit registers using ripple-carry approach."""
+
+from qiskit.circuit import QuantumCircuit, QuantumRegister, AncillaRegister
+
+from .adder import Adder
+
+
+class CDKMRippleCarryAdder(Adder):
+    r"""A ripple-carry circuit to perform in-place addition on two qubit registers.
+
+    As an example, a ripple-carry adder circuit that performs addition on two 3-qubit sized
+    registers with a carry-in bit (``kind="full"``) is as follows:
+
+    .. parsed-literal::
+
+                ┌──────┐                                     ┌──────┐
+         cin_0: ┤2     ├─────────────────────────────────────┤2     ├
+                │      │┌──────┐                     ┌──────┐│      │
+           a_0: ┤0     ├┤2     ├─────────────────────┤2     ├┤0     ├
+                │      ││      │┌──────┐     ┌──────┐│      ││      │
+           a_1: ┤  MAJ ├┤0     ├┤2     ├─────┤2     ├┤0     ├┤  UMA ├
+                │      ││      ││      │     │      ││      ││      │
+           a_2: ┤      ├┤  MAJ ├┤0     ├──■──┤0     ├┤  UMA ├┤      ├
+                │      ││      ││      │  │  │      ││      ││      │
+           b_0: ┤1     ├┤      ├┤  MAJ ├──┼──┤  UMA ├┤      ├┤1     ├
+                └──────┘│      ││      │  │  │      ││      │└──────┘
+           b_1: ────────┤1     ├┤      ├──┼──┤      ├┤1     ├────────
+                        └──────┘│      │  │  │      │└──────┘
+           b_2: ────────────────┤1     ├──┼──┤1     ├────────────────
+                                └──────┘┌─┴─┐└──────┘
+        cout_0: ────────────────────────┤ X ├────────────────────────
+                                        └───┘
+
+    Here *MAJ* and *UMA* gates correspond to the gates introduced in [1]. Note that
+    in this implementation the input register qubits are ordered as all qubits from
+    the first input register, followed by all qubits from the second input register.
+
+    Two different kinds of adders are supported. By setting the ``kind`` argument, you can also
+    choose a half-adder, which doesn't have a carry-in, and a fixed-sized-adder, which has neither
+    carry-in nor carry-out, and thus acts on fixed register sizes. Unlike the full-adder,
+    these circuits need one additional helper qubit.
+
+    The circuit diagram for the fixed-point adder (``kind="fixed"``) on 3-qubit sized inputs is
+
+    .. parsed-literal::
+
+                ┌──────┐┌──────┐                ┌──────┐┌──────┐
+           a_0: ┤0     ├┤2     ├────────────────┤2     ├┤0     ├
+                │      ││      │┌──────┐┌──────┐│      ││      │
+           a_1: ┤      ├┤0     ├┤2     ├┤2     ├┤0     ├┤      ├
+                │      ││      ││      ││      ││      ││      │
+           a_2: ┤      ├┤  MAJ ├┤0     ├┤0     ├┤  UMA ├┤      ├
+                │      ││      ││      ││      ││      ││      │
+           b_0: ┤1 MAJ ├┤      ├┤  MAJ ├┤  UMA ├┤      ├┤1 UMA ├
+                │      ││      ││      ││      ││      ││      │
+           b_1: ┤      ├┤1     ├┤      ├┤      ├┤1     ├┤      ├
+                │      │└──────┘│      ││      │└──────┘│      │
+           b_2: ┤      ├────────┤1     ├┤1     ├────────┤      ├
+                │      │        └──────┘└──────┘        │      │
+        help_0: ┤2     ├────────────────────────────────┤2     ├
+                └──────┘                                └──────┘
+
+    It has one less qubit than the full-adder since it doesn't have the carry-out, but uses
+    a helper qubit instead of the carry-in, so it only has one less qubit, not two.
+
+
+    **References:**
+
+    [1] Cuccaro et al., A new quantum ripple-carry addition circuit, 2004.
+    `arXiv:quant-ph/0410184 <https://arxiv.org/pdf/quant-ph/0410184.pdf>`_
+
+    [2] Vedral et al., Quantum Networks for Elementary Arithmetic Operations, 1995.
+    `arXiv:quant-ph/9511018 <https://arxiv.org/pdf/quant-ph/9511018.pdf>`_
+
+    """
+
+    def __init__(
+        self, num_state_qubits: int, kind: str = "full", name: str = "CDKMRippleCarryAdder"
+    ) -> None:
+        r"""
+        Args:
+            num_state_qubits: The number of qubits in either input register for
+                state :math:`|a\rangle` or :math:`|b\rangle`. The two input
+                registers must have the same number of qubits.
+            kind: The kind of adder, can be ``'full'`` for a full adder, ``'half'`` for a half
+                adder, or ``'fixed'`` for a fixed-sized adder. A full adder includes both carry-in
+                and carry-out, a half only carry-out, and a fixed-sized adder neither carry-in
+                nor carry-out.
+            name: The name of the circuit object.
+        Raises:
+            ValueError: If ``num_state_qubits`` is lower than 1.
+        """
+        if num_state_qubits < 1:
+            raise ValueError("The number of qubits must be at least 1.")
+
+        super().__init__(num_state_qubits, name=name)
+
+        if kind == "full":
+            qr_c = QuantumRegister(1, name="cin")
+            self.add_register(qr_c)
+        else:
+            qr_c = AncillaRegister(1, name="help")
+
+        qr_a = QuantumRegister(num_state_qubits, name="a")
+        qr_b = QuantumRegister(num_state_qubits, name="b")
+        self.add_register(qr_a, qr_b)
+
+        if kind in ["full", "half"]:
+            qr_z = QuantumRegister(1, name="cout")
+            self.add_register(qr_z)
+
+        if kind != "full":
+            self.add_register(qr_c)
+
+        # build carry circuit for majority of 3 bits in-place
+        # corresponds to MAJ gate in [1]
+        qc_maj = QuantumCircuit(3, name="MAJ")
+        qc_maj.cx(0, 1)
+        qc_maj.cx(0, 2)
+        qc_maj.ccx(2, 1, 0)
+        maj_gate = qc_maj.to_gate()
+
+        # build circuit for reversing carry operation
+        # corresponds to UMA gate in [1]
+        qc_uma = QuantumCircuit(3, name="UMA")
+        qc_uma.ccx(2, 1, 0)
+        qc_uma.cx(0, 2)
+        qc_uma.cx(2, 1)
+        uma_gate = qc_uma.to_gate()
+
+        circuit = QuantumCircuit(*self.qregs, name=name)
+
+        # build ripple-carry adder circuit
+        circuit.append(maj_gate, [qr_a[0], qr_b[0], qr_c[0]])
+
+        for i in range(num_state_qubits - 1):
+            circuit.append(maj_gate, [qr_a[i + 1], qr_b[i + 1], qr_a[i]])
+
+        if kind in ["full", "half"]:
+            circuit.cx(qr_a[-1], qr_z[0])
+
+        for i in reversed(range(num_state_qubits - 1)):
+            circuit.append(uma_gate, [qr_a[i + 1], qr_b[i + 1], qr_a[i]])
+
+        circuit.append(uma_gate, [qr_a[0], qr_b[0], qr_c[0]])
+
+        self.append(circuit.to_gate(), self.qubits)

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

@@ -0,0 +1,116 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2021.
+#
+# 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.
+
+"""Compute the sum of two qubit registers using QFT."""
+
+import numpy as np
+
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit.library.basis_change import QFT
+
+from .adder import Adder
+
+
+class DraperQFTAdder(Adder):
+    r"""A circuit that uses QFT to perform in-place addition on two qubit registers.
+
+    For registers with :math:`n` qubits, the QFT adder can perform addition modulo
+    :math:`2^n` (with ``kind="fixed"``) or ordinary addition by adding a carry qubits (with
+    ``kind="half"``).
+
+    As an example, a non-fixed_point QFT adder circuit that performs addition on two 2-qubit sized
+    registers is as follows:
+
+    .. parsed-literal::
+
+         a_0:   ─────────■──────■────────────────────────■────────────────
+                         │      │                        │
+         a_1:   ─────────┼──────┼────────■──────■────────┼────────────────
+                ┌──────┐ │P(π)  │        │      │        │       ┌───────┐
+         b_0:   ┤0     ├─■──────┼────────┼──────┼────────┼───────┤0      ├
+                │      │        │P(π/2)  │P(π)  │        │       │       │
+         b_1:   ┤1 qft ├────────■────────■──────┼────────┼───────┤1 iqft ├
+                │      │                        │P(π/2)  │P(π/4) │       │
+        cout_0: ┤2     ├────────────────────────■────────■───────┤2      ├
+                └──────┘                                         └───────┘
+
+    **References:**
+
+    [1] T. G. Draper, Addition on a Quantum Computer, 2000.
+    `arXiv:quant-ph/0008033 <https://arxiv.org/pdf/quant-ph/0008033.pdf>`_
+
+    [2] Ruiz-Perez et al., Quantum arithmetic with the Quantum Fourier Transform, 2017.
+    `arXiv:1411.5949 <https://arxiv.org/pdf/1411.5949.pdf>`_
+
+    [3] Vedral et al., Quantum Networks for Elementary Arithmetic Operations, 1995.
+    `arXiv:quant-ph/9511018 <https://arxiv.org/pdf/quant-ph/9511018.pdf>`_
+
+    """
+
+    def __init__(
+        self, num_state_qubits: int, kind: str = "fixed", name: str = "DraperQFTAdder"
+    ) -> None:
+        r"""
+        Args:
+            num_state_qubits: The number of qubits in either input register for
+                state :math:`|a\rangle` or :math:`|b\rangle`. The two input
+                registers must have the same number of qubits.
+            kind: The kind of adder, can be ``'half'`` for a half adder or
+                ``'fixed'`` for a fixed-sized adder. A half adder contains a carry-out to represent
+                the most-significant bit, but the fixed-sized adder doesn't and hence performs
+                addition modulo ``2 ** num_state_qubits``.
+            name: The name of the circuit object.
+        Raises:
+            ValueError: If ``num_state_qubits`` is lower than 1.
+        """
+        if kind == "full":
+            raise ValueError("The DraperQFTAdder only supports 'half' and 'fixed' as ``kind``.")
+
+        if num_state_qubits < 1:
+            raise ValueError("The number of qubits must be at least 1.")
+
+        super().__init__(num_state_qubits, name=name)
+
+        qr_a = QuantumRegister(num_state_qubits, name="a")
+        qr_b = QuantumRegister(num_state_qubits, name="b")
+        qr_list = [qr_a, qr_b]
+
+        if kind == "half":
+            qr_z = QuantumRegister(1, name="cout")
+            qr_list.append(qr_z)
+
+        # add registers
+        self.add_register(*qr_list)
+
+        # define register containing the sum and number of qubits for QFT circuit
+        qr_sum = qr_b[:] if kind == "fixed" else qr_b[:] + qr_z[:]
+        num_qubits_qft = num_state_qubits if kind == "fixed" else num_state_qubits + 1
+
+        circuit = QuantumCircuit(*self.qregs, name=name)
+
+        # build QFT adder circuit
+        circuit.append(QFT(num_qubits_qft, do_swaps=False).to_gate(), qr_sum[:])
+
+        for j in range(num_state_qubits):
+            for k in range(num_state_qubits - j):
+                lam = np.pi / (2**k)
+                circuit.cp(lam, qr_a[j], qr_b[j + k])
+
+        if kind == "half":
+            for j in range(num_state_qubits):
+                lam = np.pi / (2 ** (j + 1))
+                circuit.cp(lam, qr_a[num_state_qubits - j - 1], qr_z[0])
+
+        circuit.append(QFT(num_qubits_qft, do_swaps=False).inverse().to_gate(), qr_sum[:])
+
+        self.append(circuit.to_gate(), self.qubits)

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

@@ -0,0 +1,165 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2021.
+#
+# 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.
+
+"""Compute the sum of two qubit registers using Classical Addition."""
+from __future__ import annotations
+from qiskit.circuit.bit import Bit
+
+from qiskit.circuit import QuantumCircuit, QuantumRegister, AncillaRegister
+
+from .adder import Adder
+
+
+class VBERippleCarryAdder(Adder):
+    r"""The VBE ripple carry adder [1].
+
+    This circuit performs inplace addition of two equally-sized quantum registers.
+    As an example, a classical adder circuit that performs full addition (i.e. including
+    a carry-in bit) on two 2-qubit sized registers is as follows:
+
+    .. parsed-literal::
+
+                  ┌────────┐                       ┌───────────┐┌──────┐
+           cin_0: ┤0       ├───────────────────────┤0          ├┤0     ├
+                  │        │                       │           ││      │
+             a_0: ┤1       ├───────────────────────┤1          ├┤1     ├
+                  │        │┌────────┐     ┌──────┐│           ││  Sum │
+             a_1: ┤        ├┤1       ├──■──┤1     ├┤           ├┤      ├
+                  │        ││        │  │  │      ││           ││      │
+             b_0: ┤2 Carry ├┤        ├──┼──┤      ├┤2 Carry_dg ├┤2     ├
+                  │        ││        │┌─┴─┐│      ││           │└──────┘
+             b_1: ┤        ├┤2 Carry ├┤ X ├┤2 Sum ├┤           ├────────
+                  │        ││        │└───┘│      ││           │
+          cout_0: ┤        ├┤3       ├─────┤      ├┤           ├────────
+                  │        ││        │     │      ││           │
+        helper_0: ┤3       ├┤0       ├─────┤0     ├┤3          ├────────
+                  └────────┘└────────┘     └──────┘└───────────┘
+
+
+    Here *Carry* and *Sum* gates correspond to the gates introduced in [1].
+    *Carry_dg* correspond to the inverse of the *Carry* gate. Note that
+    in this implementation the input register qubits are ordered as all qubits from
+    the first input register, followed by all qubits from the second input register.
+    This is different ordering as compared to Figure 2 in [1], which leads to a different
+    drawing of the circuit.
+
+    **References:**
+
+    [1] Vedral et al., Quantum Networks for Elementary Arithmetic Operations, 1995.
+    `arXiv:quant-ph/9511018 <https://arxiv.org/pdf/quant-ph/9511018.pdf>`_
+
+    """
+
+    def __init__(
+        self, num_state_qubits: int, kind: str = "full", name: str = "VBERippleCarryAdder"
+    ) -> None:
+        """
+        Args:
+            num_state_qubits: The size of the register.
+            kind: The kind of adder, can be ``'full'`` for a full adder, ``'half'`` for a half
+                adder, or ``'fixed'`` for a fixed-sized adder. A full adder includes both carry-in
+                and carry-out, a half only carry-out, and a fixed-sized adder neither carry-in
+                nor carry-out.
+            name: The name of the circuit.
+
+        Raises:
+            ValueError: If ``num_state_qubits`` is lower than 1.
+        """
+        if num_state_qubits < 1:
+            raise ValueError("The number of qubits must be at least 1.")
+
+        super().__init__(num_state_qubits, name=name)
+
+        # define the input registers
+        registers: list[QuantumRegister | list[Bit]] = []
+        if kind == "full":
+            qr_cin = QuantumRegister(1, name="cin")
+            registers.append(qr_cin)
+        else:
+            qr_cin = QuantumRegister(0)
+
+        qr_a = QuantumRegister(num_state_qubits, name="a")
+        qr_b = QuantumRegister(num_state_qubits, name="b")
+
+        registers += [qr_a, qr_b]
+
+        if kind in ["half", "full"]:
+            qr_cout = QuantumRegister(1, name="cout")
+            registers.append(qr_cout)
+        else:
+            qr_cout = QuantumRegister(0)
+
+        self.add_register(*registers)
+
+        if num_state_qubits > 1:
+            qr_help = AncillaRegister(num_state_qubits - 1, name="helper")
+            self.add_register(qr_help)
+        else:
+            qr_help = AncillaRegister(0)
+
+        # the code is simplified a lot if we create a list of all carries and helpers
+        carries = qr_cin[:] + qr_help[:] + qr_cout[:]
+
+        # corresponds to Carry gate in [1]
+        qc_carry = QuantumCircuit(4, name="Carry")
+        qc_carry.ccx(1, 2, 3)
+        qc_carry.cx(1, 2)
+        qc_carry.ccx(0, 2, 3)
+        carry_gate = qc_carry.to_gate()
+        carry_gate_dg = carry_gate.inverse()
+
+        # corresponds to Sum gate in [1]
+        qc_sum = QuantumCircuit(3, name="Sum")
+        qc_sum.cx(1, 2)
+        qc_sum.cx(0, 2)
+        sum_gate = qc_sum.to_gate()
+
+        circuit = QuantumCircuit(*self.qregs, name=name)
+
+        # handle all cases for the first qubits, depending on whether cin is available
+        i = 0
+        if kind == "half":
+            i += 1
+            circuit.ccx(qr_a[0], qr_b[0], carries[0])
+        elif kind == "fixed":
+            i += 1
+            if num_state_qubits == 1:
+                circuit.cx(qr_a[0], qr_b[0])
+            else:
+                circuit.ccx(qr_a[0], qr_b[0], carries[0])
+
+        for inp, out in zip(carries[:-1], carries[1:]):
+            circuit.append(carry_gate, [inp, qr_a[i], qr_b[i], out])
+            i += 1
+
+        if kind in ["full", "half"]:  # final CX (cancels for the 'fixed' case)
+            circuit.cx(qr_a[-1], qr_b[-1])
+
+        if len(carries) > 1:
+            circuit.append(sum_gate, [carries[-2], qr_a[-1], qr_b[-1]])
+
+        i -= 2
+        for j, (inp, out) in enumerate(zip(reversed(carries[:-1]), reversed(carries[1:]))):
+            if j == 0:
+                if kind == "fixed":
+                    i += 1
+                else:
+                    continue
+            circuit.append(carry_gate_dg, [inp, qr_a[i], qr_b[i], out])
+            circuit.append(sum_gate, [inp, qr_a[i], qr_b[i]])
+            i -= 1
+
+        if kind in ["half", "fixed"] and num_state_qubits > 1:
+            circuit.ccx(qr_a[0], qr_b[0], carries[0])
+            circuit.cx(qr_a[0], qr_b[0])
+
+        self.append(circuit.to_gate(), self.qubits)

qiskit/circuit/library/arithmetic/exact_reciprocal.py

@@ -0,0 +1,88 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2019, 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.
+"""Exact reciprocal rotation."""
+
+from math import isclose
+import numpy as np
+from qiskit.circuit import QuantumCircuit, QuantumRegister
+from qiskit.circuit.library.generalized_gates import UCRYGate
+
+
+class ExactReciprocal(QuantumCircuit):
+    r"""Exact reciprocal
+
+    .. math::
+
+        |x\rangle |0\rangle \mapsto \cos(1/x)|x\rangle|0\rangle + \sin(1/x)|x\rangle |1\rangle
+    """
+
+    def __init__(
+        self, num_state_qubits: int, scaling: float, neg_vals: bool = False, name: 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)`.
+            name: The name of the object.
+
+        .. note::
+
+            It is assumed that the binary string :math:`x` represents a number < 1.
+        """
+        qr_state = QuantumRegister(num_state_qubits, "state")
+        qr_flag = QuantumRegister(1, "flag")
+        circuit = QuantumCircuit(qr_state, qr_flag, name=name)
+
+        angles = [0.0]
+        nl = 2 ** (num_state_qubits - 1) if 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):
+                angles.append(np.pi)
+            elif scaling * nl / i < 1:
+                angles.append(2 * np.arcsin(scaling * nl / i))
+            else:
+                angles.append(0.0)
+
+        circuit.compose(
+            UCRYGate(angles), [qr_flag[0]] + qr_state[: len(qr_state) - neg_vals], inplace=True
+        )
+
+        if neg_vals:
+            circuit.compose(
+                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):
+                    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)))
+                else:
+                    angles_neg.append(0.0)
+            circuit.compose(
+                UCRYGate(angles_neg).control(),
+                [qr_state[-1]] + [qr_flag[0]] + qr_state[:-1],
+                inplace=True,
+            )
+
+        super().__init__(*circuit.qregs, name=name)
+        self.compose(circuit.to_gate(), qubits=self.qubits, inplace=True)

qiskit/circuit/library/arithmetic/functional_pauli_rotations.py

@@ -0,0 +1,114 @@
+# 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.
+
+
+"""Base class for functional Pauli rotations."""
+
+from typing import Optional
+
+from abc import ABC, abstractmethod
+from ..blueprintcircuit import BlueprintCircuit
+
+
+class FunctionalPauliRotations(BlueprintCircuit, ABC):
+    """Base class for functional Pauli rotations."""
+
+    def __init__(
+        self, num_state_qubits: Optional[int] = None, basis: str = "Y", name: str = "F"
+    ) -> None:
+        r"""Create a new functional Pauli rotation circuit.
+
+        Args:
+            num_state_qubits: The number of qubits representing the state :math:`|x\rangle`.
+            basis: The kind of Pauli rotation to use. Must be 'X', 'Y' or 'Z'.
+            name: The name of the circuit object.
+        """
+        super().__init__(name=name)
+
+        # define internal parameters
+        self._num_state_qubits = None
+        self._basis = None
+
+        # store parameters
+        self.num_state_qubits = num_state_qubits
+        self.basis = basis
+
+    @property
+    def basis(self) -> str:
+        """The kind of Pauli rotation to be used.
+
+        Set the basis to 'X', 'Y' or 'Z' for controlled-X, -Y, or -Z rotations respectively.
+
+        Returns:
+            The kind of Pauli rotation used in controlled rotation.
+        """
+        return self._basis
+
+    @basis.setter
+    def basis(self, basis: str) -> None:
+        """Set the kind of Pauli rotation to be used.
+
+        Args:
+            basis: The Pauli rotation to be used.
+
+        Raises:
+            ValueError: The provided basis in not X, Y or Z.
+        """
+        basis = basis.lower()
+        if self._basis is None or basis != self._basis:
+            if basis not in ["x", "y", "z"]:
+                raise ValueError(f"The provided basis must be X, Y or Z, not {basis}")
+            self._invalidate()
+            self._basis = basis
+
+    @property
+    def num_state_qubits(self) -> int:
+        r"""The number of state qubits representing the state :math:`|x\rangle`.
+
+        Returns:
+            The number of state qubits.
+        """
+        return self._num_state_qubits
+
+    @num_state_qubits.setter
+    def num_state_qubits(self, num_state_qubits: Optional[int]) -> None:
+        """Set the number of state qubits.
+
+        Note that this may change the underlying quantum register, if the number of state qubits
+        changes.
+
+        Args:
+            num_state_qubits: The new number of qubits.
+        """
+        if self._num_state_qubits is None or num_state_qubits != self._num_state_qubits:
+            self._invalidate()
+            self._num_state_qubits = num_state_qubits
+
+            self._reset_registers(num_state_qubits)
+
+    @abstractmethod
+    def _reset_registers(self, num_state_qubits: Optional[int]) -> None:
+        """Reset the registers according to the new number of state qubits.
+
+        Args:
+            num_state_qubits: The new number of qubits.
+        """
+        raise NotImplementedError
+
+    @property
+    def num_ancilla_qubits(self) -> int:
+        """The minimum number of ancilla qubits in the circuit.
+
+        Returns:
+            The minimal number of ancillas required.
+        """
+        return 0