Function

Return n-controlled version of the provided gate.

Example:

C(NOT) | (c, q) # equivalent to CNOT | (c, q)

Start a compute-section.

Example:

Compute(eng, () => {
do_something(qubits)
action(qubits)
})
Uncompute(eng) // runs inverse of the compute section

Warning:
If qubits are allocated within the compute section, they must either be
uncomputed and deallocated within that section or, alternatively,
uncomputed and deallocated in the following uncompute section.

This means that the following examples are valid:

Compute(eng, () => {
anc = eng.allocateQubit()
do_something_with_ancilla(anc)
})
...
uncompute_ancilla(anc)
anc.deallocate()

do_something_else(qubits)

Uncompute(eng)  // will allocate a new ancilla (with a different id)
// and then deallocate it again

Compute(eng, () => {
anc = eng.allocateQubit()
do_something_with_ancilla(anc)
...
})
do_something_else(qubits)

Uncompute(eng)  // will deallocate the ancilla!

After the uncompute section, ancilla qubits allocated within the
compute section will be invalid (and deallocated). The same holds when
using CustomUncompute.

Failure to comply with these rules results in an exception being thrown.

Condition an entire code block on the value of qubits being 1.

Example:

with Control(eng, ctrlqubits)
do_something(otherqubits)
Enter a controlled section.

Control(eng, ctrlqubits, () => ...)

Start a custom uncompute-section.

Throw:

Example:

Compute(eng, () => {
do_something(qubits)
})

action(qubits)

CustomUncompute(eng, () => {
do_something_inverse(qubits)
})

Invert an entire code block.

Use it with a with-statement, i.e.,

Example:

Dagger(eng, () => [code to invert])

Warning:
If the code to invert contains allocation of qubits, those qubits have
to be deleted prior to exiting the 'with Dagger()' context.

This code is **NOT VALID**:

Dagger(eng, () => {
qb = eng.allocateQubit()
H.or(qb) // qb is still available!!!
})
The **correct way** of handling qubit (de-)allocation is as follows:

Dagger(eng, () => {
qb = eng.allocateQubit()
...
qb.deallocate() // sends deallocate gate (which becomes an allocate)
})

Example:

Loop(eng, 4, () => { })
// [quantum gates to be executed 4 times]

Warning:
If the code in the loop contains allocation of qubits, those qubits
have to be deleted prior to exiting the 'Loop()' context.

This code is **NOT VALID**:

Loop(eng, 4, () => {
qb = eng.allocateQubit()
H.or(qb) // qb is still available!!!
})

The **correct way** of handling qubit (de-)allocation is as follows:

Loop(eng, 4, () => {
qb = eng.allocateQubit()
...
qb.deallocate() // sends deallocate gate
})

Subtract a constant from a quantum number represented by a quantum register, stored from low- to high-bit.

Example:

qunum = eng.allocateQureg(5) # 5-qubit number
X | qunum[2] # qunum is now equal to 4
SubConstant(3) | qunum # qunum is now equal to 1

Subtract a constant from a quantum number represented by a quantum register modulo N.

The number is stored from low- to high-bit, i.e., qunum[0] is the LSB.

Example:

qunum = eng.allocateQureg(3) # 3-qubit number
X | qunum[1] # qunum is now equal to 2
SubConstantModN(4,5) | qunum # qunum is now -2 = 6 = 1 (mod 5)

Uncompute automatically.

Example:

Compute(eng, () => {
do_something(qubits)
})
action(qubits)
Uncompute(eng) // runs inverse of the compute section

return class hierachy of cls

Removes an engine from the singly-linked list of engines.

Returns an engine list to compile to a linear chain of qubits.

Note: If you choose a new gate set for which the compiler does not yet have standard rules, it raises an NoGateDecompositionError or a RuntimeError: maximum recursion depth exceeded.... Also note that even the gate sets which work might not yet be optimized. So make sure to double check and potentially extend the decomposition rules. This implemention currently requires that the one qubit gates must contain Rz and at least one of {Ry(best), Rx, H} and the two qubit gate must contain CNOT (recommended) or CZ.

Note: Classical instructions gates such as e.g. Flush and Measure are automatically allowed.

Throw:

Example:

getEngineList(10, false, tuple(Rz, Ry, Rx, H), tuple(CNOT))

Returns an engine list to compile to a restricted gate set.

Note: If you choose a new gate set for which the compiler does not yet have standard rules, it raises an NoGateDecompositionError or a RuntimeError: maximum recursion depth exceeded.... Also note that even the gate sets which work might not yet be optimized. So make sure to double check and potentially extend the decomposition rules. This implemention currently requires that the one qubit gates must contain Rz and at least one of {Ry(best), Rx, H} and the two qubit gate must contain CNOT (recommended) or CZ.

Note: Classical instructions gates such as e.g. Flush and Measure are automatically allowed.

Throw:

Example:

getEngineList(tuple(Rz, Ry, Rx, H), tuple(CNOT), tuple(TimeEvolution))

Returns an engine list to compile to a 2-D grid of qubits.

Note: If you choose a new gate set for which the compiler does not yet have standard rules, it raises an NoGateDecompositionError or a RuntimeError: maximum recursion depth exceeded.... Also note that even the gate sets which work might not yet be optimized. So make sure to double check and potentially extend the decomposition rules. This implemention currently requires that the one qubit gates must contain Rz and at least one of {Ry(best), Rx, H} and the two qubit gate must contain CNOT (recommended) or CZ.

Note: Classical instructions gates such as e.g. Flush and Measure are automatically allowed.

Throw:

Example:

getEngineList(2, 3, tuple(Rz, Ry, Rx, H), tuple(CNOT))

Return the inverse of a gate.

Tries to call gate.getInverse and, upon failure, creates a DaggeredGate instead.

Example:

getInverse(H) // returns a Hadamard gate (HGate object)

Inserts an engine into the singly-linked list of engines. It also sets the correct main_engine for engine_to_insert.

check if inst is instance of cls, specialized for some class

check if cls is kind of superClass, will return true if cls is superClass

check if cls is subclass of superClass, will return false if cls is superClass

return length of v, act like python

create tuple from arguments