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)