qiskit 1.3.0b1__cp39-abi3-macosx_10_9_x86_64.whl

qiskit/scheduler/methods/basic.py

@@ -0,0 +1,137 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2019.
+#
+# 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.
+
+"""
+The most straightforward scheduling methods: scheduling **as early** or **as late** as possible.
+"""
+from collections import defaultdict
+from typing import List, Optional, Union
+
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit.barrier import Barrier
+from qiskit.pulse.schedule import Schedule
+
+from qiskit.scheduler.config import ScheduleConfig
+from qiskit.scheduler.lowering import lower_gates
+from qiskit.providers import BackendV1, BackendV2
+
+
+def as_soon_as_possible(
+    circuit: QuantumCircuit,
+    schedule_config: ScheduleConfig,
+    backend: Optional[Union[BackendV1, BackendV2]] = None,
+) -> Schedule:
+    """
+    Return the pulse Schedule which implements the input circuit using an "as soon as possible"
+    (asap) scheduling policy.
+
+    Circuit instructions are first each mapped to equivalent pulse
+    Schedules according to the command definition given by the schedule_config. Then, this circuit
+    instruction-equivalent Schedule is appended at the earliest time at which all qubits involved
+    in the instruction are available.
+
+    Args:
+        circuit: The quantum circuit to translate.
+        schedule_config: Backend specific parameters used for building the Schedule.
+        backend: A backend used to build the Schedule, the backend could be BackendV1
+                 or BackendV2.
+
+    Returns:
+        A schedule corresponding to the input ``circuit`` with pulses occurring as early as
+        possible.
+    """
+    qubit_time_available = defaultdict(int)
+
+    def update_times(inst_qubits: List[int], time: int = 0) -> None:
+        """Update the time tracker for all inst_qubits to the given time."""
+        for q in inst_qubits:
+            qubit_time_available[q] = time
+
+    start_times = []
+    circ_pulse_defs = lower_gates(circuit, schedule_config, backend)
+    for circ_pulse_def in circ_pulse_defs:
+        start_time = max(qubit_time_available[q] for q in circ_pulse_def.qubits)
+        stop_time = start_time
+        if not isinstance(circ_pulse_def.schedule, Barrier):
+            stop_time += circ_pulse_def.schedule.duration
+
+        start_times.append(start_time)
+        update_times(circ_pulse_def.qubits, stop_time)
+
+    timed_schedules = [
+        (time, cpd.schedule)
+        for time, cpd in zip(start_times, circ_pulse_defs)
+        if not isinstance(cpd.schedule, Barrier)
+    ]
+    schedule = Schedule.initialize_from(circuit)
+    for time, inst in timed_schedules:
+        schedule.insert(time, inst, inplace=True)
+    return schedule
+
+
+def as_late_as_possible(
+    circuit: QuantumCircuit,
+    schedule_config: ScheduleConfig,
+    backend: Optional[Union[BackendV1, BackendV2]] = None,
+) -> Schedule:
+    """
+    Return the pulse Schedule which implements the input circuit using an "as late as possible"
+    (alap) scheduling policy.
+
+    Circuit instructions are first each mapped to equivalent pulse
+    Schedules according to the command definition given by the schedule_config. Then, this circuit
+    instruction-equivalent Schedule is appended at the latest time that it can be without allowing
+    unnecessary time between instructions or allowing instructions with common qubits to overlap.
+
+    This method should improves the outcome fidelity over ASAP scheduling, because we may
+    maximize the time that the qubit remains in the ground state.
+
+    Args:
+        circuit: The quantum circuit to translate.
+        schedule_config: Backend specific parameters used for building the Schedule.
+        backend: A backend used to build the Schedule, the backend could be BackendV1
+                 or BackendV2.
+
+    Returns:
+        A schedule corresponding to the input ``circuit`` with pulses occurring as late as
+        possible.
+    """
+    qubit_time_available = defaultdict(int)
+
+    def update_times(inst_qubits: List[int], time: int = 0) -> None:
+        """Update the time tracker for all inst_qubits to the given time."""
+        for q in inst_qubits:
+            qubit_time_available[q] = time
+
+    rev_stop_times = []
+    circ_pulse_defs = lower_gates(circuit, schedule_config, backend)
+    for circ_pulse_def in reversed(circ_pulse_defs):
+        start_time = max(qubit_time_available[q] for q in circ_pulse_def.qubits)
+        stop_time = start_time
+        if not isinstance(circ_pulse_def.schedule, Barrier):
+            stop_time += circ_pulse_def.schedule.duration
+
+        rev_stop_times.append(stop_time)
+        update_times(circ_pulse_def.qubits, stop_time)
+
+    last_stop = max(t for t in qubit_time_available.values()) if qubit_time_available else 0
+    start_times = [last_stop - t for t in reversed(rev_stop_times)]
+
+    timed_schedules = [
+        (time, cpd.schedule)
+        for time, cpd in zip(start_times, circ_pulse_defs)
+        if not isinstance(cpd.schedule, Barrier)
+    ]
+    schedule = Schedule.initialize_from(circuit)
+    for time, inst in timed_schedules:
+        schedule.insert(time, inst, inplace=True)
+    return schedule

qiskit/scheduler/schedule_circuit.py

@@ -0,0 +1,67 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2019.
+#
+# 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.
+
+"""QuantumCircuit to Pulse scheduler."""
+from typing import Optional, Union
+
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.exceptions import QiskitError
+
+from qiskit.pulse.schedule import Schedule
+from qiskit.scheduler.config import ScheduleConfig
+from qiskit.scheduler.methods import as_soon_as_possible, as_late_as_possible
+from qiskit.providers import BackendV1, BackendV2
+
+
+def schedule_circuit(
+    circuit: QuantumCircuit,
+    schedule_config: ScheduleConfig,
+    method: Optional[str] = None,
+    backend: Optional[Union[BackendV1, BackendV2]] = None,
+) -> Schedule:
+    """
+    Basic scheduling pass from a circuit to a pulse Schedule, using the backend. If no method is
+    specified, then a basic, as late as possible scheduling pass is performed, i.e. pulses are
+    scheduled to occur as late as possible.
+
+    Supported methods:
+
+        * ``'as_soon_as_possible'``: Schedule pulses greedily, as early as possible on a
+          qubit resource. (alias: ``'asap'``)
+        * ``'as_late_as_possible'``: Schedule pulses late-- keep qubits in the ground state when
+          possible. (alias: ``'alap'``)
+
+    Args:
+        circuit: The quantum circuit to translate.
+        schedule_config: Backend specific parameters used for building the Schedule.
+        method: The scheduling pass method to use.
+        backend: A backend used to build the Schedule, the backend could be BackendV1
+                 or BackendV2.
+
+    Returns:
+        Schedule corresponding to the input circuit.
+
+    Raises:
+        QiskitError: If method isn't recognized.
+    """
+    methods = {
+        "as_soon_as_possible": as_soon_as_possible,
+        "asap": as_soon_as_possible,
+        "as_late_as_possible": as_late_as_possible,
+        "alap": as_late_as_possible,
+    }
+    if method is None:
+        method = "as_late_as_possible"
+    try:
+        return methods[method](circuit, schedule_config, backend)
+    except KeyError as ex:
+        raise QiskitError(f"Scheduling method {method} isn't recognized.") from ex

qiskit/scheduler/sequence.py

@@ -0,0 +1,102 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2020.
+#
+# 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.
+
+"""
+Mapping a scheduled QuantumCircuit to a pulse Schedule.
+"""
+from collections import defaultdict
+
+from typing import Optional, Union
+from qiskit.circuit.barrier import Barrier
+from qiskit.circuit.measure import Measure
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.exceptions import QiskitError
+from qiskit.pulse.schedule import Schedule
+from qiskit.pulse.transforms import pad
+from qiskit.scheduler.config import ScheduleConfig
+from qiskit.scheduler.lowering import lower_gates
+from qiskit.providers import BackendV1, BackendV2
+
+
+def sequence(
+    scheduled_circuit: QuantumCircuit,
+    schedule_config: ScheduleConfig,
+    backend: Optional[Union[BackendV1, BackendV2]] = None,
+) -> Schedule:
+    """
+    Return the pulse Schedule which implements the input scheduled circuit.
+
+    Assume all measurements are done at once at the last of the circuit.
+    Schedules according to the command definition given by the schedule_config.
+
+    Args:
+        scheduled_circuit: The scheduled quantum circuit to translate.
+        schedule_config: Backend specific parameters used for building the Schedule.
+        backend: A backend used to build the Schedule, the backend could be BackendV1
+                 or BackendV2
+
+    Returns:
+        A schedule corresponding to the input ``circuit``.
+
+    Raises:
+        QiskitError: If invalid scheduled circuit is supplied.
+    """
+    circ_pulse_defs = lower_gates(scheduled_circuit, schedule_config, backend)
+
+    # find the measurement start time (assume measurement once)
+    def _meas_start_time():
+        _qubit_time_available = defaultdict(int)
+        for instruction in scheduled_circuit.data:
+            if isinstance(instruction.operation, Measure):
+                return _qubit_time_available[instruction.qubits[0]]
+            for q in instruction.qubits:
+                _qubit_time_available[q] += instruction.operation.duration
+        return None
+
+    meas_time = _meas_start_time()
+
+    # restore start times
+    qubit_time_available = {}
+    start_times = []
+    out_circ_pulse_defs = []
+    for circ_pulse_def in circ_pulse_defs:
+        active_qubits = [q for q in circ_pulse_def.qubits if q in qubit_time_available]
+
+        start_time = max((qubit_time_available[q] for q in active_qubits), default=0)
+
+        for q in active_qubits:
+            if qubit_time_available[q] != start_time:
+                # print(q, ":", qubit_time_available[q], "!=", start_time)
+                raise QiskitError("Invalid scheduled circuit.")
+
+        stop_time = start_time
+        if not isinstance(circ_pulse_def.schedule, Barrier):
+            stop_time += circ_pulse_def.schedule.duration
+
+        delay_overlaps_meas = False
+        for q in circ_pulse_def.qubits:
+            qubit_time_available[q] = stop_time
+            if (
+                meas_time is not None
+                and circ_pulse_def.schedule.name == "delay"
+                and stop_time > meas_time
+            ):
+                qubit_time_available[q] = meas_time
+                delay_overlaps_meas = True
+        # skip to delays overlapping measures and barriers
+        if not delay_overlaps_meas and not isinstance(circ_pulse_def.schedule, Barrier):
+            start_times.append(start_time)
+            out_circ_pulse_defs.append(circ_pulse_def)
+
+    timed_schedules = [(time, cpd.schedule) for time, cpd in zip(start_times, out_circ_pulse_defs)]
+    sched = Schedule(*timed_schedules, name=scheduled_circuit.name)
+    return pad(sched)

qiskit/synthesis/__init__.py

@@ -0,0 +1,195 @@
+# 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.
+
+r"""
+===========================================
+Circuit Synthesis (:mod:`qiskit.synthesis`)
+===========================================
+
+.. currentmodule:: qiskit.synthesis
+
+.. _evolution_synthesis:
+
+Evolution Synthesis
+===================
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   EvolutionSynthesis
+   ProductFormula
+   LieTrotter
+   SuzukiTrotter
+   MatrixExponential
+   QDrift
+
+Linear Function Synthesis
+=========================
+
+.. autofunction:: synth_cnot_count_full_pmh
+.. autofunction:: synth_cnot_depth_line_kms
+
+Linear-Phase Synthesis
+======================
+
+.. autofunction:: synth_cz_depth_line_mr
+.. autofunction:: synth_cx_cz_depth_line_my
+.. autofunction:: synth_cnot_phase_aam
+
+Permutation Synthesis
+=====================
+
+.. autofunction:: synth_permutation_depth_lnn_kms
+.. autofunction:: synth_permutation_basic
+.. autofunction:: synth_permutation_acg
+.. autofunction:: synth_permutation_reverse_lnn_kms
+
+Clifford Synthesis
+==================
+
+.. autofunction:: synth_clifford_full
+.. autofunction:: synth_clifford_ag
+.. autofunction:: synth_clifford_bm
+.. autofunction:: synth_clifford_greedy
+.. autofunction:: synth_clifford_layers
+.. autofunction:: synth_clifford_depth_lnn
+
+CNOTDihedral Synthesis
+======================
+
+.. autofunction:: synth_cnotdihedral_full
+.. autofunction:: synth_cnotdihedral_two_qubits
+.. autofunction:: synth_cnotdihedral_general
+
+Stabilizer State Synthesis
+==========================
+
+.. autofunction:: synth_stabilizer_layers
+.. autofunction:: synth_stabilizer_depth_lnn
+.. autofunction:: synth_circuit_from_stabilizers
+
+Discrete Basis Synthesis
+========================
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   SolovayKitaevDecomposition
+
+.. autofunction:: generate_basic_approximations
+
+Basis Change Synthesis
+======================
+
+.. autofunction:: synth_qft_line
+.. autofunction:: synth_qft_full
+
+Unitary Synthesis
+=================
+
+Decomposition of general :math:`2^n \times 2^n` unitary matrices for any number of qubits.
+
+.. autofunction:: qs_decomposition
+
+The Approximate Quantum Compiler is available as the module :mod:`qiskit.synthesis.unitary.aqc`.
+
+One-Qubit Synthesis
+===================
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   OneQubitEulerDecomposer
+
+Two-Qubit Synthesis
+===================
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   TwoQubitBasisDecomposer
+   XXDecomposer
+   TwoQubitWeylDecomposition
+
+.. autofunction:: two_qubit_cnot_decompose
+
+Multi Controlled Synthesis
+==========================
+
+.. autofunction:: synth_mcx_n_dirty_i15
+.. autofunction:: synth_mcx_n_clean_m15
+.. autofunction:: synth_mcx_1_clean_b95
+.. autofunction:: synth_mcx_noaux_v24
+.. autofunction:: synth_mcx_gray_code
+.. autofunction:: synth_c3x
+.. autofunction:: synth_c4x
+
+"""
+
+from .evolution import (
+    EvolutionSynthesis,
+    ProductFormula,
+    LieTrotter,
+    SuzukiTrotter,
+    MatrixExponential,
+    QDrift,
+)
+
+from .permutation import (
+    synth_permutation_depth_lnn_kms,
+    synth_permutation_basic,
+    synth_permutation_acg,
+    synth_permutation_reverse_lnn_kms,
+)
+from .linear import (
+    synth_cnot_count_full_pmh,
+    synth_cnot_depth_line_kms,
+)
+from .linear_phase import synth_cz_depth_line_mr, synth_cx_cz_depth_line_my, synth_cnot_phase_aam
+from .clifford import (
+    synth_clifford_full,
+    synth_clifford_ag,
+    synth_clifford_bm,
+    synth_clifford_greedy,
+    synth_clifford_layers,
+    synth_clifford_depth_lnn,
+)
+from .cnotdihedral import (
+    synth_cnotdihedral_full,
+    synth_cnotdihedral_two_qubits,
+    synth_cnotdihedral_general,
+)
+from .stabilizer import (
+    synth_stabilizer_layers,
+    synth_stabilizer_depth_lnn,
+    synth_circuit_from_stabilizers,
+)
+from .discrete_basis import SolovayKitaevDecomposition, generate_basic_approximations
+from .qft import synth_qft_line, synth_qft_full
+from .unitary.qsd import qs_decomposition
+from .unitary import aqc
+from .one_qubit import OneQubitEulerDecomposer
+from .two_qubit.xx_decompose import XXDecomposer
+from .two_qubit.two_qubit_decompose import (
+    TwoQubitBasisDecomposer,
+    two_qubit_cnot_decompose,
+    TwoQubitWeylDecomposition,
+)
+from .multi_controlled import (
+    synth_mcx_n_dirty_i15,
+    synth_mcx_n_clean_m15,
+    synth_mcx_1_clean_b95,
+    synth_mcx_noaux_v24,
+    synth_mcx_gray_code,
+    synth_c3x,
+    synth_c4x,
+)

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)