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 test_resolve_named_placeholder(): """Resolve named placeholders via feed_dict.""" wf = cirq.testing.random_superposition(2).astype(np.complex64) # placeholders can be instantiated without references in circuit gates! var_names = ["v_{}".format(i) for i in range(5)] params = np.random.randn(5) placeholder_circuit = cirq.Circuit() for i in range(5): placeholder_circuit += cirq.Rx( tf.placeholder(tf.complex64, shape=(), name=f"theta_{i}"))(q(0)) circuit_op = TFWaveFunctionSimulator(dtype=tf.complex64).simulate( placeholder_circuit, initial_state=wf) placeholder_names = ["theta_{}:0".format(i) for i in range(5)] feed_dict = dict(zip(placeholder_names, params)) with tf.Session() as sess: tf_result = sess.run(circuit_op, feed_dict=feed_dict).reshape(-1) circuit = cirq.Circuit() for theta in params: circuit += cirq.Rx(theta)(q(0)) cirq_result = cirq.Simulator().simulate( circuit, initial_state=np.copy(wf)).final_state np.testing.assert_array_almost_equal(tf_result, cirq_result)
def _many_clifford_to_many_z(pauli_sum): """Convert many clifford to many Z. Returns the gate set required for transforming an arbitrary tensor product of paulis into a product of all pauli -Z's. Args: pauli_sum: `cirq.PauliSum` object to be converted to all z's. Returns: gate_list: List of required gates to complete the transformation. conjugate_list: List of gates, but reversed and complex conjugate applied to each rotation gate """ # TODO(jaeyoo): investigate how to apply cirq.PauliString.to_z_basis_ops gate_list = [] # Hermitian conjugate conjugate_list = [] for qubit, pauli in pauli_sum.items(): if isinstance(pauli, cirq.ZPowGate): continue elif isinstance(pauli, cirq.XPowGate): gate_list.append(cirq.H(qubit)) conjugate_list.append(cirq.H(qubit)) elif isinstance(pauli, cirq.YPowGate): # It is identical to the conjugate of Phase and Hadamard gate up to # global phase. This global phase difference is gone with # multiplication of hermition conjugate later. gate_list.append(cirq.Rx(np.pi / 2)(qubit)) conjugate_list.append(cirq.Rx(-np.pi / 2)(qubit)) return gate_list, conjugate_list[::-1]
def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs ) -> Optional[np.ndarray]: if cirq.is_parameterized(self): return None am = cirq.unitary(cirq.Rx(-np.pi * self.exponent * self.weights[0])) bm = cirq.unitary(cirq.Rx(-np.pi * self.exponent * self.weights[1])) cm = cirq.unitary(cirq.Rx(-np.pi * self.exponent * self.weights[2])) a1 = args.subspace_index(0b1001) b1 = args.subspace_index(0b0101) c1 = args.subspace_index(0b0011) a2 = args.subspace_index(0b0110) b2 = args.subspace_index(0b1010) c2 = args.subspace_index(0b1100) cirq.apply_matrix_to_slices(args.target_tensor, am, slices=[a1, a2], out=args.available_buffer) cirq.apply_matrix_to_slices(args.available_buffer, bm, slices=[b1, b2], out=args.target_tensor) return cirq.apply_matrix_to_slices(args.target_tensor, cm, slices=[c1, c2], out=args.available_buffer)
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 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 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 test_many_clifford_to_many_z(self): """Confirm correct basis transformations of input PauliSums.""" q = cirq.GridQubit.rect(1, 4) test_term = 0.2277 * cirq.Z(q[1]) * cirq.X(q[2]) * cirq.Y(q[3]) test_basis_gates = [cirq.H(q[2]), cirq.Rx(np.pi / 2)(q[3])] test_conj_gates = [cirq.Rx(-np.pi / 2)(q[3]), cirq.H(q[2])] gate_list, conj_gate_list = util._many_clifford_to_many_z(test_term) self.assertEqual(gate_list, test_basis_gates) self.assertEqual(conj_gate_list, test_conj_gates)
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_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(): """ 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 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 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_text_diagrams(): a = cirq.NamedQubit('a') b = cirq.NamedQubit('b') circuit = cirq.Circuit.from_ops( cirq.SWAP(a, b), cirq.X(a), cirq.Y(a), cirq.Z(a), cirq.Z(a)**sympy.Symbol('x'), cirq.Rx(sympy.Symbol('x')).on(a), cirq.CZ(a, b), cirq.CNOT(a, b), cirq.CNOT(b, a), cirq.H(a)**0.5, cirq.ISWAP(a, b)**-1, cirq.I(a), cirq.IdentityGate(2)(a, b)) cirq.testing.assert_has_diagram(circuit, """ a: ───×───X───Y───Z───Z^x───Rx(x)───@───@───X───H^0.5───iSwap──────I───I─── │ │ │ │ │ │ b: ───×─────────────────────────────@───X───@───────────iSwap^-1───────I─── """) cirq.testing.assert_has_diagram(circuit, """ a: ---swap---X---Y---Z---Z^x---Rx(x)---@---@---X---H^0.5---iSwap------I---I--- | | | | | | b: ---swap-----------------------------@---X---@-----------iSwap^-1-------I--- """, use_unicode_characters=False)
def test_controlled_pqc_simple_learn(self, backend, repetitions): """Test a simple learning scenario using analytic and sample expectation on many backends.""" bit = cirq.GridQubit(0, 0) circuit = \ cirq.Circuit(cirq.Rx(sympy.Symbol('theta'))(bit)) inputs = tf.keras.Input(shape=(1, ), dtype=tf.dtypes.float32) quantum_datum = tf.keras.Input(shape=(), dtype=tf.dtypes.string) l1 = tf.keras.layers.Dense(10)(inputs) l2 = tf.keras.layers.Dense(1)(l1) outputs = controlled_pqc.ControlledPQC(circuit, cirq.Z(bit), repetitions=repetitions, backend=backend)( [quantum_datum, l2]) model = tf.keras.Model(inputs=[quantum_datum, inputs], outputs=outputs) data_in = np.array([[1], [0]], dtype=np.float32) data_out = np.array([[1], [-1]], dtype=np.float32) model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.05), loss=tf.keras.losses.mean_squared_error) data_circuits = util.convert_to_tensor( [cirq.Circuit(cirq.X(bit)), cirq.Circuit()]) history = model.fit(x=[data_circuits, data_in], y=data_out, epochs=30) self.assertAllClose(history.history['loss'][-1], 0, atol=1e-1)
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_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_op_roundtrip_filename(tmpdir): filename = f'{tmpdir}/op.json' q = cirq.LineQubit(5) op1 = cirq.Rx(.123).on(q) cirq.to_json(op1, filename) assert os.path.exists(filename) op2 = cirq.read_json(filename) assert op1 == op2
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 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 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 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) rcnot = cirq.ion.ConvertToIonGates().convert_one(OtherCNOT().on(q0, q1)) assert rx == [ cirq.PhasedXPowGate(phase_exponent=1).on(cirq.GridQubit(0, 0)) ] assert 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]) ] assert rcnot == [ cirq.PhasedXPowGate(phase_exponent=-0.75, exponent=0.5).on(cirq.GridQubit(0, 0)), cirq.PhasedXPowGate(phase_exponent=1, exponent=0.25).on(cirq.GridQubit(0, 1)), cirq.T.on(cirq.GridQubit(0, 0)), cirq.ms(-0.5 * np.pi / 2).on(cirq.GridQubit(0, 0), cirq.GridQubit(0, 1)), (cirq.Y**0.5).on(cirq.GridQubit(0, 0)), cirq.PhasedXPowGate(phase_exponent=1, exponent=0.25).on(cirq.GridQubit(0, 1)), (cirq.Z**-0.75).on(cirq.GridQubit(0, 0)) ]
def test_exponentiate_single_value_as_exponent(): q = cirq.LineQubit(0) assert cirq.approx_eq(math.e**(-0.25j * math.pi * cirq.X(q)), cirq.Rx(0.25 * math.pi).on(q)) assert cirq.approx_eq(math.e**(-0.25j * math.pi * cirq.Y(q)), cirq.Ry(0.25 * math.pi).on(q)) assert cirq.approx_eq(math.e**(-0.25j * math.pi * cirq.Z(q)), cirq.Rz(0.25 * math.pi).on(q)) assert cirq.approx_eq(np.exp(-0.3j * math.pi * cirq.X(q)), cirq.Rx(0.3 * math.pi).on(q)) assert cirq.approx_eq(cirq.X(q)**0.5, cirq.XPowGate(exponent=0.5).on(q)) assert cirq.approx_eq(cirq.Y(q)**0.5, cirq.YPowGate(exponent=0.5).on(q)) assert cirq.approx_eq(cirq.Z(q)**0.5, cirq.ZPowGate(exponent=0.5).on(q))
def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs ) -> Optional[np.ndarray]: if cirq.is_parameterized(self): return None inner_matrix = cirq.unitary(cirq.Rx(-2 * np.pi * self.exponent)) a = args.subspace_index(0b0011) b = args.subspace_index(0b1100) return cirq.apply_matrix_to_slices(args.target_tensor, inner_matrix, slices=[a, b], out=args.available_buffer)
def test_formulaic_rotation_xyz_export(): a = cirq.LineQubit(0) t = sympy.Symbol('t') assert_links_to(cirq.Circuit( cirq.Rx(sympy.pi / 2).on(a), cirq.Ry(sympy.pi * t).on(a), cirq.Rz(-sympy.pi * t).on(a), ), """ http://algassert.com/quirk#circuit={"cols":[ [{"arg":"(1/2)pi","id":"Rxft"}], [{"arg":"(t)pi","id":"Ryft"}], [{"arg":"(-t)pi","id":"Rzft"}] ]} """, escape_url=False) with pytest.raises(ValueError, match='unsupported'): _ = circuit_to_quirk_url( cirq.Circuit(cirq.Rx(sympy.FallingFactorial(t, t)).on(a)))
def test_axis_angle(): assert cirq.approx_eq(cirq.axis_angle(cirq.unitary(cirq.Ry(1e-10))), cirq.AxisAngleDecomposition(angle=0, axis=(1, 0, 0), global_phase=1), atol=1e-8) assert cirq.approx_eq(cirq.axis_angle(cirq.unitary(cirq.Rx(np.pi))), cirq.AxisAngleDecomposition(angle=np.pi, axis=(1, 0, 0), global_phase=1), atol=1e-8) assert cirq.approx_eq(cirq.axis_angle(cirq.unitary(cirq.X)), cirq.AxisAngleDecomposition(angle=np.pi, axis=(1, 0, 0), global_phase=1j), atol=1e-8) assert cirq.approx_eq(cirq.axis_angle(cirq.unitary(cirq.X**0.5)), cirq.AxisAngleDecomposition(angle=np.pi / 2, axis=(1, 0, 0), global_phase=np.exp( 1j * np.pi / 4)), atol=1e-8) assert cirq.approx_eq( cirq.axis_angle(cirq.unitary(cirq.X**-0.5)), cirq.AxisAngleDecomposition(angle=-np.pi / 2, axis=(1, 0, 0), global_phase=np.exp(-1j * np.pi / 4))) assert cirq.approx_eq(cirq.axis_angle(cirq.unitary(cirq.Y)), cirq.AxisAngleDecomposition(angle=np.pi, axis=(0, 1, 0), global_phase=1j), atol=1e-8) assert cirq.approx_eq(cirq.axis_angle(cirq.unitary(cirq.Z)), cirq.AxisAngleDecomposition(angle=np.pi, axis=(0, 0, 1), global_phase=1j), atol=1e-8) assert cirq.approx_eq(cirq.axis_angle(cirq.unitary(cirq.H)), cirq.AxisAngleDecomposition(angle=np.pi, axis=(np.sqrt(0.5), 0, np.sqrt(0.5)), global_phase=1j), atol=1e-8) assert cirq.approx_eq(cirq.axis_angle(cirq.unitary(cirq.H**0.5)), cirq.AxisAngleDecomposition( angle=np.pi / 2, axis=(np.sqrt(0.5), 0, np.sqrt(0.5)), global_phase=np.exp(1j * np.pi / 4)), atol=1e-8)
def test_rx_unitary(): s = np.sqrt(0.5) np.testing.assert_allclose( cirq.unitary(cirq.Rx(np.pi / 2)), np.array([[s, -s*1j], [-s*1j, s]])) np.testing.assert_allclose( cirq.unitary(cirq.Rx(-np.pi / 2)), np.array([[s, s*1j], [s*1j, s]])) np.testing.assert_allclose( cirq.unitary(cirq.Rx(0)), np.array([[1, 0], [0, 1]])) np.testing.assert_allclose( cirq.unitary(cirq.Rx(2 * np.pi)), np.array([[-1, 0], [0, -1]])) np.testing.assert_allclose( cirq.unitary(cirq.Rx(np.pi)), np.array([[0, -1j], [-1j, 0]])) np.testing.assert_allclose( cirq.unitary(cirq.Rx(-np.pi)), np.array([[0, 1j], [1j, 0]]))
def test_formulaic_gates(): a, b = cirq.LineQubit.range(2) t = sympy.Symbol('t') assert_url_to_circuit_returns( '{"cols":[["X^ft",{"id":"X^ft","arg":"t*t"}]]}', cirq.Circuit( cirq.X(a)**sympy.sin(sympy.pi * t), cirq.X(b)**(t * t), )) assert_url_to_circuit_returns( '{"cols":[["Y^ft",{"id":"Y^ft","arg":"t*t"}]]}', cirq.Circuit( cirq.Y(a)**sympy.sin(sympy.pi * t), cirq.Y(b)**(t * t), )) assert_url_to_circuit_returns( '{"cols":[["Z^ft",{"id":"Z^ft","arg":"t*t"}]]}', cirq.Circuit( cirq.Z(a)**sympy.sin(sympy.pi * t), cirq.Z(b)**(t * t), )) assert_url_to_circuit_returns( '{"cols":[["Rxft",{"id":"Rxft","arg":"t*t"}]]}', cirq.Circuit( cirq.Rx(sympy.pi * t * t).on(a), cirq.Rx(t * t).on(b), )) assert_url_to_circuit_returns( '{"cols":[["Ryft",{"id":"Ryft","arg":"t*t"}]]}', cirq.Circuit( cirq.Ry(sympy.pi * t * t).on(a), cirq.Ry(t * t).on(b), )) assert_url_to_circuit_returns( '{"cols":[["Rzft",{"id":"Rzft","arg":"t*t"}]]}', cirq.Circuit( cirq.Rz(sympy.pi * t * t).on(a), cirq.Rz(t * t).on(b), ))
def test_decomposition(): d = ion_device(3) q0 = cirq.LineQubit(0) q1 = cirq.LineQubit(1) assert d.decompose_operation(cirq.H(q0)) == [ cirq.Rx(np.pi*1.0).on(cirq.LineQubit(0)), cirq.Ry(np.pi*-0.5).on(cirq.LineQubit(0))] circuit = cirq.Circuit() circuit.append([cirq.X(q0), cirq.CNOT(q0, q1)]) ion_circuit = d.decompose_circuit(circuit) d.validate_circuit(ion_circuit) cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent( circuit, ion_circuit, atol=1e-6)
def test_resolve_scalar_placeholder(): """Resolve scalar placeholders via feed_dict.""" wf = cirq.testing.random_superposition(4).astype(np.complex64) params = [0.83, 1.2] theta_x = tf.placeholder(tf.complex64, shape=(), name="theta_x") theta_y = tf.placeholder(tf.complex64, shape=(), name="theta_y") placeholder_circuit = cirq.Circuit.from_ops([ cirq.Rx(theta_x)(q(0)), cirq.Ry(theta_y)(q(1)), ]) circuit_op = TFWaveFunctionSimulator(dtype=tf.complex64).simulate( placeholder_circuit, initial_state=wf) feed_dict = dict(zip([theta_x, theta_y], params)) with tf.Session() as sess: tf_result = sess.run(circuit_op, feed_dict=feed_dict).reshape(-1) circuit = cirq.Circuit.from_ops([ cirq.Rx(params[0])(q(0)), cirq.Ry(params[1])(q(1)), ]) cirq_result = cirq.Simulator().simulate( circuit, initial_state=np.copy(wf)).final_state np.testing.assert_array_almost_equal(tf_result, cirq_result)