qcs_sdk.compiler.quilc 

 1# This file is automatically generated by pyo3_stub_gen
 2# ruff: noqa: F401
 3
 4from qcs_sdk._qcs_sdk.compiler.quilc import CompilationResult, CompilerOpts, ConjugateByCliffordRequest, ConjugatePauliByCliffordRequest, ConjugatePauliByCliffordResponse, DEFAULT_COMPILER_TIMEOUT, GenerateRandomizedBenchmarkingSequenceResponse, NativeQuilMetadata, PauliTerm, QuilcClient, QuilcError, RandomizedBenchmarkingRequest, TargetDevice, compile_program, compile_program_async, conjugate_pauli_by_clifford, conjugate_pauli_by_clifford_async, generate_randomized_benchmarking_sequence, generate_randomized_benchmarking_sequence_async, get_version_info, get_version_info_async
 5__all__ = [
 6    "CompilationResult",
 7    "CompilerOpts",
 8    "ConjugateByCliffordRequest",
 9    "ConjugatePauliByCliffordRequest",
10    "ConjugatePauliByCliffordResponse",
11    "DEFAULT_COMPILER_TIMEOUT",
12    "GenerateRandomizedBenchmarkingSequenceResponse",
13    "NativeQuilMetadata",
14    "PauliTerm",
15    "QuilcClient",
16    "QuilcError",
17    "RandomizedBenchmarkingRequest",
18    "TargetDevice",
19    "compile_program",
20    "compile_program_async",
21    "conjugate_pauli_by_clifford",
22    "conjugate_pauli_by_clifford_async",
23    "generate_randomized_benchmarking_sequence",
24    "generate_randomized_benchmarking_sequence_async",
25    "get_version_info",
26    "get_version_info_async",
27]
class CompilationResult:

The result of compiling a Quil program to native quil with quilc

program

The compiled program

native_quil_metadata

Metadata about the compiled program

class CompilerOpts:

A set of options that determine the behavior of compiling programs with quilc

def default():

Create a new instance of CompilerOpts with default values.

class ConjugateByCliffordRequest:

Request to conjugate a Pauli Term by a Clifford element.

clifford

Clifford element.

pauli

Pauli Term to conjugate.

class ConjugatePauliByCliffordRequest:

The "outer" request shape for a conjugate_pauli_by_clifford request.

args
class ConjugatePauliByCliffordResponse:

Conjugate Pauli by Clifford response.

pauli

Description of the encoded Pauli.

phase

Encoded global phase factor on the emitted Pauli.

DEFAULT_COMPILER_TIMEOUT = 30.0
class GenerateRandomizedBenchmarkingSequenceResponse:

Randomly generated benchmarking sequence response.

sequence

List of Cliffords, each expressed as a list of generator indices.

class NativeQuilMetadata:

Metadata about a program compiled to native quil.

class PauliTerm:

Pauli Term

indices

Qubit indices onto which the factors of the Pauli term are applied.

symbols

Ordered factors of the Pauli term.

class QuilcClient:

Client used to communicate with Quilc.

def new_libquil():
def new_rpcq(endpoint):

Construct a QuilcClient that uses RPCQ to communicate with Quilc.

class QuilcError(qcs_sdk._qcs_sdk.QcsSdkError):

Errors encountered compiling a Quil program.

class RandomizedBenchmarkingRequest:

Request to generate a randomized benchmarking sequence.

gateset

List of Quil programs, each describing a Clifford.

interleaver

Fixed Clifford, specified as a Quil string, to interleave through an RB sequence.

seed

PRNG seed. Set this to guarantee repeatable results.

qubits

Number of qubits involved in the benchmarking sequence.

depth

Depth of the benchmarking sequence.

class TargetDevice:

Description of a device to compile for.

def from_isa(isa):

Create a [TargetDevice] based on an [InstructionSetArchitecture].

Errors

Returns a [QuilcError] if the [InstructionSetArchitecture] cannot be converted into a format that Quilc understands.

def from_json(value):

Create a [TargetDevice] from a JSON string.

Errors

Returns a [QuilcError] if the JSON is malformed.

def compile_program(quil, target, client, options=None):

Compile a quil program for a target device.

Parameters
  • quil: The Quil program to compile.
  • target: Architectural description of device to compile for.
  • client: Client used to send compilation requests to Quilc.
  • options: Optional compiler options. If None, default values are used.
Raises
  • QuilcError: If compilation fails.
def compile_program_async(quil, target, client, options=None):

Compile a quil program for a target device.

Parameters
  • quil: The Quil program to compile.
  • target: Architectural description of device to compile for.
  • client: Client used to send compilation requests to Quilc.
  • options: Optional compiler options. If None, default values are used.
Raises
  • QuilcError: If compilation fails.
def conjugate_pauli_by_clifford(request, client):

Given a circuit that consists only of elements of the Clifford group, return its action on a PauliTerm. In particular, for Clifford C, and Pauli P, this returns the PauliTerm representing CPC^{\dagger}.

Parameters
  • request: Pauli Term conjugation request.
  • client: Client used to send compilation requests to Quilc.
Raises
  • QuilcError: If there is a failure connecting to Quilc or if the request is malformed.
def conjugate_pauli_by_clifford_async(request, client):

Given a circuit that consists only of elements of the Clifford group, return its action on a PauliTerm. In particular, for Clifford C, and Pauli P, this returns the PauliTerm representing CPC^{\dagger}.

Parameters
  • request: Pauli Term conjugation request.
  • client: Client used to send compilation requests to Quilc.
Raises
  • QuilcError: If there is a failure connecting to Quilc or if the request is malformed.
def generate_randomized_benchmarking_sequence(request, client):

Construct a randomized benchmarking experiment on the given qubits, decomposing into gateset. If interleaver is not provided, the returned sequence will have the form

    C_1 C_2 ... C_(depth-1) C_inv ,

where each C is a Clifford element drawn from gateset, C_{< depth} are randomly selected, and C_inv is selected so that the entire sequence composes to the identity. If an interleaver G (which must be a Clifford, and which will be decomposed into the native gateset) is provided, then the sequence instead takes the form

    C_1 G C_2 G ... C_(depth-1) G C_inv .
Parameters
  • request: Randomized benchmarking request.
  • client: Client used to send compilation requests to Quilc.
Raises
  • QuilcError: If there is a failure connecting to Quilc or if the request is malformed.
def generate_randomized_benchmarking_sequence_async(request, client):

Construct a randomized benchmarking experiment on the given qubits, decomposing into gateset. If interleaver is not provided, the returned sequence will have the form

    C_1 C_2 ... C_(depth-1) C_inv ,

where each C is a Clifford element drawn from gateset, C_{< depth} are randomly selected, and C_inv is selected so that the entire sequence composes to the identity. If an interleaver G (which must be a Clifford, and which will be decomposed into the native gateset) is provided, then the sequence instead takes the form

    C_1 G C_2 G ... C_(depth-1) G C_inv .
Parameters
  • request: Randomized benchmarking request.
  • client: Client used to send compilation requests to Quilc.
Raises
  • QuilcError: If there is a failure connecting to Quilc or if the request is malformed.
def get_version_info(client):

Fetch the version information from the running Quilc service.

Parameters
  • client: Client used to send compilation requests to Quilc.
Raises
  • QuilcError: If there is a failure connecting to Quilc.
def get_version_info_async(client):

Fetch the version information from the running Quilc service.

Parameters
  • client: Client used to send compilation requests to Quilc.
Raises
  • QuilcError: If there is a failure connecting to Quilc.