qiskit 1.3.0__cp39-abi3-win32.whl

qiskit/transpiler/passes/layout/csp_layout.py

@@ -0,0 +1,132 @@
+# 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.
+
+"""A pass for choosing a Layout of a circuit onto a Coupling graph, as a
+Constraint Satisfaction Problem. It tries to find a solution that fully
+satisfy the circuit, i.e. no further swap is needed. If no solution is
+found, no ``property_set['layout']`` is set.
+"""
+import random
+
+from qiskit.transpiler.layout import Layout
+from qiskit.transpiler.basepasses import AnalysisPass
+from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.utils import optionals as _optionals
+from qiskit.transpiler.target import Target
+
+
+@_optionals.HAS_CONSTRAINT.require_in_instance
+class CSPLayout(AnalysisPass):
+    """If possible, chooses a Layout as a CSP, using backtracking."""
+
+    def __init__(
+        self,
+        coupling_map,
+        strict_direction=False,
+        seed=None,
+        call_limit=1000,
+        time_limit=10,
+    ):
+        """If possible, chooses a Layout as a CSP, using backtracking.
+
+        If not possible, does not set the layout property. In all the cases,
+        the property `CSPLayout_stop_reason` will be added with one of the
+        following values:
+
+        * solution found: If a perfect layout was found.
+        * nonexistent solution: If no perfect layout was found and every combination was checked.
+        * call limit reached: If no perfect layout was found and the call limit was reached.
+        * time limit reached: If no perfect layout was found and the time limit was reached.
+
+        Args:
+            coupling_map (Union[CouplingMap, Target]): Directed graph representing a coupling map.
+            strict_direction (bool): If True, considers the direction of the coupling map.
+                                     Default is False.
+            seed (int): Sets the seed of the PRNG.
+            call_limit (int): Amount of times that
+                ``constraint.RecursiveBacktrackingSolver.recursiveBacktracking`` will be called.
+                None means no call limit. Default: 1000.
+            time_limit (int): Amount of seconds that the pass will try to find a solution.
+                None means no time limit. Default: 10 seconds.
+        """
+        super().__init__()
+        if isinstance(coupling_map, Target):
+            self.target = coupling_map
+            self.coupling_map = self.target.build_coupling_map()
+        else:
+            self.target = None
+            self.coupling_map = coupling_map
+
+        self.strict_direction = strict_direction
+        self.call_limit = call_limit
+        self.time_limit = time_limit
+        self.seed = seed
+
+    def run(self, dag):
+        """run the layout method"""
+        if not self.coupling_map.is_connected():
+            raise TranspilerError(
+                "Coupling Map is disjoint, this pass can't be used with a disconnected coupling "
+                "map."
+            )
+        qubits = dag.qubits
+        cxs = set()
+
+        from constraint import Problem, AllDifferentConstraint, RecursiveBacktrackingSolver
+        from qiskit.transpiler.passes.layout._csp_custom_solver import CustomSolver
+
+        for gate in dag.two_qubit_ops():
+            cxs.add((qubits.index(gate.qargs[0]), qubits.index(gate.qargs[1])))
+        edges = set(self.coupling_map.get_edges())
+
+        if self.time_limit is None and self.call_limit is None:
+            solver = RecursiveBacktrackingSolver()
+        else:
+            solver = CustomSolver(call_limit=self.call_limit, time_limit=self.time_limit)
+
+        variables = list(range(len(qubits)))
+        variable_domains = list(self.coupling_map.physical_qubits)
+        random.Random(self.seed).shuffle(variable_domains)
+
+        problem = Problem(solver)
+        problem.addVariables(variables, variable_domains)
+        problem.addConstraint(AllDifferentConstraint())  # each wire is map to a single qubit
+
+        if self.strict_direction:
+
+            def constraint(control, target):
+                return (control, target) in edges
+
+        else:
+
+            def constraint(control, target):
+                return (control, target) in edges or (target, control) in edges
+
+        for pair in cxs:
+            problem.addConstraint(constraint, [pair[0], pair[1]])
+
+        solution = problem.getSolution()
+
+        if solution is None:
+            stop_reason = "nonexistent solution"
+            if isinstance(solver, CustomSolver):
+                if solver.time_current is not None and solver.time_current >= self.time_limit:
+                    stop_reason = "time limit reached"
+                elif solver.call_current is not None and solver.call_current >= self.call_limit:
+                    stop_reason = "call limit reached"
+        else:
+            stop_reason = "solution found"
+            self.property_set["layout"] = Layout({v: qubits[k] for k, v in solution.items()})
+            for reg in dag.qregs.values():
+                self.property_set["layout"].add_register(reg)
+
+        self.property_set["CSPLayout_stop_reason"] = stop_reason

qiskit/transpiler/passes/layout/dense_layout.py

@@ -0,0 +1,202 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2018.
+#
+# 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.
+
+"""Choose a Layout by finding the most connected subset of qubits."""
+
+
+import numpy as np
+import rustworkx
+
+from qiskit.transpiler.layout import Layout
+from qiskit.transpiler.basepasses import AnalysisPass
+from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.transpiler.passes.layout import disjoint_utils
+
+from qiskit._accelerate.dense_layout import best_subset
+
+
+class DenseLayout(AnalysisPass):
+    """Choose a Layout by finding the most connected subset of qubits.
+
+    This pass associates a physical qubit (int) to each virtual qubit
+    of the circuit (Qubit).
+
+    Note:
+        Even though a ``'layout'`` is not strictly a property of the DAG,
+        in the transpiler architecture it is best passed around between passes
+        by being set in ``property_set``.
+    """
+
+    def __init__(self, coupling_map=None, backend_prop=None, target=None):
+        """DenseLayout initializer.
+
+        Args:
+            coupling_map (Coupling): directed graph representing a coupling map.
+            backend_prop (BackendProperties): backend properties object
+            target (Target): A target representing the target backend.
+        """
+        super().__init__()
+        self.coupling_map = coupling_map
+        self.backend_prop = backend_prop
+        self.target = target
+        self.adjacency_matrix = None
+        if target is not None:
+            self.coupling_map = target.build_coupling_map()
+
+    def run(self, dag):
+        """Run the DenseLayout pass on `dag`.
+
+        Pick a convenient layout depending on the best matching
+        qubit connectivity, and set the property `layout`.
+
+        Args:
+            dag (DAGCircuit): DAG to find layout for.
+
+        Raises:
+            TranspilerError: if dag wider than self.coupling_map
+        """
+        if self.coupling_map is None:
+            raise TranspilerError(
+                "A coupling_map or target with constrained qargs is necessary to run the pass."
+            )
+        layout_components = disjoint_utils.run_pass_over_connected_components(
+            dag,
+            self.coupling_map if self.target is None else self.target,
+            self._inner_run,
+        )
+        layout_mapping = {}
+        for component in layout_components:
+            layout_mapping.update(component)
+        layout = Layout(layout_mapping)
+        for qreg in dag.qregs.values():
+            layout.add_register(qreg)
+        self.property_set["layout"] = layout
+
+    def _inner_run(self, dag, coupling_map):
+        num_dag_qubits = len(dag.qubits)
+        if num_dag_qubits > coupling_map.size():
+            raise TranspilerError("Number of qubits greater than device.")
+        num_cx = 0
+        num_meas = 0
+
+        if self.target is not None:
+            num_cx = 1
+            num_meas = 1
+        else:
+            # Get avg number of cx and meas per qubit
+            ops = dag.count_ops(recurse=True)
+            if "cx" in ops.keys():
+                num_cx = ops["cx"]
+            if "measure" in ops.keys():
+                num_meas = ops["measure"]
+
+        best_sub = self._best_subset(num_dag_qubits, num_meas, num_cx, coupling_map)
+        layout_mapping = {
+            qubit: coupling_map.graph[int(best_sub[i])] for i, qubit in enumerate(dag.qubits)
+        }
+        return layout_mapping
+
+    def _best_subset(self, num_qubits, num_meas, num_cx, coupling_map):
+        """Computes the qubit mapping with the best connectivity.
+
+        Args:
+            num_qubits (int): Number of subset qubits to consider.
+
+        Returns:
+            ndarray: Array of qubits to use for best connectivity mapping.
+        """
+        from scipy.sparse import coo_matrix, csgraph
+
+        if num_qubits == 1:
+            return np.array([0])
+        if num_qubits == 0:
+            return []
+
+        adjacency_matrix = rustworkx.adjacency_matrix(coupling_map.graph)
+        reverse_index_map = {v: k for k, v in enumerate(coupling_map.graph.nodes())}
+
+        error_mat, use_error = _build_error_matrix(
+            coupling_map.size(),
+            reverse_index_map,
+            backend_prop=self.backend_prop,
+            coupling_map=self.coupling_map,
+            target=self.target,
+        )
+
+        rows, cols, best_map = best_subset(
+            num_qubits,
+            adjacency_matrix,
+            num_meas,
+            num_cx,
+            use_error,
+            coupling_map.is_symmetric,
+            error_mat,
+        )
+        data = [1] * len(rows)
+        sp_sub_graph = coo_matrix((data, (rows, cols)), shape=(num_qubits, num_qubits)).tocsr()
+        perm = csgraph.reverse_cuthill_mckee(sp_sub_graph)
+        best_map = best_map[perm]
+        return best_map
+
+
+def _build_error_matrix(num_qubits, qubit_map, target=None, coupling_map=None, backend_prop=None):
+    error_mat = np.zeros((num_qubits, num_qubits))
+    use_error = False
+    if target is not None and target.qargs is not None:
+        for qargs in target.qargs:
+            # Ignore gates over 2q DenseLayout only works with 2q
+            if len(qargs) > 2:
+                continue
+            error = 0.0
+            ops = target.operation_names_for_qargs(qargs)
+            for op in ops:
+                props = target[op].get(qargs, None)
+                if props is not None and props.error is not None:
+                    # Use max error rate to represent operation error
+                    # on a qubit(s). If there is more than 1 operation available
+                    # we don't know what will be used on the qubits eventually
+                    # so we take the highest error operation as a proxy for
+                    # the possible worst case.
+                    error = max(error, props.error)
+            max_error = error
+            if any(qubit not in qubit_map for qubit in qargs):
+                continue
+            # TODO: Factor in T1 and T2 to error matrix after #7736
+            if len(qargs) == 1:
+                qubit = qubit_map[qargs[0]]
+                error_mat[qubit][qubit] = max_error
+                use_error = True
+            elif len(qargs) == 2:
+                error_mat[qubit_map[qargs[0]]][qubit_map[qargs[1]]] = max_error
+                use_error = True
+    elif backend_prop and coupling_map:
+        error_dict = {
+            tuple(gate.qubits): gate.parameters[0].value
+            for gate in backend_prop.gates
+            if len(gate.qubits) == 2
+        }
+        for edge in coupling_map.get_edges():
+            gate_error = error_dict.get(edge)
+            if gate_error is not None:
+                if edge[0] not in qubit_map or edge[1] not in qubit_map:
+                    continue
+                error_mat[qubit_map[edge[0]]][qubit_map[edge[1]]] = gate_error
+                use_error = True
+        for index, qubit_data in enumerate(backend_prop.qubits):
+            if index not in qubit_map:
+                continue
+            for item in qubit_data:
+                if item.name == "readout_error":
+                    mapped_index = qubit_map[index]
+                    error_mat[mapped_index][mapped_index] = item.value
+                    use_error = True
+    return error_mat, use_error

qiskit/transpiler/passes/layout/disjoint_utils.py

@@ -0,0 +1,219 @@
+# 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.
+
+"""This module contains common utils for disjoint coupling maps."""
+from __future__ import annotations
+from collections import defaultdict
+from typing import List, Callable, TypeVar, Dict, Union
+import uuid
+
+import rustworkx as rx
+from qiskit.dagcircuit import DAGOpNode
+
+from qiskit.circuit import Qubit, Barrier, Clbit
+from qiskit.dagcircuit.dagcircuit import DAGCircuit
+from qiskit.dagcircuit.dagnode import DAGOutNode
+from qiskit.transpiler.coupling import CouplingMap
+from qiskit.transpiler.target import Target
+from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.transpiler.passes.layout import vf2_utils
+
+T = TypeVar("T")
+
+
+def run_pass_over_connected_components(
+    dag: DAGCircuit,
+    components_source: Union[Target, CouplingMap],
+    run_func: Callable[[DAGCircuit, CouplingMap], T],
+) -> List[T]:
+    """Run a transpiler pass inner function over mapped components."""
+    if isinstance(components_source, Target):
+        coupling_map = components_source.build_coupling_map(filter_idle_qubits=True)
+    else:
+        coupling_map = components_source
+    cmap_components = coupling_map.connected_components()
+    # If graph is connected we only need to run the pass once
+    if len(cmap_components) == 1:
+        if dag.num_qubits() > cmap_components[0].size():
+            raise TranspilerError(
+                "A connected component of the DAGCircuit is too large for any of the connected "
+                "components in the coupling map."
+            )
+        return [run_func(dag, cmap_components[0])]
+    dag_components = separate_dag(dag)
+    mapped_components = map_components(dag_components, cmap_components)
+    out_component_pairs = []
+    for cmap_index, dags in mapped_components.items():
+        # Take the first dag from the mapped dag components and then
+        # compose it with any other dag components that are operating on the
+        # same coupling map connected component. This results in a subcircuit
+        # of possibly disjoint circuit components which we will run the layout
+        # pass on.
+        out_dag = dag_components[dags.pop()]
+        for dag_index in dags:
+            dag = dag_components[dag_index]
+            out_dag.add_qubits(dag.qubits)
+            out_dag.add_clbits(dag.clbits)
+            for qreg in dag.qregs:
+                out_dag.add_qreg(qreg)
+            for creg in dag.cregs:
+                out_dag.add_creg(creg)
+            out_dag.compose(dag, qubits=dag.qubits, clbits=dag.clbits)
+        out_component_pairs.append((out_dag, cmap_components[cmap_index]))
+    res = [run_func(out_dag, cmap) for out_dag, cmap in out_component_pairs]
+    return res
+
+
+def map_components(
+    dag_components: List[DAGCircuit], cmap_components: List[CouplingMap]
+) -> Dict[int, List[int]]:
+    """Returns a map where the key is the index of each connected component in cmap_components and
+    the value is a list of indices from dag_components which should be placed onto it."""
+    free_qubits = {index: len(cmap.graph) for index, cmap in enumerate(cmap_components)}
+    out_mapping = defaultdict(list)
+
+    for dag_index, dag in sorted(
+        enumerate(dag_components), key=lambda x: x[1].num_qubits(), reverse=True
+    ):
+        for cmap_index in sorted(
+            range(len(cmap_components)), key=lambda index: free_qubits[index], reverse=True
+        ):
+            # TODO: Improve heuristic to involve connectivity and estimate
+            # swap cost
+            if dag.num_qubits() <= free_qubits[cmap_index]:
+                out_mapping[cmap_index].append(dag_index)
+                free_qubits[cmap_index] -= dag.num_qubits()
+                break
+        else:
+            raise TranspilerError(
+                "A connected component of the DAGCircuit is too large for any of the connected "
+                "components in the coupling map."
+            )
+    return out_mapping
+
+
+def split_barriers(dag: DAGCircuit):
+    """Mutate an input dag to split barriers into single qubit barriers."""
+    for node in dag.op_nodes(Barrier):
+        num_qubits = len(node.qargs)
+        if num_qubits == 1:
+            continue
+        if node.label:
+            barrier_uuid = f"{node.op.label}_uuid={uuid.uuid4()}"
+        else:
+            barrier_uuid = f"_none_uuid={uuid.uuid4()}"
+        split_dag = DAGCircuit()
+        split_dag.add_qubits([Qubit() for _ in range(num_qubits)])
+        for i in range(num_qubits):
+            split_dag.apply_operation_back(
+                Barrier(1, label=barrier_uuid),
+                qargs=(split_dag.qubits[i],),
+                check=False,
+            )
+        dag.substitute_node_with_dag(node, split_dag)
+
+
+def combine_barriers(dag: DAGCircuit, retain_uuid: bool = True):
+    """Mutate input dag to combine barriers with UUID labels into a single barrier."""
+    qubit_indices = {bit: index for index, bit in enumerate(dag.qubits)}
+    uuid_map: dict[str, DAGOpNode] = {}
+    for node in dag.op_nodes(Barrier):
+        if node.label:
+            if "_uuid=" in node.label:
+                barrier_uuid = node.label
+            else:
+                continue
+            if barrier_uuid in uuid_map:
+                other_node = uuid_map[barrier_uuid]
+                num_qubits = len(other_node.qargs) + len(node.qargs)
+                if not retain_uuid:
+                    if isinstance(node.label, str) and node.label.startswith("_none_uuid="):
+                        label = None
+                    elif isinstance(node.label, str) and "_uuid=" in node.label:
+                        label = "_uuid=".join(node.label.split("_uuid=")[:-1])
+                    else:
+                        label = barrier_uuid
+                else:
+                    label = barrier_uuid
+                new_op = Barrier(num_qubits, label=label)
+                new_node = dag.replace_block_with_op([node, other_node], new_op, qubit_indices)
+                uuid_map[barrier_uuid] = new_node
+            else:
+                uuid_map[barrier_uuid] = node
+
+
+def require_layout_isolated_to_component(
+    dag: DAGCircuit, components_source: Union[Target, CouplingMap]
+):
+    """
+    Check that the layout of the dag does not require connectivity across connected components
+    in the CouplingMap
+
+    Args:
+        dag: DAGCircuit to check.
+        components_source: Target to check against.
+
+    Raises:
+        TranspilerError: Chosen layout is not valid for the target disjoint connectivity.
+    """
+    if isinstance(components_source, Target):
+        coupling_map = components_source.build_coupling_map(filter_idle_qubits=True)
+    else:
+        coupling_map = components_source
+    component_sets = [set(x.graph.nodes()) for x in coupling_map.connected_components()]
+    for inst in dag.two_qubit_ops():
+        component_index = None
+        for i, component_set in enumerate(component_sets):
+            if dag.find_bit(inst.qargs[0]).index in component_set:
+                component_index = i
+                break
+        if dag.find_bit(inst.qargs[1]).index not in component_sets[component_index]:
+            raise TranspilerError(
+                "The circuit has an invalid layout as two qubits need to interact in disconnected "
+                "components of the coupling map. The physical qubit "
+                f"{dag.find_bit(inst.qargs[1]).index} needs to interact with the "
+                f"qubit {dag.find_bit(inst.qargs[0]).index} and they belong to different components"
+            )
+
+
+def separate_dag(dag: DAGCircuit) -> List[DAGCircuit]:
+    """Separate a dag circuit into it's connected components."""
+    # Split barriers into single qubit barriers before splitting connected components
+    split_barriers(dag)
+    im_graph, _, qubit_map, __ = vf2_utils.build_interaction_graph(dag)
+    connected_components = rx.weakly_connected_components(im_graph)
+    component_qubits = []
+    for component in connected_components:
+        component_qubits.append({qubit_map[x] for x in component})
+
+    qubits = set(dag.qubits)
+
+    decomposed_dags = []
+    for dag_qubits in component_qubits:
+        new_dag = dag.copy_empty_like()
+        new_dag.remove_qubits(*qubits - dag_qubits)
+        new_dag.global_phase = 0
+        for node in dag.topological_op_nodes():
+            if dag_qubits.issuperset(node.qargs):
+                new_dag.apply_operation_back(node.op, node.qargs, node.cargs, check=False)
+        idle_clbits = []
+        for bit, node in new_dag.input_map.items():
+            succ_node = next(new_dag.successors(node))
+            if isinstance(succ_node, DAGOutNode) and isinstance(succ_node.wire, Clbit):
+                idle_clbits.append(bit)
+        new_dag.remove_clbits(*idle_clbits)
+        combine_barriers(new_dag)
+        decomposed_dags.append(new_dag)
+    # Reverse split barriers on input dag to avoid leaking out internal transformations as
+    # part of splitting
+    combine_barriers(dag, retain_uuid=False)
+    return decomposed_dags

qiskit/transpiler/passes/layout/enlarge_with_ancilla.py

@@ -0,0 +1,49 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 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.
+
+"""Extend the dag with virtual qubits that are in layout but not in the circuit yet."""
+
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.exceptions import TranspilerError
+
+
+class EnlargeWithAncilla(TransformationPass):
+    """Extend the dag with virtual qubits that are in layout but not in the circuit yet.
+
+    Extend the DAG circuit with new virtual qubits (ancilla) that are specified
+    in the layout, but not present in the circuit. Which qubits to add are
+    previously allocated in the ``layout`` property, by a previous pass.
+    """
+
+    def run(self, dag):
+        """Run the EnlargeWithAncilla pass on `dag`.
+
+        Args:
+            dag (DAGCircuit): DAG to extend.
+
+        Returns:
+            DAGCircuit: An extended DAG.
+
+        Raises:
+            TranspilerError: If there is no layout in the property set or not set at init time.
+        """
+        layout = self.property_set["layout"]
+
+        if layout is None:
+            raise TranspilerError('EnlargeWithAncilla requires property_set["layout"]')
+
+        new_qregs = {reg for reg in layout.get_registers() if reg not in dag.qregs.values()}
+
+        for qreg in new_qregs:
+            dag.add_qreg(qreg)
+
+        return dag