pyQuil Documentation

A sentinel-based loop repeats a program body until a specific condition (the sentinel) is met. This is useful for probabilistic algorithms where you want to repeat an attempt until a desired outcome is achieved.

Pattern for implementation:

1. Define the Body: The quantum circuit you want to repeat.
2. Define Reset Logic: A program to reset qubits to a known state if the outcome was unsuccessful.
3. Define the Sentinel Condition: Use if_then to check the measurement. If the condition is met (e.g., result is 1), execute the reset and a Jump back to a Label at the start of the loop. If the condition is not met (e.g., result is 0), execute a Halt instruction to end the program.
4. Compose: Use pyquil.quilbase.Label and pyquil.quilbase.Jump to create the loop structure manually, or use if_then to manage the branches.

from pyquil import Program, get_qc
from pyquil.gates import CNOT, H, X
from pyquil.quilbase import Halt, Qubit, MemoryReference, JumpTarget, Jump
from pyquil.quilatom import Label

def sentinel_program(qubits: Tuple[Qubit, Qubit]) -> Program:
    start_label = Label("start-loop")
    program = Program(JumpTarget(start_label))
    measures = program.declare("measures", "BIT", 2)

    # Add body
    program += body(qubits, measures)
    
    # Define reset and jump back
    reset = Program(
        reset_bell_state(qubits, measures),
        Jump(start_label)
    )
    
    # Enforce sentinel: if measures[0] is 1, run reset; else Halt
    program += enforce_sentinel(measures[0], reset)
    
    program.resolve_label_placeholders()
    return program

When a Quil program contains multi-qubit instructions that do not match the physical connectivity (topology) of the target device, the compiler performs rewiring to rearrange qubits so execution is possible.

Rewiring Comments

To assist with debugging, the compiler inserts human-readable comments in the raw Quil code:

• # Entering rewiring
• # Exiting rewiring: #(n0 n1 ... nk) (where nj is the physical qubit assigned to logical qubit j). Note: These comments are for human readability and are discarded during execution.

SWAP Gates

If the compiler cannot avoid it, it will insert SWAP gates to move qubits closer.

• Virtual Swaps: If swaps are required at the very beginning of a program, the compiler can treat them as 'virtual'. These do not appear as gates in the final program but instead influence the initial qubit rewiring, preventing gate inflation.
• Real Swaps: For complex programs with high entanglement, real SWAP gates may be inserted, increasing the gate depth.
• Cost: A SWAP typically costs three CZ or three XY gates. If the device supports both CZ and XY gates, the compiler can optimize a SWAP to use only two gates (one CZ and one XY).

Amplitude damping models the decay of a qubit from state $|1\rangle$ to $|0\rangle$ with probability $p$. The noise channel is parameterized by a list of Kraus operators:

$K_1 = \begin{pmatrix} 1 & 0 \ 0 & \sqrt{1-p} \end{pmatrix}$ $K_2 = \begin{pmatrix} 0 & \sqrt{p} \ 0 & 0 \end{pmatrix}$

In PyQuil simulations, you can generate these operators manually to pass to define_noisy_gate.

import numpy as np

def damping_channel(damp_prob=.1):
    """
    Generate the Kraus operators corresponding to an amplitude damping
    noise channel.

    :params float damp_prob: The one-step damping probability.
    :return: A list [k1, k2] of the Kraus operators that parametrize the map.
    :rtype: list
    """
    damping_op = np.sqrt(damp_prob) * np.array([[0, 1],
                                                [0, 0]])

    residual_kraus = np.diag([1, np.sqrt(1-damp_prob)])
    return [residual_kraus, damping_op]

Dephasing (characterized by $T_2$ time) is a diagonal error channel. For a single qubit, the Kraus operators are:

$K_1(p) = \sqrt{1-p} I_2$ $K_2(p) = \sqrt{p} \sigma_Z$

where $p$ is the dephasing probability. For multi-qubit gates, you can construct a composite Kraus map by taking the tensor product of individual qubit Kraus maps.

import numpy as np

def dephasing_kraus_map(p=.1):
    """
    Generate the Kraus operators corresponding to a dephasing channel.

    :params float p: The one-step dephasing probability.
    :return: A list [k1, k2] of the Kraus operators that parametrize the map.
    :rtype: list
    """
    return [np.sqrt(1-p)*np.eye(2), np.sqrt(p)*np.diag([1, -1])]

def tensor_kraus_maps(k1, k2):
    """
    Generate the Kraus map corresponding to the composition
    of two maps on different qubits.

    :param list k1: The Kraus operators for the first qubit.
    :param list k2: The Kraus operators for the second qubit.
    :return: A list of tensored Kraus operators.
    """
    return [np.kron(k1j, k2l) for k1j in k1 for k2l in k2]