repo
stringclasses 900
values | file
stringclasses 754
values | content
stringlengths 4
215k
|
|---|---|---|
https://github.com/Keerthiraj-Nagaraj/IBM-quantum-challenge-2020
|
Keerthiraj-Nagaraj
|
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit import IBMQ, Aer, execute
from qiskit.visualization import plot_bloch_multivector
# If you run this code outside IBM Quantum Experience,
# run the following commands to store your API token locally.
# Please refer https://qiskit.org/documentation/install.html#access-ibm-quantum-systems
# IBMQ.save_account('MY_API_TOKEN')
# Loading your IBM Q account(s)
IBMQ.load_account()
# Let's do an X-gate on a |0> qubit
q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.x(q[0])
qc.draw(output='mpl')
# Let's see the result
backend = Aer.get_backend('statevector_simulator')
result = execute(qc, backend).result().get_statevector(qc, decimals=3)
plot_bloch_multivector(result)
# Let's do an H-gate on a |0> qubit
q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.h(q[0])
qc.draw(output='mpl')
# Let's see the result
backend = Aer.get_backend('statevector_simulator')
result = execute(qc, backend).result().get_statevector(qc, decimals=3)
plot_bloch_multivector(result)
# Let's do an Z-gate on |+>
q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.h(q[0])
qc.z(q[0])
qc.draw(output='mpl')
# Let's see the result
backend = Aer.get_backend('statevector_simulator')
result = execute(qc, backend).result().get_statevector(qc, decimals=3)
print(result)
plot_bloch_multivector(result)
# Let's do an CX-gate on |00>
q = QuantumRegister(2)
qc = QuantumCircuit(q)
qc.cx(q[0],q[1])
qc.draw(output='mpl')
backend = Aer.get_backend('statevector_simulator')
result = execute(qc, backend).result().get_statevector(qc, decimals=3)
print(result)
plot_bloch_multivector(result)
# Let's do an CZ-gate on |00>
q = QuantumRegister(2)
qc = QuantumCircuit(q)
qc.cz(q[0],q[1])
qc.draw(output='mpl')
# Let's make CZ-gate with CX-gate and H-gate
q = QuantumRegister(2)
qc = QuantumCircuit(q)
qc.h(q[1])
qc.cx(q[0],q[1])
qc.h(q[1])
qc.draw(output='mpl')
# Let's do an CCX-gate on |00>
q = QuantumRegister(3)
qc = QuantumCircuit(q)
qc.ccx(q[0],q[1],q[2])
qc.draw(output='mpl')
# Create a Quantum Circuit with 1 quantum register and 1 classical register
q = QuantumRegister(1)
c = ClassicalRegister(1)
qc = QuantumCircuit(q,c)
qc.x(q[0])
qc.measure(q[0], c[0]) # Map the quantum measurement to the classical bits
qc.draw(output='mpl')
q = QuantumRegister(3)
c = ClassicalRegister(1)
qc = QuantumCircuit(q,c)
qc.ccx(q[0], q[1], q[2])
qc.measure(q[2], c[0])
qc.draw(output='mpl')
q = QuantumRegister(3)
c = ClassicalRegister(1)
qc = QuantumCircuit(q,c)
qc.ccx(q[0], q[1], q[2])
qc.x(q[2])
qc.measure(q[2], c[0])
qc.draw(output='mpl')
q = QuantumRegister(3)
c = ClassicalRegister(1)
qc = QuantumCircuit(q,c)
qc.cx(q[1], q[2])
qc.cx(q[0], q[2])
qc.ccx(q[0], q[1], q[2])
qc.measure(q[2], c[0])
qc.draw(output='mpl')
q = QuantumRegister(3)
c = ClassicalRegister(1)
qc = QuantumCircuit(q,c)
qc.cx(q[1], q[2])
qc.cx(q[0], q[2])
qc.measure(q[2], c[0])
qc.draw(output='mpl')
q = QuantumRegister(3)
c = ClassicalRegister(1)
qc = QuantumCircuit(q,c)
qc.cx(q[1], q[2])
qc.cx(q[0], q[2])
qc.ccx(q[0], q[1], q[2])
qc.x(q[2])
qc.measure(q[2], c[0])
qc.draw(output='mpl')
#Define registers and a quantum circuit
q = QuantumRegister(4)
c = ClassicalRegister(2)
qc = QuantumCircuit(q,c)
#XOR
qc.cx(q[1], q[2])
qc.cx(q[0], q[2])
qc.barrier()
#AND
qc.ccx(q[0], q[1], q[3])
qc.barrier()
#Sum
qc.measure(q[2], c[0])
#Carry out
qc.measure(q[3], c[1])
backend = Aer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=1000)
result = job.result()
count =result.get_counts()
print(count)
qc.draw(output='mpl')
import numpy as np
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import BasicAer, execute
from qiskit.quantum_info import Pauli, state_fidelity, process_fidelity
q = QuantumRegister(4, 'q0')
c = ClassicalRegister(1, 'c0')
qc = QuantumCircuit(q, c)
qc.ccx(q[0], q[1], q[2])
qc.cx(q[3], q[1])
qc.h(q[3])
qc.ccx(q[3], q[2], q[1])
qc.measure(q[3],c[0])
qc.draw(output='mpl')
qc.count_ops()
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import Unroller
pass_ = Unroller(['u3', 'cx'])
pm = PassManager(pass_)
new_circuit = pm.run(qc)
new_circuit.draw(output='mpl')
new_circuit.count_ops()
q = QuantumRegister(3, 'q0')
c = ClassicalRegister(1, 'c0')
qc = QuantumCircuit(q, c)
qc.ccx(q[0], q[1], q[2])
qc.draw(output='mpl')
pass_ = Unroller(['u3', 'cx'])
pm = PassManager(pass_)
new_circuit = pm.run(qc)
new_circuit.draw(output='mpl')
new_circuit.count_ops()
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit import IBMQ, Aer, execute
##### build your quantum circuit here
q = QuantumRegister(8, 'q')
c = ClassicalRegister(2, 'c')
qc = QuantumCircuit(q,c)
qc.x(q[0]) #input 1
#qc.x(q[1]) #input 1
qc.x(q[2]) #input 1
qc.cx(q[2],q[3])
qc.cx(q[1], q[3]) # B XOR X
qc.cx(q[3], q[4])
qc.cx(q[0], q[4]) #4 will be my sum - B XOR X XOR A
qc.ccx(q[0], q[3], q[5]) # A AND (B XOR X)
qc.ccx(q[1], q[2], q[6]) # BX
qc.cx(q[6], q[7])
qc.cx(q[5], q[7])
qc.ccx(q[5], q[6], q[7]) # BX AND A(B XOR X)
qc.measure(q[4],c[0]) # SUM - B XOR X XOR A
qc.measure(q[7],c[1]) # Carry Out - BX OR A(B XOR X)
# execute the circuit by qasm_simulator
backend = Aer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=1000)
result = job.result()
count =result.get_counts()
print(count)
qc.draw(output='mpl')
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit import IBMQ, Aer, execute
##### build your quantum circuit here
q = QuantumRegister(6, 'q')
c = ClassicalRegister(2, 'c')
qc = QuantumCircuit(q,c)
qc.x(q[0]) #input 1
#qc.x(q[1]) #input 1
qc.x(q[2]) #input 1
qc.ccx(q[1], q[2],q[3]) # BX
qc.cx(q[1], q[2]) # B XOR X
qc.ccx(q[0], q[2], q[4]) # A(B XOR X)
qc.cx(q[0], q[2]) #2 will be my sum - B XOR X XOR A
qc.cx(q[4], q[5])
qc.cx(q[3], q[5])
qc.ccx(q[3], q[4], q[5]) # BX OR A(B XOR X)
qc.measure(q[2],c[0]) # SUM - B XOR X XOR A
qc.measure(q[5],c[1]) # Carry Out - BX OR A(B XOR X)
# execute the circuit by qasm_simulator
backend = Aer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=1000)
result = job.result()
count =result.get_counts()
print(count)
qc.draw(output='mpl')
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit import IBMQ, Aer, execute
##### build your quantum circuit here
q = QuantumRegister(6, 'q')
c = ClassicalRegister(2, 'c')
qc = QuantumCircuit(q,c)
qc.x(q[0]) #input 1
#qc.x(q[1]) #input 1
qc.x(q[2]) #input 1
qc.ccx(q[1], q[2],q[3]) # BX
qc.cx(q[1], q[2]) # B XOR X
qc.ccx(q[0], q[2], q[4]) # A(B XOR X)
qc.cx(q[0], q[2]) #2 will be my sum - B XOR X XOR A
qc.measure(q[2],c[0]) # SUM - B XOR X XOR A
qc.x(q[3])
qc.x(q[4])
qc.ccx(q[3], q[4], q[5])
qc.x(q[5])# BX OR A(B XOR X)
qc.measure(q[5],c[1]) # Carry Out - BX OR A(B XOR X)
# execute the circuit by qasm_simulator
backend = Aer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=1000)
result = job.result()
count =result.get_counts()
print(count)
qc.draw(output='mpl')
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit import IBMQ, Aer, execute
##### build your quantum circuit here
q = QuantumRegister(4, 'q')
c = ClassicalRegister(2, 'c')
qc = QuantumCircuit(q,c)
qc.x(q[0]) #input 1
#qc.x(q[1]) #input 1
qc.x(q[2]) #input 1
qc.ccx(q[1], q[2],q[3]) # BX
qc.cx(q[1], q[2]) # B XOR X
qc.ccx(q[0], q[2], q[3]) # A(B XOR X)
qc.cx(q[0], q[2]) #2 will be my sum - A XOR B XOR X
qc.measure(q[2],c[0]) # SUM - B XOR X XOR A
qc.measure(q[3],c[1]) # Carry Out - BX OR A(B XOR X)
# execute the circuit by qasm_simulator
backend = Aer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=1000)
result = job.result()
count =result.get_counts()
print(count)
qc.draw(output='mpl')
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import Unroller
pass_ = Unroller(['u3', 'cx'])
pm = PassManager(pass_)
new_circuit = pm.run(qc)
#new_circuit.draw(output='mpl')
new_circuit.count_ops()
# Check your answer using following code
from qc_grader import grade_ex1a
grade_ex1a(qc)
# Submit your answer. You can re-submit at any time.
from qc_grader import submit_ex1a
submit_ex1a(qc)
|
https://github.com/Keerthiraj-Nagaraj/IBM-quantum-challenge-2020
|
Keerthiraj-Nagaraj
|
from IPython.display import Image, display
Image("ryoko.png", width="70")
from IPython.display import Image, display
Image('unstructured_search.png', width="700")
Image("oracle.png", width="700")
Image("step0.png", width="700")
Image("step1.png", width="700")
Image("step2.png", width="700")
Image("grover_algorithm.png", width="700")
#initialization
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
# importing Qiskit
from qiskit import IBMQ, BasicAer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
# import basic plot tools
from qiskit.tools.visualization import plot_histogram
def phase_oracle(circuit, register):
circuit.cz(register[0], register[1])
qr = QuantumRegister(2)
oracleCircuit = QuantumCircuit(qr)
phase_oracle(oracleCircuit, qr)
oracleCircuit.draw(output="mpl")
def inversion_about_average(circuit, register):
"""Apply inversion about the average step of Grover's algorithm."""
circuit.h(register)
circuit.x(register)
circuit.h(register[1])
circuit.cx(register[0], register[1])
circuit.h(register[1])
circuit.x(register)
circuit.h(register)
qAverage = QuantumCircuit(qr)
inversion_about_average(qAverage, qr)
qAverage.draw(output='mpl')
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
groverCircuit = QuantumCircuit(qr,cr)
groverCircuit.h(qr)
phase_oracle(groverCircuit, qr)
inversion_about_average(groverCircuit, qr)
groverCircuit.measure(qr,cr)
groverCircuit.draw(output="mpl")
backend = BasicAer.get_backend('qasm_simulator')
shots = 1024
results = execute(groverCircuit, backend=backend, shots=shots).result()
answer = results.get_counts()
plot_histogram(answer)
# Load our saved IBMQ accounts and get the least busy backend device
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
backend_lb = least_busy(provider.backends(filters=lambda b: b.configuration().n_qubits >= 3 and
not b.configuration().simulator and b.status().operational==True))
print("Least busy backend: ", backend_lb)
# Run our circuit on the least busy backend. Monitor the execution of the job in the queue
from qiskit.tools.monitor import job_monitor
backend = backend_lb
shots = 1024
job_exp = execute(groverCircuit, backend=backend, shots=shots)
job_monitor(job_exp, interval = 2)
# get the results from the computation
results = job_exp.result()
answer = results.get_counts(groverCircuit)
plot_histogram(answer)
# Initialization
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
# Importing Qiskit
from qiskit import IBMQ, BasicAer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
# Import basic plot tools
from qiskit.tools.visualization import plot_histogram
def phase_oracle(circuit, register,oracle_register):
circuit.h(oracle_register)
circuit.ccx(register[0], register[1],oracle_register)
circuit.h(oracle_register)
qr = QuantumRegister(3)
oracleCircuit = QuantumCircuit(qr)
oracleCircuit.x(qr[2])
phase_oracle(oracleCircuit, qr,qr[2])
oracleCircuit.draw(output="mpl")
def inversion_about_average(circuit, register):
"""Apply inversion about the average step of Grover's algorithm."""
circuit.h(register)
circuit.x(register)
circuit.h(register[1])
circuit.cx(register[0], register[1])
circuit.h(register[1])
circuit.x(register)
circuit.h(register)
qAverage = QuantumCircuit(qr)
inversion_about_average(qAverage, qr[0:2])
qAverage.draw(output='mpl')
qr = QuantumRegister(3)
cr = ClassicalRegister(3)
groverCircuit = QuantumCircuit(qr,cr)
groverCircuit.h(qr[0:2])
groverCircuit.x(qr[2])
phase_oracle(groverCircuit, qr,qr[2])
inversion_about_average(groverCircuit, qr[0:2])
groverCircuit.measure(qr,cr)
groverCircuit.draw(output="mpl")
backend = BasicAer.get_backend('qasm_simulator')
shots = 1024
results = execute(groverCircuit, backend=backend, shots=shots).result()
answer = results.get_counts()
plot_histogram(answer)
backend = BasicAer.get_backend('qasm_simulator')
prob_of_ans = []
for x in range(12):
database = QuantumRegister(4)
oracle = QuantumRegister(1)
auxiliary = QuantumRegister(2)
cr = ClassicalRegister(4)
qc = QuantumCircuit(database, oracle, auxiliary, cr)
qc.h(database[:])
qc.x(oracle[0])
qc.h(oracle[0])
for j in range(x):
# oracle_4q
# search 7: 0111
qc.x(database[0])
qc.mct(database[:], oracle[0], auxiliary[:], mode='basic')
qc.x(database[0])
# diffusion_4q
qc.h(database[:])
qc.x(database[:])
qc.h(database[3])
qc.mct(database[0:3], database[3], auxiliary[:], mode='basic')
qc.h(database[3])
qc.x(database[:])
qc.h(database[:])
qc.h(oracle[0])
qc.x(oracle[0])
qc.measure(database,cr)
# Change the endian
qc = qc.reverse_bits()
job = execute(qc, backend=backend, shots=1000, seed_simulator=12345, backend_options={"fusion_enable":True})
result = job.result()
count = result.get_counts()
answer = count['0111']
prob_of_ans.append(answer)
import numpy as np
import matplotlib.pyplot as plt
iteration = [i for i in range(12)]
correct = prob_of_ans
plt.bar(iteration, correct)
plt.xlabel('# of iteration')
plt.ylabel('# of times the solution was obtained')
# Change ans of following code and check your answer.
# ans must be an interger.
from qc_grader import grade_ex1b
grade_ex1b(ans)
# Change ans of following code and submit it.
# ans must be interger.
from qc_grader import submit_ex1b
submit_ex1b(ans)
|
https://github.com/Keerthiraj-Nagaraj/IBM-quantum-challenge-2020
|
Keerthiraj-Nagaraj
|
from IPython.display import Image, display
Image("ryoko.png", width="70")
from IPython.display import Image, display
Image('unstructured_search.png', width="700")
Image("oracle.png", width="700")
Image("step0.png", width="700")
Image("step1.png", width="700")
Image("step2.png", width="700")
Image("grover_algorithm.png", width="700")
#initialization
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
# importing Qiskit
from qiskit import IBMQ, BasicAer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
# import basic plot tools
from qiskit.tools.visualization import plot_histogram
def phase_oracle(circuit, register):
circuit.cz(register[0], register[1])
qr = QuantumRegister(2)
oracleCircuit = QuantumCircuit(qr)
phase_oracle(oracleCircuit, qr)
oracleCircuit.draw(output="mpl")
def inversion_about_average(circuit, register):
"""Apply inversion about the average step of Grover's algorithm."""
circuit.h(register)
circuit.x(register)
circuit.h(register[1])
circuit.cx(register[0], register[1])
circuit.h(register[1])
circuit.x(register)
circuit.h(register)
qAverage = QuantumCircuit(qr)
inversion_about_average(qAverage, qr)
qAverage.draw(output='mpl')
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
groverCircuit = QuantumCircuit(qr,cr)
groverCircuit.h(qr)
phase_oracle(groverCircuit, qr)
inversion_about_average(groverCircuit, qr)
groverCircuit.measure(qr,cr)
groverCircuit.draw(output="mpl")
backend = BasicAer.get_backend('qasm_simulator')
shots = 1024
results = execute(groverCircuit, backend=backend, shots=shots).result()
answer = results.get_counts()
plot_histogram(answer)
# Load our saved IBMQ accounts and get the least busy backend device
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
backend_lb = least_busy(provider.backends(filters=lambda b: b.configuration().n_qubits >= 3 and
not b.configuration().simulator and b.status().operational==True))
print("Least busy backend: ", backend_lb)
# Run our circuit on the least busy backend. Monitor the execution of the job in the queue
from qiskit.tools.monitor import job_monitor
backend = backend_lb
shots = 1024
job_exp = execute(groverCircuit, backend=backend, shots=shots)
job_monitor(job_exp, interval = 2)
# get the results from the computation
results = job_exp.result()
answer = results.get_counts(groverCircuit)
plot_histogram(answer)
# Initialization
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
# Importing Qiskit
from qiskit import IBMQ, BasicAer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
# Import basic plot tools
from qiskit.tools.visualization import plot_histogram
def phase_oracle(circuit, register,oracle_register):
circuit.h(oracle_register)
circuit.ccx(register[0], register[1],oracle_register)
circuit.h(oracle_register)
qr = QuantumRegister(3)
oracleCircuit = QuantumCircuit(qr)
oracleCircuit.x(qr[2])
phase_oracle(oracleCircuit, qr,qr[2])
oracleCircuit.draw(output="mpl")
def inversion_about_average(circuit, register):
"""Apply inversion about the average step of Grover's algorithm."""
circuit.h(register)
circuit.x(register)
circuit.h(register[1])
circuit.cx(register[0], register[1])
circuit.h(register[1])
circuit.x(register)
circuit.h(register)
qAverage = QuantumCircuit(qr)
inversion_about_average(qAverage, qr[0:2])
qAverage.draw(output='mpl')
qr = QuantumRegister(3)
cr = ClassicalRegister(3)
groverCircuit = QuantumCircuit(qr,cr)
groverCircuit.h(qr[0:2])
groverCircuit.x(qr[2])
phase_oracle(groverCircuit, qr,qr[2])
inversion_about_average(groverCircuit, qr[0:2])
groverCircuit.measure(qr,cr)
groverCircuit.draw(output="mpl")
backend = BasicAer.get_backend('qasm_simulator')
shots = 1024
results = execute(groverCircuit, backend=backend, shots=shots).result()
answer = results.get_counts()
plot_histogram(answer)
database = QuantumRegister(4,'d')
oracle = QuantumRegister(1, 'o')
auxiliary = QuantumRegister(2, 'q')
cr = ClassicalRegister(4, 'c')
qc = QuantumCircuit(database, oracle, auxiliary, cr)
qc.h(database[:])
qc.x(oracle[0])
qc.h(oracle[0])
qc.x(database[0])
qc.mct(database[:], oracle[0], auxiliary[:], mode='basic')
qc.x(database[0])
qc.h(database[:])
qc.x(database[:])
qc.h(database[3])
qc.mct(database[0:3], database[3], auxiliary[:], mode='basic')
qc.h(database[3])
qc.x(database[:])
qc.h(database[:])
qc.h(oracle[0])
qc.x(oracle[0])
qc.measure(database,cr)
# Change the endian
qc = qc.reverse_bits()
qc.draw(output="mpl")
backend = BasicAer.get_backend('qasm_simulator')
prob_of_ans = []
count_list = []
for x in range(12):
database = QuantumRegister(4)
oracle = QuantumRegister(1)
auxiliary = QuantumRegister(2)
cr = ClassicalRegister(4)
qc = QuantumCircuit(database, oracle, auxiliary, cr)
qc.h(database[:])
qc.x(oracle[0])
qc.h(oracle[0])
for j in range(x):
# oracle_4q
# search 7: 0111
qc.x(database[0])
qc.mct(database[:], oracle[0], auxiliary[:], mode='basic')
qc.x(database[0])
# diffusion_4q
qc.h(database[:])
qc.x(database[:])
qc.h(database[3])
qc.mct(database[0:3], database[3], auxiliary[:], mode='basic')
qc.h(database[3])
qc.x(database[:])
qc.h(database[:])
qc.h(oracle[0])
qc.x(oracle[0])
qc.measure(database,cr)
# Change the endian
qc = qc.reverse_bits()
job = execute(qc, backend=backend, shots=1000, seed_simulator=12345, backend_options={"fusion_enable":True})
result = job.result()
count = result.get_counts()
count_list.append(count)
answer = count['0111']
prob_of_ans.append(answer)
#count_list[0]
for i in range(12):
print(len(count_list[i]))
count_list[9]
import numpy as np
import matplotlib.pyplot as plt
iteration = [i for i in range(12)]
correct = prob_of_ans
plt.bar(iteration, correct)
plt.xlabel('# of iteration')
plt.ylabel('# of times the solution was obtained')
num_database = 7
database = QuantumRegister(num_database, 'd')
oracle = QuantumRegister(1, 'o')
auxiliary = QuantumRegister(5, 'a')
cr = ClassicalRegister(num_database, 'c')
qc = QuantumCircuit(database, oracle, auxiliary, cr)
qc.h(database[:])
qc.x(oracle[0])
qc.h(oracle[0])
qc.x(database[0])
qc.mct(database[:], oracle[0], auxiliary[:], mode='basic')
qc.x(database[0])
qc.h(database[:])
qc.x(database[:])
qc.h(database[num_database-1])
qc.mct(database[0:num_database-1], database[num_database-1], auxiliary[:], mode='basic')
qc.h(database[num_database-1])
qc.x(database[:])
qc.h(database[:])
qc.h(oracle[0])
qc.x(oracle[0])
qc.measure(database,cr)
qc = qc.reverse_bits()
qc.draw(output="mpl")
#My solution
backend = BasicAer.get_backend('qasm_simulator')
prob_of_ans = []
count_list = []
total_iter = 16
num_database = 7
for x in range(total_iter):
database = QuantumRegister(num_database, 'd')
oracle = QuantumRegister(1, 'o')
auxiliary = QuantumRegister(5, 'a')
cr = ClassicalRegister(num_database, 'c')
qc = QuantumCircuit(database, oracle, auxiliary, cr)
qc.h(database[:])
qc.x(oracle[0])
qc.h(oracle[0])
for j in range(x):
# oracle_4q
# search 7: 0111
qc.x(database[0])
qc.mct(database[:], oracle[0], auxiliary[:], mode='basic')
qc.x(database[0])
# diffusion_4q
qc.h(database[:])
qc.x(database[:])
qc.h(database[num_database-1])
qc.mct(database[0:num_database-1], database[num_database-1], auxiliary[:], mode='basic')
qc.h(database[num_database-1])
qc.x(database[:])
qc.h(database[:])
qc.h(oracle[0])
qc.x(oracle[0])
qc.measure(database,cr)
# Change the endian
qc = qc.reverse_bits()
job = execute(qc, backend=backend, shots=1000, seed_simulator=12345, backend_options={"fusion_enable":True})
result = job.result()
count = result.get_counts()
count_list.append(count)
answer = count['0111111']
prob_of_ans.append(answer)
#count_list[0]
for i in range(total_iter):
print(len(count_list[i]))
count_list[8]
import numpy as np
import matplotlib.pyplot as plt
iteration = [i for i in range(total_iter)]
correct = prob_of_ans
plt.bar(iteration, correct)
plt.xlabel('# of iteration')
plt.ylabel('# of times the solution was obtained')
ans = 8
# Change ans of following code and check your answer.
# ans must be an interger.
from qc_grader import grade_ex1b
grade_ex1b(ans)
# Change ans of following code and submit it.
# ans must be interger.
from qc_grader import submit_ex1b
submit_ex1b(ans)
|
https://github.com/Keerthiraj-Nagaraj/IBM-quantum-challenge-2020
|
Keerthiraj-Nagaraj
|
from IPython.display import Image, display
Image('lights_out_rule.png')
Image('lights_out_prob.png')
# The starting pattern is represented by this list of numbers.
# Please use it as an input for your solution.
lights = [0, 1, 1, 1, 0, 0, 1, 1, 1]
def week2a_ans_func(lights):
##### build your quantum circuit here
#### In addition, please make it a function that can solve the problem even with different inputs (lights). We do validation with different inputs.
return qc
# Submission code
from qc_grader import prepare_ex2a, grade_ex2a, submit_ex2a
# Execute your circuit with following prepare_ex2a() function.
# The prepare_ex2a () function works like the execute() function with only QuantumCircuit as an argument.
job = prepare_ex2a(week2a_ans_func)
result = job.result()
count = result.get_counts()
original_problem_set_counts = count[0]
original_problem_set_counts
# The bit string with the highest number of observations is treated as the solution.
# Check your answer by executing following code.
# The quantum cost of the QuantumCircuit is obtained as the score. The quantum cost is related to rank only in the third week.
grade_ex2a(job)
# Submit your results by executing following code. You can submit as many times as you like during the period.
submit_ex2a(job)
|
https://github.com/Keerthiraj-Nagaraj/IBM-quantum-challenge-2020
|
Keerthiraj-Nagaraj
|
from IPython.display import Image, display
Image('ryoko_pillars.png')
Image('lights_out_rule.png')
Image('lights_out_prob.png')
import numpy as np
# import qiskit libraries
from qiskit import IBMQ, Aer,QuantumRegister, ClassicalRegister, QuantumCircuit, execute
from qiskit.providers.ibmq import least_busy
from qiskit.quantum_info import Operator
from qiskit.tools.jupyter import *
#provider = IBMQ.load_account()
#import functions to plot
from qiskit.visualization import plot_histogram
# The starting pattern is represented by this list of numbers.
# Please use it as an input for your solution.
lights = [0, 1, 1, 1, 0, 0, 1, 1, 1]
def week2a_ans_func(lights):
##### build your quantum circuit here
def lights_oracle(qc, sol, board, orc_out, anc, c_out):
flip_matrix = [[1,1,0,1,0,0,0,0,0],
[1,1,1,0,1,0,0,0,0],
[0,1,1,0,0,1,0,0,0],
[1,0,0,1,1,0,1,0,0],
[0,1,0,1,1,1,0,1,0],
[0,0,1,0,1,1,0,0,1],
[0,0,0,1,0,0,1,1,0],
[0,0,0,0,1,0,1,1,1],
[0,0,0,0,0,1,0,1,1]]
for sol_bit in range(len(flip_matrix)):
for board_bit in range(len(flip_matrix[sol_bit])):
if flip_matrix[sol_bit][board_bit] == 1:
qc.cx(sol[sol_bit], board[board_bit])
qc.barrier()
for i in range(len(flip_matrix)):
qc.x(board[i])
qc.barrier()
qc.mct([board[0], board[1],board[2],board[3],board[4],board[5],board[6],board[7],board[8]],
orc_out,
[anc[0], anc[1],anc[2],anc[3],anc[4],anc[5],anc[6]],
mode='v-chain')
qc.barrier()
for i in range(len(flip_matrix)):
qc.x(board[i])
for sol_bit in range(len(flip_matrix)):
for board_bit in range(len(flip_matrix[sol_bit])):
if flip_matrix[sol_bit][board_bit] == 1:
qc.cx(sol[sol_bit], board[board_bit])
def diffuser(nqubits):
qc = QuantumCircuit(nqubits)
for qubit in range(nqubits):
qc.h(qubit)
for qubit in range(nqubits):
qc.x(qubit)
qc.h(nqubits-1)
qc.mct(list(range(nqubits-1)), nqubits-1) # multi-controlled-toffoli
qc.h(nqubits-1)
for qubit in range(nqubits):
qc.x(qubit)
for qubit in range(nqubits):
qc.h(qubit)
U_f0 = qc.to_gate()
U_f0.name = "V"
return U_f0
#def groverLights(lights):
n = len(lights)
r = int(np.round(np.pi/(4*np.arcsin(np.sqrt(1/3**n)))-1/2))
print(f'{3*n-1} qubits, {r} rounds')
board = QuantumRegister(n, 'board')
sol = QuantumRegister(n, 'solution')
anc = QuantumRegister(n-2, 'anc')
orc_out = QuantumRegister(1, 'oracle_out')
c_out = ClassicalRegister(n, 'classical_bits')
qc = QuantumCircuit(sol, board, orc_out, anc, c_out)
for l in range(n):
if lights[l] == 1:
qc.x(board[l])
qc.x(orc_out)
qc.h(orc_out)
qc.barrier()
qc.h(sol)
qc.barrier()
r = 1
for _ in range(r):
lights_oracle(qc, sol, board, orc_out, anc, c_out)
qc.barrier()
qc.append(diffuser(n), sol)
qc.barrier()
qc.measure(sol, c_out)
qc = qc.reverse_bits()
##### In addition, please make it a function that can solve the problem even with different inputs (lights). We do validation with different inputs.
return qc
# Submission code
from qc_grader import prepare_ex2a, grade_ex2a, submit_ex2a
# Execute your circuit with following prepare_ex2a() function.
# The prepare_ex2a () function works like the execute() function with only QuantumCircuit as an argument.
job = prepare_ex2a(week2a_ans_func)
result = job.result()
count = result.get_counts()
original_problem_set_counts = count[0]
original_problem_set_counts
# The bit string with the highest number of observations is treated as the solution.
# Check your answer by executing following code.
# The quantum cost of the QuantumCircuit is obtained as the score. The quantum cost is related to rank only in the third week.
grade_ex2a(job)
# Submit your results by executing following code. You can submit as many times as you like during the period.
submit_ex2a(job)
|
https://github.com/Keerthiraj-Nagaraj/IBM-quantum-challenge-2020
|
Keerthiraj-Nagaraj
|
from IPython.display import Image, display
Image('4lightsout_ex.png')
from qiskit import *
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit import IBMQ, Aer, execute
provider = IBMQ.load_account()
address = QuantumRegister(2)
data = QuantumRegister(3)
c = ClassicalRegister(5)
qc = QuantumCircuit(address,data,c)
# address preparation
qc.h([address[0],address[1]])
qc.barrier()
# address 0 -> data = 1
qc.x([address[0],address[1]])
qc.ccx(address[0],address[1],data[2])
qc.x([address[0],address[1]])
qc.barrier()
# address 1 -> data = 2
qc.x(address[0])
qc.ccx(address[0],address[1],data[1])
qc.x(address[0])
qc.barrier()
# address 2 -> data = 5
qc.x(address[1])
qc.ccx(address[0],address[1],data[2])
qc.ccx(address[0],address[1],data[0])
qc.x(address[1])
qc.barrier()
# address 3 -> data = 7
qc.ccx(address[0],address[1],data[2])
qc.ccx(address[0],address[1],data[1])
qc.ccx(address[0],address[1],data[0])
qc.barrier()
#Check the qRAM status
qc.measure(address[0:2], c[0:2])
qc.measure(data[0:3], c[2:5])
# Reverse the output string.
qc = qc.reverse_bits()
#backend = provider.get_backend('ibmq_qasm_simulator')
backend = Aer.get_backend('qasm_simulator')
job = execute(qc, backend=backend, shots=8000, seed_simulator=12345, backend_options={"fusion_enable":True})
#job = execute(qc, backend=backend, shots=8192)
result = job.result()
count =result.get_counts()
print(count)
qc.draw(output='mpl')
Image('circuit_ex.png')
Image('gatesynthesis_ex.png')
Image('4lightsout_pr.png')
lightsout4=[[1, 1, 1, 0, 0, 0, 1, 0, 0],[1, 0, 1, 0, 0, 0, 1, 1, 0],[1, 0, 1, 1, 1, 1, 0, 0, 1],[1, 0, 0, 0, 0, 0, 1, 0, 0]]
def week2b_ans_func(lightout4):
##### Build your cirucuit here
#### In addition, please make it a function that can solve the problem even with different inputs (lightout4). We do validation with different inputs.
return qc
# Submission code
from qc_grader import prepare_ex2b, grade_ex2b, submit_ex2b
# Execute your circuit with following prepare_ex2b() function.
# The prepare_ex2b() function works like the execute() function with only QuantumCircuit as an argument.
job = prepare_ex2b(week2b_ans_func)
result = job.result()
count = result.get_counts()
original_problem_set_counts = count[0]
original_problem_set_counts
# The bit string with the highest number of observations is treated as the solution.
# Check your answer by executing following code.
# The quantum cost of the QuantumCircuit is obtained as the score. The quantum cost is related to rank only in the third week.
grade_ex2b(job)
# Submit your results by executing following code. You can submit as many times as you like during the period.
submit_ex2b(job)
|
https://github.com/Keerthiraj-Nagaraj/IBM-quantum-challenge-2020
|
Keerthiraj-Nagaraj
|
from IPython.display import Image, display
Image("ryoko.png", width="70")
from IPython.display import Image, display
Image('4lightsout_ex.png')
from qiskit import *
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit import IBMQ, Aer, execute
provider = IBMQ.load_account()
address = QuantumRegister(2)
data = QuantumRegister(3)
c = ClassicalRegister(5)
qc = QuantumCircuit(address,data,c)
# address preparation
qc.h([address[0],address[1]])
qc.barrier()
# address 0 -> data = 1
qc.x([address[0],address[1]])
qc.ccx(address[0],address[1],data[2])
qc.x([address[0],address[1]])
qc.barrier()
# address 1 -> data = 2
qc.x(address[0])
qc.ccx(address[0],address[1],data[1])
qc.x(address[0])
qc.barrier()
# address 2 -> data = 5
qc.x(address[1])
qc.ccx(address[0],address[1],data[2])
qc.ccx(address[0],address[1],data[0])
qc.x(address[1])
qc.barrier()
# address 3 -> data = 7
qc.ccx(address[0],address[1],data[2])
qc.ccx(address[0],address[1],data[1])
qc.ccx(address[0],address[1],data[0])
qc.barrier()
#Check the qRAM status
qc.measure(address[0:2], c[0:2])
qc.measure(data[0:3], c[2:5])
# Reverse the output string.
qc = qc.reverse_bits()
#backend = provider.get_backend('ibmq_qasm_simulator')
backend = Aer.get_backend('qasm_simulator')
job = execute(qc, backend=backend, shots=8000, seed_simulator=12345, backend_options={"fusion_enable":True})
#job = execute(qc, backend=backend, shots=8192)
result = job.result()
count =result.get_counts()
print(count)
qc.draw(output='mpl')
Image('circuit_ex.png')
Image('gatesynthesis_ex.png')
Image('4lightsout_pr.png')
lightsout4=[[1, 1, 1, 0, 0, 0, 1, 0, 0],[1, 0, 1, 0, 0, 0, 1, 1, 0],[1, 0, 1, 1, 1, 1, 0, 0, 1],[1, 0, 0, 0, 0, 0, 1, 0, 0]]
import numpy as np
# import qiskit libraries
from qiskit import IBMQ, Aer,QuantumRegister, ClassicalRegister, QuantumCircuit, execute
from qiskit.tools.jupyter import *
provider = IBMQ.load_account()
#import functions to plot
from qiskit.visualization import plot_histogram
def week2b_ans_func(lightout4):
##### Build your cirucuit here
def qRAM(qc, add, board, lightout4):
# Board 1
qc.x(add[0])
qc.x(add[1])
for i, curr_light in enumerate(lightout4[0]):
if curr_light == 1:
qc.ccx(add[0], add[1], board[i])
#qc.ch(q[0], q[3])
#qc.cz(q[2], q[3])
#qc.ch(q[0], q[3])
qc.x(add[0])
qc.x(add[1])
qc.barrier()
# Board 2
qc.x(add[0])
for i, curr_light in enumerate(lightout4[1]):
if curr_light == 1:
qc.ccx(add[0], add[1], board[i])
qc.x(add[0])
qc.barrier()
# Board 3
qc.x(add[1])
for i, curr_light in enumerate(lightout4[2]):
if curr_light == 1:
qc.ccx(add[0], add[1], board[i])
qc.x(add[1])
qc.barrier()
# Board 4
for i, curr_light in enumerate(lightout4[3]):
if curr_light == 1:
qc.ccx(add[0], add[1], board[i])
qc.barrier()
def diffuser(nqubits):
qc_diff = QuantumCircuit(nqubits)
for qubit in range(nqubits):
qc_diff.h(qubit)
for qubit in range(nqubits):
qc_diff.x(qubit)
qc_diff.h(nqubits-1)
qc_diff.mct(list(range(nqubits-1)), nqubits-1) # multi-controlled-toffoli
qc_diff.h(nqubits-1)
for qubit in range(nqubits):
qc_diff.x(qubit)
for qubit in range(nqubits):
qc_diff.h(qubit)
U_f0 = qc_diff.to_gate()
U_f0.name = "V"
return U_f0
def lights_oracle(sol, board, anc, orc_out_2a):
#board_oracle = QuantumRegister(n, 'board')
#sol = QuantumRegister(n, 'solution')
#orc_out_2a = QuantumRegister(1, 'oracle_out_2a') #this has to be phase flipped
qc_1 = QuantumCircuit(sol, board, anc, orc_out_2a)
flip_matrix = [[1,1,0,1,0,0,0,0,0],
[1,1,1,0,1,0,0,0,0],
[0,1,1,0,0,1,0,0,0],
[1,0,0,1,1,0,1,0,0],
[0,1,0,1,1,1,0,1,0],
[0,0,1,0,1,1,0,0,1],
[0,0,0,1,0,0,1,1,0],
[0,0,0,0,1,0,1,1,1],
[0,0,0,0,0,1,0,1,1]]
qc_1.barrier()
for sol_bit in range(len(flip_matrix)):
for board_bit in range(len(flip_matrix[sol_bit])):
if flip_matrix[sol_bit][board_bit] == 1:
qc_1.cx(sol[sol_bit], board[board_bit])
qc_1.barrier()
for i in range(len(flip_matrix)):
qc_1.x(board[i])
qc_1.barrier()
qc_1.ccx(board[0], board[1], anc[0])
qc_1.ccx(board[2], board[3], anc[1])
qc_1.ccx(anc[0], anc[1], anc[2])
qc_1.ccx(board[4], board[5], anc[3])
qc_1.ccx(board[6], board[7], anc[4])
qc_1.ccx(anc[3], anc[4], anc[5])
qc_1.mct([board[8], anc[2], anc[5]], orc_out_2a, mode = 'noancilla')
qc_1.ccx(anc[3], anc[4], anc[5])
qc_1.ccx(board[6], board[7], anc[4])
qc_1.ccx(board[4], board[5], anc[3])
qc_1.ccx(anc[0], anc[1], anc[2])
qc_1.ccx(board[2], board[3], anc[1])
qc_1.ccx(board[0], board[1], anc[0])
#qc_1.mct([board[0], board[1],board[2],board[3],board[4],board[5],board[6],board[7],board[8]],
# orc_out_2a,
#[anc[0], anc[1],anc[2],anc[3],anc[4],anc[5],anc[6]],
# mode='noancilla')
qc_1.barrier()
for i in range(len(flip_matrix)):
qc_1.x(board[i])
qc_1.barrier()
for sol_bit in range(len(flip_matrix)):
for board_bit in range(len(flip_matrix[sol_bit])):
if flip_matrix[sol_bit][board_bit] == 1:
qc_1.cx(sol[sol_bit], board[board_bit])
return qc_1
def new_u2a(qc, sol, board, anc, orc_out_2a):
r_2a = 1
flip_matrix = [[1,1,0,1,0,0,0,0,0],
[1,1,1,0,1,0,0,0,0],
[0,1,1,0,0,1,0,0,0],
[1,0,0,1,1,0,1,0,0],
[0,1,0,1,1,1,0,1,0],
[0,0,1,0,1,1,0,0,1],
[0,0,0,1,0,0,1,1,0],
[0,0,0,0,1,0,1,1,1],
[0,0,0,0,0,1,0,1,1]]
n =len(flip_matrix)
for i_2a in range(r_2a):
qc.extend(lights_oracle(sol, board, anc, orc_out_2a))
qc.barrier()
qc.append(diffuser(n), sol)
qc.barrier()
def new_u2a_dagger(qc, sol, board, anc, orc_out_2a):
r_2a = 1
flip_matrix = [[1,1,0,1,0,0,0,0,0],
[1,1,1,0,1,0,0,0,0],
[0,1,1,0,0,1,0,0,0],
[1,0,0,1,1,0,1,0,0],
[0,1,0,1,1,1,0,1,0],
[0,0,1,0,1,1,0,0,1],
[0,0,0,1,0,0,1,1,0],
[0,0,0,0,1,0,1,1,1],
[0,0,0,0,0,1,0,1,1]]
n =len(flip_matrix)
for i_2a in range(r_2a):
qc.barrier()
qc.append(diffuser(n), sol)
qc.barrier()
orc_org = lights_oracle(sol, board, anc, orc_out_2a)
qc.extend(orc_org.inverse())
def bitcounter(qc, sol, anc):
for i in range(len(sol)):
qc.mct([sol[i], anc[0], anc[1], anc[2]], anc[3], mode = 'noancilla')
qc.mct([sol[i], anc[0], anc[1]], anc[2], mode = 'noancilla')
qc.ccx(sol[i], anc[0], anc[1])
qc.cx(sol[i], anc[0])
def bitcounter_uncompute(qc, sol, anc):
for i in range(len(sol)):
qc.cx(sol[i], anc[0])
qc.ccx(sol[i], anc[0], anc[1])
qc.mct([sol[i], anc[0], anc[1]], anc[2], mode = 'noancilla')
qc.mct([sol[i], anc[0], anc[1], anc[2]], anc[3], mode = 'noancilla')
def oracle_2b(qc, add, board, sol, anc, orc_out_2a, orc_out_2b, lightout4):
#apply QRAM
qRAM(qc, add, board, lightout4)
#apply U_2A
new_u2a(qc, sol, board, anc, orc_out_2a)
#counter
#qc.append(WeightedAdder(9), sol+anc)
bitcounter(qc, sol, anc)
#verifying that the count is less than 3
qc.x(anc[2])
qc.x(anc[3])
qc.ccx(anc[2], anc[3], orc_out_2b)
qc.x(anc[2])
qc.x(anc[3])
bitcounter_uncompute(qc, sol, anc)
#apply U_2a_dagger
new_u2a_dagger(qc, sol, board, anc, orc_out_2a)
#apply qRAM dagger - same as qRAM
qRAM(qc, add, board, lightout4)
# start building the circuit
n = len(lightout4[0])
add = QuantumRegister(2, 'address')
board = QuantumRegister(n, 'board')
sol = QuantumRegister(n, 'solution')
anc = QuantumRegister(6, 'anc')
orc_out_2a = QuantumRegister(1, 'oracle_out_2a')
orc_out_2b = QuantumRegister(1, 'oracle_out_2b')
c_out = ClassicalRegister(2, 'classical_bits')
qc = QuantumCircuit(add, board, sol, orc_out_2a, anc, orc_out_2b, c_out)
qc.h(add)
qc.h(sol)
qc.x(orc_out_2a)
qc.h(orc_out_2a)
qc.x(orc_out_2b)
qc.h(orc_out_2b)
qc.barrier()
r_2b = 2
for i_2b in range(r_2b):
oracle_2b(qc, add, board, sol, anc, orc_out_2a, orc_out_2b, lightout4)
qc.barrier()
qc.append(diffuser(2), add)
qc.barrier()
qc.measure(add, c_out)
qc = qc.reverse_bits()
#### In addition, please make sure your function can solve the problem with different inputs (lightout4). We will cross validate with different inputs.
return qc
# Submission code
from qc_grader import prepare_ex2b, grade_ex2b, submit_ex2b
# Execute your circuit with following prepare_ex2b() function.
# The prepare_ex2b() function works like the execute() function with only QuantumCircuit as an argument.
job = prepare_ex2b(week2b_ans_func)
result = job.result()
count = result.get_counts()
original_problem_set_counts = count[0]
original_problem_set_counts
# The bit string with the highest number of observations is treated as the solution.
# Check your answer by executing following code.
# The quantum cost of the QuantumCircuit is obtained as the score. The quantum cost is related to rank only in the third week.
grade_ex2b(job)
# Submit your results by executing following code. You can submit as many times as you like during the period.
submit_ex2b(job)
|
https://github.com/Keerthiraj-Nagaraj/IBM-quantum-challenge-2020
|
Keerthiraj-Nagaraj
|
from IPython.display import Image, display
Image("ryoko.png", width="70")
Image('asteroids_example.png')
Image('asteroids_beam_example.png')
Image('false_asteroids_example.png')
Image('asteroids_example.png')
problem_set = \
[[['0', '2'], ['1', '0'], ['1', '2'], ['1', '3'], ['2', '0'], ['3', '3']],
[['0', '0'], ['0', '1'], ['1', '2'], ['2', '2'], ['3', '0'], ['3', '3']],
[['0', '0'], ['1', '1'], ['1', '3'], ['2', '0'], ['3', '2'], ['3', '3']],
[['0', '0'], ['0', '1'], ['1', '1'], ['1', '3'], ['3', '2'], ['3', '3']],
[['0', '2'], ['1', '0'], ['1', '3'], ['2', '0'], ['3', '2'], ['3', '3']],
[['1', '1'], ['1', '2'], ['2', '0'], ['2', '1'], ['3', '1'], ['3', '3']],
[['0', '2'], ['0', '3'], ['1', '2'], ['2', '0'], ['2', '1'], ['3', '3']],
[['0', '0'], ['0', '3'], ['1', '2'], ['2', '2'], ['2', '3'], ['3', '0']],
[['0', '3'], ['1', '1'], ['1', '2'], ['2', '0'], ['2', '1'], ['3', '3']],
[['0', '0'], ['0', '1'], ['1', '3'], ['2', '1'], ['2', '3'], ['3', '0']],
[['0', '1'], ['0', '3'], ['1', '2'], ['1', '3'], ['2', '0'], ['3', '2']],
[['0', '0'], ['1', '3'], ['2', '0'], ['2', '1'], ['2', '3'], ['3', '1']],
[['0', '1'], ['0', '2'], ['1', '0'], ['1', '2'], ['2', '2'], ['2', '3']],
[['0', '3'], ['1', '0'], ['1', '3'], ['2', '1'], ['2', '2'], ['3', '0']],
[['0', '2'], ['0', '3'], ['1', '2'], ['2', '3'], ['3', '0'], ['3', '1']],
[['0', '1'], ['1', '0'], ['1', '2'], ['2', '2'], ['3', '0'], ['3', '1']]]
def week3_ans_func(problem_set):
##### build your quantum circuit here
##### In addition, please make it a function that can solve the problem even with different inputs (problem_set). We do validation with different inputs.
#### Code for Grover's algorithm with iterations = 1 will be as follows.
#### for i in range(1):
#### oracle()
#### diffusion()
return qc
# Submission code
from qc_grader import grade_ex3, prepare_ex3, submit_ex3
# Execute your circuit with following prepare_ex3() function.
# The prepare_ex3() function works like the execute() function with only QuantumCircuit as an argument.
job = prepare_ex3(week3_ans_func)
result = job.result()
counts = result.get_counts()
original_problem_set_counts = counts[0]
original_problem_set_counts
# The bit string with the highest number of observations is treated as the solution.
# Check your answer by executing following code.
# The quantum cost of the QuantumCircuit is obtained as the score. The lower the cost, the better.
grade_ex3(job)
# Submit your results by executing following code. You can submit as many times as you like during the period.
submit_ex3(job)
|
https://github.com/Keerthiraj-Nagaraj/IBM-quantum-challenge-2020
|
Keerthiraj-Nagaraj
|
from IPython.display import Image, display
Image("ryoko.png", width="70")
Image('asteroids_example.png')
Image('asteroids_beam_example.png')
Image('false_asteroids_example.png')
Image('asteroids_example.png')
problem_set = \
[[['0', '2'], ['1', '0'], ['1', '2'], ['1', '3'], ['2', '0'], ['3', '3']],
[['0', '0'], ['0', '1'], ['1', '2'], ['2', '2'], ['3', '0'], ['3', '3']],
[['0', '0'], ['1', '1'], ['1', '3'], ['2', '0'], ['3', '2'], ['3', '3']],
[['0', '0'], ['0', '1'], ['1', '1'], ['1', '3'], ['3', '2'], ['3', '3']],
[['0', '2'], ['1', '0'], ['1', '3'], ['2', '0'], ['3', '2'], ['3', '3']],
[['1', '1'], ['1', '2'], ['2', '0'], ['2', '1'], ['3', '1'], ['3', '3']],
[['0', '2'], ['0', '3'], ['1', '2'], ['2', '0'], ['2', '1'], ['3', '3']],
[['0', '0'], ['0', '3'], ['1', '2'], ['2', '2'], ['2', '3'], ['3', '0']],
[['0', '3'], ['1', '1'], ['1', '2'], ['2', '0'], ['2', '1'], ['3', '3']],
[['0', '0'], ['0', '1'], ['1', '3'], ['2', '1'], ['2', '3'], ['3', '0']],
[['0', '1'], ['0', '3'], ['1', '2'], ['1', '3'], ['2', '0'], ['3', '2']],
[['0', '0'], ['1', '3'], ['2', '0'], ['2', '1'], ['2', '3'], ['3', '1']],
[['0', '1'], ['0', '2'], ['1', '0'], ['1', '2'], ['2', '2'], ['2', '3']],
[['0', '3'], ['1', '0'], ['1', '3'], ['2', '1'], ['2', '2'], ['3', '0']],
[['0', '2'], ['0', '3'], ['1', '2'], ['2', '3'], ['3', '0'], ['3', '1']],
[['0', '1'], ['1', '0'], ['1', '2'], ['2', '2'], ['3', '0'], ['3', '1']]]
import numpy as np
# import qiskit libraries
from qiskit import IBMQ, Aer,QuantumRegister, ClassicalRegister, QuantumCircuit, execute
from qiskit.tools.jupyter import *
from qiskit.circuit.library import OR as or_gate
provider = IBMQ.load_account()
#import functions to plot
from qiskit.visualization import plot_histogram
def week3_ans_func(problem_set):
##### build your quantum circuit here
##### In addition, please make it a function that can solve the problem even with different inputs (problem_set). We do validation with different inputs.
def qRAM(qc,add,data, auxiliary, problem_set):
problem_set_mapping_dict = {'0' : {'0': 0, '1': 1, '2': 2, '3':3},
'1' : {'0': 4, '1': 5, '2': 6, '3':7},
'2' : {'0': 8, '1': 9, '2': 10, '3':11},
'3' : {'0': 12, '1': 13, '2': 14, '3':15}}
for ind in range(len(data)):
binary = f'{ind:04b}'
if(binary[0] == '0'):
qc.x(add[0])
if(binary[1] == '0'):
qc.x(add[1])
if(binary[2] == '0'):
qc.x(add[2])
if(binary[3] == '0'):
qc.x(add[3])
for i, edg in enumerate(problem_set[ind]):
qc.ch(add[0],auxiliary[0])
qc.cz(add[1],auxiliary[0])
qc.ch(add[0], auxiliary[0])
#qc.ccx(add[0], add[1], auxiliary[0])
qc.ch(add[2],auxiliary[1])
qc.cz(add[3],auxiliary[1])
qc.ch(add[2], auxiliary[1])
#qc.ccx(add[2], add[3], auxiliary[1])
qc.ch(auxiliary[0],auxiliary[2])
qc.cz(auxiliary[1],auxiliary[2])
qc.ch(auxiliary[0],auxiliary[2])
#qc.ccx(auxiliary[0], auxiliary[1], auxiliary[2])
qc.cx(auxiliary[2], data[problem_set_mapping_dict[edg[0]][edg[1]]])
qc.ch(auxiliary[0],auxiliary[2])
qc.cz(auxiliary[1],auxiliary[2])
qc.ch(auxiliary[0],auxiliary[2])
qc.ch(add[2],auxiliary[1])
qc.cz(add[3],auxiliary[1])
qc.ch(add[2], auxiliary[1])
qc.ch(add[0],auxiliary[0])
qc.cz(add[1],auxiliary[0])
qc.ch(add[0], auxiliary[0])
if(binary[0] == '0'):
qc.x(add[0])
if(binary[1] == '0'):
qc.x(add[1])
if(binary[2] == '0'):
qc.x(add[2])
if(binary[3] == '0'):
qc.x(add[3])
qc.barrier()
def diffuser(nqubits):
qc_diff = QuantumCircuit(nqubits)
for qubit in range(nqubits):
qc_diff.h(qubit)
for qubit in range(nqubits):
qc_diff.x(qubit)
qc_diff.h(nqubits-1)
qc_diff.mct(list(range(nqubits-1)), nqubits-1) # multi-controlled-toffoli
qc_diff.h(nqubits-1)
for qubit in range(nqubits):
qc_diff.x(qubit)
for qubit in range(nqubits):
qc_diff.h(qubit)
U_f0 = qc_diff.to_gate()
U_f0.name = "V"
return U_f0
def add_row_counters(qc, data, auxiliary):
row_mat = [[0, 1, 2, 3],
[4, 5, 6, 7],
[8, 9, 10, 11],
[12, 13, 14, 15]]
for i, curr_row in enumerate(row_mat):
flag_list = [0] * len(data)
for curr_flag_index in range(len(data)):
if curr_flag_index in curr_row:
flag_list[curr_flag_index] = 1
qc.append(or_gate(len(data), flag_list, mcx_mode='noancilla'), [*data, auxiliary[i]])
def add_column_counters(qc, data, auxiliary):
col_mat = [[0, 4, 8, 12],
[1, 5, 9, 13],
[2, 6, 10, 14],
[3, 7, 11, 15]]
for i, curr_col in enumerate(col_mat):
flag_list = [0] * len(data)
for curr_flag_index in range(len(data)):
if curr_flag_index in curr_col:
flag_list[curr_flag_index] = 1
qc.append(or_gate(len(data), flag_list, mcx_mode='noancilla'), [*data, auxiliary[i]])
def add_lone_counters(qc, data, auxiliary, count_out):
lone_mat = [[0, 1, 2, 3, 4, 8, 12],
[1, 0, 2, 3, 5, 9, 13],
[2, 0, 1, 3, 6, 10, 14],
[3, 0, 1, 2, 7, 11, 15],
[4, 5, 6, 7, 0, 8, 12],
[5, 4, 6, 7, 1, 9, 13],
[6, 4, 5, 7, 2, 10, 14],
[7, 4, 5, 6, 3, 11, 15],
[8, 9, 10, 11, 0, 4, 12],
[9, 8, 10, 11, 1, 5, 13],
[10, 8, 9, 11, 2, 6, 14],
[11, 8, 9, 10, 3, 7, 15],
[12, 13, 14, 15, 0, 4, 8],
[13, 12, 14, 15, 1, 5, 9],
[14, 12, 13, 15, 2, 6, 10],
[15, 12, 13, 14, 3, 7, 11]]
qc.barrier()
#curr_lone_row = [0, 1, 2, 3, 4, 8, 12]
for curr_lone_row in lone_mat:
n = len(curr_lone_row)
for j in range(1,n):
qc.x(data[curr_lone_row[j]])
qc.ch(data[curr_lone_row[0]], auxiliary[0])
qc.cz(data[curr_lone_row[1]], auxiliary[0])
qc.ch(data[curr_lone_row[0]],auxiliary[0])
#qc.ccx(data[curr_lone_row[0]], data[curr_lone_row[1]], auxiliary[0])
qc.ch(data[curr_lone_row[2]],auxiliary[1])
qc.cz(data[curr_lone_row[3]],auxiliary[1])
qc.ch(data[curr_lone_row[2]],auxiliary[1])
#qc.ccx(data[curr_lone_row[2]], data[curr_lone_row[3]], auxiliary[1])
qc.ch(auxiliary[0],auxiliary[2])
qc.cz(auxiliary[1],auxiliary[2])
qc.ch(auxiliary[0],auxiliary[2])
#qc.ccx(auxiliary[0], auxiliary[1], auxiliary[2])
qc.ch(data[curr_lone_row[0]],auxiliary[0])
qc.cz(data[curr_lone_row[1]],auxiliary[0])
qc.ch(data[curr_lone_row[0]],auxiliary[0])
#qc.ccx(data[curr_lone_row[0]], data[curr_lone_row[1]], auxiliary[0])
qc.ch(data[curr_lone_row[4]],auxiliary[0])
qc.cz(data[curr_lone_row[5]],auxiliary[0])
qc.ch(data[curr_lone_row[4]],auxiliary[0])
#qc.ccx(data[curr_lone_row[4]], data[curr_lone_row[5]], auxiliary[0])
qc.ch(auxiliary[0],auxiliary[3])
qc.cz(auxiliary[2],auxiliary[3])
qc.ch(auxiliary[0],auxiliary[3])
#qc.ccx(auxiliary[0], auxiliary[2], auxiliary[3])
#------------------------------------------------------------------------------------------------------------------------
#qc.ch(data[curr_lone_row[6]], count_out[2])
#qc.cz(auxiliary[3],count_out[2])
#qc.ch(data[curr_lone_row[2]],count_out[2])
qc.ccx(data[curr_lone_row[6]], auxiliary[3], count_out[2]) #this CCX is important to avoid
#unnecessary addition of relative phase
#------------------------------------------------------------------------------------------------------------------------
qc.ch(auxiliary[0],auxiliary[3])
qc.cz(auxiliary[2],auxiliary[3])
qc.ch(auxiliary[0],auxiliary[3])
qc.ch(data[curr_lone_row[4]],auxiliary[0])
qc.cz(data[curr_lone_row[5]],auxiliary[0])
qc.ch(data[curr_lone_row[4]],auxiliary[0])
qc.ch(data[curr_lone_row[0]],auxiliary[0])
qc.cz(data[curr_lone_row[1]],auxiliary[0])
qc.ch(data[curr_lone_row[0]],auxiliary[0])
qc.ch(auxiliary[0],auxiliary[2])
qc.cz(auxiliary[1],auxiliary[2])
qc.ch(auxiliary[0],auxiliary[2])
qc.ch(data[curr_lone_row[2]],auxiliary[1])
qc.cz(data[curr_lone_row[3]],auxiliary[1])
qc.ch(data[curr_lone_row[2]],auxiliary[1])
qc.ch(data[curr_lone_row[0]], auxiliary[0])
qc.cz(data[curr_lone_row[1]], auxiliary[0])
qc.ch(data[curr_lone_row[0]],auxiliary[0])
for j in range(1,n):
qc.x(data[curr_lone_row[j]])
qc.barrier
def u3a(data, auxiliary,oracle, count_out):
qc_1 = QuantumCircuit(data, auxiliary,oracle, count_out)
#Oracle -----------------------------------------------
#Adding Row counters to check if each row has at least 1 asteroid and then flipping a count_out bit if all rows has at least one asteroid
add_row_counters(qc_1, data, auxiliary) #compute
qc_1.mct([auxiliary[0], auxiliary[1], auxiliary[2], auxiliary[3]], count_out[0], mode = 'noancilla')
add_row_counters(qc_1, data, auxiliary) #uncompute
#Adding column counters to check if each column has at least 1 asteroid and then flipping a count_out bit if all columns has at least one asteroid
add_column_counters(qc_1, data, auxiliary) #compute
qc_1.mct([auxiliary[0], auxiliary[1], auxiliary[2], auxiliary[3]], count_out[1], mode = 'noancilla')
add_column_counters(qc_1, data, auxiliary) #uncompute
#qc_1.barrier()
#lone asteroid counter circuit to add
add_lone_counters(qc_1, data, auxiliary, count_out)
return qc_1
def u3a_dagger(data, auxiliary, oracle, count_out):
qc_1 = QuantumCircuit(data, auxiliary,oracle, count_out)
#Oracle -----------------------------------------------
#Adding Row counters to check if each row has at least 1 asteroid and then flipping a count_out bit if all rows has at least one asteroid
add_row_counters(qc_1, data, auxiliary) #compute
qc_1.mct([auxiliary[0], auxiliary[1], auxiliary[2], auxiliary[3]], count_out[0], mode = 'noancilla')
add_row_counters(qc_1, data, auxiliary) #uncompute
#Adding column counters to check if each column has at least 1 asteroid and then flipping a count_out bit if all columns has at least one asteroid
add_column_counters(qc_1, data, auxiliary) #compute
qc_1.mct([auxiliary[0], auxiliary[1], auxiliary[2], auxiliary[3]], count_out[1], mode = 'noancilla')
add_column_counters(qc_1, data, auxiliary) #uncompute
#qc_1.barrier()
#lone asteroid counter circuit to add
add_lone_counters(qc_1, data, auxiliary, count_out)
qc_2 = qc_1.inverse()
return qc_2
add = QuantumRegister(4, name = 'address')
data = QuantumRegister(16, name = 'data')
auxiliary = QuantumRegister(4, name = 'auxiliary')
count_out = QuantumRegister(3, name = 'counter_outputs')
oracle = QuantumRegister(1, name = 'oracle')
cbits = ClassicalRegister(4, name = 'solution')
qc = QuantumCircuit(add, data, auxiliary,oracle, count_out, cbits)
qc.x(oracle)
qc.h(oracle)
qc.h(add)
qc.barrier()
#Add qRAM
qRAM(qc,add,data, auxiliary, problem_set) #compute
qc.barrier()
# counters
qc.extend(u3a(data, auxiliary,oracle, count_out))
qc.barrier()
# Phase flipping oracle
#qc.cx(auxiliary[6], oracle)
qc.mct([count_out[0], count_out[1], count_out[2]], oracle, mode = 'noancilla')
# -------------------------------------------------------
# counters - dagger
qc.extend(u3a_dagger(data, auxiliary,oracle, count_out))
qc.barrier()
#qRAM
qc.barrier()
qRAM(qc,add,data, auxiliary, problem_set) #uncompute
qc.barrier()
#diffuser
qc.append(diffuser(4), add)
qc.barrier()
#measure
qc.measure(add[0], cbits[0])
qc.measure(add[1], cbits[1])
qc.measure(add[2], cbits[2])
qc.measure(add[3], cbits[3])
return qc
# Submission code
from qc_grader import grade_ex3, prepare_ex3, submit_ex3
# Execute your circuit with following prepare_ex3() function.
# The prepare_ex3() function works like the execute() function with only QuantumCircuit as an argument.
job = prepare_ex3(week3_ans_func)
result = job.result()
counts = result.get_counts()
original_problem_set_counts = counts[0]
original_problem_set_counts
# The bit string with the highest number of observations is treated as the solution.
# Check your answer by executing following code.
# The quantum cost of the QuantumCircuit is obtained as the score. The lower the cost, the better.
grade_ex3(job)
# Submit your results by executing following code. You can submit as many times as you like during the period.
submit_ex3(job)
|
https://github.com/Keerthiraj-Nagaraj/IBM-quantum-challenge-2020
|
Keerthiraj-Nagaraj
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# (C) Copyright IBM 2020.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
import json
from typing import Any, Callable, Optional, Tuple, Union
from urllib.parse import urljoin
from qiskit import QuantumCircuit, execute
from qiskit.providers import JobStatus
from qiskit.providers.ibmq.job import IBMQJob
from .api import get_server_endpoint, send_request, get_access_token, get_submission_endpoint
from .exercises import get_question_id
from .util import compute_cost, get_provider, get_job, circuit_to_json, get_job_urls, uses_multiqubit_gate
def _circuit_criteria(
circuit: QuantumCircuit,
max_qubits: Optional[int] = None,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False
) -> Tuple[Optional[int], Optional[int]]:
if max_qubits is not None and circuit.num_qubits > max_qubits:
print(f'Your circuit has {circuit.num_qubits} qubits, which exceeds the maximum allowed.')
print(f'Please reduce the number of qubits in your circuit to below {max_qubits}.')
return None, None
try:
if check_gates and not uses_multiqubit_gate(circuit):
print('Your circuit appears to not use any multi-quibit gates.')
print('Please review your circuit and try again.')
return None, None
cost = compute_cost(circuit)
if min_cost is not None and cost < min_cost:
print(f'Your circuit cost ({cost}) is too low. But if you are convinced that your circuit\n'
'is correct, please let us know in the `#ibm-quantum-challenge-2020` Slack channel.')
return None, None
return circuit.num_qubits, cost
except Exception as err:
print(f'Unable to compute cost: {err}')
return None, None
def _circuit_grading(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False,
max_qubits: Optional[int] = None,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
payload = None
server = None
if not isinstance(circuit, QuantumCircuit):
print(f'Expected a QuantumCircuit, but was given {type(circuit)}')
print(f'Please provide a circuit as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or '
'the grading servers are down right now.')
return None, None
else:
server = None
_, cost = _circuit_criteria(
circuit,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if cost is not None:
payload = {
'answer': circuit_to_json(circuit)
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def _job_grading(
job_or_id: Union[IBMQJob, str],
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
if not isinstance(job_or_id, IBMQJob) and not isinstance(job_or_id, str):
print(f'Expected an IBMQJob or a job ID, but was given {type(job_or_id)}')
print(f'Please submit a job as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or the grading '
'servers are down right now.')
return None, None
else:
server = None
job = get_job(job_or_id) if isinstance(job_or_id, str) else job_or_id
if not job:
print('An invalid or non-existent job was specified.')
return None, None
job_status = job.status()
if job_status in [JobStatus.CANCELLED, JobStatus.ERROR]:
print(f'Job did not successfully complete: {job_status.value}.')
return None, None
elif job_status is not JobStatus.DONE:
print(f'Job has not yet completed: {job_status.value}.')
print(f'Please wait for the job (id: {job.job_id()}) to complete then try again.')
return None, None
header = job.result().header.to_dict()
if 'qc_cost' not in header:
if is_submit:
print('An unprepared answer was specified. '
'Please prepare() and grade() answer before submitting.')
else:
print('An unprepared answer was specified. Please prepare() answer before grading.')
return None, None
download_url, result_url = get_job_urls(job)
if not download_url or not result_url:
print('Unable to obtain job URLs')
return None, None
payload = {
'answer': json.dumps({
'download_url': download_url,
'result_url': result_url
})
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def _number_grading(
answer: int,
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
if not isinstance(answer, int):
print(f'Expected a integer, but was given {type(answer)}')
print(f'Please provide a number as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server '
'or the grading servers are down right now.')
return None, None
else:
server = None
payload = {
'answer': str(answer)
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def prepare_circuit(
circuit: QuantumCircuit,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False,
**kwargs
) -> Optional[IBMQJob]:
job = None
if not isinstance(circuit, QuantumCircuit):
print(f'Expected a QuantumCircuit, but was given {type(circuit)}')
print(f'Please provide a circuit.')
return None
_, cost = _circuit_criteria(
circuit,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if cost is not None:
if 'backend' not in kwargs:
kwargs['backend'] = get_provider().get_backend('ibmq_qasm_simulator')
# execute experiments
print('Starting experiment. Please wait...')
job = execute(
circuit,
qobj_header={
'qc_cost': cost
},
**kwargs
)
print(f'You may monitor the job (id: {job.job_id()}) status '
'and proceed to grading when it successfully completes.')
return job
def prepare_solver(
solver_func: Callable,
lab_id: str,
ex_id: str,
problem_set: Optional[Any] = None,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False,
**kwargs
) -> Optional[IBMQJob]:
job = None
if not callable(solver_func):
print(f'Expected a function, but was given {type(solver_func)}')
print(f'Please provide a function that returns a QuantumCircuit.')
return None
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or the grading servers are down right now.')
return
endpoint = server + 'problem-set'
index, value = get_problem_set(lab_id, ex_id, endpoint)
print(f'Running {solver_func.__name__}...')
qc_1 = solver_func(problem_set)
_, cost = _circuit_criteria(
qc_1,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if value and index is not None and index >= 0 and cost is not None:
qc_2 = solver_func(value)
if 'backend' not in kwargs:
kwargs['backend'] = get_provider().get_backend('ibmq_qasm_simulator')
# execute experiments
print('Starting experiments. Please wait...')
job = execute(
[qc_1, qc_2],
qobj_header={
'qc_index': [None, index],
'qc_cost': cost
},
**kwargs
)
print(f'You may monitor the job (id: {job.job_id()}) status '
'and proceed to grading when it successfully completes.')
return job
def grade_circuit(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None
) -> bool:
payload, server = _circuit_grading(
circuit,
lab_id,
ex_id,
is_submit=False,
max_qubits=max_qubits,
min_cost=min_cost
)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def grade_job(
job_or_id: Union[IBMQJob, str],
lab_id: str,
ex_id: str
) -> bool:
payload, server = _job_grading(job_or_id, lab_id, ex_id, is_submit=False)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def grade_number(
answer: int,
lab_id: str,
ex_id: str
) -> bool:
payload, server = _number_grading(answer, lab_id, ex_id, is_submit=False)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def submit_circuit(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None
) -> bool:
payload, _ = _circuit_grading(
circuit,
lab_id,
ex_id,
is_submit=True,
max_qubits=max_qubits,
min_cost=min_cost
)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def submit_job(
job_or_id: IBMQJob,
lab_id: str,
ex_id: str,
) -> bool:
payload, _ = _job_grading(job_or_id, lab_id, ex_id, is_submit=True)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def submit_number(
answer: int,
lab_id: str,
ex_id: str
) -> bool:
payload, _ = _number_grading(answer, lab_id, ex_id, is_submit=True)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def get_problem_set(
lab_id: str, ex_id: str, endpoint: str
) -> Tuple[Optional[int], Optional[Any]]:
problem_set_response = None
try:
payload = {'question_id': get_question_id(lab_id, ex_id)}
problem_set_response = send_request(endpoint, query=payload, method='GET')
except Exception as err:
print('Unable to obtain the problem set')
if problem_set_response:
status = problem_set_response.get('status')
if status == 'valid':
try:
index = problem_set_response.get('index')
value = json.loads(problem_set_response.get('value'))
return index, value
except Exception as err:
print(f'Problem set could not be processed: {err}')
else:
cause = problem_set_response.get('cause')
print(f'Problem set failed: {cause}')
return None, None
def grade_answer(payload: dict, endpoint: str, cost: Optional[int] = None) -> bool:
try:
answer_response = send_request(endpoint, body=payload)
status = answer_response.get('status', None)
cause = answer_response.get('cause', None)
score = cost if cost else answer_response.get('score', None)
handle_grade_response(status, score=score, cause=cause)
return status == 'valid' or status is True
except Exception as err:
print(f'Failed: {err}')
return False
def submit_answer(payload: dict) -> bool:
try:
access_token = get_access_token()
baseurl = get_submission_endpoint()
endpoint = urljoin(baseurl, './challenges/answers')
submit_response = send_request(
endpoint,
body=payload,
query={'access_token': access_token}
)
status = submit_response.get('status', None)
if status is None:
status = submit_response.get('valid', None)
cause = submit_response.get('cause', None)
handle_submit_response(status, cause=cause)
return status == 'valid' or status is True
except Exception as err:
print(f'Failed: {err}')
return False
def handle_grade_response(
status: Optional[str], score: Optional[int] = None, cause: Optional[str] = None
) -> None:
if status == 'valid':
print('\nCongratulations 🎉! Your answer is correct.')
if score is not None:
print(f'Your score is {score}.')
elif status == 'invalid':
print(f'\nOops 😕! {cause}')
print('Please review your answer and try again.')
elif status == 'notFinished':
print(f'Job has not finished: {cause}')
print(f'Please wait for the job to complete then try again.')
else:
print(f'Failed: {cause}')
print('Unable to grade your answer.')
def handle_submit_response(
status: Union[str, bool], cause: Optional[str] = None
) -> None:
if status == 'valid' or status is True:
print('\nSuccess 🎉! Your answer has been submitted.')
elif status == 'invalid' or status is False:
print(f'\nOops 😕! {"Your answer is incorrect" if cause is None else cause}')
print('Make sure your answer is correct and successfully graded before submitting.')
elif status == 'notFinished':
print(f'Job has not finished: {cause}')
print(f'Please wait for the job to complete, grade it, and then try to submit again.')
else:
print(f'Failed: {cause}')
print('Unable to submit your answer at this time.')
|
https://github.com/Keerthiraj-Nagaraj/IBM-quantum-challenge-2020
|
Keerthiraj-Nagaraj
|
import json
import logging
import numpy as np
import warnings
from functools import wraps
from typing import Any, Callable, Optional, Tuple, Union
from qiskit import IBMQ, QuantumCircuit, assemble
from qiskit.circuit import Barrier, Gate, Instruction, Measure
from qiskit.circuit.library import UGate, U3Gate, CXGate
from qiskit.providers.ibmq import AccountProvider, IBMQProviderError
from qiskit.providers.ibmq.job import IBMQJob
def get_provider() -> AccountProvider:
with warnings.catch_warnings():
warnings.simplefilter('ignore')
ibmq_logger = logging.getLogger('qiskit.providers.ibmq')
current_level = ibmq_logger.level
ibmq_logger.setLevel(logging.ERROR)
# get provider
try:
provider = IBMQ.get_provider()
except IBMQProviderError:
provider = IBMQ.load_account()
ibmq_logger.setLevel(current_level)
return provider
def get_job(job_id: str) -> Optional[IBMQJob]:
try:
job = get_provider().backends.retrieve_job(job_id)
return job
except Exception:
pass
return None
def circuit_to_json(qc: QuantumCircuit) -> str:
class _QobjEncoder(json.encoder.JSONEncoder):
def default(self, obj: Any) -> Any:
if isinstance(obj, np.ndarray):
return obj.tolist()
if isinstance(obj, complex):
return (obj.real, obj.imag)
return json.JSONEncoder.default(self, obj)
return json.dumps(circuit_to_dict(qc), cls=_QobjEncoder)
def circuit_to_dict(qc: QuantumCircuit) -> dict:
qobj = assemble(qc)
return qobj.to_dict()
def get_job_urls(job: Union[str, IBMQJob]) -> Tuple[bool, Optional[str], Optional[str]]:
try:
job_id = job.job_id() if isinstance(job, IBMQJob) else job
download_url = get_provider()._api_client.account_api.job(job_id).download_url()['url']
result_url = get_provider()._api_client.account_api.job(job_id).result_url()['url']
return download_url, result_url
except Exception:
return None, None
def cached(key_function: Callable) -> Callable:
def _decorator(f: Any) -> Callable:
f.__cache = {}
@wraps(f)
def _decorated(*args: Any, **kwargs: Any) -> int:
key = key_function(*args, **kwargs)
if key not in f.__cache:
f.__cache[key] = f(*args, **kwargs)
return f.__cache[key]
return _decorated
return _decorator
def gate_key(gate: Gate) -> Tuple[str, int]:
return gate.name, gate.num_qubits
@cached(gate_key)
def gate_cost(gate: Gate) -> int:
if isinstance(gate, (UGate, U3Gate)):
return 1
elif isinstance(gate, CXGate):
return 10
elif isinstance(gate, (Measure, Barrier)):
return 0
return sum(map(gate_cost, (g for g, _, _ in gate.definition.data)))
def compute_cost(circuit: Union[Instruction, QuantumCircuit]) -> int:
print('Computing cost...')
circuit_data = None
if isinstance(circuit, QuantumCircuit):
circuit_data = circuit.data
elif isinstance(circuit, Instruction):
circuit_data = circuit.definition.data
else:
raise Exception(f'Unable to obtain circuit data from {type(circuit)}')
return sum(map(gate_cost, (g for g, _, _ in circuit_data)))
def uses_multiqubit_gate(circuit: QuantumCircuit) -> bool:
circuit_data = None
if isinstance(circuit, QuantumCircuit):
circuit_data = circuit.data
elif isinstance(circuit, Instruction) and circuit.definition is not None:
circuit_data = circuit.definition.data
else:
raise Exception(f'Unable to obtain circuit data from {type(circuit)}')
for g, _, _ in circuit_data:
if isinstance(g, (Barrier, Measure)):
continue
elif isinstance(g, Gate):
if g.num_qubits > 1:
return True
elif isinstance(g, (QuantumCircuit, Instruction)) and uses_multiqubit_gate(g):
return True
return False
|
https://github.com/Keerthiraj-Nagaraj/IBM-quantum-challenge-2020
|
Keerthiraj-Nagaraj
|
from qiskit import QuantumCircuit
from qc_grader.grade import grade_circuit, grade_number, submit_circuit, submit_number
criteria: dict = {
'max_qubits': 28,
'min_cost': 30
}
def grade_ex1a(circuit: QuantumCircuit) -> None:
if grade_circuit(circuit, 'week1', 'exA', **criteria):
print('Feel free to submit your answer.')
def submit_ex1a(circuit: QuantumCircuit) -> None:
submit_circuit(circuit, 'week1', 'exA', **criteria)
def grade_ex1b(answer: int) -> None:
if grade_number(answer, 'week1', 'exB'):
print('Feel free to submit your answer.')
def submit_ex1b(answer: int) -> None:
if submit_number(answer, 'week1', 'exB'):
print('Have you ever wonder about the quantum realm? Ask Dr. Ryoko about it.')
|
https://github.com/Keerthiraj-Nagaraj/IBM-quantum-challenge-2020
|
Keerthiraj-Nagaraj
|
from qiskit import QuantumCircuit
from qiskit.providers.ibmq.job import IBMQJob
from typing import Callable, Union
from qiskit.circuit.library import CXGate
from qc_grader.grade import prepare_solver, prepare_circuit, grade_job, submit_job
criteria: dict = {
'max_qubits': 28,
'min_cost': 100,
'check_gates': True
}
problem_set_ex2a = [0, 1, 1, 1, 0, 0, 1, 1, 1]
problem_set_ex2b = [
[1, 1, 1, 0, 0, 0, 1, 0, 0],
[1, 0, 1, 0, 0, 0, 1, 1, 0],
[1, 0, 1, 1, 1, 1, 0, 0, 1],
[1, 0, 0, 0, 0, 0, 1, 0, 0]
]
def prepare_ex2a(solver_func: Callable) -> IBMQJob:
return prepare_solver(
solver_func,
'week2', 'exA',
problem_set=problem_set_ex2a,
**criteria,
shots=8000,
seed_simulator=12345,
backend_options={'fusion_enable': True}
)
def grade_ex2a(job: Union[IBMQJob, str]) -> None:
if grade_job(job, 'week2', 'exA'):
print('Feel free to submit your answer.')
def submit_ex2a(job: Union[IBMQJob, str]) -> None:
submit_job(job, 'week2', 'exA')
def prepare_ex2b(solver_func: Callable) -> IBMQJob:
return prepare_solver(
solver_func,
'week2', 'exB',
problem_set=problem_set_ex2b,
**criteria,
shots=8000,
seed_simulator=12345,
backend_options={'fusion_enable': True}
)
def grade_ex2b(job: Union[IBMQJob, str]) -> None:
if grade_job(job, 'week2', 'exB'):
print('Feel free to submit your answer.')
def submit_ex2b(job: Union[IBMQJob, str]) -> None:
if submit_job(job, 'week2', 'exB'):
print('There seems to be huge "noise clusters" interfering with '
'Dr. Ryoko’s device. Can you please help?')
|
https://github.com/Pahamanx/QETCI-Hackathon-2022
|
Pahamanx
|
import numpy as np
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile, Aer, IBMQ
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from ibm_quantum_widgets import *
from qiskit.providers.aer import QasmSimulator
from qiskit.circuit.library import MCXGate
import qiskit.tools.jupyter
%qiskit_job_watcher
# Loading your IBM Quantum account(s)
provider = IBMQ.load_account()
backend = provider.get_backend('simulator_statevector')
#階乘函式
def factorial(num):
if num == 0:
return 1
else:
a = 1
for i in range(1,num+1):
a = a*i
return a
#定義complete graph大小
graphSize = 4
edgeNumbers = (graphSize)*(graphSize-1)//2
answerNumber = factorial(graphSize-1)//2
groverTimes = int(( 3.14/4*(2**edgeNumbers/answerNumber)**(1/2) )//1)
print(answerNumber, edgeNumbers)
#choosing state
def choose(a):
oracle = QuantumCircuit(edgeNumbers, name = 'choose state')
zGate = MCXGate(edgeNumbers-1)
oracle.x(a)
oracle.h([edgeNumbers-1])
oracle.append(zGate, [i for i in range(edgeNumbers)])
oracle.h([edgeNumbers-1])
oracle.x(a)
oracle.draw(output='mpl')
return oracle
#define Hamiltonian Cycles
hamiltonianCycles = [[1,4], [2,3], [0,5]]
#oracle
oracle = QuantumCircuit(edgeNumbers, name = 'oracle')
for i in range(len(hamiltonianCycles)):
oracle.append(choose(hamiltonianCycles[i]), [j for j in range(edgeNumbers)])
oracle.draw(output='mpl')
# diffuser
def diffuser(nqubits):
qc = QuantumCircuit(nqubits)
# Apply transformation |s> -> |00..0> (H-gates)
for qubit in range(nqubits):
qc.h(qubit)
# Apply transformation |00..0> -> |11..1> (X-gates)
for qubit in range(nqubits):
qc.x(qubit)
# Do multi-controlled-Z gate
qc.h(nqubits-1)
qc.mct(list(range(nqubits-1)), nqubits-1) # multi-controlled-toffoli
qc.h(nqubits-1)
# Apply transformation |11..1> -> |00..0>
for qubit in range(nqubits):
qc.x(qubit)
# Apply transformation |00..0> -> |s>
for qubit in range(nqubits):
qc.h(qubit)
# We will return the diffuser as a gate
U_s = qc.to_gate()
U_s.name = "U$_s$"
return U_s
#quantum circuit
qc = QuantumCircuit(edgeNumbers)
for i in range(edgeNumbers):
qc.h(i)
for j in range(groverTimes):
qc.append(oracle, [i for i in range(edgeNumbers)])
qc.append(diffuser(edgeNumbers), [i for i in range(edgeNumbers)])
qc.measure_all()
qc.draw(output='mpl')
job = backend.run(transpile(qc, backend=backend), shots=90)
print(job.job_id())
|
https://github.com/Pahamanx/QETCI-Hackathon-2022
|
Pahamanx
|
import numpy as np
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile, Aer, IBMQ
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from ibm_quantum_widgets import *
from qiskit.providers.aer import QasmSimulator
from qiskit.circuit.library import MCXGate
import qiskit.tools.jupyter
%qiskit_job_watcher
# Loading your IBM Quantum account(s)
provider = IBMQ.load_account()
backend = provider.get_backend('simulator_statevector')
#階乘函式
def factorial(num):
if num == 0:
return 1
else:
a = 1
for i in range(1,num+1):
a = a*i
return a
#定義complete graph大小
graphSize = 5
edgeNumbers = (graphSize)*(graphSize-1)//2
answerNumber = factorial(graphSize-1)//2
groverTimes = int(( 3.14/4*(2**edgeNumbers/answerNumber)**(1/2) )//1)
print(answerNumber, edgeNumbers)
#choosing state
def choose(a):
oracle = QuantumCircuit(edgeNumbers, name = 'choose state')
zGate = MCXGate(edgeNumbers-1)
oracle.x(a)
oracle.h([edgeNumbers-1])
oracle.append(zGate, [i for i in range(edgeNumbers)])
oracle.h([edgeNumbers-1])
oracle.x(a)
oracle.draw(output='mpl')
return oracle
#define Hamiltonian Cycles
hamiltonianCycles = [[0,6,7,8,9], [1,2,3,4,5], [1,3,4,6,8], [1,4,6,7,9],
[0,1,2,4,7], [1,3,5,7,9], [0,1,3,7,8], [0,2,5,7,9],
[2,4,5,6,9], [0,2,3,5,8], [0,2,4,6,8], [3,5,6,8,9]]
#oracle
oracle = QuantumCircuit(edgeNumbers, name = 'oracle')
for i in range(len(hamiltonianCycles)):
oracle.append(choose(hamiltonianCycles[i]), [j for j in range(edgeNumbers)])
oracle.draw(output='mpl')
# diffuser
def diffuser(nqubits):
qc = QuantumCircuit(nqubits)
# Apply transformation |s> -> |00..0> (H-gates)
for qubit in range(nqubits):
qc.h(qubit)
# Apply transformation |00..0> -> |11..1> (X-gates)
for qubit in range(nqubits):
qc.x(qubit)
# Do multi-controlled-Z gate
qc.h(nqubits-1)
qc.mct(list(range(nqubits-1)), nqubits-1) # multi-controlled-toffoli
qc.h(nqubits-1)
# Apply transformation |11..1> -> |00..0>
for qubit in range(nqubits):
qc.x(qubit)
# Apply transformation |00..0> -> |s>
for qubit in range(nqubits):
qc.h(qubit)
# We will return the diffuser as a gate
U_s = qc.to_gate()
U_s.name = "U$_s$"
return U_s
#quantum circuit
qc = QuantumCircuit(edgeNumbers)
for i in range(edgeNumbers):
qc.h(i)
for j in range(groverTimes):
qc.append(oracle, [i for i in range(edgeNumbers)])
qc.append(diffuser(edgeNumbers), [i for i in range(edgeNumbers)])
qc.measure_all()
qc.draw(output='mpl')
job = backend.run(transpile(qc, backend=backend), shots=90)
print(job.job_id())
|
https://github.com/NesyaLab/qaoa
|
NesyaLab
|
#------------------------------------------------------------------------------
# Qaoa.py
#
# Implementation of the Quantum Approximate Optimization Algorithm (QAOA) [1],[2]
# specifically tailored for solving the MaxCut problem on graphs [3].
# This class facilitates the creation of QAOA circuits with
# various types of mixer operators and allows execution on a quantum simulator
# backend provided by Qiskit.
#
# The `Qaoa` class provides methods to:
# - Initialize with QAOA parameters, graph instance, mixer type, and backend settings
# - Create cost operator and various mixer operators (x, xx, y, yy, xy)
# - Generate the complete QAOA circuit
#
# Initialization parameters include the number of QAOA layers, angles for the
# mixer and cost operators, and options for setting verbosity, measurement, and
# random seed. The class checks for consistency in the provided parameters and
# supports visualizing the graph and QAOA circuit.
#
# Refs.
# [1] https://arxiv.org/abs/1411.4028
# [2] https://learning.quantum.ibm.com/tutorial/quantum-approximate-optimization-algorithm
# [3] https://en.wikipedia.org/wiki/Maximum_cut
#
# © Leonardo Lavagna 2024
# @ NESYA https://github.com/NesyaLab
#------------------------------------------------------------------------------
import numpy as np
from matplotlib import pyplot as plt
from classes import Problems as P
from functions import qaoa_utilities as utils
from qiskit import QuantumCircuit
from qiskit_aer import Aer
from typing import List, Tuple
from networkx import Graph
from qiskit.circuit import ParameterVector
class Qaoa:
def __init__(self, p: int = 0, G: Graph = None, betas: List[float] = None, gammas: List[float] = None,
mixer: str = "x", backend = Aer.get_backend('qasm_simulator'), measure: bool = True,
seed: int = None, verbose: bool = True):
"""Initialize class QAOA.
Args:
p (int): Positive number of QAOA layers. The default is 0.
G (Graph): A graph created with the Problem class used as MaxCut problem instance. The default is None.
betas (float): Angles for the mixer operator.
gammas (float): Angles for the cost operator.
mixer (str): Type of mixer operator to be used. The default is "x".
backend (Qiskit backend): Qiskit backend to execute the code on a quantum simulator.
The default is Aer.get_backend('qasm_simulator').
measure (bool): If True measure the qaoa circuit. The default is True.
seed (int): Seed for a pseudo-random number generator. The default is None.
verbose (bool): If True enters in debugging mode. The default is True.
"""
# Setup
self.p = p
self.G = G
self.mixer = mixer
self.backend = backend
self.measure = measure
self.verbose = verbose
self.seed = seed
self.problems_class = P.Problems(p_type="custom", G=self.G)
if self.seed is not None:
np.random.seed(self.seed)
if self.G is None:
self.N = 0
self.w = [[]]
self.betas = []
self.gammas = []
if self.G is not None:
self.N = G.get_number_of_nodes()
self.w = G.get_adjacency_matrix()
if betas is None or gammas is None:
self.betas = utils.generate_parameters(n=self.p, k=1)
self.gammas = utils.generate_parameters(n=self.p, k=2)
if betas is not None and gammas is not None:
self.betas = betas
self.gammas = gammas
# Checking...
if self.problems_class.__class__.__name__ != self.G.__class__.__name__ and G is not None:
raise Exception("Invalid parameters. The graph G should be created with the Problems class.")
if (self.p == 0 and self.G is not None) or (self.p > 0 and G is None):
raise ValueError("If G is not the empty graph p should be a strictly positive integer, and viceversa.")
if len(self.betas) != p or len(self.gammas) != p or len(self.betas) != len(self.gammas):
raise ValueError("Invalid angles list. The length of betas and gammas should be equal to p.")
# Initializing...
if self.verbose is True:
print(" --------------------------- ")
print("| Intializing Qaoa class... |".upper())
print(" --------------------------- ")
print("-> Getting problem instance...".upper())
if self.G is not None:
self.G.get_draw()
plt.show()
if self.G is None:
print("\t * G = ø")
if self.betas is None and self.G is not None:
print("-> Beta angles not provided. Generating angles...".upper())
print(f"\t * betas = {self.betas}")
if self.gammas is None and self.G is not None:
print("-> Gamma angles not provided. Generating angles...".upper())
print(f"\t * gammas = {self.gammas}")
print("-> Getting the ansatz...".upper())
if self.G is not None:
print(self.get_circuit())
if self.G is None:
print("\t * Qaoa circuit = ø")
print("-> The Qaoa class was initialized with the following parameters.".upper())
print(f"\t * Number of layers: p = {self.p};")
if self.G is None:
print(f"\t * Graph: G = ø;")
if self.G is not None:
print(f"\t * Graph: G = {self.G.p_type};")
print("\t * Angles:")
print(f"\t\t - betas = {self.betas};")
print(f"\t\t - gammas = {self.gammas};")
print(f"\t * Mixer Hamiltonian type: '{self.mixer}';")
print(f"\t * Random seed: seed = {self.seed};")
print(f"\t * Measurement setting: measure = {self.measure}.")
def cost_operator(self, gamma: float) -> QuantumCircuit:
"""Create an instance of the cost operator with angle 'gamma'.
Args:
gamma (float): Angle for the cost operator.
Returns:
QuantumCircuit: Circuit representing the cost operator.
"""
qc = QuantumCircuit(self.N, self.N)
for i,j in self.G.get_edges():
qc.cx(i, j)
qc.rz(gamma, j)
qc.cx(i, j)
return qc
def x_mixer_operator(self, beta: float) -> QuantumCircuit:
"""Create an instance of the x-mixer operator with angle 'beta'.
Args:
beta (float): Angle for the mixer operator.
Returns:
QuantumCircuit: Circuit representing the mixer operator.
"""
qc = QuantumCircuit(self.N, self.N)
for v in self.G.get_nodes():
qc.rx(beta, v)
return qc
def xx_mixer_operator(self, beta: float) -> QuantumCircuit:
"""Create an instance of the xx-mixer operator with angle 'beta'.
Args:
beta (float): Angle for the mixer operator.
Returns:
QuantumCircuit: Circuit representing the mixer operator.
"""
qc = QuantumCircuit(self.N, self.N)
for i, j in self.G.get_edges():
if self.w[i, j] > 0:
qc.rxx(beta, i, j)
return qc
def y_mixer_operator(self, beta: float) -> QuantumCircuit:
"""Create an instance of the y-mixer operator with angle 'beta'.
Args:
beta (float): Angle for the mixer operator.
Returns:
QuantumCircuit: Circuit representing the mixer operator.
"""
qc = QuantumCircuit(self.N, self.N)
for v in self.G.get_nodes():
qc.ry(2 * beta, v)
return qc
def yy_mixer_operator(self, beta: float) -> QuantumCircuit:
"""Create an instance of the yy-mixer operator with angle 'beta'.
Args:
beta (float): Time-slice angle for the mixer operator.
Returns:
QuantumCircuit: Circuit representing the mixer operator.
"""
qc = QuantumCircuit(self.N, self.N)
for i, j in self.G.get_edges():
if self.w[i, j] > 0:
qc.ryy(beta / 2, i, j)
return qc
def xy_mixer_operator(self, phi: float, psi: float) -> QuantumCircuit:
"""Create an instance of the xy-mixer operator with angle 'beta'.
Args:
beta (float): Angle for the mixer operator.
Returns:
QuantumCircuit: Circuit representing the mixer operator.
"""
qc = QuantumCircuit(self.N, self.N)
# X_iX_j
for i, j in self.G.get_edges():
if self.w[i, j] > 0:
qc.rxx(phi / 2, i, j)
# Y_iY_j
for i, j in self.G.get_edges():
if self.w[i, j] > 0:
qc.ryy(psi / 2, i, j)
return qc
def get_circuit(self) -> QuantumCircuit:
"""Create an instance of the Qaoa circuit with given parameters.
Returns:
QuantumCircuit: Circuit representing the Qaoa.
"""
qc = QuantumCircuit(self.N, self.N)
params = ParameterVector("params", 2 * self.p)
betas = params[0 : self.p]
gammas = params[self.p : 2 * self.p]
qc.h(range(self.N))
qc.barrier(range(self.N))
for i in range(self.p):
qc = qc.compose(self.cost_operator(gammas[i]))
qc.barrier(range(self.N))
if self.mixer == "x":
qc = qc.compose(self.x_mixer_operator(betas[i]))
qc.barrier(range(self.N))
elif self.mixer == "xx":
qc = qc.compose(self.xx_mixer_operator(betas[i]))
qc.barrier(range(self.N))
elif self.mixer == "y":
qc = qc.compose(self.y_mixer_operator(betas[i]))
qc.barrier(range(self.N))
elif self.mixer == "yy":
qc = qc.compose(self.yy_mixer_operator(betas[i]))
qc.barrier(range(self.N))
elif self.mixer == "xy":
qc = qc.compose(self.xy_mixer_operator(betas[i],betas[i]))
qc.barrier(range(self.N))
qc.barrier(range(self.N))
if self.measure:
qc.measure(range(self.N), range(self.N))
return qc
|
https://github.com/NesyaLab/qaoa
|
NesyaLab
|
import sys
import os
os.chdir("..")
import pickle
import networkx as nx
import matplotlib.pyplot as plt
from classes import Problems as P
current_path = os.path.abspath(os.curdir)
graphs_path = current_path + '/data/'
problems_path = current_path + '/classes/'
figures_path = current_path + '/figures/'
for i in range(16):
g = P.Problems(verbose=True)
path = graphs_path + "graph_"+str(i)+".nx"
with open(path, "wb") as fp:
pickle.dump(g, fp)
# Graphs
graphs = []
for i in range(16):
sys.path.append("classes/")
path = "data/graph_"+str(i)+".nx"
with open(path, 'rb') as f:
g = pickle.load(f)
graphs.append(g)
graphs[0].get_draw()
graphs[15].get_draw()
|
https://github.com/NesyaLab/qaoa
|
NesyaLab
|
import warnings
warnings.filterwarnings('ignore')
import os
path = os.getcwd()
os.chdir(os.path.dirname(path))
from classes import Problems
instance = Problems.Problems(verbose=True)
instance.get_draw()
print(instance.G == instance.get_graph())
print(instance.get_graph())
print(instance.G.nodes == instance.get_nodes())
print(instance.get_nodes())
print(instance.G.edges == instance.get_edges())
print(instance.get_edges())
print(instance.G.number_of_nodes() == instance.get_number_of_nodes())
print(instance.get_number_of_nodes())
print(instance.G.number_of_edges() == instance.get_number_of_edges())
print(instance.get_number_of_edges())
import networkx
print((networkx.to_numpy_array(instance.G) == instance.get_adjacency_matrix()).all())
print(instance.get_adjacency_matrix())
print(instance.get_adjacency_spectrum())
print(instance.get_laplacian())
print(instance.get_laplacian_spectrum())
print(instance.get_adjacency_dict())
from classes import Qaoa
p = 1
G = instance
qaoa = Qaoa.Qaoa(p, G)
gamma = 0
cost = qaoa.cost_operator(gamma)
print(cost)
beta = 0
mixer = qaoa.x_mixer_operator(beta)
print(mixer)
beta = 0
mixer = qaoa.xx_mixer_operator(beta)
print(mixer)
beta = 0
mixer = qaoa.y_mixer_operator(beta)
print(mixer)
beta = 0
mixer = qaoa.yy_mixer_operator(beta)
print(mixer)
phi = 0
psi = 2
mixer = qaoa.xy_mixer_operator(phi, psi)
print(mixer)
circuit = qaoa.get_circuit()
print(circuit)
|
https://github.com/NesyaLab/qaoa
|
NesyaLab
|
import warnings
warnings.filterwarnings('ignore')
import os
os.chdir('..')
from functions import maxcut_utilities
import networkx
from classes import Problems
G = networkx.Graph()
G.add_edges_from([[0,3],[0,4],[1,3],[1,4],[2,3],[2,4]])
instance = Problems.Problems(G=G)
maxcut = maxcut_utilities.compute_max_cut_exactly(instance)
print(maxcut)
counts = {'11000': 1, '00011': 29, '01011': 24}
rearranged_counts = maxcut_utilities.invert_counts(counts)
print(rearranged_counts)
cut_value = maxcut_utilities.get_maxcut_number_of_edges(instance,"10011")
print(-cut_value)
approximate_result = maxcut_utilities.compute_maxcut_energy(instance,counts)
print(approximate_result)
from classes import Qaoa
instance = Problems.Problems()
qaoa = Qaoa.Qaoa(p=3, G=instance)
from functions import qaoa_optimizers
init_point = qaoa.betas + qaoa.gammas
maxcut_value = qaoa_optimizers.objective_function(init_point,qaoa,shots=100)
print("energy", maxcut_value)
qaoa_optimizers.callback([])
x, f = qaoa_optimizers.simple_optimization(qaoa)
from functions import qaoa_utilities
two_random_angles = qaoa_utilities.generate_parameters(2,1)
print(two_random_angles)
#pip install --no-binary pynauty pynauty
from functions import symmetry_utilities
instance = Problems.Problems(G=G)
adjacency_dict = instance.get_adjacency_dict()
num_automorphisms = symmetry_utilities.get_number_of_automorphisms(G=instance, adjacency_dict=adjacency_dict)
print(num_automorphisms)
generators = symmetry_utilities.get_symmetry_generators(G=instance, adjacency_dict=adjacency_dict)
print(generators)
num_orbits, orbits = symmetry_utilities.get_symmetry_orbits(G=instance, adjacency_dict=adjacency_dict)
print(num_orbits, orbits)
|
https://github.com/NesyaLab/qaoa
|
NesyaLab
|
#------------------------------------------------------------------------------
# qaoa_optimizers.py
#
# This module provides optimization routines for Quantum Approximate Optimization
# Algorithm (QAOA) [1],[2] instances applied to the Maximum Cut (MaxCut) problem [3].
# The functions facilitate the optimization of QAOA parameters using classical
# optimization methods.
#
# The module includes the following functions:
# - objective_function(init_point, circuit, shots): Computes the objective
# function for QAOA by running the quantum circuit and evaluating the MaxCut
# energy.
# - callback(x): Callback function for counting the number of optimization steps
# during the optimization process.
# - simple_optimization(circuit, method='COBYLA', seed=None, shots=1024,
# verbose=True): Performs a simple optimization routine using a specified
# classical optimization method (default is 'COBYLA') and returns the optimized
# parameters and objective function value.
#
# Refs.
# [1] https://arxiv.org/abs/1411.4028
# [2] https://learning.quantum.ibm.com/tutorial/quantum-approximate-optimization-algorithm
# [3] https://en.wikipedia.org/wiki/Maximum_cut
#
# © Leonardo Lavagna 2024
# @ NESYA https://github.com/NesyaLab
#------------------------------------------------------------------------------
import random
import numpy as np
from typing import List, Tuple
from networkx import Graph
from qiskit import QuantumCircuit, transpile
from qiskit_aer import Aer
from scipy.optimize import minimize
from functions import maxcut_utilities as m_utils
from config import backend, verbose
num_evaluations = 0
def objective_function(init_point, circuit, shots):
# Setup
G = circuit.G
qc = circuit.get_circuit()
qc = qc.assign_parameters(init_point)
# Executing the circuit to get the energies...
t_qc = transpile(qc, backend=backend)
job = backend.run(t_qc, shots=shots)
counts = job.result().get_counts(qc)
# Getting the results...
energy = m_utils.compute_maxcut_energy(G, m_utils.invert_counts(counts), verbose=verbose)
return -energy
def callback(x: List):
"""
Function to be called at each iteration of the optimization step (in the minimize method) to count the number of optimization steps.
Args:
x (list): current solution of the optimization step
"""
global num_evaluations
num_evaluations += 1
def simple_optimization(circuit, method: str = 'COBYLA', seed: int = None, shots: int = 1024, verbose: bool = True) -> Tuple[np.ndarray, float]:
"""
Perform a simple optimization routine.
Args:
circuit (QuantumCircuit): Quantum circuit.
method (str): Type of optimizer. The default is 'COBYLA'.
seed (int): Seed needed for reproducibility. The default is None.
verbose (bool): If True enters in debugging mode. The default is False.
Returns:
tuple: Optimized parameters and corresponding objective function value.
"""
# Setup
betas = circuit.betas
gammas = circuit.gammas
init_point = list(betas) + list(gammas)
if verbose:
print(" --------------------------------- ")
print("| Parameters for the optimization. |".upper())
print(" --------------------------------- ")
print("\t * betas:", betas)
print("\t * gammas:", gammas)
print("\t * init_point:", init_point)
# Optimizing...
if verbose is True:
print(" --------------- ")
print("| Optimizing... |".upper())
print(" --------------- ")
optimizer = minimize(objective_function, init_point, args=(circuit,shots), callback=callback, method=method)
elif verbose is False:
optimizer = minimize(objective_function, init_point, args=(circuit,shots), method=method)
# Getting the results...
optimal_value = -optimizer.fun
optimal_angles = optimizer.x
if verbose:
print(" --------- ")
print("| Results. |".upper())
print(" --------- ")
print("\t * optimal_anlges:", optimal_angles)
print("\t * optimal_value:", optimal_value)
return optimizer.x, optimizer.fun
|
https://github.com/NesyaLab/qaoa
|
NesyaLab
|
import os
os.chdir("..")
from classes import Qaoa as Q
from classes import Problems as P
from functions import qaoa_utilities as qaoa_utils
from functions import maxcut_utilities as mcut_utils
from functions import qaoa_optimizers as optims
import numpy as np
import pickle
import sys
from config import *
# Graphs
graphs = []
for i in range(num_graphs):
sys.path.append("classes/")
path = "data/graph_"+str(i)+".nx"
with open(path, 'rb') as f:
g = pickle.load(f)
graphs.append(g)
# Select a graph
G = graphs[idx]
G.get_draw()
# Generate initial random angles
betas = qaoa_utils.generate_parameters(n=p, k=1, seed=seed)
gammas = qaoa_utils.generate_parameters(n=p, k=2, seed=seed)
# Instantiate QAOA
qaoa = Q.Qaoa(p=p, G=G, betas=betas, gammas=gammas, mixer=mixer, seed=seed, verbose=verbose)
qaoa.get_circuit().draw()
# QAOA execution (simple optimization)
_, f = optims.simple_optimization(qaoa, method=method, seed=seed, shots=shots, verbose=verbose)
_,f
|
https://github.com/RachaelC358/Quantum-Daemonum
|
RachaelC358
|
# Rachael Carpenter
# 1/9/2022
#
# Quantum Daemonum
# A simple game where you play as as a wicked spirit in a battle with
# Van Helsing who happens to have a quantum computer. Van Helsing will
# attempt to guess your true name in an attempt to gain power over and
# and defeat you. You can attempt to thwart him with spiritual attacks.
#
import random
import qiskit
from qiskit import ClassicalRegister, QuantumRegister, QuantumCircuit
from qiskit.providers.aer import QasmSimulator
import operator
import math
import numpy as np
# This function is called when its time to use the quantum simulator
def runGame(program):
shots = 100
# execute program on quantum simulator
job = qiskit.execute(program, qiskit.Aer.get_backend('qasm_simulator'), shots=shots)
result = job.result().get_counts()
return result
# utility function called by quantumGuess
def quantumProcessing(quessProcess, qreg, hiddenName):
# Convert hiddenName in binary from list to array
secretName = list(hiddenName)
# reverse order of bits
secretName.reverse()
indexList = []
# find indices of all zeroes
for i in range(len(secretName)):
if (secretName[i] == '0'):
indexList.append(i)
# Invert the 0s
for i in range(len(indexList)):
# find bits with a value of 0
anIndex = indexList[i]
# Invert qubit
quessProcess.x(qreg[anIndex])
# This function handles the quantum and classical registers and manipulates them
# to perform Grover's search algorithm.
def quantumGuess(hiddenName):
# 4-bit Grover's search to identify target index of 4 bits from list of all combinations of 4 bits
# create 2 qubits for input
qreg = QuantumRegister(4)
# these 2 registers take output
creg = ClassicalRegister(4)
guessProcess = QuantumCircuit(qreg, creg)
# place qubits into superposition, representing all possible outcomes(starting position)
guessProcess.h(qreg)
# Run quantumProcessing on key, inverting bits with value of zero
quantumProcessing(guessProcess, qreg, hiddenName)
#Grover's Algorithm
guessProcess.cp(np.pi / 4, qreg[0], qreg[3])
guessProcess.cx(qreg[0], qreg[1])
guessProcess.cp(-np.pi / 4, qreg[1], qreg[3])
guessProcess.cx(qreg[0], qreg[1])
guessProcess.cp(np.pi / 4, qreg[1], qreg[3])
guessProcess.cx(qreg[1], qreg[2])
guessProcess.cp(-np.pi / 4, qreg[2], qreg[3])
guessProcess.cx(qreg[0], qreg[2])
guessProcess.cp(np.pi / 4, qreg[2], qreg[3])
guessProcess.cx(qreg[1], qreg[2])
guessProcess.cp(-np.pi / 4, qreg[2], qreg[3])
guessProcess.cx(qreg[0], qreg[2])
guessProcess.cp(np.pi / 4, qreg[2], qreg[3])
#Reverse the earlier inversions by guessProcessing
quantumProcessing(guessProcess, qreg, hiddenName)
#Amplification
guessProcess.h(qreg)
guessProcess.x(qreg)
#apply grover's algorithm again for amplification
guessProcess.cp(np.pi / 4, qreg[0], qreg[3])
guessProcess.cx(qreg[0], qreg[1])
guessProcess.cp(-np.pi / 4, qreg[1], qreg[3])
guessProcess.cx(qreg[0], qreg[1])
guessProcess.cp(np.pi / 4, qreg[1], qreg[3])
guessProcess.cx(qreg[1], qreg[2])
guessProcess.cp(-np.pi / 4, qreg[2], qreg[3])
guessProcess.cx(qreg[0], qreg[2])
guessProcess.cp(np.pi / 4, qreg[2], qreg[3])
guessProcess.cx(qreg[1], qreg[2])
guessProcess.cp(-np.pi / 4, qreg[2], qreg[3])
guessProcess.cx(qreg[0], qreg[2])
guessProcess.cp(np.pi / 4, qreg[2], qreg[3])
# Reverse amplification
guessProcess.x(qreg)
guessProcess.h(qreg)
# Measure results
guessProcess.barrier(qreg)
guessProcess.measure(qreg, creg)
# 'results' can be printed to check for error
results = runGame(guessProcess)
foundName = max(results.items(), key=operator.itemgetter(1))[0]
# convert binary result to character array
resultArray = list(foundName)
# convert character array in integers
resultArrayInt = [int(i) for i in resultArray]
stringy = ''.join([str(item) for item in resultArrayInt])
#convert result to index in name array
myIndex = int(stringy, 2)
return myIndex
# list of names is accessed by index in list
def getDemonName(index):
demonNames = {
1:'Dusios',
2:'Belial',
3:'Belphegor',
4:'Andromalius',
5:'Astaroth',
6:'Beleth',
7:'Drekevac',
8:'Demiurge',
9:'Forneus',
10:'Gomory',
11:'Haures',
12:'Pithius',
13:'Mammon',
14:'Marchosias',
15:'Moloch',
16:'Naphula'
}
return demonNames.get(index)
# This function returns text based on game status variables.
def battleStatus(evil, good):
if good > 50 and good < 100 and evil <= 50:
return 'Dr. Van Helsing is fiddling will a strange quantum device. Your powers are weak.'
elif evil <= 50 and good == 100:
return 'A blast of light fills the cavern.'
elif good > 75:
return 'The quantum device is flickering with light and emits steam.'
elif evil <= 50 and good <= 50:
return 'Dr. Van Helsing is experiencing technical issues.'
elif evil == 100:
return 'Your are powers have returned.'
elif evil >= 50 and good >= 50:
return 'Your powers are growing stronger. The machine sparkling with electricity.'
# This function returns text that is printed describing effects after player input.
def statusChange(actionCode):
if actionCode == 5:
return ' '
elif actionCode == 4:
return 'The cavern glows with a red light.'
elif actionCode == 3:
return 'A thick fog fills the cavern.'
elif actionCode == 1:
return 'Nothing happens.'
# Processes main player input each turn.
def action(read):
read = str(read)
read = read.lower()
switcher = {
'p': 5, #possess, requires high evil
'd': 4, #duplici, increase evil,
'v': 3, #vaporum, decrease good, VH requires high good for quantum guess
#VH will increase good each turn until he can attack
'n': 1, #nothing
'q': 0 #quit
}
return switcher.get(read[0], -1)
# Processes player input at end of game.
def response(read):
read = str(read)
read = read.lower()
switcher = {
'y': 1,
'n': 0,
'q': 0
}
return switcher.get(read, -1)
# The main function; contains main game loop.
def main():
#print welcome message
print("")
print(" __ ___ __ ___ __")
print(" / \ | | /\ |\ | | | | |\/| | \ /\ |__ |\/| / \ |\ | | | |\/|")
print(" \__X \__/ /~~\ | \| | \__/ | | |__/ /~~\ |___ | | \__/ | \| \__/ | |")
print(" ~ A DARK GAME PLAYED AGAINST A SIMULATED QUANTUM COMPUTER ~\n\n")
print(" The year is 1887. You are a wicked spirit, evil personified, who is being hunted")
print(" by Van Helsing, the infamous slayer of unholy beasts. He will try to destroy you by")
print(" guessing your true name. You must stop him at any cost. A battle of magic and wits")
print(" begins! Van Helsing has you cornered in the caverns below Corvin Castle in Romania.")
print(" He performs the rites of excorcism while you have three spells.\n\n")
print(" Use keyboard commands to attempt to thwart Van Helsing, who makes guesses using")
print(" Grover's search algorithm, which runs on a quantum simulator.\n")
# controls main game loop which accomodates multiple interior loops for each round of play
quitGame = False
#Begin main loop of program
while not quitGame:
# pick the true name for this game from name array
playerName = random.randint(0, 15)
trueName = getDemonName(playerName + 1)
print(" Your true name is ... " + str(trueName) + "\n")
# convert player name index int to binary
secretBinary = format(playerName, "04b")
gameOver = False # controls whether main loop game runs
evil = 0 # evil level 100 allows posession to occur
good = 50 # good level 100 needed for quantum divination
loopControl = 1 # counts number of rounds of battle in each game
# controls for good and evil status/level changes
evilIncrease = -1
goodDecrease = -1
VHCasting = 5
# begin main loop for this round of play
while not gameOver and not quitGame:
# controls whether Van Helsing uses quantum guessing this round
VHActive = True
print(" +:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+\n")
# manage status changes for this turn
if VHCasting > 0:
good = good + random.randint(10,45)
if good > 100:
good = 100
if evilIncrease > -1:
evil = evil + random.randint(1,50)
evilIncrease = evilIncrease - 1
if evil > 100:
evil = 100
if goodDecrease > -1:
good = good - random.randint(1,40)
goodDecrease = goodDecrease - 1
if good < 0:
good = 0
# print stats for this round
roundStr = str(loopControl)
evilStr = str(evil)
print(" Round: ", roundStr.rjust(5))
print(" Evil : ", evilStr.rjust(5))
goodStr = str(good)
print(" Good : ", goodStr.rjust(5))
print("\n " + battleStatus(evil, good))
# this variable takes resulting index indicating the resulting name of quantum guess
VHResult = -1
#process on quantum simulator, VH will guess now
if VHActive and good == 100:
#let the computer guess
VHResult = quantumGuess(secretBinary)
#check player progress
if (VHResult != -1 and str(getDemonName(VHResult+1)) == str(trueName)):
gameOver = True
print(" The strange device spits out a slip of paper.")
print(" Van Helsing reads the paper aloud in a booming voice: \"" + getDemonName(VHResult+1) + "!\"")
print(" All your power is obliterated. GAME OVER.")
if VHResult != -1 and str(getDemonName(VHResult+1)) != str(trueName):
print(VHResult+1)
print(" The strange device spits out a slip of paper.")
print(" Van Helsing reads the paper aloud in a booming voice: \"" + getDemonName(VHResult+1) + "!\"")
print(" Quantum algorithms fail sometimes...")
# get player input for this turn
if gameOver == False:
read = '' # text of input will be stored here
while not read.lower() in ['p','d','v','f','n','q','possess','duplici','vaporum','nothing','quit']:
read = input("\n [Possess(p), Duplici(d), Vaporum(v), nothing(n), quit(q)]: ").lower()
#process input
actionCode = -1
actionCode = action(read)
if actionCode == 5: #possession
if evil == 100:
gameOver = True
print("\n Van Helsing's soul withers as you take over his physical form.")
print(" You destroy the machine and escape the cavern. THE END.")
else:
print("\n You are too weak to possess Van Helsing.")
elif actionCode == 4: # Duplici, evil increases for some random amount of turns
evilIncrease = random.randint(1, 5)
elif actionCode == 3: # Vaporum, good decreases for some random amount of turns
VHActive = False
goodDecrease = random.randint(1, 5)
elif actionCode == 0: # quit
quitGame = True
break
# report evil/good status changes from the last turn
print("\n " + statusChange(actionCode))
loopControl = loopControl + 1
# end game menu, take user input
if gameOver == True:
read = ''
while not read.lower() in ['y','n','q','yes','no','quit']:
#Read input from user
read = input("\n +:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+\n" +
" Do you want to play again?"+
"\n [yes(y), no(n), quit(q)]: ").lower()
#process input
actionCode = -1
actionCode = response(read)
if actionCode == 0:
quitGame = True
break
elif actionCode == 1:
loopControl = 1
gameOver == False
else:
print(" What?")
# run main function
if __name__ == "__main__":
main()
|
https://github.com/Dpbm/scientific-research-1-quantum-oracles
|
Dpbm
|
%matplotlib inline
from qiskit import QuantumCircuit
from utils import get_image_path
constant_oracle = QuantumCircuit(3)
constant_oracle.x([0, 2])
constant_oracle.draw('mpl', filename=get_image_path("constant-oracle.png"))
balanced_oracle = QuantumCircuit(3)
balanced_oracle.x([0, 2])
balanced_oracle.barrier()
balanced_oracle.cx(1, 2)
balanced_oracle.cx(0, 2)
balanced_oracle.barrier()
balanced_oracle.x([0, 2])
balanced_oracle.draw('mpl', filename=get_image_path("balanced-oracle.png"))
|
https://github.com/Dpbm/scientific-research-1-quantum-oracles
|
Dpbm
|
%matplotlib inline
from qiskit import QuantumCircuit, QuantumRegister, AncillaRegister, ClassicalRegister
from qiskit.compiler import transpile
from qiskit.visualization import plot_distribution, plot_histogram, plot_bloch_multivector
from qiskit.primitives import Sampler
from qiskit.quantum_info import Statevector
from qiskit.circuit import Parameter
from qiskit_aer import AerSimulator
from qiskit.quantum_info.operators import Operator
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
from utils import get_image_path
from scipy.optimize import minimize_scalar, OptimizeResult, minimize
from qiskit.providers.fake_provider import Fake20QV1
player_strategy = lambda bullets, fakes: "himself" if(bullets == fakes or fakes > bullets) else "shoot"
dealer_strategy = lambda bullets, fakes: "himself" if np.random.randint(2) else "shoot"
def gun(bullets, fakes) -> bool:
v = bullets + fakes
r = np.random.randint(1, v+1)
return r <= bullets
def play(strategies:dict, players:list, total_bullets:int, total_fakes:int, debug:bool=False) -> pd.DataFrame:
lives = {
"player":0,
"dealer":0
}
actual_player = players[0]
oponent = players[1]
rounds = 0
while(total_bullets):
player = strategies[actual_player]
action = player(total_bullets, total_fakes)
shot = gun(total_bullets, total_fakes)
if(debug):
print(f"playing: {actual_player}")
print(f"oponent: {oponent}")
print(f"action: {action}")
print(f"shot: {shot}")
if(action == "shoot" and shot):
lives[oponent] -=1
total_bullets -=1
actual_player = players[0]
oponent = players[1]
elif(action == "shoot" and not shot):
total_fakes -=1
actual_player,oponent = oponent,actual_player
elif(action == "himself" and shot):
lives[actual_player] -=1
total_bullets -=1
actual_player = players[0]
oponent = players[1]
else:
total_fakes -=1
if(debug):
print(lives, end="\n\n")
rounds += 1
if(lives['player'] > lives['dealer']):
return 'player', rounds
elif(lives['dealer'] > lives['player']):
return 'dealer', rounds
else:
return 'draw', rounds
play({"player":player_strategy, "dealer":dealer_strategy}, ("player", "dealer"), total_bullets=1, total_fakes=2, debug=True)
def get_experiment_results(n:int, players_strategies:dict, players:list, total_bullets:int, total_fakes:int):
df = pd.DataFrame(columns=("total_player", "total_dealer"))
n_rounds = pd.Series()
j = 1000
for i in range(n):
results = {"player":0, "dealer":0}
for _ in range(j):
result, rounds = play(players_strategies, players, total_bullets, total_fakes)
results[result]+=1
n_rounds.loc[j*i + j] = rounds
df.loc[i] = {"total_player":results['player'], "total_dealer":results['dealer']}
return df, n_rounds
df,rounds = get_experiment_results(n=1000, players_strategies={"player":player_strategy, "dealer":dealer_strategy}, players=("player", "dealer"), total_bullets=1, total_fakes=2)
print(rounds.value_counts())
sns.lineplot(data=df)
plt.savefig(get_image_path("first_classical_player_strategy.png"))
plt.show()
df,rounds = get_experiment_results(n=1000, players_strategies={"player":dealer_strategy, "dealer":dealer_strategy}, players=("player", "dealer"), total_bullets=1, total_fakes=2)
print(rounds.value_counts())
sns.lineplot(data=df)
plt.savefig(get_image_path("two_players_same_strategy.png"))
plt.show()
df,rounds = get_experiment_results(n=1000, players_strategies={"player":player_strategy, "dealer":player_strategy}, players=("player", "dealer"), total_bullets=1, total_fakes=2)
print(rounds.value_counts())
sns.lineplot(data=df)
plt.show()
def player_start_himself_strategy(bullets, fakes):
if(bullets == 1 and fakes == 2):
return 'himself'
elif(bullets == fakes):
return 'shoot' if np.random.randint(2) else "himself"
return 'shoot'
df,rounds = get_experiment_results(n=1000, players_strategies={"player":player_start_himself_strategy, "dealer":dealer_strategy}, players=("player", "dealer"), total_bullets=1, total_fakes=2)
print(rounds.value_counts())
sns.lineplot(data=df)
plt.show()
def player_optimal_strategy(bullets, fakes):
if(bullets == 1 and fakes == 2):
return 'shoot'
elif(bullets == fakes):
return 'shoot' if np.random.randint(2) else "himself"
return 'shoot'
df,rounds = get_experiment_results(n=3000, players_strategies={"player":player_optimal_strategy, "dealer":dealer_strategy}, players=("player", "dealer"), total_bullets=1, total_fakes=2)
print(rounds.value_counts())
sns.lineplot(data=df)
plt.savefig(get_image_path("optimal_player_strategy.png"))
plt.show()
df,rounds = play({"player":player_strategy, "dealer":dealer_strategy}, players=("player", "dealer"), total_bullets=1, total_fakes=2, debug=True)
rounds
# in the first strategy, there're some possible ways to finish the game
# player shoot himself (first round)
# dealer shoot himself (second round)
# dealer shoot the player (second round)
# player shoot (third round)
# so the player loses most part of the time
df,rounds = play({"player":player_start_himself_strategy, "dealer":dealer_strategy}, players=("player", "dealer"), total_bullets=1, total_fakes=2, debug=True)
rounds
# in the second strategy, there're some possible ways to finish the game
# player shoot himself (first round)
# player shoot himself (second round)
# player shoot the dealer (second round)
# dealer shoot the player (third round)
# dealer shoot himself (third round)
# so the player loses most part of the time
df,rounds = play({"player":player_optimal_strategy, "dealer":dealer_strategy}, players=("player", "dealer"), total_bullets=1, total_fakes=2, debug=True)
rounds
# in the third strategy, there're some possible ways to finish the game
# player shoot the dealer (first round)
# dealer shoot himself (second round)
# dealer shoot the player (second round)
# dealer shoot himself (third round)
# dealer shoot the player (third round)
# player shoot the dealer(third round)
# so the dealer loses most part of the time
# as in the first play the player chooses to shoot the dealer, he has more chances to live, once he's removed one of the dying chances
player = QuantumCircuit(1, name="Player")
player.h(0)
player.draw('mpl', style="clifford")
dealer = QuantumCircuit(1, name="Dealer")
dealer.h(0)
player.draw('mpl', style="clifford")
gun = QuantumCircuit(1, name="shoot")
gun.h(0)
gun.draw('mpl', style='clifford')
def buckshot_roulette(player, dealer, gun):
player_gate = player.to_gate()
player_controlled_gate = player.to_gate().control(1)
player_two_controlled_gate = player.to_gate().control(2)
dealer_controlled_gate = dealer.to_gate().control(1)
dealer_two_controlled_gate = dealer.to_gate().control(2)
gun_controlled_gate = gun.to_gate().control(1)
gun_two_controlled_gate = gun.to_gate().control(2)
player_life = QuantumRegister(3, name="p")
dealer_life = QuantumRegister(3, name="d")
game = QuantumRegister(3, name="game")
player_life_out = ClassicalRegister(3, name="po")
dealer_life_out = ClassicalRegister(3, name="do")
aux = AncillaRegister(1, name="aux")
qc = QuantumCircuit(game, aux, player_life, dealer_life, player_life_out, dealer_life_out)
qc.append(player.copy(), [game[0]])
qc.x(game[0])
qc.append(gun_controlled_gate.copy(), [game[0], player_life[0]])
qc.x(game[0])
qc.append(gun_controlled_gate.copy(), [game[0], dealer_life[0]])
#next_player
# 0 = player, 1 = dealer
qc.barrier()
qc.append(dealer_controlled_gate, [game[0], game[1]])
qc.x(game[0])
qc.append(player_controlled_gate, [game[0], game[1]])
qc.x(game[0])
qc.barrier()
qc.x(game[1])
qc.append(gun_two_controlled_gate, [game[0], game[1], dealer_life[1]])
qc.x(game[0])
qc.append(gun_two_controlled_gate, [game[0], game[1], player_life[1]])
qc.x(game[0])
qc.x(game[1])
qc.append(gun_two_controlled_gate, [game[0], game[1], player_life[1]])
qc.x(game[0])
qc.append(gun_two_controlled_gate, [game[0], game[1], dealer_life[1]])
qc.x(game[0])
qc.barrier()
qc.append(player_two_controlled_gate, [game[0], game[1], game[2]])
qc.x(game[1])
qc.append(dealer_two_controlled_gate, [game[0], game[1], game[2]])
qc.ccx(game[0], game[1], aux)
qc.x(game[1])
qc.x(game[0])
qc.append(dealer_two_controlled_gate, [game[0], game[1], game[2]])
qc.ccx(game[0], game[1], aux)
qc.x(game[0])
qc.x([game[0], game[1]])
qc.append(player_two_controlled_gate, [game[0], game[1], game[2]])
qc.x([game[0], game[1]])
qc.barrier()
qc.append(gun_two_controlled_gate, [aux, game[2], player_life[2]])
qc.x(game[2])
qc.append(gun_two_controlled_gate, [aux, game[2], dealer_life[2]])
qc.x(game[2])
qc.x(aux)
qc.append(gun_two_controlled_gate, [aux, game[2], dealer_life[2]])
qc.x(game[2])
qc.append(gun_two_controlled_gate, [aux, game[2], player_life[2]])
qc.x(aux)
qc.barrier()
qc.measure(player_life, player_life_out)
qc.measure(dealer_life, dealer_life_out)
return qc
qc = buckshot_roulette(player, dealer, gun)
qc.draw('mpl', style="clifford", filename=get_image_path("quantum_buckshot_roulette.png"))
sim = AerSimulator()
transpiled_qc = transpile(buckshot_roulette(player, dealer, gun), sim)
result = sim.run(transpiled_qc, shots=1000).result().get_counts()
plot_histogram(result)
def parse_results(results):
wins = {'dealer':0, 'player':0}
for d,v in results.items():
#v_bin = f"{v:06b}"
if(d.count("1") > 3):
continue
bin_dealer, bin_player = d[:3], d[4:]
#first_match
first_dealer, first_player = bin_dealer[-1], bin_player[-1]
#second_match
second_dealer, second_player = bin_dealer[-2], bin_player[-2]
#third_match
third_dealer, third_player = bin_dealer[-3], bin_player[-3]
if(first_dealer != first_player):
winner = "dealer" if first_dealer == '0' else "player"
wins[winner]+=v
continue
if(second_dealer != second_player):
winner = "dealer" if second_dealer == '0' else "player"
wins[winner]+=v
continue
if(third_dealer != third_player):
winner = "dealer" if third_dealer == '0' else "player"
wins[winner]+= v
continue
return wins
parse_results(result)
player_2 = QuantumCircuit(1)
player_2.ry(np.pi/4, 0)
player_2.draw('mpl', style='clifford')
plot_bloch_multivector(player_2)
sim = AerSimulator()
transpiled_qc = transpile(buckshot_roulette(player_2, dealer, gun), sim)
result = sim.run(transpiled_qc, shots=1000).result().get_counts()
plot_histogram(result)
parse_results(result)
def obj(x, sim, shots):
player_var = QuantumCircuit(1)
theta = Parameter('theta')
phi = Parameter('phi')
lam = Parameter('lambda')
player_var.u(theta, phi, lam, 0)
player_var = player_var.assign_parameters({theta:x[0], phi:x[1], lam:x[2]})
qc = buckshot_roulette(player_var, dealer, gun)
transpiled_qc = transpile(qc, sim)
result = sim.run(transpiled_qc, shots=shots).result().get_counts()
parsed_result = parse_results(result)
print(parsed_result, x)
return parsed_result['dealer']
minimized = minimize(
x0=[0, 0, 0],
bounds=[(0, np.pi), (0, 2*np.pi), (0,None)],
fun=obj,
args=(AerSimulator(), 1000),
method="COBYLA")
minimized
player_optimal = QuantumCircuit(1)
player_optimal.u(minimized.x[0], minimized.x[1],0, 0)
display(player_optimal.draw('mpl', style='clifford'))
qc = buckshot_roulette(player_optimal, dealer, gun)
transpiled_qc = transpile(qc, sim)
result = sim.run(transpiled_qc, shots=1000).result().get_counts()
display(plot_bloch_multivector(player_optimal))
plot_histogram(parse_results(result))
def obj(x, sim, shots):
player_var = QuantumCircuit(1)
theta = Parameter('theta')
player_var.ry(theta, 0)
player_var = player_var.assign_parameters({theta:x})
qc = buckshot_roulette(player_var, dealer, gun)
transpiled_qc = transpile(qc, sim)
result = sim.run(transpiled_qc, shots=shots).result().get_counts()
parsed_result = parse_results(result)
print(parsed_result, x)
return parsed_result['dealer']
def custom_minimizer(fun, args, **kwargs):
bounds = kwargs['bounds']
best_x = 0
best_y = 100000
rounds = 0
for v in np.arange(bounds[0], bounds[1], 0.01):
y = fun(v,args[0], args[1])
if(y < best_y):
best_y = y
best_x = v
rounds+=1
print(best_x, best_y)
return OptimizeResult(fun=best_y, x=best_x, nit=0, nfev=rounds, success=True)
minimized = minimize_scalar(
fun=obj,
bounds=(0, 2*np.pi),
args=(AerSimulator(), 1000),
method=custom_minimizer)
minimized
player_optimal = QuantumCircuit(1)
player_optimal.ry(minimized.x, 0)
display(player_optimal.draw('mpl', style='clifford'))
qc = buckshot_roulette(player_optimal, dealer, gun)
transpiled_qc = transpile(qc, sim)
result = sim.run(transpiled_qc, shots=1000).result().get_counts()
plot_histogram(parse_results(result))
def obj(x, sim, shots):
player_var = QuantumCircuit(1)
theta = Parameter('theta')
phi = Parameter('phi')
player_var.u(theta, phi, 0, 0)
player_var = player_var.assign_parameters({theta:x[0], phi:x[1]})
qc = buckshot_roulette(player_var, dealer, gun)
transpiled_qc = transpile(qc, sim)
result = sim.run(transpiled_qc, shots=shots).result().get_counts()
parsed_result = parse_results(result)
print(parsed_result, x)
return parsed_result['dealer']
def custom_minimizer(fun, x0, args, **kwargs):
bounds = kwargs['bounds']
best_x = []
best_y = 100000
rounds = 0
for i in np.arange(bounds[0][0], bounds[0][1], 0.1):
for j in np.arange(bounds[1][0], bounds[1][1], 0.1):
y = fun([i, j], args[0], args[1])
if(y < best_y):
best_y = y
best_x = [i, j]
rounds+=1
print(best_x, best_y)
return OptimizeResult(fun=best_y, x=best_x, nit=0, nfev=rounds, success=True)
minimized = minimize(
x0=[0, 0],
bounds=[(np.pi/4, np.pi), (np.pi/4, 2*np.pi)],
fun=obj,
args=(AerSimulator(), 1000),
method=custom_minimizer)
minimized
player_optimal = QuantumCircuit(1)
#player_optimal.u(minimized.x[0], minimized.x[1],0, 0)
player_optimal.u(3.0853981633974477, 3.7853981633974474,0, 0)
display(player_optimal.draw('mpl', style='clifford'))
plot_bloch_multivector(player_optimal, filename=get_image_path("player_optimal_strategy_bloch.png"))
sim = AerSimulator()
qc = buckshot_roulette(player_optimal, dealer, gun)
transpiled_qc = transpile(qc, sim)
result = sim.run(transpiled_qc, shots=1000).result().get_counts()
parsed_results = parse_results(result)
plt.bar(x=['dealer', 'player'], height=list(parsed_results.values()))
plt.ylabel("counts")
plt.savefig(get_image_path("final_buckshot_roulette_quantum_optimal_strategy.png"))
plt.show()
plot_histogram(result, filename=get_image_path("final_buckshot_roulette_quantum_optimal_strategy_bit_strings.png"))
plot_histogram(result)
transpiled = transpile(buckshot_roulette(player_optimal, dealer, gun), backend=Fake20QV1(), optimization_level=3)
transpiled.depth()
exp_result = Fake20QV1().run(transpiled, shots=1000).result().get_counts()
exp_result
plot_histogram(exp_result, filename=get_image_path("final_buckshot_roulette_quantum_optimal_strategy_bit_strings_Fake20QV1.png"))
plot_histogram(exp_result)
parsed_results = parse_results(exp_result)
plt.bar(x=['dealer', 'player'], height=list(parsed_results.values()))
plt.ylabel("counts")
plt.savefig(get_image_path("final_buckshot_roulette_quantum_optimal_strategy_Fake20QV1.png"))
plt.show()
|
https://github.com/Dpbm/scientific-research-1-quantum-oracles
|
Dpbm
|
%matplotlib inline
from qiskit import QuantumCircuit, transpile
from qiskit.visualization import plot_histogram, array_to_latex
from qiskit.circuit.library import QFT, GroverOperator
from qiskit.primitives import Sampler
from qiskit_aer import AerSimulator
from math import pi, sqrt, sin
import matplotlib.pyplot as plt
from itertools import product
import pandas as pd
import functools
from utils import get_image_path
from utils import fibonacci as recursive_fibonacci
from tqdm.notebook import tqdm_notebook
def simulate(qc, shots=1000, backend=AerSimulator()):
transpiled_circuit = transpile(qc, backend) if not isinstance(backend, Sampler) else qc
return backend.run(transpiled_circuit, shots=shots)
def get_counts(job):
return job.result().get_counts()
def fibonacci(n):
qc = QuantumCircuit(n)
qc.ry(pi/2, range(n))
if(n > 1):
for i in range(0, n-1):
qc.cry(-pi/2, i, i+1)
return qc
qc = fibonacci(4)
qc.measure_all()
qc.draw('mpl', filename=get_image_path("fibonacci-circuit.png"))
job = simulate(qc)
counts = get_counts(job)
def complete_results(counts):
results = {}
for bit_string in product('01', repeat=len(qc.qubits)):
bit_string = ''.join(bit_string)
results[bit_string] = 0 if counts.get(bit_string) is None else counts[bit_string]
return results
fig= plot_histogram(complete_results(counts))
fig.savefig(get_image_path('fibonacci-4.png'))
display(fig)
def get_fibonacci_number(counts):
return len(counts)
# F(4)
get_fibonacci_number(counts)
def evaluate_fibonacci_quantum(n, shots=1000):
qc = fibonacci(n)
qc.measure_all()
job = simulate(qc, shots=shots)
counts = get_counts(job)
return get_fibonacci_number(counts)
x_values = list(range(1,15))
y_values = {"classical":[recursive_fibonacci(n+1) for n in x_values], "quantum":[]}
def comparation(shots=1000):
y_values["quantum"] = []
for n in x_values:
y_values["quantum"].append(evaluate_fibonacci_quantum(n, shots))
return y_values
y_values_1000 = comparation(shots=1000)
y_values_4000 = comparation(shots=4000)
y_values_6000 = comparation(shots=6000)
x = pd.Series(x_values)
y_1000 = pd.DataFrame(y_values_1000)
y_4000 = pd.DataFrame(y_values_4000)
y_6000 = pd.DataFrame(y_values_6000)
f, (ax1, ax2, ax3) = plt.subplots(1, 3, sharey=True, figsize=(30, 10))
#plt.title("Comparation between quantum and classical Fibonacci algorithm")
ax1.plot(x, y_1000)
ax1.legend(labels=["classical", "quantum"])
ax1.set_title("shots=1000")
ax2.plot(x, y_4000)
ax2.legend(labels=["classical", "quantum"])
ax2.set_title("shots=4000")
ax3.plot(x, y_6000)
ax3.legend(labels=["classical", "quantum"])
ax3.set_title("shots=6000")
plt.show()
f.savefig(get_image_path('comparation.png'))
def fibonacci_oracle(n):
qc = QuantumCircuit(n, name="oracle")
#from https://arxiv.org/pdf/2006.10656.pdf
predicate = lambda k: k & k >> 1 == 0
max_value = int('1'*n, 2)
for k in range(max_value):
if(predicate(k)):
bit_string = format(k, 'b').zfill(n)[::-1]
zeros = [index for index, bit in enumerate(bit_string) if bit == '0' ]
qc.x(zeros)
qc.mcp(pi, list(range(1, n)), 0)
qc.x(zeros)
return qc
def show_unitary(qc):
sim = AerSimulator()
qc_unitary = qc.copy()
qc_unitary.save_unitary()
unitary = sim.run(transpile(qc_unitary, sim), shots=1000).result().get_unitary()
display(array_to_latex(unitary, max_size=100000))
n = 4
oracle = fibonacci_oracle(n)
show_unitary(oracle)
oracle.draw('mpl')
def create_grover_operator(n_iterations, oracle):
grover = GroverOperator(oracle, name="grover").repeat(n_iterations).to_gate().control()
return grover
def create_qft_dagger(n):
return QFT(n, inverse=True).to_gate(label="QFT†")
def create_quantum_couting_algorithm(n, oracle):
total_qubits = n*2
qc = QuantumCircuit(total_qubits, n)
qc.h(range(total_qubits))
iterations = 1
for qubit in range(n):
qc.append(create_grover_operator(iterations, oracle), [qubit] + list(range(n, total_qubits)))
iterations *= 2
qc.append(create_qft_dagger(n), list(range(n)))
qc.measure(range(n), range(n))
return qc
qc = create_quantum_couting_algorithm(n, oracle)
qc.draw('mpl', filename=get_image_path("quantum_counting.png"))
def get_dist(job):
dists = job.result().quasi_dists
print(dists)
return dists[0]
def get_total_results(dist):
measured_str = max(dist, key=dist.get)
theta = (measured_str/(2**n))*pi*2
N = 2 ** n
M = N * (sin(theta/2)**2)
return M
def evaluate_fibonacci_quantum_2(n, shots):
progress = tqdm_notebook(total=3)
oracle = fibonacci_oracle(n)
progress.update(1)
qc = create_quantum_couting_algorithm(n, oracle)
progress.update(1)
dist = get_dist(simulate(qc, backend=Sampler()))
progress.update(1)
return get_total_results(dist)
x_values = list(range(2,7))
y_values = {"classical":[recursive_fibonacci(n+1) for n in x_values], "quantum":[]}
def comparation_2(shots=1000):
y_values["quantum"] = []
for n in x_values:
y_values["quantum"].append(evaluate_fibonacci_quantum_2(n, shots))
return y_values
y_values_1000 = comparation_2(shots=1000)
y_values_4000 = comparation_2(shots=4000)
y_values_6000 = comparation_2(shots=6000)
y_values_10000 = comparation_2(shots=10000)
x = pd.Series(x_values)
y_1000 = pd.DataFrame(y_values_1000)
y_4000 = pd.DataFrame(y_values_4000)
y_6000 = pd.DataFrame(y_values_6000)
y_10000 = pd.DataFrame(y_values_10000)
f, ax = plt.subplots(2, 2, sharey=True, figsize=(30, 10))
ax1 = ax[0][0]
ax2 = ax[0][1]
ax3 = ax[1][0]
ax4 = ax[1][1]
#plt.title("Comparation between quantum and classical Fibonacci algorithm")
ax1.plot(x, y_1000)
ax1.legend(labels=["classical", "quantum"])
ax1.set_title("shots=1000")
ax2.plot(x, y_4000)
ax2.legend(labels=["classical", "quantum"])
ax2.set_title("shots=4000")
ax3.plot(x, y_6000)
ax3.legend(labels=["classical", "quantum"])
ax3.set_title("shots=6000")
ax4.plot(x, y_10000)
ax4.legend(labels=["classical", "quantum"])
ax4.set_title("shots=10000")
plt.show()
f.savefig(get_image_path('comparation2.png'))
|
https://github.com/Dpbm/scientific-research-1-quantum-oracles
|
Dpbm
|
%matplotlib inline
import os
import shutil
import numpy as np
import pandas as pd
import random
import matplotlib.pyplot as plt
import seaborn as sns
from string import ascii_lowercase
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, transpile
from qiskit.quantum_info import Statevector
from qiskit.visualization import array_to_latex, plot_distribution, plot_histogram, plot_bloch_multivector
from qiskit_algorithms import AmplificationProblem, Grover
from qiskit.circuit.library import CPhaseGate
from qiskit.primitives import Sampler
from qiskit_aer import AerSimulator
from utils import get_image_path
def random_file_name(size=5):
return ''.join(random.sample(list(ascii_lowercase), size))
def create_test_folder(folder):
if(os.path.exists(folder)):
print("Path already exists")
print(f"Removing {folder}")
shutil.rmtree(folder, ignore_errors=True)
print(f"Creating: {folder}")
os.mkdir(folder)
def create_test_files(folder, n=5):
create_test_folder(folder)
for _ in range(n):
file = random_file_name()+".txt"
try:
print(f"creating file: {file}")
file_path = os.path.join(folder, file)
file = open(file_path, "a")
file.close()
except Exception as error:
print(f"Failed creating {file}")
test_folder = os.path.join('.', 'files-test')
create_test_files(test_folder)
files = os.listdir(test_folder)
files
selected_file = files[random.randint(0,len(files))]
selected_file
def classical_method_1(files, target):
#in this example, we are ignoring the extension
#just for this case, in real life a good idea is to use the entire name, or a hash of it
#unsing no type of lookup table, or sorting, the algorithm takes O(n)
total_tests = 0
for file in files:
total_tests += 1
print(f"total tests: {total_tests}")
if(file == target):
print("found file")
break
classical_method_1(files, selected_file)
def classical_method_2(files, target):
# this should be done after adding a file into the filesystem
# it takes O(1) for adding a new file, O(n) for adding n files and O(1) for searching
lut = {}
for file in files:
file_hash = hash(file)
lut[file_hash] = file
target_hash = hash(target)
if lut.get(target_hash):
print("File found")
else:
print("File doesnt exists in the filesystem")
classical_method_2(files, selected_file)
n_qubits = int(np.ceil(np.log2(len(files))))
def encoding_files_to_oracle(n_qubits, files):
oracle = QuantumCircuit(n_qubits, name="LUT")
encoded_bin = [bin(i)[2:].zfill(n_qubits)[::-1] for i in range(len(files))]
for encoded in encoded_bin:
x_positions = [i for i,char in enumerate(encoded) if char == '0']
oracle.x(x_positions)
oracle.mcp(np.pi, list(range(1,n_qubits)), 0)
oracle.x(x_positions)
return encoded_bin,oracle
binary,oracle = encoding_files_to_oracle(n_qubits,files)
oracle.draw('mpl', filename=get_image_path("look-up-table.png"))
def get_oracle_overload(files, targets):
oracle = QuantumCircuit(n_qubits, name="$LUT^{-1}$")
encode = lambda x,n: bin(x)[2:].zfill(n)[::-1]
encoded_bin = [encode(i,n_qubits) for i, file in enumerate(files) if file not in targets]
for encoded in encoded_bin:
x_positions = [i for i,char in enumerate(encoded) if char == '0']
oracle.x(x_positions)
oracle.mcp(np.pi, list(range(1,n_qubits)), 0)
oracle.x(x_positions)
return encoded_bin,oracle
lut_binary,oracle = encoding_files_to_oracle(n_qubits,files)
unvalid_states,oracle_inv = get_oracle_overload(files, [selected_file])
good_state = list(set(lut_binary) - set(unvalid_states))
n_qubits = len(oracle.qubits)
qc = QuantumCircuit(n_qubits)
qc.append(oracle, range(n_qubits))
qc.barrier(label="LUT")
qc.append(oracle_inv, range(n_qubits))
qc.draw('mpl', filename=get_image_path("sets-difference-look-up-table-oracle.png"))
qc.decompose().draw('mpl')
Statevector(qc).draw('latex')
qc_copy = qc.copy()
qc_copy.save_unitary()
sim = AerSimulator()
unitary = sim.run(transpile(qc_copy, sim)).result().get_unitary()
array_to_latex(unitary, max_size=10000)
problem = AmplificationProblem(qc, is_good_state=good_state)
problem.grover_operator.decompose().draw(output='mpl', filename=get_image_path("classical_grover_file_search.png"))
grover = Grover(sampler=Sampler())
result = grover.amplify(problem)
result.top_measurement
qc = QuantumCircuit(3)
qc.h(range(3))
qc.compose(problem.grover_operator.decompose(), range(3), inplace=True)
qc.draw('mpl', filename=get_image_path("file_explorer.png"))
sim = AerSimulator()
qc_copy = qc.copy()
qc_copy.measure_all()
aer_result = sim.run(transpile(qc_copy, sim), shots=1000).result().get_counts()
plot_histogram(aer_result, filename=get_image_path('AER_file_explorer_result.png'))
def create_new_grover(file):
n_qubits = int(np.ceil(np.log2(len(files))))
lut_binary, oracle = encoding_files_to_oracle(n_qubits,files)
unvalid_states,oracle_inv = get_oracle_overload(files, [file])
good_state = list(set(lut_binary) - set(unvalid_states))
print('good state: ', good_state)
t_qubits = len(oracle.qubits)
final_oracle = QuantumCircuit(t_qubits)
final_oracle.append(oracle, range(t_qubits))
final_oracle.barrier(label="LUT")
final_oracle.append(oracle_inv, range(t_qubits))
total_zeros = good_state[0].count('0')
"""
angles from the grover tests
000 1.013620
001 1.385071
010 1.479508
011 1.680972
100 1.397662
101 1.712451
110 1.699860
111 2.058719
"""
angles = {
"000":1.013620,
"001":1.385071,
"010":1.479508,
"011":1.680972,
"100":1.397662,
"101":1.712451,
"110":1.699860,
"111":2.058719
}
problem = AmplificationProblem(final_oracle, is_good_state=good_state)
qc = QuantumCircuit(t_qubits)
qc.ry(angles[good_state[0]], range(t_qubits))
qc.compose(problem.grover_operator.decompose(), range(t_qubits), inplace=True)
return qc
new_qc = create_new_grover(selected_file)
new_qc.draw('mpl', filename=get_image_path("improved_file_explorer.png"))
sim = AerSimulator()
qc_copy = new_qc.copy()
qc_copy.measure_all()
aer_result = sim.run(transpile(qc_copy, sim), shots=1000).result().get_counts()
hist = plot_histogram(aer_result)
plt.savefig(get_image_path("AER-file-explorer-hist-new-grover-mapped-rotations.png"))
display(hist)
x = np.array(list(range(0, 60)), dtype=np.int64)
classical_find = lambda x: x
classical_lut = lambda x: 1
quantum = lambda x: np.sqrt(x)
vec_cf = np.vectorize(classical_find)
vec_cl = np.vectorize(classical_lut)
vec_q = np.vectorize(quantum)
y_classical_f = vec_cf(x)
y_classical_l = vec_cl(x)
y_quantum = vec_q(x)
df = pd.DataFrame({"x":x, "cf":y_classical_f, "cl":y_classical_l, "q":y_quantum})
df.head()
plot = sns.lineplot(data=pd.melt(df, ["x"]), x="x", y="value", hue="variable", palette="flare")
legend = plot.axes.get_legend()
legend.set_title("O(x) comparation")
for old, new in zip(legend.texts, ["classical find = O(n)", "classical LUT = O(1)", "quantum = O(√N)"]):
old.set_text(new)
plt.savefig(get_image_path("algorithms-finding-comparation.png"))
plt.show(plot)
def get_result(qc, sim=AerSimulator()):
g_copy = qc.copy()
g_copy.measure_all()
sim = AerSimulator()
return sim.run(transpile(g_copy, sim), shots=1000).result().get_counts()
def new_g(superposition, oracle):
qc = QuantumCircuit(3)
qc.append(superposition, range(3))
qc.append(oracle, range(3))
qc.h(range(3))
qc.x(range(3))
qc.h(-1)
qc.ccx(0, 1,2)
qc.h(-1)
qc.x(range(3))
qc.h(range(3))
return qc
oracle = QuantumCircuit(3, name="oracle")
oracle.ccz(0, 1,2)
oracle.draw('mpl')
s = QuantumCircuit(3, name="s")
s.ry(np.pi/3, range(3))
display(s.draw('mpl'))
plot_bloch_multivector(s)
qc = new_g(s, oracle)
qc.draw('mpl')
plot_histogram(get_result(qc))
oracle = QuantumCircuit(3, name="oracle")
oracle.x(range(3))
oracle.ccz(0, 1,2)
oracle.x(range(3))
oracle.draw('mpl')
qc = new_g(s, oracle)
plot_histogram(get_result(qc))
oracle = QuantumCircuit(3, name="oracle")
oracle.x(range(3))
oracle.ccz(0, 1,2)
oracle.x(range(3))
oracle.ccz(0,1,2)
oracle.x(0)
oracle.ccz(0,1,2)
oracle.x(0)
oracle.draw('mpl')
qc = new_g(s, oracle)
plot_histogram(get_result(qc))
oracle = QuantumCircuit(3, name="oracle")
oracle.x(0)
oracle.ccz(0,1,2)
oracle.x(0)
oracle.x(range(3))
oracle.ccz(0, 1,2)
oracle.x(range(3))
oracle.ccz(0,1,2)
oracle.draw('mpl')
qc = new_g(s, oracle)
plot_histogram(get_result(qc))
oracle = QuantumCircuit(3, name="oracle")
oracle.x(0)
oracle.ccz(0,1,2)
oracle.x(0)
oracle.draw('mpl')
qc = new_g(s, oracle)
plot_histogram(get_result(qc))
sim = AerSimulator()
def find_best_angle(encoded_bit_string, oracle):
max_ = 0
best_angle = 0
for angle in np.linspace(0, np.pi, num=120):
s = QuantumCircuit(3)
s.ry(angle, range(3))
qc = new_g(s, oracle)
qc.measure_all()
result = sim.run(transpile(qc, sim), shots=1000).result().get_counts()
if(not result.get(encoded_bit_string)):
continue
result = result[encoded_bit_string]
if(result > max_):
max_ = result
best_angle = angle
print(angle, result)
return best_angle, max_
oracle = QuantumCircuit(3)
oracle.x(0)
oracle.ccz(0,1,2)
oracle.x(0)
best_angle, max_ = find_best_angle('110', oracle)
best_angle, max_
np.degrees(best_angle)
np.pi/4
(np.pi*11)/20
np.pi - ((np.pi*10)/18) - (np.pi/4)
qc = QuantumCircuit(1)
qc.ry(best_angle, 0)
plot_bloch_multivector(qc)
s = QuantumCircuit(3, name="S")
s.ry(best_angle, range(3))
oracle = QuantumCircuit(3, name="oracle")
oracle.x(0)
oracle.ccz(0,1,2)
oracle.x(0)
qc = new_g(s, oracle)
qc.draw('mpl')
plot_histogram(get_result(qc))
s = QuantumCircuit(3, name="S")
s.ry(best_angle, range(3))
oracle = QuantumCircuit(3, name="oracle")
oracle.ccz(0,1,2)
qc = new_g(s, oracle)
plot_histogram(get_result(qc))
s = QuantumCircuit(3, name="S")
s.ry(best_angle, range(3))
oracle = QuantumCircuit(3, name="oracle")
#oracle.ccz(0,1,2)
oracle.x(range(3))
oracle.ccz(0,1,2)
oracle.x(range(3))
oracle.x(0)
oracle.ccz(0,1,2)
oracle.x(0)
qc = new_g(s, oracle)
plot_histogram(get_result(qc))
oracle = QuantumCircuit(3, name="oracle")
oracle.ccz(0,1,2)
oracle.x(range(3))
oracle.ccz(0,1,2)
oracle.x(range(3))
oracle.x(0)
oracle.ccz(0,1,2)
oracle.x(0)
oracle.x(0)
oracle.x(1)
oracle.ccz(0,1,2)
oracle.x(0)
oracle.x(1)
qc = new_g(s, oracle)
plot_histogram(get_result(qc))
oracle = QuantumCircuit(3, name="oracle")
oracle.ccz(0,1,2)
oracle.x(range(3))
oracle.ccz(0,1,2)
oracle.x(range(3))
oracle.draw('mpl')
problem = AmplificationProblem(oracle, is_good_state=['000', '111'])
problem.grover_operator.decompose().draw(output='mpl')
grover = Grover(sampler=Sampler())
result = grover.amplify(problem)
result.circuit_results, result.iterations
qc = QuantumCircuit(3)
qc.h(range(3))
qc.compose(problem.grover_operator.decompose(), inplace=True)
qc.draw('mpl')
plot_histogram(get_result(qc))
oracle = QuantumCircuit(3, name="oracle")
oracle.x(0)
oracle.ccz(0,1,2)
oracle.x(0)
problem = AmplificationProblem(oracle, is_good_state=['110'])
problem.grover_operator.decompose().draw(output='mpl')
grover = Grover(sampler=Sampler())
result = grover.amplify(problem)
result.circuit_results, result.iterations
def p_oracle(bit_string):
bit_string = bit_string[::-1]
zeros = [i for i, v in enumerate(bit_string) if v == '0']
qc = QuantumCircuit(3)
if(zeros):qc.x(zeros)
qc.ccz(0,1,2)
if(zeros):qc.x(zeros)
return qc
p_oracle('001').draw('mpl')
best_angle
def compare(best_angle):
for b in ['000', '001', '010', '011', '100', '101', '110', '111']:
oracle = p_oracle(b)
s = QuantumCircuit(3, name="S")
s.ry(best_angle, range(3))
new = new_g(s, oracle)
old_problem = AmplificationProblem(oracle, is_good_state=[b])
old = QuantumCircuit(3)
old.h(range(3))
old.compose(old_problem.grover_operator.decompose(), inplace=True)
new_r = get_result(new)
if(not new_r.get(b)):
new_r = 0
else:
new_r = new_r[b]
old_r = get_result(old)
if(not old_r.get(b)):
old_r = 0
else:
old_r = old_r[b]
print(b, ' - ', old_r,new_r)
compare(best_angle)
best_angle, _ = find_best_angle('000', p_oracle('000'))
best_angle
compare(best_angle)
qc = QuantumCircuit(1)
qc.ry(best_angle, 0)
plot_bloch_multivector(qc)
best_angle, _ = find_best_angle('010', p_oracle('010'))
best_angle
compare(best_angle)
qc = QuantumCircuit(1)
qc.ry(best_angle, 0)
plot_bloch_multivector(qc)
old = {}
new = {}
bit_strings = ['000', '001', '010', '011', '100', '101', '110', '111']
for b in bit_strings:
oracle = p_oracle(b)
best_angle, _ = find_best_angle(b, oracle)
s = QuantumCircuit(3, name="S")
s.ry(best_angle, range(3))
new_ = new_g(s, oracle)
old_problem = AmplificationProblem(oracle, is_good_state=[b])
old_ = QuantumCircuit(3)
old_.h(range(3))
old_.compose(old_problem.grover_operator.decompose(), inplace=True)
new_r = get_result(new_)
if(not new_r.get(b)):
new_r = 0
else:
new_r = new_r[b]
old_r = get_result(old_)
if(not old_r.get(b)):
old_r = 0
else:
old_r = old_r[b]
old[b] = old_r
new[b] = new_r
old, new
data = {"new": new, "old":old}
df = pd.DataFrame(data, columns=["new", "old"], index=bit_strings)
df
plt.plot(df.index.tolist(),df['new'], label="new")
plt.plot(df.index.tolist(),df['old'], label="old")
plt.title('old vs new Grover improvement (range [0, $\pi$])')
plt.xlabel("bit string")
plt.ylabel("counts")
plt.legend(loc="upper right")
plt.savefig(get_image_path("superposition-improvement-grover-algorithm.png"))
plt.show()
def find_best_angle_d_range(encoded_bit_string, oracle):
max_ = 0
best_angle = 0
for angle in np.linspace(0, 2*np.pi, num=240):
s = QuantumCircuit(3)
s.ry(angle, range(3))
qc = new_g(s, oracle)
qc.measure_all()
result = sim.run(transpile(qc, sim), shots=1000).result().get_counts()
if(not result.get(encoded_bit_string)):
continue
result = result[encoded_bit_string]
if(result > max_):
max_ = result
best_angle = angle
print(angle, result)
return best_angle, max_
old = {}
new = {}
bit_strings = ['000', '001', '010', '011', '100', '101', '110', '111']
for b in bit_strings:
oracle = p_oracle(b)
best_angle, _ = find_best_angle_d_range(b, oracle)
s = QuantumCircuit(3, name="S")
s.ry(best_angle, range(3))
new_ = new_g(s, oracle)
old_problem = AmplificationProblem(oracle, is_good_state=[b])
old_ = QuantumCircuit(3)
old_.h(range(3))
old_.compose(old_problem.grover_operator.decompose(), inplace=True)
new_r = get_result(new_)
if(not new_r.get(b)):
new_r = 0
else:
new_r = new_r[b]
old_r = get_result(old_)
if(not old_r.get(b)):
old_r = 0
else:
old_r = old_r[b]
old[b] = old_r
new[b] = new_r
data = {"new": new, "old":old}
df = pd.DataFrame(data, columns=["new", "old"], index=bit_strings)
df
plt.plot(df.index.tolist(),df['new'], label="new")
plt.plot(df.index.tolist(),df['old'], label="old")
plt.title('old vs new Grover improvement (range [0, $2\pi$])')
plt.xlabel("bit string")
plt.ylabel("counts")
plt.legend(loc="upper right")
#plt.savefig(get_image_path("superposition-improvement-grover-algorithm.png"))
plt.show()
s = QuantumCircuit(3)
s.ry(np.pi/3, 0)
s.ry(np.pi/5, 1)
s.ry(np.pi/9, 2)
s.draw('mpl')
plot_bloch_multivector(s)
oracle = p_oracle('000')
qc = new_g(s, oracle)
plot_histogram(get_result(qc))
oracle = p_oracle('010')
qc = new_g(s, oracle)
plot_histogram(get_result(qc))
CCP = CPhaseGate(-np.pi/8).control(1)
oracle = QuantumCircuit(3)
oracle.append(CCP, [0, 1, 2])
oracle.draw('mpl')
qc_copy = oracle.copy()
qc_copy.save_unitary()
sim = AerSimulator()
unitary = sim.run(transpile(qc_copy, sim)).result().get_unitary()
array_to_latex(unitary, max_size=10000)
s = QuantumCircuit(3)
s.ry(1.7423959255203896, range(3))
qc = new_g(s, oracle)
plot_histogram(get_result(qc))
sim = AerSimulator()
def find_best_angle_rx(encoded_bit_string, oracle):
max_ = 0
best_angle = 0
for angle in np.linspace(0, np.pi, num=120):
s = QuantumCircuit(3)
s.rx(angle, range(3))
qc = new_g(s, oracle)
qc.measure_all()
result = sim.run(transpile(qc, sim), shots=1000).result().get_counts()
if(not result.get(encoded_bit_string)):
continue
result = result[encoded_bit_string]
if(result > max_):
max_ = result
best_angle = angle
#transpiled = transpile(qc, sim)
#display(transpiled.draw('mpl'))
#print(angle, result)
return best_angle, max_
def find_best_angle_rz(encoded_bit_string, oracle):
max_ = 0
best_angle = 0
for angle in np.linspace(0, np.pi, num=120):
s = QuantumCircuit(3)
s.rz(angle, range(3))
qc = new_g(s, oracle)
qc.measure_all()
result = sim.run(transpile(qc, sim), shots=1000).result().get_counts()
if(not result.get(encoded_bit_string)):
continue
result = result[encoded_bit_string]
if(result > max_):
max_ = result
best_angle = angle
#transpiled = transpile(qc, sim)
#display(transpiled.draw('mpl'))
#print(angle, result)
return best_angle, max_
def find_best_angle_ry(encoded_bit_string, oracle):
max_ = 0
best_angle = 0
for angle in np.linspace(0, np.pi, num=120):
s = QuantumCircuit(3)
s.ry(angle, range(3))
qc = new_g(s, oracle)
qc.measure_all()
result = sim.run(transpile(qc, sim), shots=1000).result().get_counts()
if(not result.get(encoded_bit_string)):
continue
result = result[encoded_bit_string]
if(result > max_):
max_ = result
best_angle = angle
#transpiled = transpile(qc, sim)
#display(transpiled.draw('mpl'))
#print(angle, result)
return best_angle, max_
rx = {}
rz = {}
ry = {}
bit_strings = ['000', '001', '010', '011', '100', '101', '110', '111']
for s in bit_strings:
oracle = p_oracle(s)
angle_rx, max_rx = find_best_angle_rx(s, oracle)
angle_rz, max_rz = find_best_angle_rz(s, oracle)
angle_ry, max_ry = find_best_angle_ry(s, oracle)
print(s, angle_rx, max_rx, angle_rz, max_rz, angle_ry, max_ry)
rx[s] = max_rx
rz[s] = max_rz
ry[s] = max_ry
data = {"ry": ry, "rx": rx, "rz": rz}
df = pd.DataFrame(data, columns=("ry", "rx", "rz"), index=bit_strings)
plt.plot(df.index.tolist(),df['ry'], label="ry")
plt.plot(df.index.tolist(),df['rx'], label="rx")
plt.plot(df.index.tolist(),df['rz'], label="rz")
plt.title('test rotations')
plt.xlabel("bit string")
plt.ylabel("counts")
plt.legend(loc="upper right")
plt.savefig(get_image_path("rotations-test-grover-algorithm.png"))
plt.show()
test = QuantumCircuit(1)
test.ry(3*np.pi/2, 0)
display(test.draw('mpl'))
plot_bloch_multivector(test)
def find_best_angle_2(encoded_bit_string, oracle, values_range, sim=AerSimulator()):
max_ = 0
best_angle = 0
for angle in values_range:
s = QuantumCircuit(3)
s.ry(angle, range(3))
qc = new_g(s, oracle)
qc.measure_all()
result = sim.run(transpile(qc, sim), shots=1000).result().get_counts()
if(not result.get(encoded_bit_string)):
continue
result = result[encoded_bit_string]
if(result > max_):
max_ = result
best_angle = angle
#print(angle, result)
return best_angle, max_
def new_compare(values_range, bit_strings=['000', '001', '010', '011', '100', '101', '110', '111']):
old = {}
new = {}
total_qubits = len(bit_strings[0])
for b in bit_strings:
oracle = p_oracle(b)
best_angle, _ = find_best_angle_2(b, oracle, values_range=values_range)
s = QuantumCircuit(total_qubits, name="S")
s.ry(best_angle, range(total_qubits))
new_ = QuantumCircuit(total_qubits)
new_.append(s, range(total_qubits))
new_.append(oracle, range(total_qubits))
new_.h(range(total_qubits))
new_.x(range(total_qubits))
new_.h(-1)
new_.mcmt(list(range(tota_qubits-1)),-1)
new_.h(-1)
new_.x(range(total_qubits))
new_.h(range(total_qubits))
old_problem = AmplificationProblem(oracle, is_good_state=[b])
old_ = QuantumCircuit(total_qubits)
old_.h(range(total_qubits))
old_.compose(old_problem.grover_operator.decompose(), inplace=True)
new_r = get_result(new_)
if(not new_r.get(b)):
new_r = 0
else:
new_r = new_r[b]
old_r = get_result(old_)
if(not old_r.get(b)):
old_r = 0
else:
old_r = old_r[b]
old[b] = old_r
new[b] = new_r
data = {"old": old, "new": new}
df = pd.DataFrame(data, columns=("old", "new"), index=bit_strings)
return df
df_0_to_pi = new_compare(np.linspace(0, np.pi, num=240))
df_0_to_pi
plt.plot(df_0_to_pi.index.tolist(),df_0_to_pi['old'], label="old")
plt.plot(df_0_to_pi.index.tolist(),df_0_to_pi['new'], label="new")
plt.xlabel("bit string")
plt.ylabel("counts")
plt.legend(loc="upper right")
plt.show()
df_0_to_2pi = new_compare(np.linspace(0, 2*np.pi, num=240))
df_0_to_2pi
plt.plot(df_0_to_2pi.index.tolist(),df_0_to_2pi['old'], label="old")
plt.plot(df_0_to_2pi.index.tolist(),df_0_to_2pi['new'], label="new")
plt.xlabel("bit string")
plt.ylabel("counts")
plt.legend(loc="upper right")
plt.show()
df_0_to_pi = new_compare(np.linspace(0, np.pi, num=240), bit_strings=['00', '01', '10', '11'])
df_0_to_pi
|
https://github.com/Dpbm/scientific-research-1-quantum-oracles
|
Dpbm
|
from qiskit import QuantumCircuit, transpile, QuantumRegister, ClassicalRegister, AncillaRegister
from qiskit_aer import AerSimulator
from qiskit.circuit.library import MCMT, GroverOperator
from qiskit.quantum_info import Statevector
from math import pi
from qiskit.visualization import plot_histogram, plot_bloch_multivector, array_to_latex
from qiskit.circuit import Parameter
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from utils import get_image_path
import seaborn as sns
from qutip import Bloch, Qobj
from itertools import combinations, product
def get_diffuser(total_qubits):
mct = MCMT('x', total_qubits-1, 1)
qc = QuantumCircuit(total_qubits)
qc.h(range(total_qubits))
qc.x(range(total_qubits))
qc.h(-1)
qc.compose(mct, range(total_qubits), inplace=True)
qc.h(-1)
qc.x(range(total_qubits))
qc.h(range(total_qubits))
return qc
def classical_grover(oracle):
total_qubits = oracle.num_qubits
qc = QuantumCircuit(total_qubits)
grover = GroverOperator(oracle).decompose()
qc.h(range(total_qubits))
qc.compose(grover, range(total_qubits), inplace=True)
return qc
def phase_oracle(states):
total_qubits = len(states[0])
mct = MCMT('z', total_qubits-1, 1)
qc = QuantumCircuit(total_qubits, name="oracle")
for state in states:
zeros = [i for i, bit in enumerate(state[::-1]) if bit == '0']
if(zeros): qc.x(zeros)
qc.compose(mct,range(total_qubits),inplace=True)
if(zeros): qc.x(zeros)
return qc
oracle = phase_oracle(['100'])
oracle.draw('mpl')
classical_grover(oracle).draw('mpl')
def get_counts(qc, sim=AerSimulator(), shots=1000):
qc_c = qc.copy()
qc_c.measure_all()
transpiled = transpile(qc_c, sim)
return sim.run(transpiled, shots=shots).result().get_counts()
def new_grover(oracle):
theta = Parameter('theta')
total_qubits = oracle.num_qubits
qc = QuantumCircuit(total_qubits)
qc.ry(theta, range(total_qubits))
qc.barrier()
qc.append(oracle, range(total_qubits))
qc.barrier()
qc.compose(get_diffuser(total_qubits), range(total_qubits), inplace=True)
return qc, theta
n_grover,theta = new_grover(oracle)
n_grover.draw('mpl')
def find_best_angle(theta, qc, values_space, target_bit_string, debug=False):
best_angle = 0
best_total = 0
for angle in values_space:
bc = qc.assign_parameters({theta:angle})
counts = get_counts(bc)
value = 0
if(counts.get(target_bit_string)):
value = counts[target_bit_string]
if(value > best_total):
best_total = value
best_angle = angle
if(debug):
print(angle, value)
return best_angle, best_total
best_angle, best_total = find_best_angle(theta, n_grover, np.linspace(0, pi, num=1000), '001', debug=True)
best_angle, best_total
BIT_STRINGS_3 = ['000', '001', '010', '011', '100', '101', '110', '111']
def compare_old_new_1_bit_string(bit_strings, values_space, debug=False):
old = {}
new = {}
angles = {}
for bit_string in bit_strings:
oracle = phase_oracle([bit_string])
old_ = classical_grover(oracle.copy())
if(debug):
display(old_.draw('mpl'))
old_counts = get_counts(old_)
old_total = 0
if(old_counts.get(bit_string)):
old[bit_string] = old_counts[bit_string]
new_, theta = new_grover(oracle.copy())
angle, max_ = find_best_angle(theta, new_, values_space, bit_string)
new[bit_string] = max_
angles[bit_string] = angle
data = {"old":old, "new":new, "angles":angles}
return pd.DataFrame(data, columns=("old", "new", "angles"), index=bit_strings)
results_1 = compare_old_new_1_bit_string(BIT_STRINGS_3, np.linspace(0, pi, num=500))
results_1
plt.plot(results_1.index.tolist(), results_1['new'], label="new")
plt.plot(results_1.index.tolist(), results_1['old'], label="old")
plt.title('old vs new Grover improvement (range [0, $\pi$])')
plt.xlabel("bit string")
plt.ylabel("counts")
plt.legend(loc="upper right")
plt.savefig(get_image_path("superposition-improvement-grover-algorithm-range-0-to-pi.png"))
plt.show()
results_2 = compare_old_new_1_bit_string(BIT_STRINGS_3, np.linspace(0, 2*pi, num=500))
results_2
plt.plot(results_2.index.tolist(), results_2['new'], label="new")
plt.plot(results_2.index.tolist(), results_2['old'], label="old")
plt.title('old vs new Grover improvement (range [0, $2\pi$])')
plt.xlabel("bit string")
plt.ylabel("counts")
plt.legend(loc="upper right")
plt.savefig(get_image_path("superposition-improvement-grover-algorithm-range-0-to-2pi.png"))
plt.show()
plt.plot(BIT_STRINGS_3, results_1['angles'], label="first")
plt.plot(BIT_STRINGS_3, results_2['angles'], label="second")
plt.title('angles comparation ([0, $\pi$] vs [0, $2\pi$])')
plt.xlabel("bit string")
plt.ylabel("angle")
plt.legend(loc="upper right")
plt.savefig(get_image_path("improvement-grover-algorithm-angles-comparation-0-pi-and-2pi.png"))
plt.show()
results_3 = compare_old_new_1_bit_string([bin(i)[2:].zfill(4) for i in range(2**4)], np.linspace(0, 2*pi, num=500))
results_3
plt.plot(results_3.index.tolist(), results_3['new'], label="new")
plt.plot(results_3.index.tolist(), results_3['old'], label="old")
plt.title('old vs new Grover improvement (range [0, $2\pi$])')
plt.xlabel("bit string")
plt.ylabel("counts")
plt.xticks(rotation = 45)
plt.legend(loc="upper right")
plt.savefig(get_image_path("improvement-grover-algorithm-4bits-0-to-2pi.png"))
plt.show()
pi/2
mid_values = results_3["angles"].drop(["0000", "1111"])
mid_values
mid_values.describe()
mid_values.mean(), pi/2
bloch_data = results_3
bloch_data['alfa'] = np.cos(bloch_data["angles"]/2)
bloch_data['beta'] = np.sin(bloch_data["angles"]/2)
bloch_data
def show_bloch(states):
bloch = Bloch()
bloch.make_sphere()
bloch.add_states(states)
display(bloch.show())
for i in bloch_data.index.tolist():
print(i, i.count('0'))
states = []
for i in range(len(bloch_data)):
row = bloch_data.iloc[i]
alfa,beta = row['alfa'], row['beta']
states.append(Qobj([[alfa], [beta]]))
show_bloch(states)
states = []
for i in range(len(bloch_data)):
row = bloch_data.iloc[i]
if(row.name.count('0') >= 3):
alfa,beta = row['alfa'], row['beta']
states.append(Qobj([[alfa], [beta]]))
show_bloch(states)
states = []
for i in range(len(bloch_data)):
row = bloch_data.iloc[i]
if(row.name.count('0') == 2):
alfa,beta = row['alfa'], row['beta']
states.append(Qobj([[alfa], [beta]]))
show_bloch(states)
states = []
for i in range(len(bloch_data)):
row = bloch_data.iloc[i]
if(row.name.count('0') <= 1):
alfa,beta = row['alfa'], row['beta']
states.append(Qobj([[alfa], [beta]]))
show_bloch(states)
def show_unitary(qc, sim=AerSimulator()):
qc_c = qc.copy()
qc_c.save_unitary()
transpiled = transpile(qc_c, sim)
u = sim.run(transpiled, shots=1000).result().get_unitary()
display(array_to_latex(u, max_size=100000))
d = pd.DataFrame(columns=("a", "b", "c"))
d["a"] =
BIT_STRINGS_2 = ['00', '01', '10', '11']
def test_angle_with_multiple_bit_strings(bit_strings):
df = pd.DataFrame(columns=("angle", *bit_strings, "default"), index=bit_strings)
for string in bit_strings:
oracle = phase_oracle([string])
n_grover,theta = new_grover(oracle.copy())
best_angle, best_total = find_best_angle(theta, n_grover, np.linspace(0, pi, num=1000), string, debug=False)
df.loc[string]['angle'] = best_angle
df.loc[string][string] = best_total
default = classical_grover(oracle.copy())
default_counts = get_counts(default)
default_total = 0
if(default_counts.get(string)):
default_total = default_counts[string]
df.loc[string]['default'] = default_total
for string2 in set(bit_strings)-{string}:
oracle = phase_oracle([string2])
n_grover_2,theta_2 = new_grover(oracle.copy())
bc = n_grover_2.assign_parameters({theta_2: best_angle})
counts = get_counts(bc)
total = 0
if(counts.get(string2)):
total = counts[string2]
df.loc[string2][string] = total
return df
df = test_angle_with_multiple_bit_strings(BIT_STRINGS_2)
df
fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2)
ax1.plot(BIT_STRINGS_2, df['00'])
ax2.plot(BIT_STRINGS_2, df['01'])
ax3.plot(BIT_STRINGS_2, df['10'])
ax4.plot(BIT_STRINGS_2, df['11'])
plt.show()
df = test_angle_with_multiple_bit_strings(BIT_STRINGS_3)
df
plt.figure(figsize=(13, 7))
sns.set_palette("Blues")
for string in BIT_STRINGS_3:
sns.lineplot(data=df, x=BIT_STRINGS_3, y=string, label=f"{string} angle")
sns.lineplot(data=df, x=BIT_STRINGS_3, y="default", label="classical Grover", color="red")
plt.xlabel("bit strings")
plt.ylabel("counts")
plt.legend(loc="upper right")
plt.show()
df.describe()
df.std()
angles = df['angle'][1:-2]
angles = angles.reset_index()
angles = angles.drop(columns=['index'])
angles.loc[5] = pi/2
angles
angles.std()
data = pd.DataFrame(columns=("+", "=", "-"), index=BIT_STRINGS_3)
default_theta = pi/2
deviation = angles.std()['angle']
for index, t_value in (('-', default_theta-deviation), ('=', default_theta), ('+', default_theta+deviation)):
for bit_string in BIT_STRINGS_3:
oracle = phase_oracle([bit_string])
ng, theta = new_grover(oracle)
bc = ng.assign_parameters({theta:t_value})
counts = get_counts(bc)
total = 0
if(counts.get(bit_string)):
total = counts[bit_string]
data.loc[bit_string][index] = total
data
data.describe()
data.std()
sns.set_palette("flare")
sns.lineplot(data=data, x=BIT_STRINGS_3, y='-', label="-deviation")
sns.lineplot(data=data, x=BIT_STRINGS_3, y='=', label="=")
sns.lineplot(data=data, x=BIT_STRINGS_3, y='+', label="+deviation")
plt.xlabel("bit strings")
plt.ylabel("counts")
plt.legend(loc="upper right")
plt.show()
oracle = phase_oracle(['010', '110'])
oracle.draw('mpl')
ng, theta = new_grover(oracle)
ng.draw('mpl')
def find_best_angle_multiple_bs(theta, qc, values_space, target_bit_strings, debug=False):
best_angle = 0
best_total = 0
for angle in values_space:
bc = qc.assign_parameters({theta:angle})
counts = get_counts(bc)
value = 0
for bit_string in target_bit_strings:
if(counts.get(bit_string)):
value += counts[bit_string]
if(value > best_total):
best_total = value
best_angle = angle
if(debug):
print(angle, value)
return best_angle, best_total
angle, max_ = find_best_angle_multiple_bs(theta, ng, np.linspace(0, pi, num=1000), ['010', '110'])
angle,max_
ng, theta = new_grover(oracle)
bc = ng.assign_parameters({theta:angle})
bc.draw('mpl')
plot_histogram(get_counts(bc))
c = classical_grover(oracle)
plot_histogram(get_counts(c))
df = pd.DataFrame(columns=("bs_1", "bs_2", "bs_3", "angle","max_new", "max_old"))
for i, comb in enumerate(combinations(BIT_STRINGS_3, 3)):
oracle = phase_oracle(comb)
old_ = classical_grover(oracle.copy())
new_,theta = new_grover(oracle.copy())
#get old
old_counts = get_counts(old_)
total_old = 0
for c in comb:
if(old_counts.get(c)):
total_old += old_counts[c]
#get new
angle, max_ = find_best_angle_multiple_bs(theta, new_, np.linspace(0, pi, num=200), comb)
df.loc[i] = (comb[0], comb[1], comb[2], angle, max_, total_old)
df
data = df
data["data"] = df["bs_1"] + " " + df["bs_2"] + " " + df["bs_3"]
data
plt.figure(figsize=(20,7))
sns.lineplot(data=data, x="data", y="max_old", label="grover")
sns.lineplot(data=data, x="data", y="max_new", label="new grover")
plt.xlabel("")
plt.ylabel("counts")
plt.xticks(rotation=90)
plt.legend(loc="upper right")
plt.savefig(get_image_path("multiple_strings_new_grover_best_angles.png"))
plt.show()
data['alfa'] = np.cos(data["angle"]/2)
data['beta'] = np.sin(data["angle"]/2)
data
states = []
for i in range(len(data)):
row = data.loc[i]
alfa,beta = row['alfa'], row['beta']
states.append(Qobj([[alfa], [beta]]))
show_bloch(states)
plt.figure(figsize=(20, 7))
sns.lineplot(data=data, x="data", y="alfa")
sns.lineplot(data=data, x="data", y="beta")
plt.xticks(rotation=90)
plt.show()
data["t_zeros"] = data["data"].str.count('0')
data
more_zeros = data[data['t_zeros'] >= 5]
more_zeros
more_zeros[['alfa', 'beta', 't_zeros']].describe()
more_zeros['alfa'].mean()
#alfa = cos(theta/2)
#cos^-1(alfa) = theta/2
#(cos^-1(alfa))*2 = theta
theta = np.arccos(more_zeros['alfa'].mean())*2
theta, np.degrees(theta)
melted = pd.melt(more_zeros, id_vars=['t_zeros'], value_vars=['alfa', 'beta'], var_name="amplitude")
melted
sns.barplot(data=melted, x="t_zeros", y="value", hue="amplitude")
plt.legend(loc="lower right")
plt.show()
data_2 = data
data_2 = data_2[['t_zeros', 'alfa', 'beta']]
data_2
melted_entire = pd.melt(data_2, id_vars=['t_zeros'], value_vars=['alfa', 'beta'], var_name="amplitude")
melted_entire
sns.barplot(data=melted_entire, x="t_zeros", y="value", hue="amplitude")
plt.legend(loc="lower right")
plt.ylabel("amplitude")
plt.savefig(get_image_path("amplitudes_based_on_total_zeros_new_grover.png"))
plt.show()
df = compare_old_new_1_bit_string(BIT_STRINGS_3, np.linspace(0, pi, num=200))
df
df['alfa'] = np.cos(df['angles']/2)
df['beta'] = np.sin(df['angles']/2)
df
df['t_zeros'] = df.index.str.count('0')
df
melted_entire_2 = pd.melt(df, id_vars=['t_zeros'], value_vars=['alfa', 'beta'], var_name="amplitude")
melted_entire_2
sns.barplot(data=melted_entire_2, x="t_zeros", y="value", hue="amplitude")
plt.legend(loc="lower right")
plt.ylabel("amplitude")
plt.savefig(get_image_path("amplitudes_based_on_total_zeros_new_grover_one_bit_string.png"))
plt.show()
q = QuantumCircuit(2)
q.ry(1.957575,0)
q.ry(1.294526,1)
plot_bloch_multivector(q)
np.degrees((3*pi)/4)
def create_grover(strings):
total_zeros = sum([ string.count('0') for string in strings ])
n_qubits = len(strings[0])
N = 2**n_qubits
t = N/2
if(n_qubits == 2):
angle = pi/2
if(total_zeros == n_qubits):
angle = 0.963001
elif(total_zeros == 0):
angle = 2.099657
else:
angle = 1.657624
oracle = phase_oracle(strings)
ng, theta = new_grover(oracle)
bc = ng.assign_parameters({theta:angle})
return bc
g = create_grover(['111'])
plot_histogram(get_counts(g))
o = phase_oracle(['000'])
c = classical_grover(o)
plot_histogram(get_counts(c))
plot_histogram(get_counts(create_grover(['100','111', '000'])))
o = phase_oracle(['100','111', '000'])
c = classical_grover(o)
plot_histogram(get_counts(c))
def run_for_2(bit_strings):
df = pd.DataFrame(columns=("bs_1", "bs_2", "angle","max_new", "max_old"))
for i, comb in enumerate(combinations(bit_strings, 2)):
oracle = phase_oracle(comb)
old_ = classical_grover(oracle.copy())
new_,theta = new_grover(oracle.copy())
#get old
old_counts = get_counts(old_)
total_old = 0
for c in comb:
if(old_counts.get(c)):
total_old += old_counts[c]
#get new
angle, max_ = find_best_angle_multiple_bs(theta, new_, np.linspace(0, pi, num=200), comb)
df.loc[i] = (comb[0], comb[1], angle, max_, total_old)
return df
df = run_for_2(BIT_STRINGS_3)
df.head()
# all angles get around pi/2
df['angle'].unique()
data = df
data["data"] = df["bs_1"] + " " + df["bs_2"]
data.head()
sns.lineplot(data=data, x="data", y="max_new")
sns.lineplot(data=data, x="data", y="max_old")
plt.xticks(rotation=90)
plt.xlabel("bit strings")
plt.ylabel("counts")
plt.savefig(get_image_path("2_bit_strings_l3_new_grover.png"))
plt.show()
plt.plot(df['angle'])
plt.show()
df = run_for_2(BIT_STRINGS_2)
df.head()
data = df
data["data"] = df["bs_1"] + " " + df["bs_2"]
data.head()
sns.lineplot(data=data, x="data", y="max_new", label="new")
sns.lineplot(data=data, x="data", y="max_old", label="old")
plt.xticks(rotation=90)
plt.xlabel("bit strings")
plt.ylabel("counts")
plt.legend(loc="upper right")
plt.savefig(get_image_path("2_bit_strings_l2_new_grover.png"))
plt.show()
plt.plot(df['angle'])
plt.show()
BIT_STRINGS_4 = [''.join(i) for i in product('01', repeat=4)]
BIT_STRINGS_4
df = run_for_2(BIT_STRINGS_4)
df.head()
data = df
data["data"] = df["bs_1"] + " " + df["bs_2"]
data.head()
plt.figure(figsize=(20, 7))
sns.lineplot(data=data, x="data", y="max_new", label="new")
sns.lineplot(data=data, x="data", y="max_old", label="old")
plt.xticks(rotation=90)
plt.xlabel("bit strings")
plt.ylabel("counts")
plt.legend(loc="upper right")
plt.savefig(get_image_path("2_bit_strings_l4_new_grover.png"))
plt.show()
def get_statistics_for_bit_strings(bit_strings_l):
for bs in bit_strings_l:
oracle = phase_oracle(bs)
ng, theta = new_grover(oracle.copy())
angle, max_ = find_best_angle_multiple_bs(theta, ng, np.linspace(0, pi, num=200), bs)
total_bit_strings = len(bs)
l = len(bs[0])
bc = ng.assign_parameters({theta:angle})
print(f"----{total_bit_strings} bit strings with length {l}----")
display(bc.draw('mpl', filename=get_image_path(f"new_grover_rotation_for_{total_bit_strings}_bit_strings_l{l}.png")))
plot_histogram(get_counts(bc), filename=get_image_path(f"new_grover_for_{total_bit_strings}_bit_strings_l{l}_outcomes.png"))
display(plot_histogram(get_counts(bc)))
c = classical_grover(oracle.copy())
display(c.draw('mpl', filename=get_image_path(f"classical_grover_for_{total_bit_strings}_bit_strings_l{l}.png")))
plot_histogram(get_counts(c), filename=get_image_path(f"classical_grover_for_{total_bit_strings}_bit_strings_l{l}_outcomes.png"))
display(plot_histogram(get_counts(c)))
get_statistics_for_bit_strings([
['01'],
['01', '10'],
['01', '10', '00'],
['010'],
['010', '101'],
['010', '101', '110'],
['0101'],
['0101', '1101'],
['0101', '1101', '1001'],
['01011'],
['01011', '01101'],
['01011', '01101', '10111'],
])
|
https://github.com/Dpbm/scientific-research-1-quantum-oracles
|
Dpbm
|
import numpy as np
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile, Aer, IBMQ
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from ibm_quantum_widgets import *
from qiskit.providers.aer import QasmSimulator
# Loading your IBM Quantum account(s)
provider = IBMQ.load_account()
from qiskit.circuit.library.standard_gates import XGate, HGate
from operator import *
n = 3
N = 8 #2**n
index_colour_table = {}
colour_hash_map = {}
index_colour_table = {'000':"yellow", '001':"red", '010':"blue", '011':"red", '100':"green", '101':"blue", '110':"orange", '111':"red"}
colour_hash_map = {"yellow":'100', "red":'011', "blue":'000', "green":'001', "orange":'010'}
def database_oracle(index_colour_table, colour_hash_map):
circ_database = QuantumCircuit(n + n)
for i in range(N):
circ_data = QuantumCircuit(n)
idx = bin(i)[2:].zfill(n) # removing the "0b" prefix appended by the bin() funtion
colour = index_colour_table[idx]
colour_hash = colour_hash_map[colour][::-1]
for j in range(n):
if colour_hash[j] == '1':
circ_data.x(j)
# qiskit maps the rightmost bit as the 0th qubit -> qn, ..., q0
# we therefore reverse the index string -> q0, ..., qn
data_gate = circ_data.to_gate(label=colour).control(num_ctrl_qubits=n, ctrl_state=idx, label="index-"+colour)
circ_database.append(data_gate, list(range(n+n)))
return circ_database
# drawing the database oracle circuit
print("Database Encoding")
database_oracle(index_colour_table, colour_hash_map).draw()
circ_data = QuantumCircuit(n)
m = 4
idx = bin(m)[2:].zfill(n) # removing the "0b" prefix appended by the bin() funtion
colour = index_colour_table[idx]
colour_hash = colour_hash_map[colour][::-1]
for j in range(n):
if colour_hash[j] == '1':
circ_data.x(j)
print("Internal colour encoding for the colour green (as an example)");
circ_data.draw()
def oracle_grover(database, data_entry):
circ_grover = QuantumCircuit(n + n + 1)
circ_grover.append(database, list(range(n+n)))
target_reflection_gate = XGate().control(num_ctrl_qubits=n, ctrl_state=colour_hash_map[data_entry], label="Reflection of " + "\"" + data_entry + "\" Target")
# control() missing 1 required positional argument: 'self' .... if only 'XGate' used instead of 'XGate()'
# The “missing 1 required positional argument: 'self'” error is raised when you do not instantiate an object of a class before calling a class method. This error is also raised when you incorrectly instantiate a class.
circ_grover.append(target_reflection_gate, list(range(n, n+n+1)))
circ_grover.append(database, list(range(n+n)))
return circ_grover
print("Grover Oracle (target example: orange)")
oracle_grover(database_oracle(index_colour_table, colour_hash_map).to_gate(label="Database Encoding"), "orange").decompose().draw()
def mcz_gate(num_qubits):
num_controls = num_qubits - 1
mcz_gate = QuantumCircuit(num_qubits)
target_mcz = QuantumCircuit(1)
target_mcz.z(0)
target_mcz = target_mcz.to_gate(label="Z_Gate").control(num_ctrl_qubits=num_controls, ctrl_state=None, label="MCZ")
mcz_gate.append(target_mcz, list(range(num_qubits)))
return mcz_gate.reverse_bits()
print("Multi-controlled Z (MCZ) Gate")
mcz_gate(n).decompose().draw()
def diffusion_operator(num_qubits):
circ_diffusion = QuantumCircuit(num_qubits)
qubits_list = list(range(num_qubits))
# Layer of H^n gates
circ_diffusion.h(qubits_list)
# Layer of X^n gates
circ_diffusion.x(qubits_list)
# Layer of Multi-controlled Z (MCZ) Gate
circ_diffusion = circ_diffusion.compose(mcz_gate(num_qubits), qubits_list)
# Layer of X^n gates
circ_diffusion.x(qubits_list)
# Layer of H^n gates
circ_diffusion.h(qubits_list)
return circ_diffusion
print("Diffusion Circuit")
diffusion_operator(n).draw()
# Putting it all together ... !!!
item = "green"
print("Searching for the index of the colour", item)
circuit = QuantumCircuit(n + n + 1, n)
circuit.x(n + n)
circuit.barrier()
circuit.h(list(range(n)))
circuit.h(n+n)
circuit.barrier()
unitary_oracle = oracle_grover(database_oracle(index_colour_table, colour_hash_map).to_gate(label="Database Encoding"), item).to_gate(label="Oracle Operator")
unitary_diffuser = diffusion_operator(n).to_gate(label="Diffusion Operator")
M = countOf(index_colour_table.values(), item)
Q = int(np.pi * np.sqrt(N/M) / 4)
for i in range(Q):
circuit.append(unitary_oracle, list(range(n + n + 1)))
circuit.append(unitary_diffuser, list(range(n)))
circuit.barrier()
circuit.measure(list(range(n)), list(range(n)))
circuit.draw()
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = backend_sim.run(transpile(circuit, backend_sim), shots=1024)
result_sim = job_sim.result()
counts = result_sim.get_counts(circuit)
if M==1:
print("Index of the colour", item, "is the index with most probable outcome")
else:
print("Indices of the colour", item, "are the indices the most probable outcomes")
from qiskit.visualization import plot_histogram
plot_histogram(counts)
|
https://github.com/Dpbm/scientific-research-1-quantum-oracles
|
Dpbm
|
%matplotlib inline
from pprint import pprint
from qiskit.quantum_info import Statevector
from qiskit import QuantumCircuit, QuantumRegister,transpile
from qiskit.visualization import array_to_latex, plot_distribution, plot_histogram
from qiskit.circuit.library import GroverOperator
from qiskit_aer import AerSimulator
from qiskit_algorithms import AmplificationProblem
from qiskit_algorithms import Grover
from qiskit.primitives import Sampler
#from qiskit.providers.fake_provider import FakeWashington
import numpy as np
import pandas as pd
import os
from tqdm.notebook import trange
import seaborn as sns
import matplotlib.pyplot as plt
from dotenv import load_dotenv
from qiskit_ibm_runtime import QiskitRuntimeService, Options, Sampler as IBMSampler
from utils import get_image_path
def hanoi(disc, start, aux, end, steps):
if(disc == 0):
return
hanoi(disc-1, start, end, aux, steps)
steps.append((disc, start, end))
hanoi(disc-1, aux, start, end, steps)
return steps
steps = hanoi(2, 0, 1, 2, [])
pprint(steps, width=20)
steps_for_3 = hanoi(3, 0, 1, 2, [])
pprint(steps_for_3, width=20)
def hanoi_solver(towers, steps):
for _, from_, to_ in steps:
value = towers[from_].pop()
towers[to_].append(value)
print(towers)
towers = [list(range(3, 0, -1)), [], []]
hanoi_solver(towers, steps_for_3)
print('result: ', towers)
def generate_hanoi_u(total_discs=3, n_qubits=3, total_towers=3):
assert total_discs <= 2**n_qubits, "Invalid size"
assert total_towers > 0 and total_towers <= 3, "invalid towers amount"
total_qubits = n_qubits*total_towers
tower = QuantumCircuit(total_qubits, name="hanoi U")
for i in range(1, total_discs+1):
binary = f"{i:0{total_qubits}b}"[::-1]
zeros = [ i for i,v in enumerate(binary) if v=='0']
has_zeros = len(zeros) > 0
if(has_zeros): tower.x(zeros)
tower.mcp(np.pi, list(range(1, total_qubits)), 0)
if(has_zeros): tower.x(zeros)
tower.barrier()
return tower
tower = generate_hanoi_u(n_qubits=1, total_discs=1)
tower.draw('mpl', style="clifford")
def get_unitary(qc, sim=AerSimulator()):
qc_copy = qc.copy()
qc_copy.save_unitary()
result = sim.run(transpile(qc_copy, sim), shots=1000).result().get_unitary()
display(array_to_latex(result, max_size=10000))
get_unitary(tower)
source = QuantumRegister(1, name="source")
auxiliary = QuantumRegister(1, name="aux")
target = QuantumRegister(1, name="target")
hanoi_1 = QuantumCircuit(source, auxiliary, target)
hanoi_1.append(generate_hanoi_u(n_qubits=1, total_discs=1), [*source, *auxiliary, *target])
hanoi_1.swap(source, target)
display(hanoi_1.draw('mpl', style="clifford", filename=get_image_path("hanoi_1_disc.png")))
get_unitary(hanoi_1)
def test_result(oracle, expected, filename=None, sampler=Sampler()):
problem = AmplificationProblem(oracle, is_good_state=expected)
grover = Grover(sampler=sampler)
result = grover.amplify(problem)
print(f"Reached the expected values: {result.oracle_evaluation}")
print(f"Top measurments: {result.top_measurement}")
s = pd.Series(result.circuit_results[0])
df = pd.DataFrame(s)
df = df.reset_index(names="bit_strings")
df = df.rename(columns={0:'distribution'})
plt.figure(figsize=(10, 5))
plt.bar(data=df, x="bit_strings", height='distribution')
plt.xticks(rotation=90)
plt.xlabel("bit_string")
plt.ylabel("dist")
if(filename):
plt.savefig(filename, bbox_inches="tight")
display(plt.show())
test_result(hanoi_1, ['100'], filename=get_image_path("result_hanoi_1_disc.png"))
hanoi(2, 0, 1, 2, [])
source = QuantumRegister(2, name="source")
auxiliary = QuantumRegister(2, name="aux")
target = QuantumRegister(2, name="target")
hanoi_2 = QuantumCircuit(source, auxiliary, target)
hanoi_2.append(generate_hanoi_u(n_qubits=2, total_discs=2), [*source, *auxiliary, *target])
hanoi_2.swap(source[0], auxiliary[0])
hanoi_2.swap(source[1], target[1])
hanoi_2.swap(auxiliary[0], target[0])
display(hanoi_2.draw('mpl', style="clifford", filename=get_image_path("hanoi_2_discs.png")))
get_unitary(hanoi_2)
test_result(hanoi_2, ['010000', '100000'], filename=get_image_path("result_hanoi_2_discs.png"))
hanoi(3, 0, 1, 2, [])
source = QuantumRegister(2, name="source")
auxiliary = QuantumRegister(2, name="aux")
target = QuantumRegister(2, name="target")
hanoi_3 = QuantumCircuit(source, auxiliary, target)
hanoi_3.append(generate_hanoi_u(n_qubits=2), [*source, *auxiliary, *target])
#(1, 0, 2)
hanoi_3.swap(source[0], target[0])
#(2, 0, 1)
hanoi_3.swap(source[1], auxiliary[1])
#(1, 2, 1)
hanoi_3.swap(target[0], auxiliary[0])
#(3, 0, 2)
hanoi_3.swap(source[0], target[0])
hanoi_3.swap(source[1], target[1])
#(1, 1, 0)
hanoi_3.swap(auxiliary[0], source[0])
#(2, 1, 2)
hanoi_3.swap(auxiliary[1], target[1])
#(1, 0, 2)
hanoi_3.swap(source[0], target[0])
display(hanoi_3.draw('mpl',style="clifford", filename=get_image_path("hanoi_3_discs.png")))
get_unitary(hanoi_3)
test_result(hanoi_3, ['010000', '100000', '110000'], filename=get_image_path("result_hanoi_3_discs.png"))
def auto_hanoi(n, enable_display=True, filename=None):
n_qubits = len(str(bin(n))[2:])
source = QuantumRegister(n_qubits, name="source")
auxiliary = QuantumRegister(n_qubits, name="aux")
target = QuantumRegister(n_qubits, name="target")
qc = QuantumCircuit(source, auxiliary, target)
qc.append(generate_hanoi_u(n_qubits=n_qubits, total_discs=n), [*source, *auxiliary, *target])
steps = hanoi(n, 0, 1, 2, [])
encoded_towers = {
0: source,
1: auxiliary,
2: target
}
for value, from_, to in steps:
binary = f"{value:0{n_qubits}b}"
ones_pos = [ i for i, value in enumerate(binary) if value == '1' ]
tower_from = encoded_towers[from_]
tower_to = encoded_towers[to]
for one_pos in ones_pos:
qc.swap(tower_from[one_pos], tower_to[one_pos])
if(enable_display): display(qc.draw('mpl', style="clifford", filename=filename))
return qc
hanoi_4 = auto_hanoi(4, filename=get_image_path("hanoi_4_discs.png"))
test_result(hanoi_4, ['001000000', '010000000', '011000000', '100000000'],filename=get_image_path("result_hanoi_4_discs.png"))
load_dotenv()
QiskitRuntimeService.save_account(channel="ibm_quantum", token=os.getenv("IBM_TOKEN"), overwrite=True)
service = QiskitRuntimeService()
options = Options(optimization_level=3)
options.execution.shots = 1000
ibm_backend = service.least_busy(operational=True, simulator=False)
display(ibm_backend.status())
print(f'num_qubits: {ibm_backend.num_qubits}')
def get_depth(start=1, end=10, backend=AerSimulator()):
depths = pd.Series(dtype=np.int32)
for n in trange(start, end):
circuit = auto_hanoi(n, enable_display=False)
depths[n] = transpile(circuit, backend=backend).depth()
return depths
start = 1
end = 10
depths = get_depth(start=start, end=end)
washington_depths = get_depth(start=start, end=end, backend=FakeWashington())
ibmq_depths = get_depth(start=start, end=end, backend=ibm_backend)
hanoi_steps = lambda n: len(hanoi(n, 1, 2, 3, []))
vec_hanoi = np.vectorize(hanoi_steps)
range_ = np.arange(start, end)
total_steps = pd.Series(vec_hanoi(range_), index=range_, dtype=np.int32)
df = pd.DataFrame({"aer_depth":depths, "depth_fake_washington":washington_depths, "IBMQ_depth":ibmq_depths, "classical_steps":total_steps}, columns=["aer_depth", "depth_fake_washington", "IBMQ_depth", "classical_steps"])
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 5), sharey=True)
fig.suptitle('Depths x classical steps comparation')
sns.lineplot(ax=ax1, data=df[["classical_steps", "aer_depth"]], palette="flare")
sns.lineplot(ax=ax2, data=df[["aer_depth", "depth_fake_washington", "IBMQ_depth"]], palette="flare")
plt.savefig(get_image_path("hanoi_depths_comparation.png"))
plt.show()
sampler = IBMSampler(backend=ibm_backend, options=options)
oracle = auto_hanoi(3)
grover = GroverOperator(oracle, insert_barriers=True).decompose()
n_qubits = oracle.num_qubits
grover.name = "Grover"
qc = QuantumCircuit(n_qubits)
qc.h(range(n_qubits))
qc.compose(grover, list(range(n_qubits)), inplace=True)
qc.measure_all()
display(qc.draw('mpl', style="clifford", filename=get_image_path("hanoi_3_discs_ibm_q_test.png")))
job = sampler.run(qc.decompose())
sim = AerSimulator()
result = sim.run(qc.decompose(), shots=1000).result().get_counts()
plot_histogram(result)
job_id = ''
job = service.job(job_id)
plot_distribution(job.result().quasi_dists)
sampler = IBMSampler(backend=ibm_backend, options=options)
test_result(auto_hanoi(3), ['010000', '100000', '110000'], filename=get_image_path("result_hanoi_3_discs_ibm_q.png"), sampler=sampler)
|
https://github.com/Dpbm/scientific-research-1-quantum-oracles
|
Dpbm
|
%matplotlib inline
from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator
from qiskit.visualization import plot_histogram, array_to_latex
from qiskit.quantum_info import Statevector
import math
from utils import get_image_path
def show_unitary(qc):
sim = AerSimulator()
qc_unitary = qc.copy()
qc_unitary.save_unitary()
unitary = sim.run(transpile(qc_unitary, sim), shots=1000).result().get_unitary()
display(array_to_latex(unitary, max_size=100000))
def plot_results(qc):
sim = AerSimulator()
result = sim.run(transpile(qc, sim), shots=1000).result().get_counts()
display(plot_histogram(result))
_3_qubits_iterator = range(3)
"""
from 2 to 7
0010
0011
0100
0101
0110
0111
"""
oracle = QuantumCircuit(4, name="oracle")
#0010
oracle.barrier(label="2")
oracle.x([0, 2, 3])
oracle.mcp(math.pi, list(range(1, 4)), 0)
oracle.x([0, 2, 3])
#0011
oracle.barrier(label="3")
oracle.x([2, 3])
oracle.mcp(math.pi, list(range(1, 4)), 0)
oracle.x([2, 3])
#0100
oracle.barrier(label="4")
oracle.x([0, 1, 3])
oracle.mcp(math.pi, list(range(1, 4)), 0)
oracle.x([0, 1, 3])
#0101
oracle.barrier(label="5")
oracle.x([1, 3])
oracle.mcp(math.pi, list(range(1, 4)), 0)
oracle.x([1, 3])
#0110
oracle.barrier(label="6")
oracle.x([0, 3])
oracle.mcp(math.pi, list(range(1, 4)), 0)
oracle.x([0, 3])
#0111
oracle.barrier(label="7")
oracle.x(3)
oracle.mcp(math.pi, list(range(1, 4)), 0)
oracle.x(3)
oracle.barrier()
display(oracle.draw('mpl'))
show_unitary(oracle)
def diffuser(n_qubits):
iterator_n_qubits = range(n_qubits)
diffuser = QuantumCircuit(n_qubits, name="diffuser")
diffuser.h(iterator_n_qubits)
diffuser.x(iterator_n_qubits)
diffuser.h(0)
diffuser.mct(list(range(1, n_qubits)), 0)
diffuser.h(0)
diffuser.x(iterator_n_qubits)
diffuser.h(iterator_n_qubits)
return diffuser
qc_test_1 = QuantumCircuit(4)
diffuser_test_1 = diffuser(4)
iterator_4_qubits = range(4)
qc_test_1.h(iterator_4_qubits)
qc_test_1.append(oracle, iterator_4_qubits)
qc_test_1.append(diffuser_test_1, iterator_4_qubits)
qc_test_1.append(oracle, iterator_4_qubits)
qc_test_1.append(diffuser_test_1, iterator_4_qubits)
qc_test_1.append(oracle, iterator_4_qubits)
qc_test_1.append(diffuser_test_1, iterator_4_qubits)
qc_test_1.measure_all()
display(qc_test_1.draw('mpl'))
plot_results(qc_test_1)
qc_test_2 = QuantumCircuit(3)
qc_test_2.h(_3_qubits_iterator)
qc_test_2.cz(2, 0)
qc_test_2.cz(1, 2)
qc_test_2.append(diffuser(3), _3_qubits_iterator)
qc_test_2.measure_all()
display(qc_test_2.draw('mpl'))
plot_results(qc_test_2)
oracle_less_than_4 = QuantumCircuit(3, name="<4")
#000
oracle_less_than_4.x(_3_qubits_iterator)
oracle_less_than_4.mcp(math.pi, [2, 1], 0)
oracle_less_than_4.x(_3_qubits_iterator)
#001
oracle_less_than_4.x(range(1, 3))
oracle_less_than_4.mcp(math.pi, [2, 1], 0)
oracle_less_than_4.x(range(1, 3))
#010
oracle_less_than_4.x([0, 2])
oracle_less_than_4.mcp(math.pi, [2, 1], 0)
oracle_less_than_4.x([0,2])
#011
oracle_less_than_4.x(2)
oracle_less_than_4.mcp(math.pi, [2, 1], 0)
oracle_less_than_4.x(2)
display(oracle_less_than_4.draw('mpl'))
show_unitary(oracle_less_than_4)
oracle_less_than_6 = QuantumCircuit(3, name="<6")
#000
oracle_less_than_6.x(_3_qubits_iterator)
oracle_less_than_6.mcp(math.pi, [2, 1], 0)
oracle_less_than_6.x(_3_qubits_iterator)
#001
oracle_less_than_6.x(range(1, 3))
oracle_less_than_6.mcp(math.pi, [2, 1], 0)
oracle_less_than_6.x(range(1, 3))
#010
oracle_less_than_6.x([0, 2])
oracle_less_than_6.mcp(math.pi, [2, 1], 0)
oracle_less_than_6.x([0,2])
#011
oracle_less_than_6.x(2)
oracle_less_than_6.mcp(math.pi, [2, 1], 0)
oracle_less_than_6.x(2)
#100
oracle_less_than_6.x(range(0, 2))
oracle_less_than_6.mcp(math.pi, [2, 1], 0)
oracle_less_than_6.x(range(0, 2))
#101
oracle_less_than_6.x(1)
oracle_less_than_6.mcp(math.pi, [2, 1], 0)
oracle_less_than_6.x(1)
display(oracle_less_than_6.draw('mpl'))
show_unitary(oracle_less_than_6)
grover_diffuser = diffuser(3)
grover_oracle = QuantumCircuit(3, name="oracle")
grover_oracle.append(oracle_less_than_4, _3_qubits_iterator)
grover_oracle.append(oracle_less_than_6, _3_qubits_iterator)
qc_test_3 = QuantumCircuit(3)
qc_test_3.h(_3_qubits_iterator)
qc_test_3.append(grover_oracle, _3_qubits_iterator)
qc_test_3.append(grover_diffuser, _3_qubits_iterator)
qc_test_3.measure_all()
display(qc_test_3.draw('mpl'))
plot_results(qc_test_3)
add_two_oracle = QuantumCircuit(3, name="+2")
add_two_oracle.cx(1, 2)
add_two_oracle.x(1)
add_two_oracle.cz(1, 2)
add_two_oracle.z(1)
display(add_two_oracle.draw('mpl'))
show_unitary(add_two_oracle)
oracle_2 = QuantumCircuit(3, name="oracle")
oracle_2.append(oracle_less_than_4, _3_qubits_iterator)
oracle_2.append(add_two_oracle, _3_qubits_iterator)
display(oracle_2.draw('mpl'))
show_unitary(oracle_2)
qc = QuantumCircuit(3, name="oracle")
qc.append(oracle_less_than_4, _3_qubits_iterator)
qc.append(oracle_less_than_6, _3_qubits_iterator)
qc.draw('mpl', filename=get_image_path("less_than.png"))
show_unitary(qc)
|
https://github.com/Dpbm/scientific-research-1-quantum-oracles
|
Dpbm
|
%matplotlib inline
from qiskit import QuantumCircuit, transpile, QuantumRegister, ClassicalRegister
from qiskit.visualization import plot_histogram
from qiskit.quantum_info import Statevector
from qiskit_aer import AerSimulator
from qiskit_ibm_provider import IBMProvider
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
from dotenv import load_dotenv
from tqdm.notebook import tqdm
import functools
import os
from time import time
from collections import defaultdict
from utils import fibonacci, fibonacci_no_cache, get_image_path
ONE_KM_TO_MILES=0.621371
@functools.lru_cache(maxsize=1000)
def km_to_miles(km, last=0, n=0):
fib_value = fibonacci(n)
if(fib_value == km):
return last
if(fib_value > km*ONE_KM_TO_MILES):
raise Exception(f"{km} Not in the sequence")
return km_to_miles(km, fib_value, n+1)
km_to_miles(21)
@functools.lru_cache(maxsize=1000)
def miles_to_km(miles, last=0, n=0):
fib_value = fibonacci(n)
if(last == miles):
return fib_value
if(fib_value > miles/ONE_KM_TO_MILES):
raise Exception(f"{miles} Not in the sequence")
return miles_to_km(miles, fib_value, n+1)
miles_to_km(13)
km_miles = lambda km : km*ONE_KM_TO_MILES
miles_km = lambda miles: miles/ONE_KM_TO_MILES
km_miles(12)
km_miles(24)
BASE_NUMBERS = (1, 2, 3, 5, 8, 13, 21)
def breakdown(n, base_numbers=BASE_NUMBERS):
used_numbers = defaultdict(int)
for base_number in reversed(base_numbers):
while(base_number <= n):
used_numbers[base_number] += 1
n -= base_number
return dict(used_numbers)
breakdown(10)
def get_fib_pos(n, base_numbers=BASE_NUMBERS):
return base_numbers.index(n)
def get_relative_miles_km(n):
numbers = list(BASE_NUMBERS)+[34]
pos = get_fib_pos(n)
return numbers[pos+1]
def get_relative_km_miles(n):
numbers = [1]+list(BASE_NUMBERS)
pos = get_fib_pos(n)
return numbers[pos]
get_relative_miles_km(8)
get_relative_km_miles(8)
def new_miles_to_km(n):
result = 0
factors = breakdown(n)
for (number, total) in factors.items():
relative = get_relative_miles_km(number)
result += (relative*total)
return result
new_miles_to_km(15)
def new_km_to_miles(n):
result = 0
factors = breakdown(n)
print(factors)
for (number, total) in factors.items():
relative = get_relative_km_miles(number)
result += (relative*total)
return result
new_km_to_miles(12)
PI = np.pi
class Oracle(QuantumCircuit):
def __init__(self, n_qubits):
assert n_qubits >= 2, "Invalid number of qubits!"
self.n_qubits = n_qubits
super().__init__(n_qubits, name="oracle")
self.generate()
def generate(self):
self.ry(PI/2, range(self.n_qubits))
for i in range(self.n_qubits-1):
self.cry(-PI/2, i, i+1)
def simulate(self, backend=AerSimulator(), shots=1000):
qc_copy = self.copy()
qc_copy.measure_all()
transpiled_qc = transpile(qc_copy, backend)
return backend.run(transpiled_qc).result().get_counts()
oracle = Oracle(2)
display(oracle.draw('mpl'))
class KM_to_Miles(object):
def __init__(self, iterations=3, base_oracle=Oracle):
self.iterations = iterations
self.total_qubits = 2
self.oracle = base_oracle
self.qc = self.oracle(2)
self.results = pd.DataFrame(columns=['n_qubits', 'result'])
def run(self, backend=AerSimulator(), shots=1000, debug=True):
for i in tqdm(range(self.iterations)):
results = self.qc.simulate(backend, shots)
fibonacci_number = len(results)
if(debug):
print('-'*20)
print(f'i: {i}')
print(f'n: {self.total_qubits}')
print(f'F({i}): {fibonacci_number}')
self.results = pd.concat([self.results, pd.DataFrame({'n_qubits':self.total_qubits, 'result':fibonacci_number}, columns=['n_qubits', 'result'], index=[iter])], ignore_index=True)
self.total_qubits+=1
self.qc = self.oracle(self.total_qubits)
converter = KM_to_Miles(10)
converter.run(debug=False)
quantum_results = converter.results
quantum_results
def generate_miles_km_table(iter=3):
return pd.DataFrame([(fibonacci(i), fibonacci(i+1)) for i in range(iter)], columns=['miles', 'km'])
miles_km_data = generate_miles_km_table(12).loc[2:].reset_index().drop(columns=['index'])
miles_km_data
miles_km_data.shape, quantum_results.shape
def get_all_data(iter, converter, shots=1000):
miles_km = generate_miles_km_table(iter+2).loc[2:].reset_index().drop(columns=['index'])
converter_obj = KM_to_Miles(iter)
converter_obj.run(shots=shots, debug=False)
all_data = pd.concat([miles_km, converter_obj.results], axis=1)
return all_data
result_data = get_all_data(24, converter, shots=100000)
result_data.tail()
fig, ((ax1,ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12, 10))
first_batch = result_data.loc[:8]
ax1.plot('miles', 'km', data=first_batch)
ax1.plot('miles', 'result', data=first_batch)
ax1.set_title('[0-7]')
ax1.set(xlabel="miles", ylabel="km")
second_batch = result_data.loc[8:16]
ax2.plot('miles', 'km', data=second_batch)
ax2.plot('miles', 'result', data=second_batch)
ax2.set_title('[8-15]')
ax2.set(xlabel="miles", ylabel="km")
third_batch = result_data.loc[16:]
ax3.plot('miles', 'km', data=third_batch)
ax3.plot('miles', 'result', data=third_batch)
ax3.set_title('[16-23]')
ax3.set(xlabel="miles", ylabel="km")
ax4.set_visible(False)
fig.legend(["classical", "quantum"], bbox_to_anchor=(0.75,0.4), fontsize=20)
plt.savefig(get_image_path("miles_to_km_defiance.png"))
plt.show()
QUANTUM_BASE_NUMBERS = (3, 5, 8, 13, 21)
def get_quantum_fib_numbers(inp_value, base_numbers=QUANTUM_BASE_NUMBERS):
breakdown_values = breakdown(inp_value, base_numbers=base_numbers)
remain = inp_value - sum(breakdown_values.keys())
remain_values = {}
if(remain > 0):
REMAIN_BASE_NUMBERS = (1, 2)
remain_values = breakdown(remain, base_numbers=REMAIN_BASE_NUMBERS)
return breakdown_values, remain_values
values, remain = get_quantum_fib_numbers(100)
values
total_n_qubits = [ get_fib_pos(i, base_numbers=QUANTUM_BASE_NUMBERS)+2 for i in values ]
n_qubits = max(total_n_qubits)
measures = len(total_n_qubits)
total_n_qubits, n_qubits, measures
qubits = QuantumRegister(n_qubits, name="q")
measurements = [ClassicalRegister(cbits, name=index) for (index, cbits) in enumerate(total_n_qubits)]
qc = QuantumCircuit(qubits, *measurements)
for n, measurement in zip(total_n_qubits, measurements):
qc.append(Oracle(n), range(n))
qc.measure(range(n), measurement)
qc.reset(range(n))
qc.barrier()
qc.draw('mpl', filename=get_image_path("number_breakdown_circuit.png"))
def get_counts(qc, sim=AerSimulator()):
return sim.run(transpile(qc, sim)).result().get_counts()
result = get_counts(qc)
plot_histogram(result)
bit_string = result.keys()
total = result.values()
data = {"bit_string": bit_string, 'total':total}
df = pd.DataFrame(data, columns=['bit_string', 'total'])
df.head()
df[['bit_string0', 'bit_string1', 'bit_string2']] = df['bit_string'].str.split(' ', n=2, expand=True)
df.head()
len(df['bit_string0'].unique()), len(df['bit_string1'].unique()), len(df['bit_string2'].unique())
def get_times(func, values_range):
results = []
for i in values_range:
start = time()
func(i)
results.append(time() - start)
return results
def quantum_run(n):
qc = Oracle(n)
qc.simulate()
values_range = range(2, 25)
classical_no_cache_results = pd.Series(get_times(fibonacci_no_cache, values_range), dtype=np.float64)
classical_cache_results = pd.Series(get_times(fibonacci, values_range), dtype=np.float64)
quantum_local = pd.Series(get_times(quantum_run, values_range), dtype=np.float64)
times_data = pd.DataFrame({
"n": pd.Series(list(values_range), dtype=np.int8),
"classical_nc": classical_no_cache_results,
"classical_c": classical_cache_results,
"quantum_local": quantum_local
})
times_data.head()
load_dotenv()
IBMProvider.save_account(token=os.getenv("IBM_TOKEN"), overwrite=True)
provider = IBMProvider()
backends = provider.backends(min_num_qubits=25, operational=True, simulator=False)
min_pending_jobs = 1000000000
selected_backend = ''
for backend in backends:
backend_name = backend.name
pending_jobs = backend.status().pending_jobs
if(pending_jobs < min_pending_jobs):
min_pending_jobs = pending_jobs
selected_backend = backend_name
print(f'name: {backend_name}')
print(f'qubits: {backend.num_qubits}')
print(f'max_shots: {backend.max_shots}')
print(f'jobs: {pending_jobs}')
print(f'max_circuits: {backend.max_circuits}', end='\n\n')
backend = provider.get_backend(selected_backend)
circuits = [transpile(Oracle(n), backend) for n in values_range ]
ids = []
for i,circuit in enumerate(circuits):
status = None
job = backend.run(circuit, shots=1000)
id = job.job_id()
print(f'circuit: {i+1}')
print(f'job: {id}', end='\n\n')
ids.append(id)
while status != 'DONE':
status = job.status().name
results = [provider.retrieve_job(job_id).result()._metadata['time_taken'] for job_id in ids]
quantum_ibm = pd.Series(results, dtype=np.float64)
times_data['quantum_ibm'] = quantum_ibm
times_data.head()
index = times_data.index.tolist()
plt.plot(index, "classical_nc", data=times_data)
plt.plot(index, "classical_c", data=times_data)
plt.plot(index, "quantum_local", data=times_data)
plt.plot(index, "quantum_ibm", data=times_data)
plt.legend()
plt.savefig(get_image_path("comparison_miles_to_km.png"))
plt.show()
|
https://github.com/Dpbm/scientific-research-1-quantum-oracles
|
Dpbm
|
%matplotlib inline
from qiskit import QuantumCircuit, transpile
from qiskit.visualization import plot_histogram, array_to_latex
from qiskit_aer import AerSimulator
from utils import get_image_path
def simulate(qc, backend=AerSimulator(), shots=1000):
transpiled_qc = transpile(qc, backend)
return backend.run(transpiled_qc, shots=shots).result()
oracle_swap = QuantumCircuit(4)
oracle_swap.swap(0, -1)
oracle_swap.swap(1, -2)
oracle_swap.draw('mpl', filename=get_image_path("minimal-oracle.png"))
oracle_copy = oracle_swap.copy()
oracle_copy.save_unitary()
unitary = simulate(oracle_copy).get_unitary()
array_to_latex(unitary, max_size=10000)
oracle = oracle_swap.to_gate(label="$oracle_{Swap}$")
qc = QuantumCircuit(4)
qc.h(range(1, 4))
qc.draw('mpl')
qc_copy = qc.copy()
qc_copy.measure_all()
plot_histogram(simulate(qc_copy, shots=100).get_counts())
qc.append(oracle, range(4))
qc.measure_all()
qc.draw('mpl')
plot_histogram(simulate(qc, shots=100).get_counts())
|
https://github.com/Dpbm/scientific-research-1-quantum-oracles
|
Dpbm
|
%matplotlib inline
from qiskit import QuantumCircuit, transpile
from qiskit.circuit.library import QFT
from qiskit.visualization import plot_histogram, plot_bloch_multivector
from qiskit.quantum_info import Statevector
from qiskit_aer import AerSimulator
import numpy as np
from fractions import Fraction
from utils import get_image_path
def create_qpe(phase, total_counting_qubits=3):
total_qubits = total_counting_qubits+1
qc = QuantumCircuit(total_qubits, total_counting_qubits)
qc.x(-1)
qc.h(range(total_counting_qubits))
repetitions = 1
for qubit in range(total_counting_qubits):
for _ in range(repetitions):
qc.cp(phase, qubit, -1)
repetitions *= 2
qc.append(QFT(total_counting_qubits, inverse=True), range(total_counting_qubits))
qc.measure(range(total_counting_qubits), range(total_counting_qubits))
return qc
sim = AerSimulator()
counting_qubits = 3
lambda_ = np.pi
qc = create_qpe(lambda_)
display(qc.draw('mpl', filename=get_image_path('qpe.png')))
job = sim.run(transpile(qc, sim), shots=1000).result().get_counts()
display(plot_histogram(job))
def get_theta(counting_qubits, counts):
N = 2**(counting_qubits)
estimated_value = int(max(counts, key=counts.get), 2)
return Fraction(estimated_value, N)
theta = get_theta(counting_qubits, job)
theta
def get_phi(counting_qubits, theta):
fraction = Fraction(2*float(theta)).limit_denominator(2**counting_qubits)
return float(fraction)*np.pi
phi = get_phi(counting_qubits, theta)
phi
def check(phi):
qc = QuantumCircuit(1)
qc.x(0)
qc.p(phi, 0)
display(Statevector(qc).draw('latex'))
check(phi)
lambda_ = np.pi/2
counting_qubits = 4
qc = create_qpe(lambda_, counting_qubits)
job = sim.run(transpile(qc, sim), shots=1000).result().get_counts()
plot_histogram(job)
theta = get_theta(counting_qubits, job)
phi = get_phi(counting_qubits, theta)
print(f"theta: {theta}\nphi:{phi}")
check(phi)
|
https://github.com/Dpbm/scientific-research-1-quantum-oracles
|
Dpbm
|
%matplotlib inline
from qiskit import QuantumCircuit, transpile
from qiskit.visualization import array_to_latex, plot_histogram
from qiskit_aer import AerSimulator
from utils import get_image_path
sim = AerSimulator()
circuit = QuantumCircuit(4,3)
circuit.x(-1)
circuit.h(range(4))
circuit.barrier()
circuit.cx(0, -1)
circuit.cx(1, -1)
#circuit.cx(2, -1)
circuit.barrier()
circuit.h(range(3))
circuit.measure(range(3), range(3))
circuit.draw('mpl', filename=get_image_path("phase_oracle_1.png"))
result = sim.run(circuit).result().get_counts()
plot_histogram(result, filename=get_image_path("result_phase_oracle_plot.png"))
from math import pi
circuit2 = QuantumCircuit(3)
circuit2.x(-1)
circuit2.ccz(2, 1, 0)
circuit2.x(-1)
circuit2.draw('mpl')
circuit_tmp = circuit2.copy()
circuit_tmp.save_unitary()
unitary = sim.run(transpile(circuit_tmp, sim)).result().get_unitary()
array_to_latex(unitary, max_size=1000)
|
https://github.com/Dpbm/scientific-research-1-quantum-oracles
|
Dpbm
|
import numpy as np
from numpy import pi
# importing Qiskit
from qiskit import QuantumCircuit, transpile, assemble, Aer
from qiskit.visualization import plot_histogram, plot_bloch_multivector
qc = QuantumCircuit(3)
qc.h(2)
qc.cp(pi/2, 1, 2)
qc.cp(pi/4, 0, 2)
qc.h(1)
qc.cp(pi/2, 0, 1)
qc.h(0)
qc.swap(0, 2)
qc.draw()
def qft_rotations(circuit, n):
if n == 0:
return circuit
n -= 1
circuit.h(n)
for qubit in range(n):
circuit.cp(pi/2**(n-qubit), qubit, n)
qft_rotations(circuit, n)
def swap_registers(circuit, n):
for qubit in range(n//2):
circuit.swap(qubit, n-qubit-1)
return circuit
def qft(circuit, n):
qft_rotations(circuit, n)
swap_registers(circuit, n)
return circuit
qc = QuantumCircuit(4)
qft(qc,4)
qc.draw()
# Create the circuit
qc = QuantumCircuit(3)
# Encode the state 5 (101 in binary)
qc.x(0)
qc.x(2)
qc.draw()
sim = Aer.get_backend("aer_simulator")
qc_init = qc.copy()
qc_init.save_statevector()
statevector = sim.run(qc_init).result().get_statevector()
plot_bloch_multivector(statevector)
qft(qc, 3)
qc.draw()
qc.save_statevector()
statevector = sim.run(qc).result().get_statevector()
plot_bloch_multivector(statevector)
|
https://github.com/Dpbm/scientific-research-1-quantum-oracles
|
Dpbm
|
%matplotlib inline
from qiskit import QuantumCircuit, QuantumRegister, transpile, ClassicalRegister
from qiskit.quantum_info import Statevector
from qiskit.visualization import array_to_latex, plot_histogram, plot_bloch_multivector
from qiskit.circuit.library import CHGate
from qiskit_aer import AerSimulator
from functools import partial
import numpy as np
from utils import get_image_path
show_unitary = partial(array_to_latex, max_size=100000)
show_state = lambda qc: Statevector(qc).draw('latex')
def get_unitary(qc, sim=AerSimulator()):
qc_copy = qc.copy()
qc_copy.save_unitary()
unitary = sim.run(transpile(qc_copy, sim), shots=1000).result().get_unitary()
return unitary
def measure(qc, sim=AerSimulator(), qubits=None):
qc_copy = qc.copy()
if(not qubits):
qc_copy.measure_all()
else:
qc_copy.measure(qubits, list(range(len(qubits))))
result = sim.run(transpile(qc_copy, sim), shots=1000).result().get_counts()
return result
mem = QuantumCircuit(2, name="QROM")
mem.cz(0,1)
display(mem.draw('mpl'))
show_unitary(get_unitary(mem))
qc = QuantumCircuit(2)
qc.x(range(2))
qc.append(mem, [0,1])
qc.x(range(2))
display(qc.draw('mpl'))
display(show_unitary(get_unitary(qc)))
show_state(qc)
mem = QuantumCircuit(2, name="QROM")
mem.cp(np.pi/3,0,1)
display(mem.draw('mpl'))
show_unitary(get_unitary(mem))
qc = QuantumCircuit(2)
qc.x(range(2))
qc.append(mem, [0,1])
qc.x(range(2))
display(qc.draw('mpl'))
display(show_unitary(get_unitary(qc)))
show_state(qc)
plot_bloch_multivector(qc)
qc = QuantumCircuit(3)
qc.x(range(2))
qc.h(2)
qc.barrier()
qc.append(mem, [0,1])
qc.barrier()
qc.cx(2,1)
qc.x(range(2))
qc.h(2)
display(qc.draw('mpl'))
display(show_unitary(get_unitary(qc)))
display(show_state(qc))
display(plot_histogram(measure(qc)))
qc = QuantumCircuit(1)
#qc.h(0)
qc.p(np.pi/2, 0)
#qc.barrier()
#qc.cx(1,0)
qc.h(0)
display(qc.draw('mpl'))
display(show_unitary(get_unitary(qc)))
display(show_state(qc))
display(plot_histogram(measure(qc)))
mem = QuantumCircuit(2, name="QROM")
mem.cp(np.pi/3,0,1)
mem.x(range(2))
mem.cp(np.pi/7,0,1)
mem.x(range(2))
display(mem.draw('mpl'))
show_unitary(get_unitary(mem))
qc = QuantumCircuit(2)
#qc.x(range(2))
qc.append(mem, [0,1])
#qc.x(range(2))
display(qc.draw('mpl'))
display(show_unitary(get_unitary(qc)))
show_state(qc)
mem = QuantumCircuit(2, name="qrom")
mem.ch(0,1)
mem.x(0)
mem.cry(np.pi/3, 0, 1)
mem.x(0)
display(mem.draw('mpl', filename=get_image_path("qrom_1.png")))
display(show_unitary(get_unitary(mem)))
show_state(mem)
addr = QuantumRegister(1, name="addr")
out = QuantumRegister(1, name="out")
q = QuantumRegister(1,name="q")
result = ClassicalRegister(1, "m")
qc = QuantumCircuit(addr, out, q, result)
qc.x(addr)
qc.barrier(addr)
qc.append(mem, [addr, out])
qc.cx(out, q)
display(qc.draw('mpl'))
display(show_unitary(get_unitary(qc)))
display(show_state(qc))
display(plot_histogram(measure(qc, qubits=[2])))
addr = QuantumRegister(1, name="addr")
out = QuantumRegister(1, name="out")
q = QuantumRegister(1,name="q")
result = ClassicalRegister(1, "m")
qc = QuantumCircuit(addr, out, q)
qc.h(addr)
qc.barrier(addr)
qc.append(mem, [addr, out])
qc.cx(out, q)
display(qc.draw('mpl', filename=get_image_path("qrom_1_usage.png")))
display(show_unitary(get_unitary(qc)))
display(show_state(qc))
#display(plot_histogram(measure(qc, qubits=[2])))
CCH = CHGate().control(1)
addr = QuantumRegister(2, name="addr")
data = QuantumRegister(2, name="data")
mem = QuantumCircuit(addr, data, name="qrom")
mem.x(addr[0])
mem.ccx(addr[0], addr[1], data[0])
mem.x(addr[0])
mem.barrier()
mem.append(CCH, [addr[0], addr[1], data[0]])
mem.ccx(addr[0], addr[1], data[1])
display(mem.draw('mpl'))
display(show_unitary(get_unitary(mem)))
show_state(mem)
addr = QuantumRegister(2, name="addr")
data = QuantumRegister(2, name="data")
q = QuantumRegister(1, name="q")
out = ClassicalRegister(1, name="c")
qc = QuantumCircuit(addr, data, q, out)
qc.x(range(2))
qc.barrier(addr)
qc.append(mem, [*addr, *data])
qc.cx(data[1], q[0])
qc.cx(data[0], q[0])
qc.append(mem, [*addr, *data])
qc.barrier(addr)
qc.x(range(2))
display(qc.draw('mpl'))
#display(show_unitary(get_unitary(qc)))
display(show_state(qc))
display(plot_histogram(measure(qc, qubits=[4])))
#memory with teleportation
addr = QuantumRegister(1, name="addr")
data = QuantumRegister(1, name="data")
mem = QuantumCircuit(addr, data, name="qrom")
mem.cry(np.pi/5, 0, 1)
display(mem.draw('mpl'))
display(show_unitary(get_unitary(mem)))
show_state(mem)
addr = QuantumRegister(1, name="addr")
data = QuantumRegister(2, name="data")
q = QuantumRegister(1, name="q")
out = ClassicalRegister(1, name="c")
qc = QuantumCircuit(addr, data, q, out)
qc.x(addr)
qc.barrier(addr)
qc.append(mem, [addr, data[0]])
qc.cx(data[0], q)
qc.barrier(addr)
qc.append(mem, [addr, data[0]])
qc.x(addr)
display(qc.draw('mpl'))
#display(show_unitary(get_unitary(qc)))
display(show_state(qc))
display(plot_histogram(measure(qc, qubits=[3])))
addr = QuantumRegister(1, name="addr")
data = QuantumRegister(2, name="data")
q = QuantumRegister(1, name="q")
out = ClassicalRegister(1, name="c")
qc = QuantumCircuit(addr, data, q, out)
qc.x(addr)
qc.barrier(addr)
qc.append(mem, [addr, data[0]])
qc.h(data[1])
qc.cx(data[1], q)
qc.cx(data[0], data[1])
qc.h(data[0])
qc.cx(data[1], q)
qc.cz(data[0], q)
display(qc.draw('mpl'))
#display(show_unitary(get_unitary(qc)))
display(show_state(qc))
display(plot_histogram(measure(qc, qubits=[3])))
display(plot_histogram(measure(qc, qubits=[1])))
(np.cos(np.pi/5/2))**2, (np.sin(np.pi/5/2))**2
qc = QuantumCircuit(3,3)
qc.ry(np.pi/5, 0)
qc.barrier()
qc.h(1)
qc.cx(1,2)
qc.barrier()
qc.cx(0,1)
qc.h(0)
qc.cx(1,2)
qc.cz(0,2)
qc.draw('mpl')
display(qc.draw('mpl'))
#display(show_unitary(get_unitary(qc)))
display(show_state(qc))
display(plot_histogram(measure(qc, qubits=[2])))
data = QuantumRegister(1, name="data")
teleportation_provider = QuantumRegister(1, name="t")
q = QuantumRegister(1, name="q")
meas = ClassicalRegister(1, name="out")
qram = QuantumCircuit(data, teleportation_provider, q,meas)
qram.h(teleportation_provider)
qram.cx(teleportation_provider, data)
qram.barrier()
qram.ry(np.pi/7, q)
qram.barrier()
qram.cx(q, teleportation_provider)
qram.h(q)
qram.cx(teleportation_provider, data)
qram.cz(q, data)
display(qram.draw('mpl'))
#display(show_unitary(get_unitary(qram)))
display(show_state(qram))
display(plot_histogram(measure(qram, qubits=[0])))
display(plot_histogram(measure(qram, qubits=[2])))
np.cos(np.pi/7/2)**2, np.sin(np.pi/7/2)**2
data = QuantumRegister(2, name="data")
teleportation_provider = QuantumRegister(2, name="t")
q = QuantumRegister(2, name="q")
meas = ClassicalRegister(1, name="out")
qram = QuantumCircuit(data, teleportation_provider, q,meas)
qram.h(teleportation_provider)
qram.cx(teleportation_provider, data)
qram.barrier()
qram.ry(np.pi/3, q[0])
qram.ry(np.pi/7, q[1])
qram.barrier()
qram.cx(q, teleportation_provider)
qram.h(q)
qram.cx(teleportation_provider, data)
qram.cz(q, data)
display(qram.draw('mpl', filename=get_image_path('qram.png')))
#display(show_unitary(get_unitary(qram)))
display(show_state(qram))
display(plot_histogram(measure(qram, qubits=[0])))
display(plot_histogram(measure(qram, qubits=[4])))
display(plot_histogram(measure(qram, qubits=[1])))
display(plot_histogram(measure(qram, qubits=[5])))
np.cos(np.pi/3/2)**2, np.sin(np.pi/3/2)**2
data = QuantumRegister(2, name="data")
teleportation_provider = QuantumRegister(2, name="t")
q = QuantumRegister(2, name="q")
meas = ClassicalRegister(1, name="out")
qram = QuantumCircuit(data, teleportation_provider, q,meas)
qram.h(teleportation_provider)
qram.cx(teleportation_provider, data)
qram.barrier()
qram.h(q[0])
qram.h(q[1])
qram.barrier()
qram.cx(q, teleportation_provider)
qram.h(q)
qram.cx(teleportation_provider, data)
qram.cz(q, data)
qram.barrier(label='second')
qram.cz(q, data)
qram.cx(teleportation_provider, data)
qram.h(q)
qram.cx(q, teleportation_provider)
qram.barrier()
qram.h(q[0])
qram.barrier()
qram.cx(q, teleportation_provider)
qram.h(q)
qram.cx(teleportation_provider, data)
qram.cz(q, data)
display(qram.draw('mpl'))
#display(show_unitary(get_unitary(qram)))
display(show_state(qram))
display(plot_histogram(measure(qram, qubits=[0])))
display(plot_histogram(measure(qram, qubits=[4])))
display(plot_histogram(measure(qram, qubits=[1])))
display(plot_histogram(measure(qram, qubits=[5])))
data = QuantumRegister(2, name="data")
teleportation_provider = QuantumRegister(1, name="t")
q = QuantumRegister(2, name="q")
meas = ClassicalRegister(1, name="out")
qram = QuantumCircuit(data, teleportation_provider, q,meas)
qram.h(teleportation_provider)
qram.cx(teleportation_provider, data)
qram.barrier()
qram.ry(np.pi/3, q[0])
qram.ry(np.pi/7, q[1])
qram.barrier()
qram.cx(q, teleportation_provider)
qram.h(q)
qram.cx(teleportation_provider, data)
qram.cz(q, data)
display(qram.draw('mpl', filename=get_image_path('qram.png')))
#display(show_unitary(get_unitary(qram)))
display(show_state(qram))
display(plot_histogram(measure(qram, qubits=[0])))
display(plot_histogram(measure(qram, qubits=[4])))
display(plot_histogram(measure(qram, qubits=[1])))
display(plot_histogram(measure(qram, qubits=[5])))
|
https://github.com/clement-boisson/kagome-vqe-on-heavy-hex
|
clement-boisson
|
import numpy as np
import random
import math
from qiskit import QuantumCircuit
class HeavyHexKagomeEstimator:
"""
Custom estimator designed for the XXX Heisenberg hamiltonian on a Kagome lattice
to be run on a quantum computer based on the Heavy Hex architecture (like the IBMQ
Guadalupe).
It uses 2 error mitigation mechnisms:
- Twirled REadout eXtinction algorithm (T-REx)
- Circuit error mitigation based on control qubits
"""
def __init__(self, device_edges, kagome_triangles):
"""
Create an instance of the estimator.
Caution: this function does NOT check that the kagome lattice, the device and the mapping are correct
Args:
device_edges (List[Tuple[int]]): list of connected qubits on the device
kagome_triangles (List[dict]): list of kagome triangle with a possible control qubit (e.g. {"kagome": (0, 2, 4), "control": 1})
"""
# Save the arguments
self.device_edges = device_edges
self.kagome_triangles = kagome_triangles
# Compute the number of physical qubits, and
self.qubit_count = np.max(self.device_edges) + 1
# Compute the list of Kagome edges and vertices (used to compute the energy)
self.kagome_edges = []
self.kagome_vertices = []
for triangle in self.kagome_triangles:
self.kagome_edges.append([triangle["kagome"][0], triangle["kagome"][1]])
self.kagome_edges.append([triangle["kagome"][1], triangle["kagome"][2]])
self.kagome_edges.append([triangle["kagome"][2], triangle["kagome"][0]])
for vertex in triangle["kagome"]:
if vertex not in self.kagome_vertices:
self.kagome_vertices.append(vertex)
def qiskit_number_to_bit_array(self, qiskit_number):
"""
Convert a number returned by the qiskit sampler primitive to a tuple containing '0' or '1'
for each qubit. Qiskit uses little-endian convention, hence the use of reversed.
Example: 3 will be converted to ('1', '1', '0', '0', '0', '0') in a 6-qubit context.
Args:
qiskit_number(int): the number returned as a key of a qiskit sampler result
Returns:
bitstring (tuple[str]): the tuple that we can use to easily get the value of a qubit
"""
pattern = "{0:0" + str(self.qubit_count) + "b}" # generates "{0:016b}" for qubit_count=16
return tuple(reversed(list(pattern.format(int(qiskit_number)))))
def post_process_qiskit_quasi_dists(self, quasi_dists):
"""
Convert a number returned by the qiskit sampler primitive to a tuple containing '0' or '1'
for each qubit. Qiskit uses little-endian convention, hence the use of reversed.
Example: 3 will be converted to ('1', '1', '0', '0', '0', '0') in a 6-qubit context.
Args:
qiskit_number(int): the number returned as a key of a qiskit sampler result
Returns:
quasi_dists (List[dict]): the quasi_dists with converted keys
"""
for i, quasi_dist in enumerate(quasi_dists):
quasi_dists[i] = {self.qiskit_number_to_bit_array(qiskit_number):quasi_dist[qiskit_number] for qiskit_number in quasi_dist.keys()}
return quasi_dists
def TREx_f(self, gatestrings, quasi_dists, s):
"""
Compute the f function of the T-REx algorithm (see https://arxiv.org/abs/2012.09738)
Note that the probabilities don't have to sum up to 1.0 for each circuit
Args:
gatestrings (List[tuple(str)]): a list of tuples like ('I', 'X', ..., 'I') indicating whether there is an X gate or not in the circuit
quasi_dists (List[dict]): for each circuit, the result of the sampler
s (tuple(str)): a tuple like ('I', 'Z', 'Z', ..., 'I', 'I') indicating the targeted pauli hamiltonian
Returns:
gatestrings (List[tuple(str)]): the list of circuits as a tuple indicating if inserting an X gate or not
"""
# Instead of working with D as in the paper, we'll use probabilities
result = 0.0
probs_sum = 0.0
# For each circuit:
for q_idx in range(len(gatestrings)):
q = gatestrings[q_idx] # same q as in the paper
# Compute \gamma_{s,q} as in the paper, i.e. checking if q and s commute:
gamma_sq_ct = 0
for i in range(len(s)):
if s[i] == 'I' or q[i] == 'I' or s[i] == q[i]:
gamma_sq_ct += 0
else:
gamma_sq_ct += 1
# Use the definition of \gamma_{s,q} (1 if q and s commute, -1 otherwise)
gamma_sq = -1
if gamma_sq_ct % 2 == 0:
gamma_sq = 1
# Loop over x, the measurements of the qubits:
for x in quasi_dists[q_idx].keys():
# compute <s,x>
sx = 0
for i in range(self.qubit_count):
if s[i] == 'Z' and x[i] == '1':
sx += 1
# add probability * \gamma_{s,q} * (-1)^{<s,x>}
prob = quasi_dists[q_idx][x]
result += prob * gamma_sq * (-1)**sx
probs_sum += prob
if probs_sum == 0.0:
return 0.0 # In order to avoid an exception in special cases such as noiseless environments
return result / probs_sum
def generate_balanced_random_X_gates(self, num_twirled_circuits, where_to_apply):
"""
Generates a list of twirled circuits X instructions.
In order to ensure both 0s and 1s well distributed, for each qubit, we take randomly
half of circuits and set a X gate, keeping the other half unchanged.
Example:
For 3 qubits, num_twirled_circuits=2 and where_to_apply=[0], it will return:
[('X', 'I', 'I'), ('I', 'I', 'I')]
or
[('I', 'I', 'I'), ('X', 'I', 'I')]
with half of the circuits having an X gate for the qubit #0
Args:
num_twirled_circuits (int): number of twirled circuits to use
where_to_apply (List[int]): the list of qubits where we want to apply randomly an X gate
Returns:
gatestrings (List[tuple(str)]): the list of circuits as a tuple indicating if inserting an X gate or not
"""
gatestrings = []
for i in range(num_twirled_circuits):
gatestrings.append(['I' for i in range(self.qubit_count)])
gatestring_indices = [i for i in range(num_twirled_circuits)]
for i in where_to_apply:
random.shuffle(gatestring_indices)
for k in range(num_twirled_circuits//2):
gatestrings[gatestring_indices[k]][i] = 'X'
return gatestrings
def calibrate(self, sampler, num_twirled_circuits, shots):
"""
Calibrate the estimator
Args:
sampler: the sampler to use
num_twirled_circuits (int): number of twirled circuits to use
shots (int): number of shots per circuit to use
"""
# 1. Prepare calibration circuits with, for each qubit, either an X gate or no gate
# Let's prepare when apply X gates for all qubits
gatestrings = self.generate_balanced_random_X_gates(num_twirled_circuits, [i for i in range(self.qubit_count)])
# Use the generated gate strings to generate actual circuits
calib_circs = []
for i in range(num_twirled_circuits):
# Create a circuit
circ = QuantumCircuit(self.qubit_count, self.qubit_count)
# Choose randomly for each qubit if applying an X gate or not
gatestring = gatestrings[i]
# Add a X gate when necessary
for qubit in range(self.qubit_count):
if gatestring[qubit] == 'X':
circ.x(qubit)
# Measure all qubits
for qubit in range(self.qubit_count):
circ.measure(qubit, qubit)
# Add the circuit
calib_circs.append({
"circuit": circ,
"gatestring": gatestring
})
# 2. Execute the circuits with the sampler primitive
job = sampler.run([el["circuit"] for el in calib_circs], [[] for el in calib_circs], shots=shots)
quasi_dists = self.post_process_qiskit_quasi_dists(job.result().quasi_dists)
# 3. For all the kagome edges, compute the T-REx calibration value that will make it possible to
# later estimate the edge hamiltonian energies
self.trex_edge_calibrations = {} # key: the edge, value: the result of the f function for the T-REx calibration
for edge in self.kagome_edges:
# Prepare s (as in the T-REx paper) for this edge, i.e. the Z-pauli measurement hamiltonian
s = ['I' for i in range(self.qubit_count)]
s[edge[0]] = 'Z'
s[edge[1]] = 'Z'
fvalue = self.TREx_f([el["gatestring"] for el in calib_circs], quasi_dists, s)
self.trex_edge_calibrations[(edge[0], edge[1])] = fvalue
self.trex_edge_calibrations[(edge[1], edge[0])] = fvalue
# 4. For all the control qubits, estimate the probability of the qubit being 0/1 given a measurement of 0/1
# under uniform apriori distribution
self.control_qubit_measuring_probs = {} # key: qubit number, value: dictionary of probability (see below)
for triangle in self.kagome_triangles:
# If there is no control qubit in the triangle, just ignore it
if triangle["control"] == None:
continue
# Compute the likelihood probabilities (probability of measuring 0/1 given a ground-truth 0/1)
# ("p" as Probability, "t" as True value, "m" as Measured value)
pm0_t0 = 0.0 # 0 given a ground-truth of 0
pm1_t0 = 0.0
pm0_t1 = 0.0
pm1_t1 = 0.0
for circ_idx in range(len(calib_circs)):
for measure in quasi_dists[circ_idx].keys():
if measure[triangle["control"]] == '0': # measuring 0
if calib_circs[circ_idx]["gatestring"][triangle["control"]] == 'I': # ground-truth is 0
pm0_t0 += quasi_dists[circ_idx][measure]
else: # ground-truth is 1
pm0_t1 += quasi_dists[circ_idx][measure]
else: # measuring 1
if calib_circs[circ_idx]["gatestring"][triangle["control"]] == 'I': # ground-truth is 0
pm1_t0 += quasi_dists[circ_idx][measure]
else: # ground-truth is 1
pm1_t1 += quasi_dists[circ_idx][measure]
# Normalize in order to have pm0_t0+pm1_t0=1.0 and pm0_t1+pm1_t1=1.0
p_t0 = pm0_t0+pm1_t0
pm0_t0 /= p_t0
pm1_t0 /= p_t0
p_t1 = pm0_t1+pm1_t1
pm0_t1 /= p_t1
pm1_t1 /= p_t1
# Deriving the probabilities under uniform apriori distribution
self.control_qubit_measuring_probs[triangle["control"]] = {
"pt0_m1": pm1_t0/(pm1_t0+pm0_t0), # probability that the qubit has a true value 0 given a measurement of 1
"pt1_m0": pm0_t1/(pm0_t1+pm1_t1) # probability that the qubit has a true value 1 given a measurement of 0
}
def estimate_energy_for_circuit(self, base_circuit, sampler, num_twirled_circuits, shots):
"""
Estimates the energy (expectaction value of the hamiltonian) for a circuit.
Args:
base_circuit: a quantum circuit
sampler: the sampler to use
num_twirled_circuits (int): number of twirled circuits to use
shots (int): number of shots per circuit to use
Returns:
result (dict): a dictionary containing the value of the energy ("energy" key) and other information
"""
# 1. Let's build a list of circuits to use with the Sampler primitive
# We want circuits for the X, Y, and the Z part of the hamiltonian,
# and randomly apply X gate before measurement (for the T-REx readout error mitigation algorithm)
circuits = []
# For X, Y or Z:
for xyz in ["X", "Y", "Z"]:
circ_xyz = base_circuit.copy()
# Let's generate random X gates (for kagome vertices only):
gatestrings = self.generate_balanced_random_X_gates(num_twirled_circuits, self.kagome_vertices)
# Add the basis change to all the kagome vertices for X, Y or Z measurement
if xyz == "X":
circ_xyz.rz(math.pi/2.0, self.kagome_vertices)
circ_xyz.sx(self.kagome_vertices)
circ_xyz.rz(math.pi/2.0, self.kagome_vertices)
elif xyz == "Y":
circ_xyz.sx(self.kagome_vertices)
circ_xyz.rz(math.pi/2.0, self.kagome_vertices)
elif xyz == "Z":
pass # nothing to do for Z measurement
# And then we apply the X gates (for T-REx) and measuring
for gatestring in gatestrings:
circ = circ_xyz.copy()
# Add X gates:
for qubit in range(self.qubit_count):
if gatestring[qubit] == 'X':
circ.x(qubit)
# Add measurements:
circ.measure([i for i in range(self.qubit_count)], [i for i in range(self.qubit_count)])
# Add the circuit
circuits.append({
"circuit": circ,
"xyz": xyz,
"gatestring": gatestring
})
# 2. Execute the circuits with the sampler primitive
job = sampler.run([el["circuit"] for el in circuits], [[] for el in circuits], shots=shots)
quasi_dists = self.post_process_qiskit_quasi_dists(job.result().quasi_dists)
for i, quasi_dist in enumerate(quasi_dists):
circuits[i]["quasi_dist"] = quasi_dist # add the results to the circuits variable
# 3. For each triangle, and for each X,Y,Z, let's estimate the energy
triangle_results = []
for xyz in ["X", "Y", "Z"]:
xyz_circuits = [el for el in circuits if el["xyz"] == xyz] # keep the results corresponding to xyz
# For each triangle:
for triangle_idx, triangle in enumerate(self.kagome_triangles):
# List the kagome edges belonging to the triangle:
triangle_edges = [
(triangle["kagome"][0], triangle["kagome"][1]),
(triangle["kagome"][1], triangle["kagome"][2]),
(triangle["kagome"][2], triangle["kagome"][0])
]
# First, compute the triangle energy with just the T-REx algorithm
# without the control-qubit error mitigation (as a comparison)
triangle_energy_without_control = 0.0
for edge in triangle_edges:
# Prepare s (as in the T-REx paper) for this edge, i.e. the Z-pauli measurement hamiltonian
s = ['I' for i in range(self.qubit_count)]
s[edge[0]] = 'Z'
s[edge[1]] = 'Z'
# Estimate the edge energy, as in the T-REx paper
edge_energy = self.TREx_f([el["gatestring"] for el in xyz_circuits], [el["quasi_dist"] for el in xyz_circuits], s) / self.trex_edge_calibrations[edge]
# add the edge energy to the triangle energy
triangle_energy_without_control += edge_energy
# If the triangle has no control qubit, we just use the T-Rex algorithm
if triangle["control"] == None:
triangle_energy = triangle_energy_without_control
# If the triangle has a control qubit:
else:
# Compute p0: frequency of measuring 0 for the control qubit
p0 = 0.0
for circ in xyz_circuits:
for measure in circ["quasi_dist"].keys():
if measure[triangle["control"]] == '0': # if 0 is measured
p0 += circ["quasi_dist"][measure] # then we add the associated probability
p0 /= len(xyz_circuits) # there are several circuits, we need to normalize so that p0+p1=1
# Compute p1: frequency of measuring 1 for the control qubit
p1 = 1.0 - p0
# Separate the results of quasi_distributions depending on the measure on the control qubit:
quasi_dists0 = [{k:circ["quasi_dist"][k] for k in circ["quasi_dist"] if k[triangle["control"]] == '0'} for circ in xyz_circuits]
quasi_dists1 = [{k:circ["quasi_dist"][k] for k in circ["quasi_dist"] if k[triangle["control"]] == '1'} for circ in xyz_circuits]
# Compute E0: the energy associated with measuring 0 for the control qubit
E0 = 0.0
for edge in triangle_edges:
# Prepare s (as in the T-Rex paper) for this edge, i.e. the Z-pauli measurement hamiltonian
s = ['I' for i in range(self.qubit_count)]
s[edge[0]] = 'Z'
s[edge[1]] = 'Z'
# Estimate the edge energy, as in the T-Rex paper
edge_energy = self.TREx_f([el["gatestring"] for el in xyz_circuits], quasi_dists0, s) / self.trex_edge_calibrations[edge]
# add the edge energy to the triangle energy
E0 += edge_energy
# Compute E1: the energy associated with measuring 1 for the control qubit
E1 = 0.0
for edge in triangle_edges:
# Prepare s (as in the T-Rex paper) for this edge, i.e. the Z-pauli measurement hamiltonian
s = ['I' for i in range(self.qubit_count)]
s[edge[0]] = 'Z'
s[edge[1]] = 'Z'
# Estimate the edge energy, as in the T-Rex paper
edge_energy = self.TREx_f([el["gatestring"] for el in xyz_circuits], quasi_dists1, s) / self.trex_edge_calibrations[edge]
# add the edge energy to the triangle energy
E1 += edge_energy
# Apply a correction by taking into account readout errors on the control qubits
# and find corrected values p0c, p1c, E0c, E1c ("c" as corrected)
# Retrieve the probability of the control qubit
pt0_m1 = self.control_qubit_measuring_probs[triangle["control"]]["pt0_m1"] # probability of being 0 given that 1 is measured
pt1_m0 = self.control_qubit_measuring_probs[triangle["control"]]["pt1_m0"] # probability of being 1 given that 0 is measured
# The equations for correction are:
# E0 = (1-pt1_m0) * E0c + pt1_m0 * E1c
# E1 = (1-pt0_m1) * E1c + pt0_m1 * E0c
# p0 = (1-pt1_m0) * p0c + pt1_m0 * p1c
# p1 = (1-pt0_m1) * p1c + pt0_m1 * p0c
# Let's derive the corrected values (equivalent to inverting a 2x2 matrix)
E1c = ((1-pt1_m0)*E1 - pt0_m1*E0)/(1-pt0_m1-pt1_m0)
p1c = ((1-pt1_m0)*p1 - pt0_m1*p0)/(1-pt0_m1-pt1_m0)
E0c = ((1-pt0_m1)*E0 - pt1_m0*E1)/(1-pt0_m1-pt1_m0)
p0c = ((1-pt0_m1)*p0 - pt1_m0*p1)/(1-pt0_m1-pt1_m0)
# Find the estimation of the targeted energy
triangle_energy = (p0c * E0c - p1c * E1c) / (p0c-p1c)
# Save results:
triangle_results.append({
"xyz": xyz,
"triangle_idx": triangle_idx,
"triangle_energy": triangle_energy,
"triangle_energy_without_control": triangle_energy_without_control
})
# 4. Return the results:
return {
"energy": np.sum([triangle_result["triangle_energy"] for triangle_result in triangle_results]),
"energy_without_control": np.sum([triangle_result["triangle_energy_without_control"] for triangle_result in triangle_results]),
"triangle_results": triangle_results
}
|
https://github.com/clement-boisson/kagome-vqe-on-heavy-hex
|
clement-boisson
|
import numpy as np
from qiskit import IBMQ, Aer
from qiskit.algorithms import QAOA, VQE, NumPyMinimumEigensolver
from qiskit.algorithms.optimizers import COBYLA
from qiskit.utils import QuantumInstance, algorithm_globals
from qiskit.providers.aer.noise.noise_model import NoiseModel
from qiskit_optimization import QuadraticProgram
from qiskit_optimization.algorithms import MinimumEigenOptimizer
from qiskit_optimization.converters import QuadraticProgramToQubo
import qiskit.test.mock as Fake
IBMQ.load_account()
IBMQ.providers()
algorithm_globals.massive = True
quadprog = QuadraticProgram("test")
quadprog.integer_var(name="x_1", lowerbound=0, upperbound=4)
quadprog.integer_var(name="x_2", lowerbound=-2, upperbound=2)
quadprog.integer_var(name="x_3", lowerbound=-2, upperbound=4)
quadprog.minimize(
linear={"x_3": -6},
quadratic={("x_1", "x_1"): 1, ("x_2", "x_2"): 1, ("x_1", "x_2"): -1}
)
quadprog.linear_constraint(linear={"x_1": 1, "x_2": 1}, sense="=", rhs=2)
quadprog.quadratic_constraint(quadratic={("x_2", "x_3"): 1}, sense=">=", rhs=1)
print(quadprog.export_as_lp_string())
def cropyield_quadratic_program(n=3):
cropyield = QuadraticProgram()
# initialize the crop types as integer variables
crops = ["Wheat", "Soybeans", "Maize", "PushPull"]
w = "Wheat"
s = "Soybeans"
m = "Maize"
p = "PushPull"
for crop in crops:
cropyield.integer_var(name=crop, lowerbound=0, upperbound=n)
l = {}
q = {}
# initialize the equation for total crop output.
# these represent how "good" each of the crop types are in terms of the final equation
# so wheat is 2x as good as soybeans and maize is 4x as good, and pushpull provides no direct benefit
l[w] = 2
l[s] = 1
l[m] = 4
# define the intercropping coefficients, aka how well certain crops will be when grown together
q[(w, s)] = 2.4
q[(w, m)] = 4
q[(w, p)] = 4
q[(s, m)] = 2
q[(s, p)] = 1
q[(m, p)] = 5
# we want to maximize the output
cropyield.maximize(linear=l, quadratic=q)
# but make sure that the sum of the number of squares is <= 3
cropyield.linear_constraint(linear={w:1, s:1, m:1, p:1}, sense="<=", rhs=n)
return cropyield
# convert the quadratic problem to a quantum problem
cropyield = cropyield_quadratic_program(n=3)
ising_operations, _ = (
QuadraticProgramToQubo()
.convert(
cropyield,
)
.to_ising()
)
print(f"Number of qubits required is {ising_operations.num_qubits}")
QuadraticProgramToQubo().convert(cropyield)
# use the Aer simulator
backend = Aer.get_backend("qasm_simulator")
algorithm_globals.random_seed = 271828
def get_classical_solution_for(quadprog: QuadraticProgram):
solver = NumPyMinimumEigensolver()
optimizer = MinimumEigenOptimizer(solver)
return optimizer.solve(quadprog)
def get_QAOA_solution_for(
quadprog: QuadraticProgram, quantumInstance: QuantumInstance, optimizer=None
):
_eval_count = 0
def callback(eval_count, parameters, mean, std):
nonlocal _eval_count
_eval_count = eval_count
solver = QAOA(
optimizer=optimizer, quantum_instance=quantumInstance, callback=callback
)
optimizer = MinimumEigenOptimizer(solver)
result = optimizer.solve(quadprog)
return result, _eval_count
def get_VQE_solution_for(
quadprog: QuadraticProgram, quantumInstance: QuantumInstance, optimizer=None,
):
_eval_count = 0
def callback(eval_count, parameters, mean, std):
nonlocal _eval_count
_eval_count = eval_count
# Create solver and optimizer
solver = VQE(
optimizer=optimizer, quantum_instance=quantumInstance, callback=callback
)
# Create optimizer for solver
optimizer = MinimumEigenOptimizer(solver)
# Get result from optimizer
result = optimizer.solve(quadprog)
return result, _eval_count
classical_result = get_classical_solution_for(cropyield)
print("Solution found using classical method:\n")
print(f"Maximum crop yield is {classical_result.fval} tons")
print("Crops used are: ")
_crops = [v.name for v in cropyield.variables]
for cropIndex, cropHectares in enumerate(classical_result.x):
print(f"\t{cropHectares} ha of {_crops[cropIndex]}")
simulator_instance = QuantumInstance(
backend=backend,
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
)
qaoa_result, qaoa_eval_count = get_QAOA_solution_for(cropyield, simulator_instance)
print("Solution found using the QAOA method:\n")
print(f"Maximum crop-yield is {qaoa_result.fval} tons")
print(f"Crops used are: ")
for cropHectares, cropName in zip(qaoa_result.x, qaoa_result.variable_names):
print(f"\t{cropHectares} ha of {cropName}")
print(f"\nThe solution was found within {qaoa_eval_count} evaluations of QAOA.")
# Create a QuantumInstance
simulator_instance = QuantumInstance(
backend=backend,
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
)
# Get VQE result
vqe_result, vqe_eval_count = get_VQE_solution_for(
cropyield, simulator_instance)
# Format and print result
print("Solution found using the VQE method:\n")
print(f"Maximum crop-yield is {vqe_result.fval} tons")
print(f"Crops used are: ")
for cropHectares, cropName in zip(vqe_result.x, vqe_result.variable_names):
print(f"\t{cropHectares} ha of {cropName}")
print(f"\nThe solution was found within {vqe_eval_count} evaluations of VQE")
problem = cropyield_quadratic_program(n=50)
for _backend in IBMQ.get_provider(hub='ibm-q', group='open', project='main').backends():
print(_backend.name())
provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')
backend_real = provider.get_backend('ibmq_qasm_simulator')
quantum_instance_real = QuantumInstance(backend_real, shots=2048)
optimizer = COBYLA(maxiter=1)
## Get result from real device with VQE
vqe_result_real, vqe_eval_count_real = get_VQE_solution_for(
problem, quantum_instance_real, optimizer=optimizer
)
# Format and print result
print("Solution found using the VQE method:\n")
print(f"Maximum crop-yield is {vqe_result_real.fval} tons")
print(f"Crops used are: ")
for cropHectares, cropName in zip(vqe_result_real.x, vqe_result_real.variable_names):
print(f"\t{cropHectares} ha of {cropName}")
print(
f"\nThe solution was found within {vqe_eval_count_real} evaluations of VQE")
|
https://github.com/xijia-tao/comp3316-a4-code
|
xijia-tao
|
import matplotlib.pyplot as plt
import numpy as np
import math
# importing Qiskit
from qiskit import Aer, transpile, assemble
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
qpe = QuantumCircuit(4, 3)
qpe.x(3)
qpe.draw()
for qubit in range(3):
qpe.h(qubit)
qpe.draw()
angle = 2*math.pi/8
repetitions = 1
for counting_qubit in range(3):
for i in range(repetitions):
qpe.cp(math.pi/4, counting_qubit, 3)
repetitions *= 2
qpe.draw()
def qft_dagger(qc, n):
for qubit in range(n//2):
qc.swap(qubit, n-qubit-1)
for j in range(n):
for m in range(j):
qc.cp(-math.pi/float(2**(j-m)), m, j)
qc.h(j)
qpe.barrier()
qft_dagger(qpe, 3)
qpe.barrier()
qpe.draw()
for n in range(3):
qpe.measure(n, n)
qpe.draw()
aer_sim = Aer.get_backend('aer_simulator')
shots = 2048
t_qpe = transpile(qpe, aer_sim)
qobj = assemble(t_qpe, shots=shots)
results = aer_sim.run(qobj).result()
counts = results.get_counts()
plot_histogram(counts)
qpe2 = QuantumCircuit(4, 3)
for qubit in range(3):
qpe2.h(qubit)
qpe2.x(3)
angle = 2*math.pi/3
repetitions = 1
for counting_qubit in range(3):
for i in range(repetitions):
qpe2.cp(angle, counting_qubit, 3);
repetitions *= 2
qft_dagger(qpe2, 3)
for n in range(3):
qpe2.measure(n, n)
qpe2.draw()
aer_sim = Aer.get_backend('aer_simulator')
shots = 2048
t_qpe2 = transpile(qpe2, aer_sim)
qobj = assemble(t_qpe2, shots=shots)
results = aer_sim.run(qobj).result()
counts = results.get_counts()
plot_histogram(counts)
qpe3 = QuantumCircuit(6, 5)
for qubit in range(5):
qpe3.h(qubit)
qpe3.x(5)
angle = 2*math.pi/3
repetitions = 1
for counting_qubit in range(5):
for i in range(repetitions):
qpe3.cp(angle, counting_qubit, 5);
repetitions *= 2
qft_dagger(qpe3, 5)
for n in range(5):
qpe3.measure(n, n)
qpe3.draw()
aer_sim = Aer.get_backend('aer_simulator')
shots = 2048
t_qpe3 = transpile(qpe3, aer_sim)
qobj = assemble(t_qpe3, shots=shots)
results = aer_sim.run(qobj).result()
counts = results.get_counts()
plot_histogram(counts)
|
https://github.com/xijia-tao/comp3316-a4-code
|
xijia-tao
|
import numpy as np
from numpy import pi
# importing Qiskit
from qiskit import QuantumCircuit, transpile, assemble, Aer
from qiskit.visualization import plot_histogram, plot_bloch_multivector
qc = QuantumCircuit(3)
qc.h(2)
qc.cp(pi/2, 1, 2)
qc.cp(pi/4, 0, 2)
qc.h(1)
qc.cp(pi/2, 0, 1)
qc.h(0)
qc.swap(0, 2)
qc.draw()
def qft_rotations(circuit, n):
if n == 0:
return circuit
n -= 1
circuit.h(n)
for qubit in range(n):
circuit.cp(pi/2**(n-qubit), qubit, n)
qft_rotations(circuit, n)
def swap_registers(circuit, n):
for qubit in range(n//2):
circuit.swap(qubit, n-qubit-1)
return circuit
def qft(circuit, n):
qft_rotations(circuit, n)
swap_registers(circuit, n)
return circuit
qc = QuantumCircuit(4)
qft(qc,4)
qc.draw()
# Create the circuit
qc = QuantumCircuit(3)
# Encode the state 5 (101 in binary)
qc.x(0)
qc.x(2)
qc.draw()
sim = Aer.get_backend("aer_simulator")
qc_init = qc.copy()
qc_init.save_statevector()
statevector = sim.run(qc_init).result().get_statevector()
plot_bloch_multivector(statevector)
qft(qc, 3)
qc.draw()
qc.save_statevector()
statevector = sim.run(qc).result().get_statevector()
plot_bloch_multivector(statevector)
|
https://github.com/sooodos/Quantum-Computing-Learning-Gate
|
sooodos
|
from datetime import datetime
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, BasicAer, execute, IBMQ, transpile
from qiskit.providers import BaseJob
from qiskit.providers.ibmq import least_busy, IBMQJobManager
from qiskit.providers.ibmq.managed import ManagedJobSet
from qiskit.visualization import plot_histogram
import constants
from QCLG_lvl3.classical.bernstein_vazirani_classical import BersteinVaziraniClassical
from QCLG_lvl3.classical.classical_xor import ClassicalXor
from QCLG_lvl3.classical.random_binary import RandomBinary
from QCLG_lvl3.quantum_algorithms.bernstein_vazirani import BernsteinVazirani
from QCLG_lvl3.quantum_algorithms.deutsch_josza import DeutschJosza
from credentials import account_details
class Tools:
@classmethod
def calculate_elapsed_time(cls, first_step: datetime, last_step: datetime):
difference = last_step - first_step
return difference.total_seconds()
@classmethod
def run_on_simulator(cls, circuit: QuantumCircuit):
# use local simulator
backend = BasicAer.get_backend('qasm_simulator')
shots = 1024
results = execute(circuit, backend=backend, shots=shots).result()
answer = results.get_counts()
max_value = 0
max_key = ""
for key, value in answer.items():
if value > max_value:
max_value = value
max_key = key
return max_key[::-1]
@classmethod
def run_on_real_device(cls, circuit: QuantumCircuit, least_busy_backend):
from qiskit.tools.monitor import job_monitor
shots = int(input("Number of shots (distinct executions to run this experiment: )"))
job = execute(circuit, backend=least_busy_backend, shots=shots, optimization_level=3)
job_monitor(job, interval=2)
return job
@classmethod
def find_least_busy_backend_from_open(cls, n):
if account_details.account_token_open is None:
account_token = input("Insert your account token: ")
else:
account_token = account_details.account_token_open
if IBMQ.active_account() is None:
IBMQ.enable_account(account_token)
provider = IBMQ.get_provider(hub='ibm-q')
return least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= (n + 1) and
not x.configuration().simulator and x.status().operational == True))
@classmethod
def find_least_busy_backend_from_research(cls, n):
if account_details.account_token_research is None \
or account_details.hub is None \
or account_details.group is None \
or account_details.project is None:
account_token = input("Insert your account token: ")
hub = input("Insert your hub: ")
group = input("Insert your group: ")
project = input("Insert your project: ")
else:
account_token = account_details.account_token_research
hub = account_details.hub
group = account_details.group
project = account_details.project
IBMQ.enable_account(account_token)
provider = IBMQ.get_provider(hub=hub, group=group, project=project)
print(provider)
return least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= (n + 1) and
not x.configuration().simulator and x.status().operational == True))
@classmethod
def print_simul(cls, answer_of_simul, algorithm: str):
print(constants.algorithms[int(algorithm)])
print("\nMeasurements: ", answer_of_simul)
return
@classmethod
def print_real(cls, job: BaseJob, least_busy_backend, algorithm: str):
results = job.result()
answer = results.get_counts()
print("\nTotal counts are:", answer)
elapsed = results.time_taken
print(f"The time it took for the experiment to complete after validation was {elapsed} seconds")
plot_histogram(data=answer, title=f"{constants.algorithms[int(algorithm)]} on {least_busy_backend}")
plt.show()
return
@classmethod
def execute_classically(cls, algorithm):
if algorithm == "0":
return cls.execute_deutsch_josza_classically()
elif algorithm == "1":
return cls.execute_bernstein_vazirani_classically()
@classmethod
def execute_in_simulator(cls, algorithm):
dj_circuit = None
if algorithm == "0":
bits = str(input("Enter a bit sequence for the quantum circuit:"))
dj_circuit = DeutschJosza.deutsch_josza(bits, eval_mode=False)
elif algorithm == "1":
decimals = int(input("Give the upper limit of the random number: "))
random_binary = RandomBinary.generate_random_binary(decimals)
dj_circuit = BernsteinVazirani.bernstein_vazirani(random_binary, eval_mode=False)
return cls.run_on_simulator(dj_circuit)
@classmethod
def execute_in_real_device(cls, algorithm):
if algorithm == "0":
answer = cls.execute_dj_in_real_device()
return answer
elif algorithm == "1":
decimals = int(input("Give the upper limit of the random number: "))
random_binary = RandomBinary.generate_random_binary(decimals)
answer = cls.execute_bv_in_real_device(random_binary)
return answer
@classmethod
def execute_dj_in_real_device(cls):
bits = str(input("Enter a bit sequence for the quantum circuit:"))
least_busy_backend = Tools.choose_from_provider(len(bits) + 1)
dj_circuit = DeutschJosza.deutsch_josza(bits, eval_mode=False)
answer_of_real = Tools.run_on_real_device(dj_circuit, least_busy_backend)
print(f"least busy is {least_busy_backend}")
return answer_of_real
@classmethod
def execute_bv_in_real_device(cls, random_binary: str):
dj_circuit = BernsteinVazirani.bernstein_vazirani(random_binary, eval_mode=False)
least_busy_backend = Tools.choose_from_provider(dj_circuit.qubits)
answer_of_real = Tools.run_on_real_device(dj_circuit, least_busy_backend)
print(f"least busy is {least_busy_backend}")
return answer_of_real
@classmethod
def choose_from_provider(cls, size: int):
least_busy_backend = None
research = input("Do you want to run this experiment on the research backends? (Y/N)")
while research != "Y" and research != "N":
research = input("Do you want to run this experiment on the research backends? (Y/N)")
if research == "N":
least_busy_backend = Tools.find_least_busy_backend_from_open(size)
elif research == "Y":
least_busy_backend = Tools.find_least_busy_backend_from_research(size)
return least_busy_backend
@classmethod
def execute_deutsch_josza_classically(cls):
number_of_bits = int(input("Enter number of bits for a the classical solution:"))
return ClassicalXor.execute_classical_xor(bits=number_of_bits)
@classmethod
def execute_bernstein_vazirani_classically(cls):
decimals = int(input("Give the upper limit of the random number: "))
random_binary = RandomBinary.generate_random_binary(decimals)
return BersteinVaziraniClassical.guess_number(random_binary)
@classmethod
def print_classical_answer(cls, classical_answer, algorithm):
time_to_generate_worst_input = classical_answer[0]
execution_time = classical_answer[1]
bits = classical_answer[2]
function_nature = classical_answer[3]
print(f"Results of classical implementation for the {constants.algorithms[int(algorithm)]} Algorithm:")
print(f"Function is {function_nature}")
print(f"Time to generate worse input for {bits} bits took {time_to_generate_worst_input} seconds.")
print(f"Determining if xor is balanced for {bits} bits took {execution_time} seconds.")
print(classical_answer)
@classmethod
def execute_both(cls, algorithm):
answer = []
if algorithm == "0":
classical = cls.execute_deutsch_josza_classically()
real = cls.execute_dj_in_real_device()
answer.append(classical)
answer.append(real)
elif algorithm == " 1":
classical = cls.execute_bernstein_vazirani_classically()
real = cls.execute_bv_in_real_device(classical)
answer.append(classical)
answer.append(real)
return answer
# #################################################################################################################
# Evaluation methods
@classmethod
def prepare_dj(cls, bits: int):
bit_sequence = "0" * bits
dj_circuit = DeutschJosza.deutsch_josza(bit_sequence, eval_mode=True)
return dj_circuit
@classmethod
def prepare_bv(cls, random_binary: str):
bj_circuit = BernsteinVazirani.bernstein_vazirani(random_binary, eval_mode=True)
return bj_circuit
@classmethod
def deutsch_josza_classical(cls, bits: int):
return ClassicalXor.execute_classical_xor(bits=bits)
@classmethod
def bernstein_vazirani_classical(cls, bits: int):
random_binary = RandomBinary.generate_random_binary_v2(bits)
return BersteinVaziraniClassical.guess_number(random_binary)
@classmethod
def run_batch_job(cls, circuits: list, least_busy_backend) -> ManagedJobSet:
transpiled_circuits = transpile(circuits, backend=least_busy_backend)
# Use Job Manager to break the circuits into multiple jobs.
job_manager = IBMQJobManager()
job_set_eval = job_manager.run(transpiled_circuits, backend=least_busy_backend, name='eval',
max_experiments_per_job=1) # max_experiments_per_job =1 very important to get
# individual execution times
return job_set_eval
|
https://github.com/sooodos/Quantum-Computing-Learning-Gate
|
sooodos
|
from qiskit import IBMQ
from qiskit import (
QuantumCircuit,
execute,
Aer)
class HelloWorld:
@classmethod
def run(cls):
with open('./credentials/token', 'r') as file:
token = file.read()
IBMQ.save_account(token, overwrite=True)
# Use Aer's qasm_simulator
simulator = Aer.get_backend('qasm_simulator')
# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(2, 2)
# Add a H gate on qubit 0
circuit.h(0)
# Add a CX (CNOT) gate on control qubit 0 and target qubit 1
circuit.cx(0, 1)
# Map the quantum measurement to the classical bits
circuit.measure([0, 1], [0, 1])
# Execute the circuit on the qasm simulator
job = execute(circuit, simulator, shots=1024)
# Grab results from the job
result = job.result()
# Returns counts
counts = result.get_counts(circuit)
print("Results for the Bell State experiment.")
print("\nTotal count for 00 and 11 are:", counts)
# Draw the circuit
print(circuit)
|
https://github.com/sooodos/Quantum-Computing-Learning-Gate
|
sooodos
|
from qiskit import execute, Aer, QuantumCircuit
class Interference:
@classmethod
def run(cls):
# Use Aer's qasm_simulator
simulator = Aer.get_backend('qasm_simulator')
# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(1, 1)
# Add a H gate on qubit 0
circuit.h(0)
# Add another H gate to qubit 0
circuit.h(0)
# Map the quantum measurement to the classical bits
circuit.measure(0, 0)
# Execute the circuit on the qasm simulator
job = execute(circuit, simulator, shots=1000)
# Grab results from the job
result = job.result()
# Returns counts
counts = result.get_counts(circuit)
print("Results for the Quantum Interference experiment.")
print("\nTotal count for 0 and 1 are:", counts)
print(circuit)
|
https://github.com/sooodos/Quantum-Computing-Learning-Gate
|
sooodos
|
from qiskit import execute, Aer, QuantumCircuit, IBMQ
class SingleQubitSuperposition:
@classmethod
def run(cls):
# Use Aer's qasm_simulator
simulator = Aer.get_backend('qasm_simulator')
# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(1, 1)
# Add a H gate on qubit 0
circuit.h(0)
# Map the quantum measurement to the classical bits
circuit.measure(0, 0)
# Execute the circuit on the qasm simulator
job = execute(circuit, simulator, shots=1000)
# Grab results from the job
result = job.result()
# Returns counts
counts = result.get_counts(circuit)
print("\nTotal count for 0 and 1 are:", counts)
provider = IBMQ.load_account()
backend = provider.backends.ibmq_valencia
# Execute the circuit on a real device
job = execute(circuit, backend=backend, shots=1000)
# Grab results from the job
result = job.result()
# Returns counts
counts = result.get_counts(circuit)
print("\nTotal count for 0 and 1 are:", counts)
# Draw the circuit
print(circuit)
|
https://github.com/sooodos/Quantum-Computing-Learning-Gate
|
sooodos
|
from qiskit import execute, Aer, QuantumCircuit, IBMQ
class ThreeQubitSuperposition:
@classmethod
def run(cls):
# Use Aer's qasm_simulator
simulator = Aer.get_backend('qasm_simulator')
# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(3, 3)
# Add a H gate on qubit 0
circuit.h(0)
circuit.h(1)
circuit.h(2)
# Map the quantum measurement to the classical bits
for i in range(3):
circuit.measure(i, i)
# Execute the circuit on the qasm simulator
job = execute(circuit, simulator, shots=1024)
# Grab results from the job
result = job.result()
# Returns counts
counts = result.get_counts(circuit)
print("\nTotal count all possible states are:", counts)
provider = IBMQ.load_account()
backend = provider.backends.ibmq_valencia
# Execute the circuit on a real device
job = execute(circuit, backend=backend, shots=1024)
# Grab results from the job
result = job.result()
# Returns counts
counts = result.get_counts(circuit)
print("\nTotal count for all possible states are:", counts)
# Draw the circuit
print(circuit)
|
https://github.com/sooodos/Quantum-Computing-Learning-Gate
|
sooodos
|
from random import randint
import numpy as np
from qiskit import execute, BasicAer
from qiskit.circuit.quantumcircuit import QuantumCircuit
class Game:
@classmethod
def run(cls, circuit: QuantumCircuit):
# use local simulator
backend = BasicAer.get_backend('qasm_simulator')
results = execute(circuit, backend=backend, shots=1024).result()
answer = results.get_counts()
max_value = 0
max_key = ""
for key, value in answer.items():
if value > max_value:
max_value = value
max_key = key
print(answer)
if max_key == "00":
print("Both players stay grounded :(")
return 0
elif max_key == "01":
print("Player 1 is excited!")
return 1
elif max_key == "10":
print("Player 2 is excited!")
return 2
elif max_key == "11":
print("Both players are excited!")
return 3
return
@classmethod
def place_gate(cls, player, field, qubit):
card = player.pop()
print(f"now inserting card {card} from player {qubit + 1}")
if card == "H":
field.h(qubit)
elif card == "X":
field.x(qubit)
elif card == "RX":
field.rx(np.pi / 2, qubit)
elif card == "CX":
if qubit == 0:
field.cx(qubit, qubit + 1)
else:
field.cx(qubit, qubit - 1)
return
@classmethod
def create_playing_field(cls, player1: list, player2: list) -> QuantumCircuit:
field = QuantumCircuit(2, 2)
player1.reverse()
player2.reverse()
while len(player1) > 0:
cls.place_gate(player1, field, 0)
while len(player2) > 0:
cls.place_gate(player2, field, 1)
field.measure(0, 0)
field.measure(1, 1)
return field
@classmethod
def generate_deck(cls) -> list:
cards = ["H", "H", "X", "X", "CX", "RX", "RX"]
deck = []
for j in range(4):
for i in range(len(cards)):
deck.append(cards[i])
return deck
@classmethod
def shuffle_deck(cls, deck: list):
for i in range(len(deck) * 5):
j = randint(0, len(deck) - 1)
k = randint(0, len(deck) - 1)
temp = deck[j]
deck[j] = deck[k]
deck[k] = temp
return
@classmethod
def deal_starting_hands(cls, player1: list, player2: list, deck: list):
for i in range(0, 4, 2):
player1.append(deck.pop())
player2.append(deck.pop())
return
@classmethod
def draw_from_deck(cls, deck: list) -> str:
return deck.pop()
@classmethod
def replace(cls, replacement_choice, card, player):
player.remove(replacement_choice)
player.append(card)
return
@classmethod
def draw(cls, player: list, deck: list):
card = cls.draw_from_deck(deck)
print("Card drawn from deck is:" + card)
user_choice = "?"
while user_choice != "y" and user_choice != "n":
user_choice = input("Do you want this card? (y/n)")
if user_choice == "y":
player.append(card)
else:
deck.insert(0, card) # put the card on the bottom of the deck
return
@classmethod
def fix_hand(cls, player: list) -> list:
new_hand = []
print("Your current hand is setup like this:")
print(player)
i = 0
while len(player) > 0:
replacement_choice = input(f"Choose one of your cards to be on position {i} :")
while replacement_choice not in player:
replacement_choice = input(f"Choose one of your cards to be on position {i} :")
new_hand.insert(len(new_hand), replacement_choice)
player.remove(replacement_choice)
print("Cards remaining in previous hands")
print(player)
i = i + 1
print("New hand")
print(new_hand)
print()
return new_hand
@classmethod
def play_the_exciting_game(cls):
deck = cls.generate_deck()
cls.shuffle_deck(deck)
player1 = []
player1_wins = 0
player2 = []
player2_wins = 0
rounds = int(input("Enter number of rounds: "))
print("The exciting game begins!")
current_round = 0
while current_round <= rounds:
countdown = 4
print("#" * (current_round + 1), end="")
print(f"ROUND {current_round}", end="")
print("#" * (current_round + 1))
print()
cls.deal_starting_hands(player1, player2, deck)
while countdown != 0:
print("\nPlayer 1")
print(player1)
cls.draw(player1, deck)
print("\nPlayer 2")
print(player2)
cls.draw(player2, deck)
countdown = countdown - 1
print(f"{countdown} dealings remain before the players have to see who's Excited!")
if countdown == 0:
print("Next turn is going to be Exciting!!!")
print("Both players get to fix their hands in the order they desire!")
player1 = cls.fix_hand(player1)
player2 = cls.fix_hand(player2)
playing_field = cls.create_playing_field(player1, player2)
print(playing_field.draw())
round_result = cls.run(playing_field)
if round_result == "1":
player1_wins = player1_wins + 1
elif round_result == "2":
player2_wins = player2_wins + 1
current_round = current_round + 1
if player1_wins > player2_wins:
print("PLAYER ONE WAS MOST EXCITED!")
elif player2_wins > player1_wins:
print("PLAYER TWO WAS MOST EXCITED!")
else:
print("PLAYERS WERE EQUALLY EXCITED!")
|
https://github.com/sooodos/Quantum-Computing-Learning-Gate
|
sooodos
|
from qiskit import QuantumCircuit
class CnotOracle:
@classmethod
def create_cnot_oracle(cls, input_string, input_length, eval_mode: bool) -> QuantumCircuit:
balanced_oracle = QuantumCircuit(input_length + 1)
# Place X-gates
for qubit in range(len(input_string)):
if input_string[qubit] == '1':
balanced_oracle.x(qubit)
# Use barrier as divider
balanced_oracle.barrier()
# Controlled-NOT gates
for qubit in range(input_length):
balanced_oracle.cx(qubit, input_length)
balanced_oracle.barrier()
# Place X-gates
for qubit in range(len(input_string)):
if input_string[qubit] == '1':
balanced_oracle.x(qubit)
if not eval_mode:
# Show oracle
print("This is the oracle function, aka the black box. NORMALLY THIS WOULD BE HIDDEN!")
print(balanced_oracle)
return balanced_oracle
|
https://github.com/sooodos/Quantum-Computing-Learning-Gate
|
sooodos
|
from qiskit import QuantumCircuit
class SecretNUmberOracle:
@classmethod
def create_secret_number_oracle(cls, random_binary, eval_mode: bool) -> QuantumCircuit:
n = len(random_binary)
secret_number_oracle = QuantumCircuit(len(random_binary) + 1, len(random_binary))
# Use barrier as divider
secret_number_oracle.barrier()
# Controlled-NOT gates
for qubit in range(len(random_binary)):
if random_binary[qubit] == '1':
secret_number_oracle.cx(qubit, n)
secret_number_oracle.barrier()
if not eval_mode:
# Show oracle
print("This is the oracle function, aka the black box. NORMALLY THIS WOULD BE HIDDEN!")
print(secret_number_oracle)
return secret_number_oracle
|
https://github.com/sooodos/Quantum-Computing-Learning-Gate
|
sooodos
|
from qiskit import QuantumCircuit
from QCLG_lvl3.oracles.secret_number_oracle import SecretNUmberOracle
class BernsteinVazirani:
@classmethod
def bernstein_vazirani(cls, random_binary, eval_mode: bool) -> QuantumCircuit:
# Construct secret number oracle
secret_number_oracle = SecretNUmberOracle.create_secret_number_oracle(random_binary=random_binary, eval_mode=eval_mode)
num_of_qubits = secret_number_oracle.num_qubits
# Construct circuit according to the length of the number
dj_circuit = QuantumCircuit(num_of_qubits, num_of_qubits - 1)
dj_circuit_before_oracle = QuantumCircuit(num_of_qubits, num_of_qubits - 1)
# Apply H-gates
for qubit in range(num_of_qubits - 1):
dj_circuit_before_oracle.h(qubit)
# Put output qubit in state |->
dj_circuit_before_oracle.x(num_of_qubits - 1)
dj_circuit_before_oracle.h(num_of_qubits - 1)
dj_circuit += dj_circuit_before_oracle
# Add oracle
dj_circuit += secret_number_oracle
dj_circuit_after_oracle = QuantumCircuit(num_of_qubits, num_of_qubits - 1)
# Repeat H-gates
for qubit in range(num_of_qubits - 1):
dj_circuit_after_oracle.h(qubit)
dj_circuit_after_oracle.barrier()
# Measure
for i in range(num_of_qubits - 1):
dj_circuit_after_oracle.measure(i, i)
dj_circuit += dj_circuit_after_oracle
if not eval_mode:
print("Circuit before the oracle\n")
print(QuantumCircuit.draw(dj_circuit_before_oracle))
print("Circuit after the oracle\n")
print(QuantumCircuit.draw(dj_circuit_after_oracle))
print(dj_circuit)
return dj_circuit
|
https://github.com/sooodos/Quantum-Computing-Learning-Gate
|
sooodos
|
from qiskit import QuantumCircuit
from QCLG_lvl3.oracles.cnot_oracle import CnotOracle
class DeutschJosza:
@classmethod
def deutsch_josza(cls, bit_string: str, eval_mode: bool) -> QuantumCircuit:
n = len(bit_string)
dj_circuit = QuantumCircuit(n + 1, n)
# Apply H-gates
for qubit in range(n):
dj_circuit.h(qubit)
# Put output qubit in state |->
dj_circuit.x(n)
dj_circuit.h(n)
# Construct balanced oracle
balanced_oracle = CnotOracle.create_cnot_oracle(bit_string, n, eval_mode)
# Add oracle
dj_circuit += balanced_oracle
# Repeat H-gates
for qubit in range(n):
dj_circuit.h(qubit)
dj_circuit.barrier()
# Measure
for i in range(n):
dj_circuit.measure(i, i)
if not eval_mode:
print(dj_circuit)
# return circuit
return dj_circuit
|
https://github.com/deadshot8086/quantum-grover-boolean-sat
|
deadshot8086
|
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates.x import MCXGate
# Class that creates and holds grover's circuit for some given expression
class GroverOperator:
def get_control_circuit(self, label="Grover"):
grit = self.main_circuit.to_gate()
grit.label = label
return grit.control()
def __init__(self, n, cnf_exp):
self.n_bits = n
eq = len(cnf_exp)
self.total_bits = n + eq + 1
main_circuit = QuantumCircuit(self.total_bits)
for i, e in enumerate(cnf_exp):
state = ''
target = n + i
pos = []
for qbit in e:
state += '0' if (qbit > 0) else '1'
pos.append(abs(qbit) - 1)
pos.append(target)
state = state[::-1]
main_circuit.append(MCXGate(len(e), None, state), pos)
oracle_rev = main_circuit.reverse_ops()
main_circuit.append(MCXGate(eq, None, '0' * eq), range(n, self.total_bits))
main_circuit = main_circuit.compose(oracle_rev)
# main_circuit.barrier()
main_circuit.h(range(n))
main_circuit.append(MCXGate(n, None, '0' * n), list(range(n)) + [self.total_bits - 1])
main_circuit.h(range(n))
# main_circuit.barrier()
self.main_circuit = main_circuit
self.control_circuit = self.get_control_circuit()
|
https://github.com/deadshot8086/quantum-grover-boolean-sat
|
deadshot8086
|
from qiskit import QuantumCircuit, Aer, execute
from math import pi, sin
from qiskit.compiler import transpile, assemble
from grover_operator import GroverOperator
def qft(n): # returns circuit for inverse quantum fourier transformation for given n
circuit = QuantumCircuit(n)
def swap_registers(circuit, n):
for qubit in range(n // 2):
circuit.swap(qubit, n - qubit - 1)
return circuit
def qft_rotations(circuit, n):
if n == 0:
return circuit
n -= 1
circuit.h(n)
for qubit in range(n):
circuit.cp(pi / 2 ** (n - qubit), qubit, n)
qft_rotations(circuit, n)
qft_rotations(circuit, n)
swap_registers(circuit, n)
return circuit
class PhaseEstimation:
def get_control_gft(self, label="QFT †"):
qft_dagger = self.qft_circuit.to_gate().inverse()
qft_dagger.label = label
return qft_dagger
def get_main_circuit(self):
qc = QuantumCircuit(self.c_bits + self.s_bits, self.c_bits) # Circuit with n+t qubits and t classical bits
# Initialize all qubits to |+>
qc.h(range(self.c_bits + self.n_bits))
qc.h(self.c_bits + self.s_bits - 1)
qc.z(self.c_bits + self.s_bits - 1)
# Begin controlled Grover iterations
iterations = 1
for qubit in range(self.c_bits):
for i in range(iterations):
qc.append(self.c_grover, [qubit] + [*range(self.c_bits, self.s_bits + self.c_bits)])
iterations *= 2
# Do inverse QFT on counting qubits
qc.append(self.c_qft, range(self.c_bits))
# Measure counting qubits
qc.measure(range(self.c_bits), range(self.c_bits))
return qc
def simulate(self):
aer_sim = Aer.get_backend('aer_simulator')
transpiled_qc = transpile(self.main_circuit, aer_sim)
qobj = assemble(transpiled_qc)
job = aer_sim.run(qobj)
hist = job.result().get_counts()
# plot_histogram(hist)
measured_int = int(max(hist, key=hist.get), 2)
theta = (measured_int / (2 ** self.c_bits)) * pi * 2
N = 2 ** self.n_bits
M = N * (sin(theta / 2) ** 2)
# print(N - M, round(N - M))
return round(N - M)
def __init__(self, grover: GroverOperator, c_bits=5):
self.c_grover = grover.get_control_circuit()
self.c_bits = c_bits
self.n_bits = grover.n_bits
self.s_bits = grover.total_bits
self.qft_circuit = qft(c_bits)
self.c_qft = self.get_control_gft()
self.main_circuit = self.get_main_circuit()
self.M = self.simulate()
|
https://github.com/deadshot8086/quantum-grover-boolean-sat
|
deadshot8086
|
from qiskit import QuantumCircuit
from math import pi, sqrt, acos
# creates final grover's circuit, based of number of solutions
class SATCircuit:
def __init__(self, n, cnf, M, grover_operator):
eq = len(cnf)
total = n + eq + 1
circuit = QuantumCircuit(total, n)
circuit.h(range(n))
circuit.h(total - 1)
circuit.z(total - 1)
itr = round(((pi / (2 * acos(sqrt((pow(2, n) - M) / pow(2, n))))) - 1) / 2)
if itr == 0:
raise SystemExit("No solution found")
for x in range(itr):
circuit = circuit.compose(grover_operator)
circuit.measure(range(n), range(n))
self.main_circuit = circuit
|
https://github.com/deadshot8086/quantum-grover-boolean-sat
|
deadshot8086
|
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
# simulate in statevector_simulator
def simulateStatevector(circuit):
backend = Aer.get_backend('statevector_simulator')
result = execute(circuit.remove_final_measurements(inplace=False), backend, shots=1).result()
counts = result.get_counts()
return result.get_statevector(circuit)
# return plot_histogram(counts, color='midnightblue', title="StateVector Histogram")
# simulate in qasm_simulator
def simulateQasm(circuit, count=1024):
backend = Aer.get_backend('qasm_simulator')
result = execute(circuit, backend, shots=count).result()
counts = result.get_counts()
return plot_histogram(counts, color='midnightblue', title="Qasm Histogram")
|
https://github.com/DeboQubie/Options-Trading
|
DeboQubie
|
from qiskit import QuantumCircuit,QuantumRegister,ClassicalRegister
from qiskit_finance.circuit.library import LogNormalDistribution
import numpy as np
from qiskit.quantum_info import Statevector
# Implementing the log-normal-distribution
# number of qubits to represent the uncertainty
num_uncertainty_qubits = 3
# parameters for considered random distribution
S = 2.0 # initial spot price
vol = 0.4 # volatility of 40%
r = 0.05 # annual interest rate of 4%
T = 300 / 365 # 40 days to maturity
# resulting parameters for log-normal distribution
mu = ((r - 0.5 * vol**2) * T + np.log(S))
# sigma = vol * np.sqrt(T)
sigma=0.1 # sigma=10%
mean = np.exp(mu + sigma**2/2)
variance = (np.exp(sigma**2) - 1) * np.exp(2*mu + sigma**2)
stddev = np.sqrt(variance)
# lowest and highest value considered for the spot price; in between, an equidistant discretization is considered.
low = np.maximum(0, mean - 3*stddev)
high = mean + 3*stddev
# construct A operator for QAE for the payoff function by
# composing the uncertainty model and the objective
uncertainty_model = LogNormalDistribution(num_uncertainty_qubits, mu=mu, sigma=sigma**2, bounds=(low, high))
uncertainty_model.draw('mpl')
# Defining some constants
num_of_qubits=3
q=QuantumRegister(num_of_qubits,name="q")
q_c=QuantumRegister(1,name="c")
q_a=QuantumRegister(1,name="a")
c=ClassicalRegister(1)
qc=QuantumCircuit(q,q_c,q_a,c)
qc.append(uncertainty_model,range(num_uncertainty_qubits))
qc.barrier()
qc.draw("mpl")
psi=Statevector(qc)
psi.draw("latex")
# To see the log normal distribution
# qc.measure(q,c)
# qc.draw('mpl')
# from qiskit import transpile
# from qiskit.providers.aer import QasmSimulator
# backend=QasmSimulator()
# qc_compiled=transpile(qc,backend)
# job = backend.run(qc_compiled,shot=1024)
# result=job.result()
# counts=result.get_counts()
# print(counts)
# from qiskit.visualization import plot_histogram
# plot_histogram(counts)
k=2 # Strike price
# Implementing the comparitor circuit for the given strike price
qc.cx(q[2],q_c[0])
qc.barrier()
qc.draw("mpl")
from math import pi
# constants
C=0.25 # scalling factor
i_max=(2**num_of_qubits)-1 #2^n-1
# f(i)=f0+f1*i
f0=-(2*C*k)/(i_max-k)
f1=(2*C)/(i_max-k)
g0=(pi/4)-C
# circuit
qc.ry(g0,q_a[0])
# making the Ry[g(i)] part
qc.ry(f0,q_a[0])
qc.cry(f1,q_c[0],q_a[0])
qc.cry(4*f1,q[2],q_a[0])
qc.cry(2*f1,q[1],q_a[0])
qc.cry(f1,q[0],q_a[0])
qc.barrier()
qc.draw('mpl')
psi=Statevector(qc)
psi.draw('latex')
qc.measure(q_a,c)
qc.draw('mpl')
from qiskit import transpile
from qiskit.providers.aer import QasmSimulator
backend=QasmSimulator()
qc_compiled=transpile(qc,backend)
job = backend.run(qc_compiled,shots=2)
result=job.result()
counts=result.get_counts()
print(counts)
from qiskit.visualization import plot_histogram
plot_histogram(counts,sort="value")
from qiskit import transpile
from qiskit.providers.aer import QasmSimulator
m=[3,5,7,9,11,13] #different no.of shots
a_l=[] # stores the expected payoff for different no.of shots
for i in m:
M=2**i
backend=QasmSimulator()
qc_compiled=transpile(qc,backend)
job = backend.run(qc_compiled,shots=M)
result=job.result()
counts=result.get_counts()
print(counts)
a_l+=[counts["1"]/(2**i)]
for i in range(len(a_l)):
print("expected payoff for m =",m[i]," is =",a_l[i])
import numpy as np
import scipy.stats as si
import sympy as sy
from sympy.stats import Normal, cdf
def euro_vanilla_call(S, K, T, r, sigma):
#S: spot price
#K: strike price
#T: time to maturity
#r: interest rate
#sigma: volatility of underlying asset
d1 = (np.log(S / K) + (r + 0.5 * sigma ** 2) * T) / (sigma * np.sqrt(T))
d2 = (np.log(S / K) + (r - 0.5 * sigma ** 2) * T) / (sigma * np.sqrt(T))
call = (S * si.norm.cdf(d1, 0.0, 1.0) - K * np.exp(-r * T) * si.norm.cdf(d2, 0.0, 1.0))
return call
print(euro_vanilla_call(S, k, T, r, sigma))
|
https://github.com/jtiosue/QAOAPython
|
jtiosue
|
import qiskit, time
from numpy import pi
# define pi so that in string gates we can have pi as an angle.
# Because we use eval for string gates. For example, gate = "rz(pi/2, 1)".
name = "IBM"
simulators = simulator, unitary_simulator, state_simulator = (
"qasm_simulator", "unitary_simulator",
"statevector_simulator"
)
quantum_computer = "ibmqx4"
def apply_credentials():
print("\nApplying credentials...\n")
# with open("qSonify/qc/APItoken.txt") as f: APItoken = f.read().strip()
try:
# qiskit.IBMQ.enable_account(APItoken)
qiskit.IBMQ.load_accounts()
print('Available backends:')
print(qiskit.IBMQ.backends())
print(qiskit.Aer.backends())
print("\nCredientials applied\n")
except:
print('Something went wrong.\nDid you enter a correct token?')
#### String algorithm methods ####
# With this, we can write an algorithm as a list with any of the keys in
# GATE_ARGUMENTS. So, for example,
# alg = ["H(0)", "RX(pi/2, 1)", "CX(1, 2)", "u3(pi/2, pi/4, .2, 0)"]
# then apply it to a qiskit.QuantumCircuit and qiskit.QuantumRegister qc and r
# respectively by calling
# apply_string_algorithm(alg, r, qc).
p = lambda x: ("reg[%d]",)*x
a = lambda x: ("%g",)*x
b = lambda x, y: "(" + ", ".join(a(x)+p(y)) + ")"
GATE_PARAMS = { ## The first number is the number of parameters,
## The second number is the number of qubit arguments.
"ccx": (0, 3), "ch": (0, 2), "crz": (1, 2), "cswap": (0, 3), "cu1": (1, 2),
"cu3": (3, 2), "cx": (0, 2), "cx_base": (0, 2), "cy": (0, 2), "cz": (0, 2),
"h": (0, 1), "iden": (0, 1), "rx": (1, 1), "ry": (1, 1), "rz": (1, 1),
"rzz": (1, 2), "s": (0, 1), "sdg": (0, 1), "swap": (0, 2), "t": (0, 1),
"tdg": (0, 1), "u0": (1, 1), "u1": (1, 1), "u2": (2, 1), "u3": (3, 1),
"u_base": (3, 1), "x": (0, 1), "y": (0, 1), "z": (0, 1),
}
GATE_ARGUMENTS = {gate: b(*args) for gate, args in GATE_PARAMS.items()}
GATE_ARGUMENTS["measure"] = "(reg[%d], c_reg[%d])"
def get_gate_info(gate):
"""
gate: str, string gate. ie H(0), or "cx(1, 0)".
returns: tuple, (gate_name (str), gate_args (tuple)).
"""
gate = gate.strip().lower().replace("cnot", "cx")
i = gate.index("(")
gate_name, gate_args = gate[:i], eval(gate[i:])
try: len(gate_args)
except TypeError: gate_args = gate_args,
return gate_name, gate_args
def get_num_qubits(algorithm):
"""
Determine the max qubit value used in the algorithm.
algorithm: iterable, each element must be a string gate, as in
apply_string_gate above.
ie, algorithm = ["h(0)", "cx(0, 1)", "rx(pi/4, 1)",..]
returns: int, max qubit value in algorithm.
"""
n = -1
for gate in algorithm:
gate_name, gate_args = get_gate_info(gate)
if gate_name == "measure": m = gate_args[0]
# elif sum(GATE_PARAMS[gate_name]) == 1: m = gate_args
else: m = max(gate_args[GATE_PARAMS[gate_name][0]:])
n = max(n, m)
return n + 1
def apply_string_gate(gate, reg, cir, c_reg=None):
"""
gate: str, one of the elements in GATE_ARGUMENTS.keys() + a tuple of
arguments. ie, for a rx rotation by pi/2 radians on qubit 0,
gate = "rx(pi/2, 0)".
reg: qiskit.QuantumRegister, register to apply gate to.
cir: qiskit.QuantumCircuit, circuit to add gate to.
c_reg: qiskit.ClassicalRegister, must be supplied if gate is a measurement.
Classical register to measure to.
returns: int, if gate is a measure gate, then return the integer
corresponding to the classical register to measure to,
otherwise returns -1.
"""
gate_name, gate_args = get_gate_info(gate)
# apply gate
eval("cir." + gate_name + GATE_ARGUMENTS[gate_name] % gate_args)
# value of the classical register to measure to
if "measure" in gate: return gate_args[-1]
else: return -1
def apply_string_algorithm(algorithm, reg, cir, c_reg=None):
"""
algorithm: iterable, each element must be a string gate, as in
apply_string_gate above.
ie, algorithm = ["h(0)", "cx(0, 1)", "rx(pi/4, 1)",..]
reg: qiskit.QuantumRegister, register to apply algorithm to.
cir: qiskit.QuantumCircuit, circuit to add gates in algorithm to.
c_reg: qiskit.ClassicalRegister, must be supplied if gate is a measurement.
Classical register to measure to.
returns: int, if the algorithm has any measure gates, then returns the
integer corresponding to the largest index of the classical
register that is measured to, otherwise returns -1.
"""
if not algorithm: return -1
return max(apply_string_gate(gate, reg, cir, c_reg) for gate in algorithm)
def _make_job(qc, backend, num_samples):
"""
Begin the execution of the circuit qc on the backend with shots=num_samples
qc: qiskit.QuantumCircuit or list of circuits, circuits to run.
backend: str, IBM backend to run circuit on. Can be 'ibmqx4', 'ibmqx5',
'local_qasm_simulator', 'local_unitary_simulator', etc.
num_samples: int, number of samples to take from the quantum computer in
in order to determine the probabilities for each state.
returns: qiskit Job object from qiskit.backends.
"""
if backend in simulators: f = qiskit.Aer
else: f = qiskit.IBMQ
try:
return qiskit.execute(qc, backend=f.get_backend(backend),
shots=num_samples, max_credits=3)
except LookupError:
apply_credentials()
return qiskit.execute(qc, backend=f.get_backend(backend),
shots=num_samples, max_credits=3)
class Result(dict):
""" Just a dictionary that automatically gives default values = 0.0 """
def __getitem__(self, key):
""" Return 0.0 if key not in result dictionary """
return self.get(key, 0.0)
def run(algorithm, num_qubits=None, num_samples=8000, backend=simulator):
"""
Create a quantum circuit, run the algorithm, return the resulting
probability distribution.
algorithm: algorithm (list of strings) or list of algorithms,
each string is a gate in GATE_ARGUMENTS.keys() with whatever
arguments required to define the gate.
num_qubits: int, number of qubits to run each algorithm on. Can be None,
in which case the algorithm will be run on the minimum
number of qubits required.
num_samples: int, number of samples to take from the quantum computer in
in order to determine the probabilities for each state.
backend: str, IBM backend to run the algorithm on. If backend is not
a local simulator then credentials must have already
been applied.
returns: dict (common.Result), keys are states, values are probabilities
found to be in that state.
"""
multiple = bool(algorithm and isinstance(algorithm[0], list))
if not multiple: algorithm = [algorithm]
n = len(algorithm)
if num_qubits is None:
num_qubits = max(get_num_qubits(a) for a in algorithm)
q = qiskit.QuantumRegister(num_qubits)
c = [qiskit.ClassicalRegister(num_qubits) for _ in range(n)]
qc = [qiskit.QuantumCircuit(q, c[j]) for j in range(n)]
for j in range(n):
i = apply_string_algorithm(algorithm[j], q, qc[j], c[j])
if i == -1: qc[j].measure(q, c[j])
else: c[j].size = i + 1
job_exp = _make_job(qc, backend, num_samples)
# Often there are random queue errors that have happened to
# me that cause the job to never complete. Two things I have
# encountered: I lose connection or something, and I get an
# error, or for some reason their server tells me that the
# job is running indefinitely, ie it just get stuck running.
# So if either of those things happen, we reset and
# reinitialize our job(s) into the queue.
if backend not in simulators:
lapse, interval = 0, 30
done = False
while not done:
str_status = str(job_exp.status())
queue_position = job_exp.queue_position()
error = job_exp.error_message()
print('\nStatus @ %d seconds' % (interval * lapse))
print("queue position =", queue_position)
print(str_status)
done = queue_position is not None and queue_position < 1
if error:
print("\nEncountered an error")
print(error)
print("reentering job into queue\n")
job_exp.cancel()
job_exp = _make_job(qc, backend, num_samples)
lapse = 0
lapse += 1
time.sleep(interval)
res = job_exp.result()
## qiskit orders their bits opposite to Cirq nad ProjectQ, and in my
## opinion in a much less intuitive way. So I flip the order of the bits
## here.
if multiple:
return [
Result(
{k[::-1]: v/num_samples
for k, v in res.get_counts(cir).items()}
) for cir in qc
]
else:
return Result(
{k[::-1]: v/num_samples for k, v in res.get_counts(qc[0]).items()}
)
def algorithm_unitary(algorithm, num_qubits=None):
"""
Find the unitary corresponding to the algorithm.
algorithm: list of strings, each string is a gate in GATE_ARGUMENTS.keys()
with whatever arguments required to define the
gate.
num_qubits: int, number of qubits to run the algorithm on.
returns: np.array, unitary matrix corresponding to the algorithm.
"""
if num_qubits is None: num_qubits = get_num_qubits(algorithm)
if not algorithm: algorithm = ["iden(0)"]
## qiskit orders their bits opposite to Cirq nad ProjectQ, and in my
## opinion in a much less intuitive way. So I flip the order of the bits
## here.
a = []
for gate in algorithm:
gate_name, gate_args = get_gate_info(gate)
i = GATE_PARAMS[gate_name][0]
params = gate_args[:i]
qubits = gate_args[i:]
qubits = tuple(num_qubits-q-1 for q in qubits)
a.append(gate_name + str(params + qubits))
q = qiskit.QuantumRegister(num_qubits)
qc = qiskit.QuantumCircuit(q)
apply_string_algorithm(a, q, qc)
return qiskit.execute(
qc, backend=qiskit.Aer.get_backend(unitary_simulator)
).result().get_data(qc)["unitary"]
def prepare_state(state):
"""
state: string, string of 0's and 1's.
returns: algorithm (list of strings), algorithm to prepare the state.
"""
return ["x(%d)" % i for i in range(len(state)) if state[i] == "1"]
def sample(algorithm, num_qubits=None,
num_samples=1, backend=simulator):
"""
Get a list of all the outputs from an algorithm. Differs from `run` because
`run` returns the determined probabilities of each state, but `sample`
returns a list of the outputs.
algorithm: algorithm (list of strings), NOT a list of algorithms,
each string is a gate in GATE_ARGUMENTS.keys() with whatever
arguments required to define the gate.
num_qubits: int, number of qubits to run each algorithm on.
num_samples: int, number of samples to take from the quantum computer.
backend: str, IBM backend to run the algorithm on. If backend is not
a local simulator then credentials must have already
been applied.
returns: list, each element is the measured state.
"""
d = run([algorithm]*num_samples,
num_qubits=num_qubits,
num_samples=1, backend=backend)
return [list(x.keys())[0] for x in d]
def single_sample(algorithm, num_qubits=None, backend=simulator):
"""
Same as `sample` with one sample, but returns a state instead of a list of
one state.
"""
return sample(algorithm, num_qubits, 1, backend)[0]
def markovian_sample(algorithm, num_qubits=None,
num_samples=1, backend=simulator):
"""
Get a list of all the outputs from an algorithm, where the previous output
is prepared as the starting point for the next algorithm; ie the
measurement of the algorithm is input to run the algorithm again.
algorithm: algorithm (list of strings), NOT a list of algorithms,
each string is a gate in GATE_ARGUMENTS.keys() with whatever
arguments required to define the gate.
num_qubits: int, number of qubits to run each algorithm on.
num_samples: int, number of samples to take from the quantum computer.
backend: str, IBM backend to run the algorithm on. If backend is not
a local simulator then credentials must have already
been applied.
returns: list, each element is the measured state.
"""
if num_samples < 1: raise ValueError("Must have >= 1 sample")
if num_qubits is None: num_qubits = get_num_qubits(algorithm)
args = num_qubits, backend
res = [single_sample(algorithm, *args)]
for _ in range(num_samples-1):
res.append(single_sample(prepare_state(res[-1])+algorithm, *args))
return res
if __name__ == "__main__":
## Examples
# `run` returns a dictionary mapping states to probabilities, ie
# run(["h(0)", "cx(0, 1)"]) should return {"00":0.5, "11": 0.5}.
# if no "measure" is included in alg, then by default everything will
# be measured.
alg = ["H(0)", "CX(0, 1)", "u3(pi, pi/2, pi/4, 0)"]
print(run(alg, 3, num_samples=10000))
# since a measure is included, only that register will be measured.
alg = ["H(0)", "CX(0, 1)", "u3(pi, pi/2, pi/4, 0)", "measure(0, 0)"]
# print(run(alg, 3, num_samples=1000, backend="ibmqx4"))
# run multiple circuits at once
alg0 = ["h(0)", "cx(0, 1)", "measure(0, 0)", "measure(1, 1)"]
alg1 = ["x(0)", "H(1)", "ccx(0, 1, 2)"]
print(run([alg0, alg1]))
# convert alg to its unitary respresentation.
alg = ["h(0)", "cx(0, 1)"]
print(algorithm_unitary(alg, 2))
|
https://github.com/Alternat3/Quantum-Bitcoin
|
Alternat3
|
from qiskit import *
#provider = IBMQ.enable_account('YOUR API KEY HERE')
#backend = provider.get_backend('ibm_oslo')
def applyHadamard(qc, qubits):
for q in qubits:
qc.h(q)
return qc
def createBooleanOracle(input):
oracle_circuit = QuantumCircuit(4,name="boolean oracle")
for x in range(3):
if input[x] == '0':
oracle_circuit.x(x)
oracle_circuit.mct([0,1,2], 3)
for x in range(3):
if input[x] == '0':
oracle_circuit.x(x)
return oracle_circuit.to_gate()
def createPhaseOracle(input):
oracle_circuit = QuantumCircuit(3,name="phase oracle")
for x in range(3):
if input[x] == '0':
oracle_circuit.x(x)
oracle_circuit.ccz(0,1,2)
for x in range(3):
if input[x] == '0':
oracle_circuit.x(x)
return oracle_circuit.to_gate()
def amplificationGate():
ampGate = QuantumCircuit(3,name="amplification gate")
for x in range(3):
ampGate.x(x)
ampGate.ccz(0,1,2)
for x in range(3):
ampGate.x(x)
for x in range(3):
ampGate.h(x)
return ampGate.to_gate()
def runSimulator(grover_circuit): # >70% accuracy mine until 78% accuracy??????
backend = BasicAer.get_backend('qasm_simulator')
job = execute(grover_circuit, backend, shots=8192)
result = job.result()
counts = result.get_counts()
return counts
def runReal(grover_circuit): # <50% accuracy
job = execute(grover_circuit, backend, shots=8192)
result = job.result()
counts = result.get_counts()
return counts
def mine(input, type_choice):
grover_circuit = QuantumCircuit(4,3)
grover_circuit.initialize('0000', grover_circuit.qubits)
grover_circuit = applyHadamard(grover_circuit, [0,1,2,3])
#grover_circuit.append(createBooleanOracle(input), [0,1,2,3])
grover_circuit.append(createPhaseOracle(input), [0,1,2])
grover_circuit = applyHadamard(grover_circuit, [0,1,2,3])
grover_circuit.append(amplificationGate(), [0,1,2])
grover_circuit.measure([0,1,2], [0,1,2])
if type_choice == "1":
counts = runSimulator(grover_circuit)
if type_choice == "2":
counts = runReal(grover_circuit)
searchFor = input[::-1]
accuracy = (counts[searchFor] / 8192) * 100
return accuracy
|
https://github.com/electricalgorithm/DeutschJozsaAlgorithm
|
electricalgorithm
|
"""
This module implements the Deutsch-Jozsa algorithm using Qiskit.
"""
import numpy as np
from qiskit import Aer
from qiskit import QuantumCircuit, assemble, transpile
from qiskit.circuit.instruction import Instruction
class DJAlgorithm:
"""This class implements the Deutsch-Jozsa algorithm."""
@staticmethod
def simulate(oracle_block: QuantumCircuit) -> dict:
"""
Run the Deutsch-Jozsa algorithm on the simulator.
:param oracle_block: The oracle block to check with Deutsch-Jozsa algorithm.
:return: The result of the algorithm as dictionary. Check "result" attribute.
"""
circuit = DJAlgorithm._construct_the_circuit(oracle_block)
aer_sim = Aer.get_backend("aer_simulator")
transpiled_dj_circuit = transpile(circuit, aer_sim)
qobj = assemble(transpiled_dj_circuit)
results = aer_sim.run(qobj).result()
answer = results.get_counts()
if "0" * (circuit.num_qubits - 1) in answer:
return {"result": "Constant"}
else:
return {"result": "Balanced"}
@staticmethod
def give_a_balanced_function(inputs_count: int) -> Instruction:
"""Returns a balanced oracle function.
:param inputs_count: The number of input qubits.
:return: The balanced oracle function as Instruction.
"""
# Get the number of input qubits.
random_number = np.random.randint(1, 2**inputs_count)
inputs = format(random_number, "0" + str(inputs_count) + "b")
# Create a quantum circuit with the number of input qubits + 1 output qubit.
oracle = QuantumCircuit(inputs_count + 1, inputs_count)
# Place X gates on the start of input qubit lines.
for index, qubit in enumerate(reversed(inputs)):
if qubit == "1":
oracle.x(index)
# Apply the oracle block.
for index, qubit in enumerate(inputs):
oracle.cx(index, inputs_count)
# Place X-gates on the end of input qubits lines.
for index, qubit in enumerate(reversed(inputs)):
if qubit == "1":
oracle.x(index)
inst = oracle.to_instruction()
inst.name = "BalancedOracle"
return inst
@staticmethod
def give_a_constant_function(inputs_count: int) -> Instruction:
"""Returns a constant oracle function.
:param inputs_count: The number of input qubits.
:return: The balanced oracle function as Instruction.
"""
# Create a quantum circuit with the number of input qubits + 1 output qubit.
oracle = QuantumCircuit(inputs_count + 1)
if np.random.randint(2) == 1:
oracle.x(inputs_count)
inst = oracle.to_instruction()
inst.name = "ConstantOracle"
return inst
@staticmethod
def _construct_the_circuit(function_block: QuantumCircuit) -> QuantumCircuit:
"""It creates the circuit for the Deutsch-Jozsa algorithm.
:param function_block: The oracle block to check with Deutsch-Jozsa algorithm.
:return: The circuit for the Deutsch-Jozsa algorithm.
"""
# Get the number of input qubits.
input_length = function_block.num_qubits - 1
_circuit = QuantumCircuit(input_length + 1, input_length)
# Apply Hadamard gates to all input qubits.
for qubit in range(input_length):
_circuit.h(qubit)
# Convert the last qubit to |-) state.
_circuit.x(input_length)
_circuit.h(input_length)
_circuit.barrier()
# Apply the oracle block.
_circuit.append(
function_block, range(function_block.num_qubits), range(function_block.num_clbits)
)
_circuit.barrier()
# Apply Hadamard gates to all input qubits.
for qubit in range(input_length):
_circuit.h(qubit)
_circuit.barrier()
# Measure all input qubits and put them to classical bits.
for qubit in range(input_length):
_circuit.measure(qubit, qubit)
return _circuit
if __name__ == "__main__":
print("===================================")
print("Deutsch-Jozsa Algorithm Simulation")
print("===================================")
# Get the number of input qubits.
inputs_count = int(input("> Enter the number of input qubits: "))
# Get the oracle block.
oracle_type = input("> Enter the type of function (c)onstant/(b)alanced: ")
oracle_type = oracle_type.lower()
if oracle_type == "constant" or oracle_type == "c":
block_to_test = DJAlgorithm.give_a_constant_function(inputs_count)
elif oracle_type == "balanced" or oracle_type == "b":
block_to_test = DJAlgorithm.give_a_balanced_function(inputs_count)
else:
print("Invalid function type.")
exit(1)
# Run the algorithm.
result = DJAlgorithm.simulate(block_to_test)
print("Result: " + result["result"])
|
https://github.com/RokiyaMG/Shors_Algorithm
|
RokiyaMG
|
import numpy as np
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile, Aer, IBMQ
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from ibm_quantum_widgets import *
from qiskit.providers.aer import QasmSimulator
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, Aer, transpile, assemble
from qiskit.visualization import plot_histogram
from math import gcd
from numpy.random import randint
import pandas as pd
from fractions import Fraction
print("Imports Successful")
# Loading your IBM Quantum account(s)
provider = IBMQ.load_account()
#defining the U gates for mod 63
def c_amod63(a, power):
"""Controlled multiplication by a mod 63"""
if a not in [2, 4, 5, 8, 10, 11, 13, 16, 17, 19, 20, 22, 23, 25, 26, 29, 31, 32, 34, 37, 38, 40, 41, 43, 44, 46, 47, 50, 52, 53, 55, 58, 59, 61, 62]:
raise ValueError("'a' must be 2, 4, 5, 8, 10, 11, 13, 16, 17, 19, 20, 22, 23, 25, 26, 29, 31, 32, 34, 37, 38, 40, 41, 43, 44, 46, 47, 50, 52, 53, 55, 58, 59, 61, or 62")
#the number of qubits used is 6
U = QuantumCircuit(6)
#implementing the swap gates for rotation
#we implement every number and see common behaivor between the numbers
for iteration in range(power):
if a in [2,61]:
U.swap(0,1)
U.swap(1,2)
U.swap(2,3)
U.swap(3,4)
U.swap(4,5)
if a in [4, 59]:
U.swap(0,2)
U.swap(1,3)
U.swap(2,4)
U.swap(3,5)
if a in [5, 58]:
U.swap(0,2)
U.swap(1,3)
U.swap(0,4)
U.swap(1,5)
if a in [8, 55]:
U.swap(0,3)
U.swap(1,4)
U.swap(2,5)
if a in [10, 53]:
U.swap(0,2)
U.swap(1,3)
U.swap(0,4)
U.swap(1,5)
U.swap(0,2)
U.swap(1,3)
U.swap(0,4)
U.swap(1,5)
if a in [11, 52]:
U.swap(0,1)
U.swap(1,2)
U.swap(2,3)
U.swap(3,4)
U.swap(4,5)
U.swap(0,1)
U.swap(1,2)
U.swap(2,3)
U.swap(3,4)
U.swap(4,5)
U.swap(0,1)
U.swap(1,2)
U.swap(2,3)
U.swap(3,4)
U.swap(4,5)
U.swap(0,1)
U.swap(1,2)
U.swap(2,3)
U.swap(3,4)
U.swap(4,5)
if a in [13, 50]:
U.swap(0,5)
U.swap(1,5)
U.swap(2,5)
U.swap(3,5)
U.swap(4,5)
if a in [16, 47]:
U.swap(0,1)
U.swap(1,2)
U.swap(2,3)
U.swap(3,4)
U.swap(4,5)
U.swap(0,1)
U.swap(1,2)
U.swap(2,3)
U.swap(3,4)
U.swap(4,5)
U.swap(0,1)
U.swap(1,2)
U.swap(2,3)
U.swap(3,4)
U.swap(4,5)
U.swap(0,1)
U.swap(1,2)
U.swap(2,3)
U.swap(3,4)
U.swap(4,5)
# if a in [17, 46]:
# if a in [19, 44]:
if a in [20, 43]:
U.swap(0,1)
U.swap(1,2)
U.swap(2,3)
U.swap(3,4)
U.swap(4,5)
if a in [22, 41]:
U.swap(0,5)
U.swap(1,5)
U.swap(2,5)
U.swap(3,5)
U.swap(4,5)
if a in [23, 40]:
U.swap(0,2)
U.swap(1,3)
U.swap(2,4)
U.swap(3,5)
if a in [25, 38]:
U.swap(0,1)
U.swap(1,2)
U.swap(2,3)
U.swap(3,4)
U.swap(4,5)
# if a in [26, 37]:
if a in [29, 34]:
U.swap(0,1)
U.swap(1,2)
U.swap(2,3)
U.swap(3,4)
U.swap(4,5)
if a in [31, 32]:
U.swap(0,5)
U.swap(1,5)
U.swap(2,5)
U.swap(3,5)
U.swap(4,5)
if a in [62]:
U.swap(0,3)
U.swap(1,4)
U.swap(2,5)
if a in [5, 11, 13, 17, 19, 23, 25, 29, 31, 37, 41, 43, 47, 53, 55, 59, 61]:
for q in range(6):
U.x(q)
U = U.to_gate()
U.name = "%i^%i mod 63" % (a, power)
c_U = U.control()
return c_U
# Specify variables
n_count = 10 # number of counting qubits
a = 13
def qft_dagger(n):
"""n-qubit QFTdagger the first n qubits in circ"""
qc = QuantumCircuit(n)
# Don't forget the Swaps!
for qubit in range(n//2):
qc.swap(qubit, n-qubit-1)
for j in range(n):
for m in range(j):
qc.cp(-np.pi/float(2**(j-m)), m, j)
qc.h(j)
qc.name = "QFT†"
return qc
# Create QuantumCircuit with n_count counting qubits
# plus 4 qubits for U to act on
qc = QuantumCircuit(n_count + 10, n_count)
# Initialize counting qubits
# in state |+>
for q in range(n_count):
qc.h(q)
# And auxiliary register in state |1>
qc.x(3+n_count)
# Do controlled-U operations
for q in range(n_count):
qc.append(c_amod63(a, 2**q),
[q] + [i+n_count for i in range(6)])
# Do inverse-QFT
qc.append(qft_dagger(n_count), range(n_count))
# Measure circuit
qc.measure(range(n_count), range(n_count))
qc.draw(fold=-1) # -1 means 'do not fold'
aer_sim = Aer.get_backend('aer_simulator')
t_qc = transpile(qc, aer_sim)
qobj = assemble(t_qc)
results = aer_sim.run(qobj).result()
counts = results.get_counts()
plot_histogram(counts)
rows, measured_phases = [], []
for output in counts:
decimal = int(output, 2) # Convert (base 2) string to decimal
phase = decimal/(2**n_count) # Find corresponding eigenvalue
measured_phases.append(phase)
# Add these values to the rows in our table:
rows.append([f"{output}(bin) = {decimal:>3}(dec)",
f"{decimal}/{2**n_count} = {phase:.2f}"])
# Print the rows in a table
headers=["Register Output", "Phase"]
df = pd.DataFrame(rows, columns=headers)
print(df)
Fraction(0.666)
# Get fraction that most closely resembles 0.666
# with denominator < 63
Fraction(0.666).limit_denominator(63)
rows = []
for phase in measured_phases:
frac = Fraction(phase).limit_denominator(63)
rows.append([phase, f"{frac.numerator}/{frac.denominator}", frac.denominator])
# Print as a table
headers=["Phase", "Fraction", "Guess for r"]
df = pd.DataFrame(rows, columns=headers)
print(df)
|
https://github.com/SakshieP/Grovers-algorithm
|
SakshieP
|
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute, Aer, IBMQ
from qiskit.visualization import plot_histogram
IBMQ.save_account("APIKEY")
my_list=[1,3,5,6,7,8,23,56]
def the_oracle(my_input):
winner=7
if my_input is winner:
response = True
else:
response = False
return response
for index, trial_number in enumerate(my_list):
if the_oracle(trial_number) is True:
print('Winner found at index %i' %index)
print('%i calls to the Oracle used' %(index+1))
break
from qiskit import *
import matplotlib.pyplot as plt
import numpy as np
oracle = QuantumCircuit(2,name='oracle')
oracle.cz(0,1)
oracle.to_gate()
oracle.draw()
backend = Aer.get_backend('statevector_simulator')
grover_circ = QuantumCircuit(2,2)
grover_circ.h([0,1])
grover_circ.append(oracle,[0,1])
grover_circ.draw()
job = execute(grover_circ,backend)
result = job.result()
sv = result .get_statevector()
np.around(sv,2)
reflection = QuantumCircuit(2,name='reflection')
reflection.h([0,1])
reflection.z([0,1])
reflection.cz(0,1)
reflection.h([0,1])
reflection.to_gate()
reflection.draw()
backend = Aer.get_backend('qasm_simulator')
grover_circ = QuantumCircuit(2,2)
grover_circ.h([0,1])
grover_circ.append(oracle,[0,1])
grover_circ.append(reflection,[0,1])
grover_circ.measure([0,1],[0,1])
grover_circ.draw()
job=execute(grover_circ,backend,shots=1)
result=job.result()
result.get_counts()
|
https://github.com/renatawong/quantum-maxcut
|
renatawong
|
'''
(C) Renata Wong (NCTS-NTU) 2023
This is the accompanying code for the paper "Quantum speedup for the maximum cut problem"
for the example graph given in Fig. 1.
Note: It is impossible to execute it for graphs with more than 2 edges as the number of qubits exceeds the simulator limit.
'''
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
import numpy as np
'''
Create the quantum circuit for the 3-vertex example
num_vertices = n = number of vertices
num_enges = m = number of edges
'''
'''
PLEASE FILL IN THE EDGE LIST FOR YOUR GRAPH IN THE LINE BELOW
'''
permanent_edge_list = [[0,1], [1,2]]
num_vertices = len({x for l in permanent_edge_list for x in l})
num_edges = len(permanent_edge_list)
range_z = (((num_edges + 1) * (num_edges + 2)) / 2) - 1
range_r = 4 * (num_edges * (num_edges + 1)) / 2
range_s = 2 * (num_edges * (num_edges + 1)) / 2
aux = QuantumRegister(1, 'aux')
z_reg = QuantumRegister(range_z, 'z_reg')
s_reg = QuantumRegister(range_s, 's_reg')
r_reg = QuantumRegister(range_r, 'r_reg')
x_reg = QuantumRegister(num_vertices, 'x_reg')
readout = ClassicalRegister(num_vertices, 'out')
qc = QuantumCircuit(aux, x_reg, r_reg, s_reg, z_reg, readout)
qc.x(aux)
qc.h(aux)
# Print this variable to see the system size
system_size = qc.num_qubits
'''
Create z_matrix to store elements of z_reg
'''
z_matrix = [ [ 0 for i in range(num_edges + 1) ] for j in range(num_edges + 1) ]
zij = 0
for i in range(1, num_edges + 1):
for j in range(i + 1):
z_matrix[i][j] = zij
zij += 1
'''
Define the CFE subcircuit
'''
sq = QuantumRegister(10,'sq')
sc = QuantumCircuit(sq, name='CFE')
# EIIAC
sc.x(sq[1])
sc.ccx(sq[0], sq[1], sq[2])
sc.x(sq[0])
sc.x(sq[1])
sc.ccx(sq[0], sq[1], sq[3])
sc.x(sq[0])
sc.x(sq[2])
sc.x(sq[3])
sc.ccx(sq[2], sq[3], sq[6])
sc.x(sq[2])
sc.x(sq[3])
# EINIAC
sc.x(sq[0])
sc.x(sq[1])
sc.ccx(sq[0], sq[1], sq[4])
sc.x(sq[0])
sc.x(sq[1])
sc.ccx(sq[0], sq[1], sq[5])
sc.x(sq[4])
sc.x(sq[5])
sc.ccx(sq[4], sq[5], sq[7])
sc.x(sq[4])
sc.x(sq[5])
# CNOTS
sc.cx(sq[6], sq[9])
sc.cx(sq[7], sq[8])
cfe = sc.to_instruction()
'''
Define the CSE subcircuit
'''
cq = QuantumRegister(11,'cq')
ce = QuantumCircuit(cq, name='CSE')
# EIIAC
ce.x(cq[1])
ce.ccx(cq[0], cq[1], cq[2])
ce.x(cq[0])
ce.x(cq[1])
ce.ccx(cq[0], cq[1], cq[3])
ce.x(cq[0])
ce.x(cq[2])
ce.x(cq[3])
ce.ccx(cq[2], cq[3], cq[6])
ce.x(cq[2])
ce.x(cq[3])
# EINIAC
ce.x(cq[0])
ce.x(cq[1])
ce.ccx(cq[0], cq[1], cq[4])
ce.x(cq[0])
ce.x(cq[1])
ce.ccx(cq[0], cq[1], cq[5])
ce.x(cq[4])
ce.x(cq[5])
ce.ccx(cq[4], cq[5], cq[7])
ce.x(cq[4])
ce.x(cq[5])
# CNOTS
ce.ccx(cq[6], cq[8], cq[9])
ce.ccx(cq[7], cq[8], cq[10])
cse = ce.to_instruction()
'''
Initialize the system and set it in a uniform superpostion -> lines 1 and 2 of Algorithm 1 in paper
'''
for qubit in s_reg:
qc.x(qubit)
for qubit in x_reg:
qc.h(qubit)
qc.barrier()
'''
NOTE: There will always be an even number of solutions, since under maximum cut 101 is the same as 010.
For Fig. 1 in the paper, we set the number of solutions to 2.
YOU MAY NEED TO ADJUST THE NUMBER OF SOLUTIONS.
'''
num_solutions = 2
num_runs = int(np.ceil(np.pi * np.sqrt((2**num_vertices) / num_solutions)) / 4)
'''
Amplitude amplification
'''
for run in range(num_runs):
# Apply CFE to |psi_1> -> line 3 in Algorithm 1
# It is assumed that the two vertices in the x_reg share an edge
r = 4
s = 2
edge_list = permanent_edge_list.copy()
if len(edge_list) > 0:
index_v1 = edge_list[0][0]
index_v2 = edge_list[0][1]
edge_list.pop(0)
cfe_qubits = []
cfe_qubits += [x_reg[index_v1]]
cfe_qubits += [x_reg[index_v2]]
cfe_qubits += [r_reg[i] for i in range(4)]
cfe_qubits += [s_reg[i] for i in range(2)]
cfe_qubits += [z_reg[i] for i in range(2)]
qc.append(cfe, cfe_qubits)
# Apply CSE to |psi_2> --> line 4 in Algorithm 1
# It is assumed that the two vertices in the x_reg share an edge
for i in range(1, num_edges):
index_v1 = edge_list[0][0]
index_v2 = edge_list[0][1]
cse_qubits = []
for j in reversed(range(i+1)):
cse_qubits += [x_reg[index_v1]]
cse_qubits += [x_reg[index_v2]]
cse_qubits += [r_reg[i] for i in range(r, r+4)]
cse_qubits += [s_reg[i] for i in range(s, s+2)]
cse_qubits += [z_reg[z_matrix[i][j]]]
cse_qubits += [z_reg[z_matrix[i+1][j+1]]]
cse_qubits += [z_reg[z_matrix[i+1][j]]]
qc.append(cse, cse_qubits)
cse_qubits.clear()
r += 4
s += 2
edge_list.pop(0)
'''
Which qubit of register z_reg is used here depends on how many edges are there in the cut.
For the example in Fig. 1 we expect 2 edges, and therefore we choose qubit 2 (counting from 0, 1, 2, etc.).
This qubit should be in the state 1.
YOU MAY NEED TO ADJUST THE CONTROL QUBIT IN THE CX GATE.
'''
qc.barrier()
qc.cx(z_reg[len(z_reg)-1], aux)
qc.barrier()
'''
Uncompute CSE and CFE operations
'''
edge_list = permanent_edge_list.copy()
for i in reversed(range(1, num_edges)):
index_v1 = edge_list[len(edge_list) - 1][0]
index_v2 = edge_list[len(edge_list) - 1][1]
cse_qubits = []
for j in range(i+1):
r -= 4
s -= 2
cse_qubits += [x_reg[index_v1]]
cse_qubits += [x_reg[index_v2]]
cse_qubits += [r_reg[i] for i in range(r, r+4)]
cse_qubits += [s_reg[i] for i in range(s, s+2)]
cse_qubits += [z_reg[z_matrix[i][j]]]
cse_qubits += [z_reg[z_matrix[i+1][j+1]]]
cse_qubits += [z_reg[z_matrix[i+1][j]]]
qc.append(cse.inverse(), cse_qubits)
cse_qubits.clear()
edge_list.pop(0)
edge_list = [permanent_edge_list[0]]
if len(edge_list) > 0:
index_v1 = edge_list[0][0]
index_v2 = edge_list[0][1]
cfe_qubits = []
cfe_qubits += [x_reg[index_v1]]
cfe_qubits += [x_reg[index_v2]]
cfe_qubits += [r_reg[i] for i in range(4)]
cfe_qubits += [s_reg[i] for i in range(2)]
cfe_qubits += [z_reg[i] for i in range(2)]
qc.append(cfe.inverse(), cfe_qubits)
edge_list.pop()
'''
Diffusion operations
'''
qc.barrier()
for qubit in x_reg:
qc.h(qubit)
qc.x(qubit)
# apply CZ to x_reg
qc.h(x_reg[len(x_reg) - 1])
multiplexer = [x_reg[i] for i in range(len(x_reg) - 1)]
qc.mcx(multiplexer, x_reg[len(x_reg) - 1])
qc.h(x_reg[len(x_reg) - 1])
for qubit in x_reg:
qc.x(qubit)
qc.h(qubit)
qc.barrier()
'''
Measurement
'''
cuts = []
for i in range(len(x_reg)):
cuts.append(x_reg[i])
# Reverse the order in which the output is shown so that it can be read from left to right.
cuts.reverse()
qc.measure(cuts, readout)
from qiskit import Aer, execute
simulator = Aer.get_backend('qasm_simulator')
result = execute(qc, backend = simulator, shots = 100).result()
counts = result.get_counts()
print(counts)
|
https://github.com/renatawong/quantum-maxcut
|
renatawong
|
'''
(C) Renata Wong (NCTS-NTU) 2023
This is the accompanying code for the paper "Quantum speedup for the maximum cut problem"
for the example graph given in Fig. 1.
Note: It is impossible to execute it for graphs with more than 2 edges as the number of qubits exceeds the simulator limit.
'''
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
import numpy as np
'''
Create the quantum circuit for the 3-vertex example
num_vertices = n = number of vertices
num_enges = m = number of edges
'''
'''
PLEASE FILL IN THE EDGE LIST FOR YOUR GRAPH IN THE LINE BELOW
'''
permanent_edge_list = [[0,1], [1,2]]
num_vertices = len({x for l in permanent_edge_list for x in l})
num_edges = len(permanent_edge_list)
range_z = (((num_edges + 1) * (num_edges + 2)) / 2) - 1
range_r = 4 * (num_edges * (num_edges + 1)) / 2
range_s = 2 * (num_edges * (num_edges + 1)) / 2
aux = QuantumRegister(1, 'aux')
z_reg = QuantumRegister(range_z, 'z_reg')
s_reg = QuantumRegister(range_s, 's_reg')
r_reg = QuantumRegister(range_r, 'r_reg')
x_reg = QuantumRegister(num_vertices, 'x_reg')
readout = ClassicalRegister(num_vertices, 'out')
qc = QuantumCircuit(aux, x_reg, r_reg, s_reg, z_reg, readout)
qc.x(aux)
qc.h(aux)
# Print this variable to see the system size
system_size = qc.num_qubits
'''
Create z_matrix to store elements of z_reg
'''
z_matrix = [ [ 0 for i in range(num_edges + 1) ] for j in range(num_edges + 1) ]
zij = 0
for i in range(1, num_edges + 1):
for j in range(i + 1):
z_matrix[i][j] = zij
zij += 1
'''
Define the CFE subcircuit
'''
sq = QuantumRegister(10,'sq')
sc = QuantumCircuit(sq, name='CFE')
# EIIAC
sc.x(sq[1])
sc.ccx(sq[0], sq[1], sq[2])
sc.x(sq[0])
sc.x(sq[1])
sc.ccx(sq[0], sq[1], sq[3])
sc.x(sq[0])
sc.x(sq[2])
sc.x(sq[3])
sc.ccx(sq[2], sq[3], sq[6])
sc.x(sq[2])
sc.x(sq[3])
# EINIAC
sc.x(sq[0])
sc.x(sq[1])
sc.ccx(sq[0], sq[1], sq[4])
sc.x(sq[0])
sc.x(sq[1])
sc.ccx(sq[0], sq[1], sq[5])
sc.x(sq[4])
sc.x(sq[5])
sc.ccx(sq[4], sq[5], sq[7])
sc.x(sq[4])
sc.x(sq[5])
# CNOTS
sc.cx(sq[6], sq[9])
sc.cx(sq[7], sq[8])
cfe = sc.to_instruction()
'''
Define the CSE subcircuit
'''
cq = QuantumRegister(11,'cq')
ce = QuantumCircuit(cq, name='CSE')
# EIIAC
ce.x(cq[1])
ce.ccx(cq[0], cq[1], cq[2])
ce.x(cq[0])
ce.x(cq[1])
ce.ccx(cq[0], cq[1], cq[3])
ce.x(cq[0])
ce.x(cq[2])
ce.x(cq[3])
ce.ccx(cq[2], cq[3], cq[6])
ce.x(cq[2])
ce.x(cq[3])
# EINIAC
ce.x(cq[0])
ce.x(cq[1])
ce.ccx(cq[0], cq[1], cq[4])
ce.x(cq[0])
ce.x(cq[1])
ce.ccx(cq[0], cq[1], cq[5])
ce.x(cq[4])
ce.x(cq[5])
ce.ccx(cq[4], cq[5], cq[7])
ce.x(cq[4])
ce.x(cq[5])
# CNOTS
ce.ccx(cq[6], cq[8], cq[9])
ce.ccx(cq[7], cq[8], cq[10])
cse = ce.to_instruction()
'''
Initialize the system and set it in a uniform superpostion -> lines 1 and 2 of Algorithm 1 in paper
'''
for qubit in s_reg:
qc.x(qubit)
for qubit in x_reg:
qc.h(qubit)
qc.barrier()
'''
NOTE: There will always be an even number of solutions, since under maximum cut 101 is the same as 010.
For Fig. 1 in the paper, we set the number of solutions to 2.
YOU MAY NEED TO ADJUST THE NUMBER OF SOLUTIONS.
'''
num_solutions = 2
num_runs = int(np.ceil(np.pi * np.sqrt((2**num_vertices) / num_solutions)) / 4)
'''
Amplitude amplification
'''
for run in range(num_runs):
# Apply CFE to |psi_1> -> line 3 in Algorithm 1
# It is assumed that the two vertices in the x_reg share an edge
r = 4
s = 2
edge_list = permanent_edge_list.copy()
if len(edge_list) > 0:
index_v1 = edge_list[0][0]
index_v2 = edge_list[0][1]
edge_list.pop(0)
cfe_qubits = []
cfe_qubits += [x_reg[index_v1]]
cfe_qubits += [x_reg[index_v2]]
cfe_qubits += [r_reg[i] for i in range(4)]
cfe_qubits += [s_reg[i] for i in range(2)]
cfe_qubits += [z_reg[i] for i in range(2)]
qc.append(cfe, cfe_qubits)
# Apply CSE to |psi_2> --> line 4 in Algorithm 1
# It is assumed that the two vertices in the x_reg share an edge
for i in range(1, num_edges):
index_v1 = edge_list[0][0]
index_v2 = edge_list[0][1]
cse_qubits = []
for j in reversed(range(i+1)):
cse_qubits += [x_reg[index_v1]]
cse_qubits += [x_reg[index_v2]]
cse_qubits += [r_reg[i] for i in range(r, r+4)]
cse_qubits += [s_reg[i] for i in range(s, s+2)]
cse_qubits += [z_reg[z_matrix[i][j]]]
cse_qubits += [z_reg[z_matrix[i+1][j+1]]]
cse_qubits += [z_reg[z_matrix[i+1][j]]]
qc.append(cse, cse_qubits)
cse_qubits.clear()
r += 4
s += 2
edge_list.pop(0)
'''
Which qubit of register z_reg is used here depends on how many edges are there in the cut.
For the example in Fig. 1 we expect 2 edges, and therefore we choose qubit 2 (counting from 0, 1, 2, etc.).
This qubit should be in the state 1.
YOU MAY NEED TO ADJUST THE CONTROL QUBIT IN THE CX GATE.
'''
qc.barrier()
qc.cx(z_reg[len(z_reg)-1], aux)
qc.barrier()
'''
Uncompute CSE and CFE operations
'''
edge_list = permanent_edge_list.copy()
for i in reversed(range(1, num_edges)):
index_v1 = edge_list[len(edge_list) - 1][0]
index_v2 = edge_list[len(edge_list) - 1][1]
cse_qubits = []
for j in range(i+1):
r -= 4
s -= 2
cse_qubits += [x_reg[index_v1]]
cse_qubits += [x_reg[index_v2]]
cse_qubits += [r_reg[i] for i in range(r, r+4)]
cse_qubits += [s_reg[i] for i in range(s, s+2)]
cse_qubits += [z_reg[z_matrix[i][j]]]
cse_qubits += [z_reg[z_matrix[i+1][j+1]]]
cse_qubits += [z_reg[z_matrix[i+1][j]]]
qc.append(cse.inverse(), cse_qubits)
cse_qubits.clear()
edge_list.pop(0)
edge_list = [permanent_edge_list[0]]
if len(edge_list) > 0:
index_v1 = edge_list[0][0]
index_v2 = edge_list[0][1]
cfe_qubits = []
cfe_qubits += [x_reg[index_v1]]
cfe_qubits += [x_reg[index_v2]]
cfe_qubits += [r_reg[i] for i in range(4)]
cfe_qubits += [s_reg[i] for i in range(2)]
cfe_qubits += [z_reg[i] for i in range(2)]
qc.append(cfe.inverse(), cfe_qubits)
edge_list.pop()
'''
Diffusion operations
'''
qc.barrier()
for qubit in x_reg:
qc.h(qubit)
qc.x(qubit)
# apply CZ to x_reg
qc.h(x_reg[len(x_reg) - 1])
multiplexer = [x_reg[i] for i in range(len(x_reg) - 1)]
qc.mcx(multiplexer, x_reg[len(x_reg) - 1])
qc.h(x_reg[len(x_reg) - 1])
for qubit in x_reg:
qc.x(qubit)
qc.h(qubit)
qc.barrier()
'''
Measurement
'''
cuts = []
for i in range(len(x_reg)):
cuts.append(x_reg[i])
# Reverse the order in which the output is shown so that it can be read from left to right.
cuts.reverse()
qc.measure(cuts, readout)
from qiskit import Aer, execute
from qiskit.visualization import plot_histogram
from qiskit.providers.aer import QasmSimulator, StatevectorSimulator
simulator = Aer.get_backend('qasm_simulator')
result = execute(qc, backend = simulator, shots = 100).result()
counts = result.get_counts()
# Uncomment to save the output
#plot_histogram(counts).savefig('example.svg')
plot_histogram(counts)
# See the produced circuit
qc.draw('mpl')
|
https://github.com/renatawong/quantum-maxcut
|
renatawong
|
'''
(C) Renata Wong (CGU-CoIC, NCTS-NTU) 2023
This is the accompanying code for the paper
"Bioinspired Quantum Oracle Circuits for Biomolecular Solutions of the Maximum Cut Problem"
by Weng-Long Chang, Renata Wong, Yu-Hao Chen, Wen-Yu Chung, Ju-Chin Chen, and Athanasios V. Vasilakos
'''
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
import numpy as np
'''
Create the quantum circuit for the 3-vertex example
num_vertices = n = number of vertices
num_enges = m = number of edges
'''
'''
PLEASE FILL IN THE EDGE LIST FOR YOUR GRAPH IN THE LINE BELOW
'''
permanent_edge_list = [[0,1], [1,2]]
# t is the maximum possible number of edges in a cut and is assumed to be known upfront
t = 2
num_vertices = len({x for l in permanent_edge_list for x in l})
num_edges = len(permanent_edge_list)
range_z = (num_edges * (num_edges + 3)) / 2
range_r = 2 * num_edges
range_s = num_edges
aux = QuantumRegister(1, 'aux')
z_reg = QuantumRegister(range_z, 'z_reg')
s_reg = QuantumRegister(range_s, 's_reg')
r_reg = QuantumRegister(range_r, 'r_reg')
x_reg = QuantumRegister(num_vertices, 'x_reg')
readout = ClassicalRegister(num_vertices, 'out')
qc = QuantumCircuit(x_reg, r_reg, s_reg, z_reg, aux, readout)
system_size = qc.num_qubits
print('System size:', system_size)
'''
Create r_matrix to store indices of the register r_reg
'''
r_matrix = [ [0 for j in range(2)] for i in range(num_edges)]
rij = 0
for i in range(num_edges):
for j in range(2):
r_matrix[i][j] = rij
rij += 1
#print('r matrix', r_matrix)
'''
Create z_matrix to store indices of z_reg
Note that i starts with index 1, not 0.
'''
z_matrix = [ [ 0 for j in range(num_edges + 1) ] for i in range(num_edges + 1) ]
zij = 0
for i in range(1, num_edges + 1):
for j in range(i + 1):
z_matrix[i][j] = zij
zij += 1
#print('z matrix', z_matrix)
'''
Define the EIIAC subcircuit
'''
sq = QuantumRegister(5,'sq')
sc = QuantumCircuit(sq, name='EIIAC')
sc.x(sq[1])
sc.ccx(sq[0], sq[1], sq[2])
sc.x(sq[1])
sc.x(sq[0])
sc.ccx(sq[0], sq[1], sq[3])
sc.x(sq[0])
sc.x(sq[2])
sc.x(sq[3])
sc.ccx(sq[2], sq[3], sq[4])
sc.x(sq[2])
sc.x(sq[3])
eiiac = sc.to_instruction()
'''
Initialize the system and set it in a uniform superpostion
'''
for qubit in s_reg:
qc.x(qubit)
for qubit in x_reg:
qc.h(qubit)
qc.x(aux)
qc.h(aux)
#qc.barrier()
'''
NOTE: There will always be an even number of solutions, since under maximum cut 101 is the same as 010.
For Fig. 1 in the paper, we set the number of solutions to 2.
YOU MAY NEED TO ADJUST THE NUMBER OF SOLUTIONS.
'''
num_solutions = 2
num_runs = int(np.ceil(np.pi * np.sqrt((2**num_vertices) / num_solutions)) / 4)
print('Number of iterations:', num_runs)
'''
Amplitude amplification
'''
for run in range(num_runs):
# Apply EIIAC
# It is assumed that the two vertices in the x_reg share an edge
edge_list = permanent_edge_list.copy()
for index, edge in enumerate(edge_list):
[index_v1, index_v2] = edge
cfe_qubits = []
cfe_qubits += [x_reg[index_v1]]
cfe_qubits += [x_reg[index_v2]]
cfe_qubits += [r_reg[k] for k in range(2*index, 2*index+2)]
cfe_qubits += [s_reg[index]]
qc.append(eiiac, cfe_qubits)
#qc.barrier()
# Apply INO
if t > 0:
qc.cx(s_reg[0], z_reg[1])
# Apply PNO
if t < num_edges:
qc.x(s_reg[0])
qc.cx(s_reg[0], z_reg[0])
qc.x(s_reg[0])
# Apply CIO and CPO
for i in range(1, num_edges):
for j in reversed(range(i+1)):
if j+1 <= t and num_edges-i+j == t:
qc.ccx(s_reg[i], z_reg[z_matrix[i][j]], z_reg[z_matrix[i+1][j+1]])
if j <= t and num_edges-i+j-1 == t:
qc.x(s_reg[i])
qc.ccx(s_reg[i], z_reg[z_matrix[i][j]], z_reg[z_matrix[i+1][j+1]])
qc.x(s_reg[i])
'''
Which qubit of register z_reg is used here depends on how many edges are there in the cut.
For the example in Fig. 1 we expect 2 edges, and therefore we choose qubit 2 (counting from 0, 1, 2, etc.).
This qubit should be in the state 1.
YOU MAY NEED TO ADJUST THE CONTROL QUBIT IN THE CX GATE.
'''
#qc.barrier()
qc.cx(z_reg[z_matrix[num_edges][t]], aux)
#qc.barrier()
'''
Uncomputing CIO, CPO, PNO, INO, and EIIAC,
'''
# uncompute CIO and CPO
for i in range(1, num_edges):
for j in reversed(range(i+1)):
if j+1 <= t and num_edges-i+j == t:
qc.ccx(s_reg[i], z_reg[z_matrix[i][j]], z_reg[z_matrix[i+1][j+1]])
if j <= t and num_edges-i+j-1 == t:
qc.x(s_reg[i])
qc.ccx(s_reg[i], z_reg[z_matrix[i][j]], z_reg[z_matrix[i+1][j+1]])
qc.x(s_reg[i])
# Uncompute PNO
if t < num_edges:
qc.x(s_reg[0])
qc.cx(s_reg[0], z_reg[0])
qc.x(s_reg[0])
# Uncompute INO
if t > 0:
qc.cx(s_reg[0], z_reg[1])
# Uncompute EIIAC
index = len(edge_list) - 1
for edge in reversed(edge_list):
[index_v1, index_v2] = edge
cfe_qubits = []
cfe_qubits += [x_reg[index_v1]]
cfe_qubits += [x_reg[index_v2]]
cfe_qubits += [r_reg[k] for k in range(2*index, 2*index+2)]
cfe_qubits += [s_reg[index]]
index -= 1
qc.append(eiiac.inverse(), cfe_qubits)
'''
Diffusion operations
'''
qc.barrier()
for qubit in x_reg:
qc.h(qubit)
qc.x(qubit)
qc.h(x_reg[len(x_reg) - 1])
multiplexer = [x_reg[i] for i in range(len(x_reg) - 1)]
qc.mcx(multiplexer, x_reg[len(x_reg) - 1])
qc.h(x_reg[len(x_reg) - 1])
for qubit in x_reg:
qc.x(qubit)
qc.h(qubit)
#qc.barrier()
'''
Measurement
'''
cuts = []
for i in range(len(x_reg)):
cuts.append(x_reg[i])
# Reverse the order in which the output is shown so that it can be read from left to right.
cuts.reverse()
qc.measure(cuts, readout)
from qiskit import Aer, execute
from qiskit.visualization import plot_histogram
from qiskit.providers.aer import QasmSimulator, StatevectorSimulator
simulator = Aer.get_backend('qasm_simulator')
result = execute(qc, backend = simulator, shots = 1024).result()
counts = result.get_counts()
# Uncomment to save the output
#plot_histogram(counts).savefig('example.svg')
plot_histogram(counts)
qc.draw('mpl')
|
https://github.com/renatawong/quantum-maxcut
|
renatawong
|
#%%timeit
'''
(C) Renata Wong (CGU-CoIC, NCTS-NTU) 2023
This is the accompanying code for the paper
"Bioinspired Quantum Oracle Circuits for Biomolecular Solutions of the Maximum Cut Problem"
by Weng-Long Chang, Renata Wong, Yu-Hao Chen, Wen-Yu Chung, Ju-Chin Chen, and Athanasios V. Vasilakos
'''
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, transpile
import numpy as np
import time
'''
Create the quantum circuit for the 3-vertex example
num_vertices = n = number of vertices
num_enges = m = number of edges
'''
'''
PLEASE FILL IN THE EDGE LIST FOR YOUR GRAPH IN THE LINE BELOW
'''
permanent_edge_list = [[0,1], [1,2]]
# t is the maximum possible number of edges in a cut and is assumed to be known upfront
t = 2
num_vertices = len({x for l in permanent_edge_list for x in l})
num_edges = len(permanent_edge_list)
range_z = (num_edges * (num_edges + 3)) / 2
range_r = 2 * num_edges
range_s = num_edges
aux = QuantumRegister(1, 'aux')
z_reg = QuantumRegister(range_z, 'z_reg')
s_reg = QuantumRegister(range_s, 's_reg')
r_reg = QuantumRegister(range_r, 'r_reg')
x_reg = QuantumRegister(num_vertices, 'x_reg')
readout = ClassicalRegister(num_vertices, 'out')
qc = QuantumCircuit(x_reg, r_reg, s_reg, z_reg, aux, readout)
system_size = qc.num_qubits
print('System size:', system_size)
'''
Create r_matrix to store indices of the register r_reg
'''
r_matrix = [ [0 for j in range(2)] for i in range(num_edges)]
rij = 0
for i in range(num_edges):
for j in range(2):
r_matrix[i][j] = rij
rij += 1
#print('r matrix', r_matrix)
'''
Create z_matrix to store indices of z_reg
Note that i starts with index 1, not 0.
'''
z_matrix = [ [ 0 for j in range(num_edges + 1) ] for i in range(num_edges + 1) ]
zij = 0
for i in range(1, num_edges + 1):
for j in range(i + 1):
z_matrix[i][j] = zij
zij += 1
#print('z matrix', z_matrix)
'''
Define the EIIAC subcircuit
'''
sq = QuantumRegister(5,'sq')
sc = QuantumCircuit(sq, name='EIIAC')
sc.x(sq[1])
sc.ccx(sq[0], sq[1], sq[2])
sc.x(sq[1])
sc.x(sq[0])
sc.ccx(sq[0], sq[1], sq[3])
sc.x(sq[0])
sc.x(sq[2])
sc.x(sq[3])
sc.ccx(sq[2], sq[3], sq[4])
sc.x(sq[2])
sc.x(sq[3])
eiiac = sc.to_instruction()
'''
Initialize the system and set it in a uniform superpostion
'''
for qubit in s_reg:
qc.x(qubit)
for qubit in x_reg:
qc.h(qubit)
qc.x(aux)
qc.h(aux)
#qc.barrier()
'''
NOTE: There will always be an even number of solutions, since under maximum cut 101 is the same as 010.
For Fig. 1 in the paper, we set the number of solutions to 2.
YOU MAY NEED TO ADJUST THE NUMBER OF SOLUTIONS.
'''
num_solutions = 2
num_runs = int(np.ceil(np.pi * np.sqrt((2**num_vertices) / num_solutions)) / 4)
print('Number of iterations:', num_runs)
'''
Amplitude amplification
'''
for run in range(num_runs):
# Apply EIIAC
# It is assumed that the two vertices in the x_reg share an edge
edge_list = permanent_edge_list.copy()
for index, edge in enumerate(edge_list):
[index_v1, index_v2] = edge
cfe_qubits = []
cfe_qubits += [x_reg[index_v1]]
cfe_qubits += [x_reg[index_v2]]
cfe_qubits += [r_reg[k] for k in range(2*index, 2*index+2)]
cfe_qubits += [s_reg[index]]
qc.append(eiiac, cfe_qubits)
#qc.barrier()
# Apply INO
if t > 0:
qc.cx(s_reg[0], z_reg[1])
# Apply PNO
if t < num_edges:
qc.x(s_reg[0])
qc.cx(s_reg[0], z_reg[0])
qc.x(s_reg[0])
# Apply CIO and CPO
for i in range(1, num_edges):
for j in reversed(range(i+1)):
if j+1 <= t and num_edges-i+j == t:
qc.ccx(s_reg[i], z_reg[z_matrix[i][j]], z_reg[z_matrix[i+1][j+1]])
if j <= t and num_edges-i+j-1 == t:
qc.x(s_reg[i])
qc.ccx(s_reg[i], z_reg[z_matrix[i][j]], z_reg[z_matrix[i+1][j+1]])
qc.x(s_reg[i])
'''
YOU MAY NEED TO ADJUST THE CONTROL QUBIT IN THE CX GATE.
'''
#qc.barrier()
qc.cx(z_reg[z_matrix[num_edges][t]], aux)
#qc.barrier()
'''
Uncomputing CIO, CPO, PNO, INO, and EIIAC,
'''
# uncompute CIO and CPO
for i in range(1, num_edges):
for j in reversed(range(i+1)):
if j+1 <= t and num_edges-i+j == t:
qc.ccx(s_reg[i], z_reg[z_matrix[i][j]], z_reg[z_matrix[i+1][j+1]])
if j <= t and num_edges-i+j-1 == t:
qc.x(s_reg[i])
qc.ccx(s_reg[i], z_reg[z_matrix[i][j]], z_reg[z_matrix[i+1][j+1]])
qc.x(s_reg[i])
# Uncompute PNO
if t < num_edges:
qc.x(s_reg[0])
qc.cx(s_reg[0], z_reg[0])
qc.x(s_reg[0])
# Uncompute INO
if t > 0:
qc.cx(s_reg[0], z_reg[1])
# Uncompute EIIAC
index = len(edge_list) - 1
for edge in reversed(edge_list):
[index_v1, index_v2] = edge
cfe_qubits = []
cfe_qubits += [x_reg[index_v1]]
cfe_qubits += [x_reg[index_v2]]
cfe_qubits += [r_reg[k] for k in range(2*index, 2*index+2)]
cfe_qubits += [s_reg[index]]
index -= 1
qc.append(eiiac.inverse(), cfe_qubits)
'''
Diffusion operations
'''
qc.barrier()
for qubit in x_reg:
qc.h(qubit)
qc.x(qubit)
qc.h(x_reg[len(x_reg) - 1])
multiplexer = [x_reg[i] for i in range(len(x_reg) - 1)]
qc.mcx(multiplexer, x_reg[len(x_reg) - 1])
qc.h(x_reg[len(x_reg) - 1])
for qubit in x_reg:
qc.x(qubit)
qc.h(qubit)
#qc.barrier()
'''
Measurement
'''
cuts = []
for i in range(len(x_reg)):
cuts.append(x_reg[i])
# Reverse the order in which the output is shown so that it can be read from left to right.
cuts.reverse()
qc.measure(cuts, readout)
#from qiskit import Aer, execute
from qiskit.visualization import plot_histogram
from qiskit.providers.fake_provider import GenericBackendV2
backend = GenericBackendV2(num_qubits=15)
start_time = time.time()
# Transpile the ideal circuit to a circuit that can be directly executed by the backend
transpiled_circuit = transpile(qc, backend)
transpiled_circuit.draw('mpl')
job = backend.run(transpiled_circuit)
elapsed_time = time.time() - start_time
print("Execution time = ", time.strftime("%H:%M:%S", time.gmtime(elapsed_time)))
counts = job.result().get_counts()
plot_histogram(counts)
# Uncomment to save the output
#plot_histogram(counts).savefig('example.svg')
qc.draw('mpl')
print('Backend name: ', backend.name)
print()
t1_sum, t2_sum, fr_sum = 0, 0, 0
for qubit in range(qc.num_qubits):
t1_sum += backend.qubit_properties(qubit).t1
t2_sum += backend.qubit_properties(qubit).t2
fr_sum += backend.qubit_properties(qubit).frequency
print('Average qubit properties:')
print('T1 in microsec: ', t1_sum/qc.num_qubits)
print('T2 in microsec: ', t2_sum/qc.num_qubits)
print('Frequency in Hz: ', fr_sum/qc.num_qubits)
print()
xdu_sum, xer_sum = 0, 0
sxdu_sum, sxer_sum = 0, 0
rzdu_sum, rzer_sum = 0, 0
iddu_sum, ider_sum = 0, 0
cxdu_sum, cxer_sum = 0, 0
#print(backend.instructions)
#print('Instruction durations: ', backend.instruction_durations)
for qubit in range(qc.num_qubits):
xdu_sum += backend.target["x"][(qubit,)].duration
xer_sum += backend.target["x"][(qubit,)].error
sxdu_sum += backend.target["sx"][(qubit,)].duration
sxer_sum += backend.target["sx"][(qubit,)].error
rzdu_sum += backend.target["rz"][(qubit,)].duration
rzer_sum += backend.target["rz"][(qubit,)].error
iddu_sum += backend.target["id"][(qubit,)].duration
ider_sum += backend.target["id"][(qubit,)].error
for target in range(qc.num_qubits):
if target != qubit:
cxdu_sum += backend.target["cx"][(qubit,target)].duration
cxer_sum += backend.target["cx"][(qubit,target)].error
print('Average x gate properties: ')
print('Duration: ', xdu_sum/qc.num_qubits)
print('Error: ', xer_sum/qc.num_qubits)
print()
print('Average sx gate properties: ')
print('Duration: ', sxdu_sum/qc.num_qubits)
print('Error: ', sxer_sum/qc.num_qubits)
print()
print('Average rz gate properties: ')
print('Duration: ', rzdu_sum/qc.num_qubits)
print('Error: ', rzer_sum/qc.num_qubits)
print()
print('Average id gate properties: ')
print('Duration: ', iddu_sum/qc.num_qubits)
print('Error: ', ider_sum/qc.num_qubits)
print()
print('Average cx gate properties: ')
print('Duration: ', cxdu_sum/qc.num_qubits)
print('Error: ', cxer_sum/qc.num_qubits)
print()
num_gates = qc.count_ops()
print('Number of gates:', num_gates)
print('Gates in EIIAC:', sc.count_ops())
|
https://github.com/henryliao85/GroverFor3SAT
|
henryliao85
|
# importing Qiskit
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.tools.visualization import plot_histogram
from qiskit_ibm_provider import IBMProvider
def threeSAT_oracle(circuit, f_in, f_out, aux, n, expression):
num_clauses = len(expression)
for k, clause in enumerate(expression):
# This loop ensures aux[k] is 1 if an odd number of literals
# are true
for literal in clause:
if literal > 0:
circuit.cx(f_in[literal-1], aux[k])
else:
circuit.x(f_in[-literal-1])
circuit.cx(f_in[-literal-1], aux[k])
# Flip aux[k] if 2 literals are true
for literal_1 in clause:
if literal_1 > 0:
l1 = literal_1
else:
l1 = -literal_1
for literal_2 in clause:
if literal_1 >= literal_2:
continue
if literal_2 > 0:
l2 = literal_2
else:
l2 = -literal_2
circuit.ccx(f_in[l1-1], f_in[l2-1], aux[k])
# Flip aux[k] if all literals are true, using auxiliary qubit
# (ancilla) aux[num_clauses]
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
circuit.ccx(f_in[2], aux[num_clauses], aux[k])
# Flip back to reverse state of negative literals and ancilla
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
for literal in clause:
if literal < 0:
circuit.x(f_in[-literal-1])
# The formula is satisfied if and only if all auxiliary qubits
# except aux[num_clauses] are 1
if (num_clauses == 1):
circuit.cx(aux[0], f_out[0])
elif (num_clauses == 2):
circuit.ccx(aux[0], aux[1], f_out[0])
else:
circuit.ccx(aux[0], aux[1], aux[num_clauses])
for i in range(2, num_clauses-1):
circuit.ccx(aux[i], aux[num_clauses+i-2], aux[num_clauses+i-1])
circuit.ccx(aux[num_clauses-1], aux[2*num_clauses-3], f_out[0])
for i in range(num_clauses-2, 1, -1):
circuit.ccx(aux[i], aux[num_clauses+i-2], aux[num_clauses+i-1])
circuit.ccx(aux[0], aux[1], aux[num_clauses])
# Flip back any auxiliary qubits to make sure state is consistent
# for future executions of this routine; same loop as above.
for k, clause in enumerate(expression):
for literal in clause:
if literal > 0:
circuit.cx(f_in[literal-1], aux[k])
else:
circuit.x(f_in[-literal-1])
circuit.cx(f_in[-literal-1], aux[k])
for literal_1 in clause:
if literal_1 > 0:
l1 = literal_1
else:
l1 = -literal_1
for literal_2 in clause:
if literal_1 >= literal_2:
continue
if literal_2 > 0:
l2 = literal_2
else:
l2 = -literal_2
circuit.ccx(f_in[l1-1], f_in[l2-1], aux[k])
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
circuit.ccx(f_in[2], aux[num_clauses], aux[k])
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
for literal in clause:
if literal < 0:
circuit.x(f_in[-literal-1])
def exactly1_threeSAT_oracle(circuit, f_in, f_out, aux, n, expression):
num_clauses = len(expression)
for k, clause in enumerate(expression):
for literal in clause:
if literal > 0:
circuit.cx(f_in[literal-1], aux[k])
else:
circuit.x(f_in[-literal-1])
circuit.cx(f_in[-literal-1], aux[k])
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
circuit.ccx(f_in[2], aux[num_clauses], aux[k])
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
for literal in clause:
if literal < 0:
circuit.x(f_in[-literal-1])
if num_clauses == 1:
circuit.cx(aux[0], f_out[0])
elif num_clauses == 2:
circuit.ccx(aux[0], aux[1], f_out[0])
else:
circuit.ccx(aux[0], aux[1], aux[num_clauses])
for i in range(2, num_clauses-1):
circuit.ccx(aux[i], aux[num_clauses+i-2], aux[num_clauses+i-1])
circuit.ccx(aux[num_clauses-1], aux[2*num_clauses-3], f_out[0])
for i in range(num_clauses-2, 1, -1):
circuit.ccx(aux[i], aux[num_clauses+i-2], aux[num_clauses+i-1])
circuit.ccx(aux[0], aux[1], aux[num_clauses])
for k, clause in enumerate(expression):
for literal in clause:
if literal > 0:
circuit.cx(f_in[literal-1], aux[k])
else:
circuit.x(f_in[-literal-1])
circuit.cx(f_in[-literal-1], aux[k])
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
circuit.ccx(f_in[2], aux[num_clauses], aux[k])
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
for literal in clause:
if literal < 0:
circuit.x(f_in[-literal-1])
def n_controlled_Z(qc, controls, target, aux):
n = len(controls)
qc.h(target)
if (n == 1):
qc.cx(controls[0], target)
elif (n == 2):
qc.ccx(controls[0], controls[1], target)
else:
qc.ccx(controls[0], controls[1], aux[0])
for i in range(2, n-1):
qc.ccx(controls[i], aux[i-2], aux[i-1])
qc.ccx(controls[n-1], aux[n-3], target)
for i in range(n-2, 1, -1):
qc.ccx(controls[i], aux[i-2], aux[i-1])
qc.ccx(controls[0], controls[1], aux[0])
qc.h(target)
def reflect_around_psi(qc, qr1, aux, n=3):
for j in range(n):
qc.h(qr1[j])
qc.x(qr1[j])
n_controlled_Z(qc, qr1[:-1], qr1[-1], aux)
for j in range(n):
qc.x(qr1[j])
qc.h(qr1[j])
def input_state(qc, qr1, qr2, n=3):
for j in range(n):
qc.h(qr1[j])
qc.x(qr2)
qc.h(qr2)
qc.barrier()
# Make a quantum program for the n-bit Grover search.
n = 4
expression = [[1, 2, 3], [-1, 3, 4], [1,2,-4], [-2,3,-4], [-2,-3,4]]
# n = 3
# expression = [[1, 2, -3], [-1, -2, -3], [-1, 2, 3]]
num_run = 4
grovers=[]
for num_grover in range(1,num_run+1):
var = QuantumRegister(n)
res = QuantumRegister(1)
aux = QuantumRegister(2*len(expression)-2)
ans = ClassicalRegister(n)
grover = QuantumCircuit()
grover.add_register(var)
grover.add_register(res)
grover.add_register(aux)
grover.add_register(ans)
input_state(grover, var, res, n)
for _ in range(num_grover):
threeSAT_oracle(grover, var, res, aux, n, expression)
# exactly1_threeSAT_oracle(grover, var, res, aux, n, expression)
grover.barrier()
reflect_around_psi(grover, var, aux, n)
grover.barrier()
for j in range(n):
grover.measure(var[j], ans[j])
grovers.append(grover)
grovers[0].draw(output='mpl')
TOKEN = ''
provider = IBMProvider(token=TOKEN)
# display current supported backends
# print(provider.backends())
# get IBM's simulator backend
backend = provider.get_backend('ibmq_qasm_simulator')
results=[]
histos=[]
for grover in grovers:
# Execute circuit
job = execute(grover, backend=backend)
result = job.result()
counts = result.get_counts(grover)
results.append(result)
histos.append(plot_histogram(counts))
len(histos)
histos[0]
histos[1]
histos[2]
histos[3]
histos[4]
|
https://github.com/tuf65651/quantum-research
|
tuf65651
|
# %matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
# import math
# Loading your IBM Q account(s)
# IBMQ.load_account()
backend = Aer.get_backend("qasm_simulator")
from ArithmaticFunctions import *
def convolute_shift_func(circuit, control_reg, acc_reg, power):
"""Implement bit shift.
@param circuit: QuantumCircuit containing operands
@param control_reg: QuantumRegister containing qubit that defines power (all operations conditional on this)
@param acc_reg: QuantumRegister containing integer to shift
@param power: int number of places to shift (if control_reg[power])"""
## NOTE: Power is the number of places to shift. Power 1 is controlled by
## control register's 2nd bit, which is control_reg[1]
## and refers to shift of 2^1, or shift one place
# Flip all qubits in accumulator to allow ripple carry
# for qubit in range(len(acc_reg)):
# circuit.x(acc_reg[qubit])
for target_bit in range(len(acc_reg) - 1):
# shift bit by correct number of places
# circuit.ccx(control_reg[power], acc_reg[target_bit], acc_reg[target_bit + power])
# Circuit will flip target bit before evaluating. Preempt that first flip.
circuit.cx(control_reg[power], acc_reg[target_bit])
# Flip next bit if carry occurs
for flipped_bit in range(target_bit, len(acc_reg) - 1):
## Carry occurs if target now 0 (if flip makes it 1).
circuit.cx(control_reg[power], acc_reg[flipped_bit])
circuit.ccx(control_reg[power], acc_reg[flipped_bit], acc_reg[flipped_bit + 1])
circuit.cx(control_reg[power], acc_reg[flipped_bit])
# Flip bit that's being shifted
# circuit.cx(control_reg[power], acc_reg[target_bit])
def ripple_carry_bits(circuit, control_bit, acc_reg, scratch_reg, start_shifting_at):
"""Continue a carry operation
This assumes that whatever simple op triggered the ripple has already occurred.
For example, if the ripple started with addition of 1 to the least significant bit,
manually flip and then call function.
@param circuit: QuantumCircuit containing operands
@param control_bit: single bit controling whether op begins.
@param acc_reg: QuantumRegister containing integer to shift
@param scratch_reg: Quantum registered in initial |0..0> state used to store carry result of each simple addition.
@param start_shifting_at: index in acc_reg of bit to shift
TESTING - Passed minimal test cases July 18 at 8:24am Pacific Time
"""
"""
NOTE: Power is the number of places to shift. Power 1 is controlled by
control register's 2nd bit, which is control_reg[1]
and refers to shift of 2^1, or shift one place
"""
circuit.ccx(control_bit, acc_reg[start_shifting_at], scratch_reg[start_shifting_at])
circuit.cx(control_bit, acc_reg[start_shifting_at])
# After flipping target, state |0> means we should have carried... =>
# before flipping target, state |1> means we should carry.
# Flip each bit, if it's 1, carry to the next bit, and flip it back.
for bit in range(start_shifting_at + 1, len(acc_reg) - 1):
circuit.ccx(acc_reg[bit], scratch_reg[bit - 1], scratch_reg[bit])
circuit.cx(scratch_reg[bit - 1], acc_reg[bit])
def c_ripple_subtract(circuit, control_bit, min_reg, scratch_reg, start_shifting_at):
"""Continue a subtract operation
@param circuit: QuantumCircuit containing operands
@param control_bit: single bit controling whether op begins.
@param min_reg: QuantumRegister containing integer to transform
@param scratch_reg: Quantum register in initial |0..0> state used to store carry result of each simple addition.
@param start_shifting_at: index in acc_reg of bit to shift
"""
circuit.x(min_reg[start_shifting_at])
circuit.ccx(min_reg[start_shifting_at], control_bit, scratch_reg[start_shifting_at])
circuit.x(min_reg[start_shifting_at])
# Check how deep the borrow goes. Flip a scratch bit for every borrow op.
for bit in range(start_shifting_at + 1, len(min_reg)):
circuit.x(min_reg[bit])
circuit.ccx(min_reg[bit], scratch_reg[bit - 1], scratch_reg[bit])
circuit.x(min_reg[bit])
# Perform every borrow indicated in scratch, and then flip targeted bit.
for bit in range(len(scratch_reg) - 2, -1, -1):
circuit.cx(scratch_reg[bit], min_reg[bit+1])
# Finally flip original target bit
circuit.x(min_reg[start_shifting_at])
def carry_op(circuit, a_reg, acc_reg, scratch_reg):
"""Used as 'CARRY' operator for circuit illustated in arxiv.org/quant-ph/9511018
@param circuit: QuantumCircuit
@param a_reg: QuantumRegister containing addend
@param acc_reg: QuantumRegister 'b' starts with addend and accumulates sum
@param scratch_reg: QuantumRegister holds carry bits at each step"""
for bit in range(len(a_reg)):
circuit.cx(a_reg[bit], acc_reg[bit])
circuit.x(acc_reg[bit])
circuit.cx(acc_reg[bit], scratch_reg[bit])
circuit.x(acc_reg[bit])
def add_to_b_in_place(circuit, a_reg, b_reg, scratch_reg):
"""|a > | b > => |a > |a+b >
TESTING - Passed minimal test cases July 18 at 8:24am Pacific Time
"""
for bit in range(len(a_reg)):
circuit.reset(scratch_reg)
ripple_carry_bits(
circuit=circuit,
control_bit=a_reg[bit],
acc_reg=b_reg,
scratch_reg=scratch_reg,
start_shifting_at=bit)
def sub_b_from_a_in_place(circuit, minnd_reg, subtrhnd_reg, scratch_reg):
"""Subtract subtrahend integer b from minuend integer a in register a
@param circuit: QuantumCircuit containing other parameters
@param minnd_reg: QuantumRegister transformed from minuend to difference
@param subtrhnd_reg: QuantumRegister containing subtrahend
@param scratch_reg: QuantumRegister in initial |0...0> state used as borrow flags
for each primitive op (final bit indicates negative difference)
"""
def bit_shift_left(circuit, register, places=1):
"""
TESTING - Passed minimal test cases July 21 at 2:30 Pacific Time
"""
# zero out all trailing bits
num_bits = len(register)
for rollover in range(num_bits - places, num_bits):
circuit.reset(register[rollover])
# swap every bit 'places' forward, with last bits wrapping around to beginning
for bit in range(num_bits - 1,places-1,-1):
circuit.swap(register[bit], register[bit - places])
def c_copy_register(circuit, control_bit, origin, dest):
"""sets contents of dest with contents of origin if control_bit
WARNING - perform a reset before use
"""
circuit.reset(dest)
for bit in range(len(dest)):
circuit.ccx(control_bit, origin[bit], dest[bit])
def multiply(circuit, multiplicand, multiplier, scratch_zero_check, scratch_carrier, prod_accumulator):
c_copy_register(circuit=circuit, control_bit=multiplier[0], origin=multiplicand, dest=prod_accumulator)
for bit in range(1, len(multiplier)):
# free up scratch space
circuit.reset(scratch_carrier)
circuit.reset(scratch_zero_check)
# shift multiplicand one space left, to match magnitude of current multiplier bit
bit_shift_left(circuit=circuit, register=multiplicand, places=1)
# copy multiplicand into scratch register only if multiplicand bit, else keep scratch register |0>
c_copy_register(circuit=circuit, control_bit=multiplier[bit], origin=multiplicand, dest=scratch_zero_check)
# add that scratch term (shifted multiplicand or zero) to accumulated product
add_to_b_in_place(circuit=circuit, a_reg=scratch_zero_check, b_reg=prod_accumulator, scratch_reg=scratch_carrier)
n_reg = QuantumRegister(3, 'n')
m_reg = QuantumRegister(3, 'm')
scratch_a = QuantumRegister(3, 'sca')
scratch_b = QuantumRegister(3, 'scb')
scratch_y = QuantumRegister(3, 'accm')
class_reg = ClassicalRegister(3, 'y')
qc = QuantumCircuit(n_reg, m_reg, scratch_a, scratch_b, scratch_y, class_reg)
# Register n set to 5
qc.x(n_reg[0])
qc.x(n_reg[1])
# qc.x(n_reg[2])
# Register m set to
# qc.x(m_reg[0])
qc.x(m_reg[1])
n_reg = QuantumRegister(3, 'n')
m_reg = QuantumRegister(2, 'm')
scratch_a = QuantumRegister(3, 'sca')
class_reg = ClassicalRegister(3, 'y')
backend = Aer.get_backend('qasm_simulator')
n_reg = QuantumRegister(3, 'n')
scratch_a = QuantumRegister(3, 'sca')
qc = QuantumCircuit(n_reg, m_reg, scratch_a, class_reg)
# Set control bits
qc.x(m_reg[1])
# 1 - 1 = 0
"""
PASSED July 29 10:58am Pacific Time
"""
qc.x(n_reg[0])
qc.barrier()
c_ripple_subtract(circuit=qc, min_reg=n_reg, control_bit=m_reg[1], scratch_reg=scratch_a, start_shifting_at=0)
qc.draw()
# 2 - 1 = 1
"""
PASSED July 29 10:58am Pacific Time
"""
qc.x(n_reg[1])
qc.barrier()
c_ripple_subtract(circuit=qc, min_reg=n_reg, control_bit=m_reg[True], scratch_reg=scratch_a, start_shifting_at=0)
# qc.draw()
# 4 - 1 = 3
"""
PASSED July 29 10:58am Pacific Time
"""
qc.x(n_reg[2])
c_ripple_subtract(circuit=qc, min_reg=n_reg, control_bit=m_reg[True], scratch_reg=scratch_a, start_shifting_at=0)
qc.draw()
# 6 - 1 = 5
"""
PASSED July 29 10:58am Pacific Time
"""
qc.x(n_reg[1])
qc.x(n_reg[2])
c_ripple_subtract(circuit=qc, min_reg=n_reg, control_bit=n_reg[True], scratch_reg=scratch_a, start_shifting_at=0)
qc.draw()
# 5 - 1 = 4
"""
PASSED July 29 10:58am Pacific Time
"""
qc.x(n_reg[0])
qc.x(n_reg[2])
c_ripple_subtract(circuit=qc, min_reg=n_reg, control_bit=m_reg[True], scratch_reg=scratch_a, start_shifting_at=0)
# c_draw()
# 5 - 2 = 3
"""
PASSED July 29 10:58am Pacific Time
"""
qc.x(n_reg[0])
qc.x(n_reg[2])
c_ripple_subtract(circuit=qc, min_reg=n_reg, control_bit=m_reg[True], scratch_reg=scratch_a, start_shifting_at=1)
# qc.draw()
# 7 - 2 = 5
qc.x(n_reg[0])
qc.x(n_reg[1])
qc.x(n_reg[2])
c_ripple_subtract(circuit=qc, min_reg=n_reg, control_bit=m_reg[True], scratch_reg=scratch_a, start_shifting_at=1)
qc.draw()
# 7 - 0 = 7
qc.x(n_reg[0])
qc.x(n_reg[1])
qc.x(n_reg[2])
qc.barrier()
c_ripple_subtract(circuit=qc, min_reg=n_reg, control_bit=m_reg[False], scratch_reg=scratch_a, start_shifting_at=1)
qc.draw()
# 1 - 2 = ?
qc.x(n_reg[0])
c_ripple_subtract(circuit=qc, min_reg=n_reg, control_bit=m_reg[True], scratch_reg=scratch_a, start_shifting_at=1)
# c_draw()
for bit in range(len(n_reg)):
qc.measure(n_reg[bit], class_reg[bit])
execute(qc, backend=backend, shots=1024).result().get_counts()
multiply(
circuit=qc,
multiplier=n_reg,
multiplicand=m_reg,
scratch_zero_check=scratch_b,
scratch_carrier=scratch_a,
prod_accumulator=scratch_y)
# add_to_b_in_place(circuit=qc, a_reg=n_reg, b_reg=m_reg, scratch_reg=scratch_a)
# bit_shift_left(circuit=qc, register=m_reg, places=1)
# ripple_carry_bits(circuit=qc, control_bit=n_reg[0],acc_reg=m_reg,scratch_reg=scratch_reg, start_shifting_at=0)
# bit_shift_left(circuit=qc, register=m_reg, places=1)
for index in range(len(m_reg)):
qc.measure(scratch_y[index], class_reg[index])
qc.draw()
qc_opt = transpile(qc, optimization_level=1, backend=backend)
qc_opt.draw()
simulate = execute(qc_opt, backend=backend, shots=1024).result()
simulate.get_counts()
qc.reset(n_reg[0])
print(max_memory_mb)
|
https://github.com/tuf65651/quantum-research
|
tuf65651
|
%matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
import math
# Loading your IBM Q account(s)
IBMQ.load_accounts()
backend = Aer.get_backend("qasm_simulator")
def bin_expansion(circ, q, N):
"""Places q of |0> into binary expansion of N"""
for i in range(N + 1):
# while N >= 0:
if N & (1 << i):
circ.x(q[i])
q = QuantumRegister(5, 'x')
c = ClassicalRegister(5, 'y')
qc = QuantumCircuit(q, c)
bin_expansion(qc, q, 5)
for i in range(5):
qc.measure(q[i], c[i])
qc.draw()
simulate = execute(qc, backend=backend, shots=1024).result()
def raw_bin_exp(N):
place_mask = 1
bins = []
# more_digits = True
while place_mask <= N:
# while N >= 0:
if N & place_mask:
bins = [1] + bins
else:
bins = [0] + bins
# place += 1
place_mask = place_mask * 2
# more_digits
if bins == []:
bins = [0]
return bins
simulate.get_counts()
|
https://github.com/tuf65651/quantum-research
|
tuf65651
|
# %matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from datetime import datetime
# import math
# Loading your IBM Q account(s)
# IBMQ.load_account()
backend = Aer.get_backend("qasm_simulator")
# global n_reg
# global m_reg
# global scratch_a
# global class_reg
# global backend
# global qc
# global test_timestamp
# def before_tests():
n_reg = QuantumRegister(6, 'n')
m_reg = QuantumRegister(6, 'm')
scratch_a = QuantumRegister(6, 'sca')
class_reg = ClassicalRegister(6, 'y')
qc = QuantumCircuit(n_reg, m_reg, scratch_a, class_reg)
backend = Aer.get_backend('qasm_simulator')
from ArithmaticFunctions import *
# time_stamp = str(datetime.now())
test_timestamp = str(datetime.now())
def setup_each_addition():
n_reg = QuantumRegister(6, 'n')
m_reg = QuantumRegister(6, 'm')
scratch_a = QuantumRegister(6, 'sca')
class_reg = ClassicalRegister(6, 'y')
qc = QuantumCircuit(n_reg, m_reg, scratch_a, class_reg)
# return {'n_reg': n_reg, 'm_reg': m_reg, 'scratch_a': scratch_a, 'class_reg': class_reg, 'qc': qc }
def get_results_of_last_test():
# for bit in range(len(n_reg)):
# qc.measure(n_reg[bit], class_reg[bit])
simulate = execute(qc, backend=backend, shots=1024).result()
return simulate.get_counts()
def verify_results(expected):
if [expected] == list(results.keys()):
print("PASSING - ", test_timestamp)
else:
print("FAILING - ", test_timestamp)
print(f'Got - {results}')
setup_each_addition()
qc.x(m_reg[0])
CDKM_add(qc, n_reg, m_reg, scratch_a)
qc.measure(m_reg, class_reg)
results = get_results_of_last_test()
verify_results('000001')
setup_each_addition()
qc.x(n_reg[0])
CDKM_add(qc, n_reg, m_reg, scratch_a)
qc.measure(m_reg, class_reg)
results = get_results_of_last_test()
verify_results('000001')
setup_each_addition()
qc.x(n_reg[0])
qc.x(m_reg[0])
qc.barrier()
CDKM_add(qc, n_reg, m_reg, scratch_a)
qc.measure(n_reg, class_reg)
results = get_results_of_last_test()
# qc.draw()
verify_results('000010')
a = QuantumRegister(3, 'a')
b = QuantumRegister(3, 'b')
c = QuantumRegister(3, 'c')
y = ClassicalRegister(3, 'y')
circ = QuantumCircuit(a,b,c,y)
circ.x(a[1])
circ.x(b[1])
MAJ(circ, bit_a=a[0], bit_b=b[0], bit_c=c[0])
MAJ(circ, bit_a=a[1], bit_b=b[1], bit_c=a[0])
circ.cx(a[1], c[1])
UMA(circ, bit_a=a[1], bit_b=b[1], bit_c=a[0])
UMA(circ, bit_a=a[0], bit_b=b[0], bit_c=c[0])
circ.measure(c, y)
results = execute(circ, backend, shots=1024).result().get_counts()
print(results)
MAJ(circ, bit_a=a[0], bit_b=b[0], bit_c=c[0])
circ.draw()
len(scratch_a)
# setup_each_addition()
qc.x(n_reg[0])
qc.x(n_reg[1])
# qc.x(m_reg[0])
qc.barrier()
twos_compelement(qc, n_reg, scratch_a)
twos_compelement(qc, n_reg, scratch_a)
qc.measure(n_reg, class_reg)
results = get_results_of_last_test()
# qc.draw()
results = execute(qc, backend, shots=1024).result().get_counts()
print(results)
qc.draw()
a = QuantumRegister(4, 'a')
b = QuantumRegister(4, 'b')
c = QuantumRegister(4, 'c')
d = QuantumRegister(4, 'd')
y = ClassicalRegister(4, 'y')
z = ClassicalRegister(4, 'z')
qc = QuantumCircuit(a,b,c,d,y,z)
qc.x(a[0])
qc.x(b[1])
qc.barrier()
# twos_compelement(qc, a, c)
CDKM_add(qc, a, b, c)
# twos_compelement(qc, b, c)
# twos_compelement(qc, a, c)
qc.measure(a, y)
qc.measure(b, z)
results = execute(qc, backend, shots=1024).result().get_counts()
print(results)
qc.draw()
qc.x(a[1])
qc.x(b[0])
qc.barrier()
# twos_compelement(qc, a, c)
sub_b_from_a_in_place(qc, a, b, c)
# twos_compelement(qc, b, c)
# twos_compelement(qc, a, c)
qc.measure(c, y)
# qc.measure(d, z)
results = execute(qc, backend, shots=1024).result().get_counts()
print(results)
qc.x(a[1])
qc.x(b[1])
qc.barrier()
# twos_compelement(qc, a, c)
sub_b_from_a_in_place(qc, a, b, c)
# twos_compelement(qc, b, c)
# twos_compelement(qc, a, c)
qc.measure(c, y)
# qc.measure(d, z)
results = execute(qc, backend, shots=1024).result().get_counts()
print(results)
|
https://github.com/tuf65651/quantum-research
|
tuf65651
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
backend = Aer.get_backend("qasm_simulator")
"""implelement gates from arxiv.org quant-ph/0410184, A new quantum ripple-carry addition circuit"""
def MAJ(circuit, a, b, out):
"""Put out bit into state that majority of a b and out were in"""
circuit.cx(out, a)
circuit.cx(out, b)
circuit.ccx(a,b, out)
def UMA(circuit, u, m, a):
"""UnMajority and Add"""
circuit.x(m)
circuit.cx(u,m)
circuit.ccx(u,m,a)
circuit.x(m)
circuit.cx(a,u)
circuit.cx(a,m)
a = QuantumRegister(6, 'a')
b = QuantumRegister(6, 'b')
c = QuantumRegister(1, 'c')
y = QuantumRegister(1, 'z')
y = ClassicalRegister(4, 'y')
qc = QuantumCircuit(m,n,c,y)
MAJ(qc, m[0], n[1], c[0])
qc.draw()
|
https://github.com/tuf65651/quantum-research
|
tuf65651
|
%matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
import math
# Loading your IBM Q account(s)
IBMQ.load_account()
backend = Aer.get_backend("qasm_simulator")
n_reg = QuantumRegister(4, 'n')
m_reg = QuantumRegister(8, 'm')
c_reg = ClassicalRegister(8, 'y')
qc = QuantumCircuit(n_reg, m_reg,c_reg)
# Register n set to 5
qc.x(n_reg[0])
qc.x(n_reg[1])
# Register m set to 3
qc.x(m_reg[0])
qc.x(m_reg[2])
def convolute_shift_func(circuit, control_reg, acc_reg, power):
"""Implement bit shift.
@param circuit: QuantumCircuit containing operands
@param control_reg: QuantumRegister containing qubit that defines power (all operations conditional on this)
@param acc_reg: QuantumRegister containing integer to shift
@param power: int number of places to shift (if control_reg[power])"""
## NOTE: Power is the number of places to shift. Power 1 is controlled by
## control register's 2nd bit, which is control_reg[1]
## and refers to shift of 2^1, or shift one place
# Flip all qubits in accumulator to allow ripple carry
# for qubit in range(len(acc_reg)):
# circuit.x(acc_reg[qubit])
for target_bit in range(len(acc_reg) - 1):
# shift bit by correct number of places
# circuit.ccx(control_reg[power], acc_reg[target_bit], acc_reg[target_bit + power])
# Circuit will flip target bit before evaluating. Preempt that first flip.
circuit.cx(control_reg[power], acc_reg[target_bit])
# Flip next bit if carry occurs
for flipped_bit in range(target_bit, len(acc_reg) - 1):
## Carry occurs if target now 0 (if flip makes it 1).
circuit.cx(control_reg[power], acc_reg[flipped_bit])
circuit.ccx(control_reg[power], acc_reg[flipped_bit], acc_reg[flipped_bit + 1])
circuit.cx(control_reg[power], acc_reg[flipped_bit])
# Flip bit that's being shifted
# circuit.cx(control_reg[power], acc_reg[target_bit])
def ripple_carry_bits(circuit, control_bit, acc_reg, start_shifting_at):
"""Implement bit shift.
@param circuit: QuantumCircuit containing operands
@param control_reg: QuantumRegister containing qubit that defines power (all operations conditional on this)
@param acc_reg: QuantumRegister containing integer to shift
@param power: int number of places to shift (if control_reg[power])
@param start_shifting_at: index in acc_reg of bit to shift"""
"""
NOTE: Power is the number of places to shift. Power 1 is controlled by
control register's 2nd bit, which is control_reg[1]
and refers to shift of 2^1, or shift one place
"""
# After flipping target, state |0> means we should have carried... =>
# before flipping target, state |1> means we should carry.
ripple_carry_bits(circuit, control_bit, acc_reg, start_shifting)
circuit.cx(control_reg[power], acc_reg[target_bit])
control_shift_bit_x_places(qc, n_reg, m_reg, 1)
for index in range(len(n_reg)):
qc.measure(m_reg[index], c_reg[index])
qc.draw()
simulate = execute(qc, backend=backend, shots=1024).result()
simulate.get_counts()
print([x for x in range(9, 4, -1)])
|
https://github.com/tuf65651/quantum-research
|
tuf65651
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
backend = Aer.get_backend("qasm_simulator")
def ripple_carry_bits(circuit, control_bit, acc_reg, scratch_reg, start_shifting_at):
"""Continue a carry operation
This assumes that whatever simple op triggered the ripple has already occurred.
For example, if the ripple started with addition of 1 to the least significant bit,
manually flip and then call function.
@param circuit: QuantumCircuit containing operands
@param control_bit: single bit controling whether op begins.
@param acc_reg: QuantumRegister containing integer to shift
@param scratch_reg: Quantum registered in initial |0..0> state used to store carry result of each simple addition.
@param start_shifting_at: index in acc_reg of bit to shift
TESTING - Passed minimal test cases July 18 at 8:24am Pacific Time
"""
circuit.ccx(control_bit, acc_reg[start_shifting_at], scratch_reg[start_shifting_at])
circuit.cx(control_bit, acc_reg[start_shifting_at])
# After flipping target, state |0> means we should have carried... =>
# before flipping target, state |1> means we should carry.
# Flip each bit, if it's 1, carry to the next bit, and flip it back.
for bit in range(start_shifting_at + 1, len(acc_reg) - 1):
circuit.ccx(acc_reg[bit], scratch_reg[bit - 1], scratch_reg[bit])
circuit.cx(scratch_reg[bit - 1], acc_reg[bit])
def c_ripple_subtract(circuit, control_bit, min_reg, scratch_reg, start_shifting_at):
"""Continue a subtract operation
@param circuit: QuantumCircuit containing operands
@param control_bit: single bit controling whether op begins.
@param min_reg: QuantumRegister containing integer to shift
@param scratch_reg: Quantum registered in initial |0..0> state used to store carry result of each simple addition.
@param start_shifting_at: index in acc_reg of bit to shift
TESTING - Passed minimal test cases July 18 at 8:24am Pacific Time
"""
circuit.ccx(control_bit, acc_reg[start_shifting_at], scratch_reg[start_shifting_at])
circuit.cx(control_bit, acc_reg[start_shifting_at])
# After flipping target, state |0> means we should have carried... =>
# before flipping target, state |1> means we should carry.
# Flip each bit, if it's 1, carry to the next bit, and flip it back.
for bit in range(start_shifting_at + 1, len(acc_reg) - 1):
circuit.ccx(acc_reg[bit], scratch_reg[bit - 1], scratch_reg[bit])
circuit.cx(scratch_reg[bit - 1], acc_reg[bit])
def add_to_b_in_place(circuit, a_reg, b_reg, scratch_reg):
"""|a > | b > => |a > |a+b >
TESTING - Passed minimal test cases July 18 at 8:24am Pacific Time
"""
for bit in range(len(a_reg)):
circuit.reset(scratch_reg)
ripple_carry_bits(
circuit=circuit,
control_bit=a_reg[bit],
acc_reg=b_reg,
scratch_reg=scratch_reg,
start_shifting_at=bit)
def sub_b_from_a_in_place(circuit, minnd_reg, subtrhnd_reg, scratch_reg):
"""Subtract subtrahend integer b from minuend integer a in register a
@param circuit: QuantumCircuit containing other parameters
@param minnd_reg: QuantumRegister transformed from minuend to difference
@param subtrhnd_reg: QuantumRegister containing subtrahend
@param scratch_reg: QuantumRegister in initial |0...0> state used as borrow flags
for each primitive op (final bit indicates negative difference)
"""
def bit_shift_left(circuit, register, places=1):
"""
TESTING - Passed minimal test cases July 21 at 2:30 Pacific Time
"""
# zero out all trailing bits
num_bits = len(register)
for rollover in range(num_bits - places, num_bits):
circuit.reset(register[rollover])
# swap every bit 'places' forward, with last bits wrapping around to beginning
for bit in range(num_bits - 1,places-1,-1):
circuit.swap(register[bit], register[bit - places])
def c_copy_register(circuit, control_bit, origin, dest):
"""sets contents of dest with contents of origin if control_bit
WARNING - perform a reset before use
"""
circuit.reset(dest)
for bit in range(len(dest)):
circuit.ccx(control_bit, origin[bit], dest[bit])
def multiply(circuit, multiplicand, multiplier, scratch_zero_check, scratch_carrier, prod_accumulator):
c_copy_register(circuit=circuit, control_bit=multiplier[0], origin=multiplicand, dest=prod_accumulator)
for bit in range(1, len(multiplier)):
# free up scratch space
circuit.reset(scratch_carrier)
circuit.reset(scratch_zero_check)
# shift multiplicand one space left, to match magnitude of current multiplier bit
bit_shift_left(circuit=circuit, register=multiplicand, places=1)
# copy multiplicand into scratch register only if multiplicand bit, else keep scratch register |0>
c_copy_register(circuit=circuit, control_bit=multiplier[bit], origin=multiplicand, dest=scratch_zero_check)
# add that scratch term (shifted multiplicand or zero) to accumulated product
add_to_b_in_place(circuit=circuit, a_reg=scratch_zero_check, b_reg=prod_accumulator, scratch_reg=scratch_carrier)
|
https://github.com/tuf65651/quantum-research
|
tuf65651
|
#!/usr/bin/env python
# coding: utf-8
# In[13]:
get_ipython().run_line_magic('matplotlib', 'inline')
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
import math
# Loading your IBM Q account(s)
IBMQ.load_accounts()
# In[14]:
backend = Aer.get_backend("qasm_simulator")
# In[26]:
n_reg = QuantumRegister(4, 'n')
m_reg = QuantumRegister(8, 'm')
c_reg = ClassicalRegister(8, 'y')
qc = QuantumCircuit(n_reg, m_reg,c_reg)
# In[27]:
# Register n set to 5
qc.x(n_reg[0])
qc.x(n_reg[2])
# Register m set to 3
qc.x(m_reg[0])
qc.x(m_reg[1])
# In[24]:
def bit_shift_x_bits(circuit, control_reg, acc_reg, power):
"""Implement bit shift.
@param circuit: QuantumCircuit containing operands
@param control_reg: QuantumRegister containing qubit that defines power (all operations conditional on this)
@param acc_reg: QuantumRegister containing integer to shift
@param power: int number of places to shift (if control_reg[power])"""
## NOTE: Power is the number of places to shift. Power 1 is controlled by
## control register's 2nd bit, which is control_reg[1]
## and refers to shift of 2^1, or shift one place
# Flip all qubits in accumulator to allow ripple carry
# for qubit in range(len(acc_reg)):
# circuit.x(acc_reg[qubit])
for target_bit in range(len(acc_reg) - 1):
# shift bit by correct number of places
circuit.ccx(control_reg[power], acc_reg[target_bit], acc_reg[target_bit + power])
# Flip next bit if carry occurs
for flipped_bit in range(target_bit, len(acc_reg) - 1):
## Carry occurs if target now 0 (if flip makes it 1).
circuit.cx(control_reg[power], acc_reg[flipped_bit])
circuit.ccx(control_reg[power], acc_reg[flipped_bit], acc_reg[flipped_bit + 1])
circuit.cx(control_reg[power], acc_reg[flipped_bit])
# Flip bit that's being shifted
# circuit.cx(control_reg[power], acc_reg[target_bit])
# In[28]:
bit_shift_x_bits(qc, n_reg, m_reg, 1)
for index in range(len(n_reg)):
qc.measure(n_reg[index], c_reg[index])
qc.draw()
# In[29]:
simulate = execute(qc, backend=backend, shots=1024).result()
# In[30]:
simulate.get_counts()
# In[6]:
print([x for x in range(9, 4, -1)])
# In[ ]:
|
https://github.com/tuf65651/quantum-research
|
tuf65651
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from datetime import datetime
backend = Aer.get_backend("qasm_simulator")
global n_reg # = QuantumRegister(6, 'n')
global scratch_a
global class_reg # = ClassicalRegister(6, 'y')
global qc # = QuantumCircuit(n_reg, m_reg, scratch_a, class_reg)
test_timestamp = datetime.now()
from ArithmaticFunctions import *
def setup_each_addition():
n_reg = QuantumRegister(6, 'n')
m_reg = QuantumRegister(6, 'm')
scratch_a = QuantumRegister(6, 'sca')
scratch_b = QuantumRegister(6, 'scb')
class_reg = ClassicalRegister(6, 'y')
qc = QuantumCircuit(n_reg, m_reg, scratch_a, scratch_b, class_reg)
return {'n_reg': n_reg, 'm_reg': m_reg, 'scratch_a': scratch_a, 'scratch_b': scratch_b, 'class_reg': class_reg, 'qc': qc }
# def get_results_of_last_test():
# # for bit in range(len(n_reg)):
# # qc.measure(n_reg[bit], class_reg[bit])
# simulate = execute(qc, backend=backend, shots=1024).result()
return simulate.get_counts()
def verify_results(expected):
if [expected] == list(results.keys()):
print("PASSING - ", test_timestamp)
else:
print("FAILING - ", test_timestamp)
print(f'Got - {results}')
tc = setup_each_addition()
qc = tc['qc']
qc.x(tc['m_reg'][0])
qc.x(tc['m_reg'][2])
qc.x(tc['n_reg'][3])
mod_reduce(circuit=qc, mod_reg=tc['m_reg'], base_reg=tc['n_reg'], scratch_carry=tc['scratch_a'], scratch_unadd=tc['scratch_b'] )
qc.measure(tc['n_reg'], tc['class_reg'])
simulate = execute(qc, backend=backend, shots=1024).result()
print(simulate.get_counts())
|
https://github.com/tuf65651/quantum-research
|
tuf65651
|
%matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
import math
# Loading your IBM Q account(s)
IBMQ.load_accounts()
q = QuantumRegister(3)
c = ClassicalRegister(3)
qft3 = QuantumCircuit(q,c)
qft3.h(q[0])
qft3.cu1(math.pi/2, q[1], q[0])
qft3.cu1(math.pi/4, q[2], q[0])
qft3.h(q[1])
qft3.cu1(math.pi/2, q[2], q[1])
qft3.h(q[2])
qft3.draw()
def input_state(circ, q, n):
"""n-bit input state for QFT that produces output 1."""
for j in range(n):
circ.h(q[j])
circ.u1(math.pi/float(2**j) * (-1), q[j])#.inverse()
def qft(circ, q, n):
"""n-bit QFT on q in circ"""
for j in range(n):
circ.h(q[j])
for k in range(j+1, n):
circ.cu1(math.pi/float(2**(k-j)), q[k], q[j])
circ.barrier()
q = QuantumRegister(3, 'x')
c = ClassicalRegister(3, 'c')
qft3 = QuantumCircuit(q, c)
qft(qft3, q, 3)
# qft(qft3, q, 3)
for i in range(3):
qft3.measure(q[i], c[i])
#print(qft3.qasm())
qft3.draw()
backend = Aer.get_backend("qasm_simulator")
simulate = execute(qft3, backend=backend, shots=4069).result()
simulate.get_counts()
plot_histogram(simulate.get_counts())
q = QuantumRegister(8, 'x')
c = ClassicalRegister(8, 'c')
qft8a = QuantumCircuit(q, c)
# for i in range(4):
# qft8a.x(q[2*i])
qft(qft8a, q, 8)
qft(qft8a, q, 8)
for i in range(8):
qft8a.measure(q[i], c[i])
qft8a.draw()
backend = Aer.get_backend("qasm_simulator")
simulate = execute(qft8a, backend=backend, shots=1024).result()
plot_histogram(simulate.get_counts())
simulate.get_counts()
qft(qft3)
qft.measure(q,c)
|
https://github.com/tuf65651/quantum-research
|
tuf65651
|
"""Implementation of Shor's Algorithm using Qiskit and QASN simulator."""
"""All code by Shmuel Jacobs, algorithms as cited
Circuit is hard coded for specific case a=2, N=15 (N=21 code provided also)
"""
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
# from qiskit.tools.jupyter import *
from qiskit.visualization import *
from datetime import datetime
import math
REG_SIZE=6
N=15
N_len=4
from ArithmaticFunctions import *
backend = Aer.get_backend("qasm_simulator")
x_reg = QuantumRegister(N_len, 'x') # register holds superposition of powers, to which a is raised.
base_reg = QuantumRegister(REG_SIZE, 'base') # Evaluate a^x in this register
scratch_a = QuantumRegister(REG_SIZE, 'sca')
# Three scratch registers are needed. Each addition requires one carry register.
# Each multiplication requires additions, a register to hold conditional sum, and product accumulator.
# Multiplications as bitshifts require additions, conditional subtrahend and conditional shift value.
scratch_b = QuantumRegister(REG_SIZE, 'scb')
scratch_c = QuantumRegister(REG_SIZE, 'scc')
class_reg = ClassicalRegister(REG_SIZE, 'y')
# qc = QuantumCircuit(x_reg, base_reg, scratch_a, scratch_b, scratch_c, class_reg)
def qft(circ, q, n):
"""n-bit QFT on q in circ"""
for j in range(n):
circ.h(q[j])
for k in range(j+1, n):
circ.cu1(math.pi/float(2**(k-j)), q[k], q[j])
circ.barrier()
def flip_twentyone(circ, reg):
circ.x(reg[5])
circ.x(reg[3])
circ.x(reg[0])
def flip_fifteen(circ, reg):
for bit in range(N_len):
circ.x(reg[bit])
def build_circuit():
"""In the interest of saving memory, this function only builds | x, y }> -> | x, a^x Mod y }>
and transpiles along the way. QFT can be added after transpile."""
# qft(qc, x_reg, N_len)
#### Implement Exponentiation as a series of modular multiplications, Neilsen and Chang style
# NOTE: Selection of 2 as base allows bit shifts of one instead of multiplying base**i
# to prepare each exponential term. 2 is a suitable base for factoring 15 and 21, but is not
# always suitable. All multiplication by a power of two can be implemented as a bitshift.
"""When using base that is not a square integer, implement each multiplication by x^i using the following.
- Set scratch register to 1.
- c_copy original base (constant a in Neilsen and Chuang description) into scratch register.
- For j in 0:log2(i)
- multiply scratch register by itself
- mod reduce
"""
qc = QuantumCircuit(x_reg, base_reg, scratch_a, scratch_b, scratch_c, class_reg)
# Set base to 1
qc.x(base_reg[0])
# When x[0], multiply base by 2 (base *= x^1, implemented as overwrite to 2), else no op.
# This is a shortcut for 2^1 to cut down on multiplications.
qc.reset(scratch_a)
c_copy_register(qc, control_bit=x_reg[0], origin=base_reg, dest=scratch_a)
bit_shift_left(qc, scratch_a)
c_copy_register(qc, control_bit=x_reg[0], origin=scratch_a, dest=base_reg)
#### If x[1], double 2 times
# Copy into scratch register to double twice
qc.reset(scratch_a)
c_copy_register(qc, control_bit=x_reg[0], origin=base_reg, dest=scratch_a)
bit_shift_left(qc, scratch_a, places=2)
# Max value of scratch_a at this point is 2^3. Since period is not known,
# all future shifts are immediately followed by mod reduction.
#### Optimized multiplications are over. Define general case for a=2.
#### If x[k], mod double base_reg 2^(k+1) times
for k in range(2, len(x_reg)):
for j in range(2**k): # Pattern of copy -- double the copy -- reduce -- copy back
c_copy_register(qc, control_bit=x_reg[k], origin=base_reg, dest=scratch_a)
bit_shift_left(qc, scratch_a, places=1)
c_copy_register(qc, control_bit=x_reg[k], origin=scratch_a, dest=base_reg)
flip_fifteen(circ=qc, reg=scratch_a )
mod_reduce(
circuit=qc,
base_reg=base_reg,
mod_reg=scratch_a,
scratch_carry=scratch_b,
scratch_unadd=scratch_c)
gate_count = qc.count_ops()
# Transpile after each U operation, or circuit will fill memory
try:
qc = transpile(qc, backend=backend, optimization_level=2)
except MemoryError:
print(f'Failed to transpile after multplying 2^{k} times, with {gate_count} gates in circuit.')
"""At this point, base_reg holds a^x Mod N. Since x is superposition
from 0 to 15, base_reg is superposition of periodic mod function."""
# Get period of a^x Mod N
qft(qc, x_reg, N_len)
"""Quantum portion of algorithm is complete.
- Given period r = 4 for function 2^x Mod 15,we know 2^4 - 1 ModEquals 15 =>
(2^2 + 1)(2^2 - 1) ModEquals 15. GCD(3, 15) = 3 => 3 is a factor of 15,
GCD(5, 15) = 5 => 5 is a factor of 15.
- Given period r = 6 for function 2^x Mod 21,we know 2^6 - 1 ModEquals 21 =>
(2^3 + 1)(2^3 - 1) ModEquals 21. GCD(9, 21) = 3 => 3 is a factor of 21,
GCD(7, 21) = 7 => 7 is a factor of 21."""
return qc
def main():
first_QFT = QuantumCircuit(x_reg, base_reg, scratch_a, scratch_b, scratch_c, class_reg)
qft(first_QFT, x_reg, 4)
circuit = build_circuit()
# num_unopt_ops = circuit.count_ops()
# try:
# clumsy_qasm_file = open("Shor_Clumsy.qasm", 'w')
# clumsy_qasm_file.write(f'Un-optimized circuit uses {num_unopt_ops} gates')
# clumsy_qasm_file.write(circuit.qasm())
# clumsy_qasm_file.close()
# del clumsy_qasm_file
# except MemoryError:
# print("Can't write non-optimized circuit to file.")
# qc = transpile(circuit, backend=backend, optimization_level=2)
circuit = first_QFT + circuit
# try:
# qasm_out_file = open("Shor_Opt.qasm", 'w')
# qasm_out_file.write(circuit.qasm())
# qasm_out_file.write("\n\n")
# qasm_out_file.write(f'Optimized circuit uses {circuit.count_ops()} gates.')
# qasm_out_file.write(f'Optimized circuit uses {circuit.depth()} qubits.')
# except MemoryError:
# print("Can't write optimized circuit to file.")
# finally:
# qasm_out_file.close()
try:
qasm_out_file = open("results.txt", 'w')
simulate = execute(qc, backend=backend, shots=32).result()
qasm_out_file.write(simulate.get_counts())
except MemoryError:
exit("Failed")
finally:
qasm_out_file.close()
main()
|
https://github.com/tuf65651/quantum-research
|
tuf65651
|
# %matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from datetime import datetime
# import math
# Loading your IBM Q account(s)
# IBMQ.load_account()
def get_results_of_last_test():
for bit in range(len(n_reg)):
qc.measure(n_reg[bit], class_reg[bit])
simulate = execute(qc, backend=backend, shots=1024).result()
return simulate.get_counts()
def verify_results(expected):
time_stamp = str(datetime.now())
if [expected] == list(results.keys()):
print("PASSING - {}", test_timestamp)
else:
print("FAILING - {}", test_timestamp)
print(f'Got - {results}')
n_reg = QuantumRegister(3, 'n')
m_reg = QuantumRegister(3, 'm')
scratch_a = QuantumRegister(3, 'sca')
scratch_b = QuantumRegister(3, 'scb')
scratch_y = QuantumRegister(3, 'accm')
class_reg = ClassicalRegister(3, 'y')
qc = QuantumCircuit(n_reg, m_reg, scratch_a, scratch_b, scratch_y, class_reg)
# Register n set to 5
qc.x(n_reg[0])
qc.x(n_reg[1])
# qc.x(n_reg[2])
# Register m set to
# qc.x(m_reg[0])
qc.x(m_reg[1])
# global n_reg
# global m_reg
# global scratch_a
# global class_reg
# global backend
# global qc
# global test_timestamp
# def before_tests():
n_reg = QuantumRegister(3, 'n')
m_reg = QuantumRegister(2, 'm')
scratch_reg = QuantumRegister(3, 'sca')
class_reg = ClassicalRegister(3, 'y')
qc = QuantumCircuit(n_reg, m_reg, scratch_reg, class_reg)
backend = Aer.get_backend('qasm_simulator')
test_timestamp = str(datetime.now())
from ArithmaticFunctions import *
def before_each_ripple_borrow_test():
n_reg = QuantumRegister(3, 'n')
m_reg = QuantumRegister(2, 'm')
scratch_a = QuantumRegister(3, 'sca')
qc = QuantumCircuit(n_reg, m_reg, scratch_a, class_reg)
# Set control bits
qc.x(m_reg[1])
return {'n_reg': n_reg, 'm_reg': m_reg, 'scratch_a': scratch_a, 'class_reg': class_reg, 'qc': qc }
# global n_reg
# global m_reg
# global scratch_a
# global class_reg
# global backend
# global qc
# global test_timestamp
# def before_tests():
n_reg = QuantumRegister(3, 'n')
m_reg = QuantumRegister(2, 'm')
scratch_reg = QuantumRegister(3, 'sca')
class_reg = ClassicalRegister(3, 'y')
qc = QuantumCircuit(n_reg, m_reg, scratch_reg, class_reg)
backend = Aer.get_backend('qasm_simulator')
test_timestamp = str(datetime.now())
from ArithmaticFunctions import *
# global n_reg
# global m_reg
# global scratch_a
# global class_reg
# global backend
# global qc
# global test_timestamp
# def before_tests():
n_reg = QuantumRegister(3, 'n')
m_reg = QuantumRegister(2, 'm')
scratch_reg = QuantumRegister(3, 'sca')
class_reg = ClassicalRegister(3, 'y')
qc = QuantumCircuit(n_reg, m_reg, scratch_reg, class_reg)
backend = Aer.get_backend('qasm_simulator')
test_timestamp = str(datetime.now())
from ArithmaticFunctions import *
# 1 - 1 = 0
"""
PASSED July 29 10:58am Pacific Time
"""
test_components = before_each_ripple_borrow_test()
qc = test_components['qc']
qc.x(n_reg[0])
qc.barrier()
c_ripple_subtract(circuit=qc, min_reg=n_reg, control_bit=m_reg[1], scratch_reg=scratch_a, start_shifting_at=0)
results = get_results_of_last_test()
# qc.draw()
verify_results(expected='000')
# 2 - 1 = 1
"""
PASSED July 29 10:58am Pacific Time
"""
test_components = before_each_ripple_borrow_test()
qc = test_components['qc']
qc.x(n_reg[1])
# qc.barrier()
c_ripple_subtract(circuit=qc, min_reg=n_reg, control_bit=m_reg[True], scratch_reg=scratch_a, start_shifting_at=0)
results = get_results_of_last_test()
# qc.draw()
verify_results(expected='001')
# 4 - 1 = 3
"""
PASSED July 29 10:58am Pacific Time
"""
test_components = before_each_ripple_borrow_test()
qc = test_components['qc']
qc.x(n_reg[2])
c_ripple_subtract(circuit=qc, min_reg=n_reg, control_bit=m_reg[True], scratch_reg=scratch_a, start_shifting_at=0)
results = get_results_of_last_test()
# qc.draw()
verify_results(expected='011')
# 6 - 1 = 5
"""
PASSED July 29 10:58am Pacific Time
"""
test_components = before_each_ripple_borrow_test()
qc = test_components['qc']
qc.x(n_reg[1])
qc.x(n_reg[2])
# qc.barrier()
c_ripple_subtract(circuit=qc, min_reg=n_reg, control_bit=m_reg[True], scratch_reg=scratch_a, start_shifting_at=0)
results = get_results_of_last_test()
qc.draw()
verify_results(expected='101')
# 5 - 1 = 4
"""
PASSED July 29 10:58am Pacific Time
"""
test_components = before_each_ripple_borrow_test()
qc = test_components['qc']
qc.x(n_reg[0])
qc.x(n_reg[2])
c_ripple_subtract(circuit=qc, min_reg=n_reg, control_bit=m_reg[True], scratch_reg=scratch_a, start_shifting_at=0)
results = get_results_of_last_test()
# qc.draw()
verify_results(expected='100')
# 5 - 2 = 3
"""
PASSED July 29 10:58am Pacific Time
"""
test_components = before_each_ripple_borrow_test()
qc = test_components['qc']
qc.x(n_reg[0])
qc.x(n_reg[2])
c_ripple_subtract(circuit=qc, min_reg=n_reg, control_bit=m_reg[True], scratch_reg=scratch_a, start_shifting_at=1)
results = get_results_of_last_test()
# qc.draw()
verify_results(expected='011')
# 7 - 2 = 5
test_components = before_each_ripple_borrow_test()
qc = test_components['qc']
qc.x(n_reg[0])
qc.x(n_reg[1])
qc.x(n_reg[2])
c_ripple_subtract(circuit=qc, min_reg=n_reg, control_bit=m_reg[True], scratch_reg=scratch_a, start_shifting_at=1)
results = get_results_of_last_test()
# qc.draw()
verify_results(expected='101')
# NO-OP(7) = 7
test_components = before_each_ripple_borrow_test()
qc = test_components['qc']
qc.x(n_reg[0])
qc.x(n_reg[1])
qc.x(n_reg[2])
qc.barrier()
c_ripple_subtract(circuit=qc, min_reg=n_reg, control_bit=m_reg[False], scratch_reg=scratch_a, start_shifting_at=1)
results = get_results_of_last_test()
qc.draw()
verify_results(expected='111')
# 1 - 2 + 2 = ?
test_components = before_each_ripple_borrow_test()
qc = test_components['qc']
qc.x(n_reg[0])
c_ripple_subtract(circuit=qc, min_reg=n_reg, control_bit=m_reg[True], scratch_reg=scratch_a, start_shifting_at=2)
# ripple_carry_bits(circuit=qc, acc_reg=n_reg, control_bit=m_reg[True], scratch_reg=scratch_a, start_shifting_at=1)
qc.barrier()
undo_ripple_borrow(circuit=qc, min_reg=n_reg, control_bit=m_reg[True], scratch_reg=scratch_a, start_shifting_at=2)
results = get_results_of_last_test()
qc.draw()
# print(results)
verify_results('001')
# 0 - 2 + 2 = ?
test_components = before_each_ripple_borrow_test()
qc = test_components['qc']
c_ripple_subtract(circuit=qc, min_reg=n_reg, control_bit=m_reg[True], scratch_reg=scratch_a, start_shifting_at=2)
# ripple_carry_bits(circuit=qc, acc_reg=n_reg, control_bit=m_reg[True], scratch_reg=scratch_a, start_shifting_at=1)
qc.barrier()
undo_ripple_borrow(circuit=qc, min_reg=n_reg, control_bit=m_reg[True], scratch_reg=scratch_a, start_shifting_at=2)
results = get_results_of_last_test()
qc.draw()
# print(results)
verify_results('000')
def sub_once_mod(circuit, )
# global n_reg
# global m_reg
# global scratch_a
# global class_reg
# global backend
# global qc
# global test_timestamp
# def before_tests():
n_reg = QuantumRegister(3, 'n')
m_reg = QuantumRegister(2, 'm')
scratch_reg = QuantumRegister(3, 'sca')
class_reg = ClassicalRegister(3, 'y')
qc = QuantumCircuit(n_reg, m_reg, scratch_reg, class_reg)
backend = Aer.get_backend('qasm_simulator')
test_timestamp = str(datetime.now())
from ArithmaticFunctions import *
def before_each_subtraction_test():
n_reg = QuantumRegister(3, 'n')
m_reg = QuantumRegister(3, 'm')
scratch_reg = QuantumRegister(3, 'sca')
qc = QuantumCircuit(n_reg, m_reg, scratch_reg, class_reg)
return {'n_reg': n_reg, 'm_reg': m_reg, 'scratch_reg': scratch_reg, 'class_reg': class_reg, 'qc': qc }
test_components = before_each_subtraction_test()
qc = test_components['qc']
# Set n_reg to 00...1
qc.x(n_reg[0])
# m_reg is | 0 >
sub_b_from_a_in_place(circuit=qc,
minnd_reg=test_components['n_reg'],
subtrhnd_reg=test_components['m_reg'],
scratch_reg=test_components['scratch_reg'])
results = get_results_of_last_test()
# qc.draw()
# print(results)
verify_results('001')
# Get test components
comps = before_each_subtraction_test()
qc = comps['qc']
# Set n_reg to 00...1
qc.x(comps['n_reg'][0])
# Set m_reg to 00...1
qc.x(comps['m_reg'][0])
qc.barrier()
sub_b_from_a_in_place(circuit=qc,
minnd_reg=comps['n_reg'],
subtrhnd_reg=comps['m_reg'],
scratch_reg=comps['scratch_reg'])
results = get_results_of_last_test()
qc.draw()
# print(results)
verify_results('000')
# Get test components
comps = before_each_subtraction_test()
qc = comps['qc']
# Set n_reg to ...110
qc.x(comps['n_reg'][1])
qc.x(comps['n_reg'][2])
# Set m_reg to ...011
qc.x(comps['m_reg'][0])
qc.x(comps['m_reg'][1])
qc.barrier()
sub_b_from_a_in_place(circuit=qc,
minnd_reg=comps['n_reg'],
subtrhnd_reg=comps['m_reg'],
scratch_reg=comps['scratch_reg'])
results = get_results_of_last_test()
qc.draw()
# print(results)
verify_results('011')
verify_results('011')
# Get test components
comps = before_each_subtraction_test()
qc = comps['qc']
# Set n_reg to ...10
qc.x(comps['n_reg'][1])
# Set m_reg to ...01
qc.x(comps['m_reg'][0])
qc.barrier()
sub_b_from_a_in_place(circuit=qc,
minnd_reg=comps['n_reg'],
subtrhnd_reg=comps['m_reg'],
scratch_reg=comps['scratch_reg'])
results = get_results_of_last_test()
qc.draw()
# print(results)
verify_results('001')
# Get test components
comps = before_each_subtraction_test()
qc = comps['qc']
# Set n_reg to ...110
qc.x(comps['n_reg'][0])
qc.x(comps['n_reg'][1])
# Set m_reg to ...011
qc.x(comps['m_reg'][0])
qc.x(comps['m_reg'][1])
qc.barrier()
sub_b_from_a_in_place(circuit=qc,
minnd_reg=comps['n_reg'],
subtrhnd_reg=comps['m_reg'],
scratch_reg=comps['scratch_reg'])
results = get_results_of_last_test()
# qc.draw()
# print(results)
verify_results('000')
# Get test components
comps = before_each_subtraction_test()
qc = comps['qc']
# Set n_reg to ...110
qc.x(comps['n_reg'][0])
qc.x(comps['n_reg'][1])
qc.x(comps['n_reg'][2])
# Set m_reg to ...011
qc.x(comps['m_reg'][1])
qc.x(comps['m_reg'][2])
qc.barrier()
sub_b_from_a_in_place(circuit=qc,
minnd_reg=comps['n_reg'],
subtrhnd_reg=comps['m_reg'],
scratch_reg=comps['scratch_reg'])
results = get_results_of_last_test()
# qc.draw()
# print(results)
verify_results('001')
# Get test components
comps = before_each_subtraction_test()
qc = comps['qc']
# Set n_reg to ...110
qc.x(comps['n_reg'][1])
qc.x(comps['n_reg'][2])
# Set m_reg to ...011
qc.x(comps['m_reg'][1])
qc.x(comps['m_reg'][0])
qc.barrier()
sub_b_from_a_in_place(circuit=qc,
minnd_reg=comps['n_reg'],
subtrhnd_reg=comps['m_reg'],
scratch_reg=comps['scratch_reg'])
results = get_results_of_last_test()
# qc.draw()
# print(results)
verify_results('011')
# Get test components
comps = before_each_subtraction_test()
qc = comps['qc']
# Set n_reg to ...110
qc.x(comps['n_reg'][2])
# Set m_reg to ...011
qc.x(comps['m_reg'][0])
qc.barrier()
sub_b_from_a_in_place(circuit=qc,
minnd_reg=comps['n_reg'],
subtrhnd_reg=comps['m_reg'],
scratch_reg=comps['scratch_reg'])
results = get_results_of_last_test()
# qc.draw()
# print(results)
verify_results('011')
# Get test components
comps = before_each_subtraction_test()
qc = comps['qc']
qc.x(comps['n_reg'][0])
qc.x(comps['m_reg'][1])
qc.barrier()
sub_b_from_a_in_place(circuit=qc,
minnd_reg=comps['n_reg'],
subtrhnd_reg=comps['m_reg'],
scratch_reg=comps['scratch_reg'])
for bit in range(len(comps['scratch_reg'])):
qc.measure(comps['scratch_reg'], comps['class_reg'])
results = execute(qc, backend=backend, shots=1024).result()
print(results.get_counts())
# Get test components
comps = before_each_subtraction_test()
qc = comps['qc']
qc.x(comps['n_reg'][0])
qc.x(comps['m_reg'][1])
qc.barrier()
sub_b_from_a_in_place(circuit=qc,
minnd_reg=comps['n_reg'],
subtrhnd_reg=comps['m_reg'],
scratch_reg=comps['scratch_reg'])
results = get_results_of_last_test()
print(results)
# Get test components
comps = before_each_subtraction_test()
qc = comps['qc']
qc.x(comps['n_reg'][1])
qc.x(comps['m_reg'][1])
qc.x(comps['m_reg'][2])
qc.barrier()
sub_b_from_a_in_place(circuit=qc,
minnd_reg=comps['n_reg'],
subtrhnd_reg=comps['m_reg'],
scratch_reg=comps['scratch_reg'])
results = execute(qc, backend=backend, shots=1024).result()
print(results)
|
https://github.com/tuf65651/quantum-research
|
tuf65651
|
# %matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from datetime import datetime
# import math
# Loading your IBM Q account(s)
# IBMQ.load_account()
backend = Aer.get_backend("qasm_simulator")
# global n_reg
# global m_reg
# global scratch_a
# global class_reg
# global backend
# global qc
# global test_timestamp
# def before_tests():
n_reg = QuantumRegister(3, 'n')
m_reg = QuantumRegister(2, 'm')
scratch_a = QuantumRegister(3, 'sca')
class_reg = ClassicalRegister(3, 'y')
qc = QuantumCircuit(n_reg, m_reg, scratch_a, class_reg)
backend = Aer.get_backend('qasm_simulator')
from ArithmaticFunctions import ripple_carry_bits
test_timestamp = str(datetime.now())
def before_each_ripple_borrow_test():
n_reg = QuantumRegister(3, 'n')
m_reg = QuantumRegister(2, 'm')
scratch_a = QuantumRegister(3, 'sca')
qc = QuantumCircuit(n_reg, m_reg, scratch_a, class_reg)
# Set control bits
qc.x(m_reg[1])
return {'n_reg': n_reg, 'm_reg': m_reg, 'scratch_a': scratch_a, 'class_reg': class_reg, 'qc': qc }
def get_results_of_last_test():
for bit in range(len(n_reg)):
qc.measure(n_reg[bit], class_reg[bit])
simulate = execute(qc, backend=backend, shots=1024).result()
return simulate.get_counts()
def verify_results(expected):
time_stamp = str(datetime.now())
if [expected] == list(results.keys()):
print("PASSING - ", test_timestamp)
else:
print("FAILING - ", test_timestamp)
print(f'Got - {results}')
# 0 + 1 = 1
test_components = before_each_ripple_borrow_test()
qc = test_components['qc']
qc.barrier()
ripple_carry_bits(circuit=qc, acc_reg=n_reg, control_bit=m_reg[1], scratch_reg=scratch_a, start_shifting_at=0)
results = get_results_of_last_test()
# qc.draw()
verify_results(expected='001')
# NO-OP(1)
test_components = before_each_ripple_borrow_test()
qc = test_components['qc']
qc.x(n_reg[0])
# qc.barrier()
ripple_carry_bits(circuit=qc, acc_reg=n_reg, control_bit=m_reg[False], scratch_reg=scratch_a, start_shifting_at=0)
results = get_results_of_last_test()
qc.draw()
verify_results(expected='001')
# 1 + 1 = 2
test_components = before_each_ripple_borrow_test()
qc = test_components['qc']
qc.x(n_reg[0])
ripple_carry_bits(circuit=qc, acc_reg=n_reg, control_bit=m_reg[True], scratch_reg=scratch_a, start_shifting_at=0)
results = get_results_of_last_test()
# qc.draw()
verify_results(expected='010')
# 2 + 1 = 3
test_components = before_each_ripple_borrow_test()
qc = test_components['qc']
qc.x(n_reg[1])
# qc.barrier()
ripple_carry_bits(circuit=qc, acc_reg=n_reg, control_bit=m_reg[True], scratch_reg=scratch_a, start_shifting_at=0)
results = get_results_of_last_test()
qc.draw()
verify_results(expected='011')
# 1 + 2 = 3
test_components = before_each_ripple_borrow_test()
qc = test_components['qc']
qc.x(n_reg[0])
ripple_carry_bits(circuit=qc, acc_reg=n_reg, control_bit=m_reg[True], scratch_reg=scratch_a, start_shifting_at=1)
results = get_results_of_last_test()
# qc.draw()
verify_results(expected='011')
# 2 + 2 = 4
test_components = before_each_ripple_borrow_test()
qc = test_components['qc']
qc.x(n_reg[1])
ripple_carry_bits(circuit=qc, acc_reg=n_reg, control_bit=m_reg[True], scratch_reg=scratch_a, start_shifting_at=1)
results = get_results_of_last_test()
qc.draw()
verify_results(expected='100')
# 7 - 2 = 5
test_components = before_each_ripple_borrow_test()
qc = test_components['qc']
qc.x(n_reg[0])
qc.x(n_reg[1])
qc.x(n_reg[2])
c_ripple_subtract(circuit=qc, min_reg=n_reg, control_bit=m_reg[True], scratch_reg=scratch_a, start_shifting_at=1)
results = get_results_of_last_test()
# qc.draw()
verify_results(expected='101')
# NO-OP(7) = 7
test_components = before_each_ripple_borrow_test()
qc = test_components['qc']
qc.x(n_reg[0])
qc.x(n_reg[1])
qc.x(n_reg[2])
qc.barrier()
ripple_carry_bits(circuit=qc, acc_reg=n_reg, control_bit=m_reg[False], scratch_reg=scratch_a, start_shifting_at=1)
results = get_results_of_last_test()
# qc.draw()
verify_results(expected='111')
# 7 + 2 = ?
test_components = before_each_ripple_borrow_test()
qc = test_components['qc']
qc.x(n_reg[0])
qc.x(n_reg[1])
qc.x(n_reg[2])
# c_ripple_subtract(circuit=qc, min_reg=n_reg, control_bit=m_reg[True], scratch_reg=scratch_a, start_shifting_at=2)
ripple_carry_bits(circuit=qc, acc_reg=n_reg, control_bit=m_reg[True], scratch_reg=scratch_a, start_shifting_at=1)
results = get_results_of_last_test()
qc.draw()
# print(results)
print(results)
execute(qc, backend=backend, shots=1024).result().get_counts().keys()
|
https://github.com/tuf65651/quantum-research
|
tuf65651
|
# %matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from datetime import datetime
# import math
# Loading your IBM Q account(s)
# IBMQ.load_account()
backend = Aer.get_backend("qasm_simulator")
# global n_reg
# global m_reg
# global scratch_a
# global class_reg
# global backend
# global qc
# global test_timestamp
# def before_tests():
global n_reg # = QuantumRegister(6, 'n')
global scratch_a
global class_reg # = ClassicalRegister(6, 'y')
global qc # = QuantumCircuit(n_reg, m_reg, scratch_a, class_reg)
test_timestamp = datetime.now()
from ArithmaticFunctions import *
def setup_each_addition():
n_reg = QuantumRegister(6, 'n')
m_reg = QuantumRegister(6, 'm')
scratch_a = QuantumRegister(6, 'sca')
class_reg = ClassicalRegister(6, 'y')
qc = QuantumCircuit(n_reg, m_reg, scratch_a, class_reg)
return {'n_reg': n_reg, 'm_reg': m_reg, 'scratch_a': scratch_a, 'class_reg': class_reg, 'qc': qc }
def get_results_of_last_test():
# for bit in range(len(n_reg)):
# qc.measure(n_reg[bit], class_reg[bit])
simulate = execute(qc, backend=backend, shots=1024).result()
return simulate.get_counts()
def verify_results(expected):
if [expected] == list(results.keys()):
print("PASSING - ", test_timestamp)
else:
print("FAILING - ", test_timestamp)
print(f'Got - {results}')
tc = setup_each_addition()
qc = tc['qc']
twos_complement(tc['qc'], tc['n_reg'], tc['scratch_a'])
qc.measure(tc['n_reg'], tc['class_reg'])
results = get_results_of_last_test()
verify_results('000000')
tc = setup_each_addition()
qc = tc['qc']
qc.x(tc['n_reg'][0])
twos_complement(tc['qc'], tc['n_reg'], tc['scratch_a'])
qc.measure(tc['n_reg'], tc['class_reg'])
results = get_results_of_last_test()
verify_results('111111')
tc = setup_each_addition()
qc = tc['qc']
qc.x(tc['n_reg'][2])
twos_complement(tc['qc'], tc['n_reg'], tc['scratch_a'])
qc.measure(tc['n_reg'], tc['class_reg'])
results = get_results_of_last_test()
verify_results('111100')
tc = setup_each_addition()
qc = tc['qc']
qc.x(tc['n_reg'][2])
qc.x(tc['n_reg'][3])
qc.x(tc['n_reg'][4])
qc.x(tc['n_reg'][5])
twos_complement(tc['qc'], tc['n_reg'], tc['scratch_a'])
qc.measure(tc['n_reg'], tc['class_reg'])
results = get_results_of_last_test()
verify_results('000100')
tc = setup_each_addition()
qc = tc['qc']
twos_complement(tc['qc'], tc['n_reg'], tc['scratch_a'])
qc.measure(tc['n_reg'], tc['class_reg'])
results = get_results_of_last_test()
verify_results('000000')
tc = setup_each_addition()
qc = tc['qc']
qc.x(tc['n_reg'][0])
qc.x(tc['n_reg'][1])
qc.x(tc['n_reg'][2])
qc.x(tc['n_reg'][3])
qc.x(tc['n_reg'][4])
twos_complement(tc['qc'], tc['n_reg'], tc['scratch_a'])
qc.measure(tc['n_reg'], tc['class_reg'])
results = get_results_of_last_test()
verify_results('100001')
tc = setup_each_addition()
qc = tc['qc']
twos_complement(tc['qc'], tc['n_reg'], tc['scratch_a'])
qc.measure(tc['n_reg'], tc['class_reg'])
results = get_results_of_last_test()
verify_results('100001')
tc = setup_each_addition()
qc = tc['qc']
qc.x(tc['m_reg'][0])
qc.barrier()
twos_complement(qc, tc['n_reg'], tc['scratch_a'])
add_to_b_in_place(qc, tc['m_reg'], tc['n_reg'], tc['scratch_a'])
twos_complement(qc, tc['n_reg'], tc['scratch_a'])
qc.measure(tc['n_reg'], tc['class_reg'])
results = get_results_of_last_test()
verify_results('111111')
tc = setup_each_addition()
qc = tc['qc']
qc.x(tc['m_reg'][0])
qc.x(tc['m_reg'][1])
qc.x(tc['m_reg'][2])
qc.x(tc['m_reg'][3])
qc.x(tc['m_reg'][4])
qc.x(tc['m_reg'][5])
qc.barrier()
twos_complement(qc, tc['n_reg'], tc['scratch_a'])
add_to_b_in_place(qc, tc['m_reg'], tc['n_reg'], tc['scratch_a'])
twos_complement(qc, tc['n_reg'], tc['scratch_a'])
qc.measure(tc['n_reg'], tc['class_reg'])
results = get_results_of_last_test()
verify_results('111111')
|
https://github.com/JessicaJohnBritto/Quantum-Computing-and-Information
|
JessicaJohnBritto
|
## Importing Packages
import cirq
import numpy as np
from cirq.contrib.svg import SVGCircuit
import matplotlib.pyplot as plt
## Defining QFT and Inverse QFT
def qft_rotations(n_qubits):
"""A circuit performs the QFT rotations on the specified qubits.
Args:
n_qubits (list): List of qubits.
"""
n = len(n_qubits)
for i in range(n):
k = 0
yield cirq.H(n_qubits[i])
for jj in range(i+1,n,1):
k = k+1
yield (cirq.CZ ** (1/(2**(k))))(n_qubits[jj], n_qubits[i])
pass
def inverse_qft(n_qubits):
"""A circuit performs the inverse of QFT rotations on the specified qubits.
Args:
n_qubits (list): List of qubits.
"""
n = len(n_qubits)
n_qubits1 = np.flip(n_qubits)
for i in range(n):
k = 0
yield cirq.H(n_qubits1[i])
for jj in range(i+1,n,1):
k = k+1
yield (cirq.CZ ** (-1/(2**(k))))(n_qubits1[jj], n_qubits1[i])
# """Visually check the inverse QFT circuit."""
# qubits = cirq.LineQubit.range(4)
# qft = cirq.Circuit(inverse_qft(qubits))
# SVGCircuit(qft)
"""Visually check the QFT circuit."""
qubits = cirq.LineQubit.range(2)
qft = cirq.Circuit(qft_rotations(qubits))
SVGCircuit(qft)
cirq.unitary(qft)
#Defining Quantum Adder
def quantum_adder(n_qubits):
''' A circuit performs addition of two numbers
Args:
n_qubits (list): list of qubits representing the binary representation of ('binary(a)'+'binary(b)').
'''
n = len(n_qubits)
# Appending the first half of the qubits to list - kk
kk =[n_qubits[i] for i in range(0, int(len(n_qubits)/2),1)]
# Perfoms QFT on the first half of the qubits, i.e, on the first number
yield qft_rotations(kk)
for i in range(0,int(n/2),1):
k=0
for j in range(i+int(n/2),(n),1):
yield (cirq.CZ ** (1/(2**(k))))(n_qubits[j], n_qubits[i])
k+=1
yield inverse_qft(kk)
circuit = cirq.Circuit()
# Inputting the two integers in a and b
a = int(input("Enter the first number: "))
b = int(input("Enter the second number: "))
c = max(len(np.binary_repr(a)), len(np.binary_repr(b))) + 1
a_bit = np.binary_repr(a, width = c)
b_bit = np.binary_repr(b, width = c)
# Combined form of binary(a) and binary(b)
c1 = a_bit+b_bit
qubits = cirq.LineQubit.range(len(c1))
# Preparing Basis State for c1 by applying X-gate on the qubit corresponding to the index of c1 being 1
circuit.append(cirq.X(qubits[i]) for i in range(len(c1)) if c1[i]=='1')
circuit.append(quantum_adder(qubits))
# Measuring the first half of the qubits
k = [qubits[i] for i in range(0, int(len(qubits)/2),1)]
circuit.append(cirq.measure(k, key = 'ab'))
simulator = cirq.Simulator()
result = simulator.run(circuit, repetitions=1)
# print(result.data)
c = result.histogram(key="ab")
# Retrieving the result from Counter
print(list(c)[0])
# print(cirq.ResultDict('ab'))
# cirq.plot_state_histogram(result)
# SVGCircuit(circuit)
def quantum_multiplier(n_qubits):
''' A circuit performs multiplication of two numbers
Args:
n_qubits (list): list of qubits representing the binary representation of ('binary(a)'+'binary(b)').
'''
n = len(n_qubits)
# Appending the first half of the qubits to list - kk
kk =[n_qubits[i] for i in range(0, int(len(n_qubits)/2),1)]
# Perfoms QFT on the first half of the qubits, i.e, on the first number
yield qft_rotations(kk)
for i in range(int(3*n/4), n,1):
for j in range(int(n/2), int(3*n/4),1):
for m in range(int(n/2)):
yield (cirq.CCZ ** (1/(2**(-(5*n/4)-m+j+i+1))))(n_qubits[j], n_qubits[i], n_qubits[m])
yield inverse_qft(kk)
pass
circuit = cirq.Circuit()
# Inputting the two integers in a and b
a = int(input("Enter the first number: "))
b = int(input("Enter the second number: "))
c = max(len(np.binary_repr(a)), len(np.binary_repr(b))) + 1
a1 = np.binary_repr(0, width = 2*c)
a_bit = np.binary_repr(a, width = c)
b_bit = np.binary_repr(b, width = c)
# Combined form of binary(0), binary(a) and binary(b)
c1 = a1 + a_bit+b_bit
qubits = cirq.LineQubit.range(len(c1))
# Preparing Basis State for c1 by applying X-gate on the qubit corresponding to the index of c1 being 1
circuit.append(cirq.X(qubits[i]) for i in range(len(c1)) if c1[i]=='1')
circuit.append(quantum_multiplier(qubits))
k = [qubits[i] for i in range(0, int(len(qubits)/2),1)]
# Measuring the first half of the qubits
circuit.append(cirq.measure(k, key = 'ab'))
simulator = cirq.Simulator()
result = simulator.run(circuit, repetitions=1)
# print(result.data)
c = result.histogram(key="ab")
# Retrieving the result from Counter
print(list(c)[0])
# SVGCircuit(circuit)
# a = 3
# b = 2
# a_bit = np.binary_repr(a)
# # print(a_bit)
# b_bit = np.binary_repr(b)
# # print(a_bit+ b_bit)
# c = a_bit+b_bit
# print(c)
# qubits = cirq.LineQubit.range(len(c))
# # print(k,f,g,h)
# circuit = cirq.Circuit(quantum_adder(qubits))
# SVGCircuit(circuit)
# state2 = cirq.Simulator().simulate(circuit, initial_state=1110).state_vector()
# print(state2)
# print(cirq.dirac_notation(state2))
# circuit.append(cirq.measure(qubits))
# simulator = cirq.Simulator()
# result = simulator.run(circuit, repetitions=2)
# print(result)
# SVGCircuit(circuit)
# k = cirq.big_endian_int_to_bits(3, bit_count = 4)
# print(k)
# for i in range(len(qubits)):
# qubits[i] = np.pad(np.array([k[i]]), (2*len(qubits)-1,0))
class MyGate(cirq.Gate):
def _init_(self):
super(MyGate, self)
def _num_qubits_(self):
return 1
def _circuit_diagram_info_(self, args):
return "MyGate"
class MyGate(cirq.Gate):
def _init_(self):
super(MyGate, self)
def _num_qubits_(self):
return 1
def _unitary_(self):
return np.array([[1,0], [0,1]])
def _circuit_diagram_info_(self, args):
return "MyGate"
mygate = MyGate()
qubits = cirq.LineQubit(0)
circuit = cirq.Circuit([cirq.H(qubits), mygate(qubits)])
SVGCircuit(circuit)
class MG(cirq.Gate):
def __init__(self, k):
super(MG, self)
self.k = k
def _num_qubits_(self):
return 2
def _unitary_(self):
return np.array([[1,0,0,0],
[0,1,0,0],
[0,0,1,0],
[0,0,0, np.sin(self.k)]])
def _circuit_diagram_info_(self, args):
return "ctrl", f"R({self.k})"
mg = MG(k=np.pi)
qubits = cirq.LineQubit.range(2)
circuit = cirq.Circuit(mg(*qubits))
SVGCircuit(circuit)
cirq.unitary(circuit)
## QFT gate
class QFT(cirq.Gate):
def __init__(self, n_qubits):
super(QFT, self)
self.n_qubits = n_qubits
def _num_qubits_(self):
return self.n_qubits
def _decompose_(self, n_qubits):
n = len(n_qubits)
for i in range(n):
k = 0
yield cirq.H(n_qubits[i])
for jj in range(i+1,n,1):
k = k+1
yield (cirq.CZ ** (1/(2**(k))))(n_qubits[jj], n_qubits[i])
def _circuit_diagram_info_(self, args):
return ["QFT"] * self.num_qubits()
# qubits = cirq.LineQubit.range(2)
# circuit = cirq.Circuit(QFT(n_qubits = 2).on(*qubits))
# SVGCircuit(circuit)
# cirq.unitary(circuit)
## Quantum Multiplier gate
class qmulti(cirq.Gate):
def __init__(self, n_qubits):
super(qmulti, self)
self.n_qubits = n_qubits
def _num_qubits_(self):
return self.n_qubits
def _decompose_(self, n_qubits):
n = len(n_qubits)
kk =[n_qubits[i] for i in range(0, int(len(n_qubits)/2),1)]
yield QFT(n_qubits = int(n/2)).on(*kk)
for i in range(int(3*n/4), n, 1):
for j in range(int(n/2), int(3*n/4),1):
for m in range(int(n/2)):
yield (cirq.CCZ ** (1/(2**(-(5*n/4)-m+j+i+1))))(n_qubits[j], n_qubits[i], n_qubits[m])
yield cirq.inverse(QFT(n_qubits = int(n/2)).on(*kk))
def _circuit_diagram_info_(self, args):
return ["QMultiplier"] * self.num_qubits()
circuit = cirq.Circuit()
# Inputting the two integers in a and b
a = int(input("Enter the first number: "))
b = int(input("Enter the second number: "))
c = max(len(np.binary_repr(a)), len(np.binary_repr(b))) + 1
a1 = np.binary_repr(0, width = 2*c)
a_bit = np.binary_repr(a, width = c)
b_bit = np.binary_repr(b, width = c)
# Combined form of binary(0), binary(a) and binary(b)
c1 = a1 + a_bit+b_bit
qubits = cirq.LineQubit.range(len(c1))
# Preparing Basis State for c1 by applying X-gate on the qubit corresponding to the index of c1 being 1
circuit.append(cirq.X(qubits[i]) for i in range(len(c1)) if c1[i]=='1')
circuit.append(qmulti(n_qubits = len(qubits)).on(*qubits))
k = [qubits[i] for i in range(0, int(len(qubits)/2),1)]
# Measuring the first half of the qubits
circuit.append(cirq.measure(k, key = 'ab'))
simulator = cirq.Simulator()
result = simulator.run(circuit, repetitions=1)
c = result.histogram(key="ab")
# Retrieving the result from Counter
print(list(c)[0])
|
https://github.com/JessicaJohnBritto/Quantum-Computing-and-Information
|
JessicaJohnBritto
|
# Importing Packages
import matplotlib.pyplot as plt
import numpy as np
from qiskit import IBMQ, Aer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, transpile, assemble
from qiskit.visualization import plot_histogram
# Input Secret Number
s = input("Input the secret number:\n")
n=len(s)
qc = QuantumCircuit(n+1, n)
# Putting states in superposition
qc.x(n)
for i in range(n+1):
qc.h(i)
qc.barrier()
# Apply the inner-product oracle
s=s[::-1] # reverse s to fit qiskit's qubit ordering
print(s)
for k in range(n):
if s[k] == '1':
qc.cx(k, n)
qc.barrier()
# Measuring
for m in range(n):
qc.h(m)
qc.barrier()
for b in range(n):
qc.measure(b,b)
qc.draw(output="mpl")
# Simulating on local simulator
aer_sim = Aer.get_backend('aer_simulator')
shots = 1024
qobj = assemble(qc)
results = aer_sim.run(qobj).result()
count = results.get_counts()
plot_histogram(count)
|
https://github.com/JessicaJohnBritto/Quantum-Computing-and-Information
|
JessicaJohnBritto
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ, BasicAer, assemble, transpile
from qiskit.visualization import plot_bloch_multivector,plot_bloch_vector, plot_histogram
from qiskit.quantum_info import Statevector
import numpy as np
import matplotlib
backend = BasicAer.get_backend('qasm_simulator')
shots = 1024
style = {'backgroundcolor': 'lightyellow'} # Style of the circuits
qreg = QuantumRegister(2)
creg = ClassicalRegister(1)
qc = QuantumCircuit(qreg, creg)
qc.x(1) # Applying X gate on qubit 2 to get |1>
qc.barrier()
qc.draw(output='mpl', style=style)
# Applying Hadamard Gate
for qubit in range(2):
qc.h(qubit)
qc.barrier()
qc.draw(output='mpl', style=style)
# Balanced Oracle
qc.cx(0,1)
qc.barrier()
for qubit in range(1):
qc.h(qubit)
qc.measure(0,0)
qc.draw(output='mpl', style=style)
transpiled_dj_circuit = transpile(qc, backend)
qobj = assemble(transpiled_dj_circuit)
results = backend.run(qobj).result()
answer = results.get_counts()
plot_histogram(answer)
## Re-initialising
qreg = QuantumRegister(2)
creg = ClassicalRegister(1)
qc = QuantumCircuit(qreg, creg)
qc.x(1) # Applying X gate on qubit 2 to get |1>
qc.barrier()
# qc.draw(output='mpl', style=style)
# Applying Hadamard Gate
for qubit in range(2):
qc.h(qubit)
qc.barrier()
# Constant Oracle
if qc[1]==1:
qc.x(1)
for qubit in range(1):
qc.h(qubit)
qc.measure(0,0)
qc.draw(output='mpl', style=style)
transpiled_dj_circuit = transpile(qc, backend)
qobj = assemble(transpiled_dj_circuit)
results = backend.run(qobj).result()
answer = results.get_counts()
plot_histogram(answer)
|
https://github.com/JessicaJohnBritto/Quantum-Computing-and-Information
|
JessicaJohnBritto
|
# initialization
import numpy as np
import matplotlib
# importing Qiskit
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ, BasicAer, assemble, transpile
from qiskit.quantum_info import Statevector
# import basic plot tools
from qiskit.visualization import plot_bloch_multivector,plot_bloch_vector, plot_histogram
style = {'backgroundcolor': 'lightyellow'} # Style of the circuits
# set the length of the n-bit input string.
n = 3
# set the length of the n-bit input string.
n = 3
const_oracle = QuantumCircuit(n+1)
output = np.random.randint(2)
if output == 1:
const_oracle.x(n)
const_oracle.draw(output='mpl', style=style)
balanced_oracle = QuantumCircuit(n+1)
b_str = "101"
balanced_oracle = QuantumCircuit(n+1)
b_str = "101"
# Place X-gates
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
balanced_oracle.x(qubit)
balanced_oracle.draw(output='mpl', style=style)
balanced_oracle = QuantumCircuit(n+1)
b_str = "101"
# Place X-gates
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
balanced_oracle.x(qubit)
# Use barrier as divider
balanced_oracle.barrier()
# Controlled-NOT gates
for qubit in range(n):
balanced_oracle.cx(qubit, n)
balanced_oracle.barrier()
balanced_oracle.draw(output='mpl', style=style)
balanced_oracle = QuantumCircuit(n+1)
b_str = "101"
# Place X-gates
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
balanced_oracle.x(qubit)
# Use barrier as divider
balanced_oracle.barrier()
# Controlled-NOT gates
for qubit in range(n):
balanced_oracle.cx(qubit, n)
balanced_oracle.barrier()
# Place X-gates
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
balanced_oracle.x(qubit)
# Show oracle
balanced_oracle.draw(output='mpl', style=style)
dj_circuit = QuantumCircuit(n+1, n)
# Apply H-gates
for qubit in range(n):
dj_circuit.h(qubit)
# Put qubit in state |->
dj_circuit.x(n)
dj_circuit.h(n)
dj_circuit.draw(output='mpl', style=style)
dj_circuit = QuantumCircuit(n+1, n)
# Apply H-gates
for qubit in range(n):
dj_circuit.h(qubit)
# Put qubit in state |->
dj_circuit.x(n)
dj_circuit.h(n)
# Add oracle
dj_circuit += balanced_oracle
dj_circuit.draw(output='mpl', style=style)
dj_circuit = QuantumCircuit(n+1, n)
# Apply H-gates
for qubit in range(n):
dj_circuit.h(qubit)
# Put qubit in state |->
dj_circuit.x(n)
dj_circuit.h(n)
# Add oracle
dj_circuit += balanced_oracle
# Repeat H-gates
for qubit in range(n):
dj_circuit.h(qubit)
dj_circuit.barrier()
# Measure
for i in range(n):
dj_circuit.measure(i, i)
# Display circuit
dj_circuit.draw(output='mpl', style=style)
# use local simulator
aer_sim = Aer.get_backend('aer_simulator')
qobj = assemble(dj_circuit, aer_sim)
results = aer_sim.run(qobj).result()
answer = results.get_counts()
plot_histogram(answer)
def dj_oracle(case, n):
# We need to make a QuantumCircuit object to return
# This circuit has n+1 qubits: the size of the input,
# plus one output qubit
oracle_qc = QuantumCircuit(n+1)
# First, let's deal with the case in which oracle is balanced
if case == "balanced":
# First generate a random number that tells us which CNOTs to
# wrap in X-gates:
b = np.random.randint(1,2**n)
print(b)
print(str(n))
b=7
# Next, format 'b' as a binary string of length 'n', padded with zeros:
b_str = format(b, '0'+str(n)+'b')
print(b_str)
# Next, we place the first X-gates. Each digit in our binary string
# corresponds to a qubit, if the digit is 0, we do nothing, if it's 1
# we apply an X-gate to that qubit:
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
oracle_qc.x(qubit)
# Do the controlled-NOT gates for each qubit, using the output qubit
# as the target:
for qubit in range(n):
oracle_qc.cx(qubit, n)
# Next, place the final X-gates
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
oracle_qc.x(qubit)
# Case in which oracle is constant
if case == "constant":
# First decide what the fixed output of the oracle will be
# (either always 0 or always 1)
output = np.random.randint(2)
if output == 1:
oracle_qc.x(n)
oracle_gate = oracle_qc.to_gate()
oracle_gate.name = "Oracle" # To show when we display the circuit
return oracle_gate
def dj_algorithm(oracle, n):
dj_circuit = QuantumCircuit(n+1, n)
# Set up the output qubit:
dj_circuit.x(n)
dj_circuit.h(n)
# And set up the input register:
for qubit in range(n):
dj_circuit.h(qubit)
# Let's append the oracle gate to our circuit:
dj_circuit.append(oracle, range(n+1))
# Finally, perform the H-gates again and measure:
for qubit in range(n):
dj_circuit.h(qubit)
for i in range(n):
dj_circuit.measure(i, i)
return dj_circuit
n = 4
oracle_gate = dj_oracle('balanced', n)
dj_circuit = dj_algorithm(oracle_gate, n)
dj_circuit.draw(output='mpl', style=style)
transpiled_dj_circuit = transpile(dj_circuit, aer_sim)
qobj = assemble(transpiled_dj_circuit)
results = aer_sim.run(qobj).result()
answer = results.get_counts()
plot_histogram(answer)
|
https://github.com/JessicaJohnBritto/Quantum-Computing-and-Information
|
JessicaJohnBritto
|
# Do the necessary imports
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, BasicAer, IBMQ
from qiskit.visualization import plot_histogram, plot_bloch_multivector
### Creating 3 qubit and 2 classical bits in each separate register
qr = QuantumRegister(3)
crz = ClassicalRegister(1)
crx = ClassicalRegister(1)
teleportation_circuit = QuantumCircuit(qr, crz, crx)
### A third party eve helps to create an entangled state
def create_bell_pair(qc, a, b):
qc.h(a)
qc.cx(a, b)
create_bell_pair(teleportation_circuit, 1, 2)
teleportation_circuit.draw()
def alice_gates(qc, a, b):
qc.cx(a, b)
qc.h(a)
teleportation_circuit.barrier()
alice_gates(teleportation_circuit, 0, 1)
teleportation_circuit.draw()
def measure_and_send(qc, a, b):
qc.barrier()
qc.measure(a,0)
qc.measure(b,1)
teleportation_circuit.barrier()
measure_and_send(teleportation_circuit, 0, 1)
teleportation_circuit.draw()
def bob_gates(qc, qubit, crz, crx):
qc.x(qubit).c_if(crx, 1)
qc.z(qubit).c_if(crz, 1)
teleportation_circuit.barrier()
bob_gates(teleportation_circuit, 2, crz, crx)
teleportation_circuit.draw()
from qiskit.extensions import Initialize
import math
qc = QuantumCircuit(1)
initial_state = [0,1]
init_gate = Initialize(initial_state)
# qc.append(initialize_qubit, [0])
qr = QuantumRegister(3) # Protocol uses 3 qubits
crz = ClassicalRegister(1) # and 2 classical registers
crx = ClassicalRegister(1)
qc = QuantumCircuit(qr, crz, crx)
# First, let's initialise Alice's q0
qc.append(init_gate, [0])
qc.barrier()
# Now begins the teleportation protocol
create_bell_pair(qc, 1, 2)
qc.barrier()
# Send q1 to Alice and q2 to Bob
alice_gates(qc, 0, 1)
# Alice then sends her classical bits to Bob
measure_and_send(qc, 0, 1)
# Bob decodes qubits
bob_gates(qc, 2, crz, crx)
qc.draw()
backend = BasicAer.get_backend('statevector_simulator')
out_vector = execute(qc, backend).result().get_statevector()
plot_bloch_multivector(out_vector)
inverse_init_gate = init_gate.gates_to_uncompute()
qc.append(inverse_init_gate, [2])
qc.draw()
cr_result = ClassicalRegister(1)
qc.add_register(cr_result)
qc.measure(2,2)
qc.draw()
backend = BasicAer.get_backend('qasm_simulator')
counts = execute(qc, backend, shots=1024).result().get_counts()
plot_histogram(counts)
def bob_gates(qc, a, b, c):
qc.cz(a, c)
qc.cx(b, c)
qc = QuantumCircuit(3,1)
# First, let's initialise Alice's q0
qc.append(init_gate, [0])
qc.barrier()
# Now begins the teleportation protocol
create_bell_pair(qc, 1, 2)
qc.barrier()
# Send q1 to Alice and q2 to Bob
alice_gates(qc, 0, 1)
qc.barrier()
# Alice sends classical bits to Bob
bob_gates(qc, 0, 1, 2)
# We undo the initialisation process
qc.append(inverse_init_gate, [2])
# See the results, we only care about the state of qubit 2
qc.measure(2,0)
# View the results:
qc.draw()
from qiskit import IBMQ
IBMQ.save_account('### IMB TOKEN ')
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
provider.backends()
from qiskit.providers.ibmq import least_busy
backend = least_busy(provider.backends(filters=lambda b: b.configuration().n_qubits >= 3 and
not b.configuration().simulator and b.status().operational==True))
job_exp = execute(qc, backend=backend, shots=8192)
exp_result = job_exp.result()
exp_measurement_result = exp_result.get_counts(qc)
print(exp_measurement_result)
plot_histogram(exp_measurement_result)
error_rate_percent = sum([exp_measurement_result[result] for result in exp_measurement_result.keys() if result[0]=='1']) \
* 100./ sum(list(exp_measurement_result.values()))
print("The experimental error rate : ", error_rate_percent, "%")
|
https://github.com/JessicaJohnBritto/Quantum-Computing-and-Information
|
JessicaJohnBritto
|
# Importing Packages
from qiskit import IBMQ, Aer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, transpile, assemble, QuantumRegister, ClassicalRegister
from qiskit.visualization import plot_histogram
from qiskit_textbook.tools import simon_oracle
bb = input("Enter the input string:\n")
### Using in-built "simon_oracle" from QISKIT
# importing Qiskit
from qiskit import IBMQ, Aer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, transpile, assemble
# import basic plot tools
from qiskit.visualization import plot_histogram
from qiskit_textbook.tools import simon_oracle
n = len(bb)
simon_circuit = QuantumCircuit(n*2, n)
# Apply Hadamard gates before querying the oracle
simon_circuit.h(range(n))
# Apply barrier for visual separation
simon_circuit.barrier()
simon_circuit += simon_oracle(bb)
# Apply barrier for visual separation
simon_circuit.barrier()
# Apply Hadamard gates to the input register
simon_circuit.h(range(n))
# Measure qubits
simon_circuit.measure(range(n), range(n))
simon_circuit.draw(output="mpl")
# use local simulator
aer_sim = Aer.get_backend('aer_simulator')
shots = 500
qobj = assemble(simon_circuit, shots=shots)
results = aer_sim.run(qobj).result()
counts = results.get_counts()
print(counts)
plot_histogram(counts)
# Calculate the dot product of the results
def bdotz(b, z):
accum = 0
for i in range(len(b)):
accum += int(b[i]) * int(z[i])
return (accum % 2)
for z in counts:
print( '{}.{} = {} (mod 2)'.format(b, z, bdotz(b,z)) )
b = input("Enter a binary string:\n")
# Actual b = 011
b_rev = b[::-1]
flagbit = b_rev.find('1')
n=len(b)
q1=QuantumRegister(n,'q1')
q2=QuantumRegister(n,'q2')
c1=ClassicalRegister(n)
qc = QuantumCircuit(q1,q2,c1)
qc.barrier()
qc.h(q1)
qc.barrier()
for i in range(n):
qc.cx(q1[i],q2[i])
qc.barrier()
if flagbit != -1:
# print("test1")
for ind, bit in enumerate(b_rev):
# print("test2")
if bit == "1":
# print("test3")
qc.cx(flagbit, q2[ind])
qc.barrier()
qc.h(q1)
qc.barrier()
qc.measure(q1,c1)
qc.draw("mpl")
aer_sim = Aer.get_backend('aer_simulator')
shots = 500
qobj = assemble(qc, shots=shots)
results = aer_sim.run(qobj).result()
counts = results.get_counts()
print(counts)
plot_histogram(counts)
# Actual b = 011
b="1"
b_rev = "1"
flagbit = b_rev.find('1')
n=len(b)
q1=QuantumRegister(n,'q1')
q2=QuantumRegister(n,'q2')
c1=ClassicalRegister(n)
qc = QuantumCircuit(q1,q2,c1)
qc.barrier()
qc.h(q1)
qc.barrier()
for i in range(n):
qc.cx(q1[i],q2[i])
qc.barrier()
if flagbit != -1:
# print("test1")
for ind, bit in enumerate(b_rev):
# print("test2")
if bit == "1":
# print("test3")
qc.cx(flagbit, q2[ind])
qc.barrier()
qc.h(q1)
qc.barrier()
# qc.measure(q1,c1)
# qc.draw("mpl")
# Simulate the unitary
usim = Aer.get_backend('aer_simulator')
qc.save_unitary()
qobj = assemble(qc)
unitary = usim.run(qobj).result().get_unitary()
# Display the results:
array_to_latex(unitary, prefix="\\text{Circuit = } ")
|
https://github.com/JessicaJohnBritto/Quantum-Computing-and-Information
|
JessicaJohnBritto
|
# Importing Packages
from qiskit import QuantumCircuit
from qiskit import IBMQ, Aer, transpile, assemble
from qiskit.visualization import plot_histogram
style = {'backgroundcolor': 'lightyellow'} # Style of the circuits
def encode(qc, qubit, msg):
if len(msg) != 2 or not set(msg).issubset({"0","1"}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
# Circuit for Superdense coding
qc = QuantumCircuit(2)
# Generating entangled state
qc.h(1)
qc.cx(1, 0)
qc.barrier()
# Encoding message
message = '11'
qc = encode(qc, 1, message)
qc.barrier()
# Decoding Message
qc.cx(1, 0)
qc.h(1)
# Measuring qubits
qc.measure_all()
qc.draw(output="mpl", style=style)
aer_sim = Aer.get_backend('aer_simulator')
qobj = assemble(qc)
result = aer_sim.run(qobj).result()
counts = result.get_counts(qc)
print(counts)
plot_histogram(counts)
|
https://github.com/JessicaJohnBritto/Quantum-Computing-and-Information
|
JessicaJohnBritto
|
# Importing Packages
import matplotlib.pyplot as plt
import numpy as np
from qiskit import IBMQ, Aer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, transpile, assemble
from qiskit.visualization import plot_histogram
# Input Secret Number
s = input("Input the secret number:\n")
n=len(s)
qc = QuantumCircuit(n+1, n)
# Putting states in superposition
qc.x(n)
for i in range(n+1):
qc.h(i)
qc.barrier()
# Apply the inner-product oracle
s=s[::-1] # reverse s to fit qiskit's qubit ordering
print(s)
for k in range(n):
if s[k] == '1':
qc.cx(k, n)
qc.barrier()
# Measuring
for m in range(n):
qc.h(m)
qc.barrier()
for b in range(n):
qc.measure(b,b)
qc.draw(output="mpl")
# Simulating on local simulator
aer_sim = Aer.get_backend('aer_simulator')
shots = 1024
qobj = assemble(qc)
results = aer_sim.run(qobj).result()
count = results.get_counts()
plot_histogram(count)
|
https://github.com/JessicaJohnBritto/Quantum-Computing-and-Information
|
JessicaJohnBritto
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ, BasicAer, assemble, transpile
from qiskit.visualization import plot_bloch_multivector,plot_bloch_vector, plot_histogram
from qiskit.quantum_info import Statevector
import numpy as np
import matplotlib
backend = BasicAer.get_backend('qasm_simulator')
shots = 1024
style = {'backgroundcolor': 'lightyellow'} # Style of the circuits
qreg = QuantumRegister(2)
creg = ClassicalRegister(1)
qc = QuantumCircuit(qreg, creg)
qc.x(1) # Applying X gate on qubit 2 to get |1>
qc.barrier()
qc.draw(output='mpl', style=style)
# Applying Hadamard Gate
for qubit in range(2):
qc.h(qubit)
qc.barrier()
qc.draw(output='mpl', style=style)
# Balanced Oracle
qc.cx(0,1)
qc.barrier()
for qubit in range(1):
qc.h(qubit)
qc.measure(0,0)
qc.draw(output='mpl', style=style)
transpiled_dj_circuit = transpile(qc, backend)
qobj = assemble(transpiled_dj_circuit)
results = backend.run(qobj).result()
answer = results.get_counts()
plot_histogram(answer)
## Re-initialising
qreg = QuantumRegister(2)
creg = ClassicalRegister(1)
qc = QuantumCircuit(qreg, creg)
qc.x(1) # Applying X gate on qubit 2 to get |1>
qc.barrier()
# qc.draw(output='mpl', style=style)
# Applying Hadamard Gate
for qubit in range(2):
qc.h(qubit)
qc.barrier()
# Constant Oracle
if qc[1]==1:
qc.x(1)
for qubit in range(1):
qc.h(qubit)
qc.measure(0,0)
qc.draw(output='mpl', style=style)
transpiled_dj_circuit = transpile(qc, backend)
qobj = assemble(transpiled_dj_circuit)
results = backend.run(qobj).result()
answer = results.get_counts()
plot_histogram(answer)
|
https://github.com/JessicaJohnBritto/Quantum-Computing-and-Information
|
JessicaJohnBritto
|
# Do the necessary imports
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, BasicAer, IBMQ
from qiskit.visualization import plot_histogram, plot_bloch_multivector
### Creating 3 qubit and 2 classical bits in each separate register
qr = QuantumRegister(3)
crz = ClassicalRegister(1)
crx = ClassicalRegister(1)
teleportation_circuit = QuantumCircuit(qr, crz, crx)
### A third party eve helps to create an entangled state
def create_bell_pair(qc, a, b):
qc.h(a)
qc.cx(a, b)
create_bell_pair(teleportation_circuit, 1, 2)
teleportation_circuit.draw()
def alice_gates(qc, a, b):
qc.cx(a, b)
qc.h(a)
teleportation_circuit.barrier()
alice_gates(teleportation_circuit, 0, 1)
teleportation_circuit.draw()
def measure_and_send(qc, a, b):
qc.barrier()
qc.measure(a,0)
qc.measure(b,1)
teleportation_circuit.barrier()
measure_and_send(teleportation_circuit, 0, 1)
teleportation_circuit.draw()
def bob_gates(qc, qubit, crz, crx):
qc.x(qubit).c_if(crx, 1)
qc.z(qubit).c_if(crz, 1)
teleportation_circuit.barrier()
bob_gates(teleportation_circuit, 2, crz, crx)
teleportation_circuit.draw()
from qiskit.extensions import Initialize
import math
qc = QuantumCircuit(1)
initial_state = [0,1]
init_gate = Initialize(initial_state)
# qc.append(initialize_qubit, [0])
qr = QuantumRegister(3) # Protocol uses 3 qubits
crz = ClassicalRegister(1) # and 2 classical registers
crx = ClassicalRegister(1)
qc = QuantumCircuit(qr, crz, crx)
# First, let's initialise Alice's q0
qc.append(init_gate, [0])
qc.barrier()
# Now begins the teleportation protocol
create_bell_pair(qc, 1, 2)
qc.barrier()
# Send q1 to Alice and q2 to Bob
alice_gates(qc, 0, 1)
# Alice then sends her classical bits to Bob
measure_and_send(qc, 0, 1)
# Bob decodes qubits
bob_gates(qc, 2, crz, crx)
qc.draw()
backend = BasicAer.get_backend('statevector_simulator')
out_vector = execute(qc, backend).result().get_statevector()
plot_bloch_multivector(out_vector)
inverse_init_gate = init_gate.gates_to_uncompute()
qc.append(inverse_init_gate, [2])
qc.draw()
cr_result = ClassicalRegister(1)
qc.add_register(cr_result)
qc.measure(2,2)
qc.draw()
backend = BasicAer.get_backend('qasm_simulator')
counts = execute(qc, backend, shots=1024).result().get_counts()
plot_histogram(counts)
def bob_gates(qc, a, b, c):
qc.cz(a, c)
qc.cx(b, c)
qc = QuantumCircuit(3,1)
# First, let's initialise Alice's q0
qc.append(init_gate, [0])
qc.barrier()
# Now begins the teleportation protocol
create_bell_pair(qc, 1, 2)
qc.barrier()
# Send q1 to Alice and q2 to Bob
alice_gates(qc, 0, 1)
qc.barrier()
# Alice sends classical bits to Bob
bob_gates(qc, 0, 1, 2)
# We undo the initialisation process
qc.append(inverse_init_gate, [2])
# See the results, we only care about the state of qubit 2
qc.measure(2,0)
# View the results:
qc.draw()
from qiskit import IBMQ
IBMQ.save_account('### IMB TOKEN ')
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
provider.backends()
from qiskit.providers.ibmq import least_busy
backend = least_busy(provider.backends(filters=lambda b: b.configuration().n_qubits >= 3 and
not b.configuration().simulator and b.status().operational==True))
job_exp = execute(qc, backend=backend, shots=8192)
exp_result = job_exp.result()
exp_measurement_result = exp_result.get_counts(qc)
print(exp_measurement_result)
plot_histogram(exp_measurement_result)
error_rate_percent = sum([exp_measurement_result[result] for result in exp_measurement_result.keys() if result[0]=='1']) \
* 100./ sum(list(exp_measurement_result.values()))
print("The experimental error rate : ", error_rate_percent, "%")
|
https://github.com/JessicaJohnBritto/Quantum-Computing-and-Information
|
JessicaJohnBritto
|
# Importing Packages
from qiskit import IBMQ, Aer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, transpile, assemble, QuantumRegister, ClassicalRegister
from qiskit.visualization import plot_histogram
from qiskit_textbook.tools import simon_oracle
bb = input("Enter the input string:\n")
### Using in-built "simon_oracle" from QISKIT
# importing Qiskit
from qiskit import IBMQ, Aer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, transpile, assemble
# import basic plot tools
from qiskit.visualization import plot_histogram
from qiskit_textbook.tools import simon_oracle
n = len(bb)
simon_circuit = QuantumCircuit(n*2, n)
# Apply Hadamard gates before querying the oracle
simon_circuit.h(range(n))
# Apply barrier for visual separation
simon_circuit.barrier()
simon_circuit += simon_oracle(b)
# Apply barrier for visual separation
simon_circuit.barrier()
# Apply Hadamard gates to the input register
simon_circuit.h(range(n))
# Measure qubits
simon_circuit.measure(range(n), range(n))
simon_circuit.draw(output="mpl")
# use local simulator
aer_sim = Aer.get_backend('aer_simulator')
shots = 500
qobj = assemble(simon_circuit, shots=shots)
results = aer_sim.run(qobj).result()
counts = results.get_counts()
print(counts)
plot_histogram(counts)
# Calculate the dot product of the results
def bdotz(b, z):
accum = 0
for i in range(len(b)):
accum += int(b[i]) * int(z[i])
return (accum % 2)
for z in counts:
print( '{}.{} = {} (mod 2)'.format(b, z, bdotz(b,z)) )
b = input("Enter a binary string:\n")
# Actual b = 011
b_rev = b[::-1]
flagbit = b_rev.find('1')
n=len(b)
q1=QuantumRegister(n,'q1')
q2=QuantumRegister(n,'q2')
c1=ClassicalRegister(n)
qc = QuantumCircuit(q1,q2,c1)
qc.barrier()
qc.h(q1)
qc.barrier()
for i in range(n):
qc.cx(q1[i],q2[i])
qc.barrier()
if flagbit != -1:
# print("test1")
for ind, bit in enumerate(b_rev):
# print("test2")
if bit == "1":
# print("test3")
qc.cx(flagbit, q2[ind])
qc.barrier()
qc.h(q1)
qc.barrier()
qc.measure(q1,c1)
qc.draw("mpl")
aer_sim = Aer.get_backend('aer_simulator')
shots = 500
qobj = assemble(qc, shots=shots)
results = aer_sim.run(qobj).result()
counts = results.get_counts()
print(counts)
plot_histogram(counts)
# Actual b = 011
b="1"
b_rev = "1"
flagbit = b_rev.find('1')
n=len(b)
q1=QuantumRegister(n,'q1')
q2=QuantumRegister(n,'q2')
c1=ClassicalRegister(n)
qc = QuantumCircuit(q1,q2,c1)
qc.barrier()
qc.h(q1)
qc.barrier()
for i in range(n):
qc.cx(q1[i],q2[i])
qc.barrier()
if flagbit != -1:
# print("test1")
for ind, bit in enumerate(b_rev):
# print("test2")
if bit == "1":
# print("test3")
qc.cx(flagbit, q2[ind])
qc.barrier()
qc.h(q1)
qc.barrier()
# qc.measure(q1,c1)
# qc.draw("mpl")
# Simulate the unitary
usim = Aer.get_backend('aer_simulator')
qc.save_unitary()
qobj = assemble(qc)
unitary = usim.run(qobj).result().get_unitary()
# Display the results:
array_to_latex(unitary, prefix="\\text{Circuit = } ")
|
https://github.com/JessicaJohnBritto/Quantum-Computing-and-Information
|
JessicaJohnBritto
|
# Importing Packages
from qiskit import QuantumCircuit
from qiskit import IBMQ, Aer, transpile, assemble
from qiskit.visualization import plot_histogram
style = {'backgroundcolor': 'lightyellow'} # Style of the circuits
def encode(qc, qubit, msg):
if len(msg) != 2 or not set(msg).issubset({"0","1"}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
# Circuit for Superdense coding
qc = QuantumCircuit(2)
# Generating entangled state
qc.h(1)
qc.cx(1, 0)
qc.barrier()
# Encoding message
message = '11'
qc = encode(qc, 1, message)
qc.barrier()
# Decoding Message
qc.cx(1, 0)
qc.h(1)
# Measuring qubits
qc.measure_all()
qc.draw(output="mpl", style=style)
aer_sim = Aer.get_backend('aer_simulator')
qobj = assemble(qc)
result = aer_sim.run(qobj).result()
counts = result.get_counts(qc)
print(counts)
plot_histogram(counts)
|
https://github.com/JessicaJohnBritto/Quantum-Computing-and-Information
|
JessicaJohnBritto
|
import pennylane as qml
from pennylane import numpy as np
import matplotlib.pyplot as plt
def coefficients_to_values(coefficients):
"""Returns the value representation of a polynomial
Args:
coefficients (array[complex]): a 1-D array of complex
coefficients of a polynomial with
index i representing the i-th degree coefficient
Returns:
array[complex]: the value representation of the
polynomial
"""
##################
# YOUR CODE HERE #
##################
# pass
return np.fft.fft(coefficients)
A = [4, 3, 2, 1]
print(coefficients_to_values(A))
def values_to_coefficients(values):
"""Returns the coefficient representation of a polynomial
Args:
values (array[complex]): a 1-D complex array with
the value representation of a polynomial
Returns:
array[complex]: a 1-D complex array of coefficients
"""
##################
# YOUR CODE HERE #
##################
return np.fft.ifft(values)
A = [10.+0.j, 2.-2.j, 2.+0.j, 2.+2.j]
print(values_to_coefficients(A))
def nearest_power_of_2(x):
"""Given an integer, return the nearest power of 2.
Args:
x (int): a positive integer
Returns:
int: the nearest power of 2 of x
"""
##################
# YOUR CODE HERE #
##################
# k = np.log2(x)
k = np.ceil(np.log2(x))
return (2**(int(k)))
nearest_power_of_2(7)
def fft_multiplication(poly_a, poly_b):
"""Returns the result of multiplying two polynomials
Args:
poly_a (array[complex]): 1-D array of coefficients
poly_b (array[complex]): 1-D array of coefficients
Returns:
array[complex]: complex coefficients of the product
of the polynomials
"""
##################
# YOUR CODE HERE #
##################
# len(poly_b) = b
# len(poly_a) = a
b = len(poly_b)
# print(b)
a = len(poly_a)
# print(a)
b = b-1
a= a-1
# Calculate the number of values required
nn = a + b + 1
# Figure out the nearest power of 2
n = nearest_power_of_2(nn)
# print(n)
# Pad zeros to the polynomial
# if a<n:
poly_a = np.pad(poly_a, (0,n-len(poly_a)))
# if b<n:
poly_b = np.pad(poly_b, (0,n-len(poly_b)))
# Convert the polynomials to value representation
aa = coefficients_to_values(poly_a)
bb = coefficients_to_values(poly_b)
# print(a)
# print(b)
# Multiply
m = aa*bb
# Convert back to coefficient representation
res = values_to_coefficients(m)
# final = np.zeros((a+b))
# final = []
# for i in range(a+b):
# final[i] = res[i]
return res
A = np.array([1,1])
B = np.array([1,-1])
fft_multiplication(A, B)
dev = qml.device("default.qubit", wires=1)
@qml.qnode(dev)
def one_qubit_QFT(basis_id):
"""A circuit that computes the QFT on a single qubit.
Args:
basis_id (int): An integer value identifying
the basis state to construct.
Returns:
array[complex]: The state of the qubit after applying QFT.
"""
# Prepare the basis state |basis_id>
bits = [int(x) for x in np.binary_repr(basis_id, width=dev.num_wires)]
qml.BasisStatePreparation(bits, wires=[0])
##################
# YOUR CODE HERE #
##################
qml.Hadamard(wires=0)
return qml.state()
n_bits = 2
dev = qml.device("default.qubit", wires=n_bits)
@qml.qnode(dev)
def two_qubit_QFT(basis_id):
"""A circuit that computes the QFT on two qubits using qml.QubitUnitary.
Args:
basis_id (int): An integer value identifying the basis state to construct.
Returns:
array[complex]: The state of the qubits after the QFT operation.
"""
# Prepare the basis state |basis_id>
bits = [int(x) for x in np.binary_repr(basis_id, width=dev.num_wires)]
qml.BasisStatePreparation(bits, wires=[0, 1])
##################
# YOUR CODE HERE #
##################
U = 0.5*(np.array([[1,1,1,1], [1, complex(0,1), -1, complex(0,-1)], [1, -1, 1, -1], [1, complex(0,-1), -1, complex(0,1)]]))
qml.QubitUnitary(U, wires=[0,1])
return qml.state()
dev = qml.device("default.qubit", wires=2)
@qml.qnode(dev)
def decompose_two_qubit_QFT(basis_id):
"""A circuit that computes the QFT on two qubits using elementary gates.
Args:
basis_id (int): An integer value identifying the basis state to construct.
Returns:
array[complex]: The state of the qubits after the QFT operation.
"""
# Prepare the basis state |basis_id>
bits = [int(x) for x in np.binary_repr(basis_id, width=dev.num_wires)]
qml.BasisStatePreparation(bits, wires=[0, 1])
##################
# YOUR CODE HERE #
##################
qml.Hadamard(wires=0)
qml.ctrl(qml.S, control=1)(wires=0)
qml.Hadamard(wires=1)
qml.SWAP(wires=[0,1])
# pass
return qml.state()
dev = qml.device("default.qubit", wires=3)
@qml.qnode(dev)
def three_qubit_QFT(basis_id):
"""A circuit that computes the QFT on three qubits.
Args:
basis_id (int): An integer value identifying the basis state to construct.
Returns:
array[complex]: The state of the qubits after the QFT operation.
"""
# Prepare the basis state |basis_id>
bits = [int(x) for x in np.binary_repr(basis_id, width=dev.num_wires)]
qml.BasisStatePreparation(bits, wires=[0, 1, 2])
##################
# YOUR CODE HERE #
##################
for i in range(3):
# j=i+1
# print("test1")
qml.Hadamard(wires=i)
for jj in range(i+1,3,1):
# print("test2")
# k = (1/(2**(jj)))*(np.pi)*(complex(0,1))
# U = np.array([[1,0], [0, np.exp(k)]])
# qml.ctrl(qml.QubitUnitary(U, wires=i), control=jj)
# Below lines of code give the same result as the above one
k = (1/(2**(jj)))*(np.pi)
qml.ctrl(qml.PhaseShift(k, wires=i), control = jj)
qml.SWAP(wires=[0,2])
return qml.state()
print(qml.draw(three_qubit_QFT)(3))
dev = qml.device('default.qubit', wires=4)
def swap_bits(n_qubits):
"""A circuit that reverses the order of qubits, i.e.,
performs a SWAP such that [q1, q2, ..., qn] -> [qn, ... q2, q1].
Args:
n_qubits (int): An integer value identifying the number of qubits.
"""
##################
# YOUR CODE HERE #
##################
# if n%2==0:
# j =
for i in range(int(n_qubits/2)):
qml.SWAP(wires=[i,n_qubits-1-i])
# pass
@qml.qnode(dev)
def qft_node(basis_id, n_qubits):
# Prepare the basis state |basis_id>
bits = [int(x) for x in np.binary_repr(basis_id, width=n_qubits)]
qml.BasisStatePreparation(bits, wires=range(n_qubits))
# qft_rotations(n_qubits)
swap_bits(n_qubits)
return qml.state()
dev = qml.device('default.qubit', wires=4)
# @qml.qnode(dev)
def qft_rotations(n_qubits):
"""A circuit performs the QFT rotations on the specified qubits.
Args:
n_qubits (int): An integer value identifying the number of qubits.
"""
##################
# YOUR CODE HERE #
##################
n = n_qubits
for i in range(n):
# j=i+1
# print("test1")
qml.Hadamard(wires=i)
for jj in range(i+1,n,1):
# print("test2")
qml.ControlledPhaseShift(np.pi/(2**(jj-i)), wires=[jj,i])
pass
@qml.qnode(dev)
def qft_node(basis_id, n_qubits):
# Prepare the basis state |basis_id>
bits = [int(x) for x in np.binary_repr(basis_id, width=n_qubits)]
qml.BasisStatePreparation(bits, wires=range(n_qubits))
qft_rotations(n_qubits)
swap_bits(n_qubits)
return qml.state()
# print(qml.draw(qft_rotations)(3))
print(qml.draw(qft_node)(3,3))
dev = qml.device('default.qubit', wires=4)
def qft_recursive_rotations(n_qubits, wire=0):
"""A circuit that performs the QFT rotations on the specified qubits
recursively.
Args:
n_qubits (int): An integer value identifying the number of qubits.
wire (int): An integer identifying the wire
(or the qubit) to apply rotations on.
"""
##################
# YOUR CODE HERE #
##################
i = wire
if i == n_qubits-1:
qml.Hadamard(wires=i)
# for i in range(n_qubits):
# qml.Hadamard(wires=i)
# if n_qubits!=i:
else:
qml.Hadamard(wires=i)
for j in range(i+1, n_qubits, 1):
qml.ControlledPhaseShift(np.pi/(2**(j-i)), wires=[j,i])
qft_recursive_rotations(n_qubits, i+1)
pass
@qml.qnode(dev)
def qft_node(basis_id, n_qubits):
# Prepare the basis state |basis_id>
bits = [int(x) for x in np.binary_repr(basis_id, width=n_qubits)]
qml.BasisStatePreparation(bits, wires=range(n_qubits))
qft_recursive_rotations(n_qubits)
swap_bits(n_qubits)
return qml.state()
print(qml.draw(qft_node)(3,3))
|
https://github.com/JessicaJohnBritto/Quantum-Computing-and-Information
|
JessicaJohnBritto
|
pip install pennylane
import pennylane as qml
from pennylane import numpy as np
import matplotlib.pyplot as plt
dev = qml.device('default.qubit', wires=3)
@qml.qnode(dev)
def make_basis_state(basis_id):
"""Produce the 3-qubit basis state corresponding to |basis_id>.
Note that the system starts in |000>.
Args:
basis_id (int): An integer value identifying the basis state to construct.
Returns:
array[complex]: The computational basis state |basis_id>.
"""
##################
# YOUR CODE HERE #
##################
# CREATE THE BASIS STATE
k = np.binary_repr(basis_id, width = 3)
l = [int(x) for x in k]
print(l)
print(np.arange(3))
qml.BasisStatePreparation(l, wires=range(3))
return qml.state()
basis_id = 3
print(f"Output state = {make_basis_state(basis_id)}")
# Creates a device with *two* qubits
dev = qml.device('default.qubit', wires=2)
@qml.qnode(dev)
def two_qubit_circuit():
##################
# YOUR CODE HERE #
##################
# PREPARE |+>|1>
qml.Hadamard(wires=0)
qml.PauliX(wires=1)
# RETURN TWO EXPECTATION VALUES, Y ON FIRST QUBIT, Z ON SECOND QUBIT
k = qml.expval(qml.PauliY(wires=0))
m = qml.expval(qml.PauliZ(wires=1))
l = [k,m]
return l
print(two_qubit_circuit())
dev = qml.device("default.qubit", wires=2)
@qml.qnode(dev)
def create_one_minus():
##################
# YOUR CODE HERE #
##################
# PREPARE |1>|->
qml.PauliX(wires=0)
qml.PauliX(wires=1)
qml.Hadamard(wires=1)
# RETURN A SINGLE EXPECTATION VALUE Z \otimes X
return qml.expval(qml.PauliZ(0)@qml.PauliX(1))
print(create_one_minus())
dev = qml.device('default.qubit', wires=2)
@qml.qnode(dev)
def circuit_1(theta):
"""Implement the circuit and measure Z I and I Z.
Args:
theta (float): a rotation angle.
Returns:
float, float: The expectation values of the observables Z I, and I Z
"""
##################
# YOUR CODE HERE #
##################
qml.RX(theta, wires=0)
qml.RY(2*theta, wires=1)
return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1))
@qml.qnode(dev)
def circuit_2(theta):
"""Implement the circuit and measure Z Z.
Args:
theta (float): a rotation angle.
Returns:
float: The expectation value of the observable Z Z
"""
##################
# YOUR CODE HERE #
##################
qml.RX(theta, wires=0)
qml.RY(2*theta, wires=1)
return qml.expval(qml.PauliZ(0) @qml.PauliZ(1))
def zi_iz_combination(ZI_results, IZ_results):
"""Implement a function that acts on the ZI and IZ results to
produce the ZZ results. How do you think they should combine?
Args:
ZI_results (array[float]): Results from the expectation value of
ZI in circuit_1.
IZ_results (array[float]): Results from the expectation value of
IZ in circuit_2.
Returns:
array[float]: A combination of ZI_results and IZ_results that
produces results equivalent to measuring ZZ.
"""
combined_results = np.zeros(len(ZI_results))
##################
# YOUR CODE HERE #
##################
return ZI_results*IZ_results
theta = np.linspace(0, 2 * np.pi, 100)
# Run circuit 1, and process the results
circuit_1_results = np.array([circuit_1(t) for t in theta])
ZI_results = circuit_1_results[:, 0]
IZ_results = circuit_1_results[:, 1]
combined_results = zi_iz_combination(ZI_results, IZ_results)
# Run circuit 2
ZZ_results = np.array([circuit_2(t) for t in theta])
# Plot your results
plot = plotter(theta, ZI_results, IZ_results, ZZ_results, combined_results)
dev = qml.device('default.qubit', wires=2)
@qml.qnode(dev)
def apply_cnot(basis_id):
"""Apply a CNOT to |basis_id>.
Args:
basis_id (int): An integer value identifying the basis state to construct.
Returns:
array[complex]: The resulting state after applying CNOT|basis_id>.
"""
# Prepare the basis state |basis_id>
bits = [int(x) for x in np.binary_repr(basis_id, width=dev.num_wires)]
qml.BasisStatePreparation(bits, wires=[0, 1])
##################
# YOUR CODE HERE #
##################
# APPLY THE CNOT
qml.CNOT(wires=[0,1])
return qml.state()
##################
# YOUR CODE HERE #
##################
# REPLACE THE BIT STRINGS VALUES BELOW WITH THE CORRECT ONES
cnot_truth_table = {
"00" : "00",
"01" : "01",
"10" : "11",
"11" : "10"
}
# Run your QNode with various inputs to help fill in your truth table
# for k in cnot_truth_table:
for k in range(4):
print(apply_cnot(k))
dev = qml.device("default.qubit", wires=2)
@qml.qnode(dev)
def apply_h_cnot():
##################
# YOUR CODE HERE #
##################
# APPLY THE OPERATIONS IN THE CIRCUIT
qml.Hadamard(wires=0)
qml.CNOT(wires=[0,1])
return qml.state()
print(apply_h_cnot())
##################
# YOUR CODE HERE #
##################
# SET THIS AS 'separable' OR 'entangled' BASED ON YOUR OUTCOME
state_status = "entangled"
dev = qml.device('default.qubit', wires=3)
@qml.qnode(dev)
def controlled_rotations(theta, phi, omega):
"""Implement the circuit above and return measurement outcome probabilities.
Args:
theta (float): A rotation angle
phi (float): A rotation angle
omega (float): A rotation angle
Returns:
array[float]: Measurement outcome probabilities of the 3-qubit
computational basis states.
"""
qml.Hadamard(wires=0)
qml.CRX(theta, wires=[0,1])
qml.CRY(phi, wires=[1,2])
qml.CRZ(omega, wires=[2,0])
##################
# YOUR CODE HERE #
##################
# APPLY THE OPERATIONS IN THE CIRCUIT AND RETURN MEASUREMENT PROBABILITIES
return qml.probs(wires=[0,1,2])
theta, phi, omega = 0.1, 0.2, 0.3
print(controlled_rotations(theta, phi, omega))
dev = qml.device("default.qubit", wires=2)
# Prepare a two-qubit state; change up the angles if you like
phi, theta, omega = 1.2, 2.3, 3.4
@qml.qnode(device=dev)
def true_cz(phi, theta, omega):
prepare_states(phi, theta, omega)
##################
# YOUR CODE HERE #
##################
# IMPLEMENT THE REGULAR CZ GATE HERE
qml.CZ(wires=[0,1])
return qml.state()
@qml.qnode(dev)
def imposter_cz(phi, theta, omega):
prepare_states(phi, theta, omega)
# qml.Hadamard(wires=0)
qml.Hadamard(wires=1)
qml.CNOT(wires=[0,1])
qml.Hadamard(wires=1)
# qml.Hadamard(wires=0)
##################
# YOUR CODE HERE #
##################
# IMPLEMENT CZ USING ONLY H AND CNOT
return qml.state()
print(f"True CZ output state {true_cz(phi, theta, omega)}")
print(f"Imposter CZ output state {imposter_cz(phi, theta, omega)}")
dev = qml.device("default.qubit", wires=2)
# Prepare a two-qubit state; change up the angles if you like
phi, theta, omega = 1.2, 2.3, 3.4
@qml.qnode(dev)
def apply_swap(phi, theta, omega):
prepare_states(phi, theta, omega)
##################
# YOUR CODE HERE #
##################
# IMPLEMENT THE REGULAR SWAP GATE HERE
qml.SWAP(wires=[0,1])
return qml.state()
@qml.qnode(dev)
def apply_swap_with_cnots(phi, theta, omega):
prepare_states(phi, theta, omega)
##################
# YOUR CODE HERE #
##################
qml.CNOT(wires=[0,1])
qml.CNOT(wires=[1,0])
qml.CNOT(wires=[0,1])
# IMPLEMENT THE SWAP GATE USING A SEQUENCE OF CNOTS
return qml.state()
print(f"Regular SWAP state = {apply_swap(phi, theta, omega)}")
print(f"CNOT SWAP state = {apply_swap_with_cnots(phi, theta, omega)}")
dev = qml.device("default.qubit", wires=3)
# Prepare first qubit in |1>, and arbitrary states on the second two qubits
phi, theta, omega = 1.2, 2.3, 3.4
# A helper function just so you can visualize the initial state
# before the controlled SWAP occurs.
@qml.qnode(dev)
def no_swap(phi, theta, omega):
prepare_states(phi, theta, omega)
return qml.state()
@qml.qnode(dev)
def controlled_swap(phi, theta, omega):
prepare_states(phi, theta, omega)
##################
# YOUR CODE HERE #
##################
# PERFORM A CONTROLLED SWAP USING A SEQUENCE OF TOFFOLIS
qml.Toffoli(wires=[0, 1, 2])
qml.Toffoli(wires=[0, 2, 1])
qml.Toffoli(wires=[0, 1, 2])
# qml.Toffoli(wires=[control1, control2, target])
return qml.state()
print(no_swap(phi, theta, omega))
print(controlled_swap(phi, theta, omega))
|
https://github.com/JessicaJohnBritto/Quantum-Computing-and-Information
|
JessicaJohnBritto
|
import pennylane as qml
from pennylane import numpy as np
import matplotlib.pyplot as plt
dev = qml.device("default.qubit", wires=1)
@qml.qnode(dev)
def apply_z_to_plus():
"""Write a circuit that applies PauliZ to the |+> state and returns
the state.
Returns:
array[complex]: The state of the qubit after the operations.
"""
##################
# YOUR CODE HERE #
##################
# CREATE THE |+> STATE
qml.Hadamard(wires=0)
# APPLY PAULI Z
qml.PauliZ(wires=0)
# RETURN THE STATE
return qml.state()
print(apply_z_to_plus())
dev = qml.device("default.qubit", wires=1)
@qml.qnode(dev)
def fake_z():
"""Use RZ to produce the same action as Pauli Z on the |+> state.
Returns:
array[complex]: The state of the qubit after the operations.
"""
##################
# YOUR CODE HERE #
##################
# CREATE THE |+> STATE
qml.Hadamard(wires=0)
# APPLY RZ
qml.RZ(np.pi, wires=0)
# RETURN THE STATE
return qml.state()
dev = qml.device("default.qubit", wires=1)
@qml.qnode(dev)
def many_rotations():
"""Implement the circuit depicted above and return the quantum state.
Returns:
array[complex]: The state of the qubit after the operations.
"""
##################
# YOUR CODE HERE #
##################
# IMPLEMENT THE CIRCUIT
qml.Hadamard(wires=0)
qml.S(wires=0)
qml.adjoint(qml.T)(wires=0)
qml.RZ(0.3, wires=0)
qml.adjoint(qml.S)(wires=0)
# RETURN THE STATE
return qml.state()
dev = qml.device('default.qubit', wires=3)
@qml.qnode(dev)
def too_many_ts():
"""You can implement the original circuit here as well, it may help you with
testing to ensure that the circuits have the same effect.
Returns:
array[float]: The measurement outcome probabilities.
"""
# qml.Hadamard(wires=[0,1,2])
qml.Hadamard(wires=0)
qml.Hadamard(wires=1)
qml.Hadamard(wires=2)
qml.T(wires=[0,1])
qml.adjoint(qml.T)(wires=2)
qml.T(wires=0)
# qml.Hadamard(wires=[0,1,2])
qml.Hadamard(wires=0)
qml.Hadamard(wires=1)
qml.Hadamard(wires=2)
qml.adjoint(qml.T)(wires=0)
qml.T(wires=1)
qml.adjoint(qml.T)(wires=2)
qml.adjoint(qml.T)(wires=0)
qml.T(wires=1)
qml.adjoint(qml.T)(wires=2)
qml.T(wires=1)
qml.adjoint(qml.T)(wires=2)
qml.T(wires=1)
# qml.Hadamard(wires=[0,1,2])
qml.Hadamard(wires=0)
qml.Hadamard(wires=1)
qml.Hadamard(wires=2)
return qml.probs(wires=[0, 1, 2])
@qml.qnode(dev)
def just_enough_ts():
"""Implement an equivalent circuit as the above with the minimum number of
T and T^\dagger gates required.
Returns:
array[float]: The measurement outcome probabilities.
"""
##################
# YOUR CODE HERE #
##################
qml.Hadamard(wires=0)
qml.Hadamard(wires=1)
qml.Hadamard(wires=2)
qml.S(wires=0)
qml.T(wires=1)
qml.adjoint(qml.T)(wires=2)
# qml.T(wires=0)
# qml.Hadamard(wires=[0,1,2])
qml.Hadamard(wires=0)
qml.Hadamard(wires=1)
qml.Hadamard(wires=2)
qml.adjoint(qml.S)(wires=0)
qml.S(wires=1)
qml.adjoint(qml.S)(wires=2)
# qml.adjoint(qml.T)(wires=0)
# qml.T(wires=1)
# qml.adjoint(qml.T)(wires=2)
qml.S(wires=1)
qml.adjoint(qml.T)(wires=2)
# qml.T(wires=1)
# qml.Hadamard(wires=[0,1,2])
qml.Hadamard(wires=0)
qml.Hadamard(wires=1)
qml.Hadamard(wires=2)
# IMPLEMENT THE CIRCUIT, BUT COMBINE AND OPTIMIZE THE GATES
# TO MINIMIZE THE NUMBER OF TS
return qml.probs(wires=[0, 1, 2])
##################
# YOUR CODE HERE #
##################
# FILL IN THE CORRECT VALUES FOR THE ORIGINAL CIRCUIT
original_depth = 8
original_t_count = 13
original_t_depth = 6
# FILL IN THE CORRECT VALUES FOR THE NEW, OPTIMIZED CIRCUIT
optimal_depth = 6
optimal_t_count = 3
optimal_t_depth = 2
dev = qml.device("default.qubit", wires=1)
##################
# YOUR CODE HERE #
##################
# ADJUST THE VALUES OF PHI, THETA, AND OMEGA
phi, theta, omega = np.pi/2, np.pi/2, np.pi/2
@qml.qnode(dev)
def hadamard_with_rz_rx():
qml.RZ(phi, wires=0)
qml.RX(theta, wires=0)
qml.RZ(omega, wires=0)
return qml.state()
dev = qml.device("default.qubit", wires=1)
@qml.qnode(dev)
def convert_to_rz_rx():
##################
# YOUR CODE HERE #
##################
# IMPLEMENT THE CIRCUIT IN THE PICTURE USING ONLY RZ AND RX
qml.RZ(np.pi/2, wires=0)
qml.RX(np.pi/2, wires=0)
qml.RZ(np.pi/2, wires=0)
qml.RZ(np.pi/2,wires=0)
qml.RZ(np.pi, wires=0)
qml.RZ(np.pi/2, wires=0)
qml.RZ(np.pi/4, wires=0)
qml.RZ(np.pi/2,wires=0)
qml.RX(np.pi, wires=0)
qml.RZ(np.pi, wires=0)
qml.RZ(np.pi/2, wires=0)
return qml.state()
dev = qml.device("default.qubit", wires=1)
@qml.qnode(dev)
def unitary_with_h_and_t():
##################
# YOUR CODE HERE #
##################
# APPLY ONLY H AND T TO PRODUCE A CIRCUIT THAT EFFECTS THE GIVEN MATRIX
# qml.T(wires=0)
qml.Hadamard(wires=0)
qml.T(wires=0)
qml.Hadamard(wires=0)
qml.T(wires=0)
qml.T(wires=0)
qml.Hadamard(wires=0)
# qml.T(wires=0)
return qml.state()
|
https://github.com/JessicaJohnBritto/Quantum-Computing-and-Information
|
JessicaJohnBritto
|
import pennylane as qml
from pennylane import numpy as np
import matplotlib.pyplot as plt
dev = qml.device("default.qubit", wires=1)
@qml.qnode(dev)
def prepare_state():
##################
# YOUR CODE HERE #
##################
# APPLY OPERATIONS TO PREPARE THE TARGET STATE
qml.Hadamard(wires=0)
qml.PauliZ(wires=0)
qml.T(wires=0)
return qml.state()
dev = qml.device("default.qubit", wires=1)
@qml.qnode(dev)
def prepare_state():
##################
# YOUR CODE HERE #
##################
# APPLY OPERATIONS TO PREPARE THE TARGET STATE
qml.RX((np.pi)/3, wires=0)
return qml.state()
v = np.array([0.52889389-0.14956775j, 0.67262317+0.49545818j])
##################
# YOUR CODE HERE #
##################
# CREATE A DEVICE
dev = qml.device("default.qubit", wires=1)
# CONSTRUCT A QNODE THAT USES qml.MottonenStatePreparation
# TO PREPARE A QUBIT IN STATE V, AND RETURN THE STATE
@qml.qnode(dev)
def prepare_state(state=v):
qml.MottonenStatePreparation(state, wires=0)
return qml.state()
# This will draw the quantum circuit and allow you to inspect the output gates
print(prepare_state(v))
print()
print(qml.draw(prepare_state)(v))
dev = qml.device("default.qubit", wires=1)
@qml.qnode(dev)
def apply_h_and_measure(state):
"""Complete the function such that we apply the Hadamard gate
and measure in the computational basis.
Args:
state (int): Either 0 or 1. If 1, prepare the qubit in state |1>,
otherwise leave it in state 0.
Returns:
array[float]: The measurement outcome probabilities.
"""
if state == 1:
qml.PauliX(wires=0)
##################
# YOUR CODE HERE #
##################
# APPLY HADAMARD AND MEASURE
qml.Hadamard(wires=0)
return qml.probs(wires=[0])
print(apply_h_and_measure(0))
print(apply_h_and_measure(1))
##################
# YOUR CODE HERE #
##################
# WRITE A QUANTUM FUNCTION THAT PREPARES (1/2)|0> + i(sqrt(3)/2)|1>
def prepare_psi():
qml.RX(4*(np.pi)/3, wires=0)
# return qml.probs(wires=[0])
# pass
# return qml.state()
# WRITE A QUANTUM FUNCTION THAT SENDS BOTH |0> TO |y_+> and |1> TO |y_->
def y_basis_rotation():
# qml.RX(3*(np.pi)/2, wires=0)
qml.Hadamard(wires=0)
qml.S(wires=0)
dev = qml.device("default.qubit", wires=1)
@qml.qnode(dev)
def measure_in_y_basis():
##################
# YOUR CODE HERE #
##################
# PREPARE THE STATE
prepare_psi()
# PERFORM THE ROTATION BACK TO COMPUTATIONAL BASIS
qml.adjoint(y_basis_rotation)()
# RETURN THE MEASUREMENT OUTCOME PROBABILITIES
return qml.probs(wires=[0])
print(measure_in_y_basis())
dev = qml.device('default.qubit', wires=1)
@qml.qnode(dev)
def circuit():
##################
# YOUR CODE HERE #
##################
qml.RX(np.pi/4, wires=0)
qml.Hadamard(wires=0)
qml.PauliZ(wires=0)
# IMPLEMENT THE CIRCUIT IN THE PICTURE AND MEASURE PAULI Y
return qml.expval(qml.PauliY(0))
print(circuit())
# An array to store your results
shot_results = []
# dev = qml.device('default.qubit', wires=1)
# @qml.qnode(dev)
def circuit():
##################
# YOUR CODE HERE #
##################
qml.RX(np.pi/4, wires=0)
qml.Hadamard(wires=0)
qml.PauliZ(wires=0)
# IMPLEMENT THE CIRCUIT IN THE PICTURE AND MEASURE PAULI Y
return qml.expval(qml.PauliY(0))
# Different numbers of shots
shot_values = [100, 1000, 10000, 100000, 1000000]
for shots in shot_values:
##################
# YOUR CODE HERE #
##################
# CREATE A DEVICE, CREATE A QNODE, AND RUN IT
dev = qml.device('default.qubit', wires=1, shots=shots)
# @qml.qnode(dev)
qnode = qml.QNode(circuit, dev)
# def circu():
shot_results.append(qnode())
# STORE RESULT IN SHOT_RESULTS ARRAY
print(qml.math.unwrap(shot_results))
dev = qml.device("default.qubit", wires=1, shots=100000)
@qml.qnode(dev)
def circuit():
qml.RX(np.pi/4, wires=0)
qml.Hadamard(wires=0)
qml.PauliZ(wires=0)
##################
# YOUR CODE HERE #
##################
# RETURN THE MEASUREMENT SAMPLES OF THE CORRECT OBSERVABLE
return qml.sample(qml.PauliY(wires=0))
def compute_expval_from_samples(samples):
"""Compute the expectation value of an observable given a set of
sample outputs. You can assume that there are two possible outcomes,
1 and -1.
Args:
samples (array[float]): 100000 samples representing the results of
running the above circuit.
Returns:
float: the expectation value computed based on samples.
"""
estimated_expval = 0
##################
# YOUR CODE HERE #
##################
k = np.array(samples)
estimated_expval = np.average(k)
# USE THE SAMPLES TO ESTIMATE THE EXPECTATION VALUE
return estimated_expval
samples = circuit()
print(compute_expval_from_samples(samples))
def variance_experiment(n_shots):
"""Run an experiment to determine the variance in an expectation
value computed with a given number of shots.
Args:
n_shots (int): The number of shots
Returns:
float: The variance in expectation value we obtain running the
circuit 100 times with n_shots shots each.
"""
# To obtain a variance, we run the circuit multiple times at each shot value.
n_trials = 100
##################
# YOUR CODE HERE #
##################
samples = []
# CREATE A DEVICE WITH GIVEN NUMBER OF SHOTS
dev = qml.device('default.qubit', wires=1, shots = n_shots)
# qnode = qml.QNode(circuit, dev)
# DECORATE THE CIRCUIT BELOW TO CREATE A QNODE
@qml.qnode(dev)
def circuit():
qml.Hadamard(wires=0)
return qml.expval(qml.PauliZ(wires=0))
# qnode = qml.QNode(circuit, dev, shots = n_shots)
# RUN THE QNODE N_TRIALS TIMES AND RETURN THE VARIANCE OF THE RESULTS
for i in range(n_trials):
sample = circuit()
samples.append(sample)
k = np.var(np.array(samples))
return k
def variance_scaling(n_shots):
"""Once you have determined how the variance in expectation value scales
with the number of shots, complete this function to programmatically
represent the relationship.
Args:
n_shots (int): The number of shots
Returns:
float: The variance in expectation value we expect to see when we run
an experiment with n_shots shots.
"""
estimated_variance = 0
sample=[]
##################
# YOUR CODE HERE #
##################
# ESTIMATE THE VARIANCE BASED ON SHOT NUMBER
# for i in range(n_shots):
# if i != 0:
# sample.append(1/i)
# estimated_variance = np.var(np.array(sample))
return 1/n_shots
# Various numbers of shots; you can change this
shot_vals = [10, 20, 40, 100, 200, 400, 1000, 2000, 4000]
# Used to plot your results
results_experiment = [variance_experiment(shots) for shots in shot_vals]
results_scaling = [variance_scaling(shots) for shots in shot_vals]
plot = plotter(shot_vals, results_experiment, results_scaling)
|
https://github.com/JessicaJohnBritto/Quantum-Computing-and-Information
|
JessicaJohnBritto
|
import pennylane as qml
from pennylane import numpy as np
# Basis State preparation
def state_preparation(basis_id, n_qubits):
bits = [int(x) for x in np.binary_repr(basis_id, width=n_qubits)]
return qml.BasisStatePreparation(bits, wires=range(n_qubits))
#Testing
state_preparation(3,5)
# Swappping of quantum circuits
def swap_bits(n_qubits):
"""A circuit that reverses the order of qubits, i.e.,
performs a SWAP such that [q1, q2, ..., qn] -> [qn, ... q2, q1].
Args:
n_qubits (int): An integer value identifying the number of qubits.
"""
for i in range(int(n_qubits/2)):
qml.SWAP(wires=[i,n_qubits-1-i])
# Conditional Rotation matrix
def qft_rotations(n_qubits):
"""A circuit performs the QFT rotations on the specified qubits.
Args:
n_qubits (int): An integer value identifying the number of qubits.
"""
n = n_qubits
for i in range(n):
qml.Hadamard(wires=i)
for jj in range(i+1,n,1):
qml.ControlledPhaseShift(np.pi/(2**(jj-i)), wires=[jj,i])
pass
def qft_node(basis_id, basis_id2, n_qubits):
''' A circuit performs addition of two numbers
Args:
basis_id (int): An integer value specifying the first number to be added.
basis_id2 (int): An integer value specifying the second number to be added.
n_qubits (int): An integer value identifying the number of qubits.
'''
# Prepare the basis state |basis_id>
bits = [int(x) for x in np.binary_repr(basis_id, width=n_qubits)]
qml.BasisStatePreparation(bits, wires=range(n_qubits))
bits2 = [int(x) for x in np.binary_repr(basis_id2, width=n_qubits)]
qml.BasisStatePreparation(bits2, wires=range(n_qubits, 2*(n_qubits),1))
qft_rotations(n_qubits)
for i in range(0,n_qubits,1):
k=0
for j in range(i+n_qubits,(2*n_qubits),1):
qml.ControlledPhaseShift((np.pi/(2**(k))), wires=[j,i])
k+=1
(qml.adjoint)(qft_rotations)(n_qubits)
return qml.sample(wires=[x for x in range(n_qubits)])
# basis_id stores a, basis_id2 stores b
basis_id = int(input("Enter number a: "))
basis_id2 = int(input("Enter number b: "))
if len(np.binary_repr(basis_id))>len(np.binary_repr(basis_id2)):
n_qubits = len(np.binary_repr(basis_id)) + 1
else:
n_qubits = len(np.binary_repr(basis_id2)) + 1
dev = qml.device('default.qubit', wires=(2*n_qubits), shots=10)
qnode = qml.QNode(qft_node, dev)
k = qnode(basis_id, basis_id2, n_qubits)
poww, summ = 0, 0
for l in reversed(k[0]):
summ = summ + (2**poww)*l
poww+=1
print(summ)
def multiplier(basis_id, basis_id2, n_qubits):
''' A circuit performs multiplication of two numbers
Args:
basis_id (int): An integer value specifying the first number to be multiplied.
basis_id2 (int): An integer value specifying the second number to be multiplied.
n_qubits (int): An integer value identifying the number of qubits.
'''
# Basis state preparation for 0, a, b respectively
bits1 = [int(x) for x in np.binary_repr(0, width=2*n_qubits)]
qml.BasisStatePreparation(bits1, wires=range(2*(n_qubits)))
bits2 = [int(x) for x in np.binary_repr(basis_id, width=n_qubits)]
qml.BasisStatePreparation(bits2, wires=range(2*n_qubits, 3*n_qubits))
bits3 = [int(x) for x in np.binary_repr(basis_id2, width=n_qubits)]
qml.BasisStatePreparation(bits3, wires=range(3*n_qubits, 4*(n_qubits),1))
# Applying QFT on first 2*n_qubits as they store the basis state for |0>
qft_rotations(2*n_qubits)
# Applying Conditional Rotation operator with controls a_j and b_m and target as |0>
for i in range(3*n_qubits, 4*n_qubits,1):
for j in range(2*n_qubits, 3*n_qubits,1):
for m in range(2*n_qubits):
qml.ctrl(qml.PhaseShift(np.pi/(2**(-(5*n_qubits)-m+j+i+1)), wires=m),control=[j,i])
# Applying inverse QFT 2*n_qubits
(qml.adjoint)(qft_rotations)(2*n_qubits)
return qml.sample(wires=[x for x in range(2*n_qubits)])
# basis_id stores a, basis_id2 stores b
basis_id = int(input("Enter number a: "))
basis_id2 = int(input("Enter number b: "))
# n_qubits takes the value of the number whose binary representation is the greatest among the two
if len(np.binary_repr(basis_id))>len(np.binary_repr(basis_id2)):
n_qubits = len(np.binary_repr(basis_id))
else:
n_qubits = len(np.binary_repr(basis_id2))
# Creating QNode
dev = qml.device('default.qubit', wires=(4*n_qubits), shots=10)
qnode = qml.QNode(multiplier, dev)
# Below code returns the sample containing measurements on the wires
# print(qnode(basis_id,basis_id2,n_qubits))
# Below prints quantum circuit
# print(qml.draw(qnode)(basis_id,basis_id2,n_qubits))
# k stores the sample of measurement values on each wire
k = qnode(basis_id, basis_id2, n_qubits)
# Converting k[0] to integer value
# Considering only k[0] as all elements of the sample are identical
poww, summ = 0, 0
for l in reversed(k[0]):
summ = summ + (2**poww)*l
poww+=1
print(summ)
|
https://github.com/JessicaJohnBritto/Quantum-Computing-and-Information
|
JessicaJohnBritto
|
import pennylane as qml
from pennylane import numpy as np
import matplotlib.pyplot as plt
def coefficients_to_values(coefficients):
"""Returns the value representation of a polynomial
Args:
coefficients (array[complex]): a 1-D array of complex
coefficients of a polynomial with
index i representing the i-th degree coefficient
Returns:
array[complex]: the value representation of the
polynomial
"""
##################
# YOUR CODE HERE #
##################
# pass
return np.fft.fft(coefficients)
A = [4, 3, 2, 1]
print(coefficients_to_values(A))
def values_to_coefficients(values):
"""Returns the coefficient representation of a polynomial
Args:
values (array[complex]): a 1-D complex array with
the value representation of a polynomial
Returns:
array[complex]: a 1-D complex array of coefficients
"""
##################
# YOUR CODE HERE #
##################
return np.fft.ifft(values)
A = [10.+0.j, 2.-2.j, 2.+0.j, 2.+2.j]
print(values_to_coefficients(A))
def nearest_power_of_2(x):
"""Given an integer, return the nearest power of 2.
Args:
x (int): a positive integer
Returns:
int: the nearest power of 2 of x
"""
##################
# YOUR CODE HERE #
##################
# k = np.log2(x)
k = np.ceil(np.log2(x))
return (2**(int(k)))
nearest_power_of_2(7)
def fft_multiplication(poly_a, poly_b):
"""Returns the result of multiplying two polynomials
Args:
poly_a (array[complex]): 1-D array of coefficients
poly_b (array[complex]): 1-D array of coefficients
Returns:
array[complex]: complex coefficients of the product
of the polynomials
"""
##################
# YOUR CODE HERE #
##################
# len(poly_b) = b
# len(poly_a) = a
b = len(poly_b)
# print(b)
a = len(poly_a)
# print(a)
b = b-1
a= a-1
# Calculate the number of values required
nn = a + b + 1
# Figure out the nearest power of 2
n = nearest_power_of_2(nn)
# print(n)
# Pad zeros to the polynomial
# if a<n:
poly_a = np.pad(poly_a, (0,n-len(poly_a)))
# if b<n:
poly_b = np.pad(poly_b, (0,n-len(poly_b)))
# Convert the polynomials to value representation
aa = coefficients_to_values(poly_a)
bb = coefficients_to_values(poly_b)
# print(a)
# print(b)
# Multiply
m = aa*bb
# Convert back to coefficient representation
res = values_to_coefficients(m)
# final = np.zeros((a+b))
# final = []
# for i in range(a+b):
# final[i] = res[i]
return res
A = np.array([1,1])
B = np.array([1,-1])
fft_multiplication(A, B)
dev = qml.device("default.qubit", wires=1)
@qml.qnode(dev)
def one_qubit_QFT(basis_id):
"""A circuit that computes the QFT on a single qubit.
Args:
basis_id (int): An integer value identifying
the basis state to construct.
Returns:
array[complex]: The state of the qubit after applying QFT.
"""
# Prepare the basis state |basis_id>
bits = [int(x) for x in np.binary_repr(basis_id, width=dev.num_wires)]
qml.BasisStatePreparation(bits, wires=[0])
##################
# YOUR CODE HERE #
##################
qml.Hadamard(wires=0)
return qml.state()
n_bits = 2
dev = qml.device("default.qubit", wires=n_bits)
@qml.qnode(dev)
def two_qubit_QFT(basis_id):
"""A circuit that computes the QFT on two qubits using qml.QubitUnitary.
Args:
basis_id (int): An integer value identifying the basis state to construct.
Returns:
array[complex]: The state of the qubits after the QFT operation.
"""
# Prepare the basis state |basis_id>
bits = [int(x) for x in np.binary_repr(basis_id, width=dev.num_wires)]
qml.BasisStatePreparation(bits, wires=[0, 1])
##################
# YOUR CODE HERE #
##################
U = 0.5*(np.array([[1,1,1,1], [1, complex(0,1), -1, complex(0,-1)], [1, -1, 1, -1], [1, complex(0,-1), -1, complex(0,1)]]))
qml.QubitUnitary(U, wires=[0,1])
return qml.state()
dev = qml.device("default.qubit", wires=2)
@qml.qnode(dev)
def decompose_two_qubit_QFT(basis_id):
"""A circuit that computes the QFT on two qubits using elementary gates.
Args:
basis_id (int): An integer value identifying the basis state to construct.
Returns:
array[complex]: The state of the qubits after the QFT operation.
"""
# Prepare the basis state |basis_id>
bits = [int(x) for x in np.binary_repr(basis_id, width=dev.num_wires)]
qml.BasisStatePreparation(bits, wires=[0, 1])
##################
# YOUR CODE HERE #
##################
qml.Hadamard(wires=0)
qml.ctrl(qml.S, control=1)(wires=0)
qml.Hadamard(wires=1)
qml.SWAP(wires=[0,1])
# pass
return qml.state()
dev = qml.device("default.qubit", wires=3)
@qml.qnode(dev)
def three_qubit_QFT(basis_id):
"""A circuit that computes the QFT on three qubits.
Args:
basis_id (int): An integer value identifying the basis state to construct.
Returns:
array[complex]: The state of the qubits after the QFT operation.
"""
# Prepare the basis state |basis_id>
bits = [int(x) for x in np.binary_repr(basis_id, width=dev.num_wires)]
qml.BasisStatePreparation(bits, wires=[0, 1, 2])
##################
# YOUR CODE HERE #
##################
for i in range(3):
# j=i+1
# print("test1")
qml.Hadamard(wires=i)
for jj in range(i+1,3,1):
# print("test2")
# k = (1/(2**(jj)))*(np.pi)*(complex(0,1))
# U = np.array([[1,0], [0, np.exp(k)]])
# qml.ctrl(qml.QubitUnitary(U, wires=i), control=jj)
# Below lines of code give the same result as the above one
k = (1/(2**(jj)))*(np.pi)
qml.ctrl(qml.PhaseShift(k, wires=i), control = jj)
qml.SWAP(wires=[0,2])
return qml.state()
print(qml.draw(three_qubit_QFT)(3))
dev = qml.device('default.qubit', wires=4)
def swap_bits(n_qubits):
"""A circuit that reverses the order of qubits, i.e.,
performs a SWAP such that [q1, q2, ..., qn] -> [qn, ... q2, q1].
Args:
n_qubits (int): An integer value identifying the number of qubits.
"""
##################
# YOUR CODE HERE #
##################
# if n%2==0:
# j =
for i in range(int(n_qubits/2)):
qml.SWAP(wires=[i,n_qubits-1-i])
# pass
@qml.qnode(dev)
def qft_node(basis_id, n_qubits):
# Prepare the basis state |basis_id>
bits = [int(x) for x in np.binary_repr(basis_id, width=n_qubits)]
qml.BasisStatePreparation(bits, wires=range(n_qubits))
# qft_rotations(n_qubits)
swap_bits(n_qubits)
return qml.state()
dev = qml.device('default.qubit', wires=4)
# @qml.qnode(dev)
def qft_rotations(n_qubits):
"""A circuit performs the QFT rotations on the specified qubits.
Args:
n_qubits (int): An integer value identifying the number of qubits.
"""
##################
# YOUR CODE HERE #
##################
n = n_qubits
for i in range(n):
# j=i+1
# print("test1")
qml.Hadamard(wires=i)
for jj in range(i+1,n,1):
# print("test2")
qml.ControlledPhaseShift(np.pi/(2**(jj-i)), wires=[jj,i])
pass
@qml.qnode(dev)
def qft_node(basis_id, n_qubits):
# Prepare the basis state |basis_id>
bits = [int(x) for x in np.binary_repr(basis_id, width=n_qubits)]
qml.BasisStatePreparation(bits, wires=range(n_qubits))
qft_rotations(n_qubits)
swap_bits(n_qubits)
return qml.state()
# print(qml.draw(qft_rotations)(3))
print(qml.draw(qft_node)(3,3))
dev = qml.device('default.qubit', wires=4)
def qft_recursive_rotations(n_qubits, wire=0):
"""A circuit that performs the QFT rotations on the specified qubits
recursively.
Args:
n_qubits (int): An integer value identifying the number of qubits.
wire (int): An integer identifying the wire
(or the qubit) to apply rotations on.
"""
##################
# YOUR CODE HERE #
##################
i = wire
if i == n_qubits-1:
qml.Hadamard(wires=i)
# for i in range(n_qubits):
# qml.Hadamard(wires=i)
# if n_qubits!=i:
else:
qml.Hadamard(wires=i)
for j in range(i+1, n_qubits, 1):
qml.ControlledPhaseShift(np.pi/(2**(j-i)), wires=[j,i])
qft_recursive_rotations(n_qubits, i+1)
pass
@qml.qnode(dev)
def qft_node(basis_id, n_qubits):
# Prepare the basis state |basis_id>
bits = [int(x) for x in np.binary_repr(basis_id, width=n_qubits)]
qml.BasisStatePreparation(bits, wires=range(n_qubits))
qft_recursive_rotations(n_qubits)
swap_bits(n_qubits)
return qml.state()
print(qml.draw(qft_node)(3,3))
|
https://github.com/JessicaJohnBritto/Quantum-Computing-and-Information
|
JessicaJohnBritto
|
pip install pennylane
import pennylane as qml
from pennylane import numpy as np
import matplotlib.pyplot as plt
dev = qml.device('default.qubit', wires=3)
@qml.qnode(dev)
def make_basis_state(basis_id):
"""Produce the 3-qubit basis state corresponding to |basis_id>.
Note that the system starts in |000>.
Args:
basis_id (int): An integer value identifying the basis state to construct.
Returns:
array[complex]: The computational basis state |basis_id>.
"""
##################
# YOUR CODE HERE #
##################
# CREATE THE BASIS STATE
k = np.binary_repr(basis_id, width = 3)
l = [int(x) for x in k]
print(l)
print(np.arange(3))
qml.BasisStatePreparation(l, wires=range(3))
return qml.state()
basis_id = 3
print(f"Output state = {make_basis_state(basis_id)}")
# Creates a device with *two* qubits
dev = qml.device('default.qubit', wires=2)
@qml.qnode(dev)
def two_qubit_circuit():
##################
# YOUR CODE HERE #
##################
# PREPARE |+>|1>
qml.Hadamard(wires=0)
qml.PauliX(wires=1)
# RETURN TWO EXPECTATION VALUES, Y ON FIRST QUBIT, Z ON SECOND QUBIT
k = qml.expval(qml.PauliY(wires=0))
m = qml.expval(qml.PauliZ(wires=1))
l = [k,m]
return l
print(two_qubit_circuit())
dev = qml.device("default.qubit", wires=2)
@qml.qnode(dev)
def create_one_minus():
##################
# YOUR CODE HERE #
##################
# PREPARE |1>|->
qml.PauliX(wires=0)
qml.PauliX(wires=1)
qml.Hadamard(wires=1)
# RETURN A SINGLE EXPECTATION VALUE Z \otimes X
return qml.expval(qml.PauliZ(0)@qml.PauliX(1))
print(create_one_minus())
dev = qml.device('default.qubit', wires=2)
@qml.qnode(dev)
def circuit_1(theta):
"""Implement the circuit and measure Z I and I Z.
Args:
theta (float): a rotation angle.
Returns:
float, float: The expectation values of the observables Z I, and I Z
"""
##################
# YOUR CODE HERE #
##################
qml.RX(theta, wires=0)
qml.RY(2*theta, wires=1)
return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1))
@qml.qnode(dev)
def circuit_2(theta):
"""Implement the circuit and measure Z Z.
Args:
theta (float): a rotation angle.
Returns:
float: The expectation value of the observable Z Z
"""
##################
# YOUR CODE HERE #
##################
qml.RX(theta, wires=0)
qml.RY(2*theta, wires=1)
return qml.expval(qml.PauliZ(0) @qml.PauliZ(1))
def zi_iz_combination(ZI_results, IZ_results):
"""Implement a function that acts on the ZI and IZ results to
produce the ZZ results. How do you think they should combine?
Args:
ZI_results (array[float]): Results from the expectation value of
ZI in circuit_1.
IZ_results (array[float]): Results from the expectation value of
IZ in circuit_2.
Returns:
array[float]: A combination of ZI_results and IZ_results that
produces results equivalent to measuring ZZ.
"""
combined_results = np.zeros(len(ZI_results))
##################
# YOUR CODE HERE #
##################
return ZI_results*IZ_results
theta = np.linspace(0, 2 * np.pi, 100)
# Run circuit 1, and process the results
circuit_1_results = np.array([circuit_1(t) for t in theta])
ZI_results = circuit_1_results[:, 0]
IZ_results = circuit_1_results[:, 1]
combined_results = zi_iz_combination(ZI_results, IZ_results)
# Run circuit 2
ZZ_results = np.array([circuit_2(t) for t in theta])
# Plot your results
plot = plotter(theta, ZI_results, IZ_results, ZZ_results, combined_results)
dev = qml.device('default.qubit', wires=2)
@qml.qnode(dev)
def apply_cnot(basis_id):
"""Apply a CNOT to |basis_id>.
Args:
basis_id (int): An integer value identifying the basis state to construct.
Returns:
array[complex]: The resulting state after applying CNOT|basis_id>.
"""
# Prepare the basis state |basis_id>
bits = [int(x) for x in np.binary_repr(basis_id, width=dev.num_wires)]
qml.BasisStatePreparation(bits, wires=[0, 1])
##################
# YOUR CODE HERE #
##################
# APPLY THE CNOT
qml.CNOT(wires=[0,1])
return qml.state()
##################
# YOUR CODE HERE #
##################
# REPLACE THE BIT STRINGS VALUES BELOW WITH THE CORRECT ONES
cnot_truth_table = {
"00" : "00",
"01" : "01",
"10" : "11",
"11" : "10"
}
# Run your QNode with various inputs to help fill in your truth table
# for k in cnot_truth_table:
for k in range(4):
print(apply_cnot(k))
dev = qml.device("default.qubit", wires=2)
@qml.qnode(dev)
def apply_h_cnot():
##################
# YOUR CODE HERE #
##################
# APPLY THE OPERATIONS IN THE CIRCUIT
qml.Hadamard(wires=0)
qml.CNOT(wires=[0,1])
return qml.state()
print(apply_h_cnot())
##################
# YOUR CODE HERE #
##################
# SET THIS AS 'separable' OR 'entangled' BASED ON YOUR OUTCOME
state_status = "entangled"
dev = qml.device('default.qubit', wires=3)
@qml.qnode(dev)
def controlled_rotations(theta, phi, omega):
"""Implement the circuit above and return measurement outcome probabilities.
Args:
theta (float): A rotation angle
phi (float): A rotation angle
omega (float): A rotation angle
Returns:
array[float]: Measurement outcome probabilities of the 3-qubit
computational basis states.
"""
qml.Hadamard(wires=0)
qml.CRX(theta, wires=[0,1])
qml.CRY(phi, wires=[1,2])
qml.CRZ(omega, wires=[2,0])
##################
# YOUR CODE HERE #
##################
# APPLY THE OPERATIONS IN THE CIRCUIT AND RETURN MEASUREMENT PROBABILITIES
return qml.probs(wires=[0,1,2])
theta, phi, omega = 0.1, 0.2, 0.3
print(controlled_rotations(theta, phi, omega))
dev = qml.device("default.qubit", wires=2)
# Prepare a two-qubit state; change up the angles if you like
phi, theta, omega = 1.2, 2.3, 3.4
@qml.qnode(device=dev)
def true_cz(phi, theta, omega):
prepare_states(phi, theta, omega)
##################
# YOUR CODE HERE #
##################
# IMPLEMENT THE REGULAR CZ GATE HERE
qml.CZ(wires=[0,1])
return qml.state()
@qml.qnode(dev)
def imposter_cz(phi, theta, omega):
prepare_states(phi, theta, omega)
# qml.Hadamard(wires=0)
qml.Hadamard(wires=1)
qml.CNOT(wires=[0,1])
qml.Hadamard(wires=1)
# qml.Hadamard(wires=0)
##################
# YOUR CODE HERE #
##################
# IMPLEMENT CZ USING ONLY H AND CNOT
return qml.state()
print(f"True CZ output state {true_cz(phi, theta, omega)}")
print(f"Imposter CZ output state {imposter_cz(phi, theta, omega)}")
dev = qml.device("default.qubit", wires=2)
# Prepare a two-qubit state; change up the angles if you like
phi, theta, omega = 1.2, 2.3, 3.4
@qml.qnode(dev)
def apply_swap(phi, theta, omega):
prepare_states(phi, theta, omega)
##################
# YOUR CODE HERE #
##################
# IMPLEMENT THE REGULAR SWAP GATE HERE
qml.SWAP(wires=[0,1])
return qml.state()
@qml.qnode(dev)
def apply_swap_with_cnots(phi, theta, omega):
prepare_states(phi, theta, omega)
##################
# YOUR CODE HERE #
##################
qml.CNOT(wires=[0,1])
qml.CNOT(wires=[1,0])
qml.CNOT(wires=[0,1])
# IMPLEMENT THE SWAP GATE USING A SEQUENCE OF CNOTS
return qml.state()
print(f"Regular SWAP state = {apply_swap(phi, theta, omega)}")
print(f"CNOT SWAP state = {apply_swap_with_cnots(phi, theta, omega)}")
dev = qml.device("default.qubit", wires=3)
# Prepare first qubit in |1>, and arbitrary states on the second two qubits
phi, theta, omega = 1.2, 2.3, 3.4
# A helper function just so you can visualize the initial state
# before the controlled SWAP occurs.
@qml.qnode(dev)
def no_swap(phi, theta, omega):
prepare_states(phi, theta, omega)
return qml.state()
@qml.qnode(dev)
def controlled_swap(phi, theta, omega):
prepare_states(phi, theta, omega)
##################
# YOUR CODE HERE #
##################
# PERFORM A CONTROLLED SWAP USING A SEQUENCE OF TOFFOLIS
qml.Toffoli(wires=[0, 1, 2])
qml.Toffoli(wires=[0, 2, 1])
qml.Toffoli(wires=[0, 1, 2])
# qml.Toffoli(wires=[control1, control2, target])
return qml.state()
print(no_swap(phi, theta, omega))
print(controlled_swap(phi, theta, omega))
|
https://github.com/JessicaJohnBritto/Quantum-Computing-and-Information
|
JessicaJohnBritto
|
import pennylane as qml
from pennylane import numpy as np
import matplotlib.pyplot as plt
dev = qml.device("default.qubit", wires=1)
@qml.qnode(dev)
def apply_z_to_plus():
"""Write a circuit that applies PauliZ to the |+> state and returns
the state.
Returns:
array[complex]: The state of the qubit after the operations.
"""
##################
# YOUR CODE HERE #
##################
# CREATE THE |+> STATE
qml.Hadamard(wires=0)
# APPLY PAULI Z
qml.PauliZ(wires=0)
# RETURN THE STATE
return qml.state()
print(apply_z_to_plus())
dev = qml.device("default.qubit", wires=1)
@qml.qnode(dev)
def fake_z():
"""Use RZ to produce the same action as Pauli Z on the |+> state.
Returns:
array[complex]: The state of the qubit after the operations.
"""
##################
# YOUR CODE HERE #
##################
# CREATE THE |+> STATE
qml.Hadamard(wires=0)
# APPLY RZ
qml.RZ(np.pi, wires=0)
# RETURN THE STATE
return qml.state()
dev = qml.device("default.qubit", wires=1)
@qml.qnode(dev)
def many_rotations():
"""Implement the circuit depicted above and return the quantum state.
Returns:
array[complex]: The state of the qubit after the operations.
"""
##################
# YOUR CODE HERE #
##################
# IMPLEMENT THE CIRCUIT
qml.Hadamard(wires=0)
qml.S(wires=0)
qml.adjoint(qml.T)(wires=0)
qml.RZ(0.3, wires=0)
qml.adjoint(qml.S)(wires=0)
# RETURN THE STATE
return qml.state()
dev = qml.device('default.qubit', wires=3)
@qml.qnode(dev)
def too_many_ts():
"""You can implement the original circuit here as well, it may help you with
testing to ensure that the circuits have the same effect.
Returns:
array[float]: The measurement outcome probabilities.
"""
# qml.Hadamard(wires=[0,1,2])
qml.Hadamard(wires=0)
qml.Hadamard(wires=1)
qml.Hadamard(wires=2)
qml.T(wires=[0,1])
qml.adjoint(qml.T)(wires=2)
qml.T(wires=0)
# qml.Hadamard(wires=[0,1,2])
qml.Hadamard(wires=0)
qml.Hadamard(wires=1)
qml.Hadamard(wires=2)
qml.adjoint(qml.T)(wires=0)
qml.T(wires=1)
qml.adjoint(qml.T)(wires=2)
qml.adjoint(qml.T)(wires=0)
qml.T(wires=1)
qml.adjoint(qml.T)(wires=2)
qml.T(wires=1)
qml.adjoint(qml.T)(wires=2)
qml.T(wires=1)
# qml.Hadamard(wires=[0,1,2])
qml.Hadamard(wires=0)
qml.Hadamard(wires=1)
qml.Hadamard(wires=2)
return qml.probs(wires=[0, 1, 2])
@qml.qnode(dev)
def just_enough_ts():
"""Implement an equivalent circuit as the above with the minimum number of
T and T^\dagger gates required.
Returns:
array[float]: The measurement outcome probabilities.
"""
##################
# YOUR CODE HERE #
##################
qml.Hadamard(wires=0)
qml.Hadamard(wires=1)
qml.Hadamard(wires=2)
qml.S(wires=0)
qml.T(wires=1)
qml.adjoint(qml.T)(wires=2)
# qml.T(wires=0)
# qml.Hadamard(wires=[0,1,2])
qml.Hadamard(wires=0)
qml.Hadamard(wires=1)
qml.Hadamard(wires=2)
qml.adjoint(qml.S)(wires=0)
qml.S(wires=1)
qml.adjoint(qml.S)(wires=2)
# qml.adjoint(qml.T)(wires=0)
# qml.T(wires=1)
# qml.adjoint(qml.T)(wires=2)
qml.S(wires=1)
qml.adjoint(qml.T)(wires=2)
# qml.T(wires=1)
# qml.Hadamard(wires=[0,1,2])
qml.Hadamard(wires=0)
qml.Hadamard(wires=1)
qml.Hadamard(wires=2)
# IMPLEMENT THE CIRCUIT, BUT COMBINE AND OPTIMIZE THE GATES
# TO MINIMIZE THE NUMBER OF TS
return qml.probs(wires=[0, 1, 2])
##################
# YOUR CODE HERE #
##################
# FILL IN THE CORRECT VALUES FOR THE ORIGINAL CIRCUIT
original_depth = 8
original_t_count = 13
original_t_depth = 6
# FILL IN THE CORRECT VALUES FOR THE NEW, OPTIMIZED CIRCUIT
optimal_depth = 6
optimal_t_count = 3
optimal_t_depth = 2
dev = qml.device("default.qubit", wires=1)
##################
# YOUR CODE HERE #
##################
# ADJUST THE VALUES OF PHI, THETA, AND OMEGA
phi, theta, omega = np.pi/2, np.pi/2, np.pi/2
@qml.qnode(dev)
def hadamard_with_rz_rx():
qml.RZ(phi, wires=0)
qml.RX(theta, wires=0)
qml.RZ(omega, wires=0)
return qml.state()
dev = qml.device("default.qubit", wires=1)
@qml.qnode(dev)
def convert_to_rz_rx():
##################
# YOUR CODE HERE #
##################
# IMPLEMENT THE CIRCUIT IN THE PICTURE USING ONLY RZ AND RX
qml.RZ(np.pi/2, wires=0)
qml.RX(np.pi/2, wires=0)
qml.RZ(np.pi/2, wires=0)
qml.RZ(np.pi/2,wires=0)
qml.RZ(np.pi, wires=0)
qml.RZ(np.pi/2, wires=0)
qml.RZ(np.pi/4, wires=0)
qml.RZ(np.pi/2,wires=0)
qml.RX(np.pi, wires=0)
qml.RZ(np.pi, wires=0)
qml.RZ(np.pi/2, wires=0)
return qml.state()
dev = qml.device("default.qubit", wires=1)
@qml.qnode(dev)
def unitary_with_h_and_t():
##################
# YOUR CODE HERE #
##################
# APPLY ONLY H AND T TO PRODUCE A CIRCUIT THAT EFFECTS THE GIVEN MATRIX
# qml.T(wires=0)
qml.Hadamard(wires=0)
qml.T(wires=0)
qml.Hadamard(wires=0)
qml.T(wires=0)
qml.T(wires=0)
qml.Hadamard(wires=0)
# qml.T(wires=0)
return qml.state()
|
https://github.com/JessicaJohnBritto/Quantum-Computing-and-Information
|
JessicaJohnBritto
|
import pennylane as qml
from pennylane import numpy as np
import matplotlib.pyplot as plt
dev = qml.device("default.qubit", wires=1)
@qml.qnode(dev)
def prepare_state():
##################
# YOUR CODE HERE #
##################
# APPLY OPERATIONS TO PREPARE THE TARGET STATE
qml.Hadamard(wires=0)
qml.PauliZ(wires=0)
qml.T(wires=0)
return qml.state()
dev = qml.device("default.qubit", wires=1)
@qml.qnode(dev)
def prepare_state():
##################
# YOUR CODE HERE #
##################
# APPLY OPERATIONS TO PREPARE THE TARGET STATE
qml.RX((np.pi)/3, wires=0)
return qml.state()
v = np.array([0.52889389-0.14956775j, 0.67262317+0.49545818j])
##################
# YOUR CODE HERE #
##################
# CREATE A DEVICE
dev = qml.device("default.qubit", wires=1)
# CONSTRUCT A QNODE THAT USES qml.MottonenStatePreparation
# TO PREPARE A QUBIT IN STATE V, AND RETURN THE STATE
@qml.qnode(dev)
def prepare_state(state=v):
qml.MottonenStatePreparation(state, wires=0)
return qml.state()
# This will draw the quantum circuit and allow you to inspect the output gates
print(prepare_state(v))
print()
print(qml.draw(prepare_state)(v))
dev = qml.device("default.qubit", wires=1)
@qml.qnode(dev)
def apply_h_and_measure(state):
"""Complete the function such that we apply the Hadamard gate
and measure in the computational basis.
Args:
state (int): Either 0 or 1. If 1, prepare the qubit in state |1>,
otherwise leave it in state 0.
Returns:
array[float]: The measurement outcome probabilities.
"""
if state == 1:
qml.PauliX(wires=0)
##################
# YOUR CODE HERE #
##################
# APPLY HADAMARD AND MEASURE
qml.Hadamard(wires=0)
return qml.probs(wires=[0])
print(apply_h_and_measure(0))
print(apply_h_and_measure(1))
##################
# YOUR CODE HERE #
##################
# WRITE A QUANTUM FUNCTION THAT PREPARES (1/2)|0> + i(sqrt(3)/2)|1>
def prepare_psi():
qml.RX(4*(np.pi)/3, wires=0)
# return qml.probs(wires=[0])
# pass
# return qml.state()
# WRITE A QUANTUM FUNCTION THAT SENDS BOTH |0> TO |y_+> and |1> TO |y_->
def y_basis_rotation():
# qml.RX(3*(np.pi)/2, wires=0)
qml.Hadamard(wires=0)
qml.S(wires=0)
dev = qml.device("default.qubit", wires=1)
@qml.qnode(dev)
def measure_in_y_basis():
##################
# YOUR CODE HERE #
##################
# PREPARE THE STATE
prepare_psi()
# PERFORM THE ROTATION BACK TO COMPUTATIONAL BASIS
qml.adjoint(y_basis_rotation)()
# RETURN THE MEASUREMENT OUTCOME PROBABILITIES
return qml.probs(wires=[0])
print(measure_in_y_basis())
dev = qml.device('default.qubit', wires=1)
@qml.qnode(dev)
def circuit():
##################
# YOUR CODE HERE #
##################
qml.RX(np.pi/4, wires=0)
qml.Hadamard(wires=0)
qml.PauliZ(wires=0)
# IMPLEMENT THE CIRCUIT IN THE PICTURE AND MEASURE PAULI Y
return qml.expval(qml.PauliY(0))
print(circuit())
# An array to store your results
shot_results = []
# dev = qml.device('default.qubit', wires=1)
# @qml.qnode(dev)
def circuit():
##################
# YOUR CODE HERE #
##################
qml.RX(np.pi/4, wires=0)
qml.Hadamard(wires=0)
qml.PauliZ(wires=0)
# IMPLEMENT THE CIRCUIT IN THE PICTURE AND MEASURE PAULI Y
return qml.expval(qml.PauliY(0))
# Different numbers of shots
shot_values = [100, 1000, 10000, 100000, 1000000]
for shots in shot_values:
##################
# YOUR CODE HERE #
##################
# CREATE A DEVICE, CREATE A QNODE, AND RUN IT
dev = qml.device('default.qubit', wires=1, shots=shots)
# @qml.qnode(dev)
qnode = qml.QNode(circuit, dev)
# def circu():
shot_results.append(qnode())
# STORE RESULT IN SHOT_RESULTS ARRAY
print(qml.math.unwrap(shot_results))
dev = qml.device("default.qubit", wires=1, shots=100000)
@qml.qnode(dev)
def circuit():
qml.RX(np.pi/4, wires=0)
qml.Hadamard(wires=0)
qml.PauliZ(wires=0)
##################
# YOUR CODE HERE #
##################
# RETURN THE MEASUREMENT SAMPLES OF THE CORRECT OBSERVABLE
return qml.sample(qml.PauliY(wires=0))
def compute_expval_from_samples(samples):
"""Compute the expectation value of an observable given a set of
sample outputs. You can assume that there are two possible outcomes,
1 and -1.
Args:
samples (array[float]): 100000 samples representing the results of
running the above circuit.
Returns:
float: the expectation value computed based on samples.
"""
estimated_expval = 0
##################
# YOUR CODE HERE #
##################
k = np.array(samples)
estimated_expval = np.average(k)
# USE THE SAMPLES TO ESTIMATE THE EXPECTATION VALUE
return estimated_expval
samples = circuit()
print(compute_expval_from_samples(samples))
def variance_experiment(n_shots):
"""Run an experiment to determine the variance in an expectation
value computed with a given number of shots.
Args:
n_shots (int): The number of shots
Returns:
float: The variance in expectation value we obtain running the
circuit 100 times with n_shots shots each.
"""
# To obtain a variance, we run the circuit multiple times at each shot value.
n_trials = 100
##################
# YOUR CODE HERE #
##################
samples = []
# CREATE A DEVICE WITH GIVEN NUMBER OF SHOTS
dev = qml.device('default.qubit', wires=1, shots = n_shots)
# qnode = qml.QNode(circuit, dev)
# DECORATE THE CIRCUIT BELOW TO CREATE A QNODE
@qml.qnode(dev)
def circuit():
qml.Hadamard(wires=0)
return qml.expval(qml.PauliZ(wires=0))
# qnode = qml.QNode(circuit, dev, shots = n_shots)
# RUN THE QNODE N_TRIALS TIMES AND RETURN THE VARIANCE OF THE RESULTS
for i in range(n_trials):
sample = circuit()
samples.append(sample)
k = np.var(np.array(samples))
return k
def variance_scaling(n_shots):
"""Once you have determined how the variance in expectation value scales
with the number of shots, complete this function to programmatically
represent the relationship.
Args:
n_shots (int): The number of shots
Returns:
float: The variance in expectation value we expect to see when we run
an experiment with n_shots shots.
"""
estimated_variance = 0
sample=[]
##################
# YOUR CODE HERE #
##################
# ESTIMATE THE VARIANCE BASED ON SHOT NUMBER
# for i in range(n_shots):
# if i != 0:
# sample.append(1/i)
# estimated_variance = np.var(np.array(sample))
return 1/n_shots
# Various numbers of shots; you can change this
shot_vals = [10, 20, 40, 100, 200, 400, 1000, 2000, 4000]
# Used to plot your results
results_experiment = [variance_experiment(shots) for shots in shot_vals]
results_scaling = [variance_scaling(shots) for shots in shot_vals]
plot = plotter(shot_vals, results_experiment, results_scaling)
|
https://github.com/JessicaJohnBritto/Quantum-Computing-and-Information
|
JessicaJohnBritto
|
import pennylane as qml
from pennylane import numpy as np
# Basis State preparation
def state_preparation(basis_id, n_qubits):
bits = [int(x) for x in np.binary_repr(basis_id, width=n_qubits)]
return qml.BasisStatePreparation(bits, wires=range(n_qubits))
#Testing
state_preparation(3,5)
# Swappping of quantum circuits
def swap_bits(n_qubits):
"""A circuit that reverses the order of qubits, i.e.,
performs a SWAP such that [q1, q2, ..., qn] -> [qn, ... q2, q1].
Args:
n_qubits (int): An integer value identifying the number of qubits.
"""
for i in range(int(n_qubits/2)):
qml.SWAP(wires=[i,n_qubits-1-i])
# Conditional Rotation matrix
def qft_rotations(n_qubits):
"""A circuit performs the QFT rotations on the specified qubits.
Args:
n_qubits (int): An integer value identifying the number of qubits.
"""
n = n_qubits
for i in range(n):
qml.Hadamard(wires=i)
for jj in range(i+1,n,1):
qml.ControlledPhaseShift(np.pi/(2**(jj-i)), wires=[jj,i])
pass
def qft_node(basis_id, basis_id2, n_qubits):
''' A circuit performs addition of two numbers
Args:
basis_id (int): An integer value specifying the first number to be added.
basis_id2 (int): An integer value specifying the second number to be added.
n_qubits (int): An integer value identifying the number of qubits.
'''
# Prepare the basis state |basis_id>
bits = [int(x) for x in np.binary_repr(basis_id, width=n_qubits)]
qml.BasisStatePreparation(bits, wires=range(n_qubits))
bits2 = [int(x) for x in np.binary_repr(basis_id2, width=n_qubits)]
qml.BasisStatePreparation(bits2, wires=range(n_qubits, 2*(n_qubits),1))
qft_rotations(n_qubits)
for i in range(0,n_qubits,1):
k=0
for j in range(i+n_qubits,(2*n_qubits),1):
qml.ControlledPhaseShift((np.pi/(2**(k))), wires=[j,i])
k+=1
(qml.adjoint)(qft_rotations)(n_qubits)
return qml.sample(wires=[x for x in range(n_qubits)])
# basis_id stores a, basis_id2 stores b
basis_id = int(input("Enter number a: "))
basis_id2 = int(input("Enter number b: "))
if len(np.binary_repr(basis_id))>len(np.binary_repr(basis_id2)):
n_qubits = len(np.binary_repr(basis_id)) + 1
else:
n_qubits = len(np.binary_repr(basis_id2)) + 1
dev = qml.device('default.qubit', wires=(2*n_qubits), shots=10)
qnode = qml.QNode(qft_node, dev)
k = qnode(basis_id, basis_id2, n_qubits)
poww, summ = 0, 0
for l in reversed(k[0]):
summ = summ + (2**poww)*l
poww+=1
print(summ)
def multiplier(basis_id, basis_id2, n_qubits):
''' A circuit performs multiplication of two numbers
Args:
basis_id (int): An integer value specifying the first number to be multiplied.
basis_id2 (int): An integer value specifying the second number to be multiplied.
n_qubits (int): An integer value identifying the number of qubits.
'''
# Basis state preparation for 0, a, b respectively
bits1 = [int(x) for x in np.binary_repr(0, width=2*n_qubits)]
qml.BasisStatePreparation(bits1, wires=range(2*(n_qubits)))
bits2 = [int(x) for x in np.binary_repr(basis_id, width=n_qubits)]
qml.BasisStatePreparation(bits2, wires=range(2*n_qubits, 3*n_qubits))
bits3 = [int(x) for x in np.binary_repr(basis_id2, width=n_qubits)]
qml.BasisStatePreparation(bits3, wires=range(3*n_qubits, 4*(n_qubits),1))
# Applying QFT on first 2*n_qubits as they store the basis state for |0>
qft_rotations(2*n_qubits)
# Applying Conditional Rotation operator with controls a_j and b_m and target as |0>
for i in range(3*n_qubits, 4*n_qubits,1):
for j in range(2*n_qubits, 3*n_qubits,1):
for m in range(2*n_qubits):
qml.ctrl(qml.PhaseShift(np.pi/(2**(-(5*n_qubits)-m+j+i+1)), wires=m),control=[j,i])
# Applying inverse QFT 2*n_qubits
(qml.adjoint)(qft_rotations)(2*n_qubits)
return qml.sample(wires=[x for x in range(2*n_qubits)])
# basis_id stores a, basis_id2 stores b
basis_id = int(input("Enter number a: "))
basis_id2 = int(input("Enter number b: "))
# n_qubits takes the value of the number whose binary representation is the greatest among the two
if len(np.binary_repr(basis_id))>len(np.binary_repr(basis_id2)):
n_qubits = len(np.binary_repr(basis_id))
else:
n_qubits = len(np.binary_repr(basis_id2))
# Creating QNode
dev = qml.device('default.qubit', wires=(4*n_qubits), shots=10)
qnode = qml.QNode(multiplier, dev)
# Below code returns the sample containing measurements on the wires
# print(qnode(basis_id,basis_id2,n_qubits))
# Below prints quantum circuit
# print(qml.draw(qnode)(basis_id,basis_id2,n_qubits))
# k stores the sample of measurement values on each wire
k = qnode(basis_id, basis_id2, n_qubits)
# Converting k[0] to integer value
# Considering only k[0] as all elements of the sample are identical
poww, summ = 0, 0
for l in reversed(k[0]):
summ = summ + (2**poww)*l
poww+=1
print(summ)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.