qiskit 1.3.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/synthesis/permutation/permutation_full.py

@@ -0,0 +1,78 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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.
+
+"""Synthesis algorithm for Permutation gates for full-connectivity."""
+
+from __future__ import annotations
+
+import numpy as np
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit._accelerate.synthesis.permutation import (
+    _synth_permutation_basic,
+    _synth_permutation_acg,
+)
+
+
+def synth_permutation_basic(pattern: list[int] | np.ndarray[int]) -> QuantumCircuit:
+    """Synthesize a permutation circuit for a fully-connected
+    architecture using sorting.
+
+    More precisely, if the input permutation is a cycle of length ``m``,
+    then this creates a quantum circuit with ``m-1`` SWAPs (and of depth ``m-1``);
+    if the input  permutation consists of several disjoint cycles, then each cycle
+    is essentially treated independently.
+
+    Args:
+        pattern: Permutation pattern, describing
+            which qubits occupy the positions 0, 1, 2, etc. after applying the
+            permutation. That is, ``pattern[k] = m`` when the permutation maps
+            qubit ``m`` to position ``k``. As an example, the pattern ``[2, 4, 3, 0, 1]``
+            means that qubit ``2`` goes to position ``0``, qubit ``4`` goes to
+            position ``1``, etc.
+
+    Returns:
+        The synthesized quantum circuit.
+    """
+    return QuantumCircuit._from_circuit_data(_synth_permutation_basic(pattern), add_regs=True)
+
+
+def synth_permutation_acg(pattern: list[int] | np.ndarray[int]) -> QuantumCircuit:
+    """Synthesize a permutation circuit for a fully-connected
+    architecture using the Alon, Chung, Graham method.
+
+    This produces a quantum circuit of depth 2 (measured in the number of SWAPs).
+
+    This implementation is based on the Proposition 4.1 in reference [1] with
+    the detailed proof given in Theorem 2 in reference [2]
+
+    Args:
+        pattern: Permutation pattern, describing
+            which qubits occupy the positions 0, 1, 2, etc. after applying the
+            permutation. That is, ``pattern[k] = m`` when the permutation maps
+            qubit ``m`` to position ``k``. As an example, the pattern ``[2, 4, 3, 0, 1]``
+            means that qubit ``2`` goes to position ``0``, qubit ``4`` goes to
+            position ``1``, etc.
+
+    Returns:
+        The synthesized quantum circuit.
+
+    References:
+        1. N. Alon, F. R. K. Chung, and R. L. Graham.
+           *Routing Permutations on Graphs Via Matchings.*,
+           Proceedings of the Twenty-Fifth Annual ACM Symposium on Theory of Computing(1993).
+           Pages 583–591.
+           `(Extended abstract) 10.1145/167088.167239 <https://doi.org/10.1145/167088.167239>`_
+        2. N. Alon, F. R. K. Chung, and R. L. Graham.
+           *Routing Permutations on Graphs Via Matchings.*,
+           `(Full paper) <https://www.cs.tau.ac.il/~nogaa/PDFS/r.pdf>`_
+    """
+    return QuantumCircuit._from_circuit_data(_synth_permutation_acg(pattern), add_regs=True)

qiskit/synthesis/permutation/permutation_lnn.py

@@ -0,0 +1,54 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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.
+
+"""Depth-efficient synthesis algorithm for Permutation gates."""
+
+from __future__ import annotations
+import numpy as np
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit._accelerate.synthesis.permutation import _synth_permutation_depth_lnn_kms
+
+
+def synth_permutation_depth_lnn_kms(pattern: list[int] | np.ndarray[int]) -> QuantumCircuit:
+    """Synthesize a permutation circuit for a linear nearest-neighbor
+    architecture using the Kutin, Moulton, Smithline method.
+
+    This is the permutation synthesis algorithm from [1], section 6.
+    It synthesizes any permutation of n qubits over linear nearest-neighbor
+    architecture using SWAP gates with depth at most :math:`n` and size at most
+    :math:`n(n-1)/2` (where both depth and size are measured with respect to SWAPs).
+
+    Args:
+        pattern: Permutation pattern, describing
+            which qubits occupy the positions 0, 1, 2, etc. after applying the
+            permutation. That is, ``pattern[k] = m`` when the permutation maps
+            qubit ``m`` to position ``k``. As an example, the pattern ``[2, 4, 3, 0, 1]``
+            means that qubit ``2`` goes to position ``0``, qubit ``4`` goes to
+            position ``1``, etc.
+
+    Returns:
+        The synthesized quantum circuit.
+
+    References:
+        1. Samuel A. Kutin, David Petrie Moulton and Lawren M. Smithline.
+           *Computation at a distance.*,
+           `arXiv:quant-ph/0701194v1 <https://arxiv.org/abs/quant-ph/0701194>`_
+    """
+
+    # In Qiskit, the permutation pattern [2, 4, 3, 0, 1] means that
+    # the permutation that maps qubit 2 to position 0, 4 to 1, 3 to 2, 0 to 3, and 1 to 4.
+    # In the permutation synthesis code below the notation is opposite:
+    # [2, 4, 3, 0, 1] means that 0 maps to 2, 1 to 3, 2 to 3, 3 to 0, and 4 to 1.
+    # This is why we invert the pattern.
+    return QuantumCircuit._from_circuit_data(
+        _synth_permutation_depth_lnn_kms(pattern), add_regs=True
+    )

qiskit/synthesis/permutation/permutation_reverse_lnn.py

@@ -0,0 +1,93 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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.
+"""
+Synthesis of a reverse permutation for LNN connectivity.
+"""
+
+from qiskit.circuit import QuantumCircuit
+from qiskit._accelerate.synthesis.permutation import (
+    synth_permutation_reverse_lnn_kms as synth_permutation_reverse_lnn_kms_inner,
+)
+
+
+def _append_cx_stage1(qc, n):
+    """A single layer of CX gates."""
+    for i in range(n // 2):
+        qc.cx(2 * i, 2 * i + 1)
+    for i in range((n + 1) // 2 - 1):
+        qc.cx(2 * i + 2, 2 * i + 1)
+    return qc
+
+
+def _append_cx_stage2(qc, n):
+    """A single layer of CX gates."""
+    for i in range(n // 2):
+        qc.cx(2 * i + 1, 2 * i)
+    for i in range((n + 1) // 2 - 1):
+        qc.cx(2 * i + 1, 2 * i + 2)
+    return qc
+
+
+def _append_reverse_permutation_lnn_kms(qc: QuantumCircuit, num_qubits: int) -> None:
+    """
+    Append reverse permutation to a QuantumCircuit for linear nearest-neighbor architectures
+    using Kutin, Moulton, Smithline method.
+
+    Synthesis algorithm for reverse permutation from [1], section 5.
+    This algorithm synthesizes the reverse permutation on :math:`n` qubits over
+    a linear nearest-neighbor architecture using CX gates with depth :math:`2 * n + 2`.
+
+    Args:
+        qc: The original quantum circuit.
+        num_qubits: The number of qubits.
+
+    Returns:
+        The quantum circuit with appended reverse permutation.
+
+    References:
+        1. Kutin, S., Moulton, D. P., Smithline, L.,
+           *Computation at a distance*, Chicago J. Theor. Comput. Sci., vol. 2007, (2007),
+           `arXiv:quant-ph/0701194 <https://arxiv.org/abs/quant-ph/0701194>`_
+    """
+
+    for _ in range((num_qubits + 1) // 2):
+        _append_cx_stage1(qc, num_qubits)
+        _append_cx_stage2(qc, num_qubits)
+    if (num_qubits % 2) == 0:
+        _append_cx_stage1(qc, num_qubits)
+
+
+def synth_permutation_reverse_lnn_kms(num_qubits: int) -> QuantumCircuit:
+    """
+    Synthesize reverse permutation for linear nearest-neighbor architectures using
+    Kutin, Moulton, Smithline method.
+
+    Synthesis algorithm for reverse permutation from [1], section 5.
+    This algorithm synthesizes the reverse permutation on :math:`n` qubits over
+    a linear nearest-neighbor architecture using CX gates with depth :math:`2 * n + 2`.
+
+    Args:
+        num_qubits: The number of qubits.
+
+    Returns:
+        The synthesized quantum circuit.
+
+    References:
+        1. Kutin, S., Moulton, D. P., Smithline, L.,
+           *Computation at a distance*, Chicago J. Theor. Comput. Sci., vol. 2007, (2007),
+           `arXiv:quant-ph/0701194 <https://arxiv.org/abs/quant-ph/0701194>`_
+    """
+
+    # Call Rust implementation
+    return QuantumCircuit._from_circuit_data(
+        synth_permutation_reverse_lnn_kms_inner(num_qubits), add_regs=True
+    )

qiskit/synthesis/permutation/permutation_utils.py

@@ -0,0 +1,16 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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.
+
+"""Utility functions for handling permutations."""
+
+# pylint: disable=unused-import
+from qiskit._accelerate.synthesis.permutation import _inverse_pattern, _validate_permutation

qiskit/synthesis/qft/__init__.py

@@ -0,0 +1,16 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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 stabilizer QFT circuit synthesis."""
+
+from .qft_decompose_lnn import synth_qft_line
+from .qft_decompose_full import synth_qft_full

qiskit/synthesis/qft/qft_decompose_full.py

@@ -0,0 +1,97 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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 a QFT circuit.
+"""
+
+from __future__ import annotations
+import warnings
+import numpy as np
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+
+
+def synth_qft_full(
+    num_qubits: int,
+    do_swaps: bool = True,
+    approximation_degree: int = 0,
+    insert_barriers: bool = False,
+    inverse: bool = False,
+    name: str | None = None,
+) -> QuantumCircuit:
+    """Construct a circuit for the Quantum Fourier Transform using all-to-all connectivity.
+
+    .. note::
+
+        With the default value of ``do_swaps = True``, this synthesis algorithm creates a
+        circuit that faithfully implements the QFT operation. This circuit contains a sequence
+        of swap gates at the end, corresponding to reversing the order of its output qubits.
+        In some applications this reversal permutation can be avoided. Setting ``do_swaps = False``
+        creates a circuit without this reversal permutation, at the expense that this circuit
+        implements the "QFT-with-reversal" instead of QFT. Alternatively, the
+        :class:`~.ElidePermutations` transpiler pass is able to remove these swap gates.
+
+    Args:
+        num_qubits: The number of qubits on which the Quantum Fourier Transform acts.
+        do_swaps: Whether to synthesize the "QFT" or the "QFT-with-reversal" operation.
+        approximation_degree: The degree of approximation (0 for no approximation).
+            It is possible to implement the QFT approximately by ignoring
+            controlled-phase rotations with the angle beneath a threshold. This is discussed
+            in more detail in https://arxiv.org/abs/quant-ph/9601018 or
+            https://arxiv.org/abs/quant-ph/0403071.
+        insert_barriers: If ``True``, barriers are inserted for improved visualization.
+        inverse: If ``True``, the inverse Quantum Fourier Transform is constructed.
+        name: The name of the circuit.
+
+    Returns:
+        A circuit implementing the QFT operation.
+
+    """
+    _warn_if_precision_loss(num_qubits - approximation_degree - 1)
+    circuit = QuantumCircuit(num_qubits, name=name)
+
+    for j in reversed(range(num_qubits)):
+        circuit.h(j)
+        num_entanglements = max(0, j - max(0, approximation_degree - (num_qubits - j - 1)))
+        for k in reversed(range(j - num_entanglements, j)):
+            # Use negative exponents so that the angle safely underflows to zero, rather than
+            # using a temporary variable that overflows to infinity in the worst case.
+            lam = np.pi * (2.0 ** (k - j))
+            circuit.cp(lam, j, k)
+
+        if insert_barriers:
+            circuit.barrier()
+
+    if do_swaps:
+        for i in range(num_qubits // 2):
+            circuit.swap(i, num_qubits - i - 1)
+
+    if inverse:
+        circuit = circuit.inverse()
+
+    return circuit
+
+
+def _warn_if_precision_loss(max_num_entanglements):
+    """Issue a warning if constructing the circuit will lose precision.
+
+    If we need an angle smaller than ``pi * 2**-1022``, we start to lose precision by going into
+    the subnormal numbers.  We won't lose _all_ precision until an exponent of about 1075, but
+    beyond 1022 we're using fractional bits to represent leading zeros.
+    """
+    if max_num_entanglements > -np.finfo(float).minexp:  # > 1022 for doubles.
+        warnings.warn(
+            "precision loss in QFT."
+            f" The rotation needed to represent {max_num_entanglements} entanglements"
+            " is smaller than the smallest normal floating-point number.",
+            category=RuntimeWarning,
+            stacklevel=4,
+        )

qiskit/synthesis/qft/qft_decompose_lnn.py

@@ -0,0 +1,79 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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.
+"""
+Circuit synthesis for a QFT circuit.
+"""
+
+import numpy as np
+from qiskit.circuit import QuantumCircuit
+from qiskit.synthesis.permutation.permutation_reverse_lnn import _append_reverse_permutation_lnn_kms
+from .qft_decompose_full import _warn_if_precision_loss
+
+
+def synth_qft_line(
+    num_qubits: int, do_swaps: bool = True, approximation_degree: int = 0
+) -> QuantumCircuit:
+    """Construct a circuit for the Quantum Fourier Transform using linear
+    neighbor connectivity.
+
+    The construction is based on Fig 2.b in Fowler et al. [1].
+
+    .. note::
+
+        With the default value of ``do_swaps = True``, this synthesis algorithm creates a
+        circuit that faithfully implements the QFT operation. When ``do_swaps = False``,
+        this synthesis algorithm creates a circuit that corresponds to "QFT-with-reversal":
+        applying the QFT and reversing the order of its output qubits.
+
+    Args:
+        num_qubits: The number of qubits on which the Quantum Fourier Transform acts.
+        approximation_degree: The degree of approximation (0 for no approximation).
+            It is possible to implement the QFT approximately by ignoring
+            controlled-phase rotations with the angle beneath a threshold. This is discussed
+            in more detail in https://arxiv.org/abs/quant-ph/9601018 or
+            https://arxiv.org/abs/quant-ph/0403071.
+        do_swaps: Whether to synthesize the "QFT" or the "QFT-with-reversal" operation.
+
+    Returns:
+        A circuit implementing the QFT operation.
+
+    References:
+        1. A. G. Fowler, S. J. Devitt, and L. C. L. Hollenberg,
+           *Implementation of Shor's algorithm on a linear nearest neighbour qubit array*,
+           Quantum Info. Comput. 4, 4 (July 2004), 237–251.
+           `arXiv:quant-ph/0402196 [quant-ph] <https://arxiv.org/abs/quant-ph/0402196>`_
+    """
+    _warn_if_precision_loss(num_qubits - approximation_degree - 1)
+    qc = QuantumCircuit(num_qubits)
+
+    for i in range(num_qubits):
+        qc.h(num_qubits - 1)
+
+        for j in range(i, num_qubits - 1):
+            if j - i + 2 < num_qubits - approximation_degree + 1:
+                qc.p(np.pi / 2 ** (j - i + 2), num_qubits - j + i - 1)
+                qc.cx(num_qubits - j + i - 1, num_qubits - j + i - 2)
+                qc.p(-np.pi / 2 ** (j - i + 2), num_qubits - j + i - 2)
+                qc.cx(num_qubits - j + i - 2, num_qubits - j + i - 1)
+                qc.cx(num_qubits - j + i - 1, num_qubits - j + i - 2)
+                qc.p(np.pi / 2 ** (j - i + 2), num_qubits - j + i - 1)
+            else:
+                qc.cx(num_qubits - j + i - 1, num_qubits - j + i - 2)
+                qc.cx(num_qubits - j + i - 2, num_qubits - j + i - 1)
+                qc.cx(num_qubits - j + i - 1, num_qubits - j + i - 2)
+
+    if not do_swaps:
+        # Add a reversal network for LNN connectivity in depth 2*n+2,
+        # based on Kutin at al., https://arxiv.org/abs/quant-ph/0701194, Section 5.
+        _append_reverse_permutation_lnn_kms(qc, num_qubits)
+
+    return qc

qiskit/synthesis/stabilizer/__init__.py

@@ -0,0 +1,16 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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 stabilizer state preparation circuit synthesis."""
+
+from .stabilizer_decompose import synth_stabilizer_layers, synth_stabilizer_depth_lnn
+from .stabilizer_circuit import synth_circuit_from_stabilizers

qiskit/synthesis/stabilizer/stabilizer_circuit.py

@@ -0,0 +1,149 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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.
+"""
+Stabilizer to circuit function
+"""
+from __future__ import annotations
+
+from collections.abc import Collection
+
+import numpy as np
+
+from qiskit.quantum_info import PauliList
+from qiskit.exceptions import QiskitError
+from qiskit.circuit import QuantumCircuit
+from qiskit.quantum_info.operators.symplectic.clifford import Clifford
+
+
+def synth_circuit_from_stabilizers(
+    stabilizers: Collection[str],
+    allow_redundant: bool = False,
+    allow_underconstrained: bool = False,
+    invert: bool = False,
+) -> QuantumCircuit:
+    # pylint: disable=line-too-long
+    """Synthesis of a circuit that generates a state stabilized by the stabilizers
+    using Gaussian elimination with Clifford gates.
+    If the stabilizers are underconstrained, and ``allow_underconstrained`` is ``True``,
+    the circuit will output one of the states stabilized by the stabilizers.
+    Based on stim implementation.
+
+    Args:
+        stabilizers: List of stabilizer strings
+        allow_redundant: Allow redundant stabilizers (i.e., some stabilizers
+            can be products of the others)
+        allow_underconstrained: Allow underconstrained set of stabilizers (i.e.,
+            the stabilizers do not specify a unique state)
+        invert: Return inverse circuit
+
+    Returns:
+        A circuit that generates a state stabilized by ``stabilizers``.
+
+    Raises:
+        QiskitError: if the stabilizers are invalid, do not commute, or contradict each other,
+                     if the list is underconstrained and ``allow_underconstrained`` is ``False``,
+                     or if the list is redundant and ``allow_redundant`` is ``False``.
+
+    References:
+        1. https://github.com/quantumlib/Stim/blob/c0dd0b1c8125b2096cd54b6f72884a459e47fe3e/src/stim/stabilizers/conversions.inl#L469
+        2. https://quantumcomputing.stackexchange.com/questions/12721/how-to-calculate-destabilizer-group-of-toric-and-other-codes
+
+    """
+    stabilizer_list = PauliList(stabilizers)
+    if np.any(stabilizer_list.phase % 2):
+        raise QiskitError("Some stabilizers have an invalid phase")
+    if len(stabilizer_list.commutes_with_all(stabilizer_list)) < len(stabilizer_list):
+        raise QiskitError("Some stabilizers do not commute.")
+
+    num_qubits = stabilizer_list.num_qubits
+    circuit = QuantumCircuit(num_qubits)
+
+    used = 0
+    for i, stabilizer in enumerate(stabilizer_list):
+        curr_stab = stabilizer.evolve(Clifford(circuit), frame="s")
+
+        # Find pivot.
+        pivot = used
+        while pivot < num_qubits:
+            if curr_stab[pivot].x or curr_stab[pivot].z:
+                break
+            pivot += 1
+
+        if pivot == num_qubits:
+            if curr_stab.x.any():
+                raise QiskitError(
+                    f"Stabilizer {i} ({stabilizer}) anti-commutes with some of "
+                    "the previous stabilizers."
+                )
+            if curr_stab.phase == 2:
+                raise QiskitError(
+                    f"Stabilizer {i} ({stabilizer}) contradicts "
+                    "some of the previous stabilizers."
+                )
+            if curr_stab.z.any() and not allow_redundant:
+                raise QiskitError(
+                    f"Stabilizer {i} ({stabilizer}) is a product of the others "
+                    "and allow_redundant is False. Add allow_redundant=True "
+                    "to the function call if you want to allow redundant stabilizers."
+                )
+            continue
+
+        # Change pivot basis to the Z axis.
+        if curr_stab[pivot].x:
+            if curr_stab[pivot].z:
+                circuit.h(pivot)
+                circuit.s(pivot)
+                circuit.h(pivot)
+                circuit.s(pivot)
+                circuit.s(pivot)
+            else:
+                circuit.h(pivot)
+
+        # Cancel other terms in Pauli string.
+        for j in range(num_qubits):
+            if j == pivot or not (curr_stab[j].x or curr_stab[j].z):
+                continue
+            p = curr_stab[j].x + curr_stab[j].z * 2
+            if p == 1:  # X
+                circuit.h(pivot)
+                circuit.cx(pivot, j)
+                circuit.h(pivot)
+            elif p == 2:  # Z
+                circuit.cx(j, pivot)
+            elif p == 3:  # Y
+                circuit.h(pivot)
+                circuit.s(j)
+                circuit.s(j)
+                circuit.s(j)
+                circuit.cx(pivot, j)
+                circuit.h(pivot)
+                circuit.s(j)
+
+        # Move pivot to diagonal.
+        if pivot != used:
+            circuit.swap(pivot, used)
+
+        # fix sign
+        curr_stab = stabilizer.evolve(Clifford(circuit), frame="s")
+        if curr_stab.phase == 2:
+            circuit.x(used)
+        used += 1
+
+    if used < num_qubits and not allow_underconstrained:
+        raise QiskitError(
+            "Stabilizers are underconstrained and allow_underconstrained is False."
+            " Add allow_underconstrained=True  to the function call "
+            "if you want to allow underconstrained stabilizers."
+        )
+    if invert:
+        return circuit
+    return circuit.inverse()