def test_circuit_addition_execution(backend, accelerators):
c1 = Circuit(4, accelerators)
c1.add(gates.H(0))
c1.add(gates.H(1))
c1.add(gates.H(2))
c2 = Circuit(4, accelerators)
c2.add(gates.CNOT(0, 1))
c2.add(gates.CZ(2, 3))
c3 = c1 + c2
c = Circuit(4, accelerators)
c.add(gates.H(0))
c.add(gates.H(1))
c.add(gates.H(2))
c.add(gates.CNOT(0, 1))
c.add(gates.CZ(2, 3))
K.assert_allclose(c3(), c())
def test_set_parameters_with_variationallayer(backend, nqubits, accelerators):
"""Check updating parameters of variational layer."""
theta = np.random.random(nqubits)
c = Circuit(nqubits, accelerators)
pairs = [(i, i + 1) for i in range(0, nqubits - 1, 2)]
c.add(
gates.VariationalLayer(range(nqubits), pairs, gates.RY, gates.CZ,
theta))
target_c = Circuit(nqubits)
target_c.add((gates.RY(i, theta[i]) for i in range(nqubits)))
target_c.add((gates.CZ(i, i + 1) for i in range(0, nqubits - 1, 2)))
K.assert_allclose(c(), target_c())
# Test setting VariationalLayer using a list
new_theta = np.random.random(nqubits)
c.set_parameters([np.copy(new_theta)])
target_c.set_parameters(np.copy(new_theta))
K.assert_allclose(c(), target_c())
# Test setting VariationalLayer using an array
new_theta = np.random.random(nqubits)
c.set_parameters(np.copy(new_theta))
target_c.set_parameters(np.copy(new_theta))
K.assert_allclose(c(), target_c())
def test_set_parameters_with_gate_fusion(backend, trainable):
"""Check updating parameters of fused circuit."""
params = np.random.random(9)
c = Circuit(5)
c.add(gates.RX(0, theta=params[0], trainable=trainable))
c.add(gates.RY(1, theta=params[1]))
c.add(gates.CZ(0, 1))
c.add(gates.RX(2, theta=params[2]))
c.add(gates.RY(3, theta=params[3], trainable=trainable))
c.add(gates.fSim(2, 3, theta=params[4], phi=params[5]))
c.add(gates.RX(4, theta=params[6]))
c.add(gates.RZ(0, theta=params[7], trainable=trainable))
c.add(gates.RZ(1, theta=params[8]))
fused_c = c.fuse()
final_state = fused_c()
target_state = c()
K.assert_allclose(final_state, target_state)
if trainable:
new_params = np.random.random(9)
new_params_list = list(new_params[:4])
new_params_list.append((new_params[4], new_params[5]))
new_params_list.extend(new_params[6:])
else:
new_params = np.random.random(9)
new_params_list = list(new_params[1:3])
new_params_list.append((new_params[4], new_params[5]))
new_params_list.append(new_params[6])
new_params_list.append(new_params[8])
c.set_parameters(new_params_list)
fused_c.set_parameters(new_params_list)
K.assert_allclose(c(), fused_c())
def test_controlled_u1(backend):
theta = 0.1234
c = Circuit(3)
c.add(gates.X(0))
c.add(gates.X(1))
c.add(gates.X(2))
c.add(gates.U1(2, theta).controlled_by(0, 1))
c.add(gates.X(0))
c.add(gates.X(1))
final_state = c.execute()
target_state = np.zeros_like(final_state)
target_state[1] = np.exp(1j * theta)
K.assert_allclose(final_state, target_state)
gate = gates.U1(0, theta).controlled_by(1)
assert gate.__class__.__name__ == "CU1"
def test_controlled_x(backend, accelerators):
c = Circuit(4, accelerators)
c.add(gates.X(0))
c.add(gates.X(1))
c.add(gates.X(2))
c.add(gates.X(3).controlled_by(0, 1, 2))
c.add(gates.X(0))
c.add(gates.X(2))
target_c = Circuit(4)
target_c.add(gates.X(1))
target_c.add(gates.X(3))
K.assert_allclose(c(), target_c())
def test_controlled_unitary(backend, accelerators):
matrix = np.random.random((2, 2))
c = Circuit(2)
c.add(gates.H(0))
c.add(gates.H(1))
c.add(gates.Unitary(matrix, 1).controlled_by(0))
final_state = c.execute()
target_state = np.ones_like(final_state) / 2.0
target_state[2:] = matrix.dot(target_state[2:])
K.assert_allclose(final_state, target_state)
matrix = np.random.random((4, 4))
c = Circuit(4, accelerators)
c.add((gates.H(i) for i in range(4)))
c.add(gates.Unitary(matrix, 1, 3).controlled_by(0, 2))
final_state = c.execute()
target_state = np.ones_like(final_state) / 4.0
ids = [10, 11, 14, 15]
target_state[ids] = matrix.dot(target_state[ids])
K.assert_allclose(final_state, target_state)
def test_controlled_x_vs_toffoli(backend):
c1 = Circuit(3)
c1.add(gates.X(0))
c1.add(gates.X(2))
c1.add(gates.X(1).controlled_by(0, 2))
c2 = Circuit(3)
c2.add(gates.X(0))
c2.add(gates.X(2))
c2.add(gates.TOFFOLI(0, 2, 1))
K.assert_allclose(c1(), c2())
def test_circuit_decompose():
"""Check ``circuit.decompose`` agrees with multi-control ``X`` decomposition."""
c = Circuit(6)
c.add(gates.RX(0, 0.1234))
c.add(gates.RY(1, 0.4321))
c.add((gates.H(i) for i in range(2, 6)))
c.add(gates.CNOT(0, 1))
c.add(gates.X(3).controlled_by(0, 1, 2, 4))
decomp_c = c.decompose(5)
init_state = utils.random_numpy_state(c.nqubits)
target_state = c(np.copy(init_state)).numpy()
final_state = decomp_c(np.copy(init_state)).numpy()
np.testing.assert_allclose(final_state, target_state, atol=_ATOL)
target_c = Circuit(c.nqubits)
target_c.add(gates.RX(0, 0.1234))
target_c.add(gates.RY(1, 0.4321))
target_c.add((gates.H(i) for i in range(2, 6)))
target_c.add(gates.CNOT(0, 1))
target_c.add(gates.X(3).controlled_by(0, 1, 2, 4).decompose(5))
assert_circuit_same_gates(decomp_c, target_c)
def test_circuit_decompose_with_measurements():
"""Check ``circuit.decompose`` for circuit with measurements."""
c = Circuit(8)
c.add(gates.X(4).controlled_by(0, 2, 5, 6, 7))
c.add(gates.M(0, 2, 4, 6, register_name="A"))
c.add(gates.M(1, 3, 5, 7, register_name="B"))
target_c = Circuit(8)
target_c.add(gates.X(4).controlled_by(0, 2, 5, 6, 7).decompose(1, 3))
target_c.add(gates.M(0, 2, 4, 6, register_name="A"))
target_c.add(gates.M(1, 3, 5, 7, register_name="B"))
decomp_c = c.decompose(1, 3)
assert_circuit_same_gates(decomp_c, target_c)
def test_entropy_in_distributed_circuit(backend, accelerators, gateconf,
target_entropy):
"""Check that various entropy configurations work in distributed circuit."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
target_c = Circuit(4)
target_c.add([gates.H(0), gates.CNOT(0, 1)])
target_state = target_c()
entropy = callbacks.EntanglementEntropy([0])
c = Circuit(4, accelerators)
for gate in gateconf:
if gate == "H":
c.add(gates.H(0))
elif gate == "CNOT":
c.add(gates.CNOT(0, 1))
elif gate == "entropy":
c.add(gates.CallbackGate(entropy))
final_state = c()
np.testing.assert_allclose(final_state, target_state)
np.testing.assert_allclose(entropy[:], target_entropy, atol=_atol)
qibo.set_backend(original_backend)
def test_entropy_in_compiled_circuit(backend):
"""Check that entropy calculation works when circuit is compiled."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
entropy = callbacks.EntanglementEntropy([0])
c = Circuit(2)
c.add(gates.CallbackGate(entropy))
c.add(gates.H(0))
c.add(gates.CallbackGate(entropy))
c.add(gates.CNOT(0, 1))
c.add(gates.CallbackGate(entropy))
if backend == "custom":
with pytest.raises(RuntimeError):
c.compile()
else:
c.compile()
final_state = c()
np.testing.assert_allclose(entropy[:], [0, 0, 1.0], atol=_atol)
qibo.set_backend(original_backend)
def test_entropy_in_circuit(backend, density_matrix):
"""Check that entropy calculation works in circuit."""
original_backend = qibo.get_backend()
qibo.set_backend(backend)
entropy = callbacks.EntanglementEntropy([0], compute_spectrum=True)
c = Circuit(2, density_matrix=density_matrix)
c.add(gates.CallbackGate(entropy))
c.add(gates.H(0))
c.add(gates.CallbackGate(entropy))
c.add(gates.CNOT(0, 1))
c.add(gates.CallbackGate(entropy))
state = c()
target = [0, 0, 1.0]
np.testing.assert_allclose(entropy[:], target, atol=_atol)
target_spectrum = [0, 0, np.log(2), np.log(2)]
entropy_spectrum = np.concatenate(entropy.spectrum).ravel().tolist()
np.testing.assert_allclose(entropy_spectrum, target_spectrum, atol=_atol)
qibo.set_backend(original_backend)
def test_circuit_invert_and_addition_execution(backend, accelerators):
subroutine = Circuit(6)
subroutine.add([gates.RX(i, theta=0.1) for i in range(5)])
subroutine.add([gates.CZ(i, i + 1) for i in range(0, 5, 2)])
middle = Circuit(6)
middle.add([gates.CU2(i, i + 1, phi=0.1, lam=0.2) for i in range(0, 5, 2)])
circuit = subroutine + middle + subroutine.invert()
c = Circuit(6)
c.add([gates.RX(i, theta=0.1) for i in range(5)])
c.add([gates.CZ(i, i + 1) for i in range(0, 5, 2)])
c.add([gates.CU2(i, i + 1, phi=0.1, lam=0.2) for i in range(0, 5, 2)])
c.add([gates.CZ(i, i + 1) for i in range(0, 5, 2)])
c.add([gates.RX(i, theta=-0.1) for i in range(5)])
assert c.depth == circuit.depth
K.assert_allclose(circuit(), c())
def test_inverse_circuit_execution(backend, accelerators, fuse):
c = Circuit(4, accelerators)
c.add(gates.RX(0, theta=0.1))
c.add(gates.U2(1, phi=0.2, lam=0.3))
c.add(gates.U3(2, theta=0.1, phi=0.3, lam=0.2))
c.add(gates.CNOT(0, 1))
c.add(gates.CZ(1, 2))
c.add(gates.fSim(0, 2, theta=0.1, phi=0.3))
c.add(gates.CU2(0, 1, phi=0.1, lam=0.1))
if fuse:
if accelerators:
with pytest.raises(NotImplementedError):
c = c.fuse()
else:
c = c.fuse()
invc = c.invert()
target_state = np.ones(2**4) / 4
final_state = invc(c(np.copy(target_state)))
K.assert_allclose(final_state, target_state)
def test_controlled_swap(backend, applyx, free_qubit):
f = int(free_qubit)
c = Circuit(3 + f)
if applyx:
c.add(gates.X(0))
c.add(gates.RX(1 + f, theta=0.1234))
c.add(gates.RY(2 + f, theta=0.4321))
c.add(gates.SWAP(1 + f, 2 + f).controlled_by(0))
final_state = c.execute()
c = Circuit(3 + f)
c.add(gates.RX(1 + f, theta=0.1234))
c.add(gates.RY(2 + f, theta=0.4321))
if applyx:
c.add(gates.X(0))
c.add(gates.SWAP(1 + f, 2 + f))
target_state = c.execute()
K.assert_allclose(final_state, target_state)
def quantum_order_finding_full(N, a):
"""Quantum circuit that performs the order finding algorithm using a fully quantum iQFT.
Args:
N (int): number to factorize.
a (int): chosen number to use in the algorithm.
Returns:
s (float): value of the state measured by the quantum computer.
"""
print(' - Performing algorithm using a fully quantum iQFT.\n')
# Creating the parts of the needed quantum circuit.
n = int(np.ceil(np.log2(N)))
b = [i for i in range(n + 1)]
x = [n + 1 + i for i in range(n)]
ancilla = 2 * n + 1
q_reg = [2 * n + 2 + i for i in range(2 * n)]
circuit = Circuit(4 * n + 2)
print(f' - Total number of qubits used: {4*n+2}.\n')
# Building the quantum circuit
for i in range(len(q_reg)):
circuit.add(gates.H(q_reg[i]))
circuit.add(gates.X(x[len(x) - 1]))
exponents = []
exp = a % N
for i in range(len(q_reg)):
exponents.append(exp)
exp = (exp**2) % N
#a**(2**i)
circuit.add((c_U(q, x, b, exponents[i], N, ancilla, n)
for i, q in enumerate(q_reg)))
circuit.add(i_qft(q_reg))
# Adding measurement gates
circuit.add(gates.M(*q_reg))
result = circuit(nshots=1)
s = result.frequencies(binary=False).most_common()[0][0]
print(f"The quantum circuit measures s = {s}.\n")
return s
def test_controlled_swap_double(backend, applyx):
c = Circuit(4)
c.add(gates.X(0))
if applyx:
c.add(gates.X(3))
c.add(gates.RX(1, theta=0.1234))
c.add(gates.RY(2, theta=0.4321))
c.add(gates.SWAP(1, 2).controlled_by(0, 3))
c.add(gates.X(0))
final_state = c.execute()
c = Circuit(4)
c.add(gates.RX(1, theta=0.1234))
c.add(gates.RY(2, theta=0.4321))
if applyx:
c.add(gates.X(3))
c.add(gates.SWAP(1, 2))
target_state = c.execute()
K.assert_allclose(final_state, target_state)
def quantum_order_finding_semiclassical(N, a):
"""Quantum circuit that performs the order finding algorithm using a semiclassical iQFT.
Args:
N (int): number to factorize.
a (int): chosen number to use in the algorithm.
Returns:
s (float): value of the state measured by the quantum computer.
"""
print(' - Performing algorithm using a semiclassical iQFT.\n')
# Creating the parts of the needed quantum circuit.
n = int(np.ceil(np.log2(N)))
b = [i for i in range(n + 1)]
x = [n + 1 + i for i in range(n)]
ancilla = 2 * n + 1
q_reg = 2 * n + 2
print(f' - Total number of qubits used: {2*n+3}.\n')
results = []
exponents = []
exp = a % N
for i in range(2 * n):
exponents.append(exp)
exp = (exp**2) % N
circuit = Circuit(2 * n + 3)
# Building the quantum circuit
circuit.add(gates.H(q_reg))
circuit.add(gates.X(x[len(x) - 1]))
#a_i = (a**(2**(2*n - 1)))
circuit.add(c_U(q_reg, x, b, exponents[-1], N, ancilla, n))
circuit.add(gates.H(q_reg))
results.append(circuit.add(gates.M(q_reg, collapse=True)))
# Using multiple measurements for the semiclassical QFT.
for i in range(1, 2 * n):
# reset measured qubit to |0>
circuit.add(gates.RX(q_reg, theta=np.pi * results[-1]))
circuit.add(gates.H(q_reg))
#a_i = (a**(2**(2*n - 1 - i)))
circuit.add(c_U(q_reg, x, b, exponents[-1 - i], N, ancilla, n))
angle = 0
for k in range(2, i + 2):
angle += 2 * np.pi * results[i + 1 - k] / (2**k)
circuit.add(gates.U1(q_reg, -angle))
circuit.add(gates.H(q_reg))
results.append(circuit.add(gates.M(q_reg, collapse=True)))
circuit() # execute
s = sum(int(r.outcome()) * (2**i) for i, r in enumerate(results))
print(f"The quantum circuit measures s = {s}.\n")
return s
def test_controlled_x_vs_cnot(backend):
c1 = Circuit(3)
c1.add(gates.X(0))
c1.add(gates.X(2).controlled_by(0))
c2 = Circuit(3)
c2.add(gates.X(0))
c2.add(gates.CNOT(0, 2))
K.assert_allclose(c1(), c2())
def test_entropy_in_distributed_circuit():
"""Check that various entropy configurations work in distributed circuit."""
target_c = Circuit(2)
target_c.add([gates.H(0), gates.CNOT(0, 1)])
target_state = target_c().numpy()
accelerators = {"/GPU:0": 1, "/GPU:1": 1}
entropy = callbacks.EntanglementEntropy([0])
c = Circuit(2, accelerators)
c.add([gates.H(0), gates.CNOT(0, 1), gates.CallbackGate(entropy)])
final_state = c().numpy()
np.testing.assert_allclose(final_state, target_state)
np.testing.assert_allclose(entropy[:].numpy(), [1.0], atol=_atol)
entropy = callbacks.EntanglementEntropy([0])
c = Circuit(2, accelerators)
c.add([gates.H(0), gates.CallbackGate(entropy), gates.CNOT(0, 1)])
final_state = c().numpy()
np.testing.assert_allclose(final_state, target_state)
np.testing.assert_allclose(entropy[:].numpy(), [0.0], atol=_atol)
entropy = callbacks.EntanglementEntropy([0])
c = Circuit(2, accelerators)
c.add([gates.CallbackGate(entropy), gates.H(0), gates.CNOT(0, 1)])
final_state = c().numpy()
np.testing.assert_allclose(final_state, target_state)
np.testing.assert_allclose(entropy[:].numpy(), [0.0], atol=_atol)
entropy = callbacks.EntanglementEntropy([0])
c = Circuit(2, accelerators)
c.add([gates.CallbackGate(entropy), gates.H(0),
gates.CNOT(0, 1), gates.CallbackGate(entropy)])
final_state = c().numpy()
np.testing.assert_allclose(final_state, target_state)
np.testing.assert_allclose(entropy[:].numpy(), [0, 1.0], atol=_atol)
entropy = callbacks.EntanglementEntropy([0])
c = Circuit(2, accelerators)
c.add([gates.H(0), gates.CallbackGate(entropy),
gates.CNOT(0, 1), gates.CallbackGate(entropy)])
final_state = c().numpy()
np.testing.assert_allclose(final_state, target_state)
np.testing.assert_allclose(entropy[:].numpy(), [0, 1.0], atol=_atol)
entropy = callbacks.EntanglementEntropy([0])
c = Circuit(2, accelerators)
c.add([gates.CallbackGate(entropy), gates.H(0),
gates.CallbackGate(entropy), gates.CNOT(0, 1)])
final_state = c().numpy()
np.testing.assert_allclose(final_state, target_state)
np.testing.assert_allclose(entropy[:].numpy(), [0, 0], atol=_atol)
def test_controlled_rx(backend, applyx):
theta = 0.1234
c = Circuit(3)
c.add(gates.X(0))
if applyx:
c.add(gates.X(1))
c.add(gates.RX(2, theta).controlled_by(0, 1))
c.add(gates.X(0))
final_state = c.execute()
c = Circuit(3)
if applyx:
c.add(gates.X(1))
c.add(gates.RX(2, theta))
target_state = c.execute()
K.assert_allclose(final_state, target_state)
def test_entropy_in_compiled_circuit():
"""Check that entropy calculation works when circuit is compiled."""
import qibo
original_backend = qibo.get_backend()
qibo.set_backend("matmuleinsum")
entropy = callbacks.EntanglementEntropy([0])
c = Circuit(2)
c.add(gates.CallbackGate(entropy))
c.add(gates.H(0))
c.add(gates.CallbackGate(entropy))
c.add(gates.CNOT(0, 1))
c.add(gates.CallbackGate(entropy))
c.compile()
state = c()
qibo.set_backend("custom")
target = [0, 0, 1.0]
np.testing.assert_allclose(entropy[:].numpy(), target, atol=_atol)
qibo.set_backend(original_backend)
def test_controlled_u2(backend):
phi = 0.1234
lam = 0.4321
c = Circuit(3)
c.add([gates.X(0), gates.X(1)])
c.add(gates.U2(2, phi, lam).controlled_by(0, 1))
c.add([gates.X(0), gates.X(1)])
final_state = c()
c = Circuit(3)
c.add([gates.X(0), gates.X(1)])
c.add(gates.U2(2, phi, lam))
c.add([gates.X(0), gates.X(1)])
target_state = c()
K.assert_allclose(final_state, target_state)
# for coverage
gate = gates.CU2(0, 1, phi, lam)
assert gate.parameters == (phi, lam)
def test_entropy_multiple_executions(accelerators):
"""Check entropy calculation when the callback is used in multiple executions."""
entropy = callbacks.EntanglementEntropy([0])
target_c = Circuit(2)
target_c.add([gates.RY(0, 0.1234), gates.CNOT(0, 1)])
target_state = target_c().numpy()
c = Circuit(2, accelerators)
c.add(gates.RY(0, 0.1234))
c.add(gates.CallbackGate(entropy))
c.add(gates.CNOT(0, 1))
c.add(gates.CallbackGate(entropy))
state = c()
np.testing.assert_allclose(state.numpy(), target_state)
target_c = Circuit(2)
target_c.add([gates.RY(0, 0.4321), gates.CNOT(0, 1)])
target_state = target_c().numpy()
c = Circuit(2, accelerators)
c.add(gates.RY(0, 0.4321))
c.add(gates.CallbackGate(entropy))
c.add(gates.CNOT(0, 1))
c.add(gates.CallbackGate(entropy))
state = c()
np.testing.assert_allclose(state.numpy(), target_state)
def target_entropy(t):
cos = np.cos(t / 2.0) ** 2
sin = np.sin(t / 2.0) ** 2
return - cos * np.log2(cos) - sin * np.log2(sin)
target = [0, target_entropy(0.1234), 0, target_entropy(0.4321)]
np.testing.assert_allclose(entropy[:].numpy(), target, atol=_atol)
def test_circuit_set_parameters_with_unitary(backend, trainable, accelerators):
"""Check updating parameters of circuit that contains ``Unitary`` gate."""
params = [0.1234, np.random.random((4, 4))]
c = Circuit(4, accelerators)
c.add(gates.RX(0, theta=0))
if trainable:
c.add(gates.Unitary(np.zeros((4, 4)), 1, 2, trainable=trainable))
trainable_params = list(params)
else:
c.add(gates.Unitary(params[1], 1, 2, trainable=trainable))
trainable_params = [params[0]]
# execute once
final_state = c()
target_c = Circuit(4)
target_c.add(gates.RX(0, theta=params[0]))
target_c.add(gates.Unitary(params[1], 1, 2))
c.set_parameters(trainable_params)
K.assert_allclose(c(), target_c())
# Attempt using a flat list / np.ndarray
new_params = np.random.random(17)
if trainable:
c.set_parameters(new_params)
else:
c.set_parameters(new_params[:1])
new_params[1:] = params[1].ravel()
target_c = Circuit(4)
target_c.add(gates.RX(0, theta=new_params[0]))
target_c.add(gates.Unitary(new_params[1:].reshape((4, 4)), 1, 2))
K.assert_allclose(c(), target_c())
def test_entropy_large_circuit(accelerators):
"""Check that entropy calculation works for variational like circuit."""
thetas = np.pi * np.random.random((3, 8))
target_entropy = callbacks.EntanglementEntropy([0, 2, 4, 5])
c1 = Circuit(8)
c1.add((gates.RY(i, thetas[0, i]) for i in range(8)))
c1.add((gates.CZ(i, i + 1) for i in range(0, 7, 2)))
state1 = c1()
e1 = target_entropy(state1)
c2 = Circuit(8)
c2.add((gates.RY(i, thetas[1, i]) for i in range(8)))
c2.add((gates.CZ(i, i + 1) for i in range(1, 7, 2)))
c2.add(gates.CZ(0, 7))
state2 = (c1 + c2)()
e2 = target_entropy(state2)
c3 = Circuit(8)
c3.add((gates.RY(i, thetas[2, i]) for i in range(8)))
c3.add((gates.CZ(i, i + 1) for i in range(0, 7, 2)))
state3 = (c1 + c2 + c3)()
e3 = target_entropy(state3)
entropy = callbacks.EntanglementEntropy([0, 2, 4, 5])
c = Circuit(8, accelerators)
c.add(gates.CallbackGate(entropy))
c.add((gates.RY(i, thetas[0, i]) for i in range(8)))
c.add((gates.CZ(i, i + 1) for i in range(0, 7, 2)))
c.add(gates.CallbackGate(entropy))
c.add((gates.RY(i, thetas[1, i]) for i in range(8)))
c.add((gates.CZ(i, i + 1) for i in range(1, 7, 2)))
c.add(gates.CZ(0, 7))
c.add(gates.CallbackGate(entropy))
c.add((gates.RY(i, thetas[2, i]) for i in range(8)))
c.add((gates.CZ(i, i + 1) for i in range(0, 7, 2)))
c.add(gates.CallbackGate(entropy))
state = c()
np.testing.assert_allclose(state3.numpy(), state.numpy())
np.testing.assert_allclose(entropy[:].numpy(), [0, e1, e2, e3])
def test_set_parameters_with_double_variationallayer(backend, nqubits,
trainable, accelerators):
"""Check updating parameters of variational layer."""
theta = np.random.random((3, nqubits))
c = Circuit(nqubits, accelerators)
pairs = [(i, i + 1) for i in range(0, nqubits - 1, 2)]
c.add(
gates.VariationalLayer(range(nqubits),
pairs,
gates.RY,
gates.CZ,
theta[0],
theta[1],
trainable=trainable))
c.add((gates.RX(i, theta[2, i]) for i in range(nqubits)))
target_c = Circuit(nqubits)
target_c.add((gates.RY(i, theta[0, i]) for i in range(nqubits)))
target_c.add((gates.CZ(i, i + 1) for i in range(0, nqubits - 1, 2)))
target_c.add((gates.RY(i, theta[1, i]) for i in range(nqubits)))
target_c.add((gates.RX(i, theta[2, i]) for i in range(nqubits)))
K.assert_allclose(c(), target_c())
new_theta = np.random.random(3 * nqubits)
if trainable:
c.set_parameters(np.copy(new_theta))
else:
c.set_parameters(np.copy(new_theta[2 * nqubits:]))
new_theta[:2 * nqubits] = theta[:2].ravel()
target_c.set_parameters(np.copy(new_theta))
K.assert_allclose(c(), target_c())
def test_entropy_in_circuit(accelerators, dm):
"""Check that entropy calculation works in circuit."""
entropy = callbacks.EntanglementEntropy([0], compute_spectrum=True)
c = Circuit(2, accelerators=accelerators, density_matrix=dm)
c.add(gates.CallbackGate(entropy))
c.add(gates.H(0))
c.add(gates.CallbackGate(entropy))
c.add(gates.CNOT(0, 1))
c.add(gates.CallbackGate(entropy))
state = c()
target = [0, 0, 1.0]
np.testing.assert_allclose(entropy[:].numpy(), target, atol=_atol)
target_spectrum = [0, 0, np.log(2), np.log(2)]
entropy_spectrum = np.concatenate(entropy.spectrum).ravel().tolist()
np.testing.assert_allclose(entropy_spectrum, target_spectrum, atol=_atol)
def test_circuit_set_parameters_ungates(backend, trainable, accelerators):
"""Check updating parameters of circuit with list."""
params = [0.1, 0.2, 0.3, (0.4, 0.5), (0.6, 0.7, 0.8)]
if trainable:
trainable_params = list(params)
else:
trainable_params = [0.1, 0.3, (0.4, 0.5)]
c = Circuit(3, accelerators)
c.add(gates.RX(0, theta=0))
if trainable:
c.add(gates.CRY(0, 1, theta=0, trainable=trainable))
else:
c.add(gates.CRY(0, 1, theta=params[1], trainable=trainable))
c.add(gates.CZ(1, 2))
c.add(gates.U1(2, theta=0))
c.add(gates.CU2(0, 2, phi=0, lam=0))
if trainable:
c.add(gates.U3(1, theta=0, phi=0, lam=0, trainable=trainable))
else:
c.add(gates.U3(1, *params[4], trainable=trainable))
# execute once
final_state = c()
target_c = Circuit(3)
target_c.add(gates.RX(0, theta=params[0]))
target_c.add(gates.CRY(0, 1, theta=params[1]))
target_c.add(gates.CZ(1, 2))
target_c.add(gates.U1(2, theta=params[2]))
target_c.add(gates.CU2(0, 2, *params[3]))
target_c.add(gates.U3(1, *params[4]))
c.set_parameters(trainable_params)
K.assert_allclose(c(), target_c())
# Attempt using a flat list
npparams = np.random.random(8)
if trainable:
trainable_params = np.copy(npparams)
else:
npparams[1] = params[1]
npparams[5:] = params[4]
trainable_params = np.delete(npparams, [1, 5, 6, 7])
target_c = Circuit(3)
target_c.add(gates.RX(0, theta=npparams[0]))
target_c.add(gates.CRY(0, 1, theta=npparams[1]))
target_c.add(gates.CZ(1, 2))
target_c.add(gates.U1(2, theta=npparams[2]))
target_c.add(gates.CU2(0, 2, *npparams[3:5]))
target_c.add(gates.U3(1, *npparams[5:]))
c.set_parameters(trainable_params)
K.assert_allclose(c(), target_c())
def test_repeated_execute_with_noise(backend):
thetas = np.random.random(4)
c = Circuit(4)
c.add((gates.RY(i, t) for i, t in enumerate(thetas)))
noisy_c = c.with_noise((0.2, 0.0, 0.1))
np.random.seed(1234)
final_state = noisy_c(nshots=20)
np.random.seed(1234)
target_state = []
for _ in range(20):
noiseless_c = Circuit(4)
for i, t in enumerate(thetas):
noiseless_c.add(gates.RY(i, theta=t))
if np.random.random() < 0.2:
noiseless_c.add(gates.X(i))
if np.random.random() < 0.1:
noiseless_c.add(gates.Z(i))
target_state.append(noiseless_c())
target_state = np.stack(target_state)
K.assert_allclose(final_state, target_state)
