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

qiskit/circuit/library/phase_oracle.py

@@ -12,33 +12,34 @@
 
 """Phase Oracle object."""
 
-# Needed to avoid type hints from erroring when `classicalfunction` might not be available.
 from __future__ import annotations
 
-from typing import Union, Callable, Optional, TYPE_CHECKING
+from qiskit.circuit import QuantumCircuit, Gate
 
-from qiskit.circuit import QuantumCircuit
-from qiskit.utils import optionals as _optionals
+from qiskit.synthesis.boolean.boolean_expression import BooleanExpression
 
-if TYPE_CHECKING:
-    from qiskit.circuit.classicalfunction.boolean_expression import BooleanExpression
-    from qiskit.circuit.classicalfunction.classical_element import ClassicalElement
 
-
-@_optionals.HAS_TWEEDLEDUM.require_in_instance
 class PhaseOracle(QuantumCircuit):
     r"""Phase Oracle.
 
     The Phase Oracle object constructs circuits for any arbitrary
     input logical expressions. A logical expression is composed of logical operators
-    `&` (`AND`), `|` (`OR`), `~` (`NOT`), and `^` (`XOR`).
+    `&` (logical `AND`), `|` (logical  `OR`),
+    `~` (logical  `NOT`), and `^` (logical  `XOR`).
     as well as symbols for literals (variables).
     For example, `'a & b'`, and `(v0 | ~v1) & (~v2 & v3)`
     are both valid string representation of boolean logical expressions.
 
+    A phase oracle for a boolean function `f(x)` performs the following
+    quantum operation:
+
+    .. math::
+
+            |x\rangle \mapsto (-1)^{f(x)}|x\rangle
+
     For convenience, this oracle, in addition to parsing arbitrary logical expressions,
     also supports input strings in the `DIMACS CNF format
-    <http://www.satcompetition.org/2009/format-benchmarks2009.html>`__,
+    <https://web.archive.org/web/20190325181937/https://www.satcompetition.org/2009/format-benchmarks2009.html>`__,
     which is the standard format for specifying SATisfiability (SAT) problem instances in
     `Conjunctive Normal Form (CNF) <https://en.wikipedia.org/wiki/Conjunctive_normal_form>`__,
     which is a conjunction of one or more clauses, where a clause is a disjunction of one
@@ -50,51 +51,21 @@ class PhaseOracle(QuantumCircuit):
 
     def __init__(
         self,
-        expression: Union[str, ClassicalElement],
-        synthesizer: Optional[Callable[[BooleanExpression], QuantumCircuit]] = None,
-        var_order: list = None,
+        expression: str,
+        var_order: list[str] | None = None,
     ) -> None:
-        """Creates a PhaseOracle object
-
+        """
         Args:
             expression: A Python-like boolean expression.
-            synthesizer: Optional. A function to convert a BooleanExpression into a QuantumCircuit
-               If None is provided, Tweedledum's `pkrm_synth` with `phase_esop` will be used.
-            var_order(list): A list with the order in which variables will be created.
+            var_order: A list with the order in which variables will be created.
                (default: by appearance)
         """
-        # ignore deprecation warning for BooleanExpression; implementation is changing in 2.0
-        import warnings
-
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore", DeprecationWarning)
-            from qiskit.circuit.classicalfunction.boolean_expression import BooleanExpression
-            from qiskit.circuit.classicalfunction.classical_element import ClassicalElement
-
-            if not isinstance(expression, ClassicalElement):
-                expression = BooleanExpression(expression, var_order=var_order)
-
-            self.boolean_expression = expression
-
-            if synthesizer is None:
-
-                def synthesizer(boolean_expression):
-                    from tweedledum.synthesis import pkrm_synth  # pylint: disable=import-error
-                    from qiskit.circuit.classicalfunction.utils import tweedledum2qiskit
+        self.boolean_expression = BooleanExpression(expression, var_order=var_order)
+        oracle = self.boolean_expression.synth(circuit_type="phase")
 
-                    truth_table = boolean_expression._tweedledum_bool_expression.truth_table(
-                        output_bit=0
-                    )
-                    tweedledum_circuit = pkrm_synth(
-                        truth_table, {"pkrm_synth": {"phase_esop": True}}
-                    )
-                    return tweedledum2qiskit(tweedledum_circuit)
+        super().__init__(oracle.num_qubits, name="Phase Oracle")
 
-            oracle = expression.synth(synthesizer=synthesizer)
-
-            super().__init__(oracle.num_qubits, name="Phase Oracle")
-
-            self.compose(oracle, inplace=True, copy=False)
+        self.compose(oracle, inplace=True, copy=False)
 
     def evaluate_bitstring(self, bitstring: str) -> bool:
         """Evaluate the oracle on a bitstring.
@@ -114,7 +85,7 @@ class PhaseOracle(QuantumCircuit):
         r"""Create a PhaseOracle from the string in the DIMACS format.
 
         It is possible to build a PhaseOracle from a file in `DIMACS CNF format
-        <http://www.satcompetition.org/2009/format-benchmarks2009.html>`__,
+        <https://web.archive.org/web/20190325181937/https://www.satcompetition.org/2009/format-benchmarks2009.html>`__,
         which is the standard format for specifying SATisfiability (SAT) problem instances in
         `Conjunctive Normal Form (CNF) <https://en.wikipedia.org/wiki/Conjunctive_normal_form>`__,
         which is a conjunction of one or more clauses, where a clause is a disjunction of one
@@ -154,7 +125,115 @@ class PhaseOracle(QuantumCircuit):
         Returns:
             PhaseOracle: A quantum circuit with a phase oracle.
         """
-        from qiskit.circuit.classicalfunction.boolean_expression import BooleanExpression
+        expr = BooleanExpression.from_dimacs_file(filename)
+        return cls(expr)
+
+
+class PhaseOracleGate(Gate):
+    r"""Implements a phase oracle.
+
+    The Phase Oracle Gate object constructs circuits for any arbitrary
+    input logical expressions. A logical expression is composed of logical operators
+    `&` (logical `AND`), `|` (logical  `OR`),
+    `~` (logical  `NOT`), and `^` (logical  `XOR`).
+    as well as symbols for literals (variables).
+    For example, `'a & b'`, and `(v0 | ~v1) & (~v2 & v3)`
+    are both valid string representation of boolean logical expressions.
+
+    A phase oracle for a boolean function `f(x)` performs the following
+    quantum operation:
+
+    .. math::
+
+            |x\rangle \mapsto (-1)^{f(x)}|x\rangle
+
+    For convenience, this oracle, in addition to parsing arbitrary logical expressions,
+    also supports input strings in the `DIMACS CNF format
+    <https://web.archive.org/web/20190325181937/https://www.satcompetition.org/2009/format-benchmarks2009.html>`__,
+    which is the standard format for specifying SATisfiability (SAT) problem instances in
+    `Conjunctive Normal Form (CNF) <https://en.wikipedia.org/wiki/Conjunctive_normal_form>`__,
+    which is a conjunction of one or more clauses, where a clause is a disjunction of one
+    or more literals. See :meth:`qiskit.circuit.library.phase_oracle.PhaseOracleGate.from_dimacs_file`.
+
+    From 16 variables on, possible performance issues should be expected when using the
+    default synthesizer.
+    """
+
+    def __init__(
+        self,
+        expression: str,
+        var_order: list[str] | None = None,
+        label: str | None = None,
+    ) -> None:
+        """
+        Args:
+            expression: A Python-like boolean expression.
+            var_order: A list with the order in which variables will be created.
+               (default: by appearance)
+            label: A label for the gate to display in visualizations. Per default, the label is
+                set to display the textual represntation of the boolean expression (truncated if needed)
+        """
+        self.boolean_expression = BooleanExpression(expression, var_order=var_order)
 
+        if label is None:
+            short_expr_for_name = (expression[:15] + "...") if len(expression) > 15 else expression
+            label = short_expr_for_name
+
+        super().__init__(
+            name="Phase Oracle",
+            num_qubits=self.boolean_expression.num_bits,
+            params=[],
+            label=label,
+        )
+
+    def _define(self):
+        """Defined by the synthesized phase oracle"""
+        self.definition = self.boolean_expression.synth(circuit_type="phase")
+
+    @classmethod
+    def from_dimacs_file(cls, filename: str) -> PhaseOracleGate:
+        r"""Create a PhaseOracle from the string in the DIMACS format.
+
+        It is possible to build a PhaseOracle from a file in `DIMACS CNF format
+        <https://web.archive.org/web/20190325181937/https://www.satcompetition.org/2009/format-benchmarks2009.html>`__,
+        which is the standard format for specifying SATisfiability (SAT) problem instances in
+        `Conjunctive Normal Form (CNF) <https://en.wikipedia.org/wiki/Conjunctive_normal_form>`__,
+        which is a conjunction of one or more clauses, where a clause is a disjunction of one
+        or more literals.
+
+        The following is an example of a CNF expressed in the DIMACS format:
+
+        .. code:: text
+
+          c DIMACS CNF file with 3 satisfying assignments: 1 -2 3, -1 -2 -3, 1 2 -3.
+          p cnf 3 5
+          -1 -2 -3 0
+          1 -2 3 0
+          1 2 -3 0
+          1 -2 -3 0
+          -1 2 3 0
+
+        The first line, following the `c` character, is a comment. The second line specifies that
+        the CNF is over three boolean variables --- let us call them  :math:`x_1, x_2, x_3`, and
+        contains five clauses.  The five clauses, listed afterwards, are implicitly joined by the
+        logical `AND` operator, :math:`\land`, while the variables in each clause, represented by
+        their indices, are implicitly disjoined by the logical `OR` operator, :math:`\lor`. The
+        :math:`-` symbol preceding a boolean variable index corresponds to the logical `NOT`
+        operator, :math:`\lnot`. Character `0` (zero) marks the end of each clause.  Essentially,
+        the code above corresponds to the following CNF:
+
+        :math:`(\lnot x_1 \lor \lnot x_2 \lor \lnot x_3)
+        \land (x_1 \lor \lnot x_2 \lor x_3)
+        \land (x_1 \lor x_2 \lor \lnot x_3)
+        \land (x_1 \lor \lnot x_2 \lor \lnot x_3)
+        \land (\lnot x_1 \lor x_2 \lor x_3)`.
+
+
+        Args:
+            filename: A file in DIMACS format.
+
+        Returns:
+            PhaseOracleGate: A quantum circuit with a phase oracle.
+        """
         expr = BooleanExpression.from_dimacs_file(filename)
         return cls(expr)

qiskit/circuit/library/standard_gates/__init__.py

@@ -43,7 +43,6 @@ from .x import MCXGate, MCXGrayCode, MCXRecursive, MCXVChain
 from .y import YGate, CYGate
 from .z import ZGate, CZGate, CCZGate
 from .global_phase import GlobalPhaseGate
-from .multi_control_rotation_gates import mcrx, mcry, mcrz
 
 
 def get_standard_gate_name_mapping():

qiskit/circuit/library/standard_gates/dcx.py

@@ -13,7 +13,6 @@
 """Double-CNOT gate."""
 
 from qiskit.circuit.singleton import SingletonGate, stdlib_singleton_key
-from qiskit.circuit.quantumregister import QuantumRegister
 from qiskit.circuit._utils import with_gate_array
 from qiskit._accelerate.circuit import StandardGate
 
@@ -52,9 +51,9 @@ class DCXGate(SingletonGate):
 
     _standard_gate = StandardGate.DCXGate
 
-    def __init__(self, label=None, *, duration=None, unit="dt"):
+    def __init__(self, label=None):
         """Create new DCX gate."""
-        super().__init__("dcx", 2, [], label=label, duration=duration, unit=unit)
+        super().__init__("dcx", 2, [], label=label)
 
     _singleton_lookup_key = stdlib_singleton_key()
 
@@ -63,7 +62,7 @@ class DCXGate(SingletonGate):
         gate dcx a, b { cx a, b; cx b, a; }
         """
         # pylint: disable=cyclic-import
-        from qiskit.circuit.quantumcircuit import QuantumCircuit
+        from qiskit.circuit import QuantumCircuit, QuantumRegister
         from .x import CXGate
 
         q = QuantumRegister(2, "q")

qiskit/circuit/library/standard_gates/ecr.py

@@ -15,7 +15,6 @@ from math import sqrt
 import numpy as np
 
 from qiskit.circuit._utils import with_gate_array
-from qiskit.circuit.quantumregister import QuantumRegister
 from qiskit.circuit.singleton import SingletonGate, stdlib_singleton_key
 from qiskit._accelerate.circuit import StandardGate
 from .rzx import RZXGate
@@ -87,9 +86,9 @@ class ECRGate(SingletonGate):
 
     _standard_gate = StandardGate.ECRGate
 
-    def __init__(self, label=None, *, duration=None, unit="dt"):
+    def __init__(self, label=None):
         """Create new ECR gate."""
-        super().__init__("ecr", 2, [], label=label, duration=duration, unit=unit)
+        super().__init__("ecr", 2, [], label=label)
 
     _singleton_lookup_key = stdlib_singleton_key()
 
@@ -98,7 +97,7 @@ class ECRGate(SingletonGate):
         gate ecr a, b { rzx(pi/4) a, b; x a; rzx(-pi/4) a, b;}
         """
         # pylint: disable=cyclic-import
-        from qiskit.circuit.quantumcircuit import QuantumCircuit
+        from qiskit.circuit import QuantumCircuit, QuantumRegister
 
         q = QuantumRegister(2, "q")
         qc = QuantumCircuit(q, name=self.name)

qiskit/circuit/library/standard_gates/global_phase.py

@@ -17,8 +17,6 @@ from typing import Optional
 import numpy
 
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
-from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.circuit.parameterexpression import ParameterValueType
 from qiskit._accelerate.circuit import StandardGate
 
@@ -39,17 +37,18 @@ class GlobalPhaseGate(Gate):
 
     _standard_gate = StandardGate.GlobalPhaseGate
 
-    def __init__(
-        self, phase: ParameterValueType, label: Optional[str] = None, *, duration=None, unit="dt"
-    ):
+    def __init__(self, phase: ParameterValueType, label: Optional[str] = None):
         """
         Args:
             phase: The value of phase it takes.
             label: An optional label for the gate.
         """
-        super().__init__("global_phase", 0, [phase], label=label, duration=duration, unit=unit)
+        super().__init__("global_phase", 0, [phase], label=label)
 
     def _define(self):
+        # pylint: disable=cyclic-import
+        from qiskit.circuit import QuantumCircuit, QuantumRegister
+
         q = QuantumRegister(0, "q")
         qc = QuantumCircuit(q, name=self.name, global_phase=self.params[0])
 

qiskit/circuit/library/standard_gates/h.py

@@ -18,7 +18,6 @@ from math import sqrt, pi
 from typing import Optional, Union
 import numpy
 from qiskit.circuit.singleton import SingletonGate, SingletonControlledGate, stdlib_singleton_key
-from qiskit.circuit.quantumregister import QuantumRegister
 from qiskit.circuit._utils import with_gate_array, with_controlled_gate_array
 from qiskit._accelerate.circuit import StandardGate
 
@@ -57,9 +56,9 @@ class HGate(SingletonGate):
 
     _standard_gate = StandardGate.HGate
 
-    def __init__(self, label: Optional[str] = None, *, duration=None, unit="dt"):
+    def __init__(self, label: Optional[str] = None):
         """Create new H gate."""
-        super().__init__("h", 1, [], label=label, duration=duration, unit=unit)
+        super().__init__("h", 1, [], label=label)
 
     _singleton_lookup_key = stdlib_singleton_key()
 
@@ -68,7 +67,7 @@ class HGate(SingletonGate):
         gate h a { u2(0,pi) a; }
         """
         # pylint: disable=cyclic-import
-        from qiskit.circuit.quantumcircuit import QuantumCircuit
+        from qiskit.circuit import QuantumCircuit, QuantumRegister
         from .u2 import U2Gate
 
         q = QuantumRegister(1, "q")
@@ -196,8 +195,6 @@ class CHGate(SingletonControlledGate):
         label: Optional[str] = None,
         ctrl_state: Optional[Union[int, str]] = None,
         *,
-        duration=None,
-        unit="dt",
         _base_label=None,
     ):
         """Create new CH gate."""
@@ -209,8 +206,6 @@ class CHGate(SingletonControlledGate):
             label=label,
             ctrl_state=ctrl_state,
             base_gate=HGate(label=_base_label),
-            duration=duration,
-            unit=unit,
             _base_label=_base_label,
         )
 
@@ -229,7 +224,7 @@ class CHGate(SingletonControlledGate):
         }
         """
         # pylint: disable=cyclic-import
-        from qiskit.circuit.quantumcircuit import QuantumCircuit
+        from qiskit.circuit import QuantumCircuit, QuantumRegister
         from .x import CXGate  # pylint: disable=cyclic-import
         from .t import TGate, TdgGate
         from .s import SGate, SdgGate

qiskit/circuit/library/standard_gates/i.py

@@ -49,9 +49,9 @@ class IGate(SingletonGate):
 
     _standard_gate = StandardGate.IGate
 
-    def __init__(self, label: Optional[str] = None, *, duration=None, unit="dt"):
+    def __init__(self, label: Optional[str] = None):
         """Create new Identity gate."""
-        super().__init__("id", 1, [], label=label, duration=duration, unit=unit)
+        super().__init__("id", 1, [], label=label)
 
     _singleton_lookup_key = stdlib_singleton_key()
 

qiskit/circuit/library/standard_gates/iswap.py

@@ -17,7 +17,6 @@ from typing import Optional
 import numpy as np
 
 from qiskit.circuit.singleton import SingletonGate, stdlib_singleton_key
-from qiskit.circuit.quantumregister import QuantumRegister
 from qiskit.circuit._utils import with_gate_array
 from qiskit._accelerate.circuit import StandardGate
 
@@ -88,9 +87,9 @@ class iSwapGate(SingletonGate):
 
     _standard_gate = StandardGate.ISwapGate
 
-    def __init__(self, label: Optional[str] = None, *, duration=None, unit="dt"):
+    def __init__(self, label: Optional[str] = None):
         """Create new iSwap gate."""
-        super().__init__("iswap", 2, [], label=label, duration=duration, unit=unit)
+        super().__init__("iswap", 2, [], label=label)
 
     _singleton_lookup_key = stdlib_singleton_key()
 
@@ -106,7 +105,7 @@ class iSwapGate(SingletonGate):
         }
         """
         # pylint: disable=cyclic-import
-        from qiskit.circuit.quantumcircuit import QuantumCircuit
+        from qiskit.circuit import QuantumCircuit, QuantumRegister
 
         from .h import HGate
         from .s import SGate

qiskit/circuit/library/standard_gates/p.py

@@ -17,7 +17,6 @@ from cmath import exp
 import numpy
 from qiskit.circuit.controlledgate import ControlledGate
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
 from qiskit.circuit.parameterexpression import ParameterValueType
 from qiskit._accelerate.circuit import StandardGate
 
@@ -78,15 +77,13 @@ class PhaseGate(Gate):
 
     _standard_gate = StandardGate.PhaseGate
 
-    def __init__(
-        self, theta: ParameterValueType, label: str | None = None, *, duration=None, unit="dt"
-    ):
+    def __init__(self, theta: ParameterValueType, label: str | None = None):
         """Create new Phase gate."""
-        super().__init__("p", 1, [theta], label=label, duration=duration, unit=unit)
+        super().__init__("p", 1, [theta], label=label)
 
     def _define(self):
         # pylint: disable=cyclic-import
-        from qiskit.circuit.quantumcircuit import QuantumCircuit
+        from qiskit.circuit import QuantumCircuit, QuantumRegister
         from .u import UGate
 
         q = QuantumRegister(1, "q")
@@ -208,8 +205,6 @@ class CPhaseGate(ControlledGate):
         label: str | None = None,
         ctrl_state: str | int | None = None,
         *,
-        duration=None,
-        unit="dt",
         _base_label=None,
     ):
         """Create new CPhase gate."""
@@ -221,8 +216,6 @@ class CPhaseGate(ControlledGate):
             label=label,
             ctrl_state=ctrl_state,
             base_gate=PhaseGate(theta, label=_base_label),
-            duration=duration,
-            unit=unit,
         )
 
     def _define(self):
@@ -234,7 +227,7 @@ class CPhaseGate(ControlledGate):
         }
         """
         # pylint: disable=cyclic-import
-        from qiskit.circuit.quantumcircuit import QuantumCircuit
+        from qiskit.circuit import QuantumCircuit, QuantumRegister
 
         #      ┌────────┐
         # q_0: ┤ P(λ/2) ├──■───────────────■────────────
@@ -342,8 +335,6 @@ class MCPhaseGate(ControlledGate):
         label: str | None = None,
         ctrl_state: str | int | None = None,
         *,
-        duration=None,
-        unit="dt",
         _base_label=None,
     ):
         """Create new MCPhase gate."""
@@ -355,13 +346,11 @@ class MCPhaseGate(ControlledGate):
             label=label,
             ctrl_state=ctrl_state,
             base_gate=PhaseGate(lam, label=_base_label),
-            duration=duration,
-            unit=unit,
         )
 
     def _define(self):
         # pylint: disable=cyclic-import
-        from qiskit.circuit.quantumcircuit import QuantumCircuit
+        from qiskit.circuit import QuantumCircuit, QuantumRegister
 
         qr = QuantumRegister(self.num_qubits, "q")
         qc = QuantumCircuit(qr, name=self.name)
@@ -372,24 +361,16 @@ class MCPhaseGate(ControlledGate):
             qc.cp(self.params[0], 0, 1)
         else:
             lam = self.params[0]
-            if type(lam) in [float, int]:
-                q_controls = list(range(self.num_ctrl_qubits))
-                q_target = self.num_ctrl_qubits
-                new_target = q_target
-                for k in range(self.num_ctrl_qubits):
-                    # Note: it's better *not* to run transpile recursively
-                    qc.mcrz(lam / (2**k), q_controls, new_target, use_basis_gates=False)
-                    new_target = q_controls.pop()
-                qc.p(lam / (2**self.num_ctrl_qubits), new_target)
-            else:  # in this case type(lam) is ParameterValueType
-                from .u3 import _gray_code_chain
-
-                scaled_lam = self.params[0] / (2 ** (self.num_ctrl_qubits - 1))
-                bottom_gate = CPhaseGate(scaled_lam)
-                for operation, qubits, clbits in _gray_code_chain(
-                    qr, self.num_ctrl_qubits, bottom_gate
-                ):
-                    qc._append(operation, qubits, clbits)
+
+            q_controls = list(range(self.num_ctrl_qubits))
+            q_target = self.num_ctrl_qubits
+            new_target = q_target
+            for k in range(self.num_ctrl_qubits):
+                # Note: it's better *not* to run transpile recursively
+                qc.mcrz(lam / (2**k), q_controls, new_target, use_basis_gates=False)
+                new_target = q_controls.pop()
+            qc.p(lam / (2**self.num_ctrl_qubits), new_target)
+
         self.definition = qc
 
     def control(

qiskit/circuit/library/standard_gates/r.py

@@ -18,7 +18,6 @@ from math import pi
 from typing import Optional
 import numpy
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
 from qiskit.circuit.parameterexpression import ParameterValueType
 from qiskit._accelerate.circuit import StandardGate
 
@@ -33,9 +32,10 @@ class RGate(Gate):
 
     .. code-block:: text
 
-             ┌──────┐
-        q_0: ┤ R(ϴ) ├
-             └──────┘
+               ┌─────────┐
+        q_0:   ┤ R(θ,ϕ)  ├ 
+               └─────────┘
+
 
     **Matrix Representation:**
 
@@ -57,19 +57,16 @@ class RGate(Gate):
         theta: ParameterValueType,
         phi: ParameterValueType,
         label: Optional[str] = None,
-        *,
-        duration=None,
-        unit="dt",
     ):
         """Create new r single-qubit gate."""
-        super().__init__("r", 1, [theta, phi], label=label, duration=duration, unit=unit)
+        super().__init__("r", 1, [theta, phi], label=label)
 
     def _define(self):
         """
         gate r(θ, φ) a {u3(θ, φ - π/2, -φ + π/2) a;}
         """
         # pylint: disable=cyclic-import
-        from qiskit.circuit.quantumcircuit import QuantumCircuit
+        from qiskit.circuit import QuantumCircuit, QuantumRegister
         from .u3 import U3Gate
 
         q = QuantumRegister(1, "q")
@@ -83,7 +80,7 @@ class RGate(Gate):
         self.definition = qc
 
     def inverse(self, annotated: bool = False):
-        """Invert this gate as: :math:`r(θ, φ)^dagger = r(-θ, φ)`
+        r"""Invert this gate as: :math:`R(θ, φ)^{\dagger} = R(-θ, φ)`
 
         Args:
             annotated: when set to ``True``, this is typically used to return an

qiskit/circuit/library/standard_gates/rx.py

@@ -21,8 +21,7 @@ import numpy
 
 from qiskit.circuit.controlledgate import ControlledGate
 from qiskit.circuit.gate import Gate
-from qiskit.circuit.quantumregister import QuantumRegister
-from qiskit.circuit.parameterexpression import ParameterValueType, ParameterExpression
+from qiskit.circuit.parameterexpression import ParameterValueType
 from qiskit._accelerate.circuit import StandardGate
 
 
@@ -55,18 +54,16 @@ class RXGate(Gate):
 
     _standard_gate = StandardGate.RXGate
 
-    def __init__(
-        self, theta: ParameterValueType, label: Optional[str] = None, *, duration=None, unit="dt"
-    ):
+    def __init__(self, theta: ParameterValueType, label: Optional[str] = None):
         """Create new RX gate."""
-        super().__init__("rx", 1, [theta], label=label, duration=duration, unit=unit)
+        super().__init__("rx", 1, [theta], label=label)
 
     def _define(self):
         """
         gate rx(theta) a {r(theta, 0) a;}
         """
         # pylint: disable=cyclic-import
-        from qiskit.circuit.quantumcircuit import QuantumCircuit
+        from qiskit.circuit import QuantumCircuit, QuantumRegister
         from .r import RGate
 
         q = QuantumRegister(1, "q")
@@ -104,11 +101,6 @@ class RXGate(Gate):
             gate = CRXGate(self.params[0], label=label, ctrl_state=ctrl_state)
             gate.base_gate.label = self.label
         else:
-            # If the gate parameters contain free parameters, we cannot eagerly synthesize
-            # the controlled gate decomposition. In this case, we annotate the gate per default.
-            if annotated is None:
-                annotated = any(isinstance(p, ParameterExpression) for p in self.params)
-
             gate = super().control(
                 num_ctrl_qubits=num_ctrl_qubits,
                 label=label,
@@ -218,8 +210,6 @@ class CRXGate(ControlledGate):
         label: Optional[str] = None,
         ctrl_state: Optional[Union[str, int]] = None,
         *,
-        duration=None,
-        unit="dt",
         _base_label=None,
     ):
         """Create new CRX gate."""
@@ -244,7 +234,7 @@ class CRXGate(ControlledGate):
         }
         """
         # pylint: disable=cyclic-import
-        from qiskit.circuit.quantumcircuit import QuantumCircuit
+        from qiskit.circuit import QuantumCircuit, QuantumRegister
         from .u1 import U1Gate
         from .u3 import U3Gate
         from .x import CXGate