pyquil.quilbase module¶

Contains the core pyQuil objects that correspond to Quil instructions.

class pyquil.quilbase.AbstractInstruction[source]¶

Bases: object

Abstract class for representing single instructions.

class pyquil.quilbase.ArithmeticBinaryOp(left: MemoryReference, right: MemoryReference | int | float)[source]¶

Bases: Arithmetic, AbstractInstruction

Base class for binary arithmetic classical instructions.

Initialize the operands of the binary arithmetic instruction.

property left: MemoryReference¶: The left hand side of the binary expression.

op: ClassVar[ArithmeticOperator]¶

out() → str[source]¶: Return the instruction as a valid Quil string. Raises an error if the instruction contains placeholders.

property right: MemoryReference | int | float¶: The left hand side of the binary expression.

class pyquil.quilbase.Call(name, arguments)[source]¶

Bases: Call, AbstractInstruction

An instruction that calls an external function declared with a PRAGMA EXTERN instruction.

These calls are generally specific to a particular hardware or virtual machine backend. For further detail, see: * Other instructions and Directives

in the Quil specification.

out() → str[source]¶: Return the instruction as a valid Quil string.

class pyquil.quilbase.Capture(frame: Frame, kernel: WaveformReference | TemplateWaveform, memory_region: MemoryReference, nonblocking: bool = False)[source]¶

Bases: Capture, AbstractInstruction

The CAPTURE instruction.

Initialize a new CAPTURE instruction.

property frame: Frame¶: Get the frame this instruction captures.

get_qubit_indices() → set[int][source]¶: Get the qubits the capture instruction operates on, as integer indices.

get_qubits(indices: bool = True) → set[Qubit | QubitPlaceholder | FormalArgument | int] | set[int][source]¶: Get the qubits the capture instruction operates on.

Deprecated since version 4.0: The indices flag will be removed, use get_qubit_indices() instead.

property kernel: WaveformReference | TemplateWaveform¶: Get the kernel waveform.

property memory_region: MemoryReference¶: Get the memory reference that the capture is written to.

property nonblocking: bool¶: Whether the capture is non-blocking.

out() → str[source]¶: Return the instruction as a valid Quil string.

class pyquil.quilbase.ClassicalAdd(left: MemoryReference, right: MemoryReference | int | float)[source]¶

Bases: ArithmeticBinaryOp

The ADD instruction.

Initialize the operands of the binary arithmetic instruction.

op: ClassVar[ArithmeticOperator] = Add¶

class pyquil.quilbase.ClassicalAnd(left: MemoryReference, right: MemoryReference | int)[source]¶

Bases: LogicalBinaryOp

The AND instruction.

Initialize the operands of the binary logical instruction.

op: ClassVar[BinaryOperator] = And¶

class pyquil.quilbase.ClassicalComparison(target: MemoryReference, left: MemoryReference, right: MemoryReference | int | float)[source]¶

Bases: Comparison, AbstractInstruction

Base class for ternary comparison instructions.

Initialize a new comparison instruction.

property left: MemoryReference¶: The left hand side of the comparison.

op: ClassVar[ComparisonOperator]¶

out() → str[source]¶: Return the instruction as a valid Quil string.

property right: MemoryReference | int | float¶: The right hand side of the comparison.

property target: MemoryReference¶: The target of the comparison.

class pyquil.quilbase.ClassicalConvert(left: MemoryReference, right: MemoryReference)[source]¶

Bases: Convert, AbstractInstruction

The CONVERT instruction.

Initialize a new CONVERT instruction.

property left: MemoryReference¶: Return the left hand side (or “destination”) of the conversion instruction.

out() → str[source]¶: Return the instruction as a valid Quil string.

property right: MemoryReference¶: Return the right hand side (or “source”) of the conversion instruction.

class pyquil.quilbase.ClassicalDiv(left: MemoryReference, right: MemoryReference | int | float)[source]¶

Bases: ArithmeticBinaryOp

The DIV instruction.

Initialize the operands of the binary arithmetic instruction.

op: ClassVar[ArithmeticOperator] = Divide¶

class pyquil.quilbase.ClassicalEqual(target: MemoryReference, left: MemoryReference, right: MemoryReference | int | float)[source]¶

Bases: ClassicalComparison

The EQ comparison instruction.

Initialize a new comparison instruction.

op: ClassVar[ComparisonOperator] = ComparisonOperator.Equal¶

class pyquil.quilbase.ClassicalExchange(left: MemoryReference, right: MemoryReference)[source]¶

Bases: Exchange, AbstractInstruction

The EXCHANGE instruction.

Initialize a new EXCHANGE instruction.

property left: MemoryReference¶: The left hand side of the exchange instruction.

out() → str[source]¶: Return the instruction as a valid Quil string.

property right: MemoryReference¶: The left hand side of the exchange instruction.

class pyquil.quilbase.ClassicalExclusiveOr(left: MemoryReference, right: MemoryReference | int)[source]¶

Bases: LogicalBinaryOp

The XOR instruction.

Initialize the operands of the binary logical instruction.

op: ClassVar[BinaryOperator] = Xor¶

class pyquil.quilbase.ClassicalGreaterEqual(target: MemoryReference, left: MemoryReference, right: MemoryReference | int | float)[source]¶

Bases: ClassicalComparison

The GE comparison instruction.

Initialize a new comparison instruction.

op: ClassVar[ComparisonOperator] = ComparisonOperator.GreaterThanOrEqual¶

class pyquil.quilbase.ClassicalGreaterThan(target: MemoryReference, left: MemoryReference, right: MemoryReference | int | float)[source]¶

Bases: ClassicalComparison

The GT comparison instruction.

Initialize a new comparison instruction.

op: ClassVar[ComparisonOperator] = ComparisonOperator.GreaterThan¶

class pyquil.quilbase.ClassicalInclusiveOr(left: MemoryReference, right: MemoryReference | int)[source]¶

Bases: LogicalBinaryOp

The IOR instruction.

Initialize the operands of the binary logical instruction.

op: ClassVar[BinaryOperator] = Ior¶

class pyquil.quilbase.ClassicalLessEqual(target: MemoryReference, left: MemoryReference, right: MemoryReference | int | float)[source]¶

Bases: ClassicalComparison

The LE comparison instruction.

Initialize a new comparison instruction.

op: ClassVar[ComparisonOperator] = ComparisonOperator.LessThanOrEqual¶

class pyquil.quilbase.ClassicalLessThan(target: MemoryReference, left: MemoryReference, right: MemoryReference | int | float)[source]¶

Bases: ClassicalComparison

The LT comparison instruction.

Initialize a new comparison instruction.

op: ClassVar[ComparisonOperator] = ComparisonOperator.LessThan¶

class pyquil.quilbase.ClassicalLoad(target: MemoryReference, left: str, right: MemoryReference)[source]¶

Bases: Load, AbstractInstruction

The LOAD instruction.

Initialize a new LOAD instruction.

property left: str¶: The left hand side of the LOAD instruction.

out() → str[source]¶: Return the instruction as a valid Quil string.

property right: MemoryReference¶: The right hand side of the LOAD instruction.

property target: MemoryReference¶: The MemoryReference that the instruction loads into.

class pyquil.quilbase.ClassicalMove(left: MemoryReference, right: MemoryReference | int | float)[source]¶

Bases: Move, AbstractInstruction

The MOVE instruction.

Initialize a new MOVE instruction.

property left: MemoryReference¶: The left hand side (or “destination”) of the move instruction.

out() → str[source]¶: Return the move instruction as a valid Quil string.

property right: MemoryReference | int | float¶: The right hand side (or “source”) of the move instruction.

class pyquil.quilbase.ClassicalMul(left: MemoryReference, right: MemoryReference | int | float)[source]¶

Bases: ArithmeticBinaryOp

The MUL instruction.

Initialize the operands of the binary arithmetic instruction.

op: ClassVar[ArithmeticOperator] = Multiply¶

class pyquil.quilbase.ClassicalNeg(target: MemoryReference)[source]¶

Bases: UnaryClassicalInstruction

The NEG instruction.

Initialize a new unary classical instruction.

op: ClassVar[UnaryOperator] = Neg¶

class pyquil.quilbase.ClassicalNot(target: MemoryReference)[source]¶

Bases: UnaryClassicalInstruction

The NOT instruction.

Initialize a new unary classical instruction.

op: ClassVar[UnaryOperator] = Not¶

class pyquil.quilbase.ClassicalStore(target: str, left: MemoryReference, right: MemoryReference | int | float)[source]¶

Bases: Store, AbstractInstruction

The STORE instruction.

Initialize a new STORE instruction.

property left: MemoryReference¶: The left hand side of the STORE instruction.

out() → str[source]¶: Return a valid Quil string representation of the instruction.

property right: MemoryReference | int | float¶: The left hand side of the STORE instruction.

property target: str¶: The target of the STORE instruction.

class pyquil.quilbase.ClassicalSub(left: MemoryReference, right: MemoryReference | int | float)[source]¶

Bases: ArithmeticBinaryOp

The SUB instruction.

Initialize the operands of the binary arithmetic instruction.

op: ClassVar[ArithmeticOperator] = Subtract¶

class pyquil.quilbase.Declare(name: str, memory_type: str, memory_size: int = 1, shared_region: str | None = None, offsets: Sequence[tuple[int, str]] | None = None)[source]¶

Bases: Declaration, AbstractInstruction

A DECLARE directive.

This is printed in Quil as:

DECLARE <name> <memory-type> (SHARING <other-name> (OFFSET <amount> <type>)* )?

Initialize a new DECLARE directive.

asdict() → dict[str, Sequence[tuple[int, str]] | str | None | int][source]¶: Get the DECLARE directive as a dictionary.

property memory_size: int¶: Get the number of elements being declared.

property memory_type: str¶: Get the type of memory being declared.

property offsets: list[tuple[int, str]]¶: Get the offsets for this declaration.

out() → str[source]¶: Return the instruction as a valid Quil string.

property shared_region: str | None¶: Get the memory region this declaration is sharing with, if any.

Bases: Calibration, AbstractInstruction

A calibration definition.

Initialize a new calibration definition.

property instrs: list[AbstractInstruction]¶: The instructions in the calibration.

property instructions: list[AbstractInstruction]¶: The instructions in the calibration.

property name: str¶: Get the name of the calibration.

out() → str[source]¶: Return the instruction as a valid Quil string.

property parameters: Sequence[Expression | MemoryReference | int | float | complex | number]¶: The parameters of the calibration.

property qubits: list[Qubit | QubitPlaceholder | FormalArgument | int]¶: The qubits the calibration operates on.

class pyquil.quilbase.DefCircuit(name: str, parameters: list[Parameter], qubits: list[FormalArgument], instructions: list[AbstractInstruction])[source]¶

Bases: CircuitDefinition, AbstractInstruction

A circuit definition.

Initialize a new circuit definition.

property instructions: list[AbstractInstruction]¶: Get the instructions in the circuit.

out() → str[source]¶: Return the instruction as a valid Quil string.

property parameters: list[Parameter]¶: Get the parameters of the circuit.

property qubit_variables: list[FormalArgument]¶: Get the qubit parameters of the circuit.

Bases: FrameDefinition, AbstractInstruction

A frame definition.

Get the frame definition.

property center_frequency: Frame¶: Get the CENTER-FREQUENCY attribute of the frame.

Deprecated since version 4.0: Quil now supports generic key/value pairs in DEFFRAMEs. Use get_attribute(‘CENTER-FREQUENCY’) instead.

property channel_delay: Frame¶: Get the CHANNEL-DELAY attribute of the frame.

Deprecated since version 4.0: Quil now supports generic key/value pairs in DEFFRAMEs. Use get_attribute(‘CHANNEL-DELAY’) instead.

property direction: str | None¶: Get the DIRECTION attribute of the frame.

Deprecated since version 4.0: Quil now supports generic key/value pairs in DEFFRAMEs. Use get_attribute(‘DIRECTION’) instead.

property frame: Frame¶: Get the frame identifier.

get_attribute(name: str) → str | float | None[source]¶: Get an attribute’s value on the frame definition.

property hardware_object: str | None¶: Get the HARDWARE-OBJECT attribute of the frame.

Deprecated since version 4.0: Quil now supports generic key/value pairs in DEFFRAMEs. Use get_attribute(‘HARDWARE-OBJECT’) instead.

property initial_frequency: float | None¶: Get the INITIAL-FREQUENCY attribute of the frame.

Deprecated since version 4.0: Quil now supports generic key/value pairs in DEFFRAMEs. Use set_attribute(‘INITIAL-FREQUENCY’) instead.

out() → str[source]¶: Return the instruction as a valid Quil string.

property sample_rate: Frame¶: Get the SAMPLE-RATE attribute of the frame.

Deprecated since version 4.0: Quil now supports generic key/value pairs in DEFFRAMEs. Use get_attribute(‘SAMPLE-RATE’) instead.

set_attribute(name: str, value: str | float) → None[source]¶: Set an attribute on the frame definition.

class pyquil.quilbase.DefGate(name: str, matrix: list[list[Expression]] | ndarray | matrix, parameters: list[Parameter] | None = None)[source]¶

Bases: GateDefinition, AbstractInstruction

A DEFGATE directive.

Initialize a new gate definition.

Parameters:

name – The name of the newly defined gate.
matrix – The matrix defining this gate.
parameters – list of parameters that are used in this gate

get_constructor() → Callable[[...], Gate] | Callable[[...], Callable[[...], Gate]][source]¶

Return a function that constructs this gate on variable qubit indices.

For example, mygate.get_constructor()(1) applies the gate to qubit 1.

property matrix: ndarray¶: Get the matrix that defines this GateDefinition.

num_args() → int[source]¶: Get the number of qubit arguments the gate takes.

out() → str[source]¶: Return the Gate as a valid Quil string.

property parameters: list[Parameter]¶: Get the parameters this gate definition takes.

class pyquil.quilbase.DefGateByPaulis(gate_name: str, parameters: list[Parameter], arguments: list[Qubit | QubitPlaceholder | FormalArgument | int], body: PauliSum)[source]¶

Bases: DefGate

A gate definition defined by the exponentiation of a PauliSum.

Initialize a new gate, defined by a PauliSum.

property arguments: list[FormalArgument]¶: Get the arguments the gate takes.

property body: PauliSum¶: Get the PauliSum that defines the gate.

num_args() → int[source]¶: Get the number of arguments the gate takes.

class pyquil.quilbase.DefMeasureCalibration(qubit: Qubit | FormalArgument | None, memory_reference: MemoryReference, instrs: list[AbstractInstruction])[source]¶

Bases: MeasureCalibrationDefinition, AbstractInstruction

A measure calibration definition.

Initialize a new measure calibration definition.

property instrs: list[AbstractInstruction]¶: Get the instructions in the calibration.

property instructions: list[AbstractInstruction]¶: The instructions in the calibration.

property memory_reference: MemoryReference | None¶: Get the memory reference this calibration writes to.

out() → str[source]¶: Return the instruction as a valid Quil string.

property qubit: Qubit | QubitPlaceholder | FormalArgument | int | None¶: Get the qubit this calibration matches.

class pyquil.quilbase.DefPermutationGate(name: str, permutation: list[int] | ndarray)[source]¶

Bases: DefGate

A gate defined by a permutation of numbers.

Initialize a new gate definition with a permutation.

num_args() → int[source]¶: Get the number of arguments the gate takes.

property permutation: list[int]¶: Get the permutation that defines the gate.

class pyquil.quilbase.DefWaveform(name: str, parameters: list[Parameter], entries: list[complex | Expression])[source]¶

Bases: WaveformDefinition, AbstractInstruction

A waveform definition.

Initialize a new waveform definition.

property entries: Sequence[Expression | MemoryReference | int | float | complex | number]¶: Get the entries in the waveform definition.

out() → str[source]¶: Return the instruction as a valid Quil string.

property parameters: list[Parameter]¶: Get the parameters of the waveform.

class pyquil.quilbase.Delay(frames: list[Frame], qubits: Sequence[int | Qubit | FormalArgument], duration: float)[source]¶

Bases: Delay, AbstractInstruction

The DELAY instruction.

Initialize a new DELAY instruction.

property duration: float¶: Get the duration of the delay.

property frames: list[Frame]¶: Get the frames the delay operates on.

out() → str[source]¶: Return the instruction as a valid Quil string.

property qubits: list[Qubit | QubitPlaceholder | FormalArgument | int]¶: Get the qubits the delay operates on.

class pyquil.quilbase.DelayFrames(frames: list[Frame], duration: float)[source]¶

Bases: Delay

A DELAY instruction that operates on frames.

Initialize a new DELAY instruction that operates on frames.

class pyquil.quilbase.DelayQubits(qubits: Sequence[Qubit | FormalArgument], duration: float)[source]¶

Bases: Delay

Initialize a new DELAY instruction that operates on qubits.

class pyquil.quilbase.Fence(qubits: list[Qubit | FormalArgument])[source]¶

Bases: Fence, AbstractInstruction

The FENCE instruction.

Initialize a new FENCE instruction.

out() → str[source]¶: Return the instruction as a valid Quil string.

property qubits: list[Qubit | QubitPlaceholder | FormalArgument | int]¶

Get the qubits the fence operates on.

Note: If qubits is empty, then the instruction fences all qubits.

class pyquil.quilbase.FenceAll[source]¶

Bases: Fence

A FENCE instruction that operates on all qubits.

Initialize a new FenceAll instruction.

Bases: Gate, AbstractInstruction

A quantum gate instruction.

Initialize a new gate instruction.

controlled(control_qubit: Qubit | Qubit | QubitPlaceholder | FormalArgument | int | Sequence[Qubit | QubitPlaceholder | FormalArgument | int | Qubit]) → Gate[source]¶: Add the CONTROLLED modifier to the gate with the given control qubit or Sequence of control qubits.

dagger() → Gate[source]¶: Add the DAGGER modifier to the gate.

forked(fork_qubit: Qubit | Qubit | QubitPlaceholder | FormalArgument | int, alt_params: Sequence[Expression | MemoryReference | int | float | complex | number] | Sequence[Expression]) → Gate[source]¶: Add the FORKED modifier to the gate with the given fork qubit and given additional parameters.

get_qubit_indices() → list[int][source]¶: Get the qubits the gate operates on, as integer indices.

get_qubits(indices: bool = True) → Sequence[Qubit | QubitPlaceholder | FormalArgument | int][source]¶: Get the qubits the gate operates on.

Deprecated since version 4.0: The indices flag will be removed, use get_qubit_indices() instead.

property modifiers: list[str]¶: Get all modifiers applied to the gate.

out() → str[source]¶: Return the Gate as a valid Quil string.

property params: Sequence[Expression | MemoryReference | int | float | complex | number]¶: Get the parameters the gate operates on.

property qubits: list[Qubit | QubitPlaceholder | FormalArgument | int]¶: Get the qubits the gate operates on.

class pyquil.quilbase.Halt[source]¶

Bases: SimpleInstruction

The HALT instruction.

instruction: ClassVar[Instruction] = Halt¶

class pyquil.quilbase.Include(filename)[source]¶

Bases: Include, AbstractInstruction

An INCLUDE directive.

out() → str[source]¶: Return the instruction as a valid Quil string.

class pyquil.quilbase.Jump(target: Label | LabelPlaceholder)[source]¶

Bases: Jump, AbstractInstruction

Representation of an unconditional jump instruction (JUMP).

Initialize a new jump instruction.

out() → str[source]¶: Return the instruction as a valid Quil string. Raises an error if the target is an unresolved placeholder.

property target: Label | LabelPlaceholder¶: Get the target of the jump.

class pyquil.quilbase.JumpTarget(label: Label | LabelPlaceholder)[source]¶

Bases: Label, AbstractInstruction

Representation of a target that can be jumped to.

Initialize a new target.

property label: Label | LabelPlaceholder¶: Get the target as a label.

out() → str[source]¶: Return the target as valid Quil. Raises an error if the target is an unresolved placeholder.

class pyquil.quilbase.JumpUnless(target: Label | LabelPlaceholder, condition: MemoryReference)[source]¶

Bases: JumpUnless, AbstractInstruction

The JUMP-UNLESS instruction.

Initialize a new JumpUnless instruction.

Parameters:

target – The target to jump to if the condition is true.
condition – A memory reference that determines if the jump should be performed. The memory reference must refer to an INTEGER or BIT. The jump will be performed if the value in the reference is 0 when the instruction is evaluated.

property condition: MemoryReference¶: Get the MemoryReference the instruction uses to determine if the jump should be performed or not.

out() → str[source]¶: Return the instruction as valid Quil. Raises an error if the target is an unresolved placeholder.

property target: Label | LabelPlaceholder¶: Get the target the instruction will jump to if the condition bit is not 1.

class pyquil.quilbase.JumpWhen(target: Label | LabelPlaceholder, condition: MemoryReference)[source]¶

Bases: JumpWhen, AbstractInstruction

The JUMP-WHEN instruction.

Initialize a new JumpWhen instruction.

Parameters:

target – The target to jump to if the condition is true.
condition – A memory reference that determines if the jump should be performed. The memory reference must refer to an INTEGER or BIT. The jump will be performed if the value in the reference is not 0 when the instruction is evaluated.

property condition: MemoryReference¶: Get the MemoryReference the instruction uses to determine if the jump should be performed or not.

out() → str[source]¶: Return the instruction as valid Quil. Raises an error if the target is an unresolved placeholder.

property target: Label | LabelPlaceholder¶: Get the target the instruction will jump to if the condition bit is not 1.

class pyquil.quilbase.LogicalBinaryOp(left: MemoryReference, right: MemoryReference | int)[source]¶

Bases: BinaryLogic, AbstractInstruction

Base class for binary logical classical instructions.

Initialize the operands of the binary logical instruction.

property left: MemoryReference¶: The left hand side of the binary expression.

op: ClassVar[BinaryOperator]¶

out() → str[source]¶: Return the instruction as a valid Quil string. Raises an error if the instruction contains placeholders.

property right: MemoryReference | int¶: The right hand side of the binary expression.

class pyquil.quilbase.Measurement(qubit: Qubit | QubitPlaceholder | FormalArgument | int, classical_reg: MemoryReference | None)[source]¶

Bases: Measurement, AbstractInstruction

A Quil measurement instruction.

Initialize a new measurement instruction.

property classical_reg: MemoryReference | None¶: Get the MemoryReference that this instruction writes to, if any.

get_qubit_indices() → set[int][source]¶: Get the qubit this instruction measures, as an integer index.

get_qubits(indices: bool = True) → set[Qubit | QubitPlaceholder | FormalArgument | int] | set[int][source]¶: Get the qubit this instruction measures.

Deprecated since version 4.0: The indices flag will be removed, use get_qubit_indices() instead.

out() → str[source]¶: Return the instruction as a valid Quil string.

property qubit: Qubit | QubitPlaceholder | FormalArgument | int¶: Get the qubit the instruction measures.

class pyquil.quilbase.Nop[source]¶

Bases: SimpleInstruction

The NOP instruction.

instruction: ClassVar[Instruction] = Nop¶

class pyquil.quilbase.Pragma(command: str, args: Sequence[Qubit | FormalArgument | int | str] = (), freeform_string: str = '')[source]¶

Bases: Pragma, AbstractInstruction

A PRAGMA instruction.

This is printed in QUIL as:

PRAGMA <command> <arg1> <arg2> … <argn> “<freeform_string>”

Initialize a new PRAGMA instruction.

property args: tuple[Qubit | QubitPlaceholder | FormalArgument | int]¶: Get the arguments of the PRAGMA command.

property command: str¶: Get the pragma command identifier.

property freeform_string: str¶: Get the PRAGMA’s freeform string.

out() → str[source]¶: Return the instruction as a valid Quil string.

class pyquil.quilbase.Pulse(frame: Frame, waveform: WaveformReference | TemplateWaveform, nonblocking: bool = False)[source]¶

Bases: Pulse, AbstractInstruction

A PULSE instruction.

Initialize a new Pulse instruction.

property frame: Frame¶: Get the frame the pulse operates on.

get_qubit_indices() → set[int][source]¶: Get the qubits the pulse operates on, as integer indices.

get_qubits(indices: bool = True) → set[Qubit | QubitPlaceholder | FormalArgument | int] | set[int][source]¶: Get the qubits the pulse operates on.

Deprecated since version 4.0: The indices flag will be removed, use get_qubit_indices() instead.

property nonblocking: bool¶: Return whether the pulse is non-blocking.

out() → str[source]¶: Return the instruction as a valid Quil string.

property waveform: WaveformReference | TemplateWaveform¶: Get the waveform of the pulse.

class pyquil.quilbase.RawCapture(frame: Frame, duration: float, memory_region: MemoryReference, nonblocking: bool = False)[source]¶

Bases: RawCapture, AbstractInstruction

The RAW-CAPTURE instruction.

Initialize a new RAW-CAPTURE instruction.

property duration: complex¶: Get the duration of the capture.

property frame: Frame¶: Get the frame this instruction operates on.

get_qubit_indices() → set[int][source]¶: Get the qubits the raw-capture instruction operates on, as integer indices.

get_qubits(indices: bool = True) → set[Qubit | QubitPlaceholder | FormalArgument | int] | set[int][source]¶: Get the qubits the raw-capture instruction operates on.

Deprecated since version 4.0: The indices flag will be removed, use get_qubit_indices() instead.

property memory_region: MemoryReference¶: Get the memory region that the capture is written to.

property nonblocking: bool¶: Whether the capture is non-blocking.

out() → str[source]¶: Return the instruction as a valid Quil string.

class pyquil.quilbase.Reset(qubit: Qubit | QubitPlaceholder | FormalArgument | int | None = None)[source]¶

Bases: Reset, AbstractInstruction

The RESET instruction.

Initialize a new reset instruction.

get_qubit_indices() → set[int] | None[source]¶: Get the qubit this instruction resets, as an integer index.

get_qubits(indices: bool = True) → set[Qubit | QubitPlaceholder | FormalArgument | int] | None[source]¶: Get the qubit this instruction resets.

Deprecated since version 4.0: The indices flag will be removed, use get_qubit_indices() instead.

out() → str[source]¶: Return the instruction as a valid Quil string.

property qubit: Qubit | QubitPlaceholder | FormalArgument | int | None¶: Get the qubit this instruction resets, if any.

class pyquil.quilbase.ResetQubit(qubit: Qubit | QubitPlaceholder | FormalArgument | int)[source]¶

Bases: Reset

A targeted RESET instruction.

Initialize a new reset instruction, with a target qubit.

Bases: SetFrequency, AbstractInstruction

A SET-FREQUENCY instruction.

Initialize a new SET-FREQUENCY instruction.

property frame: Frame¶: Get the frame the frequency is set on.

property freq: Expression | MemoryReference | int | float | complex | number¶: Get the frequency that is set.

get_qubit_indices() → set[int][source]¶: Get the qubits the frequency is set on, as integer indices.

get_qubits(indices: bool = True) → set[Qubit | QubitPlaceholder | FormalArgument | int] | set[int][source]¶: Get the qubits the frequency is set on.

Deprecated since version 4.0: The indices flag will be removed, use get_qubit_indices() instead.

out() → str[source]¶: Return the instruction as a valid Quil string.

Bases: SetPhase, AbstractInstruction

The SET-PHASE instruction.

Initialize a new SET-PHASE instruction.

property frame: Frame¶: Get the frame the phase is set on.

get_qubit_indices() → set[int][source]¶: Get the quibts the phase is set on, as integer indices.

get_qubits(indices: bool = True) → set[Qubit | QubitPlaceholder | FormalArgument | int] | set[int][source]¶: Get the quibts the phase is set on.

Deprecated since version 4.0: The indices flag will be removed, use get_qubit_indices() instead.

out() → str[source]¶: Return the instruction as a valid Quil string.

property phase: Expression | MemoryReference | int | float | complex | number¶: Get the phase this instruction sets.

Bases: SetScale, AbstractInstruction

The SET-SCALE instruction.

Initialize a new SET-SCALE instruction.

property frame: Frame¶: Get the frame the scale is set on.

get_qubit_indices() → set[int][source]¶: Get the qubits the scale is set on, as integer indices.

get_qubits(indices: bool = True) → set[Qubit | QubitPlaceholder | FormalArgument | int] | set[int][source]¶: Get the qubits the scale is set on.

Deprecated since version 4.0: The indices flag will be removed, use get_qubit_indices() instead.

out() → str[source]¶: Return the instruction as a valid Quil string.

property scale: Expression | MemoryReference | int | float | complex | number¶: Get the scale that is set.

Bases: ShiftFrequency, AbstractInstruction

The SHIFT-FREQUENCY instruction.

Initialize a new SHIFT-FREQUENCY instruction.

property frame: Frame¶: Get the frame the frequency is shifted on.

property freq: Expression | MemoryReference | int | float | complex | number¶: Get the parameter that defines how the frequency is shifted.

get_qubit_indices() → set[int][source]¶: Get the qubits the frequency is shifted on, as integer indices.

get_qubits(indices: bool = True) → set[Qubit | QubitPlaceholder | FormalArgument | int] | set[int][source]¶: Get the qubits the frequency is shifted on.

Deprecated since version 4.0: The indices flag will be removed, use get_qubit_indices() instead.

out() → str[source]¶: Return the instruction as a valid Quil string.

Bases: ShiftPhase, AbstractInstruction

The SHIFT-PHASE instruction.

Initialize a new SHIFT-PHASE instruction.

property frame: Frame¶: Get the frame the phase is shifted on.

get_qubit_indices() → set[int][source]¶: Get the qubits the phase is shifted on, as integer indices.

get_qubits(indices: bool = True) → set[Qubit | QubitPlaceholder | FormalArgument | int] | set[int][source]¶: Get the qubits the phase is shifted on.

Deprecated since version 4.0: The indices flag will be removed, use get_qubit_indices() instead.

out() → str[source]¶: Return the instruction as a valid Quil string.

property phase: Expression | MemoryReference | int | float | complex | number¶: Get the parameter that defines how the phase is shifted.

class pyquil.quilbase.SimpleInstruction[source]¶

Bases: AbstractInstruction

Base class for simple instructions with no arguments.

instruction: ClassVar[Instruction]¶

out() → str[source]¶: Return the instruction as a valid Quil string.

class pyquil.quilbase.SwapPhases(frameA: Frame, frameB: Frame)[source]¶

Bases: SwapPhases, AbstractInstruction

The SWAP-PHASES instruction.

Initialize a new SWAP-PHASES instruction.

property frameA: Frame¶: The first frame of the SWAP-PHASES instruction.

property frameB: Frame¶: The second frame of the SWAP-PHASES instruction.

get_qubit_indices() → set[int][source]¶: Get the qubits the swap-phases instruction operates on, as integer indices.

get_qubits(indices: bool = True) → set[Qubit | QubitPlaceholder | FormalArgument | int] | set[int][source]¶: Get the qubits the swap-phases instruction operates on.

Deprecated since version 4.0: The indices flag will be removed, use get_qubit_indices() instead.

out() → str[source]¶: Return the instruction as a valid Quil string.

class pyquil.quilbase.UnaryClassicalInstruction(target: MemoryReference)[source]¶

Bases: UnaryLogic, AbstractInstruction

Base class for unary classical instructions.

Initialize a new unary classical instruction.

op: ClassVar[UnaryOperator]¶

out() → str[source]¶: Return the instruction as a valid Quil string. Raises an error if the instruction contains placeholders.

property target: MemoryReference¶: The MemoryReference that the instruction operates on.

class pyquil.quilbase.Wait[source]¶

Bases: SimpleInstruction

The WAIT instruction.

instruction: ClassVar[Instruction] = Wait¶