qiskit 1.3.0__cp39-abi3-win32.whl

qiskit/scheduler/methods/basic.py

@@ -0,0 +1,140 @@
+# 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
+from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
+
+
+@deprecate_pulse_dependency(moving_to_dynamics=True)
+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
+
+
+@deprecate_pulse_dependency(moving_to_dynamics=True)
+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,69 @@
+# 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
+from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
+
+
+@deprecate_pulse_dependency(moving_to_dynamics=True)
+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,104 @@
+# 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
+from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
+
+
+@deprecate_pulse_dependency(moving_to_dynamics=True)
+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,220 @@
+# 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_mcmt_vchain
+.. 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
+
+Binary Arithmetic Synthesis
+===========================
+
+Adders
+------
+
+.. autofunction:: adder_qft_d00
+.. autofunction:: adder_ripple_c04
+.. autofunction:: adder_ripple_v95
+
+Multipliers
+-----------
+
+.. autofunction:: multiplier_cumulative_h18 
+.. autofunction:: multiplier_qft_r17
+
+"""
+
+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_mcmt_vchain,
+    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,
+)
+from .arithmetic import (
+    adder_qft_d00,
+    adder_ripple_c04,
+    adder_ripple_v95,
+    multiplier_cumulative_h18,
+    multiplier_qft_r17,
+)

qiskit/synthesis/arithmetic/__init__.py

@@ -0,0 +1,16 @@
+# 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.
+
+"""Module containing multi-controlled circuits synthesis"""
+
+from .adders import adder_qft_d00, adder_ripple_c04, adder_ripple_v95
+from .multipliers import multiplier_cumulative_h18, multiplier_qft_r17

qiskit/synthesis/arithmetic/adders/__init__.py

@@ -0,0 +1,17 @@
+# 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.
+
+"""Module containing multi-controlled circuits synthesis"""
+
+from .cdkm_ripple_carry_adder import adder_ripple_c04
+from .vbe_ripple_carry_adder import adder_ripple_v95
+from .draper_qft_adder import adder_qft_d00