def test_dynamic_single_qubit_rotations(): a, b, c = cirq.LineQubit.range(3) t = sympy.Symbol('t') # Dynamic single qubit rotations. assert_url_to_circuit_returns( '{"cols":[["X^t","Y^t","Z^t"],["X^-t","Y^-t","Z^-t"]]}', cirq.Circuit( cirq.X(a)**t, cirq.Y(b)**t, cirq.Z(c)**t, cirq.X(a)**-t, cirq.Y(b)**-t, cirq.Z(c)**-t, )) assert_url_to_circuit_returns( '{"cols":[["e^iXt","e^iYt","e^iZt"],["e^-iXt","e^-iYt","e^-iZt"]]}', cirq.Circuit( cirq.Rx(2 * sympy.pi * t).on(a), cirq.Ry(2 * sympy.pi * t).on(b), cirq.Rz(2 * sympy.pi * t).on(c), cirq.Rx(2 * sympy.pi * -t).on(a), cirq.Ry(2 * sympy.pi * -t).on(b), cirq.Rz(2 * sympy.pi * -t).on(c), ))
def U(i, ψ=None, χ=None, ϕ=None): """U: Random SU(2) element""" ψ = 2 * π * rand() if ψ is None else ψ χ = 2 * π * rand() if χ is None else χ φ = arcsin(sqrt(rand())) if ϕ is None else ϕ for g in [cirq.Rz(χ + ψ), cirq.Ry(2 * φ), cirq.Rz(χ - ψ)]: yield g(cirq.LineQubit(i))
def U(i): """U: Random SU(2) element""" ψ = 2 * π * rand() χ = 2 * π * rand() φ = arcsin(sqrt(rand())) for g in [cirq.Rz(χ + ψ), cirq.Ry(2 * φ), cirq.Rz(χ - ψ)]: yield g(cirq.LineQubit(i))
def test_rxyz_exponent(theta, exp): def resolve(gate): return cirq.resolve_parameters(gate, {'theta': np.pi / 4}, {'exp': 1 / 4}) assert resolve(cirq.Rx(rads=theta) ** exp) == resolve(cirq.Rx(rads=theta * exp)) assert resolve(cirq.Ry(rads=theta) ** exp) == resolve(cirq.Ry(rads=theta * exp)) assert resolve(cirq.Rz(rads=theta) ** exp) == resolve(cirq.Rz(rads=theta * exp))
def cphase_symbols_to_sqrt_iswap(a, b, turns): """Version of cphase_to_sqrt_iswap that works with symbols. Note that the formulae contained below will need to be flattened into a sweep before serializing. """ theta = sympy.Mod(turns, 2.0) * sympy.pi # -1 if theta > pi. Adds a hacky fudge factor so theta=pi is not 0 sign = sympy.sign(sympy.pi - theta + 1e-9) # For sign = 1: theta. For sign = -1, 2pi-theta theta_prime = (sympy.pi - sign * sympy.pi) + sign * theta phi = sympy.asin(np.sqrt(2) * sympy.sin(theta_prime / 4)) xi = sympy.atan(sympy.tan(phi) / np.sqrt(2)) yield cirq.Rz(sign * 0.5 * theta_prime).on(a) yield cirq.Rz(sign * 0.5 * theta_prime).on(b) yield cirq.Rx(xi).on(a) yield cirq.X(b)**(-sign * 0.5) yield SQRT_ISWAP_INV(a, b) yield cirq.Rx(-2 * phi).on(a) yield SQRT_ISWAP(a, b) yield cirq.Rx(xi).on(a) yield cirq.X(b)**(sign * 0.5)
def trotter_step( self, qubits: Sequence[cirq.QubitId], time: float, control_qubit: Optional[cirq.QubitId] = None) -> cirq.OP_TREE: n_qubits = len(qubits) # Simulate the one-body terms for half of the full time yield (cirq.Rz(rads=-0.5 * self.orbital_energies[i] * time).on( qubits[i]) for i in range(n_qubits)) # Rotate to the computational basis yield bogoliubov_transform(qubits, self.basis_change_matrix) # Simulate the two-body terms for the full time def two_body_interaction(p, q, a, b) -> cirq.OP_TREE: yield rot11(rads=-2 * self.hamiltonian.two_body[p, q] * time).on( a, b) yield swap_network(qubits, two_body_interaction) # The qubit ordering has been reversed qubits = qubits[::-1] # Rotate back to the basis in which the one-body term is diagonal yield cirq.inverse( bogoliubov_transform(qubits, self.basis_change_matrix)) # Simulate the one-body terms for half of the full time yield (cirq.Rz(rads=-0.5 * self.orbital_energies[i] * time).on( qubits[i]) for i in range(n_qubits))
def test_str(): assert str(cirq.X) == 'X' assert str(cirq.X**0.5) == 'X**0.5' assert str(cirq.Rx(np.pi)) == 'Rx(π)' assert str(cirq.Rx(0.5 * np.pi)) == 'Rx(0.5π)' assert str(cirq.XPowGate( global_shift=-0.25)) == 'XPowGate(exponent=1.0, global_shift=-0.25)' assert str(cirq.Z) == 'Z' assert str(cirq.Z**0.5) == 'S' assert str(cirq.Z**0.125) == 'Z**0.125' assert str(cirq.Rz(np.pi)) == 'Rz(π)' assert str(cirq.Rz(1.4 * np.pi)) == 'Rz(1.4π)' assert str(cirq.ZPowGate( global_shift=0.25)) == 'ZPowGate(exponent=1.0, global_shift=0.25)' assert str(cirq.S) == 'S' assert str(cirq.S**-1) == 'S**-1' assert str(cirq.T) == 'T' assert str(cirq.T**-1) == 'T**-1' assert str(cirq.Y) == 'Y' assert str(cirq.Y**0.5) == 'Y**0.5' assert str(cirq.Ry(np.pi)) == 'Ry(π)' assert str(cirq.Ry(3.14 * np.pi)) == 'Ry(3.14π)' assert str(cirq.YPowGate( exponent=2, global_shift=-0.25)) == 'YPowGate(exponent=2, global_shift=-0.25)' assert str(cirq.CX) == 'CNOT' assert str(cirq.CNOT**0.5) == 'CNOT**0.5'
def __init__(self, path: list, test_type: BellTestType, add_measurements, num_shots): super().__init__() qubit_a = path[0] qubit_b = path[-1] self.qubit_a = qubit_a self.qubit_b = qubit_b self.path = path self.test_type = test_type self.add_measurements = add_measurements self.num_shots = num_shots # Build the circuit _path = [cirq.GridQubit(0, i) for i in path] _qubit_a, _qubit_b = _path[0], _path[-1] circuit = cirq.Circuit() circuit.append(cirq.X(_qubit_a)) circuit.append(cirq.X(_qubit_b)) circuit.append(cirq.H(_qubit_a)) # CNOT along path for (_x, _y) in zip(_path[:-2], _path[1:-1]): circuit.append(cirq.H(_y)) circuit.append(cirq.CZ(_x, _y)) circuit.append(cirq.H(_y)) # CNOT the last pair circuit.append(cirq.H(_qubit_b)) circuit.append(cirq.CZ(_qubit_a, _qubit_b)) circuit.append(cirq.H(_qubit_b)) # undo CNOT along path for (_x, _y) in reversed(list(zip(_path[:-2], _path[1:-1]))): circuit.append(cirq.H(_y)) circuit.append(cirq.CZ(_x, _y)) circuit.append(cirq.H(_y)) # measurement directions angle_a, angle_b = test_type.value if angle_a != 0: circuit.append(cirq.Rz(angle_a)(_qubit_a)) if angle_b != 0: circuit.append(cirq.Rz(angle_b)(_qubit_b)) # final hadamards circuit.append(cirq.H(_qubit_a)) circuit.append(cirq.H(_qubit_b)) # measurements if add_measurements: circuit.append(cirq.measure(_qubit_a, key="A")) circuit.append(cirq.measure(_qubit_b, key="B")) # store the resulting circuit self.circuit = circuit
def apply_C_unitary(length, gamma): # Apply the compute --> rotate --> uncompute method to change the phase of a specific computational basis state for j in set_edges: yield cirq.CNOT.on(cirq.GridQubit(0, j.start_node), cirq.GridQubit(0, j.end_node)) yield cirq.Rz((-1 * gamma)).on(cirq.GridQubit(0, j.end_node)) yield cirq.CNOT.on(cirq.GridQubit(0, j.start_node), cirq.GridQubit(0, j.end_node)) yield cirq.Rz((-1 * gamma)).on(work_qubit)
def apply_C_unitary(length, gamma): # Apply the compute --> rotate --> uncompute method to change the phase of a specific computational basis state for i in the_search: for j in range (0, len(i)-1): yield cirq.CNOT.on(cirq.GridQubit(0, i[j]), cirq.GridQubit(0, i[j+1])) yield cirq.Rz((-1*gamma)).on(cirq.GridQubit(0, i[(j+1)])) yield cirq.CNOT.on(cirq.GridQubit(0, i[j]), cirq.GridQubit(0, i[(j+1)])) yield cirq.Rz((-1*gamma)).on(work_qubit)
def _gen_single_bit_rotation_problem(bit, symbols): """Generate a toy problem on 1 qubit.""" starting_state = np.random.uniform(0, 2 * np.pi, 3) circuit = cirq.Circuit( cirq.Rx(starting_state[0])(bit), cirq.Ry(starting_state[1])(bit), cirq.Rz(starting_state[2])(bit), cirq.Rz(symbols[2])(bit), cirq.Ry(symbols[1])(bit), cirq.Rx(symbols[0])(bit)) return circuit
def test_gate_with_custom_names(): q0, q1, q2, q3 = cirq.LineQubit.range(4) gate = cirq.BooleanHamiltonianGate(['a', 'b'], ['a'], 0.1) assert cirq.decompose(gate.on(q0, q1)) == [cirq.Rz(rads=-0.05).on(q0)] assert cirq.decompose_once_with_qubits(gate, (q0, q1)) == [cirq.Rz(rads=-0.05).on(q0)] assert cirq.decompose(gate.on(q2, q3)) == [cirq.Rz(rads=-0.05).on(q2)] assert cirq.decompose_once_with_qubits(gate, (q2, q3)) == [cirq.Rz(rads=-0.05).on(q2)] with pytest.raises(ValueError, match='Wrong number of qubits'): gate.on(q2) with pytest.raises(ValueError, match='Wrong shape of qids'): gate.on(q0, cirq.LineQid(1, 3))
def trotter_step( self, qubits: Sequence[cirq.Qid], time: float, control_qubit: Optional[cirq.Qid]=None ) -> cirq.OP_TREE: n_qubits = len(qubits) # Change to the basis in which the one-body term is diagonal yield bogoliubov_transform( qubits, self.one_body_basis_change_matrix.T.conj()) # Simulate the one-body terms. for p in range(n_qubits): yield cirq.Rz(rads= -self.one_body_energies[p] * time ).on(qubits[p]) # Simulate each singular vector of the two-body terms. prior_basis_matrix = self.one_body_basis_change_matrix for j in range(len(self.eigenvalues)): # Get the two-body coefficients and basis change matrix. two_body_coefficients = self.scaled_density_density_matrices[j] basis_change_matrix = self.basis_change_matrices[j] # Merge previous basis change matrix with the inverse of the # current one merged_basis_change_matrix = numpy.dot(prior_basis_matrix, basis_change_matrix.T.conj()) yield bogoliubov_transform(qubits, merged_basis_change_matrix) # Simulate the off-diagonal two-body terms. yield swap_network( qubits, lambda p, q, a, b: rot11(rads= -2 * two_body_coefficients[p, q] * time).on(a, b)) qubits = qubits[::-1] # Simulate the diagonal two-body terms. for p in range(n_qubits): yield cirq.Rz(rads= -two_body_coefficients[p, p] * time ).on(qubits[p]) # Update prior basis change matrix prior_basis_matrix = basis_change_matrix # Undo final basis transformation yield bogoliubov_transform(qubits, prior_basis_matrix)
def test_parametrize(self): """Tests that parametrize yields the correct queue of operations.""" operation = CirqOperation( lambda a, b, c: [cirq.X, cirq.Ry(a), cirq.Rx(b), cirq.Z, cirq.Rz(c)]) operation.parametrize(0.1, 0.2, 0.3) assert operation.parametrized_cirq_gates[0] == cirq.X assert operation.parametrized_cirq_gates[1] == cirq.Ry(0.1) assert operation.parametrized_cirq_gates[2] == cirq.Rx(0.2) assert operation.parametrized_cirq_gates[3] == cirq.Z assert operation.parametrized_cirq_gates[4] == cirq.Rz(0.3)
def main(): """ Simulates HHL with matrix input, and outputs Pauli observables of the resulting qubit state |x>. Expected observables are calculated from the expected solution |x>. """ # Eigendecomposition: # >>> import numpy as np # >>> x, y = np.linalg.eigh(A) # Eigendecomposition for a complex Hermitian matrix. # >>> [z for z in zip(list(x.astype(np.float32)), list(np.transpose(y)))] # [(0.34899944, array([-0.23681357+0.j, 0.23727026-0.94213702j])), # (4.5370007, array([-0.97155511+0.j, -0.05783389+0.229643j]))] # |b> = (0.64510-0.47848j, 0.35490-0.47848j) # |x> = (-0.0662724-0.214548j, 0.784392-0.578192j) A = np.array([[4.30213466 - 6.01593490e-08j, 0.23531802 + 9.34386156e-01j], [0.23531882 - 9.34388383e-01j, 0.58386534 + 6.01593489e-08j]]) t = 0.358166 * math.pi register_size = 4 input_prep_gates = [cirq.Rx(1.276359), cirq.Rz(1.276359)] expected = (0.144130, 0.413217, -0.899154) # Set C to be the smallest eigenvalue that can be represented by the # circuit. C = 2 * math.pi / (2**register_size * t) # Simulate circuit print("Expected observable outputs:") print("X =", expected[0]) print("Y =", expected[1]) print("Z =", expected[2]) print("Actual: ") simulate(hhl_circuit(A, C, t, register_size, *input_prep_gates))
def test_pyquil2cirq(self): qprog = pyquil.quil.Program().inst(pyquil.gates.X(0), pyquil.gates.T(1), pyquil.gates.RZ(0.1, 3), pyquil.gates.CNOT(0, 1), pyquil.gates.SWAP(0, 1), pyquil.gates.CZ(1, 0)) circuit = pyquil2cirq(qprog) qubits = [cirq.GridQubit(i, 0) for i in qprog.get_qubits()] gates = [ cirq.X(qubits[0]), cirq.T(qubits[1]), cirq.Rz(rads=0.1)(qubits[2]), cirq.CNOT(qubits[0], qubits[1]), cirq.SWAP(qubits[0], qubits[1]), cirq.CZ(qubits[1], qubits[0]) ] ref_circuit = cirq.Circuit() ref_circuit.append(gates, strategy=cirq.circuits.InsertStrategy.EARLIEST) # Get the unitary matrix for the circuit U = circuit.unitary() # Get the unitary matrix for the reference circuit U_ref = ref_circuit.unitary() # Check that the matrices are identical to within a global phase. See J. Chem. Phys. 134, 144112 (2011). self.assertTrue(compare_unitary(U, U_ref))
def main(): """ Simulates HHL with matrix input, and outputs Pauli observables of the resulting qubit state |x>. Expected observables are calculated from the expected solution |x>. """ # Eigendecomposition: # (4.537, [-0.971555, -0.0578339+0.229643j]) # (0.349, [-0.236813, 0.237270-0.942137j]) # |b> = (0.64510-0.47848j, 0.35490-0.47848j) # |x> = (-0.0662724-0.214548j, 0.784392-0.578192j) A = np.array([[4.30213466-6.01593490e-08j, 0.23531802+9.34386156e-01j], [0.23531882-9.34388383e-01j, 0.58386534+6.01593489e-08j]]) t = 0.358166*math.pi register_size = 4 input_prep_gates = [cirq.Rx(1.276359), cirq.Rz(1.276359)] expected = (0.144130, 0.413217, -0.899154) # Set C to be the smallest eigenvalue that can be represented by the # circuit. C = 2*math.pi / (2**register_size * t) # Simulate circuit print("Expected observable outputs:") print("X =", expected[0]) print("Y =", expected[1]) print("Z =", expected[2]) print("Actual: ") simulate(hhl_circuit(A, C, t, register_size, *input_prep_gates))
def trotter_step( self, qubits: Sequence[cirq.QubitId], time: float, control_qubit: Optional[cirq.QubitId] = None) -> cirq.OP_TREE: n_qubits = len(qubits) # Apply one- and two-body interactions for the full time def one_and_two_body_interaction(p, q, a, b) -> cirq.OP_TREE: yield CRxxyy(self.hamiltonian.one_body[p, q].real * time).on( control_qubit, a, b) yield CRyxxy(self.hamiltonian.one_body[p, q].imag * time).on( control_qubit, a, b) yield rot111(-2 * self.hamiltonian.two_body[p, q] * time).on( control_qubit, a, b) yield swap_network(qubits, one_and_two_body_interaction, fermionic=True) qubits = qubits[::-1] # Apply one-body potential for the full time yield (rot11(rads=-self.hamiltonian.one_body[i, i].real * time).on( control_qubit, qubits[i]) for i in range(n_qubits)) # Apply phase from constant term yield cirq.Rz(rads=-self.hamiltonian.constant * time).on(control_qubit)
def _gaussian_basis_change( qubits: Sequence[cirq.QubitId], transformation_matrix: numpy.ndarray, initially_occupied_orbitals: Optional[Sequence[int]]) -> cirq.OP_TREE: n_qubits = len(qubits) # Rearrange the transformation matrix because the OpenFermion routine # expects it to describe annihilation operators rather than creation # operators left_block = transformation_matrix[:, :n_qubits] right_block = transformation_matrix[:, n_qubits:] transformation_matrix = numpy.block( [numpy.conjugate(right_block), numpy.conjugate(left_block)]) decomposition, left_decomposition, _, left_diagonal = ( fermionic_gaussian_decomposition(transformation_matrix)) if (initially_occupied_orbitals is not None and len(initially_occupied_orbitals) == 0): # Starting with the vacuum state yields additional symmetry circuit_description = list(reversed(decomposition)) else: if initially_occupied_orbitals is None: # The initial state is not a computational basis state so the # phases left on the diagonal in the Givens decomposition matter yield (cirq.Rz(rads=numpy.angle(left_diagonal[j])).on(qubits[j]) for j in range(n_qubits)) circuit_description = list(reversed(decomposition + left_decomposition)) yield _ops_from_givens_rotations_circuit_description( qubits, circuit_description)
def _slater_basis_change( qubits: Sequence[cirq.QubitId], transformation_matrix: numpy.ndarray, initially_occupied_orbitals: Optional[Sequence[int]]) -> cirq.OP_TREE: n_qubits = len(qubits) if initially_occupied_orbitals is None: decomposition, diagonal = givens_decomposition_square( transformation_matrix) circuit_description = list(reversed(decomposition)) # The initial state is not a computational basis state so the # phases left on the diagonal in the decomposition matter yield (cirq.Rz(rads=numpy.angle(diagonal[j])).on(qubits[j]) for j in range(n_qubits)) else: initially_occupied_orbitals = cast(Sequence[int], initially_occupied_orbitals) transformation_matrix = transformation_matrix[list( initially_occupied_orbitals)] n_occupied = len(initially_occupied_orbitals) # Flip bits so that the first n_occupied are 1 and the rest 0 initially_occupied_orbitals_set = set(initially_occupied_orbitals) yield (cirq.X(qubits[j]) for j in range(n_qubits) if (j < n_occupied) != (j in initially_occupied_orbitals_set)) circuit_description = slater_determinant_preparation_circuit( transformation_matrix) yield _ops_from_givens_rotations_circuit_description( qubits, circuit_description)
def main(): """ HHL을 행렬 입력과 결과 큐비트 상태인 |x>의 파울리 측정 출력을 시뮬레이션하기. 기대되는 해 |x>로 부터 기대되는 관측량을 계산합니다. """ # 고유값분해 결과: # >>> import numpy as np # >>> x, y = np.linalg.eig(A) # >>> [z for z in zip(list(x.astype(np.float32)), list(y))] # [(4.537, array([ 0.9715551 +0.j , -0.05783371-0.22964251j])), # (0.349, array([0.05783391-0.22964302j, 0.97155524+0.j ]))] # |b> = (0.64510-0.47848j, 0.35490-0.47848j) # |x> = (-0.0662724-0.214548j, 0.784392-0.578192j) A = np.array([[4.30213466 - 6.01593490e-08j, 0.23531802 + 9.34386156e-01j], [0.23531882 - 9.34388383e-01j, 0.58386534 + 6.01593489e-08j]]) t = 0.358166 * math.pi register_size = 4 input_prep_gates = [cirq.Rx(1.276359), cirq.Rz(1.276359)] expected = (0.144130, 0.413217, -0.899154) # C를 회로에서 표현가능한 최소의 고유값에 맞춥니다. C = 2 * math.pi / (2**register_size * t) # 회로를 시뮬레이션합니다. print("Expected observable outputs:") print("X =", expected[0]) print("Y =", expected[1]) print("Z =", expected[2]) print("Actual: ") simulate(hhl_circuit(A, C, t, register_size, *input_prep_gates))
def test_repr(): assert repr(cirq.X) == 'cirq.X' assert repr(cirq.X**0.5) == '(cirq.X**0.5)' assert repr(cirq.Z) == 'cirq.Z' assert repr(cirq.Z**0.5) == 'cirq.S' assert repr(cirq.Z**0.25) == 'cirq.T' assert repr(cirq.Z**0.125) == '(cirq.Z**0.125)' assert repr(cirq.S) == 'cirq.S' assert repr(cirq.S**-1) == '(cirq.S**-1)' assert repr(cirq.T) == 'cirq.T' assert repr(cirq.T**-1) == '(cirq.T**-1)' assert repr(cirq.Y) == 'cirq.Y' assert repr(cirq.Y**0.5) == '(cirq.Y**0.5)' assert repr(cirq.CNOT) == 'cirq.CNOT' assert repr(cirq.CNOT**0.5) == '(cirq.CNOT**0.5)' cirq.testing.assert_equivalent_repr(cirq.X**(sympy.Symbol('a') / 2 - sympy.Symbol('c') * 3 + 5)) cirq.testing.assert_equivalent_repr(cirq.Rx(rads=sympy.Symbol('theta'))) cirq.testing.assert_equivalent_repr(cirq.Ry(rads=sympy.Symbol('theta'))) cirq.testing.assert_equivalent_repr(cirq.Rz(rads=sympy.Symbol('theta'))) # There should be no floating point error during initialization, and repr # should be using the "shortest decimal value closer to X than any other # floating point value" strategy, as opposed to the "exactly value in # decimal" strategy. assert repr(cirq.CZ**0.2) == '(cirq.CZ**0.2)'
def test_rxyz_circuit_diagram(): q = cirq.NamedQubit('q') cirq.testing.assert_has_diagram( cirq.Circuit.from_ops( cirq.Rx(np.pi).on(q), cirq.Rx(-np.pi).on(q), cirq.Rx(-np.pi + 0.00001).on(q), cirq.Rx(-np.pi - 0.00001).on(q), cirq.Rx(3*np.pi).on(q), cirq.Rx(7*np.pi/2).on(q), cirq.Rx(9*np.pi/2 + 0.00001).on(q), ), """ q: ───Rx(π)───Rx(-π)───Rx(-π)───Rx(-π)───Rx(-π)───Rx(-0.5π)───Rx(0.5π)─── """) cirq.testing.assert_has_diagram( cirq.Circuit.from_ops( cirq.Rx(np.pi).on(q), cirq.Rx(np.pi/2).on(q), cirq.Rx(-np.pi + 0.00001).on(q), cirq.Rx(-np.pi - 0.00001).on(q), ), """ q: ---Rx(pi)---Rx(0.5pi)---Rx(-pi)---Rx(-pi)--- """, use_unicode_characters=False) cirq.testing.assert_has_diagram( cirq.Circuit.from_ops( cirq.Ry(np.pi).on(q), cirq.Ry(-np.pi).on(q), cirq.Ry(3 * np.pi).on(q), cirq.Ry(9*np.pi/2).on(q), ), """ q: ───Ry(π)───Ry(-π)───Ry(-π)───Ry(0.5π)─── """) cirq.testing.assert_has_diagram( cirq.Circuit.from_ops( cirq.Rz(np.pi).on(q), cirq.Rz(-np.pi).on(q), cirq.Rz(3 * np.pi).on(q), cirq.Rz(9*np.pi/2).on(q), cirq.Rz(9*np.pi/2 + 0.00001).on(q), ), """ q: ───Rz(π)───Rz(-π)───Rz(-π)───Rz(0.5π)───Rz(0.5π)─── """)
def test_deprecated_rxyz_rotations(rads): with capture_logging(): assert np.all( cirq.unitary(cirq.Rx(rads)) == cirq.unitary(cirq.rx(rads))) assert np.all( cirq.unitary(cirq.Ry(rads)) == cirq.unitary(cirq.ry(rads))) assert np.all( cirq.unitary(cirq.Rz(rads)) == cirq.unitary(cirq.rz(rads)))
def test_with_custom_names(): q0, q1, q2, q3 = cirq.LineQubit.range(4) original_op = cirq.BooleanHamiltonian( { 'a': q0, 'b': q1 }, ['a'], 0.1, ) assert cirq.decompose(original_op) == [cirq.Rz(rads=-0.05).on(q0)] renamed_op = original_op.with_qubits(q2, q3) assert cirq.decompose(renamed_op) == [cirq.Rz(rads=-0.05).on(q2)] with pytest.raises(ValueError, match='Length of replacement qubits must be the same'): original_op.with_qubits(q2)
def adjoint_integer_increment_phase(circuit, increment, target): """ The adjoint version of integer_increment_phase. """ d = len(target) for i in range(d - 1, -1, -1): y = math.pi * increment / (2**(d - 1 - i)) circuit.append(cirq.Rz(-y).on(target[i]))
def cphase_to_sqrt_iswap(a, b, turns): """Implement a C-Phase gate using two sqrt ISWAP gates and single-qubit operations. The circuit is equivalent to cirq.CZPowGate(exponent=turns). Output unitary: [1 0 0 0], [0 1 0 0], [0 0 1 0], [0 0 0 e^{i turns pi}]. Args: a: the first qubit b: the second qubit turns: Exponent specifying the evolution time in number of rotations. """ theta = (turns % 2) * np.pi if 0 <= theta <= np.pi: sign = 1. theta_prime = theta elif np.pi < theta < 2 * np.pi: sign = -1. theta_prime = 2 * np.pi - theta if np.isclose(theta, np.pi): # If we are close to pi, just set values manually to avoid possible # numerical errors with arcsin of greater than 1.0 (Ahem, Windows). phi = np.pi / 2 xi = np.pi / 2 else: phi = np.arcsin(np.sqrt(2) * np.sin(theta_prime / 4)) xi = np.arctan(np.tan(phi) / np.sqrt(2)) yield cirq.Rz(sign * 0.5 * theta_prime).on(a) yield cirq.Rz(sign * 0.5 * theta_prime).on(b) yield cirq.Rx(xi).on(a) yield cirq.X(b)**(-sign * 0.5) yield SQRT_ISWAP_INV(a, b) yield cirq.Rx(-2 * phi).on(a) yield SQRT_ISWAP(a, b) yield cirq.Rx(xi).on(a) yield cirq.X(b)**(sign * 0.5) # Corrects global phase yield cirq.GlobalPhaseOperation(np.exp(sign * theta_prime * 0.25j))
def test_apply(self): """Tests that the operations in the queue are correctly applied.""" operation = CirqOperation( lambda a, b, c: [cirq.X, cirq.Ry(a), cirq.Rx(b), cirq.Z, cirq.Rz(c)]) operation.parametrize(0.1, 0.2, 0.3) qubit = cirq.LineQubit(1) gate_applications = list(operation.apply(qubit)) assert gate_applications[0] == cirq.X.on(qubit) assert gate_applications[1] == cirq.Ry(0.1).on(qubit) assert gate_applications[2] == cirq.Rx(0.2).on(qubit) assert gate_applications[3] == cirq.Z.on(qubit) assert gate_applications[4] == cirq.Rz(0.3).on(qubit)
def rot(qubit, params): """Helper function to return an arbitrary rotation of the form R = Rz(params[2]) * Ry(params[1]) * Rx(params[0]) on the qubit. """ rx = cirq.Rx(rads=params[0]) ry = cirq.Ry(rads=params[1]) rz = cirq.Rz(rads=params[2]) yield (rx(qubit), ry(qubit), rz(qubit))
def controlled_adjoint_integer_increment_phase(circuit, control_list, increment, target): """ The adjoint version of controlled_integer_increment_phase. """ d = len(target) for i in range(d - 1, -1, -1): y = math.pi * increment / (2**(d - 1 - i)) circuit.append(cirq.Rz(-y).on(target[i]).controlled_by(*control_list))