def test_circuit_init():
circuit = qcs.circuit_init(1)
with (pytest.raises(ValueError)):
circuit_to_much = qcs.circuit_init(21)
with (pytest.raises(ValueError)):
circuit_negative = qcs.circuit_init(-1)
with (pytest.raises(ValueError)):
circuit_zero = qcs.circuit_init(0)
assert len(circuit._qbits) == 1
def test_rxyz_gate_qiskit_comparison():
circuit = qcs.circuit_init(3)
circuit.h(0)
circuit.h(1)
circuit.h(2)
circuit.rx(1, -np.pi / 4)
circuit.rx(2, np.pi / 16)
circuit.ry(0, -np.pi / 3)
circuit.ry(1, np.pi / 4)
circuit.rz(2, -np.pi / 12)
circuit.rz(0, np.pi / 6)
result = circuit.execute()
sv = result.get_state_vector()
S_simulator = Aer.backends(name='statevector_simulator')[0]
q = QuantumRegister(3)
qubit = QuantumCircuit(q)
qubit.h(q[0])
qubit.h(q[1])
qubit.h(q[2])
qubit.rx(-np.pi / 4, q[1])
qubit.rx(np.pi / 16, q[2])
qubit.ry(-np.pi / 3, q[0])
qubit.ry(np.pi / 4, q[1])
qubit.rz(-np.pi / 12, q[2])
qubit.rz(np.pi / 6, q[0])
job = execute(qubit, S_simulator)
result_qkit = job.result()
sv_qkit = result_qkit.get_statevector()
assert np.testing.assert_allclose(sv, sv_qkit, atol=1e-8,
rtol=1e-8) == None
def test_qft_vs_manual_qiskit_qft_comparison():
circuit = qcs.circuit_init(3)
circuit.i(0)
circuit.i(1)
circuit.x(2)
circuit.qft(0, 2)
result = circuit.execute()
sv = result.get_state_vector()
S_simulator = Aer.backends(name='statevector_simulator')[0]
q = QuantumRegister(3)
qubit = QuantumCircuit(q)
qubit.iden(q[0])
qubit.iden(q[1])
qubit.x(q[2])
#QFT
qubit.h(q[0])
qubit.cu1(np.pi / 2, q[1], q[0])
qubit.cu1(np.pi / 4, q[2], q[0])
qubit.h(q[1])
qubit.cu1(np.pi / 4, q[2], q[1])
qubit.h(q[2])
job = execute(qubit, S_simulator)
result_qkit = job.result()
sv_qkit = result_qkit.get_statevector()
assert np.testing.assert_allclose(sv, sv_qkit, atol=1e-8,
rtol=1e-8) == None
def test_single_gates_simpletest():
circuit = qcs.circuit_init(1)
circuit.x(0)
circuit.y(0)
circuit.z(0)
circuit.h(0)
circuit.t(0)
circuit.i(0)
result = circuit.execute()
def test_controll_gates_simpletest():
circuit = qcs.circuit_init(2)
circuit.ch(0, 1)
circuit.cx(0, 1)
circuit.cy(0, 1)
circuit.cz(0, 1)
circuit.crot(0, 1, np.pi / 4)
circuit.ci(0, 1)
circuit.swap(0, 1)
result = circuit.execute()
def test_n_qubit_probability():
probs = {"00": 0.0, "10": 0.4999, "01": 0.0, "11": 0.4999}
circuit = qcs.circuit_init(4)
circuit.h(0)
circuit.h(1)
circuit.x(2)
circuit.x(3)
result = circuit.execute()
slice_probs = result.get_n_qubit_probability(1, 3)
for key in probs:
assert slice_probs[key] == pytest.approx(probs[key], 1e-3)
def test_measure_all():
circuit = qcs.circuit_init(4)
circuit.h(2)
result = circuit.execute()
strs = result.measure_all()
assert '0100' in strs
assert '0000' in strs
assert '0010' not in strs
assert '0011' not in strs
assert '1010' not in strs
assert '1111' not in strs
def test_disabled_autocalc():
circuit = qcs.circuit_init(2)
circuit.h(0)
circuit.ch(0, 1)
with (pytest.raises(TypeError)):
result = circuit.execute(probs_autocalc="no")
result = circuit.execute(probs_autocalc=False)
with (pytest.raises(ValueError)):
result.get_all_probabilities()
with (pytest.raises(ValueError)):
result.get_n_qubit_probability(1, 3)
with (pytest.raises(ValueError)):
result.get_bitstr_probability()
def test_empty_circuit_qiskit_comparison():
circuit = qcs.circuit_init(10)
result = circuit.execute()
sv = result.get_state_vector()
S_simulator = Aer.backends(name='statevector_simulator')[0]
q = QuantumRegister(10)
qubit = QuantumCircuit(q)
job = execute(qubit, S_simulator)
result_qkit = job.result()
sv_qkit = result_qkit.get_statevector()
assert np.testing.assert_allclose(sv, sv_qkit, atol=1e-8,
rtol=1e-8) == None
def test_errors():
circuit = qcs.circuit_init(2)
circuit.h(0)
circuit.ch(0, 1)
result = circuit.execute()
with (pytest.raises(TypeError)):
result.get_single_qubit_probability("0")
result.get_bitstr_probability(1)
with (pytest.raises(IndexError)):
result.get_single_qubit_probability(10)
result.get_n_qubit_probability(0, -1)
result.get_n_qubit_probability(0, 10)
with (pytest.raises(ValueError)):
result.get_bitstr_probability("1000110")
result.get_bitstr_probability("123")
def test_qft_reverse_qft():
circuit = qcs.circuit_init(4)
circuit.h(0)
circuit.x(1)
circuit.h(2)
circuit.x(3)
result = circuit.execute()
sv_init = result.get_state_vector()
circuit.qft(0, 3)
circuit.qft_rev(0, 3)
result = circuit.execute()
sv = result.get_state_vector()
assert np.testing.assert_allclose(sv, sv_init, atol=1e-8,
rtol=1e-8) == None
def test_simple_qaoa_vs_manual_qiskit_qaoa_comparison():
n = 5
p = 2
V = np.arange(0, n, 1)
E = [(0, 1, 1.0), (0, 2, 1.0), (1, 2, 1.0), (3, 2, 1.0), (3, 4, 1.0),
(4, 2, 1.0)]
graph = nx.Graph()
graph.add_nodes_from(V)
graph.add_weighted_edges_from(E)
betas = np.random.uniform(-np.pi, np.pi, size=p)
gammas = np.random.uniform(-np.pi, np.pi, size=p)
circuit = qcs.circuit_init(n)
for i in range(n):
circuit.h(i)
for beta, gamma in zip(betas, gammas):
for i, j in graph.edges:
circuit.cx(i, j)
circuit.rot(j, gamma)
circuit.cx(i, j)
for i in range(n):
circuit.rx(i, 2 * beta)
result = circuit.execute()
sv = result.get_state_vector()
S_simulator = Aer.backends(name='statevector_simulator')[0]
q = QuantumRegister(n)
qubit = QuantumCircuit(q)
for i in range(n):
qubit.h(q[i])
for beta, gamma in zip(betas, gammas):
for i, j in graph.edges:
qubit.cx(q[int(i)], q[int(j)])
qubit.u1(gamma, q[int(j)])
qubit.cx(q[int(i)], q[int(j)])
for i in range(n):
qubit.rx(beta * 2, q[i])
job = execute(qubit, S_simulator)
result_qkit = job.result()
sv_qkit = result_qkit.get_statevector()
assert np.testing.assert_allclose(sv, sv_qkit, atol=1e-8,
rtol=1e-8) == None
def test_gates_check_input():
circuit = qcs.circuit_init(2)
circuit.x(0)
circuit.x(-1)
circuit.cx(-2, -1)
circuit.cx(1, 0)
with (pytest.raises(IndexError)):
circuit.x(2)
with (pytest.raises(IndexError)):
circuit.x(-3)
with (pytest.raises(IndexError)):
circuit.cx(1, -3)
with (pytest.raises(IndexError)):
circuit.cx(4, 0)
with (pytest.raises(ValueError)):
circuit.cx(0, 0)
with (pytest.raises(TypeError)):
circuit.x("0")
def test_circuit3_qiskit_comparison():
circuit = qcs.circuit_init(3)
circuit.y(0)
circuit.h(1)
circuit.x(2)
circuit.cx(0, 1)
circuit.h(0)
circuit.cz(1, 2)
circuit.cy(0, 2)
circuit.cy(0, 2)
circuit.cz(1, 2)
circuit.h(0)
circuit.cx(0, 1)
circuit.x(2)
circuit.h(1)
circuit.y(0)
result = circuit.execute()
sv = result.get_state_vector()
S_simulator = Aer.backends(name='statevector_simulator')[0]
q = QuantumRegister(3)
qubit = QuantumCircuit(q)
qubit.y(q[0])
qubit.h(q[1])
qubit.x(q[2])
qubit.cx(q[0], q[1])
qubit.h(q[0])
qubit.cz(q[1], q[2])
qubit.cy(q[0], q[2])
qubit.cy(q[0], q[2])
qubit.cz(q[1], q[2])
qubit.h(q[0])
qubit.cx(q[0], q[1])
qubit.x(q[2])
qubit.h(q[1])
qubit.y(q[0])
job = execute(qubit, S_simulator)
result_qkit = job.result()
sv_qkit = result_qkit.get_statevector()
assert np.testing.assert_allclose(sv, sv_qkit, atol=1e-8,
rtol=1e-8) == None
def test_random_circuit_generator_qiskit_comparison():
gates_c = ["circuit.i({})", \
"circuit.x({})", \
"circuit.y({})", \
"circuit.z({})", \
"circuit.h({})", \
"circuit.t({})", \
"circuit.cx({}, {})", \
"circuit.cy({}, {})", \
"circuit.cz({}, {})", \
"circuit.ch({}, {})", \
"circuit.swap({}, {})", \
#"circuit.rx({}, {})", \
#"circuit.ry({}, {})", \
#"circuit.rz({}, {})", \
"circuit.rot({}, {})", \
"circuit.crot({}, {}, {})"]
gates_qkit = ["qubit.iden(q_reg[{}])", \
"qubit.x(q_reg[{}])", \
"qubit.y(q_reg[{}])", \
"qubit.z(q_reg[{}])", \
"qubit.h(q_reg[{}])", \
"qubit.t(q_reg[{}])", \
"qubit.cx(q_reg[{}], q_reg[{}])", \
"qubit.cy(q_reg[{}], q_reg[{}])", \
"qubit.cz(q_reg[{}], q_reg[{}])", \
"qubit.ch(q_reg[{}], q_reg[{}])", \
"qubit.swap(q_reg[{}], q_reg[{}])", \
#"qubit.rx({}, q_reg[{}])", \
#"qubit.ry({}, q_reg[{}])", \
#"qubit.rz({}, q_reg[{}])", \
"qubit.u1({}, q_reg[{}])", \
"qubit.cu1({},q_reg[{}], q_reg[{}])"]
gate_type = [1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 4]
#gate_type = [1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 3, 3, 3, 3, 4]
func_len = len(gates_c)
S_simulator = Aer.backends(name='statevector_simulator')[0]
#errors = 0
# number of circuits generated
for _ in range(n_of_circuits_generated):
n_qbit = random.randrange(2, 21)
circuit = qcs.circuit_init(n_qbit)
q_reg = QuantumRegister(n_qbit)
qubit = QuantumCircuit(q_reg)
# number of gates on circuit
for _ in range(n_of_gates_per_circuit):
q = random.randrange(0, n_qbit - 1)
gate_choice = random.randrange(0, func_len)
my_gate = gates_c[gate_choice]
qiskit_gate = gates_qkit[gate_choice]
gtype = gate_type[gate_choice]
# single gate
if (gtype == 1):
exec(my_gate.format(q))
exec(qiskit_gate.format(q))
# controlled gate
elif (gtype == 2):
side = random.choice(["up", "down"])
if (q == n_qbit - 1):
q = q - 1
if side == "up":
exec(my_gate.format(q, q + 1))
exec(qiskit_gate.format(q, q + 1))
if side == "down":
exec(my_gate.format(q + 1, q))
exec(qiskit_gate.format(q + 1, q))
# rotation gates
if (gtype == 3):
angle = random.uniform(-np.pi, np.pi)
exec(my_gate.format(q, angle))
exec(qiskit_gate.format(angle, q))
# controlled rotation gate
elif (gtype == 4):
angle = random.uniform(-np.pi, np.pi)
side = random.choice(["up", "down"])
if (q == n_qbit - 1):
q = q - 1
if side == "up":
exec(my_gate.format(q, q + 1, angle))
exec(qiskit_gate.format(angle, q, q + 1))
if side == "down":
exec(my_gate.format(q + 1, q, angle))
exec(qiskit_gate.format(angle, q + 1, q))
# getting and comparing results
result = circuit.execute(probs_autocalc=False)
sv = result.get_state_vector()
job = execute(qubit, S_simulator)
result_qkit = job.result()
sv_qkit = result_qkit.get_statevector()
assert np.testing.assert_allclose(sv, sv_qkit, atol=1e-8, rtol=1e-8) \
== None
import qcsimulator as qcs
import numpy as np
import tensornetwork as tn
import pytest
from qiskit import QuantumRegister, QuantumCircuit, execute, Aer
# global circuit with known values for tests
prob_table_big_end = {"00": 0.4999, "10": 0.24999, "01": 0.0, "11": 0.24999}
prob_table_little_end = {"00": 0.4999, "01": 0.24999, "10": 0.0, "11": 0.24999}
circuit = qcs.circuit_init(2)
circuit.h(0)
circuit.ch(0, 1)
result = circuit.execute()
def test_disabled_autocalc():
circuit = qcs.circuit_init(2)
circuit.h(0)
circuit.ch(0, 1)
with (pytest.raises(TypeError)):
result = circuit.execute(probs_autocalc="no")
result = circuit.execute(probs_autocalc=False)
with (pytest.raises(ValueError)):
result.get_all_probabilities()
with (pytest.raises(ValueError)):
result.get_n_qubit_probability(1, 3)
with (pytest.raises(ValueError)):
result.get_bitstr_probability()
def test_errors():
