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)