def main_4(): qft_4 = partial(qft_qem_vag, n=4) set_op_pool( [ cirq.I, cirq.X, cirq.Y, cirq.Z, cirq.H, cirq.rx(np.pi / 3), cirq.rx(np.pi * 2.0 / 3), cirq.rz(np.pi / 3), cirq.rz(np.pi * 2.0 / 3), cirq.S, cirq.T, ] ) DQAS_search( qft_4, nnp_initial_value=tf.zeros([12, 11]), p=12, prethermal=0, batch=32, verbose=False, verbose_func=verbose_output, epochs=6, )
def layer(weights, qbits): ret = [] ret.append(cirq.CNOT(qbits[0], qbits[1])) ret.append(cirq.CNOT(qbits[1], qbits[2])) ret.append(cirq.CNOT(qbits[2], qbits[3])) i = 0 j = 0 temp = [] while i < len(qbits): rz_g = cirq.rz(weights[j]) temp.append(rz_g(qbits[i])) i += 1 j += 1 ret.append(cirq.Moment(temp)) i = 0 temp.clear() while i < len(qbits): ry_g = cirq.ry(weights[j]) temp.append(ry_g(qbits[i])) i += 1 j += 1 ret.append(cirq.Moment(temp)) i = 0 temp.clear() while i < len(qbits): rz_g2 = cirq.rz(weights[j]) ret.append(rz_g2(qbits[i])) i += 1 j += 1 ret.append(cirq.Moment(temp)) a = cirq.Circuit() a.append(ret) print(a) return a
def test_joined_generator(self): generator1 = TwoRotsGenerator() generator2 = OneRotGenerator() grad = op_tree_generator_grad( OpTreeGenerator.join(generator1, generator2), rad ) grad_lco = LinearCombinationOfOperations({ _generator((q0, q1)): _coeff for _generator, _coeff in grad.items() }) for _generator, _coeff in grad.items(): print(_generator.diagram(), _coeff) exact_grad_lco = LinearCombinationOfOperations({ (X(q0), rx(rad).on(q0), rz(rad).on(q1), ry(c * rad).on(q0)): -0.5j, (rx(rad).on(q0), Z(q1), rz(rad).on(q1), ry(c * rad).on(q0)): -0.5j, (rx(rad).on(q0), rz(rad).on(q1), Y(q0), ry(c * rad).on(q0)): -0.5j * c, }) param_resolver = { rad: np.random.rand() * 4 * np.pi, c: np.random.rand() } grad_lco = cirq.resolve_parameters(grad_lco, param_resolver) exact_grad_lco = cirq.resolve_parameters(exact_grad_lco, param_resolver) test_lco_identical_with_simulator( grad_lco, exact_grad_lco, self )
def _transformation_gates_from_z( pauli: Pauli ) -> typing.Tuple[typing.List[cirq.Gate], typing.List[cirq.Gate]]: if pauli == Pauli("Z"): return [], [] elif pauli == Pauli("X"): return [cirq.H], [cirq.H] elif pauli == Pauli("Y"): # vectors_y.inv.dagger @ z @ vectors_y.inv == y # vectors_y == i Rz(pi/2) Ry(pi/2) Rz(3pi/2) # vectors_y.inv == -i Rz(-3pi/2) Ry(-pi/2) Rz(-pi/2) # vectors_y.inv.dagger == i Rz(pi/2) Ry(pi/2) Rz(3pi/2) return ([ cirq.rz(np.pi / 2), cirq.ry(np.pi / 2), cirq.rz(3 * np.pi / 2) ], [ cirq.rz(-3 * np.pi / 2), cirq.ry(-np.pi / 2), cirq.rz(-np.pi / 2) ]) else: raise ValueError("invalid Pauli {}".format(pauli))
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 call(self, theta_inp): """Keras call function. Input options: `inputs`, `symbol_names`, `symbol_values`: see `input_checks.expand_circuits` Output shape: `tf.RaggedTensor` with shape: [batch size of symbol_values, <size of state>, <size of state>] or [number of circuits, <size of state>, <size of state>] """ wx = cirq.Circuit(cirq.rx(2 * theta_inp)) self.rot_zs = [ cirq.Circuit(cirq.rz(2 * self.phi[k])(self.q)) for k in range(self.poly_deg) ] full_circuit = self.rot_zs[0] full_circuit_test = cirq.Circuit( cirq.rz(2 * self.symbol_names[0])(self.q), cirq.rx(2 * self.symbol_names[-1])(self.q), cirq.rz(2 * self.symbol_names[0])(self.q)) phi_values = tf.expand_dims(self.phi, axis=0) symbol_values = tf.expand_dims(tf.concat([self.phi, [4]], 0), 0) tensor_full_circuit_test = tfq.convert_to_tensor([full_circuit_test]) tfq.from_tensor( tfq.resolve_parameters(tensor_full_circuit_test, self.symbol_names, symbol_values)) return full_circuit_test.unitary()[0, 0]
def _decompose_(self, qubits): control, target = qubits yield cirq.rz(self.rads / 2.0).on(target) yield cirq.CNOT(control=control, target=target) yield cirq.rz(-self.rads / 2.0).on(target) yield cirq.CNOT(control=control, target=target)
def test_approx_eq_symbol(): q = cirq.GridQubit(0, 0) s = sympy.Symbol("s") t = sympy.Symbol("t") assert not cirq.approx_eq(t + 1.51 + s, t + 1.50 + s, atol=0.005) assert cirq.approx_eq(t + 1.51 + s, t + 1.50 + s, atol=0.020) with pytest.raises( AttributeError, match="Insufficient information to decide whether expressions are " "approximately equal .* vs .*", ): cirq.approx_eq(t, 0.0, atol=0.005) symbol_1 = cirq.Circuit(cirq.rz(1.515 + s)(q)) symbol_2 = cirq.Circuit(cirq.rz(1.510 + s)(q)) assert cirq.approx_eq(symbol_1, symbol_2, atol=0.2) symbol_3 = cirq.Circuit(cirq.rz(1.510 + t)(q)) with pytest.raises( AttributeError, match="Insufficient information to decide whether expressions are " "approximately equal .* vs .*", ): cirq.approx_eq(symbol_1, symbol_3, atol=0.2)
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' assert str(cirq.CZ) == 'CZ' assert str(cirq.CZ**0.5) == 'CZ**0.5' assert str(cirq.cphase(np.pi)) == 'CZ' assert str(cirq.cphase(np.pi / 2)) == 'CZ**0.5'
def layer(circuit, qubits, params): circuit += cirq.CNOT(qubits[0], qubits[1]) circuit += cirq.ry(params[0]).on(qubits[0]) circuit += cirq.rz(params[1]).on(qubits[0]) circuit += cirq.ry(params[2]).on(qubits[1]) circuit += cirq.rz(params[3]).on(qubits[1]) return circuit
def _decompose_(self, qubits): #U gate object takes in two qubits as input q0, q1 = qubits #U^(1) #Y on q0 yield cirq.ry(self.l[0]).on(q0) #X on q0 yield cirq.rx(self.l[1]).on(q0) #U^(2) #Y on q1 yield cirq.ry(self.l[2]).on(q1) #XY on q0,q1 yield cirq.H(q0) yield cirq.rx(np.pi/2).on(q1) yield cirq.CNOT(q0,q1) yield cirq.rz(self.l[3]).on(q1) yield cirq.CNOT(q0,q1) yield cirq.rx(-np.pi/2).on(q1) yield cirq.H(q0) #X on q1 yield cirq.rx(self.l[4]).on(q1) #XX on q0,q1 yield cirq.H(q0) yield cirq.H(q1) yield cirq.CNOT(q0,q1) yield cirq.rz(self.l[5]).on(q1) yield cirq.CNOT(q0,q1) yield cirq.H(q1) yield cirq.H(q0)
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 cirq.SQRT_ISWAP_INV(a, b) yield cirq.rx(-2 * phi).on(a) yield cirq.SQRT_ISWAP(a, b) yield cirq.rx(xi).on(a) yield cirq.X(b)**(sign * 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 trotter_step(self, qubits: Sequence[cirq.Qid], time: float, control_qubit: Optional[cirq.Qid] = 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_merge_rotations(self): q_0 = cirq.NamedQubit("q_0") before = cirq.Circuit( [cirq.rz(np.pi / 4).on(q_0), cirq.rz(np.pi / 4).on(q_0)]) after = cirq.Circuit([cirq.S.on(q_0)]) self.assertEqual(self.run_voqc(before, ["merge_rotations"]), after)
def _apply_unitary_(self, args: 'cirq.ApplyUnitaryArgs') -> Optional[np.ndarray]: if cirq.is_parameterized(self): return None oi = args.subspace_index(0b01) io = args.subspace_index(0b10) ii = args.subspace_index(0b11) if self.theta != 0 or self.zeta != 0 or self.chi != 0: rx = protocols.unitary(cirq.rx(2 * self.theta)) rz1 = protocols.unitary(cirq.rz(-self.zeta + self.chi)) rz2 = protocols.unitary(cirq.rz(-self.zeta - self.chi)) inner_matrix = rz1 @ rx @ rz2 out = cirq.apply_matrix_to_slices(args.target_tensor, inner_matrix, slices=[oi, io], out=args.available_buffer) else: out = args.target_tensor if self.phi != 0: out[ii] *= cmath.exp(-1j * self.phi) if self.gamma != 0: f = cmath.exp(-1j * self.gamma) out[oi] *= f out[io] *= f out[ii] *= f * f return out
def _decompose_(self, qubits): a, b, c, d, e, f = self.βγs[:6] return [ cirq.rx(a)(qubits[0]), cirq.rx(b)(qubits[1]), cirq.rz(c)(qubits[0]), cirq.rz(d)(qubits[1]), (cirq.XX**e)(*qubits), (cirq.YY**f)(*qubits) ]
def _decompose_(self, qubits): return [[cirq.rz(a)(qubits[0]), cirq.rz(d)(qubits[1])] + \ [cirq.rx(b)(qubits[0]), cirq.rx(e)(qubits[1])] + \ [cirq.rz(c)(qubits[0]), cirq.rz(f)(qubits[1])] + \ list(reversed([cirq.CNOT(qubits[i], qubits[i + 1]) for i in range(self.n_qubits - 1)])) +\ [cirq.SWAP(qubits[i], qubits[i+1 if i!= self.n_qubits-1 else 0]) for i in list(range(self.n_qubits))] for a, b, c, d, e, f in split_ns(self.βγs, 6)]
def ryxxy(a, b, theta): """Implements the givens rotation with sqrt(iswap). The inverse(sqrt(iswap)) is made with z before and after""" yield cirq.ISWAP.on(a, b)**0.5 yield cirq.rz(-theta + np.pi).on(a) yield cirq.rz(theta).on(b) yield cirq.ISWAP.on(a, b)**0.5 yield cirq.rz(np.pi).on(a)
def _decompose_(self, qubits): return [[cirq.rz(β)(qubit) for qubit in qubits] + \ [cirq.rx(γ)(qubit) for qubit in qubits] + \ [cirq.rz(ω)(qubit) for qubit in qubits] + \ [cirq.H(qubits[0])]+\ list(reversed([cirq.CNOT(qubits[i], qubits[i + 1]) for i in range(self.n_qubits - 1)])) #+\ # [cirq.SWAP(qubits[i], qubits[i+1 if i!= self.n_qubits-1 else 0]) for i in list(range(self.n_qubits))] for β, γ, ω in split_3s(self.βγs)]
def _zxz_ry(q, thetas): symbols_dict['z1'].add(thetas[0]) symbols_dict['x'].add(thetas[1]) symbols_dict['z2'].add(thetas[2]) return [ cirq.rz(thetas[0]).on(q), cirq.rx(thetas[1]).on(q), cirq.rz(thetas[2]).on(q) ]
def _decompose_(self, qubits): return [ cirq.rz(self.ψ)(qubits[1]), cirq.rx(self.ϕ)(qubits[1]), cirq.rx(self.θ)(qubits[0]), cirq.CNOT(qubits[1], qubits[0]), cirq.rx(self.θ)(qubits[0]), cirq.rx(-self.ϕ)(qubits[1]), cirq.rz(-self.ψ)(qubits[1]) ]
def ryxxy2(a, b, theta): """ Implement realistic Givens rotation considering the always on parasitic cphase """ yield cirq.FSimGate(-np.pi / 4, np.pi / 24).on(a, b) yield cirq.rz(-theta + np.pi).on(a) yield cirq.rz(theta).on(b) yield cirq.FSimGate(-np.pi / 4, np.pi / 24).on(a, b) yield cirq.rz(np.pi).on(a)
def test_rxyz_circuit_diagram(): q = cirq.NamedQubit('q') cirq.testing.assert_has_diagram( cirq.Circuit( 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( 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( 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( 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 __init__(self, phi, theta, alpha, qubit=None): self.phi = phi self.theta = theta self.alpha = alpha self.qubit = qubit self.exponent = 1 self.gates = [ cirq.rz(phi)**-1, cirq.ry(theta)**-1, cirq.rz(alpha), cirq.ry(theta), cirq.rz(phi) ]
def test_ryxxy2(): a, b = cirq.LineQubit.range(2) test_circuit = list(ryxxy2(a, b, np.pi / 3)) true_circuit = [ cirq.FSimGate(-np.pi / 4, np.pi / 24).on(a, b), cirq.rz(-np.pi / 3 + np.pi).on(a), cirq.rz(np.pi / 3).on(b), cirq.FSimGate(-np.pi / 4, np.pi / 24).on(a, b), cirq.rz(np.pi).on(a) ] assert test_circuit == true_circuit
def test_ryxxy(): a, b = cirq.LineQubit.range(2) test_circuit = list(ryxxy(a, b, np.pi / 3)) true_circuit = [ cirq.ISWAP.on(a, b)**0.5, cirq.rz(-np.pi / 3 + np.pi).on(a), cirq.rz(np.pi / 3).on(b), cirq.ISWAP.on(a, b)**0.5, cirq.rz(np.pi).on(a) ] assert test_circuit == true_circuit
def test_QulacsDensityMatrixSimulator_Ugate(self): qubits = [cirq.LineQubit(i) for i in range(self.qubit_n)] circuit = cirq.Circuit() for _ in range(self.test_repeat): index = np.random.randint(self.qubit_n) angle = np.random.rand(3) * np.pi * 2 # circuit.append(cirq.circuits.qasm_output.QasmUGate(angle[0], angle[1], angle[2]).on(qubits[index])) circuit.append(cirq.rz(angle[0]).on(qubits[index])) circuit.append(cirq.ry(angle[1]).on(qubits[index])) circuit.append(cirq.rz(angle[2]).on(qubits[index])) self.check_result(circuit)
def ryxxy4(a, b, theta): """ Implement realistic Givens rotation considering the always on parasitic cphase and attempt to reduce the error by 1/3 for running on hardware """ yield cirq.FSimGate(-np.pi / 4, 0).on(a, b) yield cirq.rz(-theta + np.pi + np.pi / 48).on(a) yield cirq.rz(theta + np.pi / 48).on(b) yield cirq.FSimGate(-np.pi / 4, 0).on(a, b) yield cirq.rz(np.pi + np.pi / 48).on(a) yield cirq.rz(+np.pi / 48).on(b)
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)