def test_xeb_parse_result():
q_00, q_01, q_02, q_03 = [cirq.GridQubit(0, index) for index in range(4)]
gate = cirq.FSimGate(theta=np.pi / 4, phi=0.0)
request = XEBPhasedFSimCalibrationRequest(
gate=gate,
pairs=((q_00, q_01), (q_02, q_03)),
options=XEBPhasedFSimCalibrationOptions(
fsim_options=XEBPhasedFSimCharacterizationOptions(
characterize_theta=False,
characterize_zeta=False,
characterize_chi=False,
characterize_gamma=False,
characterize_phi=True,
)),
)
result = _load_xeb_results_textproto()
assert request.parse_result(result) == PhasedFSimCalibrationResult(
parameters={
(q_00, q_01): PhasedFSimCharacterization(phi=0.0,
theta=-0.7853981),
(q_02, q_03): PhasedFSimCharacterization(phi=0.0,
theta=-0.7853981),
},
gate=gate,
options=request.options,
)
def test_get_parameters():
q_00, q_01, q_02, q_03 = [cirq.GridQubit(0, index) for index in range(4)]
gate = cirq.FSimGate(theta=np.pi / 4, phi=0.0)
result = PhasedFSimCalibrationResult(
parameters={
(q_00, q_01):
PhasedFSimCharacterization(theta=0.1,
zeta=0.2,
chi=None,
gamma=None,
phi=0.3),
(q_02, q_03):
PhasedFSimCharacterization(theta=0.4,
zeta=0.5,
chi=None,
gamma=None,
phi=0.6),
},
gate=gate,
options=FloquetPhasedFSimCalibrationOptions(
characterize_theta=True,
characterize_zeta=True,
characterize_chi=False,
characterize_gamma=False,
characterize_phi=True,
),
)
assert result.get_parameters(q_00, q_01) == PhasedFSimCharacterization(
theta=0.1, zeta=0.2, chi=None, gamma=None, phi=0.3)
assert result.get_parameters(q_01, q_00) == PhasedFSimCharacterization(
theta=0.1, zeta=-0.2, chi=None, gamma=None, phi=0.3)
assert result.get_parameters(q_02, q_03) == PhasedFSimCharacterization(
theta=0.4, zeta=0.5, chi=None, gamma=None, phi=0.6)
assert result.get_parameters(q_00, q_03) is None
def test_asdict():
characterization_angles = {
'theta': 0.1,
'zeta': 0.2,
'chi': 0.3,
'gamma': 0.4,
'phi': 0.5
}
characterization = PhasedFSimCharacterization(**characterization_angles)
assert characterization.asdict() == characterization_angles
def test_merge_matching_results_when_incompatible_fails():
q_00, q_01, q_02, q_03 = [cirq.GridQubit(0, index) for index in range(4)]
gate = cirq.FSimGate(theta=np.pi / 4, phi=0.0)
options = WITHOUT_CHI_FLOQUET_PHASED_FSIM_CHARACTERIZATION
parameters_1 = {
(q_00, q_01):
PhasedFSimCharacterization(theta=0.1,
zeta=0.2,
chi=None,
gamma=None,
phi=0.3)
}
parameters_2 = {
(q_02, q_03):
PhasedFSimCharacterization(theta=0.4,
zeta=0.5,
chi=None,
gamma=None,
phi=0.6)
}
with pytest.raises(ValueError):
results = [
PhasedFSimCalibrationResult(parameters=parameters_1,
gate=gate,
options=options),
PhasedFSimCalibrationResult(parameters=parameters_1,
gate=gate,
options=options),
]
assert merge_matching_results(results)
with pytest.raises(ValueError):
results = [
PhasedFSimCalibrationResult(parameters=parameters_1,
gate=gate,
options=options),
PhasedFSimCalibrationResult(parameters=parameters_2,
gate=cirq.CZ,
options=options),
]
assert merge_matching_results(results)
with pytest.raises(ValueError):
results = [
PhasedFSimCalibrationResult(parameters=parameters_1,
gate=gate,
options=options),
PhasedFSimCalibrationResult(
parameters=parameters_2,
gate=gate,
options=ALL_ANGLES_FLOQUET_PHASED_FSIM_CHARACTERIZATION,
),
]
assert merge_matching_results(results)
def test_all_none():
assert PhasedFSimCharacterization().all_none()
characterization_angles = {
'theta': 0.1,
'zeta': 0.2,
'chi': 0.3,
'gamma': 0.4,
'phi': 0.5
}
for angle, value in characterization_angles.items():
assert not PhasedFSimCharacterization(**{angle: value}).all_none()
def test_parameters_for_qubits_swapped():
characterization = PhasedFSimCharacterization(theta=0.1,
zeta=0.2,
chi=0.3,
gamma=0.4,
phi=0.5)
assert characterization.parameters_for_qubits_swapped(
) == PhasedFSimCharacterization(theta=0.1,
zeta=-0.2,
chi=-0.3,
gamma=0.4,
phi=0.5)
def test_options_phase_corrected_override():
assert (ALL_ANGLES_FLOQUET_PHASED_FSIM_CHARACTERIZATION.
zeta_chi_gamma_correction_override() == PhasedFSimCharacterization(
zeta=0.0, chi=0.0, gamma=0.0))
assert (FloquetPhasedFSimCalibrationOptions(
characterize_theta=False,
characterize_zeta=False,
characterize_chi=False,
characterize_gamma=False,
characterize_phi=False,
).zeta_chi_gamma_correction_override() == PhasedFSimCharacterization())
def test_any_none():
characterization_angles = {
'theta': 0.1,
'zeta': 0.2,
'chi': 0.3,
'gamma': 0.4,
'phi': 0.5
}
assert not PhasedFSimCharacterization(**characterization_angles).any_none()
for angle in characterization_angles:
none_angles = dict(characterization_angles)
del none_angles[angle]
assert PhasedFSimCharacterization(**none_angles).any_none()
def test_to_zphase_unknown_gate_raises_error():
q0, q1, q2 = cirq.GridQubit.rect(1, 3)
result_1 = PhasedFSimCalibrationResult(
{
(q0, q1): PhasedFSimCharacterization(zeta=0.1, gamma=0.2),
(q1, q2): PhasedFSimCharacterization(zeta=0.3, gamma=0.4),
},
gate=cirq.CZPowGate(),
options=WITHOUT_CHI_FLOQUET_PHASED_FSIM_CHARACTERIZATION,
)
with pytest.raises(
ValueError,
match="Only 'SycamoreGate' and 'ISwapPowGate' are supported"):
_ = to_zphase_data([result_1])
def test_phase_calibrated_fsim_gate_as_characterized_phased_fsim_gate(
phase_exponent: float):
a, b = cirq.LineQubit.range(2)
ideal_gate = cirq.FSimGate(theta=np.pi / 4, phi=0.0)
characterized_gate = cirq.PhasedFSimGate(theta=ideal_gate.theta,
zeta=0.1,
chi=0.2,
gamma=0.3,
phi=ideal_gate.phi)
parameters = PhasedFSimCharacterization(
theta=ideal_gate.theta,
zeta=characterized_gate.zeta,
chi=characterized_gate.chi,
gamma=characterized_gate.gamma,
phi=ideal_gate.phi,
)
calibrated = PhaseCalibratedFSimGate(ideal_gate,
phase_exponent=phase_exponent)
phased_gate = calibrated.as_characterized_phased_fsim_gate(parameters).on(
a, b)
assert np.allclose(
cirq.unitary(phased_gate),
cirq.unitary(
cirq.Circuit([
[cirq.Z(a)**-phase_exponent,
cirq.Z(b)**phase_exponent],
characterized_gate.on(a, b),
[cirq.Z(a)**phase_exponent,
cirq.Z(b)**-phase_exponent],
])),
)
def test_phase_calibrated_fsim_gate_compensated(phase_exponent: float):
a, b = cirq.LineQubit.range(2)
ideal_gate = cirq.FSimGate(theta=np.pi / 4, phi=0.0)
characterized_gate = cirq.PhasedFSimGate(theta=ideal_gate.theta,
zeta=0.1,
chi=0.2,
gamma=0.3,
phi=ideal_gate.phi)
parameters = PhasedFSimCharacterization(
theta=ideal_gate.theta,
zeta=characterized_gate.zeta,
chi=characterized_gate.chi,
gamma=characterized_gate.gamma,
phi=ideal_gate.phi,
)
calibrated = PhaseCalibratedFSimGate(ideal_gate,
phase_exponent=phase_exponent)
# Passing characterized_gate as engine_gate simulates the hardware execution.
operations = calibrated.with_zeta_chi_gamma_compensated(
(a, b), parameters, engine_gate=characterized_gate)
cirq.testing.assert_allclose_up_to_global_phase(
cirq.unitary(cirq.Circuit(operations)),
cirq.unitary(
cirq.Circuit([
[cirq.Z(a)**-phase_exponent,
cirq.Z(b)**phase_exponent],
ideal_gate.on(a, b),
[cirq.Z(a)**phase_exponent,
cirq.Z(b)**-phase_exponent],
])),
atol=1e-8,
)
def sample_gate(_1: cirq.Qid, _2: cirq.Qid,
gate: cirq.FSimGate) -> PhasedFSimCharacterization:
_assert_inv_sqrt_iswap_like(gate)
return PhasedFSimCharacterization(theta=np.pi / 4,
zeta=0.0,
chi=0.0,
gamma=0.0,
phi=0.0)
def test_run_characterization_with_simulator():
q_00, q_01, q_02, q_03 = [cirq.GridQubit(0, index) for index in range(4)]
gate = SQRT_ISWAP_GATE
request = FloquetPhasedFSimCalibrationRequest(
gate=gate,
pairs=((q_00, q_01), (q_02, q_03)),
options=FloquetPhasedFSimCalibrationOptions(
characterize_theta=True,
characterize_zeta=True,
characterize_chi=False,
characterize_gamma=False,
characterize_phi=True,
),
)
simulator = PhasedFSimEngineSimulator.create_with_ideal_sqrt_iswap()
actual = workflow.run_calibrations([request], simulator)
assert actual == [
PhasedFSimCalibrationResult(
parameters={
(q_00, q_01):
PhasedFSimCharacterization(theta=np.pi / 4,
zeta=0.0,
chi=None,
gamma=None,
phi=0.0),
(q_02, q_03):
PhasedFSimCharacterization(theta=np.pi / 4,
zeta=0.0,
chi=None,
gamma=None,
phi=0.0),
},
gate=SQRT_ISWAP_GATE,
options=FloquetPhasedFSimCalibrationOptions(
characterize_theta=True,
characterize_zeta=True,
characterize_chi=False,
characterize_gamma=False,
characterize_phi=True,
),
)
]
def sample_gate(a: cirq.Qid, b: cirq.Qid,
gate: cirq.FSimGate) -> PhasedFSimCharacterization:
_assert_inv_sqrt_iswap_like(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
def sample_gate(a: cirq.Qid, b: cirq.Qid,
gate: cirq.FSimGate) -> PhasedFSimCharacterization:
assert isinstance(gate,
cirq.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
def test_result_override():
q_00, q_01, q_02, q_03 = [cirq.GridQubit(0, index) for index in range(4)]
gate = cirq.FSimGate(theta=np.pi / 4, phi=0.0)
options = WITHOUT_CHI_FLOQUET_PHASED_FSIM_CHARACTERIZATION
result = PhasedFSimCalibrationResult(
parameters={
(q_00, q_01):
PhasedFSimCharacterization(theta=0.1,
zeta=0.2,
chi=None,
gamma=0.4,
phi=0.5),
(q_02, q_03):
PhasedFSimCharacterization(theta=0.6,
zeta=0.7,
chi=None,
gamma=0.9,
phi=1.0),
},
gate=gate,
options=options,
)
overridden = result.override(options.zeta_chi_gamma_correction_override())
assert overridden == PhasedFSimCalibrationResult(
parameters={
(q_00, q_01):
PhasedFSimCharacterization(theta=0.1,
zeta=0.0,
chi=None,
gamma=0.0,
phi=0.5),
(q_02, q_03):
PhasedFSimCharacterization(theta=0.6,
zeta=0.0,
chi=None,
gamma=0.0,
phi=1.0),
},
gate=gate,
options=WITHOUT_CHI_FLOQUET_PHASED_FSIM_CHARACTERIZATION,
)
def sample_gate(
a: cirq.Qid, b: cirq.Qid, gate: cirq.FSimGate
) -> PhasedFSimCharacterization:
pair_parameters = None
swapped = False
if (a, b) in parameters:
pair_parameters = parameters[(a, b)].get(gate)
elif (b, a) in parameters:
pair_parameters = parameters[(b, a)].get(gate)
swapped = True
if pair_parameters is None:
raise ValueError(f'Missing parameters for value for pair {(a, b)} and gate {gate}.')
if not isinstance(pair_parameters, PhasedFSimCharacterization):
pair_parameters = PhasedFSimCharacterization(**pair_parameters)
if swapped:
pair_parameters = pair_parameters.parameters_for_qubits_swapped()
return pair_parameters
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)
def test_merge_matching_results():
q_00, q_01, q_02, q_03 = [cirq.GridQubit(0, index) for index in range(4)]
gate = cirq.FSimGate(theta=np.pi / 4, phi=0.0)
options = WITHOUT_CHI_FLOQUET_PHASED_FSIM_CHARACTERIZATION
parameters_1 = {
(q_00, q_01):
PhasedFSimCharacterization(theta=0.1,
zeta=0.2,
chi=None,
gamma=None,
phi=0.3),
}
parameters_2 = {
(q_02, q_03):
PhasedFSimCharacterization(theta=0.4,
zeta=0.5,
chi=None,
gamma=None,
phi=0.6),
}
results = [
PhasedFSimCalibrationResult(
parameters=parameters_1,
gate=gate,
options=options,
),
PhasedFSimCalibrationResult(
parameters=parameters_2,
gate=gate,
options=options,
),
]
assert merge_matching_results(results) == PhasedFSimCalibrationResult(
parameters={
**parameters_1,
**parameters_2
},
gate=gate,
options=options,
)
def sample_gate(_1: cirq.Qid, _2: cirq.Qid,
gate: cirq.FSimGate) -> PhasedFSimCharacterization:
_assert_inv_sqrt_iswap_like(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),
)
def get_calibrations(
self, requests: Sequence[PhasedFSimCalibrationRequest]
) -> List[PhasedFSimCalibrationResult]:
"""Retrieves the calibration that matches the requests
Args:
requests: Calibration requests to obtain.
Returns:
Calibration results that reflect the internal state of simulator.
Raises:
ValueError: If supplied type of request is not supported or if the request contains
and unsupported gate.
"""
results = []
for request in requests:
if isinstance(request, FloquetPhasedFSimCalibrationRequest):
options = request.options
characterize_theta = options.characterize_theta
characterize_zeta = options.characterize_zeta
characterize_chi = options.characterize_chi
characterize_gamma = options.characterize_gamma
characterize_phi = options.characterize_phi
else:
raise ValueError(f'Unsupported calibration request {request}')
translated = self.gates_translator(request.gate)
if translated is None:
raise ValueError(
f'Calibration request contains unsupported gate {request.gate}'
)
parameters = {}
for a, b in request.pairs:
drifted = self.create_gate_with_drift(a, b, translated)
parameters[a, b] = PhasedFSimCharacterization(
theta=cast(float, drifted.theta)
if characterize_theta else None,
zeta=cast(float, drifted.zeta)
if characterize_zeta else None,
chi=cast(float, drifted.chi) if characterize_chi else None,
gamma=cast(float, drifted.gamma)
if characterize_gamma else None,
phi=cast(float, drifted.phi) if characterize_phi else None,
)
results.append(
PhasedFSimCalibrationResult(parameters=parameters,
gate=request.gate,
options=options))
return results
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),
)
def test_override_by():
characterization = PhasedFSimCharacterization(theta=0.1, zeta=0.2, chi=0.3)
other = PhasedFSimCharacterization(gamma=0.4, phi=0.5, theta=0.6)
assert characterization.override_by(other) == PhasedFSimCharacterization(
theta=0.6, zeta=0.2, chi=0.3, gamma=0.4, phi=0.5)
def test_run_characterization():
q_00, q_01, q_02, q_03 = [cirq.GridQubit(0, index) for index in range(4)]
gate = cirq.FSimGate(theta=np.pi / 4, phi=0.0)
request = FloquetPhasedFSimCalibrationRequest(
gate=gate,
pairs=((q_00, q_01), (q_02, q_03)),
options=FloquetPhasedFSimCalibrationOptions(
characterize_theta=True,
characterize_zeta=True,
characterize_chi=False,
characterize_gamma=False,
characterize_phi=True,
),
)
result = cirq_google.CalibrationResult(
code=cirq_google.api.v2.calibration_pb2.SUCCESS,
error_message=None,
token=None,
valid_until=None,
metrics=cirq_google.Calibration(
cirq_google.api.v2.metrics_pb2.MetricsSnapshot(metrics=[
cirq_google.api.v2.metrics_pb2.Metric(
name='angles',
targets=[
'0_qubit_a',
'0_qubit_b',
'0_theta_est',
'0_zeta_est',
'0_phi_est',
'1_qubit_a',
'1_qubit_b',
'1_theta_est',
'1_zeta_est',
'1_phi_est',
],
values=[
cirq_google.api.v2.metrics_pb2.Value(str_val='0_0'),
cirq_google.api.v2.metrics_pb2.Value(str_val='0_1'),
cirq_google.api.v2.metrics_pb2.Value(double_val=0.1),
cirq_google.api.v2.metrics_pb2.Value(double_val=0.2),
cirq_google.api.v2.metrics_pb2.Value(double_val=0.3),
cirq_google.api.v2.metrics_pb2.Value(str_val='0_2'),
cirq_google.api.v2.metrics_pb2.Value(str_val='0_3'),
cirq_google.api.v2.metrics_pb2.Value(double_val=0.4),
cirq_google.api.v2.metrics_pb2.Value(double_val=0.5),
cirq_google.api.v2.metrics_pb2.Value(double_val=0.6),
],
)
])),
)
job = cirq_google.engine.EngineJob('', '', '', None)
job._calibration_results = [result]
engine = mock.MagicMock(spec=cirq_google.Engine)
engine.run_calibration.return_value = job
progress_calls = []
def progress(step: int, steps: int) -> None:
progress_calls.append((step, steps))
actual = workflow.run_calibrations([request],
engine,
'qproc',
cirq_google.FSIM_GATESET,
progress_func=progress)
expected = [
PhasedFSimCalibrationResult(
parameters={
(q_00, q_01):
PhasedFSimCharacterization(theta=0.1,
zeta=0.2,
chi=None,
gamma=None,
phi=0.3),
(q_02, q_03):
PhasedFSimCharacterization(theta=0.4,
zeta=0.5,
chi=None,
gamma=None,
phi=0.6),
},
gate=gate,
options=FloquetPhasedFSimCalibrationOptions(
characterize_theta=True,
characterize_zeta=True,
characterize_chi=False,
characterize_gamma=False,
characterize_phi=True,
),
)
]
assert actual == expected
assert progress_calls == [(1, 1)]
def _make_zeta_chi_gamma_compensation(
circuit_with_calibration: CircuitWithCalibration,
characterizations: List[PhasedFSimCalibrationResult],
gates_translator: Callable[[Gate], Optional[PhaseCalibratedFSimGate]],
permit_mixed_moments: bool,
) -> CircuitWithCalibration:
if permit_mixed_moments:
raise NotImplementedError(
'Mixed moments compensation ist supported yet')
if len(circuit_with_calibration.circuit) != len(
circuit_with_calibration.moment_to_calibration):
raise ValueError('Moment allocations does not match circuit length')
default_phases = PhasedFSimCharacterization(zeta=0.0, chi=0.0, gamma=0.0)
compensated = Circuit()
compensated_moment_to_calibration: List[Optional[int]] = []
for moment, characterization_index in zip(
circuit_with_calibration.circuit,
circuit_with_calibration.moment_to_calibration):
parameters = None
if characterization_index is not None:
parameters = characterizations[characterization_index]
decompositions: List[Tuple[Tuple[Operation, ...], ...]] = []
other: List[Operation] = []
new_moment_moment_to_calibration: Optional[List[Optional[int]]] = None
for op in moment:
if not isinstance(op, GateOperation):
raise IncompatibleMomentError(
'Moment contains operation different than GateOperation')
if isinstance(op.gate, _CALIBRATION_IRRELEVANT_GATES):
other.append(op)
continue
a, b = op.qubits
translated = gates_translator(op.gate)
if translated is None:
raise IncompatibleMomentError(
f'Moment {moment} contains unsupported non-single qubit operation {op}'
)
if parameters is None:
raise ValueError(
f'Missing characterization data for moment {moment}')
pair_parameters = parameters.get_parameters(a, b)
if pair_parameters is None:
raise ValueError(
f'Missing characterization data for pair {(a, b)} in {parameters}'
)
pair_parameters = pair_parameters.merge_with(default_phases)
corrections = FSimPhaseCorrections.from_characterization(
(a, b),
translated,
pair_parameters,
characterization_index,
)
decompositions.append(corrections.operations)
if new_moment_moment_to_calibration is None:
new_moment_moment_to_calibration = corrections.moment_to_calibration
else:
assert (
new_moment_moment_to_calibration ==
corrections.moment_to_calibration
), f'Inconsistent decompositions with a moment {moment}'
if other and decompositions:
raise IncompatibleMomentError(
f'Moment {moment} contains mixed operations')
elif other:
compensated += Moment(other)
compensated_moment_to_calibration.append(characterization_index)
elif decompositions:
for operations in itertools.zip_longest(*decompositions,
fillvalue=()):
compensated += Moment(operations)
assert new_moment_moment_to_calibration is not None # Required for mypy
compensated_moment_to_calibration += new_moment_moment_to_calibration
return CircuitWithCalibration(compensated,
compensated_moment_to_calibration)
def create_with_random_gaussian_sqrt_iswap(
cls,
mean: PhasedFSimCharacterization = SQRT_ISWAP_INV_PARAMETERS,
*,
simulator: Optional[cirq.Simulator] = None,
sigma: PhasedFSimCharacterization = PhasedFSimCharacterization(
theta=0.02, zeta=0.05, chi=0.05, gamma=0.05, phi=0.02),
random_or_seed: cirq.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.
Raises:
ValueError: If not all mean values were supplied.
"""
if mean.any_none():
raise ValueError(
f'All mean values must be provided, got mean of {mean}')
rand = value.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: cirq.Qid, _2: cirq.Qid,
gate: cirq.FSimGate) -> PhasedFSimCharacterization:
assert isinstance(gate,
cirq.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 = cirq.Simulator()
return cls(simulator,
drift_generator=sample_gate,
gates_translator=try_convert_sqrt_iswap_to_fsim)
def test_run_floquet_characterization_for_moments():
q_00, q_01, q_02, q_03 = [cirq.GridQubit(0, index) for index in range(4)]
gate = cirq.FSimGate(theta=np.pi / 4, phi=0.0)
circuit = cirq.Circuit([gate.on(q_00, q_01), gate.on(q_02, q_03)])
options = FloquetPhasedFSimCalibrationOptions(
characterize_theta=True,
characterize_zeta=True,
characterize_chi=False,
characterize_gamma=False,
characterize_phi=True,
)
job = cirq_google.engine.EngineJob('', '', '', None)
job._calibration_results = [
cirq_google.CalibrationResult(
code=cirq_google.api.v2.calibration_pb2.SUCCESS,
error_message=None,
token=None,
valid_until=None,
metrics=cirq_google.Calibration(
cirq_google.api.v2.metrics_pb2.MetricsSnapshot(metrics=[
cirq_google.api.v2.metrics_pb2.Metric(
name='angles',
targets=[
'0_qubit_a',
'0_qubit_b',
'0_theta_est',
'0_zeta_est',
'0_phi_est',
'1_qubit_a',
'1_qubit_b',
'1_theta_est',
'1_zeta_est',
'1_phi_est',
],
values=[
cirq_google.api.v2.metrics_pb2.Value(
str_val='0_0'),
cirq_google.api.v2.metrics_pb2.Value(
str_val='0_1'),
cirq_google.api.v2.metrics_pb2.Value(
double_val=0.1),
cirq_google.api.v2.metrics_pb2.Value(
double_val=0.2),
cirq_google.api.v2.metrics_pb2.Value(
double_val=0.3),
cirq_google.api.v2.metrics_pb2.Value(
str_val='0_2'),
cirq_google.api.v2.metrics_pb2.Value(
str_val='0_3'),
cirq_google.api.v2.metrics_pb2.Value(
double_val=0.4),
cirq_google.api.v2.metrics_pb2.Value(
double_val=0.5),
cirq_google.api.v2.metrics_pb2.Value(
double_val=0.6),
],
)
])),
)
]
engine = mock.MagicMock(spec=cirq_google.Engine)
engine.run_calibration.return_value = job
circuit_with_calibration, requests = workflow.run_floquet_characterization_for_moments(
circuit, engine, 'qproc', cirq_google.FSIM_GATESET, options=options)
assert requests == [
PhasedFSimCalibrationResult(
parameters={
(q_00, q_01):
PhasedFSimCharacterization(theta=0.1,
zeta=0.2,
chi=None,
gamma=None,
phi=0.3),
(q_02, q_03):
PhasedFSimCharacterization(theta=0.4,
zeta=0.5,
chi=None,
gamma=None,
phi=0.6),
},
gate=gate,
options=options,
)
]
assert circuit_with_calibration.circuit == circuit
assert circuit_with_calibration.moment_to_calibration == [0]
def test_merge_with():
characterization = PhasedFSimCharacterization(theta=0.1, zeta=0.2, chi=0.3)
other = PhasedFSimCharacterization(gamma=0.4, phi=0.5, theta=0.6)
assert characterization.merge_with(other) == PhasedFSimCharacterization(
theta=0.1, zeta=0.2, chi=0.3, gamma=0.4, phi=0.5)
def test_zeta_chi_gamma_calibration_for_moments_invalid_argument_fails(
) -> None:
a, b, c = cirq.LineQubit.range(3)
with pytest.raises(ValueError):
circuit_with_calibration = workflow.CircuitWithCalibration(
cirq.Circuit(), [1])
workflow.make_zeta_chi_gamma_compensation_for_moments(
circuit_with_calibration, [])
with pytest.raises(ValueError):
circuit_with_calibration = workflow.CircuitWithCalibration(
cirq.Circuit(SQRT_ISWAP_GATE.on(a, b)), [None])
workflow.make_zeta_chi_gamma_compensation_for_moments(
circuit_with_calibration, [])
with pytest.raises(ValueError):
circuit_with_calibration = workflow.CircuitWithCalibration(
cirq.Circuit(SQRT_ISWAP_GATE.on(a, b)), [0])
characterizations = [
PhasedFSimCalibrationResult(
parameters={},
gate=SQRT_ISWAP_GATE,
options=WITHOUT_CHI_FLOQUET_PHASED_FSIM_CHARACTERIZATION,
)
]
workflow.make_zeta_chi_gamma_compensation_for_moments(
circuit_with_calibration, characterizations)
with pytest.raises(workflow.IncompatibleMomentError):
circuit_with_calibration = workflow.CircuitWithCalibration(
cirq.Circuit(cirq.GlobalPhaseOperation(coefficient=1.0)), [None])
workflow.make_zeta_chi_gamma_compensation_for_moments(
circuit_with_calibration, [])
with pytest.raises(workflow.IncompatibleMomentError):
circuit_with_calibration = workflow.CircuitWithCalibration(
cirq.Circuit(cirq.CZ.on(a, b)), [None])
workflow.make_zeta_chi_gamma_compensation_for_moments(
circuit_with_calibration, [])
with pytest.raises(workflow.IncompatibleMomentError):
circuit_with_calibration = workflow.CircuitWithCalibration(
cirq.Circuit([SQRT_ISWAP_GATE.on(a, b),
cirq.Z.on(c)]), [0])
characterizations = [
PhasedFSimCalibrationResult(
parameters={
(a, b):
PhasedFSimCharacterization(theta=0.1,
zeta=0.2,
chi=0.3,
gamma=0.4,
phi=0.5)
},
gate=SQRT_ISWAP_GATE,
options=WITHOUT_CHI_FLOQUET_PHASED_FSIM_CHARACTERIZATION,
)
]
workflow.make_zeta_chi_gamma_compensation_for_moments(
circuit_with_calibration, characterizations)
def test_floquet_parse_result():
q_00, q_01, q_02, q_03 = [cirq.GridQubit(0, index) for index in range(4)]
gate = cirq.FSimGate(theta=np.pi / 4, phi=0.0)
request = FloquetPhasedFSimCalibrationRequest(
gate=gate,
pairs=((q_00, q_01), (q_02, q_03)),
options=FloquetPhasedFSimCalibrationOptions(
characterize_theta=True,
characterize_zeta=True,
characterize_chi=False,
characterize_gamma=False,
characterize_phi=True,
),
)
result = cirq_google.CalibrationResult(
code=cirq_google.api.v2.calibration_pb2.SUCCESS,
error_message=None,
token=None,
valid_until=None,
metrics=cirq_google.Calibration(
cirq_google.api.v2.metrics_pb2.MetricsSnapshot(metrics=[
cirq_google.api.v2.metrics_pb2.Metric(
name='angles',
targets=[
'0_qubit_a',
'0_qubit_b',
'0_theta_est',
'0_zeta_est',
'0_phi_est',
'1_qubit_a',
'1_qubit_b',
'1_theta_est',
'1_zeta_est',
'1_phi_est',
],
values=[
cirq_google.api.v2.metrics_pb2.Value(str_val='0_0'),
cirq_google.api.v2.metrics_pb2.Value(str_val='0_1'),
cirq_google.api.v2.metrics_pb2.Value(double_val=0.1),
cirq_google.api.v2.metrics_pb2.Value(double_val=0.2),
cirq_google.api.v2.metrics_pb2.Value(double_val=0.3),
cirq_google.api.v2.metrics_pb2.Value(str_val='0_2'),
cirq_google.api.v2.metrics_pb2.Value(str_val='0_3'),
cirq_google.api.v2.metrics_pb2.Value(double_val=0.4),
cirq_google.api.v2.metrics_pb2.Value(double_val=0.5),
cirq_google.api.v2.metrics_pb2.Value(double_val=0.6),
],
)
])),
)
assert request.parse_result(result) == PhasedFSimCalibrationResult(
parameters={
(q_00, q_01):
PhasedFSimCharacterization(theta=0.1,
zeta=0.2,
chi=None,
gamma=None,
phi=0.3),
(q_02, q_03):
PhasedFSimCharacterization(theta=0.4,
zeta=0.5,
chi=None,
gamma=None,
phi=0.6),
},
gate=gate,
options=FloquetPhasedFSimCalibrationOptions(
characterize_theta=True,
characterize_zeta=True,
characterize_chi=False,
characterize_gamma=False,
characterize_phi=True,
),
)
