import sys
sys.path.append('../..')
from methods import test_locally, run_main_loop_with_chsh_test
from qiskit import ClassicalRegister, QuantumRegister, QuantumCircuit
# Create a Quantum Register called "qr" with 2 qubits.
qr = QuantumRegister(2)
# Create a Classical Register called "cr" with 2 bits.
cr = ClassicalRegister(2)
# Create a Quantum Circuit called involving "qr" and "cr"
qc = QuantumCircuit(qr, cr, name='Hello-Quantum')
# Add a H gate on qubit 0, putting this qubit in superposition.
qc.h(qr[0])
# Add a CX (CNOT) gate on control qubit 0 and target qubit 1, putting
# the qubits in a Bell state.
qc.cx(qr[0], qr[1])
# Add X Pauli gat, to get different Bell state
qc.x(qr[1])
# Barrier added due to qasm parsing issue
# https://github.com/QISKit/qiskit-sdk-py/issues/309
qc.barrier(qr)
# Add a Measure gate to see the state.
qc.measure(qr, cr)
print('Circuit prepared for execution.')
#run_main_loop_with_chsh_test(qc)
test_locally([qc])
qc.h(qr[T])
qc.x(qr[C0])
qc.x(qr[C1])
qc.x(qr[C2])
qc.x(qr[T])
qc.h(qr[C0])
qc.h(qr[C1])
qc.h(qr[C2])
qc.h(qr[T])
states = ['{0:04b}'.format(x) for x in range(2**4)]
circuits = []
print(states)
for state in states:
initialization(state)
for i in range(algorithm_repetition_times):
oracle(state)
diffusion()
qc.measure(qr, cr)
circuits.append(qc)
test_locally(circuits, True)
# run_main_loop_with_chsh_test(circuits)
return rotated_states
def name_circuits(circuits: list):
for step in range(len(circuits)):
circuits[step].name = 'Mermin_' + str(2 * step) + 'pi/' + str(
len(circuits)) + '_B'
def get_mermin_circuits(steps=8):
mermin_circuit = create_ghz_state()
mermin_circuit.name = 'Mermin_B'
rotated_states = apply_symmetric_rz_rotations(mermin_circuit, steps)
name_circuits(rotated_states)
mermin_circuits = add_measurements_in_selected_bases(rotated_states)
return mermin_circuits
def get_mermin_test_circuits():
mermin_test_base_circuits = create_ghz_state()
mermin_test_base_circuits.name = "Mermin-test"
mermin_test_circuits = add_measurements_in_selected_bases(
[mermin_test_base_circuits])
return mermin_test_circuits
# run_main_loop_with_chsh_test(get_mermin_circuits())
# test_locally(get_mermin_circuits(), use_mapping=True, save_to_file=True, number_of_simulations=1)
# draw_circuit(get_mermin_circuits()[0])
test_locally(get_mermin_circuits())
qr3 = QuantumRegister(3)
cr3 = ClassicalRegister(3)
# bases_n3 = ['XXX', 'YYX', 'YXY', 'XYY', 'ZZX', 'ZXZ', 'XZZ']
bases_n3 = ['XXX', 'YYX', 'YXY', 'XYY']
c3 = QuantumCircuit(qr3, cr3)
c3.name = "SC_000"
c4 = QuantumCircuit(qr3, cr3)
c4.x(qr3[0])
c4.x(qr3[1])
c4.x(qr3[2])
c4.barrier()
c4.name = "SC_111_B"
circuits_n3 = [c3, c4]
sc_n3_circuits = []
for c in circuits_n3:
for b in bases_n3:
sc_n3_circuits.append(add_measure_in_base(c.copy(), b))
return sc_n3_circuits
# test_locally(SC_Circuits, use_mapping=True, save_to_file=True, number_of_simulations=100)
# test_locally_with_noise(SC_Circuits)
test_locally(get_sc_n3_circuits())
import sys
sys.path.append('../..')
from methods import test_locally, create_circuit_from_qasm, run_main_loop_with_chsh_test
available_file_names = [
'Grover_2_00_1.qasm', 'Grover_2_01_1.qasm', 'Grover_2_10_1.qasm',
'Grover_2_11_1.qasm'
]
selected_file_index = 0
circuits = []
for file_name in available_file_names:
qc = create_circuit_from_qasm(file_name)
qc.name = file_name.split('.')[0]
circuits.append(qc)
#run_main_loop_with_chsh_test(circuits)
test_locally(circuits)
from methods import test_locally
def get_bell_circuits(circuits_copies_number: int = 50):
qr = QuantumRegister(5)
cr = ClassicalRegister(5)
circuits = []
# Circuits preparation
for i in range(0, circuits_copies_number):
qc = QuantumCircuit(qr, cr)
qc.h(qr[2])
qc.cx(qr[2], qr[0])
qc.cx(qr[2], qr[4])
qc.h(qr[2])
qc.ry(np.pi / 4, qr[0])
qc.measure(qr, cr)
circuits.append(qc)
circuits[i].name = "Bell_" + str(i)
return circuits
print("Bell experiment start")
test_locally(get_bell_circuits())
print("Bell experiment finished")
import os
import sys
current_dir = os.path.dirname(os.path.realpath(__file__))
parent_dir = os.path.dirname(current_dir)
sys.path.append(parent_dir)
from CHSH.CHSH_XY import get_symmetric_chsh_circuits, get_symmetric_chsh_test_circuits
from Mermin.Mermin import get_mermin_circuits, get_mermin_test_circuits
from SanityCheck.SanityCheck import get_sc_n2_circuits, get_sc_n3_circuits, get_n2_calibration_circuits, \
get_n3_calibration_circuits
from methods import test_locally
chsh_circuits = get_sc_n2_circuits() + get_symmetric_chsh_circuits(
8) + get_symmetric_chsh_test_circuits() + get_n2_calibration_circuits()
mermin_circuits = get_sc_n3_circuits() + get_mermin_circuits(
8) + get_mermin_test_circuits() + get_n3_calibration_circuits()
# no_signaling_circuits = [chsh_circuits, mermin_circuits]
no_signaling_circuits = mermin_circuits
# print(f'CHSH Experiment Circuits Length: {len(chsh_circuits)}')
print(f'Mermin Experiment Circuits Length: {len(mermin_circuits)}')
print(f'No_signaling_experiments num: {len(no_signaling_circuits)}')
# run_main_loop(no_signaling_circuits)
# run_main_loop_with_chsh_test(circuits)
test_locally(no_signaling_circuits, True, False, 1)
circuit = qiskit.QuantumCircuit(qr, cr)
circuit.measure(qr[i], cr[i])
return circuit
def get_teleportation_circuits():
# A circuit to teleport state from qubit 0 to qubit 2.
teleport = qiskit.QuantumCircuit(qr, cr)
# Prepare bell state on qubits 1 and 2.
teleport.h(qr[1])
teleport.cx(qr[1], qr[2])
teleport.measure(qr[0], cr[0])
teleport.measure(qr[1], cr[1])
# Prepare circuits
circuits = []
for theta in np.linspace(0, np.pi, 10):
qc_test = prepare_state(theta) + measure(0) + measure(1) + measure(2)
circuits.append(qc_test)
qc_teleport = prepare_state(theta) + teleport + measure(2)
circuits.append(qc_teleport)
return circuits
# Execute
test_locally(get_teleportation_circuits())
