def create_with_ideal_sqrt_iswap(
cls,
*,
simulator: Optional[Simulator] = None,
) -> 'PhasedFSimEngineSimulator':
"""Creates a PhasedFSimEngineSimulator that simulates ideal FSimGate(theta=π/4, phi=0).
Attributes:
simulator: Simulator object to use. When None, a new instance of cirq.Simulator() will
be created.
Returns:
New PhasedFSimEngineSimulator instance.
"""
def sample_gate(_1: Qid, _2: Qid,
gate: FSimGate) -> PhasedFSimCharacterization:
assert isinstance(gate, FSimGate), f'Expected FSimGate, got {gate}'
assert np.isclose(gate.theta, np.pi / 4) and np.isclose(
gate.phi, 0.0), f'Expected ISWAP ** -0.5 like gate, got {gate}'
return PhasedFSimCharacterization(theta=np.pi / 4,
zeta=0.0,
chi=0.0,
gamma=0.0,
phi=0.0)
if simulator is None:
simulator = Simulator()
return cls(simulator,
drift_generator=sample_gate,
gates_translator=try_convert_sqrt_iswap_to_fsim)
def create_from_characterizations_sqrt_iswap(
cls,
characterizations: Iterable[PhasedFSimCalibrationResult],
*,
simulator: Optional[Simulator] = None,
ideal_when_missing_gate: bool = False,
ideal_when_missing_parameter: bool = False,
) -> 'PhasedFSimEngineSimulator':
"""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.
"""
parameters: PhasedFsimDictParameters = {}
for characterization in characterizations:
gate = characterization.gate
if (not isinstance(gate, FSimGate)
or not np.isclose(gate.theta, np.pi / 4)
or not np.isclose(gate.phi, 0.0)):
raise ValueError(
f'Expected ISWAP ** -0.5 like gate, got {gate}')
for (a, b), pair_parameters in characterization.parameters.items():
if a > b:
a, b = b, a
pair_parameters = pair_parameters.parameters_for_qubits_swapped(
)
if (a, b) in parameters:
raise ValueError(
f'Pair ({(a, b)}) appears in multiple moments, multi-moment '
f'simulation is not supported.')
parameters[(a, b)] = pair_parameters
if simulator is None:
simulator = Simulator()
return cls.create_from_dictionary_sqrt_iswap(
parameters,
simulator=simulator,
ideal_when_missing_gate=ideal_when_missing_gate,
ideal_when_missing_parameter=ideal_when_missing_parameter,
)
def create_with_random_gaussian_sqrt_iswap(
cls,
mean: PhasedFSimCharacterization = SQRT_ISWAP_INV_PARAMETERS,
*,
simulator: Optional[Simulator] = None,
sigma: PhasedFSimCharacterization = PhasedFSimCharacterization(
theta=0.02, zeta=0.05, chi=0.05, gamma=0.05, phi=0.02),
random_or_seed: RANDOM_STATE_OR_SEED_LIKE = None,
) -> 'PhasedFSimEngineSimulator':
"""Creates a PhasedFSimEngineSimulator that introduces a random deviation from the mean.
The random deviations are described by a Gaussian distribution of a given mean and sigma,
for each angle respectively.
Each gate for each pair of qubits retains the sampled values for the entire simulation, even
when used multiple times within a circuit.
Attributes:
mean: The mean value for each unitary angle. All parameters must be provided.
simulator: Simulator object to use. When None, a new instance of cirq.Simulator() will
be created.
sigma: The standard deviation for each unitary angle. For sigma parameters that are
None, the mean value will be used without any sampling.
Returns:
New PhasedFSimEngineSimulator instance.
"""
if mean.any_none():
raise ValueError(
f'All mean values must be provided, got mean of {mean}')
rand = parse_random_state(random_or_seed)
def sample_value(gaussian_mean: Optional[float],
gaussian_sigma: Optional[float]) -> float:
assert gaussian_mean is not None
if gaussian_sigma is None:
return gaussian_mean
return rand.normal(gaussian_mean, gaussian_sigma)
def sample_gate(_1: Qid, _2: Qid,
gate: FSimGate) -> PhasedFSimCharacterization:
assert isinstance(gate, FSimGate), f'Expected FSimGate, got {gate}'
assert np.isclose(gate.theta, np.pi / 4) and np.isclose(
gate.phi, 0.0), f'Expected ISWAP ** -0.5 like gate, got {gate}'
return PhasedFSimCharacterization(
theta=sample_value(mean.theta, sigma.theta),
zeta=sample_value(mean.zeta, sigma.zeta),
chi=sample_value(mean.chi, sigma.chi),
gamma=sample_value(mean.gamma, sigma.gamma),
phi=sample_value(mean.phi, sigma.phi),
)
if simulator is None:
simulator = Simulator()
return cls(simulator,
drift_generator=sample_gate,
gates_translator=try_convert_sqrt_iswap_to_fsim)
def create_from_dictionary_sqrt_iswap(
cls,
parameters: PhasedFsimDictParameters,
*,
simulator: Optional[Simulator] = None,
ideal_when_missing_gate: bool = False,
ideal_when_missing_parameter: bool = False,
) -> 'PhasedFSimEngineSimulator':
"""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.
"""
def sample_gate(a: Qid, b: Qid,
gate: FSimGate) -> PhasedFSimCharacterization:
assert isinstance(gate, FSimGate), f'Expected FSimGate, got {gate}'
assert np.isclose(gate.theta, np.pi / 4) and np.isclose(
gate.phi, 0.0), f'Expected ISWAP ** -0.5 like gate, got {gate}'
if (a, b) in parameters:
pair_parameters = parameters[(a, b)]
if not isinstance(pair_parameters, PhasedFSimCharacterization):
pair_parameters = PhasedFSimCharacterization(
**pair_parameters)
elif (b, a) in parameters:
pair_parameters = parameters[(b, a)]
if not isinstance(pair_parameters, PhasedFSimCharacterization):
pair_parameters = PhasedFSimCharacterization(
**pair_parameters)
pair_parameters = pair_parameters.parameters_for_qubits_swapped(
)
elif ideal_when_missing_gate:
pair_parameters = SQRT_ISWAP_INV_PARAMETERS
else:
raise ValueError(f'Missing parameters for pair {(a, b)}')
if pair_parameters.any_none():
if not ideal_when_missing_parameter:
raise ValueError(
f'Missing parameter value for pair {(a, b)}, '
f'parameters={pair_parameters}')
pair_parameters = pair_parameters.merge_with(
SQRT_ISWAP_INV_PARAMETERS)
return pair_parameters
for a, b in parameters:
if a > b:
raise ValueError(
f'All qubit pairs must be given in canonical order where the first qubit is '
f'less than the second, got {a} > {b}')
if simulator is None:
simulator = Simulator()
return cls(simulator,
drift_generator=sample_gate,
gates_translator=try_convert_sqrt_iswap_to_fsim)
def set_simulator(self, **kwargs: KwargTypes) -> Simulator:
return Simulator(seed=kwargs.get("seed"))
