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

qiskit/circuit/library/generalized_gates/uc.py

@@ -28,13 +28,13 @@ import numpy as np
 from qiskit.circuit.gate import Gate
 from qiskit.circuit.library.standard_gates.h import HGate
 from qiskit.quantum_info.operators.predicates import is_unitary_matrix
-from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit import QuantumRegister
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.circuit.exceptions import CircuitError
 from qiskit.exceptions import QiskitError
 from qiskit._accelerate import uc_gate
 
-from .diagonal import Diagonal
+from .diagonal import DiagonalGate
 
 _EPS = 1e-10  # global variable used to chop very small numbers to zero
 
@@ -60,14 +60,21 @@ class UCGate(Gate):
 
     The decomposition is based on Ref. [1].
 
+    Unnecessary controls and repeated operators can be removed as described in Ref [2].
+
     **References:**
 
     [1] Bergholm et al., Quantum circuits with uniformly controlled one-qubit gates (2005).
         `Phys. Rev. A 71, 052330 <https://journals.aps.org/pra/abstract/10.1103/PhysRevA.71.052330>`__.
 
+    [2] de Carvalho et al., Quantum multiplexer simplification for state preparation (2024).
+        `arXiv:2409.05618 <https://arxiv.org/abs/2409.05618>`__.
+
     """
 
-    def __init__(self, gate_list: list[np.ndarray], up_to_diagonal: bool = False):
+    def __init__(
+        self, gate_list: list[np.ndarray], up_to_diagonal: bool = False, mux_simp: bool = True
+    ):
         r"""
         Args:
             gate_list: List of two qubit unitaries :math:`[U_0, ..., U_{2^{k-1}}]`, where each
@@ -76,6 +83,9 @@ class UCGate(Gate):
                 or if it is decomposed completely (default: False).
                 If the ``UCGate`` :math:`U` is decomposed up to a diagonal :math:`D`, this means
                 that the circuit implements a unitary :math:`U'` such that :math:`D U' = U`.
+            mux_simp: Determines whether the search for repetitions is conducted (default: True).
+                The intention is to perform a possible simplification in the number of controls
+                and operators.
 
         Raises:
             QiskitError: in case of bad input to the constructor
@@ -101,10 +111,67 @@ class UCGate(Gate):
             if not is_unitary_matrix(gate, _EPS):
                 raise QiskitError("A controlled gate is not unitary.")
 
+        new_controls = set()
+        if mux_simp:
+            new_controls, gate_list = self._simplify(gate_list, num_contr)
+        self.simp_contr = (mux_simp, new_controls)
+
         # Create new gate.
         super().__init__("multiplexer", int(num_contr) + 1, gate_list)
         self.up_to_diagonal = up_to_diagonal
 
+    def _simplify(self, gate_list, num_contr):
+        """https://arxiv.org/abs/2409.05618"""
+
+        c = set()
+        nc = set()
+        mux_copy = gate_list.copy()
+
+        for i in range(int(num_contr)):
+            c.add(i + 1)
+
+        if len(gate_list) > 1:
+            nc, mux_copy = self._repetition_search(gate_list, num_contr, mux_copy)
+
+        new_controls = {x for x in c if x not in nc}
+        new_mux = [gate for gate in mux_copy if gate is not None]
+        return new_controls, new_mux
+
+    def _repetition_search(self, mux, level, mux_copy):
+        nc = set()
+        d = 1
+        while d <= len(mux) / 2:
+            disentanglement = False
+            if np.allclose(mux[d], mux[0]):
+                mux_org = mux_copy.copy()
+                repetitions = len(mux) / (2 * d)
+                p = 0
+                while repetitions > 0:
+                    repetitions -= 1
+                    valid, mux_copy = self._repetition_verify(p, d, mux, mux_copy)
+                    p = p + 2 * d
+                    if not valid:
+                        mux_copy = mux_org
+                        break
+                    if repetitions == 0:
+                        disentanglement = True
+
+            if disentanglement:
+                removed_contr = level - math.log2(d)
+                nc.add(removed_contr)
+            d = 2 * d
+        return nc, mux_copy
+
+    def _repetition_verify(self, base, d, mux, mux_copy):
+        i = 0
+        next_base = base + d
+        while i < d:
+            if not np.allclose(mux[base], mux[next_base]):
+                return False, mux_copy
+            mux_copy[next_base] = None
+            base, next_base, i = base + 1, next_base + 1, i + 1
+        return True, mux_copy
+
     def inverse(self, annotated: bool = False) -> Gate:
         """Return the inverse.
 
@@ -135,6 +202,19 @@ class UCGate(Gate):
         # q[k-1],...,q[0],q_target, decreasingly ordered with respect to the
         # significance of the qubit in the computational basis
         _, diag = self._dec_ucg()
+        if self.simp_contr[1]:
+            q_controls = [self.num_qubits - i for i in self.simp_contr[1]]
+            q_controls.reverse()
+            for i in range(self.num_qubits):
+                if i not in [0] + q_controls:
+                    d = 2**i
+                    new_diag = []
+                    n = len(diag)
+                    for j in range(n):
+                        new_diag.append(diag[j])
+                        if (j + 1) % d == 0:
+                            new_diag.extend(diag[j + 1 - d : j + 1])
+                    diag = np.array(new_diag)
         return diag
 
     def _define(self):
@@ -149,12 +229,19 @@ class UCGate(Gate):
         """
         diag = np.ones(2**self.num_qubits).tolist()
         q = QuantumRegister(self.num_qubits, "q")
-        q_controls = q[1:]
         q_target = q[0]
+        mux_simplify = self.simp_contr[0]
+
+        if mux_simplify:
+            q_controls = [q[self.num_qubits - i] for i in self.simp_contr[1]]
+            q_controls.reverse()
+        else:
+            q_controls = q[1:]
+
         circuit = QuantumCircuit(q, name="uc")
         # If there is no control, we use the ZYZ decomposition
         if not q_controls:
-            circuit.unitary(self.params[0], [q])
+            circuit.unitary(self.params[0], q[0])
             return circuit, diag
         # If there is at least one control, first,
         # we find the single qubit gates of the decomposition.
@@ -189,8 +276,9 @@ class UCGate(Gate):
             # Important: the diagonal gate is given in the computational basis of the qubits
             # q[k-1],...,q[0],q_target (ordered with decreasing significance),
             # where q[i] are the control qubits and t denotes the target qubit.
-            diagonal = Diagonal(diag)
-            circuit.append(diagonal, q)
+            diagonal = DiagonalGate(diag)
+
+            circuit.append(diagonal, [q_target] + q_controls)
         return circuit, diag
 
     def _dec_ucg_help(self):
@@ -199,6 +287,8 @@ class UCGate(Gate):
         https://arxiv.org/pdf/quant-ph/0410066.pdf.
         """
         single_qubit_gates = [gate.astype(complex) for gate in self.params]
+        if self.simp_contr[0]:
+            return uc_gate.dec_ucg_help(single_qubit_gates, len(self.simp_contr[1]) + 1)
         return uc_gate.dec_ucg_help(single_qubit_gates, self.num_qubits)
 
     @staticmethod

qiskit/circuit/library/generalized_gates/uc_pauli_rot.py

@@ -23,7 +23,7 @@ import numpy as np
 
 from qiskit.circuit.gate import Gate
 from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit import QuantumRegister
 from qiskit.exceptions import QiskitError
 
 _EPS = 1e-10  # global variable used to chop very small numbers to zero

qiskit/circuit/library/generalized_gates/unitary.py

@@ -23,7 +23,7 @@ from qiskit.circuit.gate import Gate
 from qiskit.circuit.controlledgate import ControlledGate
 from qiskit.circuit.annotated_operation import AnnotatedOperation, ControlModifier
 from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit import QuantumRegister
 from qiskit.circuit.exceptions import CircuitError
 from qiskit.circuit._utils import _compute_control_matrix
 from qiskit.circuit.library.standard_gates.u import UGate
@@ -45,7 +45,9 @@ class UnitaryGate(Gate):
         quantum circuit. The matrix can also be directly applied to the quantum
         circuit, see :meth:`.QuantumCircuit.unitary`.
 
-        .. code-block:: python
+        .. plot::
+           :include-source:
+           :nofigs:
 
             from qiskit import QuantumCircuit
             from qiskit.circuit.library import UnitaryGate

qiskit/circuit/library/hamiltonian_gate.py

@@ -24,7 +24,7 @@ import numpy as np
 from qiskit import _numpy_compat
 from qiskit.circuit.gate import Gate
 from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit import QuantumRegister
 from qiskit.circuit.parameterexpression import ParameterExpression
 from qiskit.circuit.exceptions import CircuitError
 from qiskit.quantum_info.operators.predicates import matrix_equal

qiskit/circuit/library/n_local/evolved_operator_ansatz.py

@@ -23,7 +23,7 @@ import numpy as np
 from qiskit.circuit.library.pauli_evolution import PauliEvolutionGate
 from qiskit.circuit.parameter import Parameter
 from qiskit.circuit.parametervector import ParameterVector
-from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit import QuantumRegister
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.quantum_info import Operator, Pauli, SparsePauliOp
 from qiskit.quantum_info.operators.base_operator import BaseOperator

qiskit/circuit/library/n_local/n_local.py

@@ -23,7 +23,7 @@ import numpy
 from qiskit.circuit.gate import Gate
 from qiskit.circuit.quantumcircuit import QuantumCircuit, ParameterValueType
 from qiskit.circuit.parametervector import ParameterVector, ParameterVectorElement
-from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit import QuantumRegister
 from qiskit.circuit import (
     Instruction,
     Parameter,

qiskit/circuit/library/n_local/qaoa_ansatz.py

@@ -19,7 +19,7 @@ import numpy as np
 
 from qiskit.circuit.parametervector import ParameterVector
 from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit import QuantumRegister
 from qiskit.quantum_info import SparsePauliOp
 from qiskit.quantum_info.operators.base_operator import BaseOperator
 

qiskit/circuit/library/overlap.py

@@ -132,10 +132,10 @@ def unitary_overlap(
         :include-source:
 
         import numpy as np
-        from qiskit.circuit.library import EfficientSU2, unitary_overlap
+        from qiskit.circuit.library import efficient_su2, unitary_overlap
 
         # get two circuit to prepare states of which we compute the overlap
-        circuit = EfficientSU2(2, reps=1)
+        circuit = efficient_su2(2, reps=1)
         unitary1 = circuit.assign_parameters(np.random.random(circuit.num_parameters))
         unitary2 = circuit.assign_parameters(np.random.random(circuit.num_parameters))
 

qiskit/circuit/library/pauli_evolution.py

@@ -20,7 +20,7 @@ import numpy as np
 from qiskit.circuit.gate import Gate
 from qiskit.circuit.quantumcircuit import ParameterValueType
 from qiskit.circuit.parameterexpression import ParameterExpression
-from qiskit.quantum_info import Pauli, SparsePauliOp
+from qiskit.quantum_info import Pauli, SparsePauliOp, SparseObservable
 
 if TYPE_CHECKING:
     from qiskit.synthesis.evolution import EvolutionSynthesis
@@ -49,7 +49,9 @@ class PauliEvolutionGate(Gate):
 
     **Examples:**
 
-    .. code-block:: python
+    .. plot::
+       :include-source:
+       :nofigs:
 
         from qiskit.circuit import QuantumCircuit
         from qiskit.circuit.library import PauliEvolutionGate
@@ -68,7 +70,9 @@ class PauliEvolutionGate(Gate):
         circuit.append(evo, range(2))
         print(circuit.draw())
 
-    The above will print (note that the ``-0.1`` coefficient is not printed!)::
+    The above will print (note that the ``-0.1`` coefficient is not printed!):
+
+    .. code-block:: text
 
              ┌──────────────────────────┐
         q_0: ┤0                         ├
@@ -86,15 +90,19 @@ class PauliEvolutionGate(Gate):
 
     def __init__(
         self,
-        operator: Pauli | SparsePauliOp | list[Pauli | SparsePauliOp],
+        operator: (
+            Pauli
+            | SparsePauliOp
+            | SparseObservable
+            | list[Pauli | SparsePauliOp | SparseObservable]
+        ),
         time: ParameterValueType = 1.0,
         label: str | None = None,
         synthesis: EvolutionSynthesis | None = None,
     ) -> None:
         """
         Args:
-            operator (Pauli | SparsePauliOp | list):
-                The operator to evolve. Can also be provided as list of non-commuting
+            operator: The operator to evolve. Can also be provided as list of non-commuting
                 operators where the elements are sums of commuting operators.
                 For example: ``[XY + YX, ZZ + ZI + IZ, YY]``.
             time: The evolution time.
@@ -106,9 +114,9 @@ class PauliEvolutionGate(Gate):
                 product formula with a single repetition.
         """
         if isinstance(operator, list):
-            operator = [_to_sparse_pauli_op(op) for op in operator]
+            operator = [_to_sparse_op(op) for op in operator]
         else:
-            operator = _to_sparse_pauli_op(operator)
+            operator = _to_sparse_op(operator)
 
         if label is None:
             label = _get_default_label(operator)
@@ -155,32 +163,39 @@ class PauliEvolutionGate(Gate):
         return super().validate_parameter(parameter)
 
 
-def _to_sparse_pauli_op(operator):
+def _to_sparse_op(
+    operator: Pauli | SparsePauliOp | SparseObservable,
+) -> SparsePauliOp | SparseObservable:
     """Cast the operator to a SparsePauliOp."""
 
     if isinstance(operator, Pauli):
-        sparse_pauli = SparsePauliOp(operator)
-    elif isinstance(operator, SparsePauliOp):
-        sparse_pauli = operator
+        sparse = SparsePauliOp(operator)
+    elif isinstance(operator, (SparseObservable, SparsePauliOp)):
+        sparse = operator
     else:
         raise ValueError(f"Unsupported operator type for evolution: {type(operator)}.")
 
-    if any(np.iscomplex(sparse_pauli.coeffs)):
+    if any(np.iscomplex(sparse.coeffs)):
         raise ValueError("Operator contains complex coefficients, which are not supported.")
-    if any(isinstance(coeff, ParameterExpression) for coeff in sparse_pauli.coeffs):
+    if any(isinstance(coeff, ParameterExpression) for coeff in sparse.coeffs):
         raise ValueError("Operator contains ParameterExpression, which are not supported.")
 
-    return sparse_pauli
+    return sparse
+
+
+def _operator_label(operator):
+    if isinstance(operator, SparseObservable):
+        if len(operator) == 1:
+            return operator[0].bit_labels()[::-1]
+        return "(" + " + ".join(term.bit_labels()[::-1] for term in operator) + ")"
+
+    # else: is a SparsePauliOp
+    if len(operator.paulis) == 1:
+        return operator.paulis.to_labels()[0]
+    return "(" + " + ".join(operator.paulis.to_labels()) + ")"
 
 
 def _get_default_label(operator):
     if isinstance(operator, list):
-        label = f"exp(-it ({[' + '.join(op.paulis.to_labels()) for op in operator]}))"
-    else:
-        if len(operator.paulis) == 1:
-            label = f"exp(-it {operator.paulis.to_labels()[0]})"
-        # for just a single Pauli don't add brackets around the sum
-        else:
-            label = f"exp(-it ({' + '.join(operator.paulis.to_labels())}))"
-
-    return label
+        return f"exp(-it ({[_operator_label(op) for op in operator]}))"
+    return f"exp(-it {_operator_label(operator)})"

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")