qiskit 2.0.3__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

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

qiskit/synthesis/clifford/clifford_decompose_full.py

@@ -0,0 +1,64 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 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 for all-to-all architecture.
+"""
+
+from __future__ import annotations
+from qiskit.circuit import QuantumCircuit
+from qiskit.quantum_info import Clifford
+from qiskit.synthesis.clifford.clifford_decompose_ag import synth_clifford_ag
+from qiskit.synthesis.clifford.clifford_decompose_bm import synth_clifford_bm
+from qiskit.synthesis.clifford.clifford_decompose_greedy import synth_clifford_greedy
+
+
+def synth_clifford_full(clifford: Clifford, method: str | None = None) -> QuantumCircuit:
+    r"""Decompose a :class:`.Clifford` operator into a :class:`.QuantumCircuit`.
+
+    For :math:`N \leq 3` qubits this is based on optimal CX-cost decomposition
+    from reference [1]. For :math:`N > 3` qubits this is done using the general
+    non-optimal greedy compilation routine from reference [3],
+    which typically yields better CX cost compared to the AG method in [2].
+
+    Args:
+        clifford: A Clifford operator.
+        method: Optional, a synthesis method (``'AG'`` or ``'greedy'``).
+             If set this overrides optimal decomposition for :math:`N \leq 3` qubits.
+
+    Returns:
+        A circuit implementation of the Clifford.
+
+    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>`_
+
+        2. 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>`_
+
+        3. Sergey Bravyi, Shaohan Hu, Dmitri Maslov, Ruslan Shaydulin,
+           *Clifford Circuit Optimization with Templates and Symbolic Pauli Gates*,
+           `arXiv:2105.02291 [quant-ph] <https://arxiv.org/abs/2105.02291>`_
+    """
+    num_qubits = clifford.num_qubits
+
+    if method == "AG":
+        return synth_clifford_ag(clifford)
+
+    if method == "greedy":
+        return synth_clifford_greedy(clifford)
+
+    if num_qubits <= 3:
+        return synth_clifford_bm(clifford)
+
+    return synth_clifford_greedy(clifford)

qiskit/synthesis/clifford/clifford_decompose_greedy.py

@@ -0,0 +1,58 @@
+# 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 the Clifford class.
+"""
+
+# ---------------------------------------------------------------------
+# Synthesis based on Bravyi et. al. greedy clifford compiler
+# ---------------------------------------------------------------------
+
+from qiskit.circuit import QuantumCircuit
+from qiskit.quantum_info import Clifford
+
+from qiskit._accelerate.synthesis.clifford import (
+    synth_clifford_greedy as synth_clifford_greedy_inner,
+)
+
+
+def synth_clifford_greedy(clifford: Clifford) -> QuantumCircuit:
+    """Decompose a :class:`.Clifford` operator into a :class:`.QuantumCircuit` based
+    on the greedy Clifford compiler that is described in Appendix A of
+    Bravyi, Hu, Maslov and Shaydulin [1].
+
+    This method typically yields better CX cost compared to the Aaronson-Gottesman method.
+
+    Note that this function only implements the greedy Clifford compiler from Appendix A
+    of [1], and not the templates and symbolic Pauli gates optimizations
+    that are mentioned in the same paper.
+
+    Args:
+        clifford: A Clifford operator.
+
+    Returns:
+        A circuit implementation of the Clifford.
+
+    Raises:
+        QiskitError: if symplectic Gaussian elimination fails.
+
+    References:
+        1. Sergey Bravyi, Shaohan Hu, Dmitri Maslov, Ruslan Shaydulin,
+           *Clifford Circuit Optimization with Templates and Symbolic Pauli Gates*,
+           `arXiv:2105.02291 [quant-ph] <https://arxiv.org/abs/2105.02291>`_
+    """
+    circuit = QuantumCircuit._from_circuit_data(
+        synth_clifford_greedy_inner(clifford.tableau.astype(bool)),
+        add_regs=True,
+        name=str(clifford),
+    )
+    return circuit