def test_floquet_get_calibrations() -> None:
parameters_ab = cirq_google.PhasedFSimCharacterization(
theta=0.6, zeta=0.5, chi=0.4, gamma=0.3, phi=0.2
)
parameters_bc = cirq_google.PhasedFSimCharacterization(
theta=0.8, zeta=-0.5, chi=-0.4, gamma=-0.3, phi=-0.2
)
parameters_cd_dict = {'theta': 0.1, 'zeta': 0.2, 'chi': 0.3, 'gamma': 0.4, 'phi': 0.5}
parameters_cd = cirq_google.PhasedFSimCharacterization(**parameters_cd_dict)
a, b, c, d = cirq.LineQubit.range(4)
engine_simulator = PhasedFSimEngineSimulator.create_from_dictionary_sqrt_iswap(
parameters={(a, b): parameters_ab, (b, c): parameters_bc, (c, d): parameters_cd_dict}
)
requests = [_create_sqrt_iswap_request([(a, b), (c, d)]), _create_sqrt_iswap_request([(b, c)])]
results = engine_simulator.get_calibrations(requests)
assert results == [
cirq_google.PhasedFSimCalibrationResult(
gate=cirq.FSimGate(np.pi / 4, 0.0),
parameters={(a, b): parameters_ab, (c, d): parameters_cd},
options=ALL_ANGLES_FLOQUET_PHASED_FSIM_CHARACTERIZATION,
),
cirq_google.PhasedFSimCalibrationResult(
gate=cirq.FSimGate(np.pi / 4, 0.0),
parameters={(b, c): parameters_bc},
options=ALL_ANGLES_FLOQUET_PHASED_FSIM_CHARACTERIZATION,
),
]
def test_from_characterizations_sqrt_iswap_simulates_correctly():
parameters_ab = cirq_google.PhasedFSimCharacterization(theta=0.6,
zeta=0.5,
chi=0.4,
gamma=0.3,
phi=0.2)
parameters_bc = cirq_google.PhasedFSimCharacterization(theta=0.8,
zeta=-0.5,
chi=-0.4,
gamma=-0.3,
phi=-0.2)
parameters_cd = cirq_google.PhasedFSimCharacterization(theta=0.1,
zeta=0.2,
chi=0.3,
gamma=0.4,
phi=0.5)
a, b, c, d = cirq.LineQubit.range(4)
circuit = cirq.Circuit([
[cirq.X(a), cirq.Y(c)],
[
cirq.FSimGate(np.pi / 4, 0.0).on(a, b),
cirq.FSimGate(np.pi / 4, 0.0).on(c, d)
],
[cirq.FSimGate(np.pi / 4, 0.0).on(c, b)],
])
expected_circuit = cirq.Circuit([
[cirq.X(a), cirq.X(c)],
[
cirq.PhasedFSimGate(**parameters_ab.asdict()).on(a, b),
cirq.PhasedFSimGate(**parameters_cd.asdict()).on(c, d),
],
[cirq.PhasedFSimGate(**parameters_bc.asdict()).on(b, c)],
])
engine_simulator = PhasedFSimEngineSimulator.create_from_characterizations_sqrt_iswap(
characterizations=[
cirq_google.PhasedFSimCalibrationResult(
gate=cirq.FSimGate(np.pi / 4, 0.0),
parameters={
(a, b): parameters_ab,
(c, d): parameters_cd
},
options=ALL_ANGLES_FLOQUET_PHASED_FSIM_CHARACTERIZATION,
),
cirq_google.PhasedFSimCalibrationResult(
gate=cirq.FSimGate(np.pi / 4, 0.0),
parameters={
(c, b): parameters_bc.parameters_for_qubits_swapped()
},
options=ALL_ANGLES_FLOQUET_PHASED_FSIM_CHARACTERIZATION,
),
])
actual = engine_simulator.final_state_vector(circuit)
expected = cirq.final_state_vector(expected_circuit)
assert cirq.allclose_up_to_global_phase(actual, expected)
def test_from_characterizations_sqrt_iswap_when_invalid_arguments_fails():
parameters_ab = cirq_google.PhasedFSimCharacterization(theta=0.6,
zeta=0.5,
chi=0.4,
gamma=0.3,
phi=0.2)
parameters_bc = cirq_google.PhasedFSimCharacterization(theta=0.8,
zeta=-0.5,
chi=-0.4,
gamma=-0.3,
phi=-0.2)
a, b = cirq.LineQubit.range(2)
with pytest.raises(ValueError, match="multiple moments"):
PhasedFSimEngineSimulator.create_from_characterizations_sqrt_iswap(
characterizations=[
cirq_google.PhasedFSimCalibrationResult(
gate=cirq.FSimGate(np.pi / 4, 0.0),
parameters={(a, b): parameters_ab},
options=ALL_ANGLES_FLOQUET_PHASED_FSIM_CHARACTERIZATION,
),
cirq_google.PhasedFSimCalibrationResult(
gate=cirq.FSimGate(np.pi / 4, 0.0),
parameters={(a, b): parameters_bc},
options=ALL_ANGLES_FLOQUET_PHASED_FSIM_CHARACTERIZATION,
),
])
with pytest.raises(AssertionError, match="Expected ISWA"):
PhasedFSimEngineSimulator.create_from_characterizations_sqrt_iswap(
characterizations=[
cirq_google.PhasedFSimCalibrationResult(
gate=cirq.FSimGate(np.pi / 4, 0.2),
parameters={(a, b): parameters_ab},
options=ALL_ANGLES_FLOQUET_PHASED_FSIM_CHARACTERIZATION,
)
])
with pytest.raises(ValueError, match="unparameterized"):
PhasedFSimEngineSimulator.create_from_characterizations_sqrt_iswap(
characterizations=[
cirq_google.PhasedFSimCalibrationResult(
gate=cirq.FSimGate(np.pi / 4, sympy.Symbol("a")),
parameters={(a, b): parameters_ab},
options=ALL_ANGLES_FLOQUET_PHASED_FSIM_CHARACTERIZATION,
)
])
with pytest.raises(AssertionError, match="Expected FSimGate"):
PhasedFSimEngineSimulator.create_from_characterizations_sqrt_iswap(
characterizations=[
cirq_google.PhasedFSimCalibrationResult(
gate=cirq.CNOT,
parameters={(a, b): parameters_ab},
options=ALL_ANGLES_FLOQUET_PHASED_FSIM_CHARACTERIZATION,
)
])
def test_from_dictionary_sqrt_iswap_simulates_correctly():
parameters_ab = cirq_google.PhasedFSimCharacterization(theta=0.6,
zeta=0.5,
chi=0.4,
gamma=0.3,
phi=0.2)
parameters_bc = cirq_google.PhasedFSimCharacterization(theta=0.8,
zeta=-0.5,
chi=-0.4,
gamma=-0.3,
phi=-0.2)
parameters_cd_dict = {
'theta': 0.1,
'zeta': 0.2,
'chi': 0.3,
'gamma': 0.4,
'phi': 0.5
}
a, b, c, d = cirq.LineQubit.range(4)
circuit = cirq.Circuit([
[cirq.X(a), cirq.Y(c)],
[
cirq.FSimGate(np.pi / 4, 0.0).on(a, b),
cirq.FSimGate(np.pi / 4, 0.0).on(d, c)
],
[cirq.FSimGate(np.pi / 4, 0.0).on(b, c)],
[
cirq.FSimGate(np.pi / 4, 0.0).on(a, b),
cirq.FSimGate(np.pi / 4, 0.0).on(c, d)
],
])
expected_circuit = cirq.Circuit([
[cirq.X(a), cirq.X(c)],
[
cirq.PhasedFSimGate(**parameters_ab.asdict()).on(a, b),
cirq.PhasedFSimGate(**parameters_cd_dict).on(c, d),
],
[cirq.PhasedFSimGate(**parameters_bc.asdict()).on(b, c)],
[
cirq.PhasedFSimGate(**parameters_ab.asdict()).on(a, b),
cirq.PhasedFSimGate(**parameters_cd_dict).on(c, d),
],
])
engine_simulator = PhasedFSimEngineSimulator.create_from_dictionary_sqrt_iswap(
parameters={
(a, b): parameters_ab,
(b, c): parameters_bc,
(c, d): parameters_cd_dict
})
actual = engine_simulator.final_state_vector(circuit)
expected = cirq.final_state_vector(expected_circuit)
assert cirq.allclose_up_to_global_phase(actual, expected)
def test_make_zeta_chi_gamma_compensation_for_operations():
a, b, c, d = cirq.LineQubit.range(4)
parameters_ab = cirq_google.PhasedFSimCharacterization(zeta=0.5,
chi=0.4,
gamma=0.3)
parameters_bc = cirq_google.PhasedFSimCharacterization(zeta=-0.5,
chi=-0.4,
gamma=-0.3)
parameters_cd = cirq_google.PhasedFSimCharacterization(zeta=0.2,
chi=0.3,
gamma=0.4)
parameters_dict = {
(a, b): parameters_ab,
(b, c): parameters_bc,
(c, d): parameters_cd
}
engine_simulator = cirq_google.PhasedFSimEngineSimulator.create_from_dictionary_sqrt_iswap(
parameters={
pair: parameters.merge_with(SQRT_ISWAP_PARAMETERS)
for pair, parameters in parameters_dict.items()
})
circuit = cirq.Circuit([
[cirq.X(a), cirq.Y(c)],
[SQRT_ISWAP_GATE.on(a, b),
SQRT_ISWAP_GATE.on(c, d)],
[SQRT_ISWAP_GATE.on(b, c)],
])
options = cirq_google.FloquetPhasedFSimCalibrationOptions(
characterize_theta=False,
characterize_zeta=True,
characterize_chi=True,
characterize_gamma=True,
characterize_phi=False,
)
characterizations = [
PhasedFSimCalibrationResult(parameters={pair: parameters},
gate=SQRT_ISWAP_GATE,
options=options)
for pair, parameters in parameters_dict.items()
]
calibrated_circuit = workflow.make_zeta_chi_gamma_compensation_for_operations(
circuit,
characterizations,
)
assert cirq.allclose_up_to_global_phase(
engine_simulator.final_state_vector(calibrated_circuit),
cirq.final_state_vector(circuit),
)
def test_floquet_get_calibrations_when_invalid_request_fails() -> None:
parameters_ab = cirq_google.PhasedFSimCharacterization(
theta=0.6, zeta=0.5, chi=0.4, gamma=0.3, phi=0.2
)
a, b = cirq.LineQubit.range(2)
engine_simulator = PhasedFSimEngineSimulator.create_from_dictionary_sqrt_iswap(
parameters={(a, b): parameters_ab}
)
with pytest.raises(ValueError):
engine_simulator.get_calibrations(
[
FloquetPhasedFSimCalibrationRequest(
gate=cirq.FSimGate(np.pi / 4, 0.5),
pairs=((a, b),),
options=ALL_ANGLES_FLOQUET_PHASED_FSIM_CHARACTERIZATION,
)
]
)
with pytest.raises(ValueError):
engine_simulator.get_calibrations(
[
TestPhasedFSimCalibrationRequest(
gate=cirq.FSimGate(np.pi / 4, 0.5),
pairs=((a, b),),
)
]
)
def test_phase_corrected_fsim_operations_with_phase_exponent(
theta: float, zeta: float, chi: float, gamma: float,
phi: float) -> None:
a, b = cirq.LineQubit.range(2)
phase_exponent = 0.5
# Theta is negated to match the phase exponent of 0.5.
expected_gate = cirq.PhasedFSimGate(theta=-theta,
zeta=-zeta,
chi=-chi,
gamma=-gamma,
phi=phi)
expected = cirq.unitary(expected_gate)
corrected = workflow.FSimPhaseCorrections.from_characterization(
(a, b),
PhaseCalibratedFSimGate(cirq.FSimGate(theta=theta, phi=phi),
phase_exponent),
cirq_google.PhasedFSimCharacterization(theta=theta,
zeta=zeta,
chi=chi,
gamma=gamma,
phi=phi),
characterization_index=5,
)
actual = cirq.unitary(corrected.as_circuit())
assert cirq.equal_up_to_global_phase(actual, expected)
assert corrected.moment_to_calibration == [None, 5, None]
def test_from_dictionary_sqrt_iswap_ideal_when_missing_simulates_correctly():
parameters_ab = cirq_google.PhasedFSimCharacterization(theta=0.6,
zeta=0.5,
chi=0.4,
gamma=0.3,
phi=0.2)
parameters_bc = cirq_google.PhasedFSimCharacterization(theta=0.8,
zeta=-0.5,
chi=-0.4)
a, b, c, d = cirq.LineQubit.range(4)
circuit = cirq.Circuit([
[cirq.X(a), cirq.Y(c)],
[
cirq.FSimGate(np.pi / 4, 0.0).on(a, b),
cirq.FSimGate(np.pi / 4, 0.0).on(c, d)
],
[cirq.FSimGate(np.pi / 4, 0.0).on(b, c)],
])
expected_circuit = cirq.Circuit([
[cirq.X(a), cirq.X(c)],
[
cirq.PhasedFSimGate(**parameters_ab.asdict()).on(a, b),
cirq.PhasedFSimGate(**SQRT_ISWAP_INV_PARAMETERS.asdict()).on(c, d),
],
[
cirq.PhasedFSimGate(**parameters_bc.merge_with(
SQRT_ISWAP_INV_PARAMETERS).asdict()).on(b, c)
],
])
engine_simulator = PhasedFSimEngineSimulator.create_from_dictionary_sqrt_iswap(
parameters={
(a, b): parameters_ab,
(b, c): parameters_bc
},
ideal_when_missing_parameter=True,
ideal_when_missing_gate=True,
)
actual = engine_simulator.final_state_vector(circuit)
expected = cirq.final_state_vector(expected_circuit)
assert cirq.allclose_up_to_global_phase(actual, expected)
def test_from_dictionary_sqrt_iswap_fails_when_invalid_parameters() -> None:
a, b = cirq.LineQubit.range(2)
parameters_ab = cirq_google.PhasedFSimCharacterization(
theta=0.6, zeta=0.5, chi=0.4, gamma=0.3, phi=0.2
)
with pytest.raises(ValueError):
PhasedFSimEngineSimulator.create_from_dictionary_sqrt_iswap(
parameters={(b, a): parameters_ab}
)
def test_from_dictionary_sqrt_iswap_ideal_when_missing_parameter_fails() -> None:
parameters_ab = cirq_google.PhasedFSimCharacterization(theta=0.8, zeta=-0.5, chi=-0.4)
a, b = cirq.LineQubit.range(2)
circuit = cirq.Circuit(cirq.FSimGate(np.pi / 4, 0.0).on(a, b))
engine_simulator = PhasedFSimEngineSimulator.create_from_dictionary_sqrt_iswap(
parameters={(a, b): parameters_ab},
)
with pytest.raises(ValueError):
engine_simulator.final_state_vector(circuit)
def test_run_zeta_chi_gamma_calibration_for_moments_no_chi() -> None:
parameters_ab = cirq_google.PhasedFSimCharacterization(theta=np.pi / 4,
zeta=0.5,
gamma=0.3)
parameters_bc = cirq_google.PhasedFSimCharacterization(theta=np.pi / 4,
zeta=-0.5,
gamma=-0.3)
parameters_cd = cirq_google.PhasedFSimCharacterization(theta=np.pi / 4,
zeta=0.2,
gamma=0.4)
a, b, c, d = cirq.LineQubit.range(4)
engine_simulator = cirq_google.PhasedFSimEngineSimulator.create_from_dictionary_sqrt_iswap(
parameters={
(a, b): parameters_ab,
(b, c): parameters_bc,
(c, d): parameters_cd
},
ideal_when_missing_parameter=True,
)
circuit = cirq.Circuit([
[cirq.X(a), cirq.Y(c)],
[SQRT_ISWAP_GATE.on(a, b),
SQRT_ISWAP_GATE.on(c, d)],
[SQRT_ISWAP_GATE.on(b, c)],
])
calibrated_circuit, *_ = workflow.run_zeta_chi_gamma_compensation_for_moments(
circuit,
engine_simulator,
processor_id=None,
gate_set=cirq_google.SQRT_ISWAP_GATESET)
assert cirq.allclose_up_to_global_phase(
engine_simulator.final_state_vector(calibrated_circuit.circuit),
cirq.final_state_vector(circuit),
)
def test_from_characterizations_sqrt_iswap_when_invalid_arguments_fails() -> None:
parameters_ab = cirq_google.PhasedFSimCharacterization(
theta=0.6, zeta=0.5, chi=0.4, gamma=0.3, phi=0.2
)
parameters_bc = cirq_google.PhasedFSimCharacterization(
theta=0.8, zeta=-0.5, chi=-0.4, gamma=-0.3, phi=-0.2
)
a, b = cirq.LineQubit.range(2)
with pytest.raises(ValueError):
PhasedFSimEngineSimulator.create_from_characterizations_sqrt_iswap(
characterizations=[
cirq_google.PhasedFSimCalibrationResult(
gate=cirq.FSimGate(np.pi / 4, 0.0),
parameters={(a, b): parameters_ab},
options=ALL_ANGLES_FLOQUET_PHASED_FSIM_CHARACTERIZATION,
),
cirq_google.PhasedFSimCalibrationResult(
gate=cirq.FSimGate(np.pi / 4, 0.0),
parameters={(a, b): parameters_bc},
options=ALL_ANGLES_FLOQUET_PHASED_FSIM_CHARACTERIZATION,
),
]
)
with pytest.raises(ValueError):
PhasedFSimEngineSimulator.create_from_characterizations_sqrt_iswap(
characterizations=[
cirq_google.PhasedFSimCalibrationResult(
gate=cirq.FSimGate(np.pi / 4, 0.2),
parameters={(a, b): parameters_ab},
options=ALL_ANGLES_FLOQUET_PHASED_FSIM_CHARACTERIZATION,
)
]
)
def test_run_zeta_chi_gamma_calibration_for_moments() -> None:
parameters_ab = cirq_google.PhasedFSimCharacterization(zeta=0.5,
chi=0.4,
gamma=0.3)
parameters_bc = cirq_google.PhasedFSimCharacterization(zeta=-0.5,
chi=-0.4,
gamma=-0.3)
parameters_cd = cirq_google.PhasedFSimCharacterization(zeta=0.2,
chi=0.3,
gamma=0.4)
a, b, c, d = cirq.LineQubit.range(4)
engine_simulator = cirq_google.PhasedFSimEngineSimulator.create_from_dictionary_sqrt_iswap(
parameters={
(a, b): parameters_ab.merge_with(SQRT_ISWAP_PARAMETERS),
(b, c): parameters_bc.merge_with(SQRT_ISWAP_PARAMETERS),
(c, d): parameters_cd.merge_with(SQRT_ISWAP_PARAMETERS),
})
circuit = cirq.Circuit([
[cirq.X(a), cirq.Y(c)],
[SQRT_ISWAP_GATE.on(a, b),
SQRT_ISWAP_GATE.on(c, d)],
[SQRT_ISWAP_GATE.on(b, c)],
])
options = cirq_google.FloquetPhasedFSimCalibrationOptions(
characterize_theta=False,
characterize_zeta=True,
characterize_chi=True,
characterize_gamma=True,
characterize_phi=False,
)
calibrated_circuit, calibrations = workflow.run_zeta_chi_gamma_compensation_for_moments(
circuit,
engine_simulator,
processor_id=None,
gate_set=cirq_google.SQRT_ISWAP_GATESET,
options=options,
)
assert cirq.allclose_up_to_global_phase(
engine_simulator.final_state_vector(calibrated_circuit.circuit),
cirq.final_state_vector(circuit),
)
assert calibrations == [
cirq_google.PhasedFSimCalibrationResult(
gate=SQRT_ISWAP_GATE,
parameters={
(a, b): parameters_ab,
(c, d): parameters_cd
},
options=options,
),
cirq_google.PhasedFSimCalibrationResult(gate=SQRT_ISWAP_GATE,
parameters={
(b, c): parameters_bc
},
options=options),
]
assert calibrated_circuit.moment_to_calibration == [
None, None, 0, None, None, 1, None
]
import cirq_google.calibration.workflow as workflow
from cirq_google.calibration.engine_simulator import PhasedFSimEngineSimulator
from cirq_google.calibration.phased_fsim import (
ALL_ANGLES_FLOQUET_PHASED_FSIM_CHARACTERIZATION,
FloquetPhasedFSimCalibrationOptions,
FloquetPhasedFSimCalibrationRequest,
PhaseCalibratedFSimGate,
PhasedFSimCharacterization,
PhasedFSimCalibrationResult,
WITHOUT_CHI_FLOQUET_PHASED_FSIM_CHARACTERIZATION,
)
SQRT_ISWAP_PARAMETERS = cirq_google.PhasedFSimCharacterization(theta=np.pi / 4,
zeta=0.0,
chi=0.0,
gamma=0.0,
phi=0.0)
SQRT_ISWAP_GATE = cirq.FSimGate(np.pi / 4, 0.0)
def _fsim_identity_converter(
gate: cirq.Gate) -> Optional[PhaseCalibratedFSimGate]:
if isinstance(gate, cirq.FSimGate):
return PhaseCalibratedFSimGate(gate, 0.0)
return None
def test_make_floquet_request_for_moment_none_for_measurements() -> None:
a, b, c, d = cirq.LineQubit.range(4)
moment = cirq.Moment(cirq.measure(a, b, c, d))
