def test_qubit_order_to_wavefunction_order_matches_np_kron(scheduler): simulator = cg.XmonSimulator() zero = [1, 0] one = [0, 1] result = simulate(simulator, cirq.Circuit.from_ops(cirq.X(Q1)), scheduler, qubit_order=[Q1, Q2]) assert cirq.allclose_up_to_global_phase(result.final_state, np.kron(one, zero)) result = simulate(simulator, cirq.Circuit.from_ops(cirq.X(Q1)), scheduler, qubit_order=[Q2, Q1]) assert cirq.allclose_up_to_global_phase(result.final_state, np.kron(zero, one)) result = simulate(simulator, cirq.Circuit.from_ops(cirq.X(Q1)), scheduler, qubit_order=cirq.QubitOrder.sorted_by(repr)) assert cirq.allclose_up_to_global_phase(result.final_state, np.array(one)) result = simulate(simulator, cirq.Circuit.from_ops(cirq.X(Q1), cirq.Z(Q2)), scheduler, qubit_order=cirq.QubitOrder.sorted_by(repr)) assert cirq.allclose_up_to_global_phase(result.final_state, np.kron(one, zero))
def test_qubit_order_to_wavefunction_order_matches_np_kron(scheduler): simulator = cg.XmonSimulator() zero = [1, 0] one = [0, 1] result = simulate(simulator, cirq.Circuit.from_ops(cirq.X(Q1)), scheduler, qubit_order=[Q1, Q2]) assert cirq.allclose_up_to_global_phase( result.final_state, np.kron(one, zero)) result = simulate(simulator, cirq.Circuit.from_ops(cirq.X(Q1)), scheduler, qubit_order=[Q2, Q1]) assert cirq.allclose_up_to_global_phase( result.final_state, np.kron(zero, one)) result = simulate(simulator, cirq.Circuit.from_ops(cirq.X(Q1)), scheduler, qubit_order=cirq.QubitOrder.sorted_by(repr)) assert cirq.allclose_up_to_global_phase( result.final_state, np.array(one)) result = simulate(simulator, cirq.Circuit.from_ops(cirq.X(Q1), cirq.Z(Q2)), scheduler, qubit_order=cirq.QubitOrder.sorted_by(repr)) assert cirq.allclose_up_to_global_phase( result.final_state, np.kron(one, zero))
def test_bit_flip_order_to_wavefunction_order_matches_np_kron(scheduler): simulator = cg.XmonSimulator() result = simulate(simulator, cirq.Circuit.from_ops(cirq.X(Q1)), scheduler, qubit_order=[Q1, Q2, Q3]) assert cirq.allclose_up_to_global_phase(result.final_state, np.array([0, 0, 0, 0, 1, 0, 0, 0])) result = simulate(simulator, cirq.Circuit.from_ops(cirq.X(Q3)), scheduler, qubit_order=[Q1, Q2, Q3]) assert cirq.allclose_up_to_global_phase(result.final_state, np.array([0, 1, 0, 0, 0, 0, 0, 0])) result = simulate(simulator, cirq.Circuit.from_ops(cirq.X(Q3)), scheduler, qubit_order=[Q3, Q2, Q1]) assert cirq.allclose_up_to_global_phase(result.final_state, np.array([0, 0, 0, 0, 1, 0, 0, 0])) result = simulate(simulator, cirq.Circuit.from_ops(cirq.X(Q3)), scheduler, qubit_order=[Q2, Q3, Q1]) assert cirq.allclose_up_to_global_phase(result.final_state, np.array([0, 0, 1, 0, 0, 0, 0, 0]))
def test_bit_flip_order_to_wavefunction_order_matches_np_kron(scheduler): simulator = cg.XmonSimulator() result = simulate(simulator, cirq.Circuit.from_ops(cirq.X(Q1)), scheduler, qubit_order=[Q1, Q2, Q3]) assert cirq.allclose_up_to_global_phase( result.final_state, np.array([0, 0, 0, 0, 1, 0, 0, 0])) result = simulate(simulator, cirq.Circuit.from_ops(cirq.X(Q3)), scheduler, qubit_order=[Q1, Q2, Q3]) assert cirq.allclose_up_to_global_phase( result.final_state, np.array([0, 1, 0, 0, 0, 0, 0, 0])) result = simulate(simulator, cirq.Circuit.from_ops(cirq.X(Q3)), scheduler, qubit_order=[Q3, Q2, Q1]) assert cirq.allclose_up_to_global_phase( result.final_state, np.array([0, 0, 0, 0, 1, 0, 0, 0])) result = simulate(simulator, cirq.Circuit.from_ops(cirq.X(Q3)), scheduler, qubit_order=[Q2, Q3, Q1]) assert cirq.allclose_up_to_global_phase( result.final_state, np.array([0, 0, 1, 0, 0, 0, 0, 0]))
def test_allclose_up_to_global_phase(): assert cirq.allclose_up_to_global_phase( np.array([1]), np.array([1j])) assert cirq.allclose_up_to_global_phase( np.array([[1]]), np.array([[1]])) assert cirq.allclose_up_to_global_phase( np.array([[1]]), np.array([[-1]])) assert cirq.allclose_up_to_global_phase( np.array([[0]]), np.array([[0]])) assert cirq.allclose_up_to_global_phase( np.array([[1, 2]]), np.array([[1j, 2j]])) assert cirq.allclose_up_to_global_phase( np.array([[1, 2.0000000001]]), np.array([[1j, 2j]])) assert not cirq.allclose_up_to_global_phase( np.array([[1]]), np.array([[1, 0]])) assert not cirq.allclose_up_to_global_phase( np.array([[1]]), np.array([[2]])) assert not cirq.allclose_up_to_global_phase( np.array([[1]]), np.array([[2]]))
def test_convert_to_ion_gates(): q0 = cirq.GridQubit(0, 0) q1 = cirq.GridQubit(0, 1) op = cirq.CNOT(q0, q1) circuit = cirq.Circuit() with pytest.raises(TypeError): cirq.ion.ConvertToIonGates().convert_one(circuit) with pytest.raises(TypeError): cirq.ion.ConvertToIonGates().convert_one(NoUnitary().on(q0)) no_unitary_op = NoUnitary().on(q0) assert cirq.ion.ConvertToIonGates(ignore_failures=True).convert_one( no_unitary_op) == [no_unitary_op] rx = cirq.ion.ConvertToIonGates().convert_one(OtherX().on(q0)) rop = cirq.ion.ConvertToIonGates().convert_one(op) assert cirq.approx_eq( rx, [cirq.PhasedXPowGate(phase_exponent=1.0).on(cirq.GridQubit(0, 0))]) assert cirq.approx_eq(rop, [ cirq.ry(np.pi / 2).on(op.qubits[0]), cirq.ms(np.pi / 4).on(op.qubits[0], op.qubits[1]), cirq.rx(-1 * np.pi / 2).on(op.qubits[0]), cirq.rx(-1 * np.pi / 2).on(op.qubits[1]), cirq.ry(-1 * np.pi / 2).on(op.qubits[0]) ]) rcnot = cirq.ion.ConvertToIonGates().convert_one(OtherCNOT().on(q0, q1)) assert cirq.approx_eq([op for op in rcnot if len(op.qubits) > 1], [cirq.ms(-0.5 * np.pi / 2).on(q0, q1)], atol=1e-4) assert cirq.allclose_up_to_global_phase( cirq.unitary(cirq.Circuit(rcnot)), cirq.unitary(OtherCNOT().on(q0, q1)))
def _unitaries_allclose(circuit1, circuit2): unitary1 = cirq.unitary(circuit1) unitary2 = cirq.unitary(circuit2) if unitary2.size == 1: # Resize the unitary of empty circuits to be 4x4 for 2q gates unitary2 = unitary2 * np.eye(unitary1.shape[0]) return cirq.allclose_up_to_global_phase(unitary1, unitary2)
def check_distinct(unitaries): n = len(unitaries) for i in range(n): for j in range(i + 1, n): Ui, Uj = unitaries[i], unitaries[j] assert not cirq.allclose_up_to_global_phase(Ui, Uj), f'{i}, {j}'
def test_controlled_op_to_gates_equivalent_on_known_and_random(mat): qc = cirq.QubitId() qt = cirq.QubitId() operations = decompositions.controlled_op_to_native_gates( control=qc, target=qt, operation=mat) actual_effect = _operations_to_matrix(operations, (qc, qt)) intended_effect = cirq.kron_with_controls(cirq.CONTROL_TAG, mat) assert cirq.allclose_up_to_global_phase(actual_effect, intended_effect)
def test_controlled_op_to_operations_equivalent_on_known_and_random(mat): qc = cirq.NamedQubit('c') qt = cirq.NamedQubit('qt') operations = cirq.controlled_op_to_operations( control=qc, target=qt, operation=mat) actual_effect = _operations_to_matrix(operations, (qc, qt)) intended_effect = cirq.kron_with_controls(cirq.CONTROL_TAG, mat) assert cirq.allclose_up_to_global_phase(actual_effect, intended_effect)
def test_from_characterizations_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 = 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_interchangable_qubits(gate): q0, q1 = cirq.NamedQubit('q0'), cirq.NamedQubit('q1') op0 = gate(q0, q1) op1 = gate(q1, q0) mat0 = cirq.Circuit.from_ops(op0, ).to_unitary_matrix() mat1 = cirq.Circuit.from_ops(op1, ).to_unitary_matrix() same = op0 == op1 same_check = cirq.allclose_up_to_global_phase(mat0, mat1) assert same == same_check
def test_controlled_op_to_gates_equivalent_on_known_and_random(mat): qc = cirq.QubitId() qt = cirq.QubitId() operations = decompositions.controlled_op_to_native_gates(control=qc, target=qt, operation=mat) actual_effect = _operations_to_matrix(operations, (qc, qt)) intended_effect = cirq.kron_with_controls(cirq.CONTROL_TAG, mat) assert cirq.allclose_up_to_global_phase(actual_effect, intended_effect)
def assert_ops_implement_unitary(q0, q1, operations, intended_effect, atol=0.01): actual_effect = _operations_to_matrix(operations, (q0, q1)) assert cirq.allclose_up_to_global_phase(actual_effect, intended_effect, atol=atol)
def test_interchangeable_qubits(gate): q0, q1 = cirq.NamedQubit('q0'), cirq.NamedQubit('q1') op0 = gate(q0, q1) op1 = gate(q1, q0) mat0 = cirq.Circuit(op0).unitary() mat1 = cirq.Circuit(op1).unitary() same = op0 == op1 same_check = cirq.allclose_up_to_global_phase(mat0, mat1) assert same == same_check
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)
def test_prepare_two_qubit_state_using_cz(state): state = cirq.to_valid_state_vector(state, num_qubits=2) q = cirq.LineQubit.range(2) circuit = cirq.Circuit(cirq.prepare_two_qubit_state_using_cz(*q, state)) ops_cz = [*circuit.findall_operations(lambda op: op.gate == cirq.CZ)] ops_2q = [*circuit.findall_operations(lambda op: cirq.num_qubits(op) > 1)] assert ops_cz == ops_2q assert len(ops_cz) <= 1 assert cirq.allclose_up_to_global_phase(circuit.final_state_vector(), state)
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_single_qubit_cliffords(): I = np.eye(2) X = np.array([[0, 1], [1, 0]]) Y = np.array([[0, -1j], [1j, 0]]) Z = np.diag([1, -1]) PAULIS = (I, X, Y, Z) def is_pauli(u): return any(cirq.equal_up_to_global_phase(u, p) for p in PAULIS) cliffords = ceqc._single_qubit_cliffords() assert len(cliffords.c1_in_xy) == 24 assert len(cliffords.c1_in_xz) == 24 def unitary(gates): U = np.eye(2) for gate in gates: U = cirq.unitary(gate) @ U return U xy_unitaries = [unitary(gates) for gates in cliffords.c1_in_xy] xz_unitaries = [unitary(gates) for gates in cliffords.c1_in_xz] def check_distinct(unitaries): n = len(unitaries) for i in range(n): for j in range(i + 1, n): Ui, Uj = unitaries[i], unitaries[j] assert not cirq.allclose_up_to_global_phase(Ui, Uj), f'{i}, {j}' # Check that unitaries in each decomposition are distinct. check_distinct(xy_unitaries) check_distinct(xz_unitaries) # Check that each decomposition gives the same set of unitaries. for Uxy in xy_unitaries: assert any( cirq.allclose_up_to_global_phase(Uxy, Uxz) for Uxz in xz_unitaries) # Check that each unitary fixes the Pauli group. for u in xy_unitaries: for p in PAULIS: assert is_pauli(u @ p @ u.conj().T), str(u) # Check that XZ decomposition has at most one X gate per clifford. for gates in cliffords.c1_in_xz: num_x = len( [gate for gate in gates if isinstance(gate, cirq.XPowGate)]) num_z = len( [gate for gate in gates if isinstance(gate, cirq.ZPowGate)]) assert num_x + num_z == len(gates) assert num_x <= 1
def test_commutes_single_qubit_gate(gate, other): q0 = cirq.NamedQubit('q0') mat = cirq.Circuit( gate(q0), other(q0), ).unitary() mat_swap = cirq.Circuit( other(q0), gate(q0), ).unitary() commutes = cirq.commutes(gate, other) commutes_check = cirq.allclose_up_to_global_phase(mat, mat_swap) assert commutes == commutes_check
def test_commutes_with_single_qubit_gate(gate, other): q0 = cirq.NamedQubit('q0') mat = cirq.Circuit.from_ops( gate(q0), other(q0), ).to_unitary_matrix() mat_swap = cirq.Circuit.from_ops( other(q0), gate(q0), ).to_unitary_matrix() commutes = gate.commutes_with(other) commutes_check = cirq.allclose_up_to_global_phase(mat, mat_swap) assert commutes == commutes_check
def test_interchangable_qubits(gate): q0, q1 = cirq.NamedQubit('q0'), cirq.NamedQubit('q1') op0 = gate(q0, q1) op1 = gate(q1, q0) mat0 = cirq.Circuit.from_ops( op0, ).to_unitary_matrix() mat1 = cirq.Circuit.from_ops( op1, ).to_unitary_matrix() same = op0 == op1 same_check = cirq.allclose_up_to_global_phase(mat0, mat1) assert same == same_check
def test_commutes_single_qubit_gate(gate, other): q0 = cirq.NamedQubit('q0') gate_op = gate(q0) other_op = other(q0) mat = cirq.Circuit(gate_op, other_op).unitary() mat_swap = cirq.Circuit(other_op, gate_op).unitary() commutes = cirq.commutes(gate, other) commutes_check = cirq.allclose_up_to_global_phase(mat, mat_swap) assert commutes == commutes_check # Test after switching order mat_swap = cirq.Circuit(gate.equivalent_gate_before(other)(q0), gate_op).unitary() assert_allclose_up_to_global_phase(mat, mat_swap, rtol=1e-7, atol=1e-7)
def test_commutes_pauli(gate, pauli, half_turns): pauli_gate = pauli ** half_turns q0 = cirq.NamedQubit('q0') mat = cirq.Circuit( gate(q0), pauli_gate(q0), ).unitary() mat_swap = cirq.Circuit( pauli_gate(q0), gate(q0), ).unitary() commutes = cirq.commutes(gate, pauli) commutes_check = cirq.allclose_up_to_global_phase(mat, mat_swap) assert commutes == commutes_check
def test_commutes_with_pauli(gate, pauli, half_turns): pauli_gate = pauli**half_turns q0 = cirq.NamedQubit('q0') mat = cirq.Circuit.from_ops( gate(q0), pauli_gate(q0), ).to_unitary_matrix() mat_swap = cirq.Circuit.from_ops( pauli_gate(q0), gate(q0), ).to_unitary_matrix() commutes = gate.commutes_with(pauli) commutes_check = cirq.allclose_up_to_global_phase(mat, mat_swap) assert commutes == commutes_check
def general_rule(slack_length: int, gates: List[Gate], spacing: int = -1) -> Circuit: """Returns a digital dynamical decoupling sequence, based on inputs. Args: slack_length: Length of idle window to fill. spacing: How many identity spacing gates to apply between dynamical decoupling gates, as a non-negative int. Negative int corresponds to default. Defaults to maximal spacing that fits a single sequence in the given slack window. E.g. given slack_length = 8, gates = [X, X] the spacing defaults to 2 and the rule returns the sequence: ──I──I──X──I──I──X──I──I── given slack_length = 9, gates [X, Y, X, Y] the spacing defaults to 1 and the rule returns the sequence: ──I──X──I──Y──I──X──I──Y──I──. gates: A list of single qubit Cirq gates to build the rule. E.g. [X, X] is the xx sequence, [X, Y, X, Y] is the xyxy sequence. - Note: To repeat the sequence, specify a repeated gateset. Returns: A digital dynamical decoupling sequence, as a Cirq circuit. """ if len(gates) < 2: raise ValueError("Gateset too short to make a ddd sequence.") if slack_length < 2 or slack_length < len(gates): return Circuit() num_decoupling_gates = len(gates) slack_difference = slack_length - num_decoupling_gates if spacing < 0: spacing = slack_difference // (num_decoupling_gates + 1) slack_remainder = slack_length - (spacing * (num_decoupling_gates + 1) + num_decoupling_gates) if slack_remainder < 0: return Circuit() q = LineQubit(0) slack_gates = [I(q) for _ in range(spacing)] sequence = Circuit( slack_gates, [( gate.on(q), slack_gates, ) for (_, gate) in zip(range(num_decoupling_gates), cycle(gates))], ) if not allclose_up_to_global_phase(np.eye(2), unitary(sequence)): raise ValueError("Sequence is not equivalent to the identity!") for i in range(slack_remainder): sequence.append(I(q)) if i % 2 else sequence.insert(0, I(q)) return sequence
def test_prepare_two_qubit_state_using_sqrt_iswap(state, use_sqrt_iswap_inv): state = cirq.to_valid_state_vector(state, num_qubits=2) q = cirq.LineQubit.range(2) circuit = cirq.Circuit( cirq.prepare_two_qubit_state_using_sqrt_iswap( *q, state, use_sqrt_iswap_inv=use_sqrt_iswap_inv)) sqrt_iswap_gate = cirq.SQRT_ISWAP_INV if use_sqrt_iswap_inv else cirq.SQRT_ISWAP ops_iswap = [ *circuit.findall_operations(lambda op: op.gate == sqrt_iswap_gate) ] ops_2q = [*circuit.findall_operations(lambda op: cirq.num_qubits(op) > 1)] assert ops_iswap == ops_2q assert len(ops_iswap) <= 1 assert cirq.allclose_up_to_global_phase(circuit.final_state_vector(), state)
def test_controlled_op_to_operations_concrete_case(): c = cirq.NamedQubit('c') t = cirq.NamedQubit('t') expected = [cirq.Y(t)**-0.5, cirq.CZ(c, t)**1.5, cirq.Z(c)**0.25, cirq.Y(t)**0.5] operations = cirq.controlled_op_to_operations( control=c, target=t, operation=np.array([[1, 1j], [1j, 1]]) * np.sqrt(0.5), tolerance=0.0001) # Test closeness as opposed to equality to avoid precision errors for actual_op, expected_op in zip(operations, expected): assert cirq.allclose_up_to_global_phase(cirq.unitary(actual_op), cirq.unitary(expected_op), atol=1e-8)
def test_with_random_gaussian_sqrt_iswap_simulates_correctly() -> None: engine_simulator = PhasedFSimEngineSimulator.create_with_random_gaussian_sqrt_iswap( mean=SQRT_ISWAP_PARAMETERS, sigma=PhasedFSimCharacterization(theta=0.02, zeta=0.05, chi=0.05, gamma=None, phi=0.02), ) 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.FSimGate(np.pi / 4, 0.0).on(b, a), cirq.FSimGate(np.pi / 4, 0.0).on(d, c) ], ]) calibrations = engine_simulator.get_calibrations([ _create_sqrt_iswap_request([(a, b), (c, d)]), _create_sqrt_iswap_request([(b, c)]) ]) parameters = collections.ChainMap(*(calibration.parameters for calibration in calibrations)) expected_circuit = cirq.Circuit([ [cirq.X(a), cirq.X(c)], [ cirq.PhasedFSimGate(**parameters[(a, b)].asdict()).on(a, b), cirq.PhasedFSimGate(**parameters[(c, d)].asdict()).on(c, d), ], [cirq.PhasedFSimGate(**parameters[(b, c)].asdict()).on(b, c)], [ cirq.PhasedFSimGate(**parameters[(a, b)].asdict()).on(a, b), cirq.PhasedFSimGate(**parameters[(c, d)].asdict()).on(c, d), ], ]) 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_ideal_sqrt_iswap_inverse_simulates_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)], ] ) 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_from_dictionary_sqrt_iswap_ideal_when_missing_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) 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_PARAMETERS.asdict()).on(c, d), ], [ cirq.PhasedFSimGate( **parameters_bc.merge_with(SQRT_ISWAP_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_prepare_slater_determinant(slater_determinant_matrix, correct_state, initial_state, atol=1e-7): n_qubits = slater_determinant_matrix.shape[1] qubits = LineQubit.range(n_qubits) circuit = cirq.Circuit( prepare_slater_determinant(qubits, slater_determinant_matrix, initial_state=initial_state)) if isinstance(initial_state, list): initial_state = sum(1 << (n_qubits - 1 - i) for i in initial_state) state = circuit.final_state_vector(initial_state=initial_state) assert cirq.allclose_up_to_global_phase(state, correct_state, atol=atol)
def test_commutes_with_pauli(gate, pauli, half_turns): pauli_gates = {cirq.Pauli.X: cirq.X, cirq.Pauli.Y: cirq.Y, cirq.Pauli.Z: cirq.Z} pauli_gate = pauli_gates[pauli] ** half_turns q0 = cirq.NamedQubit('q0') mat = cirq.Circuit.from_ops( gate(q0), pauli_gate(q0), ).to_unitary_matrix() mat_swap = cirq.Circuit.from_ops( pauli_gate(q0), gate(q0), ).to_unitary_matrix() commutes = gate.commutes_with(pauli) commutes_check = cirq.allclose_up_to_global_phase(mat, mat_swap) assert commutes == commutes_check
def test_example_qaoa_same_unitary(): n = 6 p = 2 qubits = cirq.LineQubit.range(n) graph = networkx.random_regular_graph(3, n) betas = np.random.uniform(-np.pi, np.pi, size=p) gammas = np.random.uniform(-np.pi, np.pi, size=p) circuits = [ examples.qaoa.qaoa_max_cut_circuit(qubits, betas, gammas, graph, use_boolean_hamiltonian_gate) for use_boolean_hamiltonian_gate in [True, False] ] assert cirq.allclose_up_to_global_phase(cirq.unitary(circuits[0]), cirq.unitary(circuits[1]))
def test_prepare_slater_determinant(slater_determinant_matrix, correct_state, initial_state, atol=1e-7): simulator = cirq.google.XmonSimulator() n_qubits = slater_determinant_matrix.shape[1] qubits = LineQubit.range(n_qubits) circuit = cirq.Circuit.from_ops( prepare_slater_determinant(qubits, slater_determinant_matrix, initial_state=initial_state)) if isinstance(initial_state, list): initial_state = sum(1 << (n_qubits - 1 - i) for i in initial_state) result = simulator.simulate(circuit, initial_state=initial_state) state = result.final_state assert cirq.allclose_up_to_global_phase(state, correct_state, atol=atol)
def test_single_qubit_op_to_framed_phase_form_output_on_example_case(): u, t, g = cirq.single_qubit_op_to_framed_phase_form( (cirq.Y**0.25).matrix()) assert cirq.allclose_up_to_global_phase(u, (cirq.X**0.5).matrix()) assert abs(t - (1 + 1j) * math.sqrt(0.5)) < 0.00001 assert abs(g - 1) < 0.00001
def assert_gates_implement_unitary(gates, intended_effect): actual_effect = _gates_to_matrix(gates) assert cirq.allclose_up_to_global_phase(actual_effect, intended_effect)