View source on GitHub
|
Classes for working with Google's Quantum Engine API.
Modules
api module: Helpers for converting to/from api data formats.
cloud module: Protocol buffers and generated client for Quantum Engine API.
devices module: Devices and Noise models for publicly known Google devices.
engine module: Client for running on Google's Quantum Engine.
experimental module: Experimental features.
json_resolver_cache module: Module for use in exporting cirq-google objects in JSON.
line module: Utilities for picking out a line of GridQubits from a device.
ops module: Qubit Gates, Operations, and Tags useful for Google devices.
serialization module: Classes for serializing circuits into protocol buffers.
study module: Classes for running sweeps particular to Google hardware.
transformers module: Transformers for compiling to Google-specific gates, such as Sycamore.
workflow module: Utilities for running end-to-end experiments using Quantum Computing Service (QCS).
Classes
class AnnealSequenceSearchStrategy: Linearized sequence search using simulated annealing method.
class BitstringsMeasurement: Use in-circuit MeasurementGate to collect many repetitions of strings of bits.
class Calibration: A convenience wrapper for calibrations that acts like a dictionary.
class CalibrationLayer: Python implementation of the proto found in cirq_google.api.v2.calibration_pb2.FocusedCalibrationLayer for use in Engine calls.
class CalibrationResult: Python implementation of the proto found in cirq_google.api.v2.calibration_pb2.CalibrationLayerResult for use in Engine calls.
class CalibrationTag: Tag to add onto an Operation that specifies alternate parameters.
class CircuitOpDeserializer: Describes how to serialize CircuitOperations.
class CircuitOpSerializer: Describes how to serialize CircuitOperations.
class CircuitSerializer: A class for serializing and deserializing programs and operations.
class CouldNotPlaceError: Raised if a problem topology could not be placed on a device graph.
class Coupler: A Qid representing the coupler between two qubits.
class Engine: Runs programs via the Quantum Engine API.
class EngineJob: A job created via the Quantum Engine API.
class EngineProcessor: A processor available via the Quantum Engine API.
class EngineProcessorRecord: A serializable record of processor_id to map to a cg.EngineProcessor.
class EngineProgram: A program created via the Quantum Engine API.
class EngineResult: A ResultDict with additional job metadata.
class ExecutableGroupResult: Results for a cg.QuantumExecutableGroup.
class ExecutableGroupResultFilesystemRecord: Filename references to the constituent parts of a cg.ExecutableGroupResult.
class ExecutableResult: Results for a cg.QuantumExecutable.
class ExecutableSpec: Specification metadata about an executable.
class FSimGateFamily: GateFamily useful to convert/accept cirq.FSimGate and other related gate types.
class FSimViaModelTag: A tag class to denote FSim gate implementation using polynomial model.
class GoogleCZTargetGateset: cirq.CZTargetGateset implementation tailored to Google devices.
class GoogleNoiseProperties: Noise-defining properties for a Google device.
class GreedySequenceSearchStrategy: Greedy search method for linear sequence of qubits on a chip.
class GridDevice: Device object representing Google devices with a grid qubit layout.
class InternalGate: InternalGate is a placeholder gate for internal gates.
class InternalTag: InternalTag is a placeholder tag for internal tags that are not specified publicly.
class KeyValueExecutableSpec: A generic executable spec whose metadata is a list of key-value pairs.
class LinePlacementStrategy: Choice and options for the line placement calculation method.
class NaiveQubitPlacer: Don't do any qubit placement, use circuit qubits.
class NoiseModelFromGoogleNoiseProperties: A noise model defined from noise properties of a Google device.
class PhysicalZTag: Class to add as a tag onto an Operation to denote a Physical Z operation.
class ProcessorRecord: A serializable record that maps to a particular cg.engine.AbstractProcessor.
class ProcessorSampler: A wrapper around AbstractProcessor to implement the cirq.Sampler interface.
class ProtoVersion: Protocol buffer version to use for requests to the quantum engine.
class QuantumExecutable: An executable quantum program.
class QuantumExecutableGroup: A collection of QuantumExecutables.
class QuantumRuntimeConfiguration: User-requested configuration of how to execute a given cg.QuantumExecutableGroup.
class RuntimeInfo: Runtime information relevant to a particular cg.QuantumExecutable.
class Serializer: Interface for serialization.
class SharedRuntimeInfo: Runtime information common to all cg.QuantumExecutables in an execution of a cg.QuantumExecutableGroup.
class SimulatedProcessorRecord: A serializable record mapping a processor_id and optional noise spec to a simulator-backed mock of cg.AbstractProcessor.
class SimulatedProcessorWithLocalDeviceRecord: A serializable record mapping a processor_id and optional noise spec to a completely local cg.AbstractProcessor
class SycamoreGate: The Sycamore gate is a two-qubit gate equivalent to FSimGate(π/2, π/6).
class SycamoreTargetGateset: Target gateset containing Sycamore + single qubit rotations + Measurement gates.
class ValidatingSampler: Something capable of sampling quantum circuits. Simulator or hardware.
Functions
SYC(...): The Sycamore gate is a two-qubit gate equivalent to FSimGate(π/2, π/6).
arg_from_proto(...): Extracts a python value from an argument value proto.
execute(...): Execute a cg.QuantumExecutableGroup according to a cg.QuantumRuntimeConfiguration.
get_engine(...): Get an Engine instance assuming some sensible defaults.
get_engine_calibration(...): Returns calibration metrics for a given processor.
get_engine_device(...): Returns a Device object for a given processor.
get_engine_sampler(...): Get an EngineSampler assuming some sensible defaults.
known_2q_op_to_sycamore_operations(...): Synthesizes a known two-qubit operation using cirq_google.SYC + single qubit rotations.
line_on_device(...): Searches for linear sequence of qubits on device.
noise_properties_from_calibration(...): Translates between cirq_google.Calibration and NoiseProperties.
two_qubit_matrix_to_sycamore_operations(...): Decomposes a two-qubit unitary matrix into cirq_google.SYC + single qubit rotations.
Other Members | |
|---|---|
| CIRCUIT_SERIALIZER |
Instance of cirq_google.serialization.CircuitSerializer
|
| Sycamore |
Instance of cirq_google.devices.GridDevice
|
| Sycamore23 |
Instance of cirq_google.devices.GridDevice
|
| version |
'1.5.0'
|