Remove dependance of BooleanExpression on tweedledum (Qiskit#13769)

* Remove dependance of BooleanExpression on tweedledum

* Small fix for `BooleanExpression`: it still should inherit from `Gate`

* Additional tests

* Doc fixes and release notes

* Refactoring; new boolean expression code moved to synthesis, old code restored.

* Add tests for bit-flip oracle and bugfix for bit-flip oracle synthesis

* Small fixes according to PR

* Added a rudimentary truth table implementation to enable working implicitly with large number of bits

* Bug fix related to truth table generation

* Fixes according to PR review

* Fixes according to PR review

* Change BitFlipOracle to BitFlipOracleGate

* Added PhaseOracleGate

* Changes according to PR review

Author: gadial

qiskit/circuit/library/__init__.py

@@ -345,6 +345,8 @@
    QuantumVolume
    PhaseEstimation
    GroverOperator
+   BitFlipOracleGate
+   PhaseOracleGate
    PhaseOracle
    PauliEvolutionGate
    HamiltonianGate
@@ -670,6 +672,7 @@
 from .iqp import IQP, iqp, random_iqp
 from .phase_estimation import PhaseEstimation, phase_estimation
 from .grover_operator import GroverOperator, grover_operator
-from .phase_oracle import PhaseOracle
+from .phase_oracle import PhaseOracle, PhaseOracleGate
+from .bit_flip_oracle import BitFlipOracleGate
 from .overlap import UnitaryOverlap, unitary_overlap
 from .standard_gates import get_standard_gate_name_mapping

qiskit/circuit/library/bit_flip_oracle.py

@@ -0,0 +1,130 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2025.
+#
+# 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.
+
+"""Bit-flip Oracle object."""
+
+from __future__ import annotations
+
+from qiskit.circuit import Gate
+
+from qiskit.synthesis.boolean.boolean_expression import BooleanExpression
+
+
+class BitFlipOracleGate(Gate):
+    r"""Implements a bit-flip oracle
+
+    The Bit-flip 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 bit-flip oracle for a boolean function `f(x)` performs the following
+    quantum operation:
+
+    .. math::
+
+            |x\rangle|y\rangle \mapsto |x\rangle|f(x)\oplus y\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.bit_flip_oracle.BitFlipOracleGate.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="Bit-flip Oracle",
+            num_qubits=self.boolean_expression.num_bits + 1,
+            params=[],
+            label=label,
+        )
+
+    def _define(self):
+        """Defined by the synthesized bit-flip oracle"""
+        self.definition = self.boolean_expression.synth(circuit_type="bit")
+
+    @classmethod
+    def from_dimacs_file(cls, filename: str) -> BitFlipOracleGate:
+        r"""Create a BitFlipOracleGate from the string in the DIMACS format.
+
+        It is possible to build a BitFlipOracleGate 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:
+            BitFlipOracleGate: A quantum gate with a bit-flip oracle.
+        """
+        expr = BooleanExpression.from_dimacs_file(filename)
+        return cls(expr)

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,40 +51,17 @@ 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)
         """
-        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
-
-                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)
-
-        oracle = expression.synth(synthesizer=synthesizer)
+        self.boolean_expression = BooleanExpression(expression, var_order=var_order)
+        oracle = self.boolean_expression.synth(circuit_type="phase")
 
         super().__init__(oracle.num_qubits, name="Phase Oracle")
 
@@ -107,7 +85,7 @@ def from_dimacs_file(cls, filename: str):
         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
@@ -147,7 +125,115 @@ def from_dimacs_file(cls, filename: str):
         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/synthesis/boolean/__init__.py

@@ -0,0 +1,13 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2025.
+#
+# 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.
+
+"""Module containing boolean expression synthesis."""