Expression system

Qadence 2 Expression system is designed to create expressive, self-contained and abstract symbolic expressions to represent quantum programs in the digital-analog paradigm. These expressions can be transpiled later with concretized and specific data types, such as numpy, pytorch and jax for execution on targeted backends.

The Expression system defines syntactic rules to generate symbolic quantum expressions, that can contain parametric expressions for parameters (static, FeatureParameter) and variables (dynamic, VariationalParameter) to be used for training purposes. Expression composition can be seamlessly applied to quantum operators for digital, analog and digital-analog computations. It also supports arithmetic operations for both classical and quantum expressions as well as reduction, simplification and replacement methods.

Symbolic manipulation

In these examples, basic arithmetic expressions on symbols (parameters) are evaluated to illustrate simplifications and reductions.

from qadence2_expressions import *

a = parameter('a')
b = parameter('b')

a + a → 2.0 * a
a - a → 0.0
a / a → 1.0
a + b → a + b
a / (2*b) → a * (2.0 * b) ^ -1.0
a ** 0 → 1.0
a ** 1 → a
2 ** (a + b' → 2.0 ^ (a + b)

Products of sums are expanded

(a + b) * (a + b)

→ a ^ 2.0 + 2.0 * a * b + b ^ 2.0

But exponentiations of sums are not as power simplifications take precedence.

(a + b) * (a + b) ** 2 / (a + b)

→ (a + b) ^ 2.0

Quantum operators

Standard quantum operators are defined as Python Callable that accept a qubit support as argument. Please note that the support can either be a single int for single qubit operations or a tuple of qubit indices for operations that span across multiple qubits or nothing to create global operations that span across the whole register (denoted by the * wildcard).

X(2) * Y() * Z(1,2)

→ X[2] * Y[*] * Z[1,2]

(Multi-)Controlled operators need to be provided with non-overlapping tuples for control and target qubits. The notation convention is to display target indices first followed by control indices in increasing ordering.

NOT(control=(1,), target=(2,)) * NOT(target=(1,3), control=(2,4))

→ NOT[2|1] * NOT[1,3|2,4]

Quantum operators can be parametrized and expressions expanded.

X() * (cos(a) * X() + 1j * sin(a) * Y()) / 2

→ 0.5 * cos(a) + 0.5j * sin(a) * X[*] * Y[*]

Global and local operators can be combined.

X(1) * (cos(a) * X() + 1j * sin(a) * Y()) * Z(1) / 2

→ 0.5 * cos(a) * X[1] * X[*] * Z[1] + 0.5j * sin(a) * X[1] * Y[*] * Z[1]

Custom operators can be created as functions or based on other operators. For instance, the CNOT:

CNOT = lambda ctrl, tgt: NOT(target=(tgt,), control=(ctrl,))
Y(4) * X(3) * Y(5,4) * CNOT(1,2) * Z(3)

→ NOT[2|1] * X[3] * Z[3] * Y[4] * Y[4,5]

Or the number operator. Expansion rules still hold.

N = lambda k: (1 - Z(k)) / 2

sum(a * X(i) - b * Z(i) + N(i) * N(i + 1) for i in range(1))

→ 0.25 + a * X[0] - b * Z[0] - 0.25 * Z[1] - 0.25 * Z[0] + 0.25 * Z[0] * Z[1]

Parametric operators need to get passed a parameter as first argument, then the qubit support. This ensures syntactic consistency across operators. Unitarity still holds.

phi = variable("phi")

RX(phi / 2)(1) * RX(phi / 2)(1).dag

→ 1.0

Arithmetic operations still hold for operator parameters defined over the same support.

RX(phi / 2)(1) * RX(- phi / 2)(1)

→ 1.0

As opposed to:

RX(phi / 2)(1) * RX(phi / 2)(2).dag

→ RX(0.5 * phi)[1] * RX(0.5 * phi)†[2]