Transpiler Plugins and Utils

IQM Transpiler

class iqm.iqm_transpiler.IQMTranspiler(use_nnizer=True, use_remap=False, nnizer_parameters=None, lazy_synthesis_parameters=None, transpiler_method='PRX', decomposition_type='ZXZ', move_rz_to_end=True)

Bases: AbstractPlugin

Plugin used to perform transpilations of arbitrary input circuits.

Parameters

  • use_nnizer (Optional[bool]) – Choose between Nnizer (True) and LazySynthesis (False) as the topology adaption method, defaults to True

  • use_remap (Optional[bool]) – If set to true, the used qubits of each circuit will be remapped onto an initial segment of integers. Unused qubits are removed from the circuit, defaults to False

  • nnizer_parameters (Optional[dict]) – Set parameters for the Nnizer such as the specific method. Default: {“method”: “atos”}

  • lazy_synthesis_parameters (Optional[dict]) – Set parameters for lazy synthesis such as the search depth. Default: {“depth”: 2}

  • transpiler_method (Optional[str]) – Choose between the PRX, VZ and NISQ transpiler, defaults to ‘PRX’

  • decomposition_type (Optional[str]) – Choose a decomposition type for the KAK compression, defaults to ‘ZXZ’ (VZ transpiler only)

  • move_rz_to_end (Optional[str]) – Choose whether RZ gates should be collected at the end (default) or beginning of the circuit (VZ transpiler only)

Example:

The transpiler plugin can be used to compile a given circuit into a circuit with a desired gateset and to display the transpiled circuit.

from qat.core import Batch
from qat.lang import Program
from qat.lang.AQASM import H, CNOT
from qat.qpus import IQM5SimQPU
from qat.plugins import IQMTranspiler

quantum_program = Program()
qubits = quantum_program.qalloc(2)
quantum_program.apply(H, qubits[0])
quantum_program.apply(CNOT, qubits[0], qubits[1])

circuit = quantum_program.to_circ()
job = circuit.to_job()
qpu = IQM5SimQPU()
hardware_specs = qpu.get_specs()
transpiler = IQMTranspiler()
transpiled_batch = transpiler.compile(Batch(jobs=[job]), hardware_specs)
transpiled_job = transpiled_batch.jobs[0]
transpiled_circuit = transpiled_job.circuit
transpiled_circuit.display()
compile(batch, specs)
Parameters

  • batch (Batch) – A batch of jobs

  • specs (HardwareSpecs) – Hardware specs of the QPU

Return type

Batch

post_process(batch_result)
Parameters

batch_result (BatchResult) – A BatchResult object

Returns

The postprocessed BatchResult

Return type

BatchResult

IQM Observable Splitter

class iqm.iqm_observable_splitter.IQMObservableSplitter(splitting_method='coloring')

Bases: AbstractPlugin

Plugin used to execute arbitrary observable jobs on the IQM QPUs.

Parameters

splitting_method – Specify the splitting algorithm to be used. Defaults to ‘coloring’

Example:

The IQM Observable Splitter can be used to transform an arbitrary observable job to a job that is executable within the restriction given by the IQM QPU.

from qat.lang import Program
from qat.lang.AQASM import CSIGN
from qat.core import Observable, Term
from qat.iqm import PRX
from qat.qpus import IQM5SimQPU
from qat.plugins import IQMObservableSplitter
import numpy as np

quantum_program = Program()
qubits = quantum_program.qalloc(3)
quantum_program.apply(PRX(np.pi/2., -np.pi/2.), qubits[0])
quantum_program.apply(PRX(np.pi/2., -np.pi/2.), qubits[2])
quantum_program.apply(CSIGN, qubits[0], qubits[2])
quantum_program.apply(PRX(np.pi/2., -3.*np.pi/2.), qubits[2])

observable_pauli = Observable(3, pauli_terms=[Term(1., "XXX", [0, 1, 2])])

circuit = quantum_program.to_circ()
job = circuit.to_job(observable=observable_pauli)

stack = IQMObservableSplitter() | IQM5SimQPU()

result = stack.submit(job)
compile(batch, specs)

Compile a batch

Parameters

  • batch (Batch) – A batch of jobs

  • specs (HardwareSpecs) – Hardware specs of the QPU

Return type

Batch

post_process(batch_result)

Post process a result

Utils

iqm.utils.compare_results(result_a, result_b, rtol=1, atol=1e-08)

Compares the state probabilities of two different runs.

Parameters

  • result_a (Result) – Result of the first run

  • result_b (Result) – Result of the second run

Return type

bool

iqm.utils.create_random_circuit(num_gates, num_qubits, use_three_qubit_gates=True)

Creates a random circuit with all available one-, two-, and three-qubit gates within Qaptiva.

Parameters

  • num_gates (int) – The total number of gates that should be included in the random circuit.

  • num_qubits (int) – The total number of qubits that should be included in the random circuit.

  • quantum_program – The quantum program that should be instantiated.

  • use_three_qubit_gates (Optional[bool]) – Use the Toffoli gate as the three-qubit gate within the random circuit, defaults to True

Return type

Program