qat.plugins.PatternManager

This plugin can compile or optimize quantum circuits by replacing a subcircuit by an equivalent subcircuit. This plugin needs to be configured to perform the right changes in the circuit. A dedicated section in the user guide explains how to configure this plugin.

class qat.plugins.PatternManager(*args, **kwargs)

Defines an instance of Pattern Manager. A PatternManager will update any circuit to maximize a metric.

A local_metric will be used to calculate the local score of any pattern. The first step of this manager is to replace a pattern by an equivalent pattern having a strict better local score.

Then, if some patterns have the same best local score, a global_metric will be used to select the pattern which maximize the global score of the circuit

Warning

This plugin can compile jobs having less than 20 qubits. To compile bigger jobs, please use the equivalent Qaptiva plugin.

Parameters:

  • local_metric (fun<Circuit -> float>, optional) – local metric

  • global_metric (fun<Circuit -> float>, optional) – global metric

  • groups (list<PatternGroup>, optional) – list of groups to link to this pattern manager

  • collections (list<collections>, optional) – list of collections to link to this pattern manager. A collection is a list of PatternGroup

  • gate_set (GateSet, optional) – Gate set used to cast GraphCircuit objects used internally into Circuit objects

add_abstract_gate(abstract_gate, constructor=None)

Internally, the PatternManager does not manipulate Circuit objects. During the optimization, the PatternManager must be able to cast data structures used internally into Circuit (to compute metrics or to return a Circuit at the end of the optimization).

This method is used to define gates that are not part of the default gate set (to use these gates in some patterns):

from qat.lang.AQASM import AbstractGate
from qat.pbo import PatternManager

# Define an abstract gate
my_gate = AbstractGate("MY_GATE", [], 1)

# Define a manager
manager = PatternManager()
manager.add_abstract_gate(my_gate)
print("The gate 'MY_GATE' can now be used in patterns of 'manager'")

The gate 'MY_GATE' can now be used in patterns of 'manager'

Note

The constructor of PatternManager accepts a GateSet in argument. Passing a gate set in argument or adding abstract gates one by one are equivalent

Parameters:

abstract_gate (AbstractGate) – abstract gate

compile(batch, specs)

Compile a Batch. This method will call the method replace_pattern() to optimize each job composing the batch (to override the default arguments of this method, please refer to set_compile_attributes())

Parameters:

  • batch (Batch) – batch to optimize

  • specs (HardwareSpecs) – specs of the QPU that this plugin will optimize for

Returns:

optimized batch

Return type:

Batch

new_group()

Return a PatternGroup linked to this PatternManager. A group is a set of equivalent patterns. Created groups are used to perform local changes in circuits to optimize them. Please refer the method replace_pattern() for further information.

from qat.pbo import PatternManager

manager = PatternManager()

# Define a a group of equivalent patterns
group = manager.new_group()
group.add_pattern([("SWAP", {0, 1})])
group.add_pattern([("CNOT", [0, 1]), ("CNOT", [1, 0]), ("CNOT", [0, 1])])
Returns:

PatternGroup

replace_pattern(circ, method='gradient', window_size=1, max_iterations=250, temperature=1000, trace=None)

Replace some patterns in a circuit by an equivalent one with to improve the circuit

Parameters:

  • circ (qat.core.Circuit or qat.pbo.GraphCircuit)

  • method (str, optional) –

    heuristic used to optimize globally. Two heuristics are implemented:

    • ”gradient” (default) -> Gradient Descent

    • ”annealing” -> Simulated annealing

  • window_size (int, optional) – size of the window for the global optimization - used if method == "gradient" (Default value: 1)

  • max_iterations (int, optional) – maximum number of iteration for the global optimization - used if method == "annealing" (Default value: 250)

  • temperature (int, optional) – temperature of the simulated annealing - used if method == "annealing" (Default value: 1000)

  • trace (list, optional) – if a list is given, values of the metric will be inserted at each step

Returns:

Resulting circuit. The result is either a qat.core.Circuit or None

  • If a circuit was given in argument: the result is an optimized equivalent circuit

  • If a graph was given in argument: the optimal circuit is contained in the GraphCircuit object given in argument

Return type:

Circuit or None

set_compile_attributes(**kwargs)

The compile() method will call the method replace_pattern() to optimize each job composing the batch. This method will override the default arguments used by the method replace_pattern().

from qat.plugins import PatternManager

manager = PatternManager()
manager.set_compile_attributes(method="annealing")
print("The 'compile' method will use the 'annealing' method to optimize "
      "the batches")

The 'compile' method will use the 'annealing' method to optimize the batches

Note

Parameters used for the optimization could be overrided for a specific batch, by updating the meta-data of this batch

from json import dumps as json_dumps
from qat.core import Batch

# Define a batch
batch = Batch(jobs=[...])

# Define the options to optimize this batch
options = dict(method="gradient", window_size=2)
batch.meta_data = {"PatternManager": json_dumps(options)}
Keyword Arguments:

  • method (str, optional) – optimization method (cf. replace_pattern() for more information)

  • window_size (int, optional) – size of windows used during optimization (cf. replace_pattern() for more information)

  • max_iterations (int, optional) – maximal number of iteration (cf. replace_pattern() for more information)

  • temparature (int, optional) – temperature used for the simulated annealing (cf. replace_pattern() for more information)