def test_make_floquet_request_for_moment_fails_for_mixed_moment() -> None:
a, b, c = cirq.LineQubit.range(3)
moment = cirq.Moment(
[cirq.FSimGate(theta=np.pi / 4, phi=0.0).on(a, b),
cirq.Z.on(c)])
with pytest.raises(workflow.IncompatibleMomentError):
workflow.make_floquet_request_for_moment(
moment, WITHOUT_CHI_FLOQUET_PHASED_FSIM_CHARACTERIZATION)
def test_convert_to_sycamore_gates_fsim():
q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(cirq.FSimGate(theta=np.pi / 2, phi=np.pi / 6)(q0, q1))
compiled_circuit = circuit.copy()
with cirq.testing.assert_deprecated("Use cirq.optimize_for_target_gateset", deadline='v1.0'):
cgoc.ConvertToSycamoreGates()(compiled_circuit)
cirq.testing.assert_same_circuits(circuit, compiled_circuit)
def test_ideal_sqrt_iswap_inverse_simulates_correctly():
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)],
])
engine_simulator = PhasedFSimEngineSimulator.create_with_ideal_sqrt_iswap()
actual = engine_simulator.final_state_vector(circuit)
expected = cirq.final_state_vector(circuit)
assert cirq.allclose_up_to_global_phase(actual, expected)
def test_result_engine_calibration_none():
result = PhasedFSimCalibrationResult(
parameters={},
gate=cirq.FSimGate(theta=np.pi / 4, phi=0.0),
options=WITHOUT_CHI_FLOQUET_PHASED_FSIM_CHARACTERIZATION,
)
assert result.engine_calibration is None
def test_serialize_fails_on_other_fsim_gates():
a = cirq.GridQubit(1, 2)
b = cirq.GridQubit(2, 2)
op = cirq.FSimGate(phi=0.5, theta=-0.2)(a, b)
with pytest.raises(ValueError, match='Cannot serialize'):
_ = cg.SYC_GATESET.serialize_op(op)
with pytest.raises(ValueError, match='Cannot serialize'):
_ = cg.SQRT_ISWAP_GATESET.serialize_op(op)
def test_serialize_fails_on_symbols():
a = cirq.GridQubit(1, 2)
b = cirq.GridQubit(2, 2)
op = cirq.FSimGate(phi=np.pi / 2, theta=sympy.Symbol('t'))(a, b)
with pytest.raises(ValueError, match='Cannot serialize'):
_ = cg.SYC_GATESET.serialize_op(op)
with pytest.raises(ValueError, match='Cannot serialize'):
_ = cg.SQRT_ISWAP_GATESET.serialize_op(op)
def test_from_dictionary_sqrt_iswap_ideal_when_missing_gate_fails() -> None:
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={})
with pytest.raises(ValueError):
engine_simulator.final_state_vector(circuit)
def test_convert_to_sycamore_gates_fsim():
q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
cirq.FSimGate(theta=np.pi / 2, phi=np.pi / 6)(q0, q1))
compiled_circuit = circuit.copy()
cgoc.ConvertToSycamoreGates()(compiled_circuit)
cirq.testing.assert_same_circuits(circuit, compiled_circuit)
def test_swap_fsim(theta):
a, b = cirq.LineQubit.range(2)
original = cirq.Circuit(
[cirq.rz(0.123).on(a),
cirq.FSimGate(theta=theta, phi=0.123).on(a, b)])
optimized = original.copy()
cirq.EjectZ().optimize_circuit(optimized)
cirq.DropEmptyMoments().optimize_circuit(optimized)
assert optimized[0].operations == (cirq.FSimGate(theta=theta,
phi=0.123).on(a, b), )
# Note: EjectZ drops `global_phase` from Rz turning it into a Z
assert optimized[1].operations == (cirq.Z(b)**(0.123 / np.pi), )
cirq.testing.assert_allclose_up_to_global_phase(cirq.unitary(original),
cirq.unitary(optimized),
atol=1e-8)
def test_xeb_to_calibration_layer():
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(
n_library_circuits=22,
fsim_options=XEBPhasedFSimCharacterizationOptions(
characterize_theta=True,
characterize_zeta=True,
characterize_chi=False,
characterize_gamma=False,
characterize_phi=True,
),
),
)
layer = request.to_calibration_layer()
assert layer == cirq_google.CalibrationLayer(
calibration_type='xeb_phased_fsim_characterization',
program=cirq.Circuit([gate.on(q_00, q_01),
gate.on(q_02, q_03)]),
args={
'n_library_circuits': 22,
'n_combinations': 10,
'cycle_depths': '5_25_50_100_200_300',
'fatol': 5e-3,
'xatol': 5e-3,
'characterize_theta': True,
'characterize_zeta': True,
'characterize_chi': False,
'characterize_gamma': False,
'characterize_phi': True,
'theta_default': 0.0,
'zeta_default': 0.0,
'chi_default': 0.0,
'gamma_default': 0.0,
'phi_default': 0.0,
},
)
# Serialize to proto
calibration = v2.calibration_pb2.FocusedCalibration()
new_layer = calibration.layers.add()
new_layer.calibration_type = layer.calibration_type
for arg in layer.args:
arg_to_proto(layer.args[arg], out=new_layer.args[arg])
cirq_google.SQRT_ISWAP_GATESET.serialize(layer.program,
msg=new_layer.layer)
with open(
os.path.dirname(__file__) +
'/test_data/xeb_calibration_layer.textproto') as f:
desired_textproto = f.read()
layer_str = str(new_layer)
# Fix precision issues
layer_str = re.sub(r'0.004999\d+', '0.005', layer_str)
assert layer_str == desired_textproto
def test_sycamore_gate_tabulation(seed):
base_gate = cirq.unitary(cirq.FSimGate(np.pi / 2, np.pi / 6))
tab = two_qubit_gate_product_tabulation(
base_gate,
0.1,
sample_scaling=2,
random_state=np.random.RandomState(seed))
result = tab.compile_two_qubit_gate(base_gate)
assert result.success
def _create_sqrt_iswap_request(
pairs: Iterable[Tuple[cirq.Qid, cirq.Qid]],
options:
FloquetPhasedFSimCalibrationOptions = ALL_ANGLES_FLOQUET_PHASED_FSIM_CHARACTERIZATION,
) -> FloquetPhasedFSimCalibrationRequest:
return FloquetPhasedFSimCalibrationRequest(gate=cirq.FSimGate(
np.pi / 4, 0.0),
pairs=tuple(pairs),
options=options)
def test_decompose_xx_yy_into_two_fsims_ignoring_single_qubit_ops_fail():
c = _decompose_xx_yy_into_two_fsims_ignoring_single_qubit_ops(
qubits=cirq.LineQubit.range(2),
fsim_gate=cirq.FSimGate(theta=np.pi / 2, phi=0),
canonical_x_kak_coefficient=np.pi / 4,
canonical_y_kak_coefficient=np.pi / 8,
)
np.testing.assert_allclose(
cirq.kak_decomposition(cirq.Circuit(c)).interaction_coefficients,
[np.pi / 4, np.pi / 8, 0])
with pytest.raises(ValueError, match='Failed to synthesize'):
_ = _decompose_xx_yy_into_two_fsims_ignoring_single_qubit_ops(
qubits=cirq.LineQubit.range(2),
fsim_gate=cirq.FSimGate(theta=np.pi / 5, phi=0),
canonical_x_kak_coefficient=np.pi / 4,
canonical_y_kak_coefficient=np.pi / 8,
)
def _create_hopping_ops(
angles: np.ndarray,
pairs: Sequence[Tuple[cirq.Qid,
cirq.Qid]]) -> Iterable[cirq.Operation]:
"""Generator of operations that realize hopping terms with given angles."""
assert len(angles) == len(pairs), ("Length of angles and qubit pairs must "
"be equal")
for angle, qubits in zip(angles, pairs):
yield cirq.FSimGate(-angle, 0.0).on(*qubits)
def _scalar_combiner(theta, theta_scalar, phi, phi_scalar, control_qubits,
control_values):
"""This is a workaround to support symbol scalar multiplication.
See `_eigen_gate_deserializer` for details.
"""
return _optional_control_promote(
cirq.FSimGate(theta=_round(theta) * _round(theta_scalar),
phi=_round(phi) * _round(phi_scalar)),
control_qubits, control_values)
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 _decompose_xx_yy(
desired_interaction: Union[cirq.Operation, np.ndarray,
'cirq.SupportsUnitary'],
*,
available_gate: cirq.Gate,
atol: float = 1e-8,
qubits: Optional[Sequence[cirq.Qid]] = None,
) -> cirq.Circuit:
if qubits is None:
if isinstance(desired_interaction, cirq.Operation):
qubits = desired_interaction.qubits
else:
qubits = cirq.LineQubit.range(2)
kak = cirq.kak_decomposition(desired_interaction)
x, y, z = kak.interaction_coefficients
if abs(z) > atol:
raise ValueError(
f'zz term present in {desired_interaction!r} -> {kak}')
if isinstance(available_gate, cirq.ISwapPowGate):
available_gate = cirq.FSimGate(-np.pi / 2 * available_gate.exponent, 0)
if min(x, y) > np.pi / 4 - atol and abs(
available_gate.phi) < atol and abs(available_gate.theta -
np.pi / 4) < atol:
ops = [
available_gate(*qubits),
cirq.Y.on_each(*qubits),
available_gate(*qubits),
]
elif min(x, y) > np.pi / 4 - atol and abs(
available_gate.phi) < atol and abs(available_gate.theta +
np.pi / 4) < atol:
ops = [
available_gate(*qubits),
available_gate(*qubits),
]
else:
ops = _decompose_xx_yy_into_two_fsims_ignoring_single_qubit_ops(
qubits=qubits,
fsim_gate=available_gate,
canonical_x_kak_coefficient=x,
canonical_y_kak_coefficient=y,
)
result = _fix_single_qubit_gates_around_kak_interaction(
desired=kak,
operations=ops,
qubits=qubits,
)
output = cirq.Circuit(result)
cirq.testing.assert_allclose_up_to_global_phase(
output.unitary(qubit_order=qubits),
cirq.unitary(desired_interaction),
atol=1e-4)
return output
def test_fsim_circuit():
a, b = cirq.LineQubit.range(2)
c = cirq.Circuit(
cirq.FSimGate(np.pi / 2, np.pi).on(a, b),
cirq.FSimGate(-np.pi, np.pi / 2).on(a, b),
)
cirq.testing.assert_has_diagram(
c,
"""
0: ───FSim(0.5π, π)───FSim(-π, 0.5π)───
│ │
1: ───FSim(0.5π, π)───FSim(-π, 0.5π)───
""",
)
cirq.testing.assert_has_diagram(
c,
"""
0: ---FSim(0.5pi, pi)---FSim(-pi, 0.5pi)---
| |
1: ---FSim(0.5pi, pi)---FSim(-pi, 0.5pi)---
""",
use_unicode_characters=False,
)
cirq.testing.assert_has_diagram(
c,
"""
0: ---FSim(1.5707963267948966, pi)---FSim(-pi, 1.5707963267948966)---
| |
1: ---FSim(1.5707963267948966, pi)---FSim(-pi, 1.5707963267948966)---
""",
use_unicode_characters=False,
precision=None,
)
c = cirq.Circuit(
cirq.FSimGate(sympy.Symbol('a') + sympy.Symbol('b'), 0).on(a, b))
cirq.testing.assert_has_diagram(
c,
"""
0: ───FSim(a + b, 0)───
│
1: ───FSim(a + b, 0)───
""",
)
def test_setters_deprecated():
gate = cirq.FSimGate(0.1, 0.1)
assert gate.theta == 0.1
with cirq.testing.assert_deprecated('mutators', deadline='v0.15'):
gate.theta = 0.2
assert gate.theta == 0.2
assert gate.phi == 0.1
with cirq.testing.assert_deprecated('mutators', deadline='v0.15'):
gate.phi = 0.2
assert gate.phi == 0.2
def test_decompose_preserving_structure_forwards_args(decompose_mode):
a, b = cirq.LineQubit.range(2)
fc1 = cirq.FrozenCircuit(cirq.SWAP(a, b), cirq.FSimGate(0.1, 0.2).on(a, b))
cop1_1 = cirq.CircuitOperation(fc1).with_tags('test_tag')
cop1_2 = cirq.CircuitOperation(fc1).with_qubit_mapping({a: b, b: a})
fc2 = cirq.FrozenCircuit(cirq.X(a), cop1_1, cop1_2)
cop2 = cirq.CircuitOperation(fc2)
circuit = cirq.Circuit(cop2, cirq.measure(a, b, key='m'))
def keep_func(op: 'cirq.Operation'):
# Only decompose SWAP and X.
return not isinstance(op.gate, (cirq.SwapPowGate, cirq.XPowGate))
def x_to_hzh(op: 'cirq.Operation'):
if isinstance(op.gate, cirq.XPowGate) and op.gate.exponent == 1:
return [
cirq.H(*op.qubits),
cirq.Z(*op.qubits),
cirq.H(*op.qubits),
]
actual = cirq.Circuit(
cirq.decompose(
circuit,
keep=keep_func,
intercepting_decomposer=x_to_hzh
if decompose_mode == 'intercept' else None,
fallback_decomposer=x_to_hzh
if decompose_mode == 'fallback' else None,
preserve_structure=True,
), )
# This should keep the CircuitOperations but decompose their SWAPs.
fc1_decomp = cirq.FrozenCircuit(
cirq.decompose(
fc1,
keep=keep_func,
fallback_decomposer=x_to_hzh,
))
expected = cirq.Circuit(
cirq.CircuitOperation(
cirq.FrozenCircuit(
cirq.H(a),
cirq.Z(a),
cirq.H(a),
cirq.CircuitOperation(fc1_decomp).with_tags('test_tag'),
cirq.CircuitOperation(fc1_decomp).with_qubit_mapping({
a: b,
b: a
}),
)),
cirq.measure(a, b, key='m'),
)
assert actual == expected
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_fsim_eq():
eq = cirq.testing.EqualsTester()
a, b = cirq.LineQubit.range(2)
eq.add_equality_group(cirq.FSimGate(1, 2), cirq.FSimGate(1, 2))
eq.add_equality_group(cirq.FSimGate(2, 1))
eq.add_equality_group(cirq.FSimGate(0, 0))
eq.add_equality_group(cirq.FSimGate(1, 1))
eq.add_equality_group(cirq.FSimGate(1, 2).on(a, b), cirq.FSimGate(1, 2).on(b, a))
def test_phased_fsim_from_fsim_rz(theta, phi, rz_angles_before, rz_angles_after):
f = cirq.PhasedFSimGate.from_fsim_rz(theta, phi, rz_angles_before, rz_angles_after)
q0, q1 = cirq.LineQubit.range(2)
c = cirq.Circuit(
cirq.rz(rz_angles_before[0]).on(q0),
cirq.rz(rz_angles_before[1]).on(q1),
cirq.FSimGate(theta, phi).on(q0, q1),
cirq.rz(rz_angles_after[0]).on(q0),
cirq.rz(rz_angles_after[1]).on(q1),
)
cirq.testing.assert_allclose_up_to_global_phase(cirq.unitary(f), cirq.unitary(c), atol=1e-8)
def generate_circuit(size=4):
qubits = []
for x in range(size):
qubits.append([cirq.GridQubit(x, y) for y in range(size)])
moments = ()
for x in range(size - 1):
for y in range(size):
for _ in range(random.randint(2, 5)):
moments += (cirq.Moment(
[cirq.FSimGate(1, 2)(qubits[x][y], qubits[x + 1][y])]), )
for y in range(size - 1):
for x in range(size):
for _ in range(random.randint(2, 5)):
moments += (cirq.Moment(
[cirq.FSimGate(1, 2)(qubits[x][y], qubits[x][y + 1])]), )
circuit = cirq.Circuit(moments)
return circuit
def test_resolve_parameters():
# After a circuit with symbols was resolved
# Does the resulting circuit still have the same device and grid?
# In general, resolving parameters will result in a strange circuit
# But in this test I am placing a single gate and setting its exponent
circuit = cirq.Circuit()
import sympy
s1 = sympy.Symbol("theta")
s2 = sympy.Symbol("phi")
operation1 = cirq.Z.on(cirq.GridQubit(0, 0))**s1
circuit.append(operation1)
operation2 = cirq.FSimGate(s1, s2).on(cirq.GridQubit(0, 0),
cirq.GridQubit(0, 1))
circuit.append(operation2)
from qflexcirq.interface.qflex_virtual_device import QFlexVirtualDevice
dummy_device = QFlexVirtualDevice()
# Override the function to accept anything
# dummy_device.is_qflex_virt_dev_op = lambda x : True
# Return a single pair gridqubit : index
dummy_device.get_grid_qubits_as_keys = lambda: {
cirq.GridQubit(0, 0): 1,
cirq.GridQubit(0, 1): 2
}
from qflexcirq.interface.qflex_order import QFlexOrder
dummy_order = QFlexOrder("This is a dummy order")
# save the translator
original_translator = QFlexCircuit.translate_cirq_to_qflex
# place a dummy translator
QFlexCircuit.translate_cirq_to_qflex = lambda x, y: "dummy contents"
# Create a QFlexCircuit
qcircuit = QFlexCircuit(circuit, dummy_device, dummy_order)
# put back the translator
QFlexCircuit.translate_cirq_to_qflex = original_translator
param_solver = {"theta": 0.3, "phi": 0.7}
solved_circuit = cirq.protocols.resolve_parameters(qcircuit, param_solver)
assert (solved_circuit[0].operations[0].gate.exponent == 0.3)
assert (solved_circuit[1].operations[0].gate.theta == 0.3)
assert (solved_circuit[1].operations[0].gate.phi == 0.7)
assert (solved_circuit.device is dummy_device)
assert (solved_circuit._own_order is dummy_order)
def test_with_random_gaussian_runs_correctly() -> None:
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)],
cirq.measure(a, b, c, d, key='z'),
]
)
simulator = cirq.Simulator()
engine_simulator = PhasedFSimEngineSimulator.create_with_random_gaussian_sqrt_iswap(
SQRT_ISWAP_PARAMETERS, simulator=simulator
)
actual = engine_simulator.run(circuit, repetitions=20000).measurements['z']
expected = simulator.run(circuit, repetitions=20000).measurements['z']
assert np.allclose(np.average(actual, axis=0), np.average(expected, axis=0), atol=0.075)
def test_serialize_fails_on_symbols():
with cirq.testing.assert_deprecated('SerializableGateSet',
deadline='v0.16',
count=2):
a = cirq.GridQubit(1, 2)
b = cirq.GridQubit(2, 2)
op = cirq.FSimGate(phi=np.pi / 2, theta=sympy.Symbol('t'))(a, b)
with pytest.raises(ValueError, match='Cannot serialize'):
_ = cg.SYC_GATESET.serialize_op(op)
with pytest.raises(ValueError, match='Cannot serialize'):
_ = cg.SQRT_ISWAP_GATESET.serialize_op(op)
def test_test_calibration_request():
a, b = cirq.LineQubit.range(2)
request = TestPhasedFSimCalibrationRequest(
gate=cirq.FSimGate(np.pi / 4, 0.5),
pairs=((a, b),),
)
assert request.to_calibration_layer() is NotImplemented
result = mock.MagicMock(spec=cirq_google.CalibrationResult)
assert request.parse_result(result) is NotImplemented
def test_ampl_damping_error():
t1_ns = 200.0
# Create qubits and circuit
qubits = [cirq.LineQubit(0), cirq.LineQubit(1)]
circuit = cirq.Circuit(
cirq.Moment([cirq.X(qubits[0])]),
cirq.Moment([cirq.CNOT(qubits[0], qubits[1])]),
cirq.Moment([cirq.FSimGate(5 * np.pi / 2, np.pi).on_each(qubits)]),
cirq.Moment([
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1')
]),
)
# Create noise model from NoiseProperties object with specified noise
prop = NoiseProperties(t1_ns=t1_ns)
noise_model = NoiseModelFromNoiseProperties(prop)
noisy_circuit = cirq.Circuit(noise_model.noisy_moments(circuit, qubits))
# Insert expected channels to circuit
expected_circuit = cirq.Circuit(
cirq.Moment([cirq.X(qubits[0])]),
cirq.Moment(
[cirq.amplitude_damp(1 - np.exp(-25.0 / t1_ns)).on_each(qubits)]),
cirq.Moment([cirq.CNOT(qubits[0], qubits[1])]),
cirq.Moment(
[cirq.amplitude_damp(1 - np.exp(-25.0 / t1_ns)).on_each(qubits)]),
cirq.Moment([cirq.FSimGate(np.pi / 2, np.pi).on_each(qubits)]),
cirq.Moment(
[cirq.amplitude_damp(1 - np.exp(-12.0 / t1_ns)).on_each(qubits)]),
cirq.Moment([
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1')
]),
cirq.Moment([
cirq.amplitude_damp(1 - np.exp(-4000.0 / t1_ns)).on_each(qubits)
]),
)
assert_equivalent_op_tree(expected_circuit, noisy_circuit)
def test_from_dictionary_sqrt_iswap_simulates_correctly() -> 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}
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)
