def test_decomposition(angle):
for basis_state in ([1, 0], [0, 1]):
correct_dummy_eng = DummyEngine(save_commands=True)
correct_eng = MainEngine(backend=Simulator(), engine_list=[correct_dummy_eng])
rule_set = DecompositionRuleSet(modules=[rx2rz])
test_dummy_eng = DummyEngine(save_commands=True)
test_eng = MainEngine(
backend=Simulator(),
engine_list=[
AutoReplacer(rule_set),
InstructionFilter(rx_decomp_gates),
test_dummy_eng,
],
)
correct_qb = correct_eng.allocate_qubit()
Rx(angle) | correct_qb
correct_eng.flush()
test_qb = test_eng.allocate_qubit()
Rx(angle) | test_qb
test_eng.flush()
assert correct_dummy_eng.received_commands[1].gate == Rx(angle)
assert test_dummy_eng.received_commands[1].gate != Rx(angle)
for fstate in ['0', '1']:
test = test_eng.backend.get_amplitude(fstate, test_qb)
correct = correct_eng.backend.get_amplitude(fstate, correct_qb)
assert correct == pytest.approx(test, rel=1e-12, abs=1e-12)
Measure | test_qb
Measure | correct_qb
def run():
# build compilation engine list
resource_counter = ResourceCounter()
rule_set = DecompositionRuleSet(
modules=[projectq.libs.math, projectq.setups.decompositions])
compilerengines = [
AutoReplacer(rule_set),
InstructionFilter(high_level_gates),
TagRemover(),
LocalOptimizer(3),
AutoReplacer(rule_set),
TagRemover(),
LocalOptimizer(3), resource_counter
]
# make the compiler and run the circuit on the simulator backend
#eng = MainEngine(Simulator(), compilerengines)
eng = MainEngine(resource_counter)
# print welcome message and ask the user for the number to factor
print(
"\n\t\033[37mprojectq\033[0m\n\t--------\n\tImplementation of Shor"
"\'s algorithm.",
end="")
N = int(input('\n\tNumber to factor: '))
print("\n\tFactoring N = {}: \033[0m".format(N), end="")
# choose a base at random:
a = N
while not gcd(a, N) == 1:
a = random.randint(2, N)
print("\na is " + str(a))
if not gcd(a, N) == 1:
print("\n\n\t\033[92mOoops, we were lucky: Chose non relative prime"
" by accident :)")
print("\tFactor: {}\033[0m".format(gcd(a, N)))
else:
# run the quantum subroutine
r = run_shor(eng, N, a, True)
print("\n\nr found : " + str(r))
# try to determine the factors
if r % 2 != 0:
r *= 2
apowrhalf = pow(a, r >> 1, N)
f1 = gcd(apowrhalf + 1, N)
f2 = gcd(apowrhalf - 1, N)
print("f1 = {}, f2 = {}".format(f1, f2))
if ((not f1 * f2 == N) and f1 * f2 > 1
and int(1. * N / (f1 * f2)) * f1 * f2 == N):
f1, f2 = f1 * f2, int(N / (f1 * f2))
if f1 * f2 == N and f1 > 1 and f2 > 1:
print(
"\n\n\t\033[92mFactors found :-) : {} * {} = {}\033[0m".format(
f1, f2, N))
else:
print("\n\n\t\033[91mBad luck: Found {} and {}\033[0m".format(
f1, f2))
return resource_counter # print resource usage
def eng():
return MainEngine(
backend=Simulator(),
engine_list=[
AutoReplacer(rule_set),
InstructionFilter(no_math_emulation)
],
)
def test_decomposition():
for basis_state_index in range(0, 16):
basis_state = [0] * 16
basis_state[basis_state_index] = 1.0
correct_dummy_eng = DummyEngine(save_commands=True)
correct_eng = MainEngine(backend=Simulator(), engine_list=[correct_dummy_eng])
rule_set = DecompositionRuleSet(modules=[cnu2toffoliandcu])
test_dummy_eng = DummyEngine(save_commands=True)
test_eng = MainEngine(
backend=Simulator(),
engine_list=[
AutoReplacer(rule_set),
InstructionFilter(_decomp_gates),
test_dummy_eng,
],
)
test_sim = test_eng.backend
correct_sim = correct_eng.backend
correct_qb = correct_eng.allocate_qubit()
correct_ctrl_qureg = correct_eng.allocate_qureg(3)
correct_eng.flush()
test_qb = test_eng.allocate_qubit()
test_ctrl_qureg = test_eng.allocate_qureg(3)
test_eng.flush()
correct_sim.set_wavefunction(basis_state, correct_qb + correct_ctrl_qureg)
test_sim.set_wavefunction(basis_state, test_qb + test_ctrl_qureg)
with Control(test_eng, test_ctrl_qureg[:2]):
Rx(0.4) | test_qb
with Control(test_eng, test_ctrl_qureg):
Ry(0.6) | test_qb
with Control(test_eng, test_ctrl_qureg):
X | test_qb
with Control(correct_eng, correct_ctrl_qureg[:2]):
Rx(0.4) | correct_qb
with Control(correct_eng, correct_ctrl_qureg):
Ry(0.6) | correct_qb
with Control(correct_eng, correct_ctrl_qureg):
X | correct_qb
test_eng.flush()
correct_eng.flush()
assert len(correct_dummy_eng.received_commands) == 9
assert len(test_dummy_eng.received_commands) == 25
for fstate in range(16):
binary_state = format(fstate, '04b')
test = test_sim.get_amplitude(binary_state, test_qb + test_ctrl_qureg)
correct = correct_sim.get_amplitude(binary_state, correct_qb + correct_ctrl_qureg)
assert correct == pytest.approx(test, rel=1e-12, abs=1e-12)
All(Measure) | test_qb + test_ctrl_qureg
All(Measure) | correct_qb + correct_ctrl_qureg
test_eng.flush(deallocate_qubits=True)
correct_eng.flush(deallocate_qubits=True)
def test_wrong_number_of_angles():
rule_set = DecompositionRuleSet(modules=[ucr2cnot])
eng = MainEngine(
backend=DummyEngine(),
engine_list=[AutoReplacer(rule_set),
InstructionFilter(_decomp_gates)])
qb = eng.allocate_qubit()
with pytest.raises(ValueError):
UniformlyControlledRy([0.1, 0.2]) | ([], qb)
def get_main_engine(sim):
engine_list = [AutoReplacer(rule_set),
InstructionFilter(high_level_gates),
TagRemover(),
LocalOptimizer(3),
AutoReplacer(rule_set),
TagRemover(),
LocalOptimizer(3)]
return MainEngine(sim, engine_list)
def test_no_control_qubits():
rule_set = DecompositionRuleSet(modules=[ucr2cnot])
eng = MainEngine(
backend=DummyEngine(),
engine_list=[AutoReplacer(rule_set),
InstructionFilter(_decomp_gates)])
qb = eng.allocate_qubit()
with pytest.raises(TypeError):
UniformlyControlledRy([0.1]) | qb
def test_chooser_Ry_reducer_synthetic():
backend = DummyEngine(save_commands=True)
rule_set = DecompositionRuleSet(
modules=[projectq.libs.math, projectq.setups.decompositions])
engine_list = [
AutoReplacer(rule_set, chooser_Ry_reducer),
TagRemover(),
InstructionFilter(filter_gates),
]
eng = MainEngine(backend=backend, engine_list=engine_list)
control = eng.allocate_qubit()
target = eng.allocate_qubit()
CNOT | (control, target)
CNOT | (control, target)
eng.flush()
idx0 = len(backend.received_commands) - 2
idx1 = len(backend.received_commands)
CNOT | (control, target)
eng.flush()
assert isinstance(backend.received_commands[idx0].gate, Ry)
assert isinstance(backend.received_commands[idx1].gate, Ry)
assert (backend.received_commands[idx0].gate.get_inverse() ==
backend.received_commands[idx1].gate)
eng = MainEngine(backend=backend, engine_list=engine_list)
control = eng.allocate_qubit()
target = eng.allocate_qubit()
H | target
eng.flush()
idx0 = len(backend.received_commands) - 2
idx1 = len(backend.received_commands)
H | target
eng.flush()
assert isinstance(backend.received_commands[idx0].gate, Ry)
assert isinstance(backend.received_commands[idx1].gate, Ry)
assert (backend.received_commands[idx0].gate.get_inverse() ==
backend.received_commands[idx1].gate)
eng = MainEngine(backend=backend, engine_list=engine_list)
control = eng.allocate_qubit()
target = eng.allocate_qubit()
Rz(1.23456) | target
eng.flush()
idx0 = len(backend.received_commands) - 2
idx1 = len(backend.received_commands)
Rz(1.23456) | target
eng.flush()
assert isinstance(backend.received_commands[idx0].gate, Ry)
assert isinstance(backend.received_commands[idx1].gate, Ry)
assert (backend.received_commands[idx0].gate.get_inverse() ==
backend.received_commands[idx1].gate)
def test_decomposition_errors(gate_matrix):
test_gate = BasicGate()
test_gate.matrix = np.matrix(gate_matrix)
rule_set = DecompositionRuleSet(modules=[arb1q])
eng = MainEngine(backend=DummyEngine(),
engine_list=[AutoReplacer(rule_set),
InstructionFilter(z_y_decomp_gates)])
qb = eng.allocate_qubit()
with pytest.raises(Exception):
test_gate | qb
def test_entangle(): sim = Simulator() eng = MainEngine(sim, [AutoReplacer(), InstructionFilter(low_level_gates)]) qureg = eng.allocate_qureg(4) Entangle | qureg assert .5 == pytest.approx(abs(sim.cheat()[1][0])**2) assert .5 == pytest.approx(abs(sim.cheat()[1][-1])**2) Measure | qureg
def test_decomposition(angle):
"""
Test that this decomposition of Rz produces correct amplitudes
Note that this function tests each DecompositionRule in
rz2rx.all_defined_decomposition_rules
"""
decomposition_rule_list = rz2rx.all_defined_decomposition_rules
for rule in decomposition_rule_list:
for basis_state in ([1, 0], [0, 1]):
correct_dummy_eng = DummyEngine(save_commands=True)
correct_eng = MainEngine(backend=Simulator(),
engine_list=[correct_dummy_eng])
rule_set = DecompositionRuleSet(rules=[rule])
test_dummy_eng = DummyEngine(save_commands=True)
test_eng = MainEngine(backend=Simulator(),
engine_list=[
AutoReplacer(rule_set),
InstructionFilter(rz_decomp_gates),
test_dummy_eng
])
correct_qb = correct_eng.allocate_qubit()
Rz(angle) | correct_qb
correct_eng.flush()
test_qb = test_eng.allocate_qubit()
Rz(angle) | test_qb
test_eng.flush()
# Create empty vectors for the wave vectors for the correct and
# test qubits
correct_vector = np.zeros((2, 1), dtype=np.complex_)
test_vector = np.zeros((2, 1), dtype=np.complex_)
i = 0
for fstate in ['0', '1']:
test = test_eng.backend.get_amplitude(fstate, test_qb)
correct = correct_eng.backend.get_amplitude(fstate, correct_qb)
correct_vector[i] = correct
test_vector[i] = test
i += 1
# Necessary to transpose vector to use matrix dot product
test_vector = test_vector.transpose()
# Remember that transposed vector should come first in product
vector_dot_product = np.dot(test_vector, correct_vector)
assert np.absolute(vector_dot_product) == pytest.approx(1,
rel=1e-12,
abs=1e-12)
Measure | test_qb
Measure | correct_qb
def test_decomposition(gate_matrix):
# Create single qubit gate with gate_matrix
test_gate = MatrixGate()
test_gate.matrix = np.matrix(gate_matrix)
for basis_state in ([1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0,
1]):
correct_dummy_eng = DummyEngine(save_commands=True)
correct_eng = MainEngine(backend=Simulator(),
engine_list=[correct_dummy_eng])
rule_set = DecompositionRuleSet(modules=[carb1q])
test_dummy_eng = DummyEngine(save_commands=True)
test_eng = MainEngine(
backend=Simulator(),
engine_list=[
AutoReplacer(rule_set),
InstructionFilter(_decomp_gates),
test_dummy_eng,
],
)
test_sim = test_eng.backend
correct_sim = correct_eng.backend
correct_qb = correct_eng.allocate_qubit()
correct_ctrl_qb = correct_eng.allocate_qubit()
correct_eng.flush()
test_qb = test_eng.allocate_qubit()
test_ctrl_qb = test_eng.allocate_qubit()
test_eng.flush()
correct_sim.set_wavefunction(basis_state, correct_qb + correct_ctrl_qb)
test_sim.set_wavefunction(basis_state, test_qb + test_ctrl_qb)
with Control(test_eng, test_ctrl_qb):
test_gate | test_qb
with Control(correct_eng, correct_ctrl_qb):
test_gate | correct_qb
test_eng.flush()
correct_eng.flush()
assert correct_dummy_eng.received_commands[3].gate == test_gate
assert test_dummy_eng.received_commands[3].gate != test_gate
for fstate in ['00', '01', '10', '11']:
test = test_sim.get_amplitude(fstate, test_qb + test_ctrl_qb)
correct = correct_sim.get_amplitude(fstate,
correct_qb + correct_ctrl_qb)
assert correct == pytest.approx(test, rel=1e-12, abs=1e-12)
All(Measure) | test_qb + test_ctrl_qb
All(Measure) | correct_qb + correct_ctrl_qb
test_eng.flush(deallocate_qubits=True)
correct_eng.flush(deallocate_qubits=True)
def test_uniformly_controlled_ry(n, gate_classes):
random_angles = [
0.5, 0.8, 1.2, 2.5, 4.4, 2.32, 6.6, 15.12, 1, 2, 9.54, 2.1, 3.1415,
1.1, 0.01, 0.99
]
angles = random_angles[:2**n]
for basis_state_index in range(0, 2**(n + 1)):
basis_state = [0] * 2**(n + 1)
basis_state[basis_state_index] = 1.
correct_dummy_eng = DummyEngine(save_commands=True)
correct_eng = MainEngine(backend=Simulator(),
engine_list=[correct_dummy_eng])
rule_set = DecompositionRuleSet(modules=[ucr2cnot])
test_dummy_eng = DummyEngine(save_commands=True)
test_eng = MainEngine(backend=Simulator(),
engine_list=[
AutoReplacer(rule_set),
InstructionFilter(_decomp_gates),
test_dummy_eng
])
test_sim = test_eng.backend
correct_sim = correct_eng.backend
correct_qb = correct_eng.allocate_qubit()
correct_ctrl_qureg = correct_eng.allocate_qureg(n)
correct_eng.flush()
test_qb = test_eng.allocate_qubit()
test_ctrl_qureg = test_eng.allocate_qureg(n)
test_eng.flush()
correct_sim.set_wavefunction(basis_state,
correct_qb + correct_ctrl_qureg)
test_sim.set_wavefunction(basis_state, test_qb + test_ctrl_qureg)
gate_classes[1](angles) | (test_ctrl_qureg, test_qb)
slow_implementation(angles=angles,
control_qubits=correct_ctrl_qureg,
target_qubit=correct_qb,
eng=correct_eng,
gate_class=gate_classes[0])
test_eng.flush()
correct_eng.flush()
for fstate in range(2**(n + 1)):
binary_state = format(fstate, '0' + str(n + 1) + 'b')
test = test_sim.get_amplitude(binary_state,
test_qb + test_ctrl_qureg)
correct = correct_sim.get_amplitude(
binary_state, correct_qb + correct_ctrl_qureg)
assert correct == pytest.approx(test, rel=1e-10, abs=1e-10)
All(Measure) | test_qb + test_ctrl_qureg
All(Measure) | correct_qb + correct_ctrl_qureg
test_eng.flush(deallocate_qubits=True)
correct_eng.flush(deallocate_qubits=True)
def test_qubitop2singlequbit():
num_qubits = 4
random_initial_state = [
0.2 + 0.1 * x * cmath.exp(0.1j + 0.2j * x)
for x in range(2**(num_qubits + 1))
]
rule_set = DecompositionRuleSet(modules=[qubitop2onequbit])
test_eng = MainEngine(
backend=Simulator(),
engine_list=[AutoReplacer(rule_set),
InstructionFilter(_decomp_gates)],
)
test_qureg = test_eng.allocate_qureg(num_qubits)
test_ctrl_qb = test_eng.allocate_qubit()
test_eng.flush()
test_eng.backend.set_wavefunction(random_initial_state,
test_qureg + test_ctrl_qb)
correct_eng = MainEngine()
correct_qureg = correct_eng.allocate_qureg(num_qubits)
correct_ctrl_qb = correct_eng.allocate_qubit()
correct_eng.flush()
correct_eng.backend.set_wavefunction(random_initial_state,
correct_qureg + correct_ctrl_qb)
qubit_op_0 = QubitOperator("X0 Y1 Z3", -1.0j)
qubit_op_1 = QubitOperator("Z0 Y1 X3", cmath.exp(0.6j))
qubit_op_0 | test_qureg
with Control(test_eng, test_ctrl_qb):
qubit_op_1 | test_qureg
test_eng.flush()
correct_eng.backend.apply_qubit_operator(qubit_op_0, correct_qureg)
with Control(correct_eng, correct_ctrl_qb):
Ph(0.6) | correct_qureg[0]
Z | correct_qureg[0]
Y | correct_qureg[1]
X | correct_qureg[3]
correct_eng.flush()
for fstate in range(2**(num_qubits + 1)):
binary_state = format(fstate, '0' + str(num_qubits + 1) + 'b')
test = test_eng.backend.get_amplitude(binary_state,
test_qureg + test_ctrl_qb)
correct = correct_eng.backend.get_amplitude(
binary_state, correct_qureg + correct_ctrl_qb)
assert correct == pytest.approx(test, rel=1e-10, abs=1e-10)
All(Measure) | correct_qureg + correct_ctrl_qb
All(Measure) | test_qureg + test_ctrl_qb
correct_eng.flush()
test_eng.flush()
def test_entangle():
rule_set = DecompositionRuleSet(modules=[entangle])
sim = Simulator()
eng = MainEngine(sim,
[AutoReplacer(rule_set),
InstructionFilter(low_level_gates)])
qureg = eng.allocate_qureg(4)
Entangle | qureg
assert .5 == pytest.approx(abs(sim.cheat()[1][0])**2)
assert .5 == pytest.approx(abs(sim.cheat()[1][-1])**2)
All(Measure) | qureg
def test_decomposition():
"""Test that this decomposition of H produces correct amplitudes
Function tests each DecompositionRule in
h2rx.all_defined_decomposition_rules
"""
decomposition_rule_list = h2rx.all_defined_decomposition_rules
for rule in decomposition_rule_list:
for basis_state_index in range(2):
basis_state = [0] * 2
basis_state[basis_state_index] = 1.0
correct_dummy_eng = DummyEngine(save_commands=True)
correct_eng = MainEngine(backend=Simulator(),
engine_list=[correct_dummy_eng])
rule_set = DecompositionRuleSet(rules=[rule])
test_dummy_eng = DummyEngine(save_commands=True)
test_eng = MainEngine(
backend=Simulator(),
engine_list=[
AutoReplacer(rule_set),
InstructionFilter(h_decomp_gates),
test_dummy_eng,
],
)
correct_qb = correct_eng.allocate_qubit()
correct_eng.flush()
test_qb = test_eng.allocate_qubit()
test_eng.flush()
correct_eng.backend.set_wavefunction(basis_state, correct_qb)
test_eng.backend.set_wavefunction(basis_state, test_qb)
H | correct_qb
H | test_qb
correct_eng.flush()
test_eng.flush()
assert H in (cmd.gate
for cmd in correct_dummy_eng.received_commands)
assert H not in (cmd.gate
for cmd in test_dummy_eng.received_commands)
assert correct_eng.backend.cheat()[1] == pytest.approx(
test_eng.backend.cheat()[1], rel=1e-12, abs=1e-12)
Measure | test_qb
Measure | correct_qb
def test_decomposition():
""" Test that this decomposition of CNOT produces correct amplitudes
Function tests each DecompositionRule in
cnot2rxx.all_defined_decomposition_rules
"""
decomposition_rule_list = cnot2rxx.all_defined_decomposition_rules
for rule in decomposition_rule_list:
for basis_state_index in range(0, 4):
basis_state = [0] * 4
basis_state[basis_state_index] = 1.
correct_dummy_eng = DummyEngine(save_commands=True)
correct_eng = MainEngine(backend=Simulator(),
engine_list=[correct_dummy_eng])
rule_set = DecompositionRuleSet(rules=[rule])
test_dummy_eng = DummyEngine(save_commands=True)
test_eng = MainEngine(backend=Simulator(),
engine_list=[
AutoReplacer(rule_set),
InstructionFilter(_decomp_gates),
test_dummy_eng
])
test_sim = test_eng.backend
correct_sim = correct_eng.backend
correct_qb = correct_eng.allocate_qubit()
correct_ctrl_qb = correct_eng.allocate_qubit()
correct_eng.flush()
test_qb = test_eng.allocate_qubit()
test_ctrl_qb = test_eng.allocate_qubit()
test_eng.flush()
correct_sim.set_wavefunction(basis_state,
correct_qb + correct_ctrl_qb)
test_sim.set_wavefunction(basis_state, test_qb + test_ctrl_qb)
CNOT | (test_ctrl_qb, test_qb)
CNOT | (correct_ctrl_qb, correct_qb)
test_eng.flush()
correct_eng.flush()
assert len(correct_dummy_eng.received_commands) == 5
assert len(test_dummy_eng.received_commands) == 10
assert correct_eng.backend.cheat()[1] == pytest.approx(
test_eng.backend.cheat()[1], rel=1e-12, abs=1e-12)
All(Measure) | test_qb + test_ctrl_qb
All(Measure) | correct_qb + correct_ctrl_qb
test_eng.flush(deallocate_qubits=True)
correct_eng.flush(deallocate_qubits=True)
def test_decompose_commuting_terms():
saving_backend = DummyEngine(save_commands=True)
def my_filter(self, cmd):
if len(cmd.qubits[0]) <= 2 or isinstance(cmd.gate,
ClassicalInstructionGate):
return True
return False
rules = DecompositionRuleSet([te.rule_commuting_terms])
replacer = AutoReplacer(rules)
filter_eng = InstructionFilter(my_filter)
eng = MainEngine(backend=saving_backend,
engine_list=[replacer, filter_eng])
qureg = eng.allocate_qureg(5)
with Control(eng, qureg[3]):
op1 = QubitOperator("X1 Y2", 0.7)
op2 = QubitOperator("Y2 X4", -0.8)
op3 = QubitOperator((), 0.6)
TimeEvolution(1.5, op1 + op2 + op3) | qureg
cmd1 = saving_backend.received_commands[5]
cmd2 = saving_backend.received_commands[6]
cmd3 = saving_backend.received_commands[7]
found = [False, False, False]
scaled_op1 = QubitOperator("X0 Y1", 0.7)
scaled_op2 = QubitOperator("Y0 X1", -0.8)
for cmd in [cmd1, cmd2, cmd3]:
if (cmd.gate == Ph(-1.5 * 0.6) and cmd.qubits[0][0].id == qureg[1].id
and cmd.control_qubits[0].id
== qureg[3].id # 1st qubit of [1,2,4]
):
found[0] = True
elif (isinstance(cmd.gate, TimeEvolution)
and cmd.gate.hamiltonian.isclose(scaled_op1)
and cmd.gate.time == pytest.approx(1.5)
and cmd.qubits[0][0].id == qureg[1].id
and cmd.qubits[0][1].id == qureg[2].id
and cmd.control_qubits[0].id == qureg[3].id):
found[1] = True
elif (isinstance(cmd.gate, TimeEvolution)
and cmd.gate.hamiltonian.isclose(scaled_op2)
and cmd.gate.time == pytest.approx(1.5)
and cmd.qubits[0][0].id == qureg[2].id
and cmd.qubits[0][1].id == qureg[4].id
and cmd.control_qubits[0].id == qureg[3].id):
found[2] = True
assert all(found)
def test_comparator():
sim = Simulator()
eng = MainEngine(
sim, [AutoReplacer(rule_set),
InstructionFilter(no_math_emulation)])
qureg_a = eng.allocate_qureg(3)
qureg_b = eng.allocate_qureg(3)
compare_qubit = eng.allocate_qubit()
init(eng, qureg_a, 5)
init(eng, qureg_b, 3)
Comparator() | (qureg_a, qureg_b, compare_qubit)
assert 1. == pytest.approx(eng.backend.get_probability([1], compare_qubit))
def test_cnot_decomposition():
for basis_state_index in range(0, 4):
basis_state = [0] * 4
basis_state[basis_state_index] = 1.0
correct_dummy_eng = DummyEngine(save_commands=True)
correct_eng = MainEngine(backend=Simulator(),
engine_list=[correct_dummy_eng])
rule_set = DecompositionRuleSet(modules=[cnot2cz])
test_dummy_eng = DummyEngine(save_commands=True)
test_eng = MainEngine(
backend=Simulator(),
engine_list=[
AutoReplacer(rule_set),
InstructionFilter(_decomp_gates),
test_dummy_eng,
],
)
test_sim = test_eng.backend
correct_sim = correct_eng.backend
correct_qb = correct_eng.allocate_qubit()
correct_ctrl_qb = correct_eng.allocate_qubit()
correct_eng.flush()
test_qb = test_eng.allocate_qubit()
test_ctrl_qb = test_eng.allocate_qubit()
test_eng.flush()
correct_sim.set_wavefunction(basis_state, correct_qb + correct_ctrl_qb)
test_sim.set_wavefunction(basis_state, test_qb + test_ctrl_qb)
CNOT | (test_ctrl_qb, test_qb)
CNOT | (correct_ctrl_qb, correct_qb)
test_eng.flush()
correct_eng.flush()
assert len(correct_dummy_eng.received_commands) == 5
assert len(test_dummy_eng.received_commands) == 7
for fstate in range(4):
binary_state = format(fstate, '02b')
test = test_sim.get_amplitude(binary_state, test_qb + test_ctrl_qb)
correct = correct_sim.get_amplitude(binary_state,
correct_qb + correct_ctrl_qb)
assert correct == pytest.approx(test, rel=1e-12, abs=1e-12)
All(Measure) | test_qb + test_ctrl_qb
All(Measure) | correct_qb + correct_ctrl_qb
test_eng.flush(deallocate_qubits=True)
correct_eng.flush(deallocate_qubits=True)
def test_basic_engine_is_available():
eng = _basics.BasicEngine()
with pytest.raises(_basics.LastEngineException):
eng.is_last_engine = True
eng.is_available("FakeCommand")
def filter(self, cmd):
if cmd == "supported":
return True
return False
filter_eng = InstructionFilter(filter)
eng.next_engine = filter_eng
eng.is_last_engine = False
assert eng.is_available("supported")
assert not eng.is_available("something else")
def test_command_printer_is_available():
inline_cmd_printer = _printer.CommandPrinter()
cmd_printer = _printer.CommandPrinter()
def available_cmd(self, cmd):
return cmd.gate == H
filter = InstructionFilter(available_cmd)
eng = MainEngine(backend=cmd_printer, engine_list=[inline_cmd_printer, filter])
qubit = eng.allocate_qubit()
cmd0 = Command(eng, H, (qubit,))
cmd1 = Command(eng, T, (qubit,))
assert inline_cmd_printer.is_available(cmd0)
assert not inline_cmd_printer.is_available(cmd1)
assert cmd_printer.is_available(cmd0)
assert cmd_printer.is_available(cmd1)
def test_globalphase(): dummy = DummyEngine(save_commands=True) eng = MainEngine(dummy, [AutoReplacer(), InstructionFilter(low_level_gates_noglobalphase)]) qubit = eng.allocate_qubit() R(1.2) | qubit rz_count = 0 for cmd in dummy.received_commands: assert not isinstance(cmd.gate, R) if isinstance(cmd.gate, Rz): rz_count += 1 assert cmd.gate == Rz(1.2) assert rz_count == 1
def test_gate_decompositions(): sim = Simulator() eng = MainEngine(sim, []) qureg = run_circuit(eng) sim2 = Simulator() eng_lowlevel = MainEngine(sim2, [AutoReplacer(), InstructionFilter(low_level_gates)]) qureg2 = run_circuit(eng_lowlevel) for i in range(len(sim.cheat()[1])): assert sim.cheat()[1][i] == pytest.approx(sim2.cheat()[1][i]) Measure | qureg Measure | qureg2
def get_engine(api=None):
resource_counter = ResourceCounter()
rule_set = DecompositionRuleSet(
modules=[projectq.libs.math, projectq.setups.decompositions])
compilerengines = [
AutoReplacer(rule_set),
InstructionFilter(high_level_gates),
TagRemover(),
LocalOptimizer(3),
AutoReplacer(rule_set),
TagRemover(),
LocalOptimizer(3), resource_counter
]
# make the compiler and run the circuit on the simulator backend
backend = Simulator()
return MainEngine(backend, compilerengines), backend
def test_decomposition():
a = Debugger()
decomp = DecompositionRuleSet(
modules=[projectq.setups.decompositions.parity_measurement])
engine_list = [AutoReplacer(decomp), InstructionFilter(is_supported), a]
eng = projectq.MainEngine(engine_list=engine_list,
backend=CommandPrinter(accept_input=False))
q1 = eng.allocate_qubit()
q2 = eng.allocate_qubit()
ParityMeasurementGate("Z0 X1") | q1 + q2
print(a.commands)
#TODO
#assert(a.commands[-1].gate._bases[0][0] == 0)
#assert(a.commands[-1].gate._bases[0][1] == "Z")
assert (False)
def get_engine_list():
rule_set = DecompositionRuleSet(
modules=[projectq.libs.math, projectq.setups.decompositions])
return [
TagRemover(),
LocalOptimizer(5),
AutoReplacer(rule_set),
InstructionFilter(high_level_gates),
TagRemover(),
LocalOptimizer(5),
AutoReplacer(rule_set),
TagRemover(),
GridMapper(2, 8, grid_to_physical),
LocalOptimizer(5),
SwapAndCNOTFlipper(ibmqx5_connections),
LocalOptimizer(5)
]
def test_adder(): sim = Simulator() eng = MainEngine(sim, [AutoReplacer(), InstructionFilter(no_math_emulation)]) qureg = eng.allocate_qureg(4) init(eng, qureg, 4) AddConstant(3) | qureg assert 1. == pytest.approx(abs(sim.cheat()[1][7])) init(eng, qureg, 7) # reset init(eng, qureg, 2) AddConstant(15) | qureg # check for overflow -> should be 15+2 = 1 (mod 16) assert 1. == pytest.approx(abs(sim.cheat()[1][1])) Measure | qureg
def test_quantumsubtraction():
sim = Simulator()
eng = MainEngine(
sim, [AutoReplacer(rule_set),
InstructionFilter(no_math_emulation)])
qureg_a = eng.allocate_qureg(5)
qureg_b = eng.allocate_qureg(5)
init(eng, qureg_a, 5)
init(eng, qureg_b, 7)
SubtractQuantum() | (qureg_a, qureg_b)
assert 1. == pytest.approx(
eng.backend.get_probability([1, 0, 1, 0, 0], qureg_a))
assert 1. == pytest.approx(
eng.backend.get_probability([0, 1, 0, 0, 0], qureg_b))
def test_gate_decompositions():
sim = Simulator()
eng = MainEngine(sim, [])
rule_set = DecompositionRuleSet(
modules=[r2rzandph, crz2cxandrz, toffoli2cnotandtgate, ph2r])
qureg = run_circuit(eng)
sim2 = Simulator()
eng_lowlevel = MainEngine(sim2, [AutoReplacer(rule_set),
InstructionFilter(low_level_gates)])
qureg2 = run_circuit(eng_lowlevel)
for i in range(len(sim.cheat()[1])):
assert sim.cheat()[1][i] == pytest.approx(sim2.cheat()[1][i])
All(Measure) | qureg
All(Measure) | qureg2
