This simulator introduces get_calibrations which allows to simulate
cirq_google.run_characterizations requests. The returned calibration results represent the
internal state of a simulator. Circuits which are run on this simulator are modified to account
for the changes in the unitary parameters as described by the calibration results.
Args
simulator
cirq.Simulator that all the simulation requests are delegated to.
drift_generator
Callable that generates the imperfect parameters for each pair of
qubits and the gate. They are later used for simulation.
gates_translator
Function that translates a gate to a supported FSimGate which will
undergo characterization.
Attributes
gates_translator
Function that translates a gate to a supported FSimGate which will undergo
characterization.
The initial state is assumed to be the all zeros state.
Args
program
The circuit to simulate.
bitstrings
The bitstrings whose amplitudes are desired, input
as an integer array where each integer is formed from measured
qubit values according to qubit_order from most to least
significant qubit, i.e. in big-endian ordering.
param_resolver
Parameters to run with the program.
qubit_order
Determines the canonical ordering of the qubits. This
is often used in specifying the initial state, i.e. the
ordering of the computational basis states.
The initial state is assumed to be the all zeros state.
Args
program
The circuit to simulate.
bitstrings
The bitstrings whose amplitudes are desired, input
as an integer array where each integer is formed from measured
qubit values according to qubit_order from most to least
significant qubit, i.e. in big-endian ordering.
params
Parameters to run with the program.
qubit_order
Determines the canonical ordering of the qubits. This
is often used in specifying the initial state, i.e. the
ordering of the computational basis states.
Returns
An Iterator over lists of amplitudes. The outer dimension indexes
the circuit parameters and the inner dimension indexes bitstrings.
Creates PhasedFSimEngineSimulator with fixed drifts from the characterizations results.
Args
characterizations
Characterization results which are source of the parameters for
each gate.
simulator
Simulator object to use. When None, a new instance of cirq.Simulator() will
be created.
ideal_when_missing_gate
When set and parameters for some gate for a given pair of
qubits are not specified in the parameters dictionary then the
FSimGate(theta=π/4, phi=0) gate parameters will be used. When not set and this
situation occurs, ValueError is thrown during simulation.
ideal_when_missing_parameter
When set and some parameter for some gate for a given pair
of qubits is specified then the matching parameter of FSimGate(theta=π/4, phi=0)
gate will be used. When not set and this situation occurs, ValueError is thrown
during simulation.
Returns
New PhasedFSimEngineSimulator instance.
Raises
ValueError
If the gate was not a gate like ISWAP ** -0.5 or the pair of qubits it
acts on appears in multiple different moments.
Creates PhasedFSimEngineSimulator with fixed drifts.
Args
parameters
Parameters to use for each gate. All keys must be stored in canonical order,
when the first qubit is not greater than the second one.
simulator
Simulator object to use. When None, a new instance of cirq.Simulator() will
be created.
ideal_when_missing_gate
When set and parameters for some gate for a given pair of
qubits are not specified in the parameters dictionary then the
FSimGate(theta=π/4, phi=0) gate parameters will be used. When not set and this
situation occurs, ValueError is thrown during simulation.
ideal_when_missing_parameter
When set and some parameter for some gate for a given pair
of qubits is specified then the matching parameter of FSimGate(theta=π/4, phi=0)
gate will be used. When not set and this situation occurs, ValueError is thrown
during simulation.
Returns
New PhasedFSimEngineSimulator instance.
Raises
ValueError
If missing parameters for the given pair of qubits.
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.
Raises
ValueError
If length of programs is not equal to the length
of params_list or the length of repetitions.
This allows for sweeping over different parameter values,
unlike the run method.
Args
program
The circuit to sample from.
params
Parameters to run with the program.
repetitions
The number of times to sample.
Returns
Result list for this run; one for each possible parameter resolver.
run_sweep_async
run_sweep_async(
program, params, repetitions=1
)
Asynchronously 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
Parameters to run with the program.
repetitions
The number of times to sample.
Returns
Result list for this run; one for each possible parameter resolver.
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.
Raises
ValueError
If a supplied sweep is invalid.
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)) out0 11 12 13 1
Calculates estimated expectation values from samples of a circuit.
Please see also cirq.work.measure_observables for more control over how to measure
a suite of observables.
This method can be run on any device or simulator that supports circuit sampling. Compare
with simulate_expectation_values in simulator.py, which is limited to simulators
but provides exact results.
Args
program
The circuit which prepares a state from which we sample expectation values.
observables
A list of observables for which to calculate expectation values.
num_samples
The number of samples to take. Increasing this value increases the
statistical accuracy of the estimate.
params
Parameters to run with the program.
permit_terminal_measurements
If the provided circuit ends in a measurement, this
method will generate an error unless this is set to True. This is meant to
prevent measurements from ruining expectation value calculations.
Returns
A list of expectation-value lists. The outer index determines the sweep, and the inner
index determines the observable. For instance, results[1][3] would select the fourth
observable measured in the second sweep.
Raises
ValueError
If the number of samples was not positive, if empty observables were
supplied, or if the provided circuit has terminal measurements and
permit_terminal_measurements is true.
Uses amplitude simulation to sample from the given circuit.
This implements the algorithm outlined by Bravyi, Gosset, and Liu in
https://arxiv.org/abs/2112.08499 to more efficiently calculate samples
given an amplitude-based simulator.
Simulators which also implement SimulatesSamples or SimulatesFullState
should prefer run() or simulate(), respectively, as this method
only accelerates sampling for amplitude-based simulators.
Args
circuit
The circuit to simulate.
param_resolver
Parameters to run with the program.
seed
Random state to use as a seed. This must be provided
manually - if the simulator has its own seed, it will not be
used unless it is passed as this argument.
repetitions
The number of repetitions to simulate.
qubit_order
Determines the canonical ordering of the qubits. This
is often used in specifying the initial state, i.e. the
ordering of the computational basis states.
Returns
A dict of bitstrings sampled from the final state of circuit to
the number of occurrences of that bitstring.
Raises
ValueError
if 'circuit' has non-unitary elements, as differences
in behavior between sampling steps break this algorithm.
This method returns a result which allows access to the entire
simulator's final state.
Args
program
The circuit to simulate.
param_resolver
Parameters to run with the program.
qubit_order
Determines the canonical ordering of the qubits. This
is often used in specifying the initial state, i.e. the
ordering of the computational basis states.
initial_state
The initial state for the simulation. The form of
this state depends on the simulation implementation. See
documentation of the implementing class for details.
Returns
SimulationTrialResults for the simulation. Includes the final state.
Returns an iterator of StepResults for each moment simulated.
If the circuit being simulated is empty, a single step result should
be returned with the state being set to the initial state.
Args
circuit
The Circuit to simulate.
param_resolver
A ParamResolver for determining values of Symbols.
qubit_order
Determines the canonical ordering of the qubits. This
is often used in specifying the initial state, i.e. the
ordering of the computational basis states.
initial_state
The initial state for the simulation. This can be
either a raw state or a TActOnArgs. The form of the
raw state depends on the simulation implementation. See
documentation of the implementing class for details.
Returns
Iterator that steps through the simulation, simulating each
moment and returning a StepResult for each moment.
This particular implementation overrides the base implementation such
that an unparameterized prefix circuit is simulated and fed into the
parameterized suffix circuit.
Args
program
The circuit to simulate.
params
Parameters to run with the program.
qubit_order
Determines the canonical ordering of the qubits. This
is often used in specifying the initial state, i.e. the
ordering of the computational basis states.
initial_state
The initial state for the simulation. This can be
either a raw state or an OperationTarget. The form of the
raw state depends on the simulation implementation. See
documentation of the implementing class for details.
Returns
List of SimulationTrialResults for this run, one for each
possible parameter resolver.
View source on GitHub