API documentation#
Module for conversion from tket to braket
- class pytket.extensions.braket.BraketBackend(local: bool = False, local_device: str = 'default', device: Optional[str] = None, region: str = '', s3_bucket: Optional[str] = None, s3_folder: Optional[str] = None, device_type: Optional[str] = None, provider: Optional[str] = None, aws_session: Optional[braket.aws.aws_session.AwsSession] = None)#
Interface to Amazon Braket service
- __init__(local: bool = False, local_device: str = 'default', device: Optional[str] = None, region: str = '', s3_bucket: Optional[str] = None, s3_folder: Optional[str] = None, device_type: Optional[str] = None, provider: Optional[str] = None, aws_session: Optional[braket.aws.aws_session.AwsSession] = None)#
Construct a new braket backend.
If local=True, other parameters are ignored.
All parameters except device can be set in config using
pytket.extensions.braket.set_braket_config()
. For device_type, provider and device if no parameter is specified as a keyword argument or in the config file the defaults specified below are used.- Parameters
local – use simulator running on local machine, default: False
local_device – name of local device (ignored if local=False) – e.g. “braket_sv” (default) or “braket_dm”.
device – device name from device ARN (e.g. “ionQdevice”, “Aspen-8”, …), default: “sv1”
region – region from device ARN, default: “”
s3_bucket – name of S3 bucket to store results
s3_folder – name of folder (“key”) in S3 bucket to store results in
device_type – device type from device ARN (e.g. “qpu”), default: “quantum-simulator”
provider – provider name from device ARN (e.g. “ionq”, “rigetti”, “oqc”, …), default: “amazon”
aws_session – braket AwsSession object, to pass credentials in if not configured on local machine
- classmethod available_devices(**kwargs: Any) List[pytket.backends.backendinfo.BackendInfo] #
See
pytket.backends.Backend.available_devices()
. Supported kwargs:region (default None). The particular AWS region to search for devices (e.g. us-east-1). Default to the region configured with AWS. See the Braket docs for more details.
aws_session (default None). The credentials of the provided session will be used to create a new session with the specified region. Otherwise, a default new session will be created
- cancel(handle: pytket.backends.resulthandle.ResultHandle) None #
Cancel a job.
- Parameters
handle (ResultHandle) – handle to job
- Raises
NotImplementedError – If backend does not support job cancellation
- circuit_status(handle: pytket.backends.resulthandle.ResultHandle) pytket.backends.status.CircuitStatus #
Return a CircuitStatus reporting the status of the circuit execution corresponding to the ResultHandle
- default_compilation_pass(optimisation_level: int = 1) pytket.passes.BasePass #
A suggested compilation pass that will will, if possible, produce an equivalent circuit suitable for running on this backend.
At a minimum it will ensure that compatible gates are used and that all two- qubit interactions are compatible with the backend’s qubit architecture. At higher optimisation levels, further optimisations may be applied.
This is a an abstract method which is implemented in the backend itself, and so is tailored to the backend’s requirements.
- Parameters
optimisation_level (int, optional) –
The level of optimisation to perform during compilation.
Level 0 does the minimum required to solves the device constraints, without any optimisation.
Level 1 additionally performs some light optimisations.
Level 2 (the default) adds more computationally intensive optimisations that should give the best results from execution.
- Returns
Compilation pass guaranteeing required predicates.
- Return type
- get_amplitudes(circuit: pytket.circuit.Circuit, states: List[str], valid_check: bool = True, **kwargs: Optional[Union[int, float, str]]) Dict[str, complex] #
Compute the complex coefficients of the final state.
Supported kwargs are as for BraketBackend.process_circuits.
- Parameters
states – classical states of interest, as binary strings of ‘0’ and ‘1’
- Returns
final complex amplitudes if initial state is all-zeros
- get_operator_expectation_value(state_circuit: pytket.circuit.Circuit, operator: pytket.utils.QubitPauliOperator, n_shots: int = 0, valid_check: bool = True, **kwargs: Optional[Union[int, float, str]]) numpy.float64 #
Compute the (exact or empirical) expectation of the observed eigenvalues.
See pytket.expectations.get_operator_expectation_value.
If n_shots > 0 the probabilities are calculated empirically by measurements. If n_shots = 0 (if supported) they are calculated exactly by simulation.
Supported kwargs are as for BraketBackend.get_pauli_expectation_value.
- get_operator_variance(state_circuit: pytket.circuit.Circuit, operator: pytket.utils.QubitPauliOperator, n_shots: int = 0, valid_check: bool = True, **kwargs: Optional[Union[int, float, str]]) numpy.float64 #
Compute the (exact or empirical) variance of the observed eigenvalues.
See pytket.expectations.get_operator_expectation_value.
If n_shots > 0 the probabilities are calculated empirically by measurements. If n_shots = 0 (if supported) they are calculated exactly by simulation.
Supported kwargs are as for BraketBackend.get_pauli_expectation_value.
- get_pauli_expectation_value(state_circuit: pytket.circuit.Circuit, pauli: pytket.pauli.QubitPauliString, n_shots: int = 0, valid_check: bool = True, **kwargs: Optional[Union[int, float, str]]) numpy.float64 #
Compute the (exact or empirical) expectation of the observed eigenvalues.
See pytket.expectations.get_pauli_expectation_value.
If n_shots > 0 the probabilities are calculated empirically by measurements. If n_shots = 0 (if supported) they are calculated exactly by simulation.
Supported kwargs (not valid for local simulator):
poll_timeout_seconds (int) : Polling timeout for synchronous retrieval of result, in seconds (default: 5 days).
poll_interval_seconds (int) : Polling interval for synchronous retrieval of result, in seconds (default: 1 second).
- get_pauli_variance(state_circuit: pytket.circuit.Circuit, pauli: pytket.pauli.QubitPauliString, n_shots: int = 0, valid_check: bool = True, **kwargs: Optional[Union[int, float, str]]) numpy.float64 #
Compute the (exact or empirical) variance of the observed eigenvalues.
See pytket.expectations.get_pauli_expectation_value.
If n_shots > 0 the probabilities are calculated empirically by measurements. If n_shots = 0 (if supported) they are calculated exactly by simulation.
Supported kwargs are as for BraketBackend.get_pauli_expectation_value.
- get_probabilities(circuit: pytket.circuit.Circuit, qubits: Optional[Iterable[int]] = None, n_shots: int = 0, valid_check: bool = True, **kwargs: Optional[Union[int, float, str]]) numpy.ndarray #
Compute the (exact or empirical) probability distribution of outcomes.
If n_shots > 0 the probabilities are calculated empirically by measurements. If n_shots = 0 (if supported) they are calculated exactly by simulation.
Supported kwargs are as for BraketBackend.process_circuits.
The order is big-endian with respect to the order of qubits in the argument. For example, if qubits=[0,1] then the order of probabilities is [p(0,0), p(0,1), p(1,0), p(1,1)], while if qubits=[1,0] the order is [p(0,0), p(1,0), p(0,1), p(1,1)], where p(i,j) is the probability of qubit 0 being in state i and qubit 1 being in state j.
- Parameters
qubits – qubits of interest
- Returns
list of probabilities of outcomes if initial state is all-zeros
- get_result(handle: pytket.backends.resulthandle.ResultHandle, **kwargs: Optional[Union[int, float, str]]) pytket.backends.backendresult.BackendResult #
See
pytket.backends.Backend.get_result()
. Supported kwargs: timeout (default none), wait (default 1s).
- process_circuits(circuits: Sequence[pytket.circuit.Circuit], n_shots: Union[None, int, Sequence[Optional[int]]] = None, valid_check: bool = True, **kwargs: Optional[Union[int, float, str]]) List[pytket.backends.resulthandle.ResultHandle] #
Supported kwargs: - postprocess: apply end-of-circuit simplifications and classical
postprocessing to improve fidelity of results (bool, default False)
simplify_initial: apply the pytket
SimplifyInitial
pass to improve fidelity of results assuming all qubits initialized to zero (bool, default False)
- rebase_pass() pytket.passes.BasePass #
A single compilation pass that when run converts all gates in a Circuit to an OpType supported by the Backend (ignoring architecture constraints).
- Returns
Compilation pass that converts gates to primitives supported by Backend.
- Return type
- property backend_info: pytket.backends.backendinfo.BackendInfo#
Retrieve all Backend properties in a BackendInfo object, including device architecture, supported gate set, gate errors and other hardware-specific information.
- Returns
The BackendInfo describing this backend if it exists.
- Return type
Optional[BackendInfo]
- property required_predicates: List[pytket.predicates.Predicate]#
The minimum set of predicates that a circuit must satisfy before it can be successfully run on this backend.
- Returns
Required predicates.
- Return type
List[Predicate]
- property supports_amplitude: bool#
Whether the backend support calculation of final state amplitudes
- class pytket.extensions.braket.backends.config.BraketConfig(s3_bucket: Optional[str], s3_folder: Optional[str], device_type: Optional[str], provider: Optional[str])#
Holds config parameters for pytket-braket.
- classmethod from_extension_dict(ext_dict: Dict[str, Any]) pytket.extensions.braket.backends.config.BraketConfig #
Abstract method to build PytketExtConfig from dictionary serialized form.
- pytket.extensions.braket.backends.config.set_braket_config(s3_bucket: Optional[str] = None, s3_folder: Optional[str] = None, device_type: Optional[str] = None, provider: Optional[str] = None) None #
Set default values for any of s3_bucket, s3_folder, device_type or provider for AWS Braket. Can be overridden in backend construction.
Conversion from tket to braket
- pytket.extensions.braket.braket_convert.braket_to_tk(bkcirc: braket.circuits.circuit.Circuit) pytket.circuit.Circuit #
Convert a braket circuit to a tket
Circuit
- Parameters
bkcirc – circuit to be converted
- Returns
circuit converted to tket
- pytket.extensions.braket.braket_convert.tk_to_braket(tkcirc: pytket.circuit.Circuit, mapped_qubits: bool = False, forced_qubits: Optional[List[int]] = None, force_ops_on_target_qubits: bool = False) Tuple[braket.circuits.circuit.Circuit, List[int], Dict[int, int]] #
Convert a tket
Circuit
to a braket circuit.- Parameters
tkcirc – circuit to be converted
mapped_qubits – if True, tkcirc must have a single one-dimensional qubit register; the indices of the qubits in that register correspond directly to the qubit identifiers in the braket circuit
forced_qubits – optional list of braket qubit identifiers to include in the converted circuit even if they are unused
force_ops_on_target_qubits – if True, add no-ops to all target qubits
- Returns
circuit converted to braket; list of braket qubit ids corresponding in order of corresponding positions in tkcirc.qubits; (partial) map from braket qubit ids to corresponding pytket bit indices holding measurement results