cirq_aqt.aqt_sampler.AQTSampler

cirq.Sampler for the AQT ion trap device

This sampler connects to the AQT machine and runs a single circuit or an entire sweep remotely

remote_host Address of the remote device.
access_token Access token for the remote api.

Methods

run

Samples from the given Circuit.

By default, the run_async method invokes this method on another thread. So this method is supposed to be thread safe.

Args
program The circuit to sample from.
param_resolver Parameters to run with the program.
repetitions The number of times to sample.

Returns
Result for a run.

run_async

Asynchronously samples from the given Circuit.

By default, this method invokes run synchronously and simply exposes its result is an awaitable. Child classes that are capable of true asynchronous sampling should override it to use other strategies.

Args
program The circuit to sample from.
repetitions The number of times to sample.

Returns
An awaitable Result.

run_batch

Runs the supplied circuits.

Each circuit provided in programs will pair with the optional associated parameter sweep provided in the params_list, and be run with the associated repetitions provided in repetitions (if repetitions is an integer, then all runs will have that number of repetitions). If params_list is specified, then the number of circuits is required to match the number of sweeps. Similarly, when repetitions is a list, the number of circuits is required to match the length of this list.

By default, this method simply invokes run_sweep sequentially for each (circuit, parameter sweep, repetitions) tuple. Child classes that are capable of sampling batches more efficiently should override it to use other strategies. Note that child classes may have certain requirements that must be met in order for a speedup to be possible, such as a constant number of repetitions being used for all circuits. Refer to the documentation of the child class for any such requirements.

Args
programs The circuits to execute as a batch.
params_list Parameter sweeps to use with the circuits. The number of sweeps should match the number of circuits and will be paired in order with the circuits.
repetitions Number of circuit repetitions to run. Can be specified as a single value to use for all runs, or as a list of values, one for each circuit.

Returns
A list of lists of TrialResults. The outer list corresponds to the circuits, while each inner list contains the TrialResults for the corresponding circuit, in the order imposed by the associated parameter sweep.

run_sweep

View source

Samples from the given Circuit.

In contrast to run, this allows for sweeping over different parameter values.

Args
program The circuit to simulate. Should be generated using AQTSampler.generate_circuit_from_list
params Parameters to run with the program.
repetitions The number of repetitions to simulate.

Returns
Result list for this run; one for each possible parameter resolver.

run_sweep_async

Asynchronously sweeps and samples from the given Circuit.

By default, this method invokes run_sweep synchronously and simply exposes its result is an awaitable. Child classes that are capable of true asynchronous sampling should override it to use other strategies.

Args
program The circuit to sample from.
params One or more mappings from parameter keys to parameter values to use. For each parameter assignment, repetitions samples will be taken.
repetitions The number of times to sample.

Returns
An awaitable Result.

sample

Samples the given Circuit, producing a pandas data frame.

Args
program The circuit to sample from.
repetitions The number of times to sample the program, for each parameter mapping.
params Maps symbols to one or more values. This argument can be a dictionary, a list of dictionaries, a cirq.Sweep, a list of cirq.Sweep, etc. The program will be sampled repetition times for each mapping. Defaults to a single empty mapping.

Returns
A pandas.DataFrame with a row for each sample, and a column for each measurement key as well as a column for each symbolic parameter. Measurement results are stored as a big endian integer representation with one bit for each measured qubit in the key. See cirq.big_endian_int_to_bits and similar functions for how to convert this integer into bits. There is an also index column containing the repetition number, for each parameter assignment.

Examples:

a, b, c = cirq.LineQubit.range(3)
sampler = cirq.Simulator()
circuit = cirq.Circuit(cirq.X(a),
                       cirq.measure(a, key='out'))
print(sampler.sample(circuit, repetitions=4))
   out
0    1
1    1
2    1
3    1
circuit = cirq.Circuit(cirq.X(a),
                       cirq.CNOT(a, b),
                       cirq.measure(a, b, c, key='out'))
print(sampler.sample(circuit, repetitions=4))
   out
0    6
1    6
2    6
3    6
circuit = cirq.Circuit(cirq.X(a)**sympy.Symbol('t'),
                       cirq.measure(a, key='out'))
print(sampler.sample(
    circuit,
    repetitions=3,
    params=[{'t': 0}, {'t': 1}]))
   t  out
0  0    0
1  0    0
2  0    0
0  1    1
1  1    1
2  1    1