qat.lang

Programming tools

This module provide tools to create advanced quantum circuit. Designed quantum circuit is detailed in the user guide, section gate-based programming

Gate structures

All classes describing unitary operators inherit from the Gate class.

Quantum types

Managing registers

Gate set management

Linker and low level circuit manipulation

In pyAQASM, gates can be specified using various representations. They can be purely abstract (a name and a set of parameter values, such as RZ, [PI/2]). To this abstract syntax, one can attach a matrix, or even a subcircuit that implements this gate (this is the case of adders of the arithmetic library for instance).

Circuits are generated in two steps:

• first a skeleton of the circuit is generated (for instance adders will be gates called ADD in this skeleton)

• then a subcircuit is generated and attached to this abtract gate.

This second step is handled by a class called Linker. It can be useful in some settings to manipulate this Linker object in order to replace gates by subcircuits, or to generate matrices in order to simulate the circuit.

Quantum labraries and basic algorithms

This module provides a set of routine to simplify the implementation of quantum circuits

Arithmetic routines

pyAQASM comes with a pre-implemented set of arithmetic routines. Since there are different approaches to implement arithmetic routines, we provide various implementation of some low-level routines such as additions and additions by a classical constant. Higher level routines are then implemented by calling some implementation of these lower level routines.

The following diagram sums up the various routines and their implementation. Arrows mean “uses”, green boxes indicates the implementation strategy:

• QFT means QFT-based arithmetic

• CARRY means ripple-carry based arithmetic

• INDEP means agnostic. These routines call lower level routines, indepentently from their implementation.

The routines are separated into three distinct namespaces according to these three types of implementation strategy: QFT, CARRY, INDEP.

Warning

All methods are decorated using @build_gate which turn them into AbstractGates. To access the underlying routine instead of the wrapping gates, the method name can be prefixed with ‘~’.

# will generate a call to an AbstractGate having the QFT as circuit
# implementation
QFT(3)

# will generate a QRoutine object
(~QFT)(3)

The two behaviors are comparable, except that using the U notation allows to skip the inlining step when extracting the circuit (.to_circ method with inline=False) and to link another implementation of gate U later on. Using (~U) will effectively inline the gate no matter what

• qat.lang.AQASM.arithmetic
• qat.lang.AQASM.classarith
• qat.lang.AQASM.qftarith