qiskit 2.1.0rc1__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/synthesis/boolean/boolean_expression.py

@@ -0,0 +1,231 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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.
+
+"""A class for parsing and synthesizing boolean expressions"""
+
+import ast
+import itertools
+import re
+from os.path import isfile
+from typing import Union, Callable
+import numpy as np
+
+from .boolean_expression_visitor import (
+    BooleanExpressionEvalVisitor,
+    BooleanExpressionArgsCollectorVisitor,
+)
+
+
+class TruthTable:
+    """A simple implementation of a truth table for a boolean function
+
+    The truth table is built from a callable which takes an assignment, which
+    is a tuple of boolean values of a fixed given length (the number of bits
+    of the truth table) and returns a boolean value.
+
+    For a number of bits at most `EXPLICIT_REP_THRESHOLD` the values of the table
+    are explicitly computed and stored. Otherwise, the values are computed on the fly
+    and stored in a dictionary."""
+
+    EXPLICIT_REP_THRESHOLD = (
+        12  # above this number of bits, do not explicitly save the values in a list
+    )
+
+    def __init__(self, func: Callable, num_bits: int):
+        self.func = func
+        self.num_bits = num_bits
+        self.explicit_storage = self.num_bits <= self.EXPLICIT_REP_THRESHOLD
+        if self.explicit_storage:
+            self.values = np.array(
+                [self.func(assignment) for assignment in self.all_assignments()],
+                dtype=bool,
+            )
+        else:
+            self.implicit_values = {}
+
+    def all_assignments(self) -> list[tuple[bool]]:
+        """Return an ordered list of all assignments, ordered from right to left
+        i.e. 000, 100, 010, 110, 001, 101, 011, 111"""
+        return [
+            tuple(reversed(assignment))
+            for assignment in itertools.product([False, True], repeat=self.num_bits)
+        ]
+
+    def __getitem__(self, key: Union[str, tuple[bool]]) -> bool:
+        if isinstance(key, str):
+            key = (bit != "0" for bit in key)
+        if self.explicit_storage:
+            key = sum(2**n for n, bit in enumerate(key) if bit)
+            return self.values[key]
+        else:
+            return self.implicit_values.setdefault(key, self.func(key))
+
+    def __str__(self) -> str:
+        if self.explicit_storage:
+            return "".join(
+                "1" if self[assignemnt] else "0" for assignemnt in self.all_assignments()
+            )
+        else:
+            return f"Truth table on {self.num_bits} bits (implicit representation)"
+
+
+class BooleanExpression:
+    """A Boolean Expression"""
+
+    def __init__(self, expression: str, var_order: list = None) -> None:
+        """
+        Args:
+            expression (str): The logical expression string.
+            name (str): Optional. Instruction gate name. Otherwise part of the expression is
+               going to be used.
+            var_order(list): A list with the order in which variables will be created.
+               (default: by appearance)
+        """
+        self.expression = expression
+        self.expression_ast = ast.parse(expression)
+        args_collector = BooleanExpressionArgsCollectorVisitor()
+        args_collector.visit(self.expression_ast)
+        self.args = args_collector.get_sorted_args()
+        self.num_bits = len(self.args)
+        if var_order is not None:
+            missing_args = set(self.args) - set(var_order)
+            if len(missing_args) > 0:
+                raise ValueError(f"var_order missing the variable(s) {', '.join(missing_args)}")
+            self.args.sort(key=var_order.index)
+        self.truth_table_ = None
+
+    def simulate(self, bitstring: Union[str, tuple]) -> bool:
+        """Evaluate the expression on a bitstring.
+
+        This evaluation is done classically.
+
+        Args:
+            bitstring: The bitstring for which to evaluate,
+            either as a string of 0 and 1 or a tuple of booleans.
+
+        Returns:
+            bool: result of the evaluation.
+        """
+        if self.num_bits != len(bitstring):
+            raise ValueError(
+                f"bitstring length differs from the number of variables "
+                f"({len(bitstring)} != {self.num_bits}"
+            )
+        if isinstance(bitstring, str):
+            bitstring = (bit != "0" for bit in bitstring)
+        eval_visitor = BooleanExpressionEvalVisitor()
+        eval_visitor.arg_values = dict(zip(self.args, bitstring))
+        return eval_visitor.visit(self.expression_ast)
+
+    @property
+    def truth_table(self) -> dict:
+        """Generates the full truth table for the expression
+        Returns:
+            dict: A dictionary mapping boolean assignments to the boolean result
+        """
+        if self.truth_table_ is None:
+            self.truth_table_ = TruthTable(self.simulate, self.num_bits)
+        return self.truth_table_
+
+    def synth(self, circuit_type: str = "bit"):
+        r"""Synthesize the logic network into a :class:`~qiskit.circuit.QuantumCircuit`.
+        There are two common types of circuits for a boolean function :math:`f(x)`:
+
+        1. **Bit-flip oracles** which compute:
+
+         .. math::
+
+            |x\rangle|y\rangle |-> |x\rangle|f(x)\oplusy\rangle
+
+        2. **Phase-flip** oracles which compute:
+
+         .. math::
+
+            |x\rangle |-> (-1)^{f(x)}|x\rangle
+
+        By default the bit-flip oracle is generated.
+
+        Args:
+            circuit_type: which type of oracle to create, 'bit' or 'phase' flip oracle.
+        Returns:
+            QuantumCircuit: A circuit implementing the logic network.
+        Raises:
+            ValueError: If ``circuit_type`` is not either 'bit' or 'phase'.
+        """
+        # pylint: disable=cyclic-import
+        from .boolean_expression_synth import (
+            synth_bit_oracle_from_esop,
+            synth_phase_oracle_from_esop,
+            EsopGenerator,
+        )  # import here to avoid cyclic import
+
+        # generating the esop currntly requires generating the full truth table
+        # there are many optimizations that can be done to improve this step
+        esop = EsopGenerator(self.truth_table).esop
+        if circuit_type == "bit":
+            return synth_bit_oracle_from_esop(esop, self.num_bits + 1)
+        if circuit_type == "phase":
+            return synth_phase_oracle_from_esop(esop, self.num_bits)
+        raise ValueError("'circuit_type' must be either 'bit' or 'phase'")
+
+    @staticmethod
+    def from_dimacs(dimacs: str):
+        """Create a BooleanExpression from a string in the DIMACS format.
+        Args:
+            dimacs : A string in DIMACS format.
+
+        Returns:
+            BooleanExpression: A gate for the input string
+
+        Raises:
+            ValueError: If the string is not formatted according to DIMACS rules
+        """
+        header_regex = re.compile(r"p\s+cnf\s+(\d+)\s+(\d+)")
+        clause_regex = re.compile(r"(-?\d+)")
+        lines = [
+            line for line in dimacs.split("\n") if not line.startswith("c") and line != ""
+        ]  # DIMACS comment line start with c
+        header_match = header_regex.match(lines[0])
+        if not header_match:
+            raise ValueError("First line must start with 'p cnf'")
+        num_vars, _ = map(int, header_match.groups())
+        variables = [f"x{i+1}" for i in range(num_vars)]
+        clauses = []
+        for line in lines[1:]:
+            literals = clause_regex.findall(line)
+            if len(literals) == 0 or literals[-1] != "0":
+                continue
+            clauses.append([int(c) for c in literals[:-1]])
+        clause_strings = [
+            " | ".join([f'{"~" if lit < 0 else ""}{variables[abs(lit)-1]}' for lit in clause])
+            for clause in clauses
+        ]
+        expr = " & ".join([f"({c})" for c in clause_strings])
+        return BooleanExpression(expr, var_order=variables)
+
+    @staticmethod
+    def from_dimacs_file(filename: str):
+        """Create a BooleanExpression from a file in the DIMACS format.
+        Args:
+            filename: A file in DIMACS format.
+
+        Returns:
+            BooleanExpression: A gate for the input string
+
+        Raises:
+            FileNotFoundError: If filename is not found.
+        """
+        if not isfile(filename):
+            raise FileNotFoundError(f"The file {filename} does not exists.")
+        with open(filename, "r") as dimacs_file:
+            dimacs = dimacs_file.read()
+        return BooleanExpression.from_dimacs(dimacs)

qiskit/synthesis/boolean/boolean_expression_synth.py

@@ -0,0 +1,124 @@
+# 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.
+"""Circuit synthesizers and related classes for boolean expressions"""
+
+import itertools
+from qiskit.circuit import QuantumCircuit
+from qiskit.circuit.library import ZGate, XGate
+
+
+class EsopGenerator:
+    """Generates an ESOP (Exlusive-sum-of-products) representation
+    for a boolean function given by its truth table"""
+
+    def __init__(self, truth_table):
+        self.truth_table = truth_table
+        self.cofactor_table = {}
+        self.esop = self.generate_esop(assignment=())
+
+    def clause_diff(self, clause1, clause2):
+        """The indices of variables where the clauses differ"""
+        return [i for i in range(len(clause1)) if clause1[i] != clause2[i]]
+
+    def combine_and_optimize(self, clauses_1, clauses_2):
+        """Combining clauses of distance 1 until no more combinations can be performed"""
+        something_changed = True
+        combined_clauses = clauses_1 + clauses_2
+        while something_changed:
+            something_changed = False
+            for clause_1, clause_2 in itertools.combinations(combined_clauses, 2):
+                diff = self.clause_diff(clause_1, clause_2)
+                if len(diff) == 1:
+                    new_clause = clause_1[: diff[0]] + "-" + clause_1[diff[0] + 1 :]
+                    if new_clause not in combined_clauses:
+                        combined_clauses.remove(clause_1)
+                        combined_clauses.remove(clause_2)
+                        combined_clauses.append(new_clause)
+                        something_changed = True
+                        break
+        return combined_clauses
+
+    def generate_esop(self, assignment):
+        """Recursively generates an ESOP for a partially determined boolean expression
+        'assignment' is a partial assignment to the expression's variables
+        """
+        # this base case is non-optimized;
+        # we may be able to terminate even before having a full assignment
+        if len(assignment) == self.truth_table.num_bits:
+            if self.truth_table[assignment]:
+                return ["-" * self.truth_table.num_bits]  # True; a don't care clause
+            else:
+                return []  # False
+        i = len(assignment)  # current variable
+        negative_esop = self.generate_esop(assignment + (False,))
+        positive_esop = self.generate_esop(assignment + (True,))
+        # Shannon's expansion
+        negative_esop_bool_expanded = [
+            clause[:i] + "0" + clause[i + 1 :] for clause in negative_esop
+        ]
+        positive_esop_bool_expanded = [
+            clause[:i] + "1" + clause[i + 1 :] for clause in positive_esop
+        ]
+        self.cofactor_table[assignment] = self.combine_and_optimize(
+            negative_esop_bool_expanded, positive_esop_bool_expanded
+        )
+        return self.cofactor_table[assignment]
+
+
+def synth_phase_oracle_from_esop(esop, num_qubits):
+    """
+    Generates a phase oracle for the boolean function f given in ESOP (Exlusive sum of products) form
+    esop is of the form ('01-1', '11-0', ...) etc
+    where 1 is the variable, 0 is negated variable and - is don't care
+    """
+    qc = QuantumCircuit(num_qubits)
+    clause_data = [
+        (zip(*[qubit_data for qubit_data in enumerate(clause) if qubit_data[1] != "-"]))
+        for clause in esop
+    ]
+    for qubit_indices, control_data in clause_data:
+        control_state = "".join(control_data)
+        if len(control_state) == 1:  # single qubit; either Z or XZX
+            if control_state == "0":
+                qc.x(qubit_indices[0])
+            qc.z(qubit_indices[0])
+            if control_state == "0":
+                qc.x(qubit_indices[0])
+        else:  # use custom controlled-Z gate
+            # we use the last qubit as the target, flipping it if the control is 0 for that qubit
+            gate = ZGate().control(len(qubit_indices) - 1, ctrl_state=control_state[:-1][::-1])
+            if control_state[-1] == "0":
+                qc.x(qubit_indices[-1])
+            qc.append(gate, qubit_indices)
+            if control_state[-1] == "0":
+                qc.x(qubit_indices[-1])
+    return qc
+
+
+def synth_bit_oracle_from_esop(esop, num_qubits):
+    """
+    Generates a bit-flip oracle for the boolean function f given in ESOP (Exlusive sum of products) form
+    esop is of the form ('01-1', '11-0', ...) etc
+    where 1 is the variable, 0 is negated variable and - is don't care
+    """
+    output_index = num_qubits - 1
+    qc = QuantumCircuit(num_qubits)
+    clause_data = [
+        (zip(*[qubit_data for qubit_data in enumerate(clause) if qubit_data[1] != "-"]))
+        for clause in esop
+    ]
+    for qubit_indices, control_data in clause_data:
+        control_state = "".join(control_data)
+        # use custom controlled-X gate
+        gate = XGate().control(len(qubit_indices), ctrl_state=control_state[::-1])
+        qc.append(gate, qubit_indices + (output_index,))
+    return qc

qiskit/synthesis/boolean/boolean_expression_visitor.py

@@ -0,0 +1,96 @@
+# 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.
+
+"""Node visitor as defined in https://docs.python.org/3/library/ast.html#ast.NodeVisitor
+This module is used internally by ``qiskit.synthesis.boolean.BooleanExpression``.
+"""
+
+import ast
+import _ast
+
+
+class BooleanExpressionEvalVisitor(ast.NodeVisitor):
+    """Node visitor to compute the value of the expression, given the boolean values of the args
+    as defined in https://docs.python.org/3/library/ast.html#ast.NodeVisitor"""
+
+    # pylint: disable=invalid-name
+    bitops = {
+        _ast.BitAnd: lambda values: values[0] and values[1],
+        _ast.And: lambda values: values[0] and values[1],
+        _ast.BitOr: lambda values: values[0] or values[1],
+        _ast.Or: lambda values: values[0] or values[1],
+        _ast.BitXor: lambda values: values[0] ^ values[1],
+        _ast.Not: lambda values: not values[0],
+        _ast.Invert: lambda values: not values[0],
+    }
+
+    def __init__(self):
+        self.arg_values = {}
+        super().__init__()
+
+    def bit_binop(self, op, values):
+        """Performs the operation, if it is recognized"""
+        op_type = type(op)
+        if op_type not in self.bitops:
+            raise ValueError(f"Unknown op: {op_type}")
+        return self.bitops[op_type](values)
+
+    def visit_BinOp(self, node):
+        """Handles ``&``, ``^``, and ``|``."""
+        return self.bit_binop(node.op, [self.visit(node.left), self.visit(node.right)])
+
+    def visit_UnaryOp(self, node):
+        """Handles ``~``."""
+        return self.bit_binop(node.op, [self.visit(node.operand)])
+
+    def visit_Name(self, node):
+        """Reduce variable names."""
+        if node.id not in self.arg_values:
+            raise ValueError(f"Undefined value for {node.id}")
+        return self.arg_values[node.id]
+
+    def visit_Module(self, node):
+        """Returns the value of the single expression comprising the boolean expression"""
+        if len(node.body) != 1 or not isinstance(node.body[0], ast.Expr):
+            raise ValueError("Incorrectly formatted boolean expression")
+        return self.visit(node.body[0])
+
+    def visit_Expr(self, node):
+        """Returns the value of the expression"""
+        return self.visit(node.value)
+
+    def generic_visit(self, node):
+        """Catch all for the unhandled nodes."""
+        raise ValueError(f"Unknown node: {type(node)}")
+
+
+class BooleanExpressionArgsCollectorVisitor(ast.NodeVisitor):
+    """Node visitor to collect the name of the args of the expression
+    as defined in https://docs.python.org/3/library/ast.html#ast.NodeVisitor"""
+
+    # pylint: disable=invalid-name
+    def __init__(self):
+        self.args = set()
+        self.args_pos = {}
+        super().__init__()
+
+    def visit_Name(self, node):
+        """Collect arg name."""
+        self.args.add(node.id)
+        if node.id not in self.args_pos or (
+            self.args_pos[node.id] > (node.lineno, node.col_offset)
+        ):
+            self.args_pos[node.id] = (node.lineno, node.col_offset)
+
+    def get_sorted_args(self):
+        """Returns a list of the args, sorted by their appearance locations"""
+        return sorted(self.args, key=lambda arg: self.args_pos[arg])

qiskit/synthesis/clifford/__init__.py

@@ -0,0 +1,19 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2023.
+#
+# 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 clifford circuit synthesis."""
+
+from .clifford_decompose_full import synth_clifford_full
+from .clifford_decompose_ag import synth_clifford_ag
+from .clifford_decompose_bm import synth_clifford_bm
+from .clifford_decompose_greedy import synth_clifford_greedy
+from .clifford_decompose_layers import synth_clifford_layers, synth_clifford_depth_lnn

qiskit/synthesis/clifford/clifford_decompose_ag.py

@@ -0,0 +1,178 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021, 2022.
+#
+# 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.
+"""
+Circuit synthesis for the Clifford class.
+"""
+
+
+# ---------------------------------------------------------------------
+# Synthesis based on Aaronson & Gottesman decomposition
+# ---------------------------------------------------------------------
+
+import numpy as np
+
+from qiskit.circuit import QuantumCircuit
+from qiskit.quantum_info import Clifford
+from qiskit.quantum_info.operators.symplectic.clifford_circuits import (
+    _append_cx,
+    _append_h,
+    _append_s,
+    _append_swap,
+    _append_x,
+    _append_z,
+)
+from .clifford_decompose_bm import synth_clifford_bm
+
+
+def synth_clifford_ag(clifford: Clifford) -> QuantumCircuit:
+    """Decompose a :class:`.Clifford` operator into a :class:`.QuantumCircuit`
+    based on Aaronson-Gottesman method [1].
+
+    Args:
+        clifford: A Clifford operator.
+
+    Returns:
+        A circuit implementation of the Clifford.
+
+    References:
+        1. S. Aaronson, D. Gottesman, *Improved Simulation of Stabilizer Circuits*,
+           Phys. Rev. A 70, 052328 (2004).
+           `arXiv:quant-ph/0406196 <https://arxiv.org/abs/quant-ph/0406196>`_
+    """
+    # Use 1-qubit decomposition method
+    if clifford.num_qubits == 1:
+        return synth_clifford_bm(clifford)
+
+    # Compose a circuit which we will convert to an instruction
+    circuit = QuantumCircuit(clifford.num_qubits, name=str(clifford))
+
+    # Make a copy of Clifford as we are going to do row reduction to
+    # reduce it to an identity
+    clifford_cpy = clifford.copy()
+
+    for i in range(clifford.num_qubits):
+        # put a 1 one into position by permuting and using Hadamards(i,i)
+        _set_qubit_x_true(clifford_cpy, circuit, i)
+        # make all entries in row i except ith equal to 0
+        # by using phase gate and CNOTS
+        _set_row_x_zero(clifford_cpy, circuit, i)
+        # treat Zs
+        _set_row_z_zero(clifford_cpy, circuit, i)
+
+    for i in range(clifford.num_qubits):
+        if clifford_cpy.destab_phase[i]:
+            _append_z(clifford_cpy, i)
+            circuit.z(i)
+        if clifford_cpy.stab_phase[i]:
+            _append_x(clifford_cpy, i)
+            circuit.x(i)
+    # Next we invert the circuit to undo the row reduction and return the
+    # result as a gate instruction
+    return circuit.inverse()
+
+
+# ---------------------------------------------------------------------
+# Helper functions for Aaronson & Gottesman decomposition
+# ---------------------------------------------------------------------
+
+
+def _set_qubit_x_true(clifford, circuit, qubit):
+    """Set destabilizer.X[qubit, qubit] to be True.
+
+    This is done by permuting columns l > qubit or if necessary applying
+    a Hadamard
+    """
+    x = clifford.destab_x[qubit]
+    z = clifford.destab_z[qubit]
+
+    if x[qubit]:
+        return
+
+    # Try to find non-zero element
+    for i in range(qubit + 1, clifford.num_qubits):
+        if x[i]:
+            _append_swap(clifford, i, qubit)
+            circuit.swap(i, qubit)
+            return
+
+    # no non-zero element found: need to apply Hadamard somewhere
+    for i in range(qubit, clifford.num_qubits):
+        if z[i]:
+            _append_h(clifford, i)
+            circuit.h(i)
+            if i != qubit:
+                _append_swap(clifford, i, qubit)
+                circuit.swap(i, qubit)
+            return
+
+
+def _set_row_x_zero(clifford, circuit, qubit):
+    r"""Set destabilizer.X[qubit, i] to False for all i > qubit.
+
+    This is done by applying CNOTs assuming :math:`k \leq N` and A[k][k]=1
+    """
+    x = clifford.destab_x[qubit]
+    z = clifford.destab_z[qubit]
+
+    # Check X first
+    for i in range(qubit + 1, clifford.num_qubits):
+        if x[i]:
+            _append_cx(clifford, qubit, i)
+            circuit.cx(qubit, i)
+
+    # Check whether Zs need to be set to zero:
+    if np.any(z[qubit:]):
+        if not z[qubit]:
+            # to treat Zs: make sure row.Z[k] to True
+            _append_s(clifford, qubit)
+            circuit.s(qubit)
+
+        # reverse CNOTS
+        for i in range(qubit + 1, clifford.num_qubits):
+            if z[i]:
+                _append_cx(clifford, i, qubit)
+                circuit.cx(i, qubit)
+        # set row.Z[qubit] to False
+        _append_s(clifford, qubit)
+        circuit.s(qubit)
+
+
+def _set_row_z_zero(clifford, circuit, qubit):
+    """Set stabilizer.Z[qubit, i] to False for all i > qubit.
+
+    Implemented by applying (reverse) CNOTS assumes qubit < num_qubits
+    and _set_row_x_zero has been called first
+    """
+
+    x = clifford.stab_x[qubit]
+    z = clifford.stab_z[qubit]
+
+    # check whether Zs need to be set to zero:
+    if np.any(z[qubit + 1 :]):
+        for i in range(qubit + 1, clifford.num_qubits):
+            if z[i]:
+                _append_cx(clifford, i, qubit)
+                circuit.cx(i, qubit)
+
+    # check whether Xs need to be set to zero:
+    if np.any(x[qubit:]):
+        _append_h(clifford, qubit)
+        circuit.h(qubit)
+        for i in range(qubit + 1, clifford.num_qubits):
+            if x[i]:
+                _append_cx(clifford, qubit, i)
+                circuit.cx(qubit, i)
+        if z[qubit]:
+            _append_s(clifford, qubit)
+            circuit.s(qubit)
+        _append_h(clifford, qubit)
+        circuit.h(qubit)

qiskit/synthesis/clifford/clifford_decompose_bm.py

@@ -0,0 +1,46 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021, 2024.
+#
+# 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.
+"""
+Circuit synthesis for 2-qubit and 3-qubit Cliffords based on Bravyi & Maslov
+decomposition.
+"""
+
+from qiskit.circuit import QuantumCircuit
+from qiskit.quantum_info import Clifford
+
+from qiskit._accelerate.synthesis.clifford import (
+    synth_clifford_bm as synth_clifford_bm_inner,
+)
+
+
+def synth_clifford_bm(clifford: Clifford) -> QuantumCircuit:
+    """Optimal CX-cost decomposition of a :class:`.Clifford` operator on 2 qubits
+    or 3 qubits into a :class:`.QuantumCircuit` based on the Bravyi-Maslov method [1].
+
+    Args:
+        clifford: A Clifford operator.
+
+    Returns:
+        A circuit implementation of the Clifford.
+
+    Raises:
+        QiskitError: if Clifford is on more than 3 qubits.
+
+    References:
+        1. S. Bravyi, D. Maslov, *Hadamard-free circuits expose the
+           structure of the Clifford group*,
+           `arXiv:2003.09412 [quant-ph] <https://arxiv.org/abs/2003.09412>`_
+    """
+    circuit = QuantumCircuit._from_circuit_data(
+        synth_clifford_bm_inner(clifford.tableau.astype(bool)), add_regs=True, name=str(clifford)
+    )
+    return circuit