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)
