"""The high-level-synthesis config allows to specify a list of "methods" used by

:class:`~.HighLevelSynthesis` transformation pass to synthesize different types

of higher-level objects.

A higher-level object is an object of type :class:`~.Operation` (e.g., :class:`.Clifford` or

:class:`.LinearFunction`). Each object is referred to by its :attr:`~.Operation.name` field

(e.g., ``"clifford"`` for :class:`.Clifford` objects), and the applicable synthesis methods are

tied to this name.

In the config, each method is specified in one of several ways:

1. a tuple consisting of the name of a known synthesis plugin and a dictionary providing

additional arguments for the algorithm.

2. a tuple consisting of an instance of :class:`.HighLevelSynthesisPlugin` and additional

arguments for the algorithm.

3. a single string of a known synthesis plugin

4. a single instance of :class:`.HighLevelSynthesisPlugin`.

The following example illustrates different ways how a config file can be created::

from qiskit.transpiler.passes.synthesis.high_level_synthesis import HLSConfig

from qiskit.transpiler.passes.synthesis.high_level_synthesis import ACGSynthesisPermutation

# All the ways to specify hls_config are equivalent

hls_config = HLSConfig(permutation=[("acg", {})])

hls_config = HLSConfig(permutation=["acg"])

hls_config = HLSConfig(permutation=[(ACGSynthesisPermutation(), {})])

hls_config = HLSConfig(permutation=[ACGSynthesisPermutation()])

The names of the synthesis plugins should be declared in ``entry-points`` table for

``qiskit.synthesis`` in ``pyproject.toml``, in the form

<higher-level-object-name>.<synthesis-method-name>.

The standard higher-level-objects are recommended to have a synthesis method

called "default", which would be called automatically when synthesizing these objects,

without having to explicitly set these methods in the config.

To avoid synthesizing a given higher-level-object, one can give it an empty list of methods.

For an explicit example of using such config files, refer to the documentation for

:class:`~.HighLevelSynthesis`.

For an overview of the complete process of using high-level synthesis, see

:ref:`using-high-level-synthesis-plugins`.

"""

def __init__(

self,

use_default_on_unspecified: bool = True,

plugin_selection: str = "sequential",

plugin_evaluation_fn: Optional[Callable[[QuantumCircuit], int]] = None,

**kwargs,

):

"""Creates a high-level-synthesis config.

Args:

use_default_on_unspecified: if True, every higher-level-object without an

explicitly specified list of methods will be synthesized using the "default"

algorithm if it exists.

plugin_selection: if set to ``"sequential"`` (default), for every higher-level-object

the synthesis pass will consider the specified methods sequentially, stopping

at the first method that is able to synthesize the object. If set to ``"all"``,

all the specified methods will be considered, and the best synthesized circuit,

according to ``plugin_evaluation_fn`` will be chosen.

plugin_evaluation_fn: a callable that evaluates the quality of the synthesized

quantum circuit; a smaller value means a better circuit. If ``None``, the

quality of the circuit its size (i.e. the number of gates that it contains).

kwargs: a dictionary mapping higher-level-objects to lists of synthesis methods.

"""

self.use_default_on_unspecified = use_default_on_unspecified

self.plugin_selection = plugin_selection

self.plugin_evaluation_fn = (

plugin_evaluation_fn if plugin_evaluation_fn is not None else lambda qc: qc.size()

)

self.methods = {}

for key, value in kwargs.items():

self.set_methods(key, value)

def set_methods(self, hls_name, hls_methods):

"""Sets the list of synthesis methods for a given higher-level-object. This overwrites

the lists of methods if also set previously."""

"""Synthesize higher-level objects and unroll custom definitions.

The input to this pass is a DAG that may contain higher-level objects,

including abstract mathematical objects (e.g., objects of type :class:`.LinearFunction`),

annotated operations (objects of type :class:`.AnnotatedOperation`), and

custom gates.

In the most common use-case when either ``basis_gates`` or ``target`` is specified,

all higher-level objects are synthesized, so the output is a :class:`.DAGCircuit`

without such objects.

More precisely, every gate in the output DAG is either directly supported by the target,

or is in ``equivalence_library``.

The abstract mathematical objects are synthesized using synthesis plugins, applying

synthesis methods specified in the high-level-synthesis config (refer to the documentation

for :class:`~.HLSConfig`).

As an example, let us assume that ``op_a`` and ``op_b`` are names of two higher-level objects,

that ``op_a``-objects have two synthesis methods ``default`` which does require any additional

parameters and ``other`` with two optional integer parameters ``option_1`` and ``option_2``,

that ``op_b``-objects have a single synthesis method ``default``, and ``qc`` is a quantum

circuit containing ``op_a`` and ``op_b`` objects. The following code snippet::

hls_config = HLSConfig(op_b=[("other", {"option_1": 7, "option_2": 4})])

pm = PassManager([HighLevelSynthesis(hls_config=hls_config)])

transpiled_qc = pm.run(qc)

shows how to run the alternative synthesis method ``other`` for ``op_b``-objects, while using the

``default`` methods for all other high-level objects, including ``op_a``-objects.

The annotated operations (consisting of a base operation and a list of inverse, control and power

modifiers) are synthesizing recursively, first synthesizing the base operation, and then applying

synthesis methods for creating inverted, controlled, or powered versions of that).

The custom gates are synthesized by recursively unrolling their definitions, until every gate

is either supported by the target or is in the equivalence library.

When neither ``basis_gates`` nor ``target`` is specified, the pass synthesizes only the top-level

abstract mathematical objects and annotated operations, without descending into the gate

``definitions``. This is consistent with the older behavior of the pass, allowing to synthesize

some higher-level objects using plugins and leaving the other gates untouched.

"""

def __init__(

self,

hls_config: Optional[HLSConfig] = None,

coupling_map: Optional[CouplingMap] = None,

target: Optional[Target] = None,

use_qubit_indices: bool = False,

equivalence_library: Optional[EquivalenceLibrary] = None,

basis_gates: Optional[List[str]] = None,

min_qubits: int = 0,

):

"""

HighLevelSynthesis initializer.

Args:

hls_config: Optional, the high-level-synthesis config that specifies synthesis methods

and parameters for various high-level-objects in the circuit. If it is not specified,

the default synthesis methods and parameters will be used.

coupling_map: Optional, directed graph represented as a coupling map.

target: Optional, the backend target to use for this pass. If it is specified,

it will be used instead of the coupling map.

use_qubit_indices: a flag indicating whether this synthesis pass is running before or after

the layout is set, that is, whether the qubit indices of higher-level-objects correspond

to qubit indices on the target backend.

equivalence_library: The equivalence library used (instructions in this library will not

be unrolled by this pass).

basis_gates: Optional, target basis names to unroll to, e.g. `['u3', 'cx']`.

Ignored if ``target`` is also specified.

min_qubits: The minimum number of qubits for operations in the input

dag to translate.

"""

super().__init__()

if hls_config is not None:

self.hls_config = hls_config

else:

# When the config file is not provided, we will use the "default" method

# to synthesize Operations (when available).

self.hls_config = HLSConfig(True)

self.hls_plugin_manager = HighLevelSynthesisPluginManager()

self._coupling_map = coupling_map

self._target = target

self._use_qubit_indices = use_qubit_indices

if target is not None:

self._coupling_map = self._target.build_coupling_map()

self._equiv_lib = equivalence_library

self._basis_gates = basis_gates

self._min_qubits = min_qubits

self._top_level_only = self._basis_gates is None and self._target is None

# include path for when target exists but target.num_qubits is None (BasicSimulator)

if not self._top_level_only and (self._target is None or self._target.num_qubits is None):

basic_insts = {"measure", "reset", "barrier", "snapshot", "delay", "store"}

self._device_insts = basic_insts | set(self._basis_gates)

def run(self, dag: DAGCircuit) -> DAGCircuit:

"""Run the HighLevelSynthesis pass on `dag`.

Args:

dag: input dag.

Returns:

Output dag with higher-level operations synthesized.

Raises:

TranspilerError: when the transpiler is unable to synthesize the given DAG

(for instance, when the specified synthesis method is not available).

"""

# copy dag_op_nodes because we are modifying the DAG below

dag_op_nodes = dag.op_nodes()

for node in dag_op_nodes:

if isinstance(node.op, ControlFlowOp):

node.op = control_flow.map_blocks(self.run, node.op)

continue

if getattr(node.op, "_directive", False):

continue

if dag.has_calibration_for(node) or len(node.qargs) < self._min_qubits:

continue

qubits = (

[dag.find_bit(x).index for x in node.qargs] if self._use_qubit_indices else None

)

decomposition, modified = self._recursively_handle_op(node.op, qubits)

if not modified:

continue

if isinstance(decomposition, QuantumCircuit):

dag.substitute_node_with_dag(

node, circuit_to_dag(decomposition, copy_operations=False)

)

elif isinstance(decomposition, DAGCircuit):

dag.substitute_node_with_dag(node, decomposition)

elif isinstance(decomposition, Operation):

dag.substitute_node(node, decomposition)

return dag

def _recursively_handle_op(

self, op: Operation, qubits: Optional[List] = None

) -> Tuple[Union[QuantumCircuit, DAGCircuit, Operation], bool]:

"""Recursively synthesizes a single operation.

Note: the reason that this function accepts an operation and not a dag node

is that it's also used for synthesizing the base operation for an annotated

gate (i.e. no dag node is available).

There are several possible results:

- The given operation is unchanged: e.g., it is supported by the target or is

in the equivalence library

- The result is a quantum circuit: e.g., synthesizing Clifford using plugin

- The result is a DAGCircuit: e.g., when unrolling custom gates

- The result is an Operation: e.g., adding control to CXGate results in CCXGate

- The given operation could not be synthesized, raising a transpiler error

The function returns the result of the synthesis (either a quantum circuit or

an Operation), and, as an optimization, a boolean indicating whether

synthesis did anything.

The function is recursive, for example synthesizing an annotated operation

involves synthesizing its "base operation" which might also be

an annotated operation.

"""

# Try to apply plugin mechanism

decomposition = self._synthesize_op_using_plugins(op, qubits)

if decomposition is not None:

return decomposition, True

# Handle annotated operations

decomposition = self._synthesize_annotated_op(op)

if decomposition:

return decomposition, True

# Don't do anything else if processing only top-level

if self._top_level_only:

return op, False

# For non-controlled-gates, check if it's already supported by the target

# or is in equivalence library

controlled_gate_open_ctrl = isinstance(op, ControlledGate) and op._open_ctrl

if not controlled_gate_open_ctrl:

qargs = tuple(qubits) if qubits is not None else None

# include path for when target exists but target.num_qubits is None (BasicSimulator)

inst_supported = (

self._target.instruction_supported(

operation_name=op.name,

qargs=qargs,

)

if self._target is not None and self._target.num_qubits is not None

else op.name in self._device_insts

)

if inst_supported or (self._equiv_lib is not None and self._equiv_lib.has_entry(op)):

return op, False

try:

# extract definition

definition = op.definition

except TypeError as err:

raise TranspilerError(

f"HighLevelSynthesis was unable to extract definition for {op.name}: {err}"

) from err

except AttributeError:

# definition is None

definition = None

if definition is None:

raise TranspilerError(f"HighLevelSynthesis was unable to synthesize {op}.")

dag = circuit_to_dag(definition, copy_operations=False)

dag = self.run(dag)

return dag, True

def _synthesize_op_using_plugins(

self, op: Operation, qubits: List

) -> Union[QuantumCircuit, None]:

"""

Attempts to synthesize op using plugin mechanism.

Returns either the synthesized circuit or None (which occurs when no

synthesis methods are available or specified).

"""

hls_plugin_manager = self.hls_plugin_manager

if op.name in self.hls_config.methods.keys():

# the operation's name appears in the user-provided config,

# we use the list of methods provided by the user

methods = self.hls_config.methods[op.name]

elif (

self.hls_config.use_default_on_unspecified

and "default" in hls_plugin_manager.method_names(op.name)

):

# the operation's name does not appear in the user-specified config,

# we use the "default" method when instructed to do so and the "default"

# method is available

methods = ["default"]

else:

methods = []

best_decomposition = None

best_score = np.inf

for method in methods:

# There are two ways to specify a synthesis method. The more explicit

# way is to specify it as a tuple consisting of a synthesis algorithm and a

# list of additional arguments, e.g.,

# ("kms", {"all_mats": 1, "max_paths": 100, "orig_circuit": 0}), or

# ("pmh", {}).

# When the list of additional arguments is empty, one can also specify

# just the synthesis algorithm, e.g.,

# "pmh".

if isinstance(method, tuple):

plugin_specifier, plugin_args = method

else:

plugin_specifier = method

plugin_args = {}

# There are two ways to specify a synthesis algorithm being run,

# either by name, e.g. "kms" (which then should be specified in entry_points),

# or directly as a class inherited from HighLevelSynthesisPlugin (which then

# does not need to be specified in entry_points).

if isinstance(plugin_specifier, str):

if plugin_specifier not in hls_plugin_manager.method_names(op.name):

raise TranspilerError(

"Specified method: %s not found in available plugins for %s"

% (plugin_specifier, op.name)

)

plugin_method = hls_plugin_manager.method(op.name, plugin_specifier)

else:

plugin_method = plugin_specifier

decomposition = plugin_method.run(

op,

coupling_map=self._coupling_map,

target=self._target,

qubits=qubits,

**plugin_args,

)

# The synthesis methods that are not suited for the given higher-level-object

# will return None.

if decomposition is not None:

if self.hls_config.plugin_selection == "sequential":

# In the "sequential" mode the first successful decomposition is

# returned.

best_decomposition = decomposition

break

# In the "run everything" mode we update the best decomposition

# discovered

current_score = self.hls_config.plugin_evaluation_fn(decomposition)

if current_score < best_score:

best_decomposition = decomposition

best_score = current_score

return best_decomposition

def _synthesize_annotated_op(self, op: Operation) -> Union[Operation, None]:

"""

Recursively synthesizes annotated operations.

Returns either the synthesized operation or None (which occurs when the operation

is not an annotated operation).

"""

if isinstance(op, AnnotatedOperation):

# Recursively handle the base operation

# This results in QuantumCircuit, DAGCircuit or Gate

synthesized_op, _ = self._recursively_handle_op(op.base_op, qubits=None)

if isinstance(synthesized_op, AnnotatedOperation):

raise TranspilerError(

"HighLevelSynthesis failed to synthesize the base operation of"

" an annotated operation."

)

for modifier in op.modifiers:

# If we have a DAGCircuit at this point, convert it to QuantumCircuit

if isinstance(synthesized_op, DAGCircuit):

synthesized_op = dag_to_circuit(synthesized_op, copy_operations=False)

if isinstance(modifier, InverseModifier):

# Both QuantumCircuit and Gate have inverse method

synthesized_op = synthesized_op.inverse()

elif isinstance(modifier, ControlModifier):

# Both QuantumCircuit and Gate have control method, however for circuits

# it is more efficient to avoid constructing the controlled quantum circuit.

if isinstance(synthesized_op, QuantumCircuit):

synthesized_op = synthesized_op.to_gate()

synthesized_op = synthesized_op.control(

num_ctrl_qubits=modifier.num_ctrl_qubits,

label=None,

ctrl_state=modifier.ctrl_state,

annotated=False,

)

if isinstance(synthesized_op, AnnotatedOperation):

raise TranspilerError(

"HighLevelSynthesis failed to synthesize the control modifier."

)

# Unrolling

synthesized_op, _ = self._recursively_handle_op(synthesized_op)

elif isinstance(modifier, PowerModifier):

# QuantumCircuit has power method, and Gate needs to be converted

# to a quantum circuit.

if isinstance(synthesized_op, QuantumCircuit):

qc = synthesized_op

else:

qc = QuantumCircuit(synthesized_op.num_qubits, synthesized_op.num_clbits)

qc.append(

synthesized_op,

range(synthesized_op.num_qubits),

range(synthesized_op.num_clbits),

)

qc = qc.power(modifier.power)

synthesized_op = qc.to_gate()

# Unrolling

synthesized_op, _ = self._recursively_handle_op(synthesized_op)

else:

raise TranspilerError(f"Unknown modifier {modifier}.")

return synthesized_op

"""The default clifford synthesis plugin.

For N <= 3 qubits this is the optimal CX cost decomposition by Bravyi, Maslov.

For N > 3 qubits this is done using the general non-optimal greedy compilation

routine from reference by Bravyi, Hu, Maslov, Shaydulin.

This plugin name is :``clifford.default`` which can be used as the key on

an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.

"""

def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):

"""Run synthesis for the given Clifford."""

decomposition = synth_clifford_full(high_level_object)

"""Clifford synthesis plugin based on the Aaronson-Gottesman method.

This plugin name is :``clifford.ag`` which can be used as the key on

an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.

"""

def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):

"""Run synthesis for the given Clifford."""

decomposition = synth_clifford_ag(high_level_object)

"""Clifford synthesis plugin based on the Bravyi-Maslov method.

The method only works on Cliffords with at most 3 qubits, for which it

constructs the optimal CX cost decomposition.

This plugin name is :``clifford.bm`` which can be used as the key on

an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.

"""

def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):

"""Run synthesis for the given Clifford."""

if high_level_object.num_qubits <= 3:

decomposition = synth_clifford_bm(high_level_object)

else:

decomposition = None

"""Clifford synthesis plugin based on the greedy synthesis

Bravyi-Hu-Maslov-Shaydulin method.

This plugin name is :``clifford.greedy`` which can be used as the key on

an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.

"""

def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):

"""Run synthesis for the given Clifford."""

decomposition = synth_clifford_greedy(high_level_object)

"""Clifford synthesis plugin based on the Bravyi-Maslov method

to synthesize Cliffords into layers.

This plugin name is :``clifford.layers`` which can be used as the key on

an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.

"""

def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):

"""Run synthesis for the given Clifford."""

decomposition = synth_clifford_layers(high_level_object)

"""Clifford synthesis plugin based on the Bravyi-Maslov method

to synthesize Cliffords into layers, with each layer synthesized

adhering to LNN connectivity.

This plugin name is :``clifford.lnn`` which can be used as the key on

an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.

"""

def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):

"""Run synthesis for the given Clifford."""

decomposition = synth_clifford_depth_lnn(high_level_object)

"""The default linear function synthesis plugin.

This plugin name is :``linear_function.default`` which can be used as the key on

an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.

"""

def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):

"""Run synthesis for the given LinearFunction."""

decomposition = synth_cnot_count_full_pmh(high_level_object.linear)

"""Linear function synthesis plugin based on the Kutin-Moulton-Smithline method.

This plugin name is :``linear_function.kms`` which can be used as the key on

an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.

The plugin supports the following plugin-specific options:

* use_inverted: Indicates whether to run the algorithm on the inverse matrix

and to invert the synthesized circuit.

In certain cases this provides a better decomposition than the direct approach.

* use_transposed: Indicates whether to run the algorithm on the transposed matrix

and to invert the order of CX gates in the synthesized circuit.

In certain cases this provides a better decomposition than the direct approach.

"""

def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):

"""Run synthesis for the given LinearFunction."""

if not isinstance(high_level_object, LinearFunction):

raise TranspilerError(

"PMHSynthesisLinearFunction only accepts objects of type LinearFunction"

)

use_inverted = options.get("use_inverted", False)

use_transposed = options.get("use_transposed", False)

mat = high_level_object.linear.astype(int)

if use_transposed:

mat = np.transpose(mat)

if use_inverted:

mat = calc_inverse_matrix(mat)

decomposition = synth_cnot_depth_line_kms(mat)

if use_transposed:

decomposition = transpose_cx_circ(decomposition)

if use_inverted:

decomposition = decomposition.inverse()

"""Linear function synthesis plugin based on the Patel-Markov-Hayes method.

This plugin name is :``linear_function.pmh`` which can be used as the key on

an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.

The plugin supports the following plugin-specific options:

* section size: The size of each section used in the Patel–Markov–Hayes algorithm [1].

* use_inverted: Indicates whether to run the algorithm on the inverse matrix

and to invert the synthesized circuit.

In certain cases this provides a better decomposition than the direct approach.

* use_transposed: Indicates whether to run the algorithm on the transposed matrix

and to invert the order of CX gates in the synthesized circuit.

In certain cases this provides a better decomposition than the direct approach.

References:

1. Patel, Ketan N., Igor L. Markov, and John P. Hayes,

*Optimal synthesis of linear reversible circuits*,

Quantum Information & Computation 8.3 (2008): 282-294.

`arXiv:quant-ph/0302002 [quant-ph] <https://arxiv.org/abs/quant-ph/0302002>`_

"""

def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):

"""Run synthesis for the given LinearFunction."""

if not isinstance(high_level_object, LinearFunction):

raise TranspilerError(

"PMHSynthesisLinearFunction only accepts objects of type LinearFunction"

)

section_size = options.get("section_size", 2)

use_inverted = options.get("use_inverted", False)

use_transposed = options.get("use_transposed", False)

mat = high_level_object.linear.astype(int)

if use_transposed:

mat = np.transpose(mat)

if use_inverted:

mat = calc_inverse_matrix(mat)

decomposition = synth_cnot_count_full_pmh(mat, section_size=section_size)

if use_transposed:

decomposition = transpose_cx_circ(decomposition)

if use_inverted:

decomposition = decomposition.inverse()

"""The permutation synthesis plugin based on the Kutin, Moulton, Smithline method.

This plugin name is :``permutation.kms`` which can be used as the key on

an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.

"""

def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):

"""Run synthesis for the given Permutation."""

decomposition = synth_permutation_depth_lnn_kms(high_level_object.pattern)

"""The permutation synthesis plugin based on sorting.

This plugin name is :``permutation.basic`` which can be used as the key on

an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.

"""

def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):

"""Run synthesis for the given Permutation."""

decomposition = synth_permutation_basic(high_level_object.pattern)

"""The permutation synthesis plugin based on the Alon, Chung, Graham method.

This plugin name is :``permutation.acg`` which can be used as the key on

an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.

"""

def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):

"""Run synthesis for the given Permutation."""

decomposition = synth_permutation_acg(high_level_object.pattern)

"""The permutation synthesis plugin based on the token swapper algorithm.

This plugin name is :``permutation.token_swapper`` which can be used as the key on

an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.

In more detail, this plugin is used to synthesize objects of type `PermutationGate`.

When synthesis succeeds, the plugin outputs a quantum circuit consisting only of swap

gates. When synthesis does not succeed, the plugin outputs `None`.

If either `coupling_map` or `qubits` is None, then the synthesized circuit

is not required to adhere to connectivity constraints, as is the case

when the synthesis is done before layout/routing.

On the other hand, if both `coupling_map` and `qubits` are specified, the synthesized

circuit is supposed to adhere to connectivity constraints. At the moment, the

plugin only creates swap gates between qubits in `qubits`, i.e. it does not use

any other qubits in the coupling map (if such synthesis is not possible, the

plugin outputs `None`).

The plugin supports the following plugin-specific options:

* trials: The number of trials for the token swapper to perform the mapping. The

circuit with the smallest number of SWAPs is returned.

* seed: The argument to the token swapper specifying the seed for random trials.

* parallel_threshold: The argument to the token swapper specifying the number of nodes

in the graph beyond which the algorithm will use parallel processing.

For more details on the token swapper algorithm, see to the paper:

`arXiv:1902.09102 <https://arxiv.org/abs/1902.09102>`__.

"""

def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):

"""Run synthesis for the given Permutation."""

trials = options.get("trials", 5)

seed = options.get("seed", 0)

parallel_threshold = options.get("parallel_threshold", 50)

pattern = high_level_object.pattern

pattern_as_dict = {j: i for i, j in enumerate(pattern)}

# When the plugin is called from the HighLevelSynthesis transpiler pass,

# the coupling map already takes target into account.

if coupling_map is None or qubits is None:

# The abstract synthesis uses a fully connected coupling map, allowing

# arbitrary connections between qubits.

used_coupling_map = CouplingMap.from_full(len(pattern))

else:

# The concrete synthesis uses the coupling map restricted to the set of

# qubits over which the permutation gate is defined. If we allow using other

# qubits in the coupling map, replacing the node in the DAGCircuit that

# defines this PermutationGate by the DAG corresponding to the constructed

# decomposition becomes problematic. Note that we allow the reduced

# coupling map to be disconnected.

used_coupling_map = coupling_map.reduce(qubits, check_if_connected=False)

graph = used_coupling_map.graph.to_undirected()

swapper = ApproximateTokenSwapper(graph, seed=seed)

try:

swapper_result = swapper.map(

pattern_as_dict, trials, parallel_threshold=parallel_threshold

)

except rx.InvalidMapping:

swapper_result = None

if swapper_result is not None:

decomposition = QuantumCircuit(len(graph.node_indices()))

for swap in swapper_result:

decomposition.swap(*swap)

return decomposition