qiskit 1.3.0__cp39-abi3-macosx_11_0_arm64.whl

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