repo
stringclasses 900
values | file
stringclasses 754
values | content
stringlengths 4
215k
|
|---|---|---|
https://github.com/Seanaventure/HighErrorRateRouting
|
Seanaventure
|
import matplotlib.pyplot as plt
import networkx as nx
import qiskit
import HERR
from qiskit.transpiler import CouplingMap
from qiskit.transpiler.passes.routing import BasicSwap
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.dagcircuit import DAGCircuit
from qiskit.converters import circuit_to_dag
from qiskit.converters import dag_to_circuit
from math import pi
from qiskit.compiler import transpile, assemble
from qiskit.providers.aer.noise import NoiseModel
import qiskit.providers.aer.noise as noise
from qiskit.tools.visualization import dag_drawer
import random
from qiskit.circuit.instruction import Instruction
# This function can be use to count the number of CNOT gates. Useful for debugging
def countTwoQubitGates(transpiledCircuit):
num = 0
for gate in transpiledCircuit.data:
# print(type(gate[0]))
if issubclass(type(gate[0]), Instruction):
if gate[0].name == "cx":
num += 1
return num
"""
For the Berentien Varanzi algorithm we need a secret string and make a circuit around it. All this was taken from qiskit
https://qiskit.org/textbook/ch-algorithms/bernstein-vazirani.html
"""
s = '1101'
n = len(s)
circuit = QuantumCircuit(8, n)
# Step 0
circuit.x(n) # the n+1 qubits are indexed 0...n, so the last qubit is index n
circuit.barrier() # just a visual aid for now
# Step 1
# range(n+1) returns [0,1,2,...,n] in Python. This covers all the qubits
circuit.h(range(n+1))
circuit.barrier() # just a visual aid for now
# Step 2
for ii, yesno in enumerate(reversed(s)):
if yesno == '1':
circuit.cx(ii, n)
circuit.barrier() # just a visual aid for now
# Step 3
# range(n+1) returns [0,1,2,...,n] in Python. This covers all the qubits
circuit.h(range(n+1))
circuit.barrier() # just a visual aid for now
# measure the qubits indexed from 0 to n-1 and store them into the classical bits indexed 0 to n-
circuit.measure(range(n), range(n))
provider = IBMQ.load_account()
backend = provider.get_backend('ibmq_lima')
# To compile the circuit we need the basis gates. Just take one from a random backend
basis_gates = backend.configuration().basis_gates
# TO make the coupling maps we annoyingly need to make a list specifying each connection
squareCouplingList = list()
for i in range(4):
for j in range(4):
if i is not j:
if abs(i-j) == 1:
squareCouplingList.append([i, j])
squareCouplingList.append(([0, 3]))
squareCouplingList.append(([3, 0]))
squareCouplingMap = CouplingMap(squareCouplingList)
gridCouplingList = list()
for i in range(4):
for j in range(4):
if i is not j:
if abs(i-j) == 1:
gridCouplingList.append([i, j])
for i in range(4,8):
for j in range(4,8):
if i is not j:
if abs(i-j) == 1:
gridCouplingList.append([i, j])
gridCouplingList.append(([0, 4]))
gridCouplingList.append(([4, 0]))
gridCouplingList.append(([1, 5]))
gridCouplingList.append(([5, 1]))
gridCouplingList.append(([2, 6]))
gridCouplingList.append(([6, 2]))
gridCouplingList.append(([3, 7]))
gridCouplingList.append(([7, 3]))
gridCouplingMap = CouplingMap(gridCouplingList)
jakatraCouplingList = [[0, 1], [1, 0], [1, 2], [2, 1], [1, 3], [3, 1], [3,5], [5,3], [4,5], [5,4], [6,5], [5,6]]
jakatraCouplingMap = CouplingMap(jakatraCouplingList)
# We need to translate the circuit to a DAG to run it
circDag = circuit_to_dag(circuit)
transpiledBasic = transpile(circuit, Aer.get_backend('qasm_simulator'),
coupling_map=gridCouplingMap,
basis_gates=basis_gates,
routing_method='basic',
layout_method='trivial')
transpiledSabre = transpile(circuit, Aer.get_backend('qasm_simulator'),
coupling_map=gridCouplingMap,
basis_gates=basis_gates,
routing_method='sabre',
layout_method='trivial')
transpiledStochastic = transpile(circuit, Aer.get_backend('qasm_simulator'),
coupling_map=gridCouplingMap,
basis_gates=basis_gates,
routing_method='stochastic',
layout_method='trivial')
transpiledLookahead = transpile(circuit, Aer.get_backend('qasm_simulator'),
coupling_map=gridCouplingMap,
basis_gates=basis_gates,
routing_method='lookahead',
layout_method='trivial')
for i in range(200):
# Create a noise model for the simulations
noise_model = noise.NoiseModel()
errorRates = list()
qiskitErrors = list()
# Assemble the noise graph. This is a graph that represents the noise of each link. Nodes are qubits and edges are the corresponding link
for i in range(len(gridCouplingList)//2):
# Generate a random error for each link from 1-10%
errorRates.append(random.randrange(1, 10, 1)/100.0)
qiskitErrors.append(noise.depolarizing_error(errorRates[i], 2))
edges = gridCouplingMap.get_edges()
uniqueEdges = set()
for edge in edges:
uniqueEdges.add(tuple(sorted(edge)))
noiseGraph = nx.Graph()
noiseGraph.add_nodes_from([0, 7])
# Add quantum error for a randomly generated noise value
errorIdex = 0
for edge in uniqueEdges:
noise_model.add_quantum_error(qiskitErrors[errorIdex], ['cx'], edge)
noiseGraph.add_edge(edge[0], edge[1], weight=1-errorRates[errorIdex])
errorIdex += 1
herr = HERR.HERR(gridCouplingMap, noiseGraph)
basSwap = BasicSwap(gridCouplingMap)
# Run HERR
HERRRes = herr.run(circDag)
updatedCirc = dag_to_circuit(HERRRes)
# We ran HERR, but we need to do the rest of the transpiling process to get it ready for hardware
transpiledHERR = transpile(updatedCirc, Aer.get_backend('qasm_simulator'),
coupling_map=gridCouplingMap,
basis_gates=basis_gates,
routing_method='basic',
layout_method='trivial')
sim = Aer.get_backend('qasm_simulator')
# Run all the compiled circuits
simResultHERR = sim.run(transpiledHERR, noise_model=noise_model).result()
simResultBasic = sim.run(transpiledBasic, noise_model=noise_model).result()
simResultSabre = sim.run(transpiledSabre, noise_model=noise_model).result()
simResultLookahead = sim.run(transpiledLookahead, noise_model=noise_model).result()
simResultStochastic = sim.run(transpiledStochastic, noise_model=noise_model).result()
# Output file and print results
fName = "HERRQFTCouplingOutputs/HERRCirc" + str(i) + ".png"
fName2 = "HERRQFTCouplingOutputs/NonCirc" + str(i) + ".png"
if s in simResultHERR.get_counts() and s in simResultBasic.get_counts() and s in simResultSabre.get_counts() and s in simResultLookahead.get_counts() and s in simResultStochastic.get_counts():
print(str(simResultHERR.get_counts()[s]/1024.0) + " " + str(simResultBasic.get_counts()[s]/1024.0) + " " + str(simResultSabre.get_counts()[s]/1024.0) + " " + str(simResultLookahead.get_counts()[s]/1024.0) + " " + str(simResultStochastic.get_counts()[s]/1024.0))
else:
print("Key error! Oops!")
|
https://github.com/Seanaventure/HighErrorRateRouting
|
Seanaventure
|
import matplotlib.pyplot as plt
import networkx as nx
import qiskit
import HERR
from qiskit.transpiler import CouplingMap
from qiskit.transpiler.passes.routing import BasicSwap
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.dagcircuit import DAGCircuit
from qiskit.converters import circuit_to_dag
from qiskit.converters import dag_to_circuit
from math import pi
from qiskit.compiler import transpile, assemble
from qiskit.providers.aer.noise import NoiseModel
import qiskit.providers.aer.noise as noise
from qiskit.tools.visualization import dag_drawer
import random
from qiskit.circuit.instruction import Instruction
couplingList = list()
for i in range(4):
for j in range(4):
if i is not j:
couplingList.append([i, j])
provider = IBMQ.load_account()
backend = provider.get_backend('ibmq_lima')
basis_gates = backend.configuration().basis_gates
couplingMap = CouplingMap(couplingList)
squareCouplingList = list()
for i in range(4):
for j in range(4):
if i is not j:
if abs(i-j) == 1:
squareCouplingList.append([i, j])
squareCouplingList.append(([0, 3]))
squareCouplingList.append(([3, 0]))
squareCouplingMap = CouplingMap(squareCouplingList)
gridCouplingList = list()
for i in range(4):
for j in range(4):
if i is not j:
if abs(i-j) == 1:
gridCouplingList.append([i, j])
for i in range(4,8):
for j in range(4,8):
if i is not j:
if abs(i-j) == 1:
gridCouplingList.append([i, j])
gridCouplingList.append(([0, 4]))
gridCouplingList.append(([4, 0]))
gridCouplingList.append(([1, 5]))
gridCouplingList.append(([5, 1]))
gridCouplingList.append(([2, 6]))
gridCouplingList.append(([6, 2]))
gridCouplingList.append(([3, 7]))
gridCouplingList.append(([7, 3]))
gridCouplingMap = CouplingMap(gridCouplingList)
jakatraCouplingList = [[0, 1], [1, 0], [1, 2], [2, 1], [1, 3], [3, 1], [3,5], [5,3], [4,5], [5,4], [6,5], [5,6]]
jakatraCouplingMap = CouplingMap(jakatraCouplingList)
def qft_rotations(circuit, n):
"""Performs qft on the first n qubits in circuit (without swaps)"""
if n == 0:
return circuit
n -= 1
circuit.h(n)
for qubit in range(n):
circuit.cp(pi/2**(n-qubit), qubit, n)
# At the end of our function, we call the same function again on
# the next qubits (we reduced n by one earlier in the function)
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 on the first n qubits in circuit"""
qft_rotations(circuit, n)
swap_registers(circuit, n)
return circuit
def inverse_qft(circuit, n):
"""Does the inverse QFT on the first n qubits in circuit"""
# First we create a QFT circuit of the correct size:
qft_circ = qft(QuantumCircuit(n), n)
# Then we take the inverse of this circuit
invqft_circ = qft_circ.inverse()
# And add it to the first n qubits in our existing circuit
circuit.append(invqft_circ, circuit.qubits[:n])
return circuit.decompose() # .decompose() allows us to see the individual gates
def countTwoQubitGates(transpiledCircuit):
num = 0
for gate in transpiledCircuit.data:
# print(type(gate[0]))
if issubclass(type(gate[0]), Instruction):
if gate[0].name == "cx":
num += 1
return num
s = '1011011'
n = len(s)
# Let's see how it looks:
circuit = QuantumCircuit(n)
for ii, yesno in enumerate(reversed(s)):
if yesno == '1':
circuit.x(ii)
qft(circuit, n)
circuit = inverse_qft(circuit, n)
circuit.measure_all()
circDag = circuit_to_dag(circuit)
targetCouplingMap = jakatraCouplingMap
# Transpile non HERR
transpiledBasic = transpile(circuit, Aer.get_backend('qasm_simulator'),
coupling_map=targetCouplingMap,
basis_gates=basis_gates,
routing_method='basic',
layout_method='trivial')
transpiledSabre = transpile(circuit, Aer.get_backend('qasm_simulator'),
coupling_map=targetCouplingMap,
basis_gates=basis_gates,
routing_method='sabre',
layout_method='trivial')
transpiledStochastic = transpile(circuit, Aer.get_backend('qasm_simulator'),
coupling_map=targetCouplingMap,
basis_gates=basis_gates,
routing_method='stochastic',
layout_method='trivial')
transpiledLookahead = transpile(circuit, Aer.get_backend('qasm_simulator'),
coupling_map=targetCouplingMap,
basis_gates=basis_gates,
routing_method='lookahead',
layout_method='trivial')
for i in range(200):
# Create a noise model for the simulations
noise_model = noise.NoiseModel()
errorRates = list()
qiskitErrors = list()
for i in range(len(jakatraCouplingList)//2):
errorRates.append(random.randrange(1, 10, 1)/100.0)
qiskitErrors.append(noise.depolarizing_error(errorRates[i], 2))
edges = targetCouplingMap.get_edges()
uniqueEdges = set()
for edge in edges:
uniqueEdges.add(tuple(sorted(edge)))
noiseGraph = nx.Graph()
noiseGraph.add_nodes_from([0, 7])
errorIdex = 0
for edge in uniqueEdges:
noise_model.add_quantum_error(qiskitErrors[errorIdex], ['cx'], edge)
noiseGraph.add_edge(edge[0], edge[1], weight=errorRates[errorIdex])
errorIdex += 1
herr = HERR.HERR(targetCouplingMap, noiseGraph)
basSwap = BasicSwap(targetCouplingMap)
#print(gridCouplingMap)
# Run HERR
HERRRes = herr.run(circDag)
updatedCirc = dag_to_circuit(HERRRes)
bSwapRes = basSwap.run(circDag)
bSwapCirc = dag_to_circuit(bSwapRes)
# Transpile HERR
transpiledHERR = transpile(updatedCirc, Aer.get_backend('qasm_simulator'),
coupling_map=targetCouplingMap,
basis_gates=basis_gates,
routing_method='basic',
layout_method='trivial')
# if transpiledNormal != transpiledHERR:
# fName = "HERRQFTCouplingOutputs/HERRCirc" + str(i) + ".png"
# fName2 = "HERRQFTCouplingOutputs/NonCirc" + str(i) + ".png"
# transpiledHERR.draw(output='mpl', filename=fName)
# transpiledNormal.draw(output='mpl', filename=fName2)
# break
# HERRCnotGateNum = countTwoQubitGates(transpiledHERR)
# normalCnotGateNum = countTwoQubitGates(transpiledNormal)
# print(str(HERRCnotGateNum) + " " + str(normalCnotGateNum))
sim = Aer.get_backend('qasm_simulator')
simResultHERR = sim.run(transpiledHERR, noise_model=noise_model).result()
simResultBasic = sim.run(transpiledBasic, noise_model=noise_model).result()
simResultSabre = sim.run(transpiledSabre, noise_model=noise_model).result()
simResultLookahead = sim.run(transpiledLookahead, noise_model=noise_model).result()
simResultStochastic = sim.run(transpiledStochastic, noise_model=noise_model).result()
# Output file and print results
fName = "HERRQFTCouplingOutputs/HERRCirc" + str(i) + ".png"
fName2 = "HERRQFTCouplingOutputs/NonCirc" + str(i) + ".png"
#updatedCirc.draw(output='mpl', filename=fName)
#bSwapCirc.draw(output='mpl', filename=fName2)
#if transpiledNormal != transpiledHERR:
#print("CIRCUIT CHANGED")
#updatedCirc.draw(output='mpl', filename=fName)
#bSwapCirc.draw(output='mpl', filename=fName2)
#print("Iter: " + str(i) + " ErrorRate of edges (0,1) (1, 2), (0, 2), (1, 3), (2, 3), (0, 3) counts for HERR/nonHERR:")
#print(str(err1Rate) + " " + str(err2Rate) + " " + str(err3Rate) + " " + str(err4Rate) + " " + str(err5Rate) + " " + str(err6Rate))
if s in simResultHERR.get_counts() and s in simResultBasic.get_counts() and s in simResultSabre.get_counts() and s in simResultLookahead.get_counts() and s in simResultStochastic.get_counts():
print(str(simResultHERR.get_counts()[s]/1024.0) + " " + str(simResultBasic.get_counts()[s]/1024.0) + " " + str(simResultSabre.get_counts()[s]/1024.0) + " " + str(simResultLookahead.get_counts()[s]/1024.0) + " " + str(simResultStochastic.get_counts()[s]/1024.0))
else:
print("Key error! Oops!")
#print("----------------------")
|
https://github.com/Seanaventure/HighErrorRateRouting
|
Seanaventure
|
import matplotlib.pyplot as plt
import networkx as nx
import qiskit
import HERR
from qiskit.transpiler import CouplingMap
from qiskit.transpiler.passes.routing import BasicSwap
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.dagcircuit import DAGCircuit
from qiskit.converters import circuit_to_dag
from qiskit.converters import dag_to_circuit
from math import pi
from qiskit.compiler import transpile, assemble
from qiskit.providers.aer.noise import NoiseModel
import qiskit.providers.aer.noise as noise
from qiskit.tools.visualization import dag_drawer
import random
from qiskit.circuit.instruction import Instruction
def countTwoQubitGates(transpiledCircuit):
num = 0
for gate in transpiledCircuit.data:
# print(type(gate[0]))
if issubclass(type(gate[0]), Instruction):
if gate[0].name == "cx":
num += 1
return num
couplingList = list()
for i in range(3):
for j in range(3):
if i is not j:
couplingList.append([i, j])
squareCouplingList = list()
for i in range(4):
for j in range(4):
if i is not j:
if abs(i-j) == 1:
squareCouplingList.append([i, j])
squareCouplingList.append(([0, 3]))
squareCouplingList.append(([3, 0]))
provider = IBMQ.load_account()
backend = provider.get_backend('ibmq_lima')
basis_gates = backend.configuration().basis_gates
squareCouplingMap = CouplingMap(squareCouplingList)
couplingMap = CouplingMap(couplingList)
qcHERR = QuantumCircuit(4)
qcHERR.x(0)
qcHERR.x(1)
qcHERR.ccx(0, 1, 2)
qcHERR.measure_all()
qcHERR = qcHERR.decompose()
nonHERR = QuantumCircuit(4)
nonHERR.x(0)
nonHERR.x(1)
nonHERR.ccx(0, 1, 2)
nonHERR.measure_all()
circDag = circuit_to_dag(qcHERR)
transpiledBasic = transpile(qcHERR, Aer.get_backend('qasm_simulator'),
coupling_map=squareCouplingMap,
basis_gates=basis_gates,
routing_method='basic',
layout_method='trivial')
transpiledSabre = transpile(qcHERR, Aer.get_backend('qasm_simulator'),
coupling_map=squareCouplingMap,
basis_gates=basis_gates,
routing_method='sabre',
layout_method='trivial')
transpiledStochastic = transpile(qcHERR, Aer.get_backend('qasm_simulator'),
coupling_map=squareCouplingMap,
basis_gates=basis_gates,
routing_method='stochastic',
layout_method='trivial')
transpiledLookahead = transpile(qcHERR, Aer.get_backend('qasm_simulator'),
coupling_map=squareCouplingMap,
basis_gates=basis_gates,
routing_method='lookahead',
layout_method='trivial')
s = '0111'
for i in range(100):
# Create a noise model for the simulations
noise_model = noise.NoiseModel()
err1Rate, err2Rate, err3Rate, err4Rate = random.randrange(1, 20, 1)/100.0, random.randrange(1, 20, 1)/100.0, random.randrange(1, 20, 1)/100.0,\
random.randrange(1, 10, 1)/100.0
error_1 = noise.depolarizing_error(err1Rate, 2)
error_2 = noise.depolarizing_error(err2Rate, 2)
error_3 = noise.depolarizing_error(err3Rate, 2)
error_4 = noise.depolarizing_error(err4Rate, 2)
noise_model.add_quantum_error(error_1, ['cx'], [0, 1])
noise_model.add_quantum_error(error_2, ['cx'], [1, 2])
noise_model.add_quantum_error(error_3, ['cx'], [2, 3])
noise_model.add_quantum_error(error_4, ['cx'], [0, 3])
# Generate a noise graph to pass into HERR
noiseGraph = nx.Graph()
noiseGraph.add_nodes_from([0, 2])
noiseGraph.add_edge(0, 1, weight=1.0-err1Rate)
noiseGraph.add_edge(1, 2, weight=1.0-err2Rate)
noiseGraph.add_edge(2, 3, weight=1.0-err3Rate)
noiseGraph.add_edge(0, 3, weight=1.0-err4Rate)
herr = HERR.HERR(squareCouplingMap, noiseGraph)
basSwap = BasicSwap(squareCouplingMap)
#print(squareCouplingMap)
# Run HERR
HERRRes = herr.run(circDag)
updatedCirc = dag_to_circuit(HERRRes)
bSwapRes = basSwap.run(circDag)
bSwapCirc = dag_to_circuit(bSwapRes)
# Transpile HERR
transpiledHERR = transpile(updatedCirc, Aer.get_backend('qasm_simulator'),
coupling_map=squareCouplingMap,
basis_gates=basis_gates,
routing_method='basic',
layout_method='trivial')
# HERRCnotGateNum = countTwoQubitGates(transpiledHERR)
# normalCnotGateNum = countTwoQubitGates(transpiledNormal)
# print(str(HERRCnotGateNum) + " " + str(normalCnotGateNum))
sim = Aer.get_backend('qasm_simulator')
simResultHERR = sim.run(transpiledHERR, noise_model=noise_model).result()
simResultBasic = sim.run(transpiledBasic, noise_model=noise_model).result()
simResultSabre = sim.run(transpiledSabre, noise_model=noise_model).result()
simResultLookahead = sim.run(transpiledLookahead, noise_model=noise_model).result()
simResultStochastic = sim.run(transpiledStochastic, noise_model=noise_model).result()
# Output file and print results
fName = "HERRQFTCouplingOutputs/HERRCirc" + str(i) + ".png"
fName2 = "HERRQFTCouplingOutputs/NonCirc" + str(i) + ".png"
#updatedCirc.draw(output='mpl', filename=fName)
#bSwapCirc.draw(output='mpl', filename=fName2)
#if transpiledNormal != transpiledHERR:
#print("CIRCUIT CHANGED")
#updatedCirc.draw(output='mpl', filename=fName)
#bSwapCirc.draw(output='mpl', filename=fName2)
#print("Iter: " + str(i) + " ErrorRate of edges (0,1) (1, 2), (0, 2), (1, 3), (2, 3), (0, 3) counts for HERR/nonHERR:")
#print(str(err1Rate) + " " + str(err2Rate) + " " + str(err3Rate) + " " + str(err4Rate) + " " + str(err5Rate) + " " + str(err6Rate))
print(str(simResultHERR.get_counts()[s]/1024.0) + " " + str(simResultBasic.get_counts()[s]/1024.0) + " " + str(simResultSabre.get_counts()[s]/1024.0) + " " + str(simResultLookahead.get_counts()[s]/1024.0) + " " + str(simResultStochastic.get_counts()[s]/1024.0))
|
https://github.com/dhruvesh-asnani/discrete-log-quantum
|
dhruvesh-asnani
|
import numpy as np
import math
from time import time
from math import gcd
from qiskit import(QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer)
from qiskit.aqua.circuits import FourierTransformCircuits as ftc
from qiskit.aqua.circuits.gates import mcu1
from qiskit.visualization import plot_histogram
from qiskit.quantum_info.operators import Operator
from qiskit.aqua.utils import summarize_circuits
def mod_exp(a, b, N):
X = int(a)
E = int(b)
m = int(N)
if(E<0 or m<1):
return None
X = X % m
Y = 1
while E > 0:
if E % 2 == 0:
X = (X * X) % m
E = E/2
else:
Y = (X * Y) % m
E = E - 1
return Y
def egcd(a, b):
if a == 0:
return (b, 0, 1)
else:
g, y, x = egcd(b % a, a)
return (g, x - (b // a) * y, y)
def modinv(a, n):
if(n<2):
return None
g, _, x = egcd(n, a)
if(g!=1):
return None
return x % n
def prime_factorize(n):
n = int(n)
if n<1:
return None
if n<2:
return [], []
d=2
pf = []
power = []
while d*d<=n:
if n % d == 0:
pf.append(d)
k=0
while n%d==0:
n = n // d
k = k + 1
power.append(k)
d = d + 1
if n > 1:
pf.append(n)
power.append(1)
return pf, power
def prime_factorize_2(n):
n = int(n)
if(n<1):
return None
if n<2:
return []
d=2
pf = []
while d*d<=n:
while n%d==0:
n = n // d
pf.append(d)
d = d + 1
if n > 1:
pf.append(n)
return pf
def phi_n(n):
n = int(n)
if(n<1):
return None
pf , power = prime_factorize(n)
v = 1
for i in range(len(pf)):
v *= (pf[i] ** (power[i] - 1 )) * (pf[i] - 1)
return v
def order(a, N):
N = int(N)
a = int(a) % N
if(N<2 or gcd(a, N)!=1):
return None
phi = phi_n(N)
d = 1
r = phi
while d*d <= phi:
if(phi % d == 0):
if(mod_exp(a, d, N)==1):
return d
if(mod_exp(a, phi/d, N) == 1):
r = phi/d
d = d + 1
return r
def get_angles(a, n):
bit = bin(abs(int(a)))[2:].zfill(n)
theta = np.zeros(n)
for i in range(n):
for j in range(n-1-i, n):
if bit[j] == '1':
theta[i] += 2**(n-i-j-1)
theta = theta * np.pi
return theta
def phi_add(circuit, q, a, n, c=[], inverse = False):
theta = get_angles(a, n)
if(inverse):
theta = -theta
if not c:
for i in range(n):
circuit.u1(theta[i], q[i])
else:
for i in range(n):
circuit.mcu1(theta[i], c, q[i])
def phi_add_mod_N(circuit, q, a, n, N, c, aux, inverse = False):
if not c :
print('There should be at least one control qubit')
return None
if N <= 0 or N >= 2**n :
print('Choose appropriate N')
return None
if(inverse):
a = (-a) % N
else:
a = a % N
phi_add(circuit, q, a, n+1, c)
phi_add(circuit, q, N, n+1, inverse=True)
ftc.construct_circuit(circuit=circuit, qubits=[q[i] for i in reversed(range(n+1))], do_swaps=False, inverse=True)
circuit.cx(q[n], aux)
ftc.construct_circuit(circuit=circuit, qubits=[q[i] for i in reversed(range(n+1))], do_swaps=False)
phi_add(circuit, q, N, n+1, [aux])
phi_add(circuit, q, a, n+1, c, inverse=True)
ftc.construct_circuit(circuit=circuit, qubits=[q[i] for i in reversed(range(n+1))], do_swaps=False, inverse=True)
circuit.x(q[n])
circuit.cx(q[n], aux)
circuit.x(q[n])
ftc.construct_circuit(circuit=circuit, qubits=[q[i] for i in reversed(range(n+1))], do_swaps=False)
phi_add(circuit, q, a, n+1, c)
def multiply_mod_N(circuit, q, a, n, N, c, aux):
if N <= 0 or N >= 2**n :
print('Choose appropriate N')
return None
a = a % N
a_inv = modinv(a, N)
if(not a_inv):
print('Inverse of a does not exist')
return None
pow_2_mod = np.zeros(n)
pow_2_mod[0] = 1
for i in range(1, n):
pow_2_mod[i] = (2*pow_2_mod[i-1]) % N
ftc.construct_circuit(circuit=circuit, qubits=[aux[i] for i in reversed(range(n+1))], do_swaps=False)
for i in range(n):
phi_add_mod_N(circuit, aux, (pow_2_mod[i]*a) % N, n, N, [c, q[i]], aux[n+1])
ftc.construct_circuit(circuit=circuit, qubits=[aux[i] for i in reversed(range(n+1))], do_swaps=False, inverse=True)
for i in range(n):
circuit.cswap(c, q[i], aux[i])
ftc.construct_circuit(circuit=circuit, qubits=[aux[i] for i in reversed(range(n+1))], do_swaps=False)
for i in reversed(range(n)):
phi_add_mod_N(circuit, aux, (pow_2_mod[i]*a_inv) % N, n, N, [c, q[i]], aux[n+1], inverse=True)
ftc.construct_circuit(circuit=circuit, qubits=[aux[i] for i in reversed(range(n+1))], do_swaps=False, inverse=True)
def power_mod_N(circuit, q, r, a, m, n, N, aux):
if N <= 0 or N >= 2**n :
print('Choose appropriate N')
return None
temp = a % N
for i in range(m):
multiply_mod_N(circuit, r, temp, n, N, q[i], aux)
temp = (temp*temp) % N
def discrete_log_solver(a, b, N, r, n_shots=64):
N = int(N)
a = int(a) % N
b = int(b) % N
r = int(r)
n_shots = int(n_shots)
if(N<2 or gcd(a, N)!=1 or n_shots<1):
return None
if(mod_exp(a, r, N)!=1):
return None
if(gcd(b, N)!=1):
return (None, 0)
n = int(np.ceil(np.log2(N)))
m = int(np.ceil(np.log2(r))) + 1
q = QuantumRegister(2*(m+n+1), 'q')
c = ClassicalRegister(2*m, 'c')
circuit = QuantumCircuit(q, c)
for i in range(2*m):
circuit.h(q[i])
circuit.x(q[2*m])
power_mod_N(circuit, q[:m], q[2*m:2*m+n], a, m, n, N, q[2*m+n:2*m+2*n+2])
power_mod_N(circuit, q[m:2*m], q[2*m:2*m+n], b, m, n, N, q[2*m+n:2*m+2*n+2])
ftc.construct_circuit(circuit=circuit, qubits=[q[i] for i in reversed(range(m))], inverse=True)
ftc.construct_circuit(circuit=circuit, qubits=[q[i] for i in reversed(range(m, 2*m))], inverse=True)
circuit.measure(q[:2*m], c[:2*m])
simulator = Aer.get_backend('qasm_simulator')
job = execute(circuit, simulator, shots=n_shots)
result = job.result()
counts = result.get_counts(circuit)
i=1
for key in counts:
x = int(key[-m:], 2)
y = int(key[-2*m:-m], 2)
k = round((x*r)/(2**m))
kt_mod_r = round((y*r)/(2**m))
if(k % r != 0):
t = (modinv(k, r) * kt_mod_r) % r
if(mod_exp(a, t, N) == b):
return (t, i)
break
i = i + 1
return (None, n_shots)
def discrete_log(a, b, N, n_shots=64):
N = int(N)
a = int(a) % N
b = int(b) % N
n_shots = int(n_shots)
if(N<2 or gcd(a, N) != 1 or n_shots<1):
return None
if(gcd(b, N) != 1):
return (None, 0)
r = int(order(a, N))
if(r==1):
if(b==1):
return (0, 0)
else:
return (None, 0)
pf = prime_factorize_2(r)
n = len(pf)
print('Output Format: ')
print('Subproblem i: a_i b_i c_i time_taken_to_solve_the_subproblem')
print('Subproblems are solved in reverse order \n')
print('No. of subproblems:', n)
A = np.zeros(n+1)
R = np.zeros(n+2)
L = np.zeros(n+1)
L[1] = int(1)
R[n+1] = int(1)
k = 0
n_trials = 0
for i in reversed(range(1, n+1)):
R[i] = R[i+1] * pf[i-1]
for i in reversed(range(1, n+1)):
print('Subproblem', i, ':', end=' ')
L_i = r/R[i]
A_i = mod_exp(a, r/pf[i-1], N)
B_i = (b * mod_exp(a, (-k)%r, N) ) % N
B_i = mod_exp(B_i, L_i, N)
print(A_i, B_i, end=' ')
s_time = time()
C_i, trials = discrete_log_solver(A_i, B_i, N, pf[i-1], n_shots)
print(C_i, round(time()-s_time), 's')
n_trials = n_trials + trials
if(C_i == None):
return (None, n_trials)
k = k + C_i * R[i+1]
return (int(k) , n_trials)
a = 7
b = 19
N = 30
ans, n_trials = discrete_log(a, b, N)
print('\n')
print('ans:', ans)
print('n_trials:', n_trials)
|
https://github.com/pkaran57/quantum-computing-final-project
|
pkaran57
|
import logging
from qiskit import Aer
from qiskit.aqua import QuantumInstance
from qiskit.aqua.algorithms import Shor
logging.basicConfig(format="'%(asctime)s' %(name)s %(message)s'", level=logging.INFO)
logger = logging.getLogger('main')
# provider = IBMQ.load_account()
# device = provider.get_backend('ibmq_qasm_simulator')
device = Aer.get_backend('qasm_simulator')
number_to_factorize = 15
shor = Shor(number_to_factorize)
quantum_instance = QuantumInstance(device)
result = shor.run(quantum_instance)
print("The list of factors of {} as computed by Shor is {}.".format(number_to_factorize, result['factors'][0]))
|
https://github.com/pkaran57/quantum-computing-final-project
|
pkaran57
|
import numpy as np
import networkx as nx
import qiskit
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, assemble
from qiskit.quantum_info import Statevector
from qiskit.aqua.algorithms import NumPyEigensolver
from qiskit.quantum_info import Pauli
from qiskit.aqua.operators import op_converter
from qiskit.aqua.operators import WeightedPauliOperator
from qiskit.visualization import plot_histogram
from qiskit.providers.aer.extensions.snapshot_statevector import *
from thirdParty.classical import rand_graph, classical, bitstring_to_path, calc_cost
from utils import mapeo_grafo
from collections import defaultdict
from operator import itemgetter
from scipy.optimize import minimize
import matplotlib.pyplot as plt
LAMBDA = 10
SEED = 10
SHOTS = 10000
# returns the bit index for an alpha and j
def bit(i_city, l_time, num_cities):
return i_city * num_cities + l_time
# e^(cZZ)
def append_zz_term(qc, q_i, q_j, gamma, constant_term):
qc.cx(q_i, q_j)
qc.rz(2*gamma*constant_term,q_j)
qc.cx(q_i, q_j)
# e^(cZ)
def append_z_term(qc, q_i, gamma, constant_term):
qc.rz(2*gamma*constant_term, q_i)
# e^(cX)
def append_x_term(qc,qi,beta):
qc.rx(-2*beta, qi)
def get_not_edge_in(G):
N = G.number_of_nodes()
not_edge = []
for i in range(N):
for j in range(N):
if i != j:
buffer_tupla = (i,j)
in_edges = False
for edge_i, edge_j in G.edges():
if ( buffer_tupla == (edge_i, edge_j) or buffer_tupla == (edge_j, edge_i)):
in_edges = True
if in_edges == False:
not_edge.append((i, j))
return not_edge
def get_classical_simplified_z_term(G, _lambda):
# recorrer la formula Z con datos grafo se va guardando en diccionario que acumula si coinciden los terminos
N = G.number_of_nodes()
E = G.edges()
# z term #
z_classic_term = [0] * N**2
# first term
for l in range(N):
for i in range(N):
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += -1 * _lambda
# second term
for l in range(N):
for j in range(N):
for i in range(N):
if i < j:
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 2
# z_jl
z_jl_index = bit(j, l, N)
z_classic_term[z_jl_index] += _lambda / 2
# third term
for i in range(N):
for l in range(N):
for j in range(N):
if l < j:
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 2
# z_ij
z_ij_index = bit(i, j, N)
z_classic_term[z_ij_index] += _lambda / 2
# fourth term
not_edge = get_not_edge_in(G) # include order tuples ej = (1,0), (0,1)
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 4
# z_j(l+1)
l_plus = (l+1) % N
z_jlplus_index = bit(j, l_plus, N)
z_classic_term[z_jlplus_index] += _lambda / 4
# fifthy term
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# z_il
z_il_index = bit(edge_i, l, N)
z_classic_term[z_il_index] += weight_ij / 4
# z_jlplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_j, l_plus, N)
z_classic_term[z_jlplus_index] += weight_ij / 4
# add order term because G.edges() do not include order tuples #
# z_i'l
z_il_index = bit(edge_j, l, N)
z_classic_term[z_il_index] += weight_ji / 4
# z_j'lplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_i, l_plus, N)
z_classic_term[z_jlplus_index] += weight_ji / 4
return z_classic_term
def tsp_obj_2(x, G,_lambda):
# obtenemos el valor evaluado en f(x_1, x_2,... x_n)
not_edge = get_not_edge_in(G)
N = G.number_of_nodes()
tsp_cost=0
#Distancia
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# x_il
x_il_index = bit(edge_i, l, N)
# x_jlplus
l_plus = (l+1) % N
x_jlplus_index = bit(edge_j, l_plus, N)
tsp_cost+= int(x[x_il_index]) * int(x[x_jlplus_index]) * weight_ij
# add order term because G.edges() do not include order tuples #
# x_i'l
x_il_index = bit(edge_j, l, N)
# x_j'lplus
x_jlplus_index = bit(edge_i, l_plus, N)
tsp_cost += int(x[x_il_index]) * int(x[x_jlplus_index]) * weight_ji
#Constraint 1
for l in range(N):
penal1 = 1
for i in range(N):
x_il_index = bit(i, l, N)
penal1 -= int(x[x_il_index])
tsp_cost += _lambda * penal1**2
#Contstraint 2
for i in range(N):
penal2 = 1
for l in range(N):
x_il_index = bit(i, l, N)
penal2 -= int(x[x_il_index])
tsp_cost += _lambda*penal2**2
#Constraint 3
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# x_il
x_il_index = bit(i, l, N)
# x_j(l+1)
l_plus = (l+1) % N
x_jlplus_index = bit(j, l_plus, N)
tsp_cost += int(x[x_il_index]) * int(x[x_jlplus_index]) * _lambda
return tsp_cost
def get_classical_simplified_zz_term(G, _lambda):
# recorrer la formula Z con datos grafo se va guardando en diccionario que acumula si coinciden los terminos
N = G.number_of_nodes()
E = G.edges()
# zz term #
zz_classic_term = [[0] * N**2 for i in range(N**2) ]
# first term
for l in range(N):
for j in range(N):
for i in range(N):
if i < j:
# z_il
z_il_index = bit(i, l, N)
# z_jl
z_jl_index = bit(j, l, N)
zz_classic_term[z_il_index][z_jl_index] += _lambda / 2
# second term
for i in range(N):
for l in range(N):
for j in range(N):
if l < j:
# z_il
z_il_index = bit(i, l, N)
# z_ij
z_ij_index = bit(i, j, N)
zz_classic_term[z_il_index][z_ij_index] += _lambda / 2
# third term
not_edge = get_not_edge_in(G)
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# z_il
z_il_index = bit(i, l, N)
# z_j(l+1)
l_plus = (l+1) % N
z_jlplus_index = bit(j, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += _lambda / 4
# fourth term
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# z_il
z_il_index = bit(edge_i, l, N)
# z_jlplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_j, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += weight_ij / 4
# add order term because G.edges() do not include order tuples #
# z_i'l
z_il_index = bit(edge_j, l, N)
# z_j'lplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_i, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += weight_ji / 4
return zz_classic_term
def get_classical_simplified_hamiltonian(G, _lambda):
# z term #
z_classic_term = get_classical_simplified_z_term(G, _lambda)
# zz term #
zz_classic_term = get_classical_simplified_zz_term(G, _lambda)
return z_classic_term, zz_classic_term
def get_cost_circuit(G, gamma, _lambda):
N = G.number_of_nodes()
N_square = N**2
qc = QuantumCircuit(N_square,N_square)
z_classic_term, zz_classic_term = get_classical_simplified_hamiltonian(G, _lambda)
# z term
for i in range(N_square):
if z_classic_term[i] != 0:
append_z_term(qc, i, gamma, z_classic_term[i])
# zz term
for i in range(N_square):
for j in range(N_square):
if zz_classic_term[i][j] != 0:
append_zz_term(qc, i, j, gamma, zz_classic_term[i][j])
return qc
def get_mixer_operator(G,beta):
N = G.number_of_nodes()
qc = QuantumCircuit(N**2,N**2)
for n in range(N**2):
append_x_term(qc, n, beta)
return qc
def get_QAOA_circuit(G, beta, gamma, _lambda):
assert(len(beta)==len(gamma))
N = G.number_of_nodes()
qc = QuantumCircuit(N**2,N**2)
# init min mix state
qc.h(range(N**2))
p = len(beta)
for i in range(p):
qc = qc.compose(get_cost_circuit(G, gamma[i], _lambda))
qc = qc.compose(get_mixer_operator(G, beta[i]))
qc.barrier(range(N**2))
qc.snapshot_statevector("final_state")
qc.measure(range(N**2),range(N**2))
return qc
def invert_counts(counts):
return {k[::-1] :v for k,v in counts.items()}
# Sample expectation value
def compute_tsp_energy_2(counts, G):
energy = 0
get_counts = 0
total_counts = 0
for meas, meas_count in counts.items():
obj_for_meas = tsp_obj_2(meas, G, LAMBDA)
energy += obj_for_meas*meas_count
total_counts += meas_count
mean = energy/total_counts
return mean
def get_black_box_objective_2(G,p):
backend = Aer.get_backend('qasm_simulator')
sim = Aer.get_backend('aer_simulator')
# function f costo
def f(theta):
beta = theta[:p]
gamma = theta[p:]
# Anzats
qc = get_QAOA_circuit(G, beta, gamma, LAMBDA)
result = execute(qc, backend, seed_simulator=SEED, shots= SHOTS).result()
final_state_vector = result.data()["snapshots"]["statevector"]["final_state"][0]
state_vector = Statevector(final_state_vector)
probabilities = state_vector.probabilities()
probabilities_states = invert_counts(state_vector.probabilities_dict())
expected_value = 0
for state,probability in probabilities_states.items():
cost = tsp_obj_2(state, G, LAMBDA)
expected_value += cost*probability
counts = result.get_counts()
mean = compute_tsp_energy_2(invert_counts(counts),G)
return mean
return f
def crear_grafo(cantidad_ciudades):
pesos, conexiones = None, None
mejor_camino = None
while not mejor_camino:
pesos, conexiones = rand_graph(cantidad_ciudades)
mejor_costo, mejor_camino = classical(pesos, conexiones, loop=False)
G = mapeo_grafo(conexiones, pesos)
return G, mejor_costo, mejor_camino
def run_QAOA(p,ciudades, grafo):
if grafo == None:
G, mejor_costo, mejor_camino = crear_grafo(ciudades)
print("Mejor Costo")
print(mejor_costo)
print("Mejor Camino")
print(mejor_camino)
print("Bordes del grafo")
print(G.edges())
print("Nodos")
print(G.nodes())
print("Pesos")
labels = nx.get_edge_attributes(G,'weight')
print(labels)
else:
G = grafo
intial_random = []
# beta, mixer Hammiltonian
for i in range(p):
intial_random.append(np.random.uniform(0,np.pi))
# gamma, cost Hammiltonian
for i in range(p):
intial_random.append(np.random.uniform(0,2*np.pi))
init_point = np.array(intial_random)
obj = get_black_box_objective_2(G,p)
res_sample = minimize(obj, init_point,method="COBYLA",options={"maxiter":2500,"disp":True})
print(res_sample)
if __name__ == '__main__':
# Run QAOA parametros: profundidad p, numero d ciudades,
run_QAOA(5, 3, None)
|
https://github.com/theochemel/grovers
|
theochemel
|
import numpy as np
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute
from qiskit import BasicAer, Aer
from qiskit.tools.visualization import plot_state_city, plot_histogram, plot_state_hinton
# Create a Quantum Register with 3 qubits.
q = QuantumRegister(3, 'q')
c = ClassicalRegister(3, 'c')
# Create a Quantum Circuit acting on the q register
circ = QuantumCircuit(q, c)
# MARK: START OF CIRCUIT
circ.h(q[1])
circ.h(q[2])
# circ.x(q[0])
# circ.h(q[0])
# MARK: Oracle generation. q[0] is oracle qubit. '11' is Sv
circ.ccx(q[2], q[1], q[0])
# circ.x(q[0])
# MARK: Conditional phase rotation
# Omitted for now
circ.cz(q[1], q[0])
circ.cz(q[2], q[0])
# MARK: Grover operator. Diffusion transform D = WRW
# W = Walsh-Hadamard transform (H gate on each qubit)
# R = Rotation matrix (controlled - z wrapped in bit-flips?)
circ.h(q[1])
circ.h(q[2])
circ.x(q[1])
circ.x(q[2])
circ.h(q[1])
circ.cx(q[2], q[1])
circ.h(q[1])
circ.x(q[2])
circ.x(q[1])
circ.h(q[1])
circ.h(q[2])
# MARK: Measure circuit
circ.measure(q[1], c[1])
circ.measure(q[2], c[2])
# MARK: END OF CIRCUIT
print(circ)
backend = BasicAer.get_backend('statevector_simulator')
job = execute(circ, backend)
stateVectorResult = job.result()
outputstate = stateVectorResult.get_statevector(circ, decimals=3)
print(outputstate)
plot_state_city(outputstate)
# plot_state_hinton(outputstate)
simulator = Aer.get_backend('qasm_simulator')
shotsResult = execute(circ, simulator).result()
counts = shotsResult.get_counts(circ)
print(counts)
plot_histogram(counts)
|
https://github.com/theochemel/grovers
|
theochemel
|
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute
from qiskit import BasicAer, Aer
from qiskit.tools.visualization import plot_histogram
q = QuantumRegister(5, 'q')
c = ClassicalRegister(3, 'c')
circ = QuantumCircuit(q, c)
circ.h(q[2])
circ.h(q[3])
circ.h(q[4])
circ.draw(output='mpl')
circ.x(q[2])
circ.ccx(q[2], q[3], q[1])
circ.ccx(q[4], q[1], q[0])
circ.x(q[2])
circ.draw(output='mpl')
circ.cz(q[2], q[0])
circ.cz(q[3], q[0])
circ.cz(q[4], q[0])
circ.draw(output='mpl')
circ.h(q[2])
circ.h(q[3])
circ.h(q[4])
circ.x(q[2])
circ.x(q[3])
circ.x(q[4])
circ.ccx(q[2], q[3], q[4])
circ.x(q[2])
circ.x(q[3])
circ.x(q[4])
circ.h(q[2])
circ.h(q[3])
circ.h(q[4])
circ.draw(output='mpl')
circ.measure(q[2], c[2])
circ.measure(q[3], c[1])
circ.measure(q[4], c[0])
simulator = Aer.get_backend('qasm_simulator')
shotsResult = execute(circ, simulator).result()
counts = shotsResult.get_counts(circ)
print(counts)
plot_histogram(counts)
|
https://github.com/AdityaZade/QuantumDecoder
|
AdityaZade
|
from qiskit import *
%matplotlib inline
from qiskit.tools.visualization import plot_histogram
secretnumber='101001'
circuit=QuantumCircuit(len(secretnumber)+1,len(secretnumber))
# circuit.h([0,1,2,3,4,5])
# circuit.x(6)
# circuit.h(6)
circuit.h(range(len(secretnumber)))
circuit.x(len(secretnumber))
circuit.z(len(secretnumber))
circuit.draw(output='mpl')
circuit.barrier()
for i,check in enumerate(reversed(secretnumber)):
if check == '1':
circuit.cx(i,len(secretnumber))
# circuit.cx(5,6)
# circuit.cx(2,6)
# circuit.cx(0,6)
circuit.draw(output='mpl')
circuit.barrier()
circuit.h(range(len(secretnumber)))
circuit.draw(output='mpl')
circuit.measure(range(len(secretnumber)),range(len(secretnumber)))
circuit.draw(output='mpl')
simulator=Aer.get_backend('qasm_simulator')
result=execute(circuit,backend=simulator,shots=1).result()
count=result.get_counts()
print(count)
|
https://github.com/Muhi0709/Quantum-K-Means
|
Muhi0709
|
import numpy as np
import math
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile, Aer, IBMQ
from qiskit.tools.jupyter import *
from qiskit.quantum_info import *
from qiskit.visualization import *
from ibm_quantum_widgets import *
from qiskit.providers.aer import QasmSimulator
from qiskit.extensions import Initialize
from qiskit.providers.ibmq.managed import IBMQJobManager
# Loading your IBM Quantum account(s)
provider = IBMQ.load_account()
import matplotlib.pyplot as plt
backend=provider.get_backend('ibmq_qasm_simulator')
data=np.load("data.npy")
print("No of datapoints:", data.shape[1])
print("Dimension:", data.shape[0])
def compute_mean(x,d,k): #helperfunction to compute cluster means(used in all the follwing subparts)
l=[]
for i in range(k):
a=np.mean(x,axis=1,where=x[d-1]==i+1)[:d-1]
a[np.isnan(a)]=0 #handling empty slice and true dvide warnings
l.append(a)
return np.array(l)
def quant_clustering(data,n=400,k=4,max_iter=20):
dim=data.shape[0]
means=np.load("means.npy")
done=False
ite=0
z=list(np.random.choice([1,2,3,4],n))
error=[]
X_clus=np.vstack((data,z))
dim_new=X_clus.shape[0]
err= np.sum(np.linalg.norm(X_clus[:dim_new-1].transpose()-means[(X_clus[dim_new-1]-1).astype("int64")],axis=1)**2,axis=0)
error.append(err)
while (not done) and ite<=max_iter:
done=True
circ=[]
for i in range(n):
for j in range(k):
circuit=QuantumCircuit(12,1)
dt=np.hstack((data[:,i],np.zeros(2**9-len(data[:,i]))))
mean=np.hstack((means[j],np.zeros(2**9-len(means[j]))))
a_norm=(dt/np.linalg.norm(dt)) if np.linalg.norm(dt)!=0 else np.array([0]*2**9)
b_norm=(mean/np.linalg.norm(mean)) if np.linalg.norm(mean)!=0 else np.array([0]*2**9)
c=np.hstack((a_norm,b_norm))/ 2**0.5
c_norm=c/np.linalg.norm(c)
circuit.initialize(c_norm,range(10))
Z=(np.linalg.norm(dt)**2 + np.linalg.norm(mean)**2)
circuit.initialize([Z**(-0.5) * np.linalg.norm(dt),-Z**(-0.5) * np.linalg.norm(mean)],11)
circuit.h(11)
circuit.cswap(11,10,9)
circuit.h(11)
circuit.measure(11,0)
circ.append(circuit)
circ = transpile(circ, backend=backend)
job_manager = IBMQJobManager()
job = job_manager.run(circ, backend=backend,name="clustering_ite_{}".format(ite),shots=8192)
result= job.results()
prob=np.array([result.get_counts(i)["0"]/((result.get_counts(i)["0"] if "0" in result.get_counts(i) else 0)
+(result.get_counts(i)["1"] if "1" in result.get_counts(i) else 0)) for i in range(n*k)])
distances=list(4*Z*abs(prob-0.5))
for i in range(n):
candidate=np.argmin(distances[k*i:k*i+k])+1
if z[i]!=candidate:
done=False
z[i]=candidate
err=0
for i in range(n):
err+=(distances[4*i+(z[i]-1)])
error.append(err)
means=compute_mean(np.vstack((data,z)),len(data)+1,k)
ite+=1
if ite==20 and done==False:
print("Not Converged")
print("Final_value:", np.round(error[-1],2))
elif done==True:
print("Convergence:", np.round(error[-1],2))
plt.plot(error)
plt.grid(True)
plt.xlabel("Iteration number")
plt.ylabel("Objective function")
plt.title("Quantum")
plt.show()
return z
z1=quant_clustering(data)
np.save("cluster1.npy",np.array(z1))
from collections import Counter
def plot_result(z,title):
plt.title(title)
c=Counter(z).most_common()
cx=[x for x,y in c]
cy=[y for x,y in c]
plt.xticks(np.arange(0,5,1))
plt.yticks(np.arange(0,100,5))
plt.grid(True)
plt.xlabel("cluster number")
plt.ylabel("count")
plt.bar(cx,cy)
plt.show()
plot_result(z1[:100],"covid")
plot_result(z1[100:200],"normal")
plot_result(z1[200:300],"opacity")
plot_result(z1[300:],"viral")
cluster_stat=list(enumerate(z1))
cluster_stat.sort(key= lambda x: x[1])
cluster1=[]
cluster2=[]
cluster3=[]
cluster4=[]
a=[0]*4
b=[0]*4
c=[0]*4
d=[0]*4
for i,j in cluster_stat:
if j==1:
if i<100:
a[0]+=1
elif i>=100 and i<200:
a[1]+=1
elif i>=200 and i<300:
a[2]+=1
else:
a[3]+=1
if j==2:
if i<100:
b[0]+=1
elif i>=100 and i<200:
b[1]+=1
elif i>=200 and i<300:
b[2]+=1
else:
b[3]+=1
if j==3:
if i<100:
c[0]+=1
elif i>=100 and i<200:
c[1]+=1
elif i>=200 and i<300:
c[2]+=1
else:
c[3]+=1
if j==4:
if i<100:
d[0]+=1
elif i>=100 and i<200:
d[1]+=1
elif i>=200 and i<300:
d[2]+=1
else:
d[3]+=1
def plot_result2(a,title):
plt.title(title)
plt.grid(True)
plt.xticks(np.arange(0,5,1))
plt.yticks(np.arange(0,100,5))
plt.bar(range(4),a)
plt.xlabel("type")
plt.ylabel("count")
plt.show()
plot_result2(a,"cluster 1")
plot_result2(b,"cluster 2")
plot_result2(c,"cluster 3")
plot_result2(d,"cluster 4")
means=np.load("means.npy")
circuit=QuantumCircuit(12,1)
dt=np.hstack((data[:,0],np.zeros(2**9-len(data[:,0]))))
mean=np.hstack((means[1],np.zeros(2**9-len(means[1]))))
a_norm=(dt/np.linalg.norm(dt)) if np.linalg.norm(dt)!=0 else np.array([0]*2**9)
b_norm=(mean/np.linalg.norm(mean)) if np.linalg.norm(mean)!=0 else np.array([0]*2**9)
c=np.hstack((a_norm,b_norm))/ 2**0.5
c_norm=c/np.linalg.norm(c)
circuit.initialize(c_norm,range(10))
Z=(np.linalg.norm(dt)**2 + np.linalg.norm(mean)**2)
circuit.initialize([Z**(-0.5) * np.linalg.norm(dt),-Z**(-0.5) * np.linalg.norm(mean)],10)
circuit.h(11)
circuit.cswap(11,10,9)
circuit.h(11)
circuit.measure(11,0)
circuit.draw("latex")
circuit = transpile(circuit, backend=backend)
job_manager = IBMQJobManager()
job = job_manager.run([circuit], backend=backend,name="clustering_ite_{}".format(1),shots=8192)
result=job.results()
|
https://github.com/drobiu/quantum-project
|
drobiu
|
from qiskit import BasicAer, execute
from qiskit.circuit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.circuit.library.standard_gates import PhaseGate
from qiskit.circuit.library.basis_change import QFT
import math
from src.util.util import run_qc
q = QuantumRegister(3)
b = QuantumRegister(1)
c = ClassicalRegister(3)
qc = QuantumCircuit(q, b, c)
qc.x(q[0])
qc.draw(output='mpl')
def increment(circuit, register, apply_QFT=True):
q = register
num = len(q)
qc = circuit
if apply_QFT == True:
qc.barrier()
qc = qc.compose(QFT(num_qubits=num, approximation_degree=0, do_swaps=True, \
inverse=False, insert_barriers=True, name='qft'))
qc.barrier()
for i, qubit in enumerate(q):
qc.rz(math.pi/2**(num-1-i), qubit)
if apply_QFT == True:
qc.barrier()
qc = qc.compose(QFT(num_qubits=num, approximation_degree=0, do_swaps=True, \
inverse=True, insert_barriers=True, name='iqft'))
qc.barrier()
return qc
test = increment(qc, q)
test.draw(output='mpl')
def control_increment(circuit, qregister, cregister, apply_QFT=True):
q = qregister
c = cregister
numq = len(q)
numc = len(c)
qc = circuit
if apply_QFT == True:
qc.barrier()
qc = qc.compose(QFT(num_qubits=numq, approximation_degree=0, do_swaps=True, \
inverse=False, insert_barriers=True, name='qft'))
qc.barrier()
for i, qubit in enumerate(q):
ncp = PhaseGate(math.pi/2**(numq-i-1)).control(numc)
qc.append(ncp, [*c, qubit])
if apply_QFT == True:
qc.barrier()
qc = qc.compose(QFT(num_qubits=numq, approximation_degree=0, do_swaps=True, \
inverse=True, insert_barriers=True, name='iqft'))
qc.barrier()
return qc
test2 = control_increment(qc, q, b)
test2.draw(output='mpl')
## Test increment without control
test = increment(qc, q)
test.measure(q[:], c[:])
run_qc(qc)
test.draw(output='mpl')
# Test control increment
q = QuantumRegister(3)
b = QuantumRegister(1)
c = ClassicalRegister(3)
qc = QuantumCircuit(q, b, c)
qc.x(q[0])
qc = control_increment(qc, q, b)
# Flipping control qubit to 1
qc.x(b[0])
qc = control_increment(qc, q, b)
# Flipping control qubit to 1
qc.x(b[0])
qc = control_increment(qc, q, b)
# Should equal 010
qc.measure(q[:], c[:])
run_qc(qc)
qc.draw(output="mpl")
|
https://github.com/drobiu/quantum-project
|
drobiu
|
"""Python implementation of Grovers algorithm through use of the Qiskit library to find the value 3 (|11>)
out of four possible values."""
#import numpy and plot library
import matplotlib.pyplot as plt
import numpy as np
# importing Qiskit
from qiskit import IBMQ, Aer, QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.providers.ibmq import least_busy
from qiskit.quantum_info import Statevector
# import basic plot tools
from qiskit.visualization import plot_histogram
# define variables, 1) initialize qubits to zero
n = 2
grover_circuit = QuantumCircuit(n)
#define initialization function
def initialize_s(qc, qubits):
'''Apply a H-gate to 'qubits' in qc'''
for q in qubits:
qc.h(q)
return qc
### begin grovers circuit ###
#2) Put qubits in equal state of superposition
grover_circuit = initialize_s(grover_circuit, [0,1])
# 3) Apply oracle reflection to marked instance x_0 = 3, (|11>)
grover_circuit.cz(0,1)
statevec = job_sim.result().get_statevector()
from qiskit_textbook.tools import vector2latex
vector2latex(statevec, pretext="|\\psi\\rangle =")
# 4) apply additional reflection (diffusion operator)
grover_circuit.h([0,1])
grover_circuit.z([0,1])
grover_circuit.cz(0,1)
grover_circuit.h([0,1])
# 5) measure the qubits
grover_circuit.measure_all()
# Load IBM Q account and get the least busy backend device
provider = IBMQ.load_account()
device = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 3 and
not x.configuration().simulator and x.status().operational==True))
print("Running on current least busy device: ", device)
from qiskit.tools.monitor import job_monitor
job = execute(grover_circuit, backend=device, shots=1024, optimization_level=3)
job_monitor(job, interval = 2)
results = job.result()
answer = results.get_counts(grover_circuit)
plot_histogram(answer)
#highest amplitude should correspond with marked value x_0 (|11>)
|
https://github.com/drobiu/quantum-project
|
drobiu
|
"""Example usage of the Quantum Inspire backend with the Qiskit SDK.
A simple example that demonstrates how to use the SDK to create
a circuit to demonstrate conditional gate execution.
For documentation on how to use Qiskit we refer to
[https://qiskit.org/](https://qiskit.org/).
Specific to Quantum Inspire is the creation of the QI instance, which is used to set the authentication
of the user and provides a Quantum Inspire backend that is used to execute the circuit.
Copyright 2018-19 QuTech Delft. Licensed under the Apache License, Version 2.0.
"""
import os
from qiskit import BasicAer, execute
from qiskit.circuit import QuantumRegister, ClassicalRegister, QuantumCircuit
from coreapi.auth import BasicAuthentication
from quantuminspire.credentials import get_authentication
from quantuminspire.qiskit import QI
QI_URL = os.getenv('API_URL', 'https://api.quantum-inspire.com/')
email='ray.mao1999@hotmail.com'
password='Mm19991202.QUANTUM'
authentication = BasicAuthentication(email,password)
QI.set_authentication(authentication, QI_URL)
qi_backend = QI.get_backend('QX single-node simulator')
q = QuantumRegister(2, "q")
c0 = ClassicalRegister(1, "c0")
c1 = ClassicalRegister(1, "c1")
qc = QuantumCircuit(3, name="conditional")
qc.h([0, 2])
qc.cnot(q[0], q[1])
qc.measure_all()
qi_job = execute(qc, backend=qi_backend, shots=1024)
qi_result = qi_job.result()
histogram = qi_result.get_counts(qc)
print("\nResult from the remote Quantum Inspire backend:\n")
print('State\tCounts')
[print('{0}\t{1}'.format(state, counts)) for state, counts in histogram.items()]
print("\nResult from the local Qiskit simulator backend:\n")
backend = BasicAer.get_backend("qasm_simulator")
job = execute(qc, backend=backend, shots=1024)
result = job.result()
print(result.get_counts(qc))
qc.draw(output="latex")
|
https://github.com/drobiu/quantum-project
|
drobiu
|
import numpy as np
from qiskit import QuantumCircuit, transpile
from qiskit.providers.aer import QasmSimulator
from qiskit.visualization import plot_histogram
# Use Aer's qasm_simulator
simulator = QasmSimulator()
# 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])
# compile the circuit down to low-level QASM instructions
# supported by the backend (not needed for simple circuits)
compiled_circuit = transpile(circuit, simulator)
# Execute the circuit on the qasm simulator
job = simulator.run(compiled_circuit, shots=1000)
# Grab results from the job
result = job.result()
# Returns counts
counts = result.get_counts(compiled_circuit)
# print("\nTotal count for 00 and 11 are:",counts)
# Draw the ci
circuit.draw(output="latex", filename="printing.png")
|
https://github.com/drobiu/quantum-project
|
drobiu
|
"""Example usage of the Quantum Inspire backend with the Qiskit SDK.
A simple example that demonstrates how to use the SDK to create
a circuit to demonstrate conditional gate execution.
For documentation on how to use Qiskit we refer to
[https://qiskit.org/](https://qiskit.org/).
Specific to Quantum Inspire is the creation of the QI instance, which is used to set the authentication
of the user and provides a Quantum Inspire backend that is used to execute the circuit.
Copyright 2018-19 QuTech Delft. Licensed under the Apache License, Version 2.0.
"""
import os
from qiskit import BasicAer, execute
from qiskit.circuit import QuantumRegister, ClassicalRegister, QuantumCircuit
from quantuminspire.credentials import get_authentication
from quantuminspire.qiskit import QI
QI_URL = os.getenv('API_URL', 'https://api.quantum-inspire.com/')
authentication = get_authentication()
QI.set_authentication(authentication, QI_URL)
qi_backend = QI.get_backend('QX single-node simulator')
q = QuantumRegister(3, "q")
c0 = ClassicalRegister(1, "c0")
c1 = ClassicalRegister(1, "c1")
c2 = ClassicalRegister(1, "c2")
qc = QuantumCircuit(q, c0, c1, c2, name="conditional")
qc.h(q[0])
qc.h(q[1]).c_if(c0, 0) # h-gate on q[1] is executed
qc.h(q[2]).c_if(c1, 1) # h-gate on q[2] is not executed
qc.measure(q[0], c0)
qc.measure(q[1], c1)
qc.measure(q[2], c2)
qi_job = execute(qc, backend=qi_backend, shots=1024)
qi_result = qi_job.result()
histogram = qi_result.get_counts(qc)
print("\nResult from the remote Quantum Inspire backend:\n")
print('State\tCounts')
[print('{0}\t{1}'.format(state, counts)) for state, counts in histogram.items()]
print("\nResult from the local Qiskit simulator backend:\n")
backend = BasicAer.get_backend("qasm_simulator")
job = execute(qc, backend=backend, shots=1024)
result = job.result()
print(result.get_counts(qc))
|
https://github.com/drobiu/quantum-project
|
drobiu
|
import os
import math
from getpass import getpass
from coreapi.auth import TokenAuthentication
from qiskit import BasicAer, execute
from qiskit.circuit import QuantumRegister, ClassicalRegister, QuantumCircuit
from quantuminspire.credentials import get_authentication
from quantuminspire.qiskit import QI
QI_URL = os.getenv('API_URL', 'https://api.quantum-inspire.com/')
QI.set_authentication()
qi_backend = QI.get_backend('QX single-node simulator')
q = QuantumRegister(1, "q")
c0 = ClassicalRegister(1, "c0")
qc = QuantumCircuit(q, c0, name="coin flip")
qc.h(q[0])
qc.measure(q[0], c0)
qi_job = execute(qc, backend=qi_backend, shots=1024)
qi_result = qi_job.result()
histogram = qi_result.get_counts(qc)
print("\nResult from the remote Quantum Inspire backend:\n")
print('State\tCounts')
[print('{0}\t{1}'.format(state, counts)) for state, counts in histogram.items()]
print("\nResult from the local Qiskit simulator backend:\n")
backend = BasicAer.get_backend("qasm_simulator")
job = execute(qc, backend=backend, shots=1024)
result = job.result()
print(result.get_counts(qc))
qc.draw(output="mpl")
|
https://github.com/drobiu/quantum-project
|
drobiu
|
import os
import math
from getpass import getpass
from coreapi.auth import TokenAuthentication
from qiskit import BasicAer, execute
from qiskit.circuit import QuantumRegister, ClassicalRegister, QuantumCircuit
from quantuminspire.credentials import get_authentication
from quantuminspire.qiskit import QI
QI_URL = os.getenv('API_URL', 'https://api.quantum-inspire.com/')
QI.set_authentication()
qi_backend = QI.get_backend('QX single-node simulator')
q = QuantumRegister(4, "q")
c0 = ClassicalRegister(1, "c0")
c1 = ClassicalRegister(1, "c1")
c2 = ClassicalRegister(1, "c2")
qc = QuantumCircuit(q, c0, c1, c2, name="uneven dice")
qc.h(q[0:3])
# If q_0 is 1, set q_3 to 1
qc.cnot(q[0], q[3])
# Swap q_0 with q_2 if q_3 is 1
qc.fredkin(q[3], q[0], q[2])
# Not q_0 if q_2 and q_1 were 1 (75% of the shots)
qc.toffoli(q[1], q[2], q[0])
qc.measure(q[0], c0)
qc.measure(q[1], c1)
qc.measure(q[2], c2)
qi_job = execute(qc, backend=qi_backend, shots=1024)
qi_result = qi_job.result()
histogram = qi_result.get_counts(qc)
print("\nResult from the remote Quantum Inspire backend:\n")
print('State\tCounts')
[print('{0}\t{1}'.format(state, counts)) for state, counts in histogram.items()]
print("\nResult from the local Qiskit simulator backend:\n")
backend = BasicAer.get_backend("qasm_simulator")
job = execute(qc, backend=backend, shots=1024)
result = job.result()
print(result.get_counts(qc))
qc.draw(output="mpl")
|
https://github.com/drobiu/quantum-project
|
drobiu
|
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/drobiu/quantum-project
|
drobiu
|
"""Example usage of the Quantum Inspire backend with the Qiskit SDK.
A simple example that demonstrates how to use the SDK to create
a circuit to demonstrate conditional gate execution.
For documentation on how to use Qiskit we refer to
[https://qiskit.org/](https://qiskit.org/).
Specific to Quantum Inspire is the creation of the QI instance, which is used to set the authentication
of the user and provides a Quantum Inspire backend that is used to execute the circuit.
Copyright 2018-19 QuTech Delft. Licensed under the Apache License, Version 2.0.
"""
import os
from qiskit import BasicAer, execute
from qiskit.circuit import QuantumRegister, ClassicalRegister, QuantumCircuit
from quantuminspire.credentials import get_authentication
from quantuminspire.qiskit import QI
QI_URL = os.getenv('API_URL', 'https://api.quantum-inspire.com/')
authentication = get_authentication()
QI.set_authentication(authentication, QI_URL)
qi_backend = QI.get_backend('QX single-node simulator')
q = QuantumRegister(2, "q")
c0 = ClassicalRegister(1, "c0")
c1 = ClassicalRegister(1, "c1")
qc = QuantumCircuit(3, name="conditional")
qc.h([0, 2])
qc.cnot(q[0], q[1])
qc.measure_all()
qi_job = execute(qc, backend=qi_backend, shots=1024)
qi_result = qi_job.result()
histogram = qi_result.get_counts(qc)
print("\nResult from the remote Quantum Inspire backend:\n")
print('State\tCounts')
[print('{0}\t{1}'.format(state, counts)) for state, counts in histogram.items()]
print("\nResult from the local Qiskit simulator backend:\n")
backend = BasicAer.get_backend("qasm_simulator")
job = execute(qc, backend=backend, shots=1024)
result = job.result()
print(result.get_counts(qc))
qc.draw(output="latex")
|
https://github.com/drobiu/quantum-project
|
drobiu
|
from qiskit.circuit import QuantumRegister, ClassicalRegister, QuantumCircuit
from Rui.query import query_cd
from src.arithmetic.counter import count
from src.arithmetic.increment import control_decrement
from src.logic.find_color_positions import FCP
from src.logic.oracles import oracle_a, oracle_b
from src.util.util import run_qc
q = QuantumRegister(3)
a = QuantumRegister(3)
c = ClassicalRegister(3)
qc = QuantumCircuit(q, a, c)
qc.x(a[0])
qc.x(a[2])
qc = count(qc, q, a)
# Should equal 010
qc.measure(q[:], c[:])
run_qc(qc)
qc.draw(output="mpl")
q = QuantumRegister(3)
a = QuantumRegister(8)
c = ClassicalRegister(3)
qc = QuantumCircuit(q, a, c)
qc.x(a[2:5])
qc.barrier()
qc = oracle_a(qc, a, q, [0, 1, 2, 3])
# Should equal 110
qc.measure(q[:], c[:])
run_qc(qc, with_QI=False)
qc.draw(output="mpl")
q = QuantumRegister(4)
a = QuantumRegister(3)
c = ClassicalRegister(3)
qc = QuantumCircuit(q, a, c)
qc.barrier()
qc = control_decrement(qc, a, q)
# Should equal 110
qc.measure(a[:], c[:])
run_qc(qc)
qc.draw(output="mpl")
query_cd().draw(output='text')
qy = QuantumRegister(8, name='qy')
y = QuantumRegister(4, name='y')
s = QuantumRegister(3)
c = ClassicalRegister(4)
qc = QuantumCircuit(y, qy, s, c)
# qc.x(qy[0])
qc = FCP(qc, y, qy, s, [0, 1, 1, 1], 2, 0)
qc.barrier()
qc.measure(y[:], c[:])
run_qc(qc, with_QI=False)
qc.draw(output="mpl")
q = QuantumRegister(8)
b = QuantumRegister(3)
c = ClassicalRegister(3)
qc = QuantumCircuit(q, b, c)
# 10, 11, 11, 11
qc.x(q[1])
qc.x(q[7])
qc.barrier()
# [0, 0, 0, 1] = 11, 11, 11, 10
qc.compose(oracle_b(qc, q, b, [0, 0, 0, 1]).to_gate(label='oracle_b'))
# Should equal 110
qc.measure(b[:], c[:])
run_qc(qc, with_QI=False)
qc.draw(output="mpl")
|
https://github.com/drobiu/quantum-project
|
drobiu
|
import numpy as np
from qiskit import QuantumCircuit, transpile
from qiskit.providers.aer import QasmSimulator
from qiskit.visualization import plot_histogram
# Use Aer's qasm_simulator
simulator = QasmSimulator()
# 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])
# compile the circuit down to low-level QASM instructions
# supported by the backend (not needed for simple circuits)
compiled_circuit = transpile(circuit, simulator)
# Execute the circuit on the qasm simulator
job = simulator.run(compiled_circuit, shots=1000)
# Grab results from the job
result = job.result()
# Returns counts
counts = result.get_counts(compiled_circuit)
# print("\nTotal count for 00 and 11 are:",counts)
# Draw the ci
circuit.draw(output="latex", filename="printing.png")
|
https://github.com/drobiu/quantum-project
|
drobiu
|
"""Example usage of the Quantum Inspire backend with the Qiskit SDK.
A simple example that demonstrates how to use the SDK to create
a circuit to demonstrate conditional gate execution.
For documentation on how to use Qiskit we refer to
[https://qiskit.org/](https://qiskit.org/).
Specific to Quantum Inspire is the creation of the QI instance, which is used to set the authentication
of the user and provides a Quantum Inspire backend that is used to execute the circuit.
Copyright 2018-19 QuTech Delft. Licensed under the Apache License, Version 2.0.
"""
import os
from qiskit import BasicAer, execute
from qiskit.circuit import QuantumRegister, ClassicalRegister, QuantumCircuit
from quantuminspire.credentials import get_authentication
from quantuminspire.qiskit import QI
QI_URL = os.getenv('API_URL', 'https://api.quantum-inspire.com/')
authentication = get_authentication()
QI.set_authentication(authentication, QI_URL)
qi_backend = QI.get_backend('QX single-node simulator')
q = QuantumRegister(3, "q")
c0 = ClassicalRegister(1, "c0")
c1 = ClassicalRegister(1, "c1")
c2 = ClassicalRegister(1, "c2")
qc = QuantumCircuit(q, c0, c1, c2, name="conditional")
qc.h(q[0])
qc.h(q[1]).c_if(c0, 0) # h-gate on q[1] is executed
qc.h(q[2]).c_if(c1, 1) # h-gate on q[2] is not executed
qc.measure(q[0], c0)
qc.measure(q[1], c1)
qc.measure(q[2], c2)
qi_job = execute(qc, backend=qi_backend, shots=1024)
qi_result = qi_job.result()
histogram = qi_result.get_counts(qc)
print("\nResult from the remote Quantum Inspire backend:\n")
print('State\tCounts')
[print('{0}\t{1}'.format(state, counts)) for state, counts in histogram.items()]
print("\nResult from the local Qiskit simulator backend:\n")
backend = BasicAer.get_backend("qasm_simulator")
job = execute(qc, backend=backend, shots=1024)
result = job.result()
print(result.get_counts(qc))
|
https://github.com/drobiu/quantum-project
|
drobiu
|
from math import pi
from qiskit import *
from qiskit.circuit.library.standard_gates import PhaseGate
from qiskit.circuit.library.basis_change import QFT
def add(circuit, a, b, control=None, apply_QFT=True, amount=1):
# Function adds a to b Original add function build by
# https://github.com/TimVroomans/Quantum-Mastermind/blob/master/src/mastermind/arithmetic/dradder.py
number_a = len(a)
number_b = len(b)
num = number_b + number_a
if number_a > number_b:
raise ValueError("Amount of registers in b must be larger than a")
# QFT(optional)
if apply_QFT:
circuit = circuit.compose(QFT(num_qubits=number_b, approximation_degree=0, do_swaps=True,
inverse=False, insert_barriers=True, name='qft'), [*b])
# Actual add loop
for i in range(number_a):
for j in range(number_b - i):
if control:
p_gate = PhaseGate(amount * pi / 2 ** (number_b - i - j - 1)).control(len(control) + 1)
circuit.append(p_gate, [*control, a[i], b[j]])
else:
circuit.cp(amount * pi / 2 ** (number_b - i - j - 1), a[i], b[j])
# Inverse QFT (optional)
if apply_QFT:
circuit = circuit.compose(QFT(num_qubits=number_b, approximation_degree=0, do_swaps=True,
inverse=True, insert_barriers=True, name='iqft'), [*b])
return circuit
# def c_add(circuit, a, b, control, apply_QFT=True, amount=1):
#
if __name__ == "__main__":
# test
a = QuantumRegister(3)
b = QuantumRegister(5)
qc = QuantumCircuit(a, b)
test = add(qc, a, b)
print(test.draw(output='text'))
|
https://github.com/drobiu/quantum-project
|
drobiu
|
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit.circuit.library import QFT
from src.arithmetic.increment import control_increment, control_decrement
from src.util.util import run_qc
def count(circuit, count_register, control_register, amount=1, step=1, apply_QFT=True):
q_l = len(count_register)
a_l = len(control_register)
assert a_l % step == 0
if apply_QFT:
# circuit.barrier()
circuit = circuit.compose(QFT(num_qubits=q_l, approximation_degree=0, do_swaps=True,
inverse=False, insert_barriers=True, name='qft'), qubits=count_register)
# circuit.barrier()
for i in range(int(a_l / step)):
circuit = control_increment(circuit, count_register, control_register[i * step: (i + 1) * step],
amount, apply_QFT=False)
if apply_QFT:
# circuit.barrier()
circuit = circuit.compose(QFT(num_qubits=q_l, approximation_degree=0, do_swaps=True,
inverse=True, insert_barriers=True, name='iqft'), qubits=count_register)
# circuit.barrier()
return circuit
def mincount(circuit, count_register, control_register, amount=1, step=1, apply_QFT=True):
q_l = len(count_register)
a_l = len(control_register)
assert a_l % step == 0
if apply_QFT:
# circuit.barrier()
circuit = circuit.compose(QFT(num_qubits=q_l, approximation_degree=0, do_swaps=True,
inverse=False, insert_barriers=True, name='qft'), qubits=count_register)
# circuit.barrier()
for i in range(int(a_l / step)):
circuit = control_decrement(circuit, count_register, control_register[i * step:(i + 1) * step], amount, apply_QFT=False)
if apply_QFT:
# circuit.barrier()
circuit = circuit.compose(QFT(num_qubits=q_l, approximation_degree=0, do_swaps=True,
inverse=True, insert_barriers=True, name='iqft'), qubits=count_register)
# circuit.barrier()
return circuit
def test():
q = QuantumRegister(3)
a = QuantumRegister(3)
c = ClassicalRegister(3)
qc = QuantumCircuit(q, a, c)
qc.x(a[0])
qc.x(q[:])
qc = mincount(qc, q, a)
# Should equal 110
qc.measure(q[:], c[:])
run_qc(qc)
qc.draw(output="mpl")
if __name__ == "__main__":
test()
|
https://github.com/drobiu/quantum-project
|
drobiu
|
import numpy as np
from qiskit import QuantumRegister, QuantumCircuit, ClassicalRegister
from src.logic.find_color_positions import FCP
from src.util.util import run_qc
secret_string = [3, 2, 2, 0]
print("Input string:", secret_string)
print("\nPerforming FUC\n")
colors = np.zeros(4)
for i in secret_string:
colors[i] = 1
results = []
colors = list(colors)
print("FCP result:", colors)
print("\nPerforming FCP\n")
if not np.array_equal(np.array(colors), np.ones_like(colors)):
zero = colors.index(0)
for i in range(4):
if colors[i] == 0:
results.append(np.zeros(4))
print("Color", i, ": -")
continue
qy = QuantumRegister(8, name='qy')
y = QuantumRegister(4, name='y')
s = QuantumRegister(3)
c = ClassicalRegister(4)
qc = QuantumCircuit(y, qy, s, c)
qc = FCP(qc, y, qy, s, secret_string, c=i, d=zero)
qc.measure(y[:], c[::-1])
result = run_qc(qc, with_QI=False, verbose=False)
curr_result = list(result.get_counts(qc).keys())
assert len(curr_result) == 1
print("Color", i, ":", curr_result[0])
results.append(list(map(int, str(curr_result[0]))))
result_string = np.zeros(4)
for i in range(4):
for j, n in enumerate(results[i]):
if n == 1:
result_string[j] = i
print(result_string)
|
https://github.com/drobiu/quantum-project
|
drobiu
|
from qiskit import ClassicalRegister
from qiskit.circuit.quantumcircuit import QuantumCircuit
from qiskit.circuit.quantumregister import QuantumRegister
from src.logic.query import query_cd
from src.arithmetic.increment import control_increment, control_decrement
from src.logic.oracles import oracle_a
from src.util.util import run_qc
def FCP(circuit, y_register, qy_register, s_register, secret_string, c, d, d_positions=None):
# init
# q1 = QuantumRegister(num_position, "q1")
# q2 = QuantumRegister(num_bits_color * num_position)
# out = QuantumRegister(num_bits_color + 1, "o")
# step 1: apply H gate
circuit.h(y_register[:])
circuit.barrier()
# step 2: query
circuit = circuit.compose(query_cd(c, d), [*y_register, *qy_register])
# _build_query_two_colours(qc, qy_register, y_register, c, d)
circuit.barrier()
# step 3: ask oracle
circuit = oracle_a(circuit, qy_register, s_register, secret_string)
circuit.barrier()
# step 3.alt: compensate for d positions
if d_positions is not None:
for (i, j) in enumerate(d_positions):
if j == 1:
# apply x gets to y
circuit.x(y_register[i])
# apply decrement with y control
circuit = control_decrement(circuit, s_register, [y_register[i]])
circuit.x(y_register[i])
circuit.barrier()
# step 4: apply Z to LSB
circuit.z(s_register[0])
circuit.barrier()
# step 5: undo step 2 and 3
circuit = oracle_a(circuit, qy_register, s_register, secret_string, do_inverse=True)
circuit = circuit.compose(query_cd(c, d), [*y_register, *qy_register])
# _build_query_two_colours(qc, qy_register, y_register, c, d)
circuit.barrier()
# step 5.alt: undo step 3.alt
if d_positions is not None:
for (i, j) in enumerate(d_positions):
if j == 1:
# apply x gets to y
circuit.x(y_register[i])
# apply decrement with y control
circuit = control_increment(circuit, s_register, [y_register[i]])
circuit.x(y_register[i])
circuit.barrier()
# step 6: apply H gate
circuit.h(y_register[:])
circuit.barrier()
if c + d != 3:
circuit.x(y_register)
return circuit
# d
# x 0 1 2 3
# c 0 - x x v
# 1 x - v x
# 2 x v - x
# 3 v x x -
#
# x - bit flip
# v - correct
if __name__ == "__main__":
qy = QuantumRegister(8, name='qy')
y = QuantumRegister(4, name='y')
s = QuantumRegister(3)
cr = ClassicalRegister(4)
qc = QuantumCircuit(y, qy, s, cr)
# qc.x(qy[0])
qc = FCP(qc, y, qy, s, [1, 0, 3, 3], 1, 2)
qc.barrier()
qc.measure(y[:], cr[::-1])
run_qc(qc, with_QI=False)
qc.draw(output="mpl")
|
https://github.com/drobiu/quantum-project
|
drobiu
|
from qiskit import ClassicalRegister
from qiskit.circuit.quantumcircuit import QuantumCircuit
from qiskit.circuit.quantumregister import QuantumRegister
import numpy as np
from src.logic.oracles import oracle_a
from src.logic.query import query_cd
from src.util.util import run_qc
from src.arithmetic.add import add
from src.arithmetic.counter import count, mincount
from src.arithmetic.increment import decrement, increment
def FCPA(circuit, y_register, qy_register, s_register, memory, k, secret_string, c):
# k is number of available colours
# init
# q1 = QuantumRegister(num_position, "q1")
# q2 = QuantumRegister(num_bits_color * num_position)
# out = QuantumRegister(num_bits_color + 1, "o")
c = 3 - c
# step 1: apply H gate
circuit.h(y_register[:])
circuit.barrier()
# step 2: section that repeat k times
for d in range(k):
# Query
circuit = circuit.compose(query_cd(c, d), [*y_register, *qy_register])
circuit.barrier()
# Apply oracle A
circuit = oracle_a(circuit, qy_register, s_register, secret_string)
circuit.barrier()
# add in memory qubits
circuit = add(circuit, s_register, memory)
circuit.barrier()
# Apply inverse Oracle A
circuit = oracle_a(circuit, qy_register, s_register, secret_string, do_inverse=True)
circuit.barrier()
# Apply inverse Query
circuit = circuit.compose(query_cd(c, d), [*y_register, *qy_register])
circuit.barrier()
# step 3: count
circuit = count(circuit, memory, y_register)
circuit.barrier()
# step 4:ignore
# First logk lsb memory registers must be ignored.
# For visualizing Idendity gate will be applied
# Defining logk
logk = int(np.ceil(np.log2(k)))
for i in range(logk):
circuit.i(memory[i])
circuit.barrier()
# step 5: decrement
# Decrement
circuit = decrement(circuit, memory[logk::])
circuit.barrier()
# step 6: z gate to the now remaining LSB memory
circuit.z(memory[logk])
circuit.barrier()
# step 7: undo step 2:5
# undo decrement
circuit = increment(circuit, memory[logk::])
circuit.barrier()
# undo count
circuit = mincount(circuit, memory, y_register)
circuit.barrier()
# undo the loop
for d in range(k):
# cases:
# d not in s: position c +1
# d = c: position c+0
# d in s != c: position c+1, position d+1
# all mod 2
# position c +5 == 1
# position d +1 == 1
print(d)
# Query
circuit = circuit.compose(query_cd(c, d), [*y_register, *qy_register])
circuit.barrier()
# Oracle A
circuit = oracle_a(circuit, qy_register, s_register, secret_string)
circuit.barrier()
# Substractor
circuit = add(circuit, s_register, memory, amount=-1)
circuit.barrier()
# Apply inverse Oracle A
circuit = oracle_a(circuit, qy_register, s_register, secret_string, do_inverse=True)
circuit.barrier()
# Apply inverse Query
circuit = circuit.compose(query_cd(c, d), [*y_register, *qy_register])
circuit.barrier()
# step 8: Hadamard
circuit.h(y_register[:])
circuit.barrier()
return circuit
# Test
if __name__ == "__main__":
qy = QuantumRegister(8, name='qy')
y = QuantumRegister(4, name='y')
s = QuantumRegister(3)
c2 = ClassicalRegister(4)
memory = QuantumRegister(5)
qc = QuantumCircuit(y, qy, s, memory, c2)
# k is number of available colours
k = 4
# qc.x(qy[0])
qc = FCPA(qc, y, qy, s, memory, k, [3, 2, 1, 0], 3)
qc.barrier()
qc.measure(y[:], c2[::-1])
run_qc(qc, with_QI=False)
# print(qc.draw(output="text"))
|
https://github.com/drobiu/quantum-project
|
drobiu
|
from qiskit import QuantumRegister, QuantumCircuit, ClassicalRegister, BasicAer, execute
from qiskit.circuit.library import XGate
from src.arithmetic.comparator import comparator
from src.arithmetic.counter import mincount, count
from src.logic.oracles import oracle_a, oracle_b
from src.logic.query import query
def find_used_colours(n_positions, n_colors, secret_string):
n = n_positions
k = n_colors
s = secret_string
a = QuantumRegister(3)
b = QuantumRegister(4)
c = QuantumRegister(8)
d = QuantumRegister(3)
e = QuantumRegister(3)
f = QuantumRegister(1)
g = QuantumRegister(1)
h = QuantumRegister(1)
cl = ClassicalRegister(4)
circuit = QuantumCircuit(a, b, c, d, e, f, g, h, cl)
# Step 1
circuit = oracle_a(circuit, c, a, s)
# qc.barrier()
# Step 2
circuit.h(b[:])
# qc.barrier()
# Step 3
circuit = query(circuit, b, c, s)
# qc.barrier()
# Step 4
circuit = oracle_b(circuit, c, d, s)
# qc.barrier()
# Step 5
circuit.x(e[-1])
circuit = mincount(circuit, e, b)
# qc.barrier()
# Step 6
circuit = comparator(circuit, a, e, f, 3)
# qc.barrier()
# Step 7
circuit.x(g)
circuit.x(a[:])
multiply_controlled_x(circuit, a, g)
circuit.x(a[:])
# qc.barrier()
# Step 8
circuit.x(d[0], h)
multiply_controlled_x(circuit, [e[0], f, g], h)
circuit.x(f)
multiply_controlled_x(circuit, [e[0], f, g], h)
multiply_controlled_x(circuit, [b[0], f, g], h)
circuit.x(f)
# qc.barrier()
# Step 9
circuit.z(h)
# qc.barrier()
# Step 10
circuit.x(f)
multiply_controlled_x(circuit, [b[0], f, g], h)
multiply_controlled_x(circuit, [e[0], f, g], h)
circuit.x(f)
multiply_controlled_x(circuit, [e[0], f, g], h)
circuit.cx(d[0], h)
circuit.x(a[:])
circuit.cx(a[:], g)
circuit.x(a[:])
circuit.x(g)
circuit = comparator(circuit, a, e, f, 3)
circuit = count(circuit, e, b)
circuit.x(e[2])
circuit = oracle_b(circuit, c, d, s, do_inverse=True)
circuit = query(circuit, b, c, s)
# Step 11
circuit.h(b[:])
# qc.barrier()
# Step 12
circuit.measure(b[:], cl[:])
# circuit.draw(output='text')
print("\nResult from the local Qiskit simulator backend:\n")
backend = BasicAer.get_backend("qasm_simulator")
job = execute(circuit, backend=backend, shots=1)
result = job.result()
print(result.get_counts(circuit))
return circuit
def multiply_controlled_x(circuit, control, qubit):
num_c = len(control)
cx = XGate().control(num_c)
circuit.append(cx, [*control, qubit])
if __name__ == "__main__":
qc = find_used_colours(4, 4, [2, 2, 2, 2])
|
https://github.com/drobiu/quantum-project
|
drobiu
|
from itertools import combinations
import numpy as np
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.circuit.library import QFT
from scipy.special import binom
from src.arithmetic.counter import count, mincount
from src.arithmetic.increment import control_increment, control_decrement
from src.logic.s_gate import s_gate
from src.util.util import run_qc
def oracle_a(circuit, q, a, s, do_inverse=False):
"""
circuit: the circuit to which to append the oracle.
q: quantum registers, color inputs.
a: quantum registers, count of correct colors at correct places.
s: array of integer. The input of s_gate, which represents the secret string.
"""
circuit = circuit.compose(s_gate(s).to_gate(label="s"), qubits=q)
if not do_inverse:
circuit = count(circuit, a, q, step=2)
if do_inverse:
circuit = mincount(circuit, a, q, step=2)
circuit = circuit.compose(s_gate(s).to_gate(label="s"), qubits=q)
return circuit
def c_gate(k, length=4):
s = np.ones(length) * k
return s_gate(s, length / 2)
def oracle_b(circuit, q, b, s, do_inverse=False):
q_l = len(q)
b_l = len(b)
n = len(s)
log_k = q_l / n
circuit = circuit.compose(QFT(num_qubits=b_l, approximation_degree=0, do_swaps=True,
inverse=True, insert_barriers=True, name='qft'), qubits=b)
# Hardcoded for now
n_colors = 4
color_count = [s.count(i) for i in range(n_colors)]
for color, c_n in enumerate(color_count):
if c_n == 0:
continue
contrib = [1] + (c_n - 1) * [0]
for i in range(c_n + 1, n_colors + 1):
curr_cont = c_n
for j in range(1, i):
curr_cont -= binom(i, j) * contrib[j - 1]
contrib.append(curr_cont)
circuit = circuit.compose(c_gate(color))
print(color, c_n, contrib)
if not do_inverse:
circuit = count(circuit, b, q, step=2, apply_QFT=False)
else:
circuit = mincount(circuit, b, q, step=2, apply_QFT=False)
for i in range(c_n, n):
comp = contrib[i]
if comp == 0:
continue
# Heavily inspired by
# https://github.com/TimVroomans/Quantum-Mastermind/blob/master/src/mastermind/game/algorithms/Mastermind_Oracle.py
for combination in list(combinations(range(n), i + 1)):
qubit_combinations = [q[int(log_k * color): int(log_k * (color + 1))] for color in combination]
temp_qubits = []
for qb in qubit_combinations:
temp_qubits += qb
print('gate')
if not do_inverse:
circuit = control_increment(circuit, b, temp_qubits, amount=comp, apply_QFT=False)
else:
circuit = control_decrement(circuit, b, temp_qubits, amount=comp, apply_QFT=False)
circuit = circuit.compose(c_gate(color))
circuit = circuit.compose(QFT(num_qubits=b_l, approximation_degree=0, do_swaps=True,
inverse=True, insert_barriers=True, name='iqft'), qubits=b)
return circuit
def test():
q = QuantumRegister(8)
b = QuantumRegister(3)
c = QuantumRegister(3)
d = QuantumRegister(1)
cr = ClassicalRegister(15)
qc = QuantumCircuit(q, b, c, d, cr)
# 01, 00, 00, 00
qc.x(q[1])
qc.barrier()
# [0, 0, 0, 1] = 11, 11, 11, 10
# qc = oracle_b(qc, q, b, [0, 0, 0, 1])
qc = build_mastermind_b_circuit_v2(qc, q, b, c, d, [0, 1, 1, 1])
# Should equal 110
qc.measure([*q, *b, *c, *d], cr[:])
run_qc(qc, with_QI=False)
qc.draw(output="text")
if __name__ == "__main__":
test()
|
https://github.com/drobiu/quantum-project
|
drobiu
|
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/bopardikarsoham/The-Quantum-Teleportation-Algorithm
|
bopardikarsoham
|
from qiskit import *
circuit = QuantumCircuit(3,3)
%matplotlib inline
circuit.draw(output='mpl')
circuit.x(0)
circuit.barrier()
circuit.draw(output='mpl')
circuit.h(1)
circuit.cx(1,2)
circuit.draw(output='mpl')
circuit.cx(0,1)
circuit.h(0)
circuit.draw(output='mpl')
circuit.barrier()
circuit.measure([0,1], [0,1])
circuit.draw(output='mpl')
circuit.barrier()
circuit.cx(1,2)
circuit.cz(0,2)
circuit.draw(output='mpl')
circuit.measure(2,2)
circuit.draw(output='mpl')
simulator = Aer.get_backend('qasm_simulator')
result = execute(circuit, backend = simulator, shots = 1024).result()
counts = result.get_counts()
from qiskit.tools.visualization import plot_histogram
plot_histogram(counts)
|
https://github.com/INFINIT27/Shor-s-Algorithm-using-Qiskit
|
INFINIT27
|
from qiskit import QuantumCircuit, Aer, execute, IBMQ
from qiskit.utils import QuantumInstance
import numpy as np
from qiskit.algorithms import Shor
IBMQ.enable_account('ENTER API TOKEN HERE') # Enter your API token here
provider = IBMQ.get_provider(hub='ibm-q')
backend = Aer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=1000)
my_shor = Shor(quantum_instance)
result_dict = my_shor.factor(15)
print(result_dict)
|
https://github.com/eleyeth/Quantum-computing
|
eleyeth
|
%matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
# Build
#------
# 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
#--------
# Use Aer's qasm_simulator
simulator = Aer.get_backend('qasm_simulator')
# Execute the circuit on the qasm simulator
job = execute(circuit, simulator, shots=1000)
# Grab results from the job
result = job.result()
# Return counts
counts = result.get_counts(circuit)
print("\nTotal count for 00 and 11 are:",counts)
# Analyze
#--------
# Draw the circuit
circuit.draw()
# Analyze
#--------
# Plot a histogram
plot_histogram(counts)
|
https://github.com/Cgrubick/GroversSearchAlgorithm
|
Cgrubick
|
# HONR 293W Quantum Computing for Fun Clayton Grubick
# complete program written in Qiskit for searching a
# two-qubit quantum database using Grover’s search
# algorithm.
#
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
from numpy import random
from matplotlib import pyplot as plt
def DB_function(QC, color_code):
#if color_code == 0: do nothing
if color_code == 1:
QC.ccx(0,1,3)
elif color_code == 2:
QC.ccx(0,1,2)
elif color_code == 3:
QC.ccx(0,1,2)
QC.ccx(0,1,3)
color_codes = [0,1,2,3]
random.shuffle(color_codes)
database = {}
for i in range(4):
database[i]= color_codes[i]
desired_color_code = 2
DB = QuantumCircuit(5)
#for when index = 0 = 00
DB.x(0)
DB.x(1)
DB_function(DB, database[0])
DB.x(0)
DB.x(1)
#for when index = 1 = 01
DB.x(0)
DB_function(DB, database[1])
DB.x(0)
#for when index = 2 = 10
DB.x(1)
DB_function(DB, database[2])
DB.x(1)
#for when index = 3 = 11
DB_function(DB, database[3])
MG = QuantumCircuit(5)
if desired_color_code == 0:
MG.x(2)
MG.x(3)
MG.ccx(2,3,4)
MG.x(2)
MG.x(3)
elif desired_color_code == 1:
MG.x(2)
MG.ccx(2,3,4)
MG.x(2)
elif desired_color_code == 2:
MG.x(3)
MG.ccx(2,3,4)
MG.x(3)
elif desired_color_code == 3:
MG.ccx(2,3,4)
oracle = QuantumCircuit(5)
oracle.compose(DB, inplace=True)
oracle.compose(MG, inplace=True)
oracle.compose(DB, inplace=True)
phase = QuantumCircuit(5)
phase.x(0)
phase.x(1)
phase.h(1)
phase.cx(0,1)
phase.h(1)
phase.x(0)
phase.x(1)
Grover = QuantumCircuit(5)
Grover.compose(oracle, inplace=True)
Grover.h(0)
Grover.h(1)
Grover.compose(phase, inplace=True)
Grover.h(0)
Grover.h(1)
circuit = QuantumCircuit(5,2)
circuit.x(4)
circuit.h(0)
circuit.h(1)
circuit.h(4)
circuit.compose(Grover, inplace=True)
circuit.measure(0,1)
circuit.measure(1,0)
sim = Aer.get_backend('qasm_simulator')
results = execute(circuit,sim,shots = 1000)
counts = results.result().get_counts()
print("Done")
plot_histogram(counts)
plt.show()
|
https://github.com/DmitriiNabok/QuantumKitchenSinks
|
DmitriiNabok
|
import numpy as np
from matplotlib import pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
from matplotlib.colors import ListedColormap
seed = 12345
def plot_dataset(X, y, ax, axes=[-1, 1, -1, 1], marker='o', size=50, alpha=1.0, stepsize=0.5, grid=False, cmap=ListedColormap(['#FF0000', '#0000FF'])):
"""Simple routine to visualize a 2D dataset"""
ax.scatter(X[:, 0], X[:, 1], c=y, cmap=cmap, edgecolors='k', marker=marker, s=size, alpha=alpha)
ax.axis(axes)
ax.grid(grid, which='both')
ax.set_xlabel(r"$x_1$", fontsize=24)
ax.set_ylabel(r"$x_2$", fontsize=24, rotation=0)
ax.xaxis.set_ticks(np.arange(axes[0], axes[1]+0.01, stepsize))
ax.yaxis.set_ticks(np.arange(axes[2], axes[3]+0.01, stepsize))
def visualize_dataset():
fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(18, 6))
ax1.set_title("Total", fontsize=24)
plot_dataset(X, y, ax1)
ax1.grid()
ax2.set_title("Train", fontsize=24)
plot_dataset(X_train, y_train, ax2, marker='s', size=80)
ax2.grid()
ax3.set_title("Test", fontsize=22)
plot_dataset(X_test, y_test, ax3, marker='^', size=100)
ax3.grid()
plt.rcParams['font.size'] = 15
plt.tight_layout()
plt.show()
from sklearn.datasets import load_iris
iris = load_iris()
pair = [0, 2]
X = iris.data[:, pair]
y = iris.target
# Data rescaling
xmin = -1; xmax = 1
X = MinMaxScaler(feature_range=(xmin, xmax), copy=False).fit_transform(X)
# Train/Test subdivision
train_size = 20; test_size = 20
X_train, X_test, y_train, y_test = train_test_split(
X, y,
train_size=train_size, test_size=test_size,
stratify=y,
random_state=seed
)
def iris_visualize_dataset(X, y, ax, marker='o'):
n_classes = 3
plot_colors = ['#FF0000', '#0000FF', '#00FF00']
cmap = ListedColormap(plot_colors)
for i, color in zip(range(n_classes), plot_colors):
idx = np.where(y == i)
ax.scatter(
X[idx, 0],
X[idx, 1],
c=color,
label=iris.target_names[i],
edgecolor="black",
s=50,
marker=marker
)
fig, axs = plt.subplots(1, 3, figsize=(18, 6))
iris_visualize_dataset(X, y, axs[0])
iris_visualize_dataset(X_train, y_train, axs[1], marker='s')
iris_visualize_dataset(X_test, y_test, axs[2], marker='^')
for ax in axs:
ax.set_xlim(xmin, xmax)
ax.set_ylim(xmin, xmax)
ax.set_xlabel(iris.feature_names[pair[0]])
ax.set_ylabel(iris.feature_names[pair[1]])
plt.rcParams['font.size'] = 20
plt.suptitle("Iris dataset")
plt.legend(loc="lower right")
plt.tight_layout()
plt.show()
from sklearn.datasets import make_blobs
from sklearn.preprocessing import MinMaxScaler
n_samples = 400
X, y = make_blobs(n_samples=n_samples, n_features=2, centers=2, random_state=110, shuffle=True, cluster_std=1.2)
y[y%2 == 0] = -1
y[y > 0] = 1
xmin = -1; xmax = 1
X = MinMaxScaler(feature_range=(xmin, xmax)).fit_transform(X)
train_size = 20
test_size = 20
X_train, X_test, y_train, y_test = train_test_split(
X, y,
train_size=train_size, test_size=test_size,
random_state=seed
)
visualize_dataset()
from sklearn.datasets import make_circles
n_samples = 200
X, y = make_circles(n_samples, noise=0.1, factor=0.4, random_state=0)
y[y%2 == 0] = -1
y[y > 0] = 1
xmin = -1; xmax = 1
X = MinMaxScaler(feature_range=(xmin, xmax)).fit_transform(X)
train_size = 20
test_size = 20
X_train, X_test, y_train, y_test = train_test_split(
X, y,
train_size=train_size, test_size=test_size,
random_state=seed
)
visualize_dataset()
from sklearn.datasets import make_gaussian_quantiles
n_samples = 200
X, y = make_gaussian_quantiles(n_samples=n_samples, n_features=2, n_classes=2, shuffle=True, random_state=10)
y = 2*y-1
# Data rescaling
xmin = -1; xmax = 1
X = MinMaxScaler(feature_range=(xmin, xmax), copy=False).fit_transform(X)
train_size = 20
test_size = 20
X_train, X_test, y_train, y_test = train_test_split(
X, y,
train_size=train_size,
test_size=test_size,
stratify=y,
random_state=seed
)
visualize_dataset()
from sklearn.datasets import make_moons
n_samples = 100
X, y = make_moons(n_samples=n_samples, noise=0.2, random_state=32345)
y = 2*y-1
# Data rescaling
xmin = -1; xmax = 1
X = MinMaxScaler(feature_range=(xmin, xmax), copy=False).fit_transform(X)
train_size = 20
test_size = 20
X_train, X_test, y_train, y_test = train_test_split(
X, y,
train_size=train_size,
test_size=test_size,
stratify=y,
random_state=seed
)
visualize_dataset()
|
https://github.com/DmitriiNabok/QuantumKitchenSinks
|
DmitriiNabok
|
import numpy as np
import matplotlib.pyplot as plt
import time
# Qiskit
from qiskit.circuit import QuantumCircuit, ParameterVector
# Scikit
from sklearn.model_selection import train_test_split, StratifiedKFold, StratifiedShuffleSplit, GridSearchCV
from sklearn import metrics
from sklearn.linear_model import LogisticRegression
from qks.QuantumKitchenSinks import QuantumKitchenSinks
from qks.ProjectedQuantumKitchenSinks import ProjectedQuantumKitchenSinks
seed = 12345
np.random.seed(seed)
from sklearn.datasets import make_blobs
from sklearn.preprocessing import MinMaxScaler
from qks.visualization_tools import plot_dataset, plot_predictions, plot_decisions
n_samples = 400
X, y = make_blobs(n_samples=n_samples, n_features=2, centers=9, random_state=110, shuffle=True, cluster_std=1.2)
y[y%2 == 0] = -1
y[y > 0] = 1
xmin = -1; xmax = 1
X = MinMaxScaler(feature_range=(xmin, xmax)).fit_transform(X)
axes = [xmin, xmax, xmin, xmax]
train_size = 20
test_size = 20
X_train, X_test, y_train, y_test = train_test_split(
X, y,
train_size=train_size, test_size=test_size,
random_state=seed
)
# Visualize the dataset
fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(18, 6))
axes = [xmin, xmax, xmin, xmax]
ax1.set_title("Total", fontsize=24)
plot_dataset(X, y, ax1, axes)
ax2.set_title("Train", fontsize=24)
plot_dataset(X_train, y_train, ax2, axes, marker='s', size=80)
ax3.set_title("Test", fontsize=22)
plot_dataset(X_test, y_test, ax3, axes, marker='^', size=100)
plt.rcParams['font.size'] = 15
plt.tight_layout()
plt.show()
from sklearn.svm import SVC
param_grid = {
"gamma": [0.001, 0.005, 0.01, 0.1, 0.5, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0, 5.0, 10.0],
"C": [1, 2, 4, 6, 8, 10, 100, 1000],
}
gs = GridSearchCV(
estimator=SVC(kernel='rbf'),
param_grid=param_grid,
scoring='balanced_accuracy',
n_jobs=1,
refit=True,
cv=StratifiedKFold(n_splits=2, shuffle=True, random_state=seed),
)
gs.fit(X_train, y_train)
print('Best grid search parameters:', gs.best_params_)
print('Best training score:', gs.best_score_)
clf = gs.best_estimator_
y_pred = clf.predict(X_train)
acc_tr = metrics.balanced_accuracy_score(y_true=y_train, y_pred=y_pred)
mcc_tr = metrics.matthews_corrcoef(y_true=y_train, y_pred=y_pred)
y_pred = clf.predict(X_test)
acc_te = metrics.balanced_accuracy_score(y_true=y_test, y_pred=y_pred)
mcc_te = metrics.matthews_corrcoef(y_true=y_test, y_pred=y_pred)
print()
print(f"Scores ACC-MCC (train - test): {acc_tr:.2f} {mcc_tr:.2f} {acc_te:.2f} {mcc_te:.2f}")
print()
t0 = time.perf_counter()
fig, ax = plt.subplots(1, 1, figsize=(6, 5))
N = 10
x0s = np.linspace(xmin, xmax, N)
x1s = np.linspace(xmin, xmax, N)
x0, x1 = np.meshgrid(x0s, x1s)
XX = np.c_[x0.ravel(), x1.ravel()]
y_pred = clf.decision_function(XX).reshape(x0.shape)
ax.contourf(x0, x1, y_pred, cmap=plt.cm.RdBu, alpha=1.0)
ax.scatter(X[:, 0], X[:, 1], s=80, c=y,
marker='s', cmap=plt.cm.Paired_r, edgecolors="k")
plt.tight_layout()
plt.show()
t1 = time.perf_counter()
print( 'Timing info:', time.strftime("%Hh%Mm%Ss", time.gmtime(t1-t0)) )
#####################################################
# Wrapper for the quantum kitchen sinks classifier
#####################################################
def clf_QKS(fm, X_train, y_train, X_test, y_test, n_episodes, stddev):
""" """
n_features = len(X_train[0])
qks = QuantumKitchenSinks(
n_features, fm,
n_episodes=n_episodes, stddev=stddev, sampling='normal',
seed=seed
)
emb_tr = qks.embedding(X_train)
clf = LogisticRegression(random_state=seed, max_iter=1000).fit(emb_tr, y_train)
y_pred = clf.predict(emb_tr)
acc_tr = metrics.balanced_accuracy_score(y_true=y_train, y_pred=y_pred)
mcc_tr = metrics.matthews_corrcoef(y_true=y_train, y_pred=y_pred)
emb_te = qks.embedding(X_test)
y_pred = clf.predict(emb_te)
acc_te = metrics.balanced_accuracy_score(y_true=y_test, y_pred=y_pred)
mcc_te = metrics.matthews_corrcoef(y_true=y_test, y_pred=y_pred)
return clf, qks, [acc_tr, mcc_tr, acc_te, mcc_te]
#############################################################
# Feature Map
#############################################################
n_features = len(X[0])
n_qubits = 2
n_layers = 1
n_params = 2
theta = ParameterVector('θ', length=n_params)
fm = QuantumCircuit(n_qubits)
j = 0
for r in range(n_layers):
for i in range(n_qubits):
fm.ry(theta[j%n_params], i); j += 1
for i in range(n_qubits-1):
fm.cx(i, i+1)
print(fm.draw(fold=120, plot_barriers=False))
#############################################################
# QKS
#############################################################
t0 = time.perf_counter()
clf, qks, scores = clf_QKS(fm, X_train, y_train, X_test, y_test, n_episodes=10, stddev=3.0)
print()
print(f"Scores ACC-MCC (train - test): {scores[0]:.2f} {scores[1]:.2f} {scores[2]:.2f} {scores[3]:.2f}")
print()
t1 = time.perf_counter()
print( 'Timing info:', time.strftime("%Hh%Mm%Ss", time.gmtime(t1-t0)) )
t0 = time.perf_counter()
fig, ax = plt.subplots(1, 1, figsize=(6, 5))
N = 10
x0s = np.linspace(xmin, xmax, N)
x1s = np.linspace(xmin, xmax, N)
x0, x1 = np.meshgrid(x0s, x1s)
XX = np.c_[x0.ravel(), x1.ravel()]
emb_X = qks.embedding(XX)
y_pred = clf.decision_function(emb_X).reshape(x0.shape)
ax.contourf(x0, x1, y_pred, cmap=plt.cm.RdBu, alpha=1.0)
ax.scatter(X[:, 0], X[:, 1], s=80, c=y,
marker='s', cmap=plt.cm.Paired_r, edgecolors="k")
plt.tight_layout()
plt.show()
t1 = time.perf_counter()
print( 'Timing info:', time.strftime("%Hh%Mm%Ss", time.gmtime(t1-t0)) )
#############################################################
# Wrapper for the projected quantum kitchen sinks classifier
#############################################################
def clf_pQKS(fm, X_train, y_train, X_test, y_test, n_episodes, stddev, proj='z'):
""" """
n_features = len(X_train[0])
qks = ProjectedQuantumKitchenSinks(
n_features, fm, projection=proj,
n_episodes=n_episodes, stddev=stddev, sampling='normal',
seed=seed, method='statevector'
)
emb_tr = qks.embedding(X_train)
clf = LogisticRegression(random_state=seed, max_iter=1000).fit(emb_tr, y_train)
y_pred = clf.predict(emb_tr)
acc_tr = metrics.balanced_accuracy_score(y_true=y_train, y_pred=y_pred)
mcc_tr = metrics.matthews_corrcoef(y_true=y_train, y_pred=y_pred)
emb_te = qks.embedding(X_test)
y_pred = clf.predict(emb_te)
acc_te = metrics.balanced_accuracy_score(y_true=y_test, y_pred=y_pred)
mcc_te = metrics.matthews_corrcoef(y_true=y_test, y_pred=y_pred)
return clf, qks, [acc_tr, mcc_tr, acc_te, mcc_te]
#############################################################
# Feature Map
#############################################################
n_features = len(X[0])
n_qubits = 2
n_layers = 1
n_params = 2
theta = ParameterVector('θ', length=n_params)
fm = QuantumCircuit(n_qubits)
j = 0
for r in range(n_layers):
for i in range(n_qubits):
fm.ry(theta[j%n_params], i); j += 1
for i in range(n_qubits-1):
fm.cx(i, i+1)
print(fm.draw(fold=120, plot_barriers=False))
#############################################################
# Projected QKS
#############################################################
t0 = time.perf_counter()
clf, qks, scores = clf_pQKS(fm, X_train, y_train, X_test, y_test, n_episodes=10, stddev=3.0, proj='z')
print()
print(f"Scores ACC-MCC (train - test): {scores[0]:.2f} {scores[1]:.2f} {scores[2]:.2f} {scores[3]:.2f}")
print()
t1 = time.perf_counter()
print( 'Timing info:', time.strftime("%Hh%Mm%Ss", time.gmtime(t1-t0)) )
# z 1.00 1.00 0.94 0.90
# xyz_sum 1.00 1.00 0.89 0.81
# xyz 1.00 1.00 0.89 0.81
t0 = time.perf_counter()
fig, ax = plt.subplots(1, 1, figsize=(6, 5))
N = 10
x0s = np.linspace(xmin, xmax, N)
x1s = np.linspace(xmin, xmax, N)
x0, x1 = np.meshgrid(x0s, x1s)
XX = np.c_[x0.ravel(), x1.ravel()]
emb_X = qks.embedding(XX)
y_pred = clf.decision_function(emb_X).reshape(x0.shape)
ax.contourf(x0, x1, y_pred, cmap=plt.cm.RdBu, alpha=1.0)
ax.scatter(X[:, 0], X[:, 1], s=80, c=y,
marker='s', cmap=plt.cm.Paired_r, edgecolors="k")
plt.tight_layout()
plt.show()
t1 = time.perf_counter()
print( 'Timing info:', time.strftime("%Hh%Mm%Ss", time.gmtime(t1-t0)) )
|
https://github.com/DmitriiNabok/QuantumKitchenSinks
|
DmitriiNabok
|
import numpy as np
import matplotlib.pyplot as plt
import time
# Qiskit
from qiskit.circuit import QuantumCircuit, ParameterVector
# Scikit
from sklearn.model_selection import train_test_split, StratifiedKFold, StratifiedShuffleSplit, GridSearchCV
from sklearn import metrics
from sklearn.linear_model import LogisticRegression
from qks.QuantumKitchenSinks import QuantumKitchenSinks
from qks.ProjectedQuantumKitchenSinks import ProjectedQuantumKitchenSinks
seed = 12345
np.random.seed(seed)
from sklearn.datasets import make_moons
from sklearn.preprocessing import MinMaxScaler
from qks.visualization_tools import plot_dataset, plot_predictions, plot_decisions
n_samples = 100
X, y = make_moons(n_samples=n_samples, noise=0.2, random_state=22)
y = 2*y-1
# Data rescaling
xmin = -1; xmax = 1
X = MinMaxScaler(feature_range=(xmin, xmax), copy=False).fit_transform(X)
train_size = 15
test_size = 15
X_train, X_test, y_train, y_test = train_test_split(
X, y,
train_size=train_size,
test_size=test_size,
stratify=y,
random_state=seed
)
# Visualize the dataset
fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(18, 6))
axes = [xmin, xmax, xmin, xmax]
ax1.set_title("Total", fontsize=24)
plot_dataset(X, y, ax1, axes)
ax2.set_title("Train", fontsize=24)
plot_dataset(X_train, y_train, ax2, axes, marker='s', size=80)
ax3.set_title("Test", fontsize=22)
plot_dataset(X_test, y_test, ax3, axes, marker='^', size=100)
plt.rcParams['font.size'] = 15
plt.tight_layout()
plt.show()
from sklearn.svm import SVC
param_grid = {
"gamma": [0.001, 0.005, 0.01, 0.1, 0.5, 1.0, 1.2, 1.4, 1.6, 1.8, 2.0, 5.0, 10.0],
"C": [1, 2, 4, 6, 8, 10, 100, 1000],
}
gs = GridSearchCV(
estimator=SVC(kernel='rbf'),
param_grid=param_grid,
scoring='balanced_accuracy',
n_jobs=1,
refit=True,
cv=StratifiedKFold(n_splits=2, shuffle=True, random_state=seed),
)
gs.fit(X_train, y_train)
print('Best grid search parameters:', gs.best_params_)
print('Best training score:', gs.best_score_)
clf = gs.best_estimator_
y_pred = clf.predict(X_train)
acc_tr = metrics.balanced_accuracy_score(y_true=y_train, y_pred=y_pred)
mcc_tr = metrics.matthews_corrcoef(y_true=y_train, y_pred=y_pred)
y_pred = clf.predict(X_test)
acc_te = metrics.balanced_accuracy_score(y_true=y_test, y_pred=y_pred)
mcc_te = metrics.matthews_corrcoef(y_true=y_test, y_pred=y_pred)
print()
print(f"Scores ACC-MCC (train - test): {acc_tr:.2f} {mcc_tr:.2f} {acc_te:.2f} {mcc_te:.2f}")
print()
t0 = time.perf_counter()
fig, ax = plt.subplots(1, 1, figsize=(6, 5))
N = 10
x0s = np.linspace(xmin, xmax, N)
x1s = np.linspace(xmin, xmax, N)
x0, x1 = np.meshgrid(x0s, x1s)
XX = np.c_[x0.ravel(), x1.ravel()]
y_pred = clf.decision_function(XX).reshape(x0.shape)
ax.contourf(x0, x1, y_pred, cmap=plt.cm.RdBu, alpha=1.0)
ax.scatter(X[:, 0], X[:, 1], s=80, c=y,
marker='s', cmap=plt.cm.Paired_r, edgecolors="k")
plt.tight_layout()
plt.show()
t1 = time.perf_counter()
print( 'Timing info:', time.strftime("%Hh%Mm%Ss", time.gmtime(t1-t0)) )
#####################################################
# Wrapper for the quantum kitchen sinks classifier
#####################################################
def clf_QKS(fm, X_train, y_train, X_test, y_test, n_episodes, stddev):
""" """
n_features = len(X_train[0])
qks = QuantumKitchenSinks(
n_features, fm,
n_episodes=n_episodes, stddev=stddev, sampling='normal',
seed=seed
)
emb_tr = qks.embedding(X_train)
clf = LogisticRegression(random_state=seed, max_iter=1000).fit(emb_tr, y_train)
y_pred = clf.predict(emb_tr)
acc_tr = metrics.balanced_accuracy_score(y_true=y_train, y_pred=y_pred)
mcc_tr = metrics.matthews_corrcoef(y_true=y_train, y_pred=y_pred)
emb_te = qks.embedding(X_test)
y_pred = clf.predict(emb_te)
acc_te = metrics.balanced_accuracy_score(y_true=y_test, y_pred=y_pred)
mcc_te = metrics.matthews_corrcoef(y_true=y_test, y_pred=y_pred)
return clf, qks, [acc_tr, mcc_tr, acc_te, mcc_te]
#############################################################
# Feature Map
#############################################################
n_features = len(X[0])
n_qubits = 2
n_layers = 1
n_params = 2
theta = ParameterVector('θ', length=n_params)
fm = QuantumCircuit(n_qubits)
j = 0
for r in range(n_layers):
for i in range(n_qubits):
fm.ry(theta[j%n_params], i); j += 1
for i in range(n_qubits-1):
fm.cx(i, i+1)
print(fm.draw(fold=120, plot_barriers=False))
#############################################################
# QKS
#############################################################
t0 = time.perf_counter()
clf, qks, scores = clf_QKS(fm, X_train, y_train, X_test, y_test, n_episodes=20, stddev=3.0)
print()
print(f"Scores ACC-MCC (train - test): {scores[0]:.2f} {scores[1]:.2f} {scores[2]:.2f} {scores[3]:.2f}")
print()
t1 = time.perf_counter()
print( 'Timing info:', time.strftime("%Hh%Mm%Ss", time.gmtime(t1-t0)) )
t0 = time.perf_counter()
fig, ax = plt.subplots(1, 1, figsize=(6, 5))
N = 10
x0s = np.linspace(xmin, xmax, N)
x1s = np.linspace(xmin, xmax, N)
x0, x1 = np.meshgrid(x0s, x1s)
XX = np.c_[x0.ravel(), x1.ravel()]
emb_X = qks.embedding(XX)
y_pred = clf.decision_function(emb_X).reshape(x0.shape)
ax.contourf(x0, x1, y_pred, cmap=plt.cm.RdBu, alpha=1.0)
ax.scatter(X[:, 0], X[:, 1], s=80, c=y,
marker='s', cmap=plt.cm.Paired_r, edgecolors="k")
plt.tight_layout()
plt.show()
t1 = time.perf_counter()
print( 'Timing info:', time.strftime("%Hh%Mm%Ss", time.gmtime(t1-t0)) )
##############################################################
# Wrapper for the projected quantum kitchen sinks classifier
##############################################################
def clf_pQKS(fm, X_train, y_train, X_test, y_test, n_episodes, stddev, proj='z'):
""" """
n_features = len(X_train[0])
qks = ProjectedQuantumKitchenSinks(
n_features, fm, projection=proj,
n_episodes=n_episodes, stddev=stddev, sampling='normal',
seed=seed, method='statevector'
)
emb_tr = qks.embedding(X_train)
clf = LogisticRegression(random_state=seed, max_iter=1000).fit(emb_tr, y_train)
y_pred = clf.predict(emb_tr)
acc_tr = metrics.balanced_accuracy_score(y_true=y_train, y_pred=y_pred)
mcc_tr = metrics.matthews_corrcoef(y_true=y_train, y_pred=y_pred)
emb_te = qks.embedding(X_test)
y_pred = clf.predict(emb_te)
acc_te = metrics.balanced_accuracy_score(y_true=y_test, y_pred=y_pred)
mcc_te = metrics.matthews_corrcoef(y_true=y_test, y_pred=y_pred)
return clf, qks, [acc_tr, mcc_tr, acc_te, mcc_te]
#############################################################
# Feature Map
#############################################################
n_features = len(X[0])
n_qubits = 2
n_layers = 1
n_params = 2
theta = ParameterVector('θ', length=n_params)
fm = QuantumCircuit(n_qubits)
j = 0
for r in range(n_layers):
for i in range(n_qubits):
fm.ry(theta[j%n_params], i); j += 1
for i in range(n_qubits-1):
fm.cx(i, i+1)
print(fm.draw(fold=120, plot_barriers=False))
#############################################################
# Projected QKS
#############################################################
t0 = time.perf_counter()
clf, qks, scores = clf_pQKS(fm, X_train, y_train, X_test, y_test, n_episodes=20, stddev=3.0, proj='xyz')
print()
print(f"Scores ACC-MCC (train - test): {scores[0]:.2f} {scores[1]:.2f} {scores[2]:.2f} {scores[3]:.2f}")
print()
t1 = time.perf_counter()
print( 'Timing info:', time.strftime("%Hh%Mm%Ss", time.gmtime(t1-t0)) )
t0 = time.perf_counter()
fig, ax = plt.subplots(1, 1, figsize=(6, 5))
N = 10
x0s = np.linspace(xmin, xmax, N)
x1s = np.linspace(xmin, xmax, N)
x0, x1 = np.meshgrid(x0s, x1s)
XX = np.c_[x0.ravel(), x1.ravel()]
emb_X = qks.embedding(XX)
y_pred = clf.decision_function(emb_X).reshape(x0.shape)
ax.contourf(x0, x1, y_pred, cmap=plt.cm.RdBu, alpha=1.0)
ax.scatter(X[:, 0], X[:, 1], s=80, c=y,
marker='s', cmap=plt.cm.Paired_r, edgecolors="k")
plt.tight_layout()
plt.show()
t1 = time.perf_counter()
print( 'Timing info:', time.strftime("%Hh%Mm%Ss", time.gmtime(t1-t0)) )
|
https://github.com/DmitriiNabok/QuantumKitchenSinks
|
DmitriiNabok
|
import time, sys
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split, GridSearchCV, KFold
from sklearn import metrics
from sklearn.linear_model import LogisticRegression
from sklearn.svm import LinearSVR, SVR
# Qiskit
from qiskit import Aer
from qiskit.utils import QuantumInstance, algorithm_globals
from qiskit.circuit import QuantumCircuit, ParameterVector
# sys.path.append('/Users/nabok/Work/Notebooks/qml/git/quantum-kitchen-sinks')
from qks.QuantumKitchenSinks import QuantumKitchenSinks
from qks.ProjectedQuantumKitchenSinks import ProjectedQuantumKitchenSinks
seed = 12345
np.random.seed(seed)
plt.style.use('classic')
plt.rcParams['font.size'] = 20
plt.rcParams['axes.linewidth'] = 2
plt.rcParams['axes.grid'] = True
plt.rcParams['legend.fontsize'] = 16
def compute_score(y_true, y_pred):
return {
"R2": f"{metrics.r2_score(y_true, y_pred):.3f}",
"MSE": f"{metrics.mean_squared_error(y_true, y_pred):.3f}",
"MAE": f"{metrics.median_absolute_error(y_true, y_pred):.3f}",
}
def scores(model, X_train, y_train, X_test, y_test, qks=None):
if qks is None:
y_pred = model.predict(X_train)
else:
X_emb = qks.embedding(X_train)
y_pred = model.predict(X_emb)
train_scores = compute_score(y_train, y_pred)
if qks is None:
y_pred = model.predict(X_test)
else:
X_emb = qks.embedding(X_test)
y_pred = model.predict(X_emb)
test_scores = compute_score(y_test, y_pred)
print()
print(f"R2 scores (train, test): {train_scores['R2']} {test_scores['R2']}")
print(f"MSE scores (train, test): {train_scores['MSE']} {test_scores['MSE']}")
print(f"MAE scores (train, test): {train_scores['MAE']} {test_scores['MAE']}")
print()
def plot_model(model, qks=None):
plt.figure(figsize=(8, 6), facecolor='w')
plt.scatter(X, y, c="k", s=20, label="data", zorder=1, edgecolors=(0, 0, 0))
plt.scatter(X_train, y_train, c="r", s=40, marker="s", label="train")
plt.scatter(X_test, y_test, c="b", s=50, marker="^", label="test")
if qks is None:
y_plot = model.predict(X_plot)
else:
X_emb = qks.embedding(X_plot)
y_plot = model.predict(X_emb)
plt.plot(
X_plot,
y_plot,
c="g",
lw=4,
label="SVR",
)
plt.xlabel("data")
plt.ylabel("target")
_ = plt.legend()
rng = np.random.RandomState(42)
X = 2*np.pi * rng.rand(100, 1)
y = np.sin(X).ravel()
# Add noise to targets
y[::5] += 3 * (0.5 - rng.rand(X.shape[0] // 5))
X_plot = np.linspace(0, 2*np.pi, 100)[:, None]
train_size = 20
test_size = 10
X_train, X_test, y_train, y_test = train_test_split(
X, y,
train_size=train_size, test_size=test_size,
random_state=100
)
plt.figure(figsize=(8, 6), facecolor='w')
plt.scatter(X, y, c="k", s=20, label="data", zorder=1, edgecolors=(0, 0, 0))
plt.scatter(X_train, y_train, c="r", s=40, marker="s", label="train")
plt.scatter(X_test, y_test, c="b", s=50, marker="^", label="test")
plt.legend()
plt.show()
svr = GridSearchCV(
SVR(kernel="rbf"),
param_grid={"C": [1, 20, 40, 60, 80, 100, 120, 140, 160, 180, 200], "gamma": np.logspace(-2, 1, 100)},
scoring='r2',
n_jobs=1,
cv=KFold(n_splits=2, shuffle=True, random_state=seed),
)
svr.fit(X_train, y_train)
print(f"Best SVR with params: {svr.best_params_} and R2 score: {svr.best_score_:.3f}")
scores(svr, X_train, y_train, X_test, y_test)
plot_model(svr)
t0 = time.perf_counter()
n_features = len(X[0])
n_qubits = 1
n_layers = 1
n_params = n_qubits
theta = ParameterVector('θ', length=n_params)
fm = QuantumCircuit(n_qubits)
j = 0
for r in range(n_layers):
for i in range(n_qubits):
fm.ry(theta[j%n_features], i); j += 1
for i in range(n_qubits-1):
fm.cx(i, (i+1)%n_qubits)
print(fm.draw(fold=120, plot_barriers=False))
#############################################################
# QKS
#############################################################
algorithm_globals.random_seed = seed
backend = QuantumInstance(
# Aer.get_backend("qasm_simulator"), shots=1024, seed_simulator=seed, seed_transpiler=seed,
Aer.get_backend("statevector_simulator"), seed_simulator=seed, seed_transpiler=seed,
)
n_episodes = 40
stddev = 0.5
qks = QuantumKitchenSinks(
n_features, fm,
n_episodes=n_episodes, stddev=stddev, sampling='normal',
backend=backend, seed=seed,
)
emb_tr = qks.embedding(X_train)
# print('emb_tr.shape: ', emb_tr.shape)
svr = SVR(kernel='linear', C=100.0)
svr.fit(emb_tr, y_train)
scores(svr, X_train, y_train, X_test, y_test, qks=qks)
plot_model(svr, qks=qks)
t1 = time.perf_counter()
print( 'Timing info:', time.strftime("%Hh%Mm%Ss", time.gmtime(t1-t0)) )
t0 = time.perf_counter()
n_features = len(X[0])
n_qubits = 1
n_layers = 1
n_params = n_qubits
theta = ParameterVector('θ', length=n_params)
fm = QuantumCircuit(n_qubits)
j = 0
for r in range(n_layers):
for i in range(n_qubits):
fm.ry(theta[j%n_features], i); j += 1
for i in range(n_qubits-1):
fm.cx(i, (i+1)%n_qubits)
print(fm.draw(fold=120, plot_barriers=False))
#############################################################
# QKS
#############################################################
algorithm_globals.random_seed = seed
backend = QuantumInstance(
# Aer.get_backend("qasm_simulator"), shots=1024, seed_simulator=seed, seed_transpiler=seed,
Aer.get_backend("statevector_simulator"), seed_simulator=seed, seed_transpiler=seed,
)
n_episodes = 10
stddev = 0.5
qks = ProjectedQuantumKitchenSinks(
n_features, fm, projection='z',
n_episodes=n_episodes, stddev=stddev, sampling='normal',
seed=seed, backend=backend, method='statevector'
)
emb_tr = qks.embedding(X_train)
# print('emb_tr.shape: ', emb_tr.shape)
svr = SVR(kernel='linear', C=100.0)
svr.fit(emb_tr, y_train)
scores(svr, X_train, y_train, X_test, y_test, qks=qks)
plot_model(svr, qks=qks)
t1 = time.perf_counter()
print( 'Timing info:', time.strftime("%Hh%Mm%Ss", time.gmtime(t1-t0)) )
t0 = time.perf_counter()
n_features = len(X[0])
n_qubits = 2
n_layers = 2
n_params = n_qubits
theta = ParameterVector('θ', length=n_params)
fm = QuantumCircuit(n_qubits)
j = 0
for r in range(n_layers):
for i in range(n_qubits):
fm.ry(theta[j%n_features], i); j += 1
for i in range(n_qubits):
fm.cx(i, (i+1)%n_qubits)
print(fm.draw(fold=120, plot_barriers=False))
#############################################################
# QKS
#############################################################
algorithm_globals.random_seed = seed
backend = QuantumInstance(
# Aer.get_backend("qasm_simulator"), shots=1024, seed_simulator=seed, seed_transpiler=seed,
Aer.get_backend("statevector_simulator"), seed_simulator=seed, seed_transpiler=seed,
)
n_episodes = 40
stddev = 0.5
qks = QuantumKitchenSinks(
n_features, fm,
n_episodes=n_episodes, stddev=stddev, sampling='normal',
backend=backend, seed=seed,
)
emb_tr = qks.embedding(X_train)
# print('emb_tr.shape: ', emb_tr.shape)
svr = SVR(kernel='linear', C=100.0)
svr.fit(emb_tr, y_train)
scores(svr, X_train, y_train, X_test, y_test, qks=qks)
plot_model(svr, qks=qks)
t1 = time.perf_counter()
print( 'Timing info:', time.strftime("%Hh%Mm%Ss", time.gmtime(t1-t0)) )
t0 = time.perf_counter()
n_features = len(X[0])
n_qubits = 2
n_layers = 1
n_params = n_qubits
theta = ParameterVector('θ', length=n_params)
fm = QuantumCircuit(n_qubits)
j = 0
for r in range(n_layers):
for i in range(n_qubits):
fm.ry(theta[j%n_features], i); j += 1
for i in range(n_qubits-1):
fm.cx(i, (i+1)%n_qubits)
print(fm.draw(fold=120, plot_barriers=False))
#############################################################
# QKS
#############################################################
algorithm_globals.random_seed = seed
backend = QuantumInstance(
# Aer.get_backend("qasm_simulator"), shots=1024, seed_simulator=seed, seed_transpiler=seed,
Aer.get_backend("statevector_simulator"), seed_simulator=seed, seed_transpiler=seed,
)
n_episodes = 10
stddev = 0.5
qks = ProjectedQuantumKitchenSinks(
n_features, fm, projection='z',
n_episodes=n_episodes, stddev=stddev, sampling='normal',
seed=seed, backend=backend, method='statevector'
)
emb_tr = qks.embedding(X_train)
# print('emb_tr.shape: ', emb_tr.shape)
svr = SVR(kernel='linear', C=100.0)
svr.fit(emb_tr, y_train)
scores(svr, X_train, y_train, X_test, y_test, qks=qks)
plot_model(svr, qks=qks)
t1 = time.perf_counter()
print( 'Timing info:', time.strftime("%Hh%Mm%Ss", time.gmtime(t1-t0)) )
|
https://github.com/Marduk-42/Quantum-Algorithm-Tutorials
|
Marduk-42
|
from qiskit import *
import matplotlib.pyplot as plt
qreg = QuantumRegister(2)
creg = ClassicalRegister(2)
circuit = QuantumCircuit(qreg,creg)
circuit.reset(qreg[0])
circuit.reset(qreg[1])
circuit.h(qreg[0])
circuit.cx(qreg[0],qreg[1])
circuit.measure(qreg[0],creg[0])
circuit.measure(qreg[1],creg[1])
backend = Aer.get_backend('qasm_simulator')
job = execute(circuit, backend, shots=2048)
result = job.result()
circuit.draw("mpl")
visualization.plot_histogram(result.get_counts())
from qiskit.providers.ibmq import least_busy
provider = IBMQ.load_account() #If this throws an error, run IBMQ.save_account(YOUR_API_KEY). You will find your api key on https://quantum-computing.ibm.com/account
device = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 3 and
not x.configuration().simulator and x.status().operational==True))
job = execute(circuit, backend=device, shots=2048) #May take some time
results = job.result()
answer = results.get_counts(circuit)
visualization.plot_histogram(answer)
|
https://github.com/Marduk-42/Quantum-Algorithm-Tutorials
|
Marduk-42
|
from qiskit import Aer, execute, QuantumCircuit, visualization
import matplotlib.pyplot as plt
qc = QuantumCircuit.from_qasm_file('Bell test.qasm')
backend = Aer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=2048)
result = job.result()
ax1 = qc.draw("mpl")
ax1.suptitle("Bell test circuit")
ax2 = visualization.plot_histogram(result.get_counts(qc))
ax2.suptitle("Results")
plt.show()
|
https://github.com/Marduk-42/Quantum-Algorithm-Tutorials
|
Marduk-42
|
from qiskit import *
import matplotlib.pyplot as plt
qreg = QuantumRegister(2)
creg = ClassicalRegister(2)
circuit = QuantumCircuit(qreg,creg)
circuit.reset(qreg[0])
circuit.reset(qreg[1])
circuit.h(qreg[0])
circuit.cx(qreg[0],qreg[1])
circuit.measure(qreg[0],creg[0])
circuit.measure(qreg[1],creg[1])
backend = Aer.get_backend('qasm_simulator')
job = execute(circuit, backend, shots=2048)
result = job.result()
ax1 = circuit.draw("mpl")
ax1.suptitle("Bell test circuit")
ax2 = visualization.plot_histogram(result.get_counts(circuit))
ax2.suptitle("Results")
plt.show()
|
https://github.com/Marduk-42/Quantum-Algorithm-Tutorials
|
Marduk-42
|
from qiskit import *
def random_int(backend, size):
circuit = QuantumCircuit.from_qasm_file("Random_number.qasm")
job = execute(circuit, backend, shots=size, memory=True)
result = job.result()
bin_num = ''.join(result.get_memory())
return int(bin_num,2)
#QASM Simulator backend:
backend = Aer.get_backend('qasm_simulator')
#Real IBM Quantum Computer backend
#from qiskit.providers.ibmq import least_busy
#provider = IBMQ.load_account()
#backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 3 and
# not x.configuration().simulator and x.status().operational==True))
bits = 64
print("Here you have a random number: ", random_int(backend, bits))
|
https://github.com/Marduk-42/Quantum-Algorithm-Tutorials
|
Marduk-42
|
from qiskit import *
def random_int(backend, size):
qreg = QuantumRegister(1) #Using only one quibt
creg = ClassicalRegister(1)
circuit = QuantumCircuit(qreg,creg)
circuit.reset(qreg) #Reset the qubit to state |0>
circuit.h(qreg) #Apply Hadamard gate/put qubit into superposition
circuit.measure(qreg,creg) #Measure
job = execute(circuit, backend, shots=size, memory=True)
result = job.result()
bin_num = ''.join(result.get_memory())
return int(bin_num,2)
#QASM Simulator backend:
backend = Aer.get_backend('qasm_simulator')
#Real IBM Quantum Computer backend
#from qiskit.providers.ibmq import least_busy
#provider = IBMQ.load_account()
#backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 3 and
# not x.configuration().simulator and x.status().operational==True))
bits = 64
print("Here you have a random number: ", random_int(backend, bits))
|
https://github.com/ankitkmisra/Quantum-Computing-and-Cryptography
|
ankitkmisra
|
from qiskit import *
from qiskit.tools.jupyter import *
from qiskit.visualization import *
import matplotlib.pyplot as plotter
import numpy as np
from IPython.display import display, Math, Latex
%matplotlib inline
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
# The '0' state
plot_bloch_vector([0,0,1])
# The '1' state
plot_bloch_vector([0,0,-1])
qc1 = QuantumCircuit(2,2) # Initializing a quantum ciruit (2 qubits, 2 classical bits)
# All initialized to '0' by default.
qc1.draw(output='mpl') # Draws the circuit diagram
qc1.x(0) # Applying X gate to the first qubit
qc1.draw(output='mpl')
qc1.x(1) # Applying X gate to the second qubit
qc1.draw(output='mpl')
# The '+' state
plot_bloch_vector([1,0,0])
# The '-' state
plot_bloch_vector([-1,0,0])
qc2 = QuantumCircuit(2,2) # A new quantum circuit with 2 qubits and 2 classical bits
qc2.h(0) # Applying the Hadamard gate on first qubit
qc2.draw(output='mpl')
qc2.cx(0,1) # Applying CX gate ('control','target')
qc2.draw(output='mpl')
qc2.measure(0,0) # Measure first qubit and store it in first classical bit
qc2.measure(1,1) # Measure second qubit and store it in second classical bit
# The code below plots a histogram of the measurement result. You can copy it for further use.
def run_circuit(qc):
backend = Aer.get_backend('qasm_simulator') # we choose the simulator as our backend
result = execute(qc, backend, shots = 2000).result() # we run the simulation
counts = result.get_counts() # we get the counts
return counts
counts = run_circuit(qc2)
print(counts)
plot_histogram(counts)
qc1.h(0)
qc1.cx(0, 1)
qc1.draw(output='mpl')
qc1.measure(0,0)
qc1.measure(1,1)
def run_circuit(qc):
backend = Aer.get_backend('qasm_simulator')
result = execute(qc, backend, shots = 2000).result()
counts = result.get_counts()
return counts
counts = run_circuit(qc1)
print(counts)
plot_histogram(counts)
qc3 = QuantumCircuit(3,3)
qc3.x(range(3)) # Setting the all qubits to '1'
qc3.toffoli(0,1,2) # (control,control,target)
qc3.measure(0,0)
qc3.measure(1,1)
qc3.measure(2,2)
def run_circuit(qc3):
backend = Aer.get_backend('qasm_simulator') # we choose the simulator as our backend
result = execute(qc3, backend, shots = 2000).result() # we run the simulation
counts = result.get_counts() # we get the counts
return counts
counts = run_circuit(qc3)
print(counts)
plot_histogram(counts)
# The output should be '011' as the highest (q2) is flipped because the other two qubits were set to '1'
qc4 = QuantumCircuit(2,2)
#Applying the Pauli-X gate to quantum bit 0, we turn it into 1 so that the swap outcome is observable.
qc4.x(0)
qc4.cx(0, 1)
qc4.cx(1, 0)
qc4.cx(0, 1)
qc4.draw(output='mpl')
qc4.measure(0,0)
qc4.measure(1,1)
def run_circuit(qc):
backend = Aer.get_backend('qasm_simulator')
result = execute(qc, backend, shots = 2000).result()
counts = result.get_counts()
return counts
counts = run_circuit(qc4)
print(counts)
plot_histogram(counts)
qc5 = QuantumCircuit(2,2)
#We turn quantum bit 1 into 1 so that we can observe the results of HZH on both 0 (from q0) and 1 (from q1).
qc5.x(1)
qc5.h((0, 1))
qc5.z((0, 1))
qc5.h((0, 1))
qc5.draw(output='mpl')
qc5.measure(0,0)
qc5.measure(1,1)
def run_circuit(qc):
backend = Aer.get_backend('qasm_simulator')
result = execute(qc, backend, shots = 2000).result()
counts = result.get_counts()
return counts
counts = run_circuit(qc5)
print(counts)
plot_histogram(counts)
qc6 = QuantumCircuit(3,3)
#Initializing quantum bits using gates:
#q0 is initialized to 0.
#q1 is initialized to 1.
qc6.x(1)
#q2 is initialized to the state given above.
qc6.x(2)
qc6.h(2)
qc6.t(2)
#We change q2 for the controlled swap now; we'll bring it back to the same state afterwards.
qc6.tdg(2)
qc6.h(2)
#Controlled swap.
qc6.toffoli(0, 2, 1)
qc6.toffoli(1, 2, 0)
qc6.toffoli(0, 2, 1)
#We convert q2 back to whatever it was.
qc6.h(2)
qc6.t(2)
qc6.draw(output='mpl')
qc6.measure(0, 0)
qc6.measure(1, 1)
qc6.measure(2, 2)
def run_circuit(qc):
backend = Aer.get_backend('qasm_simulator')
result = execute(qc, backend, shots = 2000).result()
counts = result.get_counts()
return counts
counts = run_circuit(qc6)
print(counts)
plot_histogram(counts)
|
https://github.com/ankitkmisra/Quantum-Computing-and-Cryptography
|
ankitkmisra
|
from qiskit import *
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
import matplotlib.pyplot as plotter
import numpy as np
from IPython.display import display, Math, Latex
%matplotlib inline
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
qc1 = QuantumCircuit(3,3)
# All initialized to '0' by default.
qc1.x(0) #This is for the purpose of setting the control qubit to '1'
qc1.x(2) #As a result, the second target qubit becomes '1' while the first remains '0'. Now, lets's try swapping them.
#Fredkin gate:
def fredkin(qc):
qc.toffoli(0,1,2)
qc.toffoli(0,2,1)
qc.toffoli(0,1,2)
fredkin(qc1)
qc1.draw('mpl')
#First let's measure all three qubits.
#We're using the classical bits to store the result obtained on measuring each corresponding qubit.
qc1.measure(0,0)
qc1.measure(1,1)
qc1.measure(2,2)
#Now we use the same function we defined yesterday to run a quantum circuit
def run_circuit(qc2):
backend = Aer.get_backend('qasm_simulator') # we choose the simulator as our backend
result = execute(qc2, backend, shots = 2000).result() # we run the simulation
counts = result.get_counts() # we get the counts
return counts
counts1=run_circuit(qc1)
print(counts1)
plot_histogram(counts1)
qc2 = QuantumCircuit(3,3)
# All initialized to '0' by default.
qc2.x(2) #The second target qubit is initialised to '1'
fredkin(qc2)
qc2.measure(0,0)
qc2.measure(1,1)
qc2.measure(2,2)
qc2.draw(output='mpl')
counts2=run_circuit(qc2)
print(counts2)
plot_histogram(counts2)
qc = QuantumCircuit(1)
#This is how we apply the rotation operators in Qiskit, mentioning the angle of rotation and qubit no. as parameters
qc.rx(np.pi/2, 0)
qc.draw('mpl')
def final_vector(qc):
backend = Aer.get_backend('statevector_simulator')
job = execute(qc, backend)
result = job.result()
outputstate = result.get_statevector(qc, decimals=3)
return outputstate
print(final_vector(qc))
# This prints the vector obtained on applying the above gate to the qubit state '0'
# The Pauli-X gate serves this purpose, as demonstrated below:
qc3 = QuantumCircuit(1)
theta = np.pi/7
qc3.x(0)
qc3.ry(theta, 0)
qc3.x(0)
print(final_vector(qc3))
qc3 = QuantumCircuit(1)
qc3.ry(-theta, 0)
print(final_vector(qc3))
#Run this code for different values of theta and see if the two vectors printed are equal in each case
qc4 = QuantumCircuit(1)
alpha = np.pi/2
beta = 0
gamma = np.pi/2
delta = np.pi
def A(qc, qbits, beta, gamma):
qc.ry(gamma/2, qbits)
qc.rz(beta, qbits)
def B(qc, qbits, beta, gamma, delta):
qc.rz(-(beta+delta)/2, qbits)
qc.ry(-gamma/2, qbits)
def C(qc, qbits, beta, delta):
qc.rz((delta-beta)/2, qbits)
C(qc4, 0, beta, delta)
qc4.x(0)
B(qc4, 0, beta, gamma, delta)
qc4.x(0)
A(qc4, 0, beta, gamma)
qc4.unitary([[1.j, 0.], [0., 1.j]], [0])
print(final_vector(qc4))
qc4 = QuantumCircuit(1)
qc4.h(0)
print(final_vector(qc4))
qc5 = QuantumCircuit(3, 3)
# Target qubit q1 is initially |1> and target qubit q2 is initially |0>.
qc5.x(0) # Control qubit initialized to |1> to see effects of controlled Hadamard.
qc5.x(1) # One target qubit initialized to |1>.
alpha = np.pi/2
beta = 0
gamma = np.pi/2
delta = np.pi
def A(qc, qbits, beta, gamma):
qc.ry(gamma/2, qbits)
qc.rz(beta, qbits)
def B(qc, qbits, beta, gamma, delta):
qc.rz(-(beta+delta)/2, qbits)
qc.ry(-gamma/2, qbits)
def C(qc, qbits, beta, delta):
qc.rz((delta-beta)/2, qbits)
C(qc5, [1, 2], beta, delta)
qc5.cx(0, [1, 2])
B(qc5, [1, 2], beta, gamma, delta)
qc5.cx(0, [1, 2])
A(qc5, [1, 2], beta, gamma)
qc5.s(0) # Using S gate because alpha = pi/2
qc5.measure(0, 0)
qc5.measure(1, 1)
qc5.measure(2, 2)
qc5.draw('mpl')
def run_circuit(qc):
backend = Aer.get_backend('qasm_simulator')
result = execute(qc, backend, shots = 10000).result()
counts = result.get_counts()
return counts
counts = run_circuit(qc5)
print(counts)
plot_histogram(counts)
qc_u3=QuantumCircuit(1)
qc_u3.u3(np.pi/6,-np.pi/2,np.pi/2,0)
print(final_vector(qc_u3))
qc_rx=QuantumCircuit(1)
qc_rx.rx(np.pi/6,0)
print(final_vector(qc_rx))
#Getting the same results will verify our observation stated above
######### Defining some constants and functions ##########
# Constants for the decomposition of Hadamard gate.
H_alpha = np.pi/2
H_beta = 0
H_gamma = np.pi/2
H_delta = np.pi
# V^2 = X
V = [[0.5+0.5j, 0.5-0.5j],
[0.5-0.5j, 0.5+0.5j]]
# Constants for the decomposition of V (where V^2 = X).
V_alpha = np.pi/4
V_beta = np.pi/2
V_gamma = -np.pi/2
V_delta = -np.pi/2
# Functions to implement A, B, C (generalized).
def A_gate(qc, qbits, beta, gamma):
qc.ry(gamma/2, qbits)
qc.rz(beta, qbits)
def B_gate(qc, qbits, beta, gamma, delta):
qc.rz(-(beta+delta)/2, qbits)
qc.ry(-gamma/2, qbits)
def C_gate(qc, qbits, beta, delta):
qc.rz((delta-beta)/2, qbits)
# Higher abstraction functions.
def controlled_V(qc, control, target):
C_gate(qc, target, V_beta, V_delta)
qc.cx(control, target)
B_gate(qc, target, V_beta, V_gamma, V_delta)
qc.cx(control, target)
A_gate(qc, target, V_beta, V_gamma)
qc.t(control) # Using T gate because V_alpha = pi/4.
def controlled_Vdg(qc, control, target):
C_gate(qc, target, V_beta, V_delta)
qc.cx(control, target)
B_gate(qc, target, V_beta, -V_gamma, V_delta)
qc.cx(control, target)
A_gate(qc, target, V_beta, -V_gamma)
qc.tdg(control) # Using Tdg gate because V_alpha = pi/4, so Vdg_alpha would be -pi/4.
def double_controlled_X(qc, control1, control2, target):
controlled_V(qc, control2, target)
qc.cx(control1, control2)
controlled_Vdg(qc, control2, target)
qc.cx(control1, control2)
controlled_V(qc, control1, target)
############ Constructing the circuit ##############
qc6 = QuantumCircuit(7, 5) # No need to measure ancillary qubits :P
# q0, q1, q2, q3 are control qubits
# q4, q5 are ancillary qubits
# q6 is the target qubit
# Change the following line to try different combinations of control qubits:
qc6.x([0,1,2,3])
C_gate(qc6, 6, H_beta, H_delta)
double_controlled_X(qc6, 0, 1, 4)
double_controlled_X(qc6, 2, 3, 5)
double_controlled_X(qc6, 4, 5, 6)
double_controlled_X(qc6, 2, 3, 5)
double_controlled_X(qc6, 0, 1, 4)
B_gate(qc6, 6, H_beta, H_gamma, H_delta)
double_controlled_X(qc6, 0, 1, 4)
double_controlled_X(qc6, 2, 3, 5)
double_controlled_X(qc6, 4, 5, 6)
double_controlled_X(qc6, 2, 3, 5)
double_controlled_X(qc6, 0, 1, 4)
A_gate(qc6, 6, H_beta, H_gamma)
qc6.s([0,1,2,3]) # Using S gate because H_alpha = pi/2.
qc6.measure(0, 0)
qc6.measure(1, 1)
qc6.measure(2, 2)
qc6.measure(3, 3)
qc6.measure(6, 4)
qc6.draw('mpl')
def run_circuit(qc):
backend = Aer.get_backend('qasm_simulator')
result = execute(qc, backend, shots = 2000).result()
counts = result.get_counts()
return counts
counts = run_circuit(qc6)
print(counts)
plot_histogram(counts)
|
https://github.com/ankitkmisra/Quantum-Computing-and-Cryptography
|
ankitkmisra
|
from qiskit import *
from qiskit.tools.jupyter import *
from qiskit.visualization import *
import matplotlib.pyplot as plotter
import numpy as np
from IPython.display import display, Math, Latex
%matplotlib inline
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
qr = QuantumRegister(3)
crz = ClassicalRegister(1)
crx = ClassicalRegister(2) # we will need seperates registers for using 'c_if' later.
qc = QuantumCircuit(qr,crz,crx)
qc.x(0)
qc.h(0) # 'psi' can't be unknown to us as we are creating it here. Let us take '-' state as our 'psi'
# We will verify later if the '-' is been teleported.
qc.h(1)
qc.cx(1,2) # creating a bell state
qc.barrier() # Use barrier to separate steps, everything till this barrier is just intialisation.
qc.cx(0,1) # '0' and '1' are with Alice and '2' is with Bob.
# psi_1 prepared.
qc.h(0)
# psi_2 prepared.
qc.barrier()
qc.measure(0,0)
qc.measure(1,1)
qc.draw (output = 'mpl')
qc.x(2).c_if(crx,1) # 'c_if' compares a classical register with a value (either 0 or 1) and performs the
qc.z(2).c_if(crz,1) # operation if they are equal.
qc.draw('mpl')
# be careful of the order of applying X and Z!
qc.h(2)
qc.measure(2,crx[1])
def run_circuit(qc):
backend = Aer.get_backend('qasm_simulator') # we choose the simulator as our backend
result = execute(qc, backend, shots = 10000).result() # we run the simulation
counts = result.get_counts() # we get the counts
return counts
counts = run_circuit(qc)
print(counts)
plot_histogram(counts)
# the output should be '1xx' if the teleportation is successful.
# Refer to above cell for a detailed explanation of the strategy.
qc1 = QuantumCircuit(2, 2)
# Preparing Alice's Bell state: \beta_{00}
qc1.h(0)
qc1.cx(0, 1)
# Skyler's mischief:
# Suppose for this example that she applied Pauli-Y.
# You can change 'y' to 'x' or 'z' in the following line for other cases.
qc1.y(0)
# Alice's strategy:
qc1.cx(0, 1)
qc1.h(0)
qc1.measure(0, 0)
qc1.measure(1, 1)
qc1.draw('mpl')
def run_circuit(qc):
backend = Aer.get_backend('qasm_simulator') # we choose the simulator as our backend
result = execute(qc, backend, shots = 10000).result() # we run the simulation
counts = result.get_counts() # we get the counts
return counts
counts = run_circuit(qc1)
print(counts)
if '10' in counts:
print('Skyler used Pauli-X!')
if '11' in counts:
print('Skyler used Pauli-Y!')
if '01' in counts:
print('Skyler used Pauli-Z!')
plot_histogram(counts)
|
https://github.com/ankitkmisra/Quantum-Computing-and-Cryptography
|
ankitkmisra
|
%matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import *
from qiskit.compiler import *
from qiskit.tools.jupyter import *
from qiskit.visualization import *
import numpy as np
import qiskit.quantum_info as qi
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
#This cell is just for seeing what the U tilde matrix looks like
a, b, c, d = np.cos(np.pi/8), np.sin(np.pi/8), -np.sin(np.pi/8), np.cos(np.pi/8)
u_tilde = np.array([[a,c],[b,d]]).reshape(2,2)
print(u_tilde)
#This cell defines the controlled variant of the U tilde matrix
qc_for_u = QuantumCircuit(1)
qc_for_u.ry(np.pi/4, 0)
qc_for_u.name = "U"
controlled_u_tilde = qc_for_u.to_gate().control(2)
qc1 = QuantumCircuit(3)
qc1.x(0)
qc1.x(1)
qc1.toffoli(0,1,2)#Flipping the third bit if the first two are zero
qc1.x(0) #Essentially 000 -> 001
qc1.x(1)
qc1.x(0)
qc1.toffoli(0,2,1)#Flipping the second bit if the first bit is zero and the third is one
qc1.x(0) #Essentially 001 -> 011
qc1.append(controlled_u_tilde, [1, 2, 0])
qc1.x(0)
qc1.toffoli(0,2,1)#Undoing the flip from before
qc1.x(0)
qc1.x(0)
qc1.x(1)
qc1.toffoli(0,1,2)#Undoing the flip from before
qc1.x(0)
qc1.x(1)
qc1.draw('mpl')
U_circ = qi.Operator(qc1).data
print(U_circ)
qc2 = QuantumCircuit(3)
# Code for U
qc2.x(0)
qc2.x(1)
qc2.toffoli(0,1,2)#Flipping the third bit if the first two are zero
qc2.x(0) #Essentially 000 -> 001
qc2.x(1)
qc2.x(0)
qc2.toffoli(0,2,1)#Flipping the second bit if the first bit is zero and the third is one
qc2.x(0) #Essentially 001 -> 011
qc2.append(controlled_u_tilde, [1, 2, 0])
qc2.x(0)
qc2.toffoli(0,2,1)#Undoing the flip from before
qc2.x(0)
qc2.x(0)
qc2.x(1)
qc2.toffoli(0,1,2)#Undoing the flip from before
qc2.x(0)
qc2.x(1)
# Code for V
qc2.x(0)
qc2.toffoli(0,1,2) # |010> -> |011>
qc2.x(0)
qc2.toffoli(1,2,0) # V-tilde is the same as Toffoli
qc2.x(0)
qc2.toffoli(0,1,2) # Reversing the flip
qc2.x(0)
qc2.draw('mpl')
def without_global_phase(matrix: np.ndarray, atol: float = 1e-8) :
phases1 = np.angle(matrix[abs(matrix) > atol].ravel(order='F'))
if len(phases1) > 0:
matrix = np.exp(-1j * phases1[0]) * matrix
return matrix
V_circ = without_global_phase(qi.Operator(qc2).data)
print(V_circ)
#Function just returns norm ignoring global phase between unitaries
def norm(unitary_a: np.ndarray, unitary_b: np.ndarray) :
return np.linalg.norm(without_global_phase(unitary_b)-without_global_phase(unitary_a), ord=2)
#Make the Pauli Y gate
qcy = QuantumCircuit(1)
for i in range(6):
qcy.t(0)
qcy.h(0)
for i in range(4):
qcy.t(0)
qcy.h(0)
for i in range(2):
qcy.t(0)
Y_circ = qi.Operator(qcy).data
Y = np.array([[0,-1j],[1j,0]])
print(norm(Y_circ,Y))
print("Final Circuit:")
qcy.draw('mpl')
uni_q = np.array([[-0.25+0.60355339j, 0.60355339+0.45710678j],
[0.60355339-0.45710678j, 0.25+0.60355339j]]).reshape(2,2)
while True:
qc3 = QuantumCircuit(1)
for i in range(5):
for j in range(np.random.randint(8)):
qc3.t(0)
qc3.h(0)
for j in range(np.random.randint(8)):
qc3.t(0)
uni_q_circ = qi.Operator(qc3).data
if norm(uni_q_circ,uni_q) < 1e-8:
break
print("Final Error: ", norm(uni_q_circ,uni_q))
print("Final Circuit:")
qc3.draw('mpl')
#Defining the gate as controlled_irx
from qiskit.extensions import *
pi_alpha = np.arccos(0.6)
qc_for_irx = QuantumCircuit(1)
irx = np.array([[1j*np.cos(pi_alpha/2),np.sin(pi_alpha/2)],[np.sin(pi_alpha/2),1j*np.cos(pi_alpha/2)]]).reshape(2,2)
g_irx = UnitaryGate(data=irx,label=None)
controlled_irx = g_irx.control(2)
def final_vector(qc):
backend = Aer.get_backend('statevector_simulator')
job = execute(qc, backend)
result = job.result()
outputstate = result.get_statevector(qc, decimals=3)
return outputstate
n = 4
qcb = QuantumCircuit(n,n)
qcb.x(0)#Ancilla
qcb.x(1)#Ancilla You can use these two as control to use the controlled_irx gate
count1 = 0
while abs(0.5 - (count1*pi_alpha/np.pi)%2) >= 1e-2 or count1 % 4 != 0:
count1 += 1
count2 = 0
while abs(1.5 - (count2*pi_alpha/np.pi)%2) >= 1e-2 or count2 % 4 != 0:
count2 += 1
count3 = 0
while abs(4.0 - (count3*pi_alpha/np.pi)%4) >= 1e-2 or count3 % 4 != 2:
count3 += 1
for i in range(count1): # Rotation about x by pi/2 (count1 % 4 == 0)
qcb.append(controlled_irx, [0, 1, 2])
qcb.cx(2, 3)
for i in range(count2): # Rotation about x by -pi/2 (count2 % 4 == 0)
qcb.append(controlled_irx, [0, 1, 2])
qcb.x(0)
qcb.cx(3, 0)
for i in range(count3): # Rotation about x by 0 (count3 % 4 == 2)
qcb.append(controlled_irx, [0, 2, 3])
qcb.cx(3, 0)
qcb.x(0)
print("Executing circuit...")
#Get state of qubit which should have the |+> state using the backend simulator
i = 3 #Index for the qubit at |+> state
qcb.h(i)#Puts the |+> state to |0>
for i in range(4):
qcb.measure(i, i)
def run_circuit(qcb):
backend = Aer.get_backend('qasm_simulator') # we choose the simulator as our backend
result = execute(qcb, backend, shots = 2000).result() # we run the simulation
counts = result.get_counts() # we get the counts
return counts
counts = run_circuit(qcb)
print(counts)
plot_histogram(counts)
|
https://github.com/ankitkmisra/Quantum-Computing-and-Cryptography
|
ankitkmisra
|
%matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
import numpy as np
from fractions import Fraction as frac
import qiskit.quantum_info as qi
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
qc=QuantumCircuit(4)
#In this particular oracle, the last qubit is storing the value of the function
qc.cx(0,3)
qc.cx(1,3)
qc.cx(2,3)
#The last qubit is 1 if there are odd no. of 1s in the other 3 qubits
#and 0 otherwise
#Hence it is a balanced function
qc.draw('mpl')
qc1=QuantumCircuit(3)
qc1.x(2)
qc1.h(0)
qc1.h(1)
qc1.h(2)
qc1.barrier(range(3))
qc1.cx(0,2)
qc1.cx(1,2)
qc1.barrier(range(3))
qc1.h(0)
qc1.h(1)
meas = QuantumCircuit(3, 2)
meas.measure(range(2),range(2))
# The Qiskit circuit object supports composition using
# the addition operator.
circ = qc1+meas
circ.draw('mpl')
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = execute(circ, backend_sim, shots=1000)
result_sim = job_sim.result()
counts = result_sim.get_counts(circ)
print(counts)
plot_histogram(counts)
qc2=QuantumCircuit(5)
qc2.x(4)
qc2.h(0)
qc2.h(1)
qc2.h(2)
qc2.h(3)
qc2.h(4)
qc2.barrier(range(5))
#Your code for the oracle here
#YOU ARE PERMITTED TO USE ONLY SINGLE QUBIT GATES AND CNOT(cx) GATES
qc2.cx(0,4)
qc2.cx(1,4)
qc2.cx(2,4)
qc2.cx(3,4)
qc2.x(4)
qc2.barrier(range(5))
qc2.h(0)
qc2.h(1)
qc2.h(2)
qc2.h(3)
meas2 = QuantumCircuit(5, 4)
meas2.measure(range(4),range(4))
circ2 = qc2+meas2
circ2.draw('mpl')
#verification cell, reinitialising the circuit so that it's easier for you to copy-paste the oracle
qc2=QuantumCircuit(5)
#Add X gates HERE as required to change the input state
qc2.x([0,2])
qc2.barrier(range(5))
qc2.cx(0,4)
qc2.cx(1,4)
qc2.cx(2,4)
qc2.cx(3,4)
qc2.x(4)
qc2.barrier(range(5))
measv = QuantumCircuit(5, 1)
measv.measure(4,0)
circv = qc2+measv
circv.draw('mpl')
#DO NOT RUN THIS CELL WITHOUT EDITING THE ABOVE ONE AS DESIRED
#The following code will give you f(x) for the value of x you chose in the above cell
backend_sim2 = Aer.get_backend('qasm_simulator')
job_sim2 = execute(circv, backend_sim2, shots=1000)
result_sim2 = job_sim2.result()
counts2 = result_sim2.get_counts(circv)
print(counts2)
plot_histogram(counts2)
|
https://github.com/ankitkmisra/Quantum-Computing-and-Cryptography
|
ankitkmisra
|
%matplotlib inline
# Importing standard Qiskit libraries
import random
from qiskit import *
from qiskit.tools.jupyter import *
from qiskit.visualization import *
#Get the library to check the answers
%pip install -I git+https://github.com/mnp-club/MnP_QC_Workshop.git
from mnp_qc_workshop_2020.bb84 import *
# Configuring account
provider = IBMQ.load_account()
backend = provider.get_backend('ibmq_qasm_simulator') # with this simulator it wouldn't work \
# Initial setup
random.seed(64) # do not change this seed, otherwise you will get a different key
random.seed(64)
# This is your 'random' bit string that determines your bases
numqubits = 16
bob_bases = str('{0:016b}'.format(random.getrandbits(numqubits)))
def bb84():
print('Bob\'s bases:', bob_bases)
# Now Alice will send her bits one by one...
all_qubit_circuits = []
for qubit_index in range(numqubits):
# This is Alice creating the qubit
thisqubit_circuit = alice_prepare_qubit(qubit_index)
# This is Bob finishing the protocol below
bob_measure_qubit(bob_bases, qubit_index, thisqubit_circuit)
# We collect all these circuits and put them in an array
all_qubit_circuits.append(thisqubit_circuit)
# Now execute all the circuits for each qubit
results = execute(all_qubit_circuits, backend=backend, shots=1).result()
# And combine the results
bits = ''
for qubit_index in range(numqubits):
bits += [measurement for measurement in results.get_counts(qubit_index)][0]
return bits
# Here is your task
def bob_measure_qubit(bob_bases, qubit_index, qubit_circuit):
if bob_bases[qubit_index] == '1':
qubit_circuit.h(0)
qubit_circuit.measure(0, 0)
bits = bb84()
print('Bob\'s bits: ', bits)
check_bits(bits)
alice_bases = '0100000101011100' # Alice's bases bits
key = ''
for i in range(16):
if bob_bases[i] == alice_bases[i]:
key += bits[i]
print(key)
check_key(key)
message = get_message()# encrypted message
decrypted = ''
for i in range(len(message)):
x = key[-(i%len(key))-1]
y = message[-i-1]
if x == y:
decrypted = '0' + decrypted
else:
decrypted = '1' + decrypted
print(decrypted)
check_decrypted(decrypted)
decrypted_to_string_ASCII = ''
i = 0
while i < 43:
decrypted_to_string_ASCII += decrypted[]
check_message(decrypted_to_string_ASCII)
|
https://github.com/ankitkmisra/Quantum-Computing-and-Cryptography
|
ankitkmisra
|
from qiskit import *
from qiskit.compiler import *
from qiskit.tools.jupyter import *
from qiskit.visualization import *
import matplotlib.pyplot as plotter
import numpy as np
from IPython.display import display, Math, Latex
%matplotlib inline
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
qc1=QuantumCircuit(2)
qc1.h(0)
qc1.h(1)
qc1.barrier() #The part between the barriers is our oracle
qc1.cz(0,1)
#We are using a controlled-Z gate which flips the sign of the second qubit when both qubits are set to '1'
qc1.barrier()
qc1.draw('mpl')
def final_vector(qc):
backend = Aer.get_backend('statevector_simulator')
job = execute(qc, backend)
result = job.result()
outputstate = result.get_statevector(qc, decimals=3)
return outputstate
print(final_vector(qc1)) #We can see that the desired state has been obtained
qc2=QuantumCircuit(3)
qc2.h(0)
qc2.h(1)
qc2.h(2)
qc2.barrier()
#The part between the barriers is our oracle
qc2.x(0)
qc2.h(1)
qc2.x(2)
qc2.ccx(0, 2, 1)
qc2.x(0)
qc2.h(1)
qc2.x(2)
qc2.barrier()
qc2.draw('mpl')
def final_vector(qc):
backend = Aer.get_backend('statevector_simulator')
job = execute(qc, backend)
result = job.result()
outputstate = result.get_statevector(qc, decimals=3)
return outputstate
print(final_vector(qc2))
def ccz_gate(qc,a,b,c):
qc.h(c)
qc.ccx(a,b,c)
qc.h(c)
#Let's create an oracle which will mark the states 101 and 110
#(This particular oracle won't be using ancilla qubits)
def phase_oracle(circuit):
circuit.cz(0, 2)
circuit.cz(0, 1)
n=3
qc2=QuantumCircuit(n,n)
for i in range(0,n):
qc2.h(i)
qc2.barrier([0,1,2])
#This creates a superposition of all states
#We will now perform the Grover iteration
phase_oracle(qc2)
qc2.barrier([0,1,2])
for i in range(0,n):
qc2.h(i)
#Performing a conditional phase shift
qc2.x(0)
qc2.x(1)
qc2.x(2)
ccz_gate(qc2,0,1,2)
qc2.x(0)
qc2.x(1)
qc2.x(2)
for i in range(0,n):
qc2.h(i)
#The Grover iteration is now complete
qc2.barrier([0,1,2])
qc2.draw('mpl')
qc2.measure(0,0)
qc2.measure(1,1)
qc2.measure(2,2)
qc2.draw('mpl')
def counts_circ(circ):
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = execute(circ, backend_sim, shots=2000)
result_sim = job_sim.result()
counts = result_sim.get_counts(circ)
return(counts)
plot_histogram(counts_circ(qc2))
qc_mct=QuantumCircuit(5,5)
for i in range(0,4):
qc_mct.x(i)
qc_mct.mct([0,1,2,3],4)
qc_mct.draw('mpl')
qc_mct.measure(0,0)
qc_mct.measure(1,1)
qc_mct.measure(2,2)
qc_mct.measure(3,3)
qc_mct.measure(4,4)
plot_histogram(counts_circ(qc_mct))
def c3z_gate(qc, a, b, c, d):
qc.h(d)
qc.mct([a, b, c], d)
qc.h(d)
def phase_oracle(qc):
qc.x(1)
qc.x(3)
c3z_gate(qc, 0, 1, 2, 3) # Handles 1010
qc.x(2)
c3z_gate(qc, 0, 1, 2, 3) # Handles 1000
qc.x(3)
c3z_gate(qc, 0, 1, 2, 3) # Handles 1001
qc.x(2)
qc.x(0)
qc.x(3)
c3z_gate(qc, 0, 1, 2, 3) # Handles 0010
qc.x(0)
qc.x(1)
qc.x(3)
n = 4
qc3 = QuantumCircuit(n, n)
for i in range(0,n):
qc3.h(i)
qc3.barrier([0, 1, 2, 3])
phase_oracle(qc3)
qc3.barrier([0, 1, 2, 3])
for i in range(0,n):
qc3.h(i)
qc3.x(0)
qc3.x(1)
qc3.x(2)
qc3.x(3)
c3z_gate(qc3, 0, 1, 2, 3)
qc3.x(0)
qc3.x(1)
qc3.x(2)
qc3.x(3)
for i in range(0,n):
qc3.h(i)
qc3.barrier([0, 1, 2, 3])
qc3.measure(0, 0)
qc3.measure(1, 1)
qc3.measure(2, 2)
qc3.measure(3, 3)
qc3.draw('mpl')
def counts_circ(circ):
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = execute(circ, backend_sim, shots=2000)
result_sim = job_sim.result()
counts = result_sim.get_counts(circ)
return(counts)
plot_histogram(counts_circ(qc3))
|
https://github.com/IlliaOvcharenko/quantum-search
|
IlliaOvcharenko
|
import sys, os
sys.path.append(os.getcwd())
import matplotlib
matplotlib.use('Agg')
import math
import numpy as np
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.primitives.sampler import Sampler
from fire import Fire
def run_quantum_search(
array_len: int | None = None,
n_grover_iterations: int | None = None,
):
np.random.seed(42)
array = np.arange(array_len)
np.random.shuffle(array)
item = np.random.choice(array)
array = array.tolist()
print(f"Input array: {array}")
print(f"Item to search: {item}")
print(f"Correct answer should be: {array.index(item)}")
n_index_qbits = math.ceil(math.log(len(array), 2))
n_value_qbits = math.ceil(math.log(max(array), 2))
to_bits = lambda i: bin(i)[2:][::-1]
to_int = lambda b: int(b[::-1], 2)
index_qbits = [i for i in range(n_index_qbits)]
value_qbits = [i + n_index_qbits for i in range(n_value_qbits)]
phase_qbit = n_index_qbits + n_value_qbits
if n_grover_iterations is None:
n_grover_iterations = math.floor(math.sqrt(len(array)))
qc = QuantumCircuit(
QuantumRegister(n_index_qbits, "index"),
QuantumRegister(n_value_qbits, "value"),
QuantumRegister(1, "phase"),
icr := ClassicalRegister(n_index_qbits, "meas-index"),
)
qc.h(index_qbits)
qc.x(phase_qbit)
qc.h(phase_qbit)
def add_oracle(global_qc):
qc = QuantumCircuit(
QuantumRegister(n_index_qbits, "index"),
QuantumRegister(n_value_qbits, "value"),
QuantumRegister(1, "phase"),
)
for array_idx in range(len(array)):
qc.barrier()
array_idx_bit = to_bits(array_idx)[:n_index_qbits]
array_idx_bit += "0" * (n_index_qbits - len(array_idx_bit))
array_item = array[array_idx]
array_item_bit = to_bits(array_item)[:n_value_qbits]
array_item_bit += "0" * (n_value_qbits - len(array_item_bit))
zeros = [index_qbits[i] for i, b in enumerate(array_idx_bit) if b == "0"]
ones = [value_qbits[i] for i, b in enumerate(array_item_bit) if b == "1"]
for value_idx in ones:
if zeros:
qc.x(zeros)
qc.mcx(index_qbits, value_idx)
if zeros:
qc.x(zeros)
global_qc = global_qc.compose(qc)
item_bit = to_bits(item)
item_bit += "0" * (n_value_qbits - len(item_bit))
zeros = [value_qbits[i] for i, b in enumerate(item_bit) if b == "0"]
if zeros:
global_qc.x(zeros)
global_qc.mcx(value_qbits, phase_qbit)
if zeros:
global_qc.x(zeros)
global_qc = global_qc.compose(qc.inverse())
return global_qc
def add_diffuser(global_qc):
qc = QuantumCircuit(
QuantumRegister(n_index_qbits, "index"),
QuantumRegister(n_value_qbits, "value"),
QuantumRegister(1, "phase"),
)
qc.h(index_qbits)
qc.x(index_qbits)
qc.mcx(index_qbits, phase_qbit)
qc.x(index_qbits)
qc.h(index_qbits)
global_qc = global_qc.compose(qc)
return global_qc
for _ in range(n_grover_iterations):
qc = add_oracle(qc)
qc = add_diffuser(qc)
qc.measure(index_qbits, icr)
sampler = Sampler()
job = sampler.run(qc, shots=64)
result = job.result()
index_dist = result.quasi_dists[0]
index_pred = max(index_dist.items(), key=lambda x: x[1])
print(f"Search result, index: {index_pred[0]}, " \
f"empirical prob to collapse in this state: {index_pred[1]}")
print(f"Prob to collapse into a correct state: {index_dist[array.index(item)]}")
print()
return index_pred
import psutil
import os
import gc
from datetime import datetime
from functools import partial
class MeasureResult:
def __init__(self, return_value, func_name = None):
self.return_value = return_value
self.measurements = {}
self.func_name = func_name
def print(self):
if self.func_name:
print(f"func: {self.func_name}")
for k, v in self.measurements.items():
print(f"\t{k} - {v}")
print()
# def __call__():
# return self.func()
def get_func_name(f):
if isinstance(f, partial):
return f.func.__name__ + " with args " + str(f.args) + " with kwargs " + str(f.keywords)
return f.__name__
def define_name(name, measurements, depth=0):
try_name = name
if depth != 0:
try_name += f"_{depth}"
if try_name in measurements:
return define_name(name, measurements, depth=depth+1)
else:
return try_name
def measure_exec_time(f):
def nested_func():
start_t = datetime.now().timestamp()
rv = f()
end_t = datetime.now().timestamp()
exec_time = end_t - start_t
if not isinstance(rv, MeasureResult):
rv = MeasureResult(rv, func_name=get_func_name(f))
measure_name = define_name("exec_time", rv.measurements)
rv.measurements[measure_name] = exec_time
return rv
return nested_func
def measure_ram_usage(f):
def nested_func():
pid = os.getpid()
current_process = psutil.Process(pid)
start_ram = current_process.memory_info().rss / (1024 * 1024)
# print(start_ram)
# exit(0)
rv = f()
end_ram = current_process.memory_info().rss / (1024 * 1024)
ram_usage = end_ram - start_ram
if not isinstance(rv, MeasureResult):
rv = MeasureResult(rv, func_name=get_func_name(f))
measure_name = define_name("ram_usage", rv.measurements)
rv.measurements[measure_name] = ram_usage
return rv
return nested_func
def apply_measurements(f, ms):
m = ms.pop()
if not ms:
return m(f)
return apply_measurements(m(f), ms)
def print_measure(f):
def nested_func():
rv = f()
if isinstance(rv, MeasureResult):
rv.print()
else:
print(f"there is nothing to print yet :(")
return rv
return nested_func
def plot_with_number_of_input_data():
array_len_param = [v for v in range(10, 71, 10)]
# array_len_param = [v for v in range(10, 31, 10)]
print(array_len_param)
measurements = []
for al in array_len_param:
run_quantum_search_with_measurements = apply_measurements(
partial(run_quantum_search, array_len=al),
[print_measure, measure_exec_time, measure_ram_usage, measure_exec_time],
)
meas = run_quantum_search_with_measurements()
measurements.append(meas)
gc.collect()
plt.figure(figsize=(15, 10))
plt.plot(array_len_param, [m.measurements["exec_time"] for m in measurements], "-*")
plt.xlabel("N, input array len")
plt.ylabel("execution time, s")
plt.grid()
plt.savefig(f"figs/n-exec-time.png", bbox_inches="tight")
plt.figure(figsize=(15, 10))
plt.plot(array_len_param, [m.measurements["ram_usage"] for m in measurements], "-*")
plt.xlabel("N, input array len")
plt.ylabel("RAM usage, s")
plt.grid()
plt.savefig(f"figs/n-ram-usage.png", bbox_inches="tight")
# for m in measurements:
# m.print()
# run_quantum_search_with_measurements = apply_measurements(
# partial(run_quantum_search, array_len=10),
# [measure_exec_time, measure_ram_usage, measure_exec_time],
# )
# m = run_quantum_search_with_measurements()
# m.print()
def plot_with_number_of_grover_iter():
array_len = 32
n_iter_param = [v for v in range(1, 8+1)]
# n_iter_param = [v for v in range(10)]
pred = []
confidence = []
for ni in n_iter_param:
print(f"num of iter: {ni}")
result = run_quantum_search(array_len=array_len, n_grover_iterations=ni)
pred.append(result[0])
confidence.append(result[1])
print(pred)
print(confidence)
plt.figure(figsize=(15, 10))
plt.plot(n_iter_param, confidence, "-*")
plt.xlabel("number of grover iterations")
plt.ylabel("prob to collapse in a correct state")
plt.axvline(math.floor(math.sqrt(array_len)), c="red")
plt.grid()
plt.savefig(f"figs/grover-iter-prob.png", bbox_inches="tight")
def plot_linear_vs_sqrt():
x = np.arange(100)
plt.figure(figsize=(15, 10))
plt.plot(x, x, "-", label="linear search", c="b")
plt.plot(x, [math.floor(math.sqrt(v)) for v in x], "-", label="quantum search", c="r")
plt.xlabel("number of input data")
plt.ylabel("number of required iterations")
plt.legend()
plt.grid()
plt.savefig(f"figs/linear-vs-sqrt.png", bbox_inches="tight")
def main():
# plot_with_number_of_input_data()
# plot_with_number_of_grover_iter()
plot_linear_vs_sqrt()
if __name__ == "__main__":
Fire(main)
|
https://github.com/IlliaOvcharenko/quantum-search
|
IlliaOvcharenko
|
import sys, os
sys.path.append(os.getcwd())
import matplotlib
matplotlib.use('Agg')
import math
import numpy as np
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime import (QiskitRuntimeService,
SamplerV2 as Sampler)
from fire import Fire
def main()
ibm_token = open("credentials/ibm-token.txt").read().replace("\n", "")
ibm_quantum_service = QiskitRuntimeService(channel="ibm_quantum", token=ibm_token)
array = [4, 7, 2, 1, 3]
# item = 5 # answer should be 6
# item = 4 # answer should be 0
item = 2 # answer should be 5
# array = [4, 7, 2, 1, 3, 0, 5, 6]
# # item = 5 # answer should be 6
# # item = 4 # answer should be 0
# item = 0 # answer should be 5
# array = np.arange(50)
# np.random.seed(42)
# np.random.shuffle(array)
# array = array.tolist()
# item = 10
print(f"Input array: {array}")
print(f"Item to search: {item}")
print(f"Answer: {array.index(item)}")
# evalue)
n_index_qbits = math.ceil(math.log(len(array), 2))
n_value_qbits = math.ceil(math.log(max(array), 2))
to_bits = lambda i: bin(i)[2:][::-1]
to_int = lambda b: int(b[::-1], 2)
# print(array)
# print([to_bits(v) for v in array])
# print([to_int(to_bits(v)) for v in array])
# exit(0)
index_qbits = [i for i in range(n_index_qbits)]
value_qbits = [i + n_index_qbits for i in range(n_value_qbits)]
phase_qbit = n_index_qbits + n_value_qbits
print(f"N qubits for index: {n_index_qbits}")
print(f"N qubits for value: {n_value_qbits}")
# n_grover_iterations = math.floor(math.sqrt(len(array)))
n_grover_iterations = 1
print(f"Num of grover iterations: {n_grover_iterations}")
# print(index_qbits)
# print(value_qbits)
# print(phase_qbit)
# exit(0)
qc = QuantumCircuit(
QuantumRegister(n_index_qbits, "index"),
QuantumRegister(n_value_qbits, "value"),
QuantumRegister(1, "phase"),
icr := ClassicalRegister(n_index_qbits, "meas-index"),
# ClassicalRegister(3, "meas-value"),
# pcr := ClassicalRegister(1, "meas-phase"),
)
# TODO hadamar for index
# TODO ket minus for phase
qc.h(index_qbits)
# qc.x(index_qbits[0])
# qc.x(index_qbits[1])
qc.x(phase_qbit)
qc.h(phase_qbit)
def add_oracle(global_qc):
qc = QuantumCircuit(
QuantumRegister(n_index_qbits, "index"),
QuantumRegister(n_value_qbits, "value"),
QuantumRegister(1, "phase"),
# vcr := ClassicalRegister(3, "meas-index"),
# ClassicalRegister(3, "meas-value"),
# pcr := ClassicalRegister(3, "meas-phase"),
)
for array_idx in range(len(array)):
# qc.barrier()
array_idx_bit = to_bits(array_idx)[:n_index_qbits]
array_idx_bit += "0" * (n_index_qbits - len(array_idx_bit))
array_item = array[array_idx]
array_item_bit = to_bits(array_item)[:n_value_qbits]
array_item_bit += "0" * (n_value_qbits - len(array_item_bit))
zeros = [index_qbits[i] for i, b in enumerate(array_idx_bit) if b == "0"]
ones = [value_qbits[i] for i, b in enumerate(array_item_bit) if b == "1"]
# print(array_idx)
# print(array_idx_bit)
# print(array_item)
# print(array_item_bit)
# print(zeros)
# print(ones)
# print()
for value_idx in ones:
if zeros:
qc.x(zeros)
qc.mcx(index_qbits, value_idx)
if zeros:
qc.x(zeros)
global_qc = global_qc.compose(qc)
item_bit = to_bits(item)
item_bit += "0" * (n_value_qbits - len(item_bit))
zeros = [value_qbits[i] for i, b in enumerate(item_bit) if b == "0"]
if zeros:
global_qc.x(zeros)
global_qc.mcx(value_qbits, phase_qbit)
if zeros:
global_qc.x(zeros)
global_qc = global_qc.compose(qc.inverse())
return global_qc
def add_diffuser(global_qc):
qc = QuantumCircuit(
QuantumRegister(n_index_qbits, "index"),
QuantumRegister(n_value_qbits, "value"),
QuantumRegister(1, "phase"),
)
qc.h(index_qbits)
qc.x(index_qbits)
qc.mcx(index_qbits, phase_qbit)
qc.x(index_qbits)
qc.h(index_qbits)
global_qc = global_qc.compose(qc)
return global_qc
for _ in range(n_grover_iterations):
qc = add_oracle(qc)
qc = add_diffuser(qc)
# qc.draw("mpl")
# plt.savefig("figs/oracle-qc.png", bbox_inches="tight")
# qc.h(phase_qbit)
qc.measure(index_qbits, icr)
qc.draw("mpl")
plt.savefig("figs/oracle-qc-array-8.png", bbox_inches="tight")
# qc = qc.measure_all(inplace=False)
# sampler = Sampler()
# job = sampler.run(qc, shots=64)
# result = job.result()
# print(max(result.quasi_dists[0].items(), key=lambda x: x[1]))
# print(result.quasi_dists[0][array.index(item)])
backend = ibm_quantum_service.get_backend("ibm_sherbrooke")
# backend = ibm_quantum_service.least_busy(operational=True, simulator=False)
print(f"Selected quantum computer: {backend}")
pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
qc_opt = pm.run(qc)
# qc_opt.draw("mpl")
# plt.savefig("figs/oracle-qc-opt-array-8.png", bbox_inches="tight")
sampler = Sampler(backend=backend)
job = sampler.run([qc_opt], shots=5)
print(f"Job ID is {job.job_id()}")
# pub_result = job.result()[0]
# print(pub_result)
if __name__ == "__main__":
Fire(main)
|
https://github.com/IlliaOvcharenko/quantum-search
|
IlliaOvcharenko
|
import sys, os
sys.path.append(os.getcwd())
import matplotlib
matplotlib.use('Agg')
import math
import numpy as np
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.primitives.sampler import Sampler
from fire import Fire
def main(
array_len: int | None = None,
n_grover_iterations: int | None = None,
save_circuit_plot: bool = False,
save_state_dist_plot: bool = False,
plot_prefix: str = "",
):
np.random.seed(42)
plot_prefix = plot_prefix + "-" if plot_prefix != "" else plot_prefix
if array_len is None:
array = [4, 7, 2, 1, 3, 0, 5, 6]
# item = 5 # answer should be 6
# item = 4 # answer should be 0
item = 0 # answer should be 5
else:
array = np.arange(array_len)
np.random.shuffle(array)
item = np.random.choice(array)
array = array.tolist()
print(f"Input array: {array}")
print(f"Item to search: {item}")
print(f"Correct answer should be: {array.index(item)}")
n_index_qbits = math.ceil(math.log(len(array), 2))
n_value_qbits = math.ceil(math.log(max(array), 2))
to_bits = lambda i: bin(i)[2:][::-1]
to_int = lambda b: int(b[::-1], 2)
index_qbits = [i for i in range(n_index_qbits)]
value_qbits = [i + n_index_qbits for i in range(n_value_qbits)]
phase_qbit = n_index_qbits + n_value_qbits
print(f"N qubits for index: {n_index_qbits}")
print(f"N qubits for value: {n_value_qbits}")
if n_grover_iterations is None:
n_grover_iterations = math.floor(math.sqrt(len(array)))
print(f"Num of grover iterations: {n_grover_iterations}")
qc = QuantumCircuit(
QuantumRegister(n_index_qbits, "index"),
QuantumRegister(n_value_qbits, "value"),
QuantumRegister(1, "phase"),
icr := ClassicalRegister(n_index_qbits, "meas-index"),
)
qc.h(index_qbits)
# qc.x(index_qbits[0])
# qc.x(index_qbits[1])
qc.x(phase_qbit)
qc.h(phase_qbit)
def add_oracle(global_qc):
qc = QuantumCircuit(
QuantumRegister(n_index_qbits, "index"),
QuantumRegister(n_value_qbits, "value"),
QuantumRegister(1, "phase"),
)
for array_idx in range(len(array)):
qc.barrier()
array_idx_bit = to_bits(array_idx)[:n_index_qbits]
array_idx_bit += "0" * (n_index_qbits - len(array_idx_bit))
array_item = array[array_idx]
array_item_bit = to_bits(array_item)[:n_value_qbits]
array_item_bit += "0" * (n_value_qbits - len(array_item_bit))
zeros = [index_qbits[i] for i, b in enumerate(array_idx_bit) if b == "0"]
ones = [value_qbits[i] for i, b in enumerate(array_item_bit) if b == "1"]
for value_idx in ones:
if zeros:
qc.x(zeros)
qc.mcx(index_qbits, value_idx)
if zeros:
qc.x(zeros)
global_qc = global_qc.compose(qc)
item_bit = to_bits(item)
item_bit += "0" * (n_value_qbits - len(item_bit))
zeros = [value_qbits[i] for i, b in enumerate(item_bit) if b == "0"]
if zeros:
global_qc.x(zeros)
global_qc.mcx(value_qbits, phase_qbit)
if zeros:
global_qc.x(zeros)
global_qc = global_qc.compose(qc.inverse())
return global_qc
def add_diffuser(global_qc):
qc = QuantumCircuit(
QuantumRegister(n_index_qbits, "index"),
QuantumRegister(n_value_qbits, "value"),
QuantumRegister(1, "phase"),
)
qc.h(index_qbits)
qc.x(index_qbits)
qc.mcx(index_qbits, phase_qbit)
qc.x(index_qbits)
qc.h(index_qbits)
global_qc = global_qc.compose(qc)
return global_qc
for _ in range(n_grover_iterations):
qc = add_oracle(qc)
qc = add_diffuser(qc)
if save_circuit_plot:
qc.draw("mpl")
plt.savefig(f"figs/{plot_prefix}qc.png", bbox_inches="tight")
qc.measure(index_qbits, icr)
sampler = Sampler()
job = sampler.run(qc, shots=64)
result = job.result()
index_dist = result.quasi_dists[0]
if save_state_dist_plot:
state_dist = [(k, v) for k, v in index_dist.items()]
state = [to_bits(k)[:n_index_qbits] for k, _ in state_dist]
state = [s + ("0" * (n_index_qbits - len(s))) for s in state]
dist = [v for k, v in state_dist]
plt.figure(figsize=(15, 10))
plt.bar(state, dist)
plt.xlabel("system state")
plt.ylabel("probability")
plt.grid()
plt.savefig(f"figs/{plot_prefix}state-dist.png", bbox_inches="tight")
index_pred = max(index_dist.items(), key=lambda x: x[1])
print(f"Search result, index: {index_pred[0]}, " \
f"empirical prob to collapse in this state: {index_pred[1]}")
print(f"Prob to collapse into a correct state: {index_dist[array.index(item)]}")
if __name__ == "__main__":
Fire(main)
|
https://github.com/IlliaOvcharenko/quantum-search
|
IlliaOvcharenko
|
import sys, os
sys.path.append(os.getcwd())
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit
# from qiskit.primitives.sampler import Sampler
from qiskit_aer.primitives import SamplerV2 as Sampler
from qiskit_aer import AerSimulator
from qiskit import transpile
from fire import Fire
def main():
sim = AerSimulator()
qc = QuantumCircuit(3)
qc.h(0)
qc.cx(0, 1)
qc.cx(0, 2)
# qc.draw("mpl")
# plt.savefig("figs/test-qc.png", bbox_inches="tight")
qc_measured = qc.measure_all(inplace=False)
# qc_measured.draw("mpl")
# plt.savefig("figs/test-qc-measured.png", bbox_inches="tight")
qc_measured_opt = transpile(qc_measured, sim, optimization_level=0)
sampler = Sampler()
job = sampler.run([qc_measured_opt], shots=10)
print(f"Job ID is {job.job_id()}")
pub_result = job.result()
print(pub_result[0].data.meas.get_counts())
if __name__ == "__main__":
Fire(main)
|
https://github.com/IlliaOvcharenko/quantum-search
|
IlliaOvcharenko
|
import sys, os
sys.path.append(os.getcwd())
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit
# from qiskit.primitives.sampler import Sampler
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime import (QiskitRuntimeService,
SamplerV2 as Sampler)
from fire import Fire
def main():
ibm_token = open("credentials/ibm-token.txt").read().replace("\n", "")
ibm_quantum_service = QiskitRuntimeService(channel="ibm_quantum", token=ibm_token)
# print(ibm_quantum_service.backends(simulator=True))
qc = QuantumCircuit(3)
qc.h(0)
qc.cx(0, 1)
qc.cx(0, 2)
# qc.draw("mpl")
# plt.savefig("figs/test-qc.png", bbox_inches="tight")
qc_measured = qc.measure_all(inplace=False)
# qc_measured.draw("mpl")
# plt.savefig("figs/test-qc-measured.png", bbox_inches="tight")
# sampler = Sampler()
# job = sampler.run(qc_measured, shots=1)
# result = job.result()
# print(result)
backend = ibm_quantum_service.least_busy(operational=True, simulator=False)
print(backend)
pm = generate_preset_pass_manager(backend=backend, optimization_level=1)
qc_measured_opt = pm.run(qc_measured)
sampler = Sampler(backend=backend)
job = sampler.run([qc_measured_opt], shots=10)
print(f"Job ID is {job.job_id()}")
pub_result = job.result()[0]
print(pub_result)
if __name__ == "__main__":
Fire(main)
|
https://github.com/IlliaOvcharenko/quantum-search
|
IlliaOvcharenko
|
"""
Test Script
"""
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
qrx = QuantumRegister(1, 'q0')
qry = QuantumRegister(1, 'q1')
cr = ClassicalRegister(1, 'c')
qc = QuantumCircuit(qrx, qry, cr)
qc.h(qrx)
qc.x(qry)
qc.h(qry)
qc.barrier()
qc.x(qry)
qc.barrier()
qc.h(qrx)
qc.h(qry)
qc.measure(qrx, cr)
qc.draw("mpl")
from qiskit import execute
from qiskit.providers.aer import AerSimulator
from qiskit.visualization import plot_histogram
sim = AerSimulator()
job = execute(qc, backend = sim, shots = 1000)
result = job.result()
counts = result.get_counts(qc)
print("Counts: ", counts)
plot_histogram(counts)
|
https://github.com/vladciocoiu/shor-algorithm
|
vladciocoiu
|
from qiskit import QuantumCircuit, Aer, execute, IBMQ
from qiskit.utils import QuantumInstance
import numpy as np
from qiskit.algorithms import Shor
IBMQ.enable_account('ENTER API TOKEN HERE') # Enter your API token here
provider = IBMQ.get_provider(hub='ibm-q')
backend = Aer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=1000)
my_shor = Shor(quantum_instance)
result_dict = my_shor.factor(15)
print(result_dict)
|
https://github.com/TheClintest/QuantumMedianFilter
|
TheClintest
|
# IMPORTS
from PIL import Image
import math
import time
import re
import numpy as np
from qiskit import *
from qiskit.circuit.library import *
from qiskit.providers.aer import *
import matplotlib.pyplot as plt
# UTILITY
def qunion(*qregs: QuantumRegister):
"""
This function returns a list of qubits by their own register variables, useful for Qiskit methods
:param qregs: Input quantum register
:return: A list of qubits, ordered by given args
"""
res = []
for r in qregs:
res += r._bits
return res
# PRINTING
def print_circuit(circuit, filename: str = None):
"""
Prints out a representation of a given circuit.
If "filename" is provided, it saves the visualization in the file system.
:param circuit: Input circuit to visualize
:param filename: Path for the output
"""
style = {
'displaycolor': {
"NEQR": "#FF33FF",
"CS+": "#FF0000",
"CS-": "#FF8888",
"SWAP": "#AAAAFF",
"Neighborhood Preparation": "#33BB33",
"p-values Computation": "#BB3333",
"Median Function": "#BB5555",
"PCN": "#AAAA11",
"ADD": "#55FF55",
"SWPPR": "#55FF55",
"COMP": "#5555FF",
"c_SWAP": "#FF5555",
"SUB": "#FF5555"
},
'fontsize': 12,
'dpi': 300
}
circuit.draw(output="mpl", reverse_bits=False, filename=filename, initial_state=False, style=style, fold=700, vertical_compression="high")
plt.show()
# QASM
qasm_dir = "./qasm/"
def load_qasm(filename, path='./qasm/', verbose=False):
"""
Load a QASM string from a path, returning the corresponding circuit
:param filename: Path to QASM file
:param verbose: Prints out debug info
:return: A QuantumCircuit described in the file
"""
t1 = time.time()
circ = QuantumCircuit.from_qasm_file(f'{path}{filename}')
t2 = time.time()
duration = t2 - t1
if verbose: print(f'QASM loading time for {filename}: {duration}')
return circ
def save_qasm(circuit, filename, path='./qasm/', verbose=False):
"""
Save a circuit/qobj as a QASM file
:param path: Path to the saving directory
:param circuit: Target circuit/qobj to save
:param filename: Name to the file
:param verbose: Prints out debug info
"""
t1 = time.time()
circuit.qasm(filename=f'{path}{filename}')
t2 = time.time()
duration = t2 - t1
if verbose: print(f'QASM saving time: {duration}')
# PATCHER
class ImagePatcher:
"""
An utility class for image decomposition.
It generates 2x2 patches of the image, "wrapped" in a 4x4 image.
Border pixels are repeated to create a sort of frame
"""
original_image = None
original_shape = None
image = None
max_patch = None
def __preprocess(self):
"""
An internal method for image padding
"""
image = self.original_image.copy()
self.max_patch = (image.shape[0], image.shape[1])
image = np.pad(image, ((1, 1), (1, 1)), mode="symmetric") # Total padding
self.image = image
def load_image(self, image_array: np.ndarray = None):
"""
Loads an image array into the patcher and pre-processes it
:param image_array: A NumPy array encoding the image
"""
# TODO: Add image check - minimum (2,2)
self.original_image = image_array
image_shape = image_array.shape
self.__preprocess()
@staticmethod
def pad_image(image_array: np.ndarray):
image = np.pad(image_array, ((1, 1), (1, 1)), mode="symmetric") # Total padding
return image
def extract_image(self):
"""
Returns the original image
:return: A NumPy array encoding the image
"""
result = self.image[1:self.image[0] - 1, 1:self.image[1] - 1]
return result
def get_image(self):
"""
Returns the processed image
:return: A NumPy array encoding the image
"""
return self.image
def get_patches(self):
"""
It generates a dictionary containing all possible patches
:return: A dictionary {pos : patch}
"""
res = dict()
for y in range(0, self.max_patch[0]):
for x in range(0, self.max_patch[1]):
patch_pos = (y, x)
x_start = x * 2
y_start = y * 2
x_end = x_start + 4
y_end = y_start + 4
patch_image = self.image[y_start:y_end, x_start:x_end]
res[patch_pos] = patch_image
return res
def convert_patches(self, patches: dict):
"""
Converts a patch dictionary into the resulting array, according to image original shape
:param patches: A dictionary {pos : patch}
:return: A NumPy array encoding the image
"""
res = self.image.copy()
for pos, patch in patches.items():
y_start = pos[0] * 2 + 1
x_start = pos[1] * 2 + 1
y_end = y_start + 2
x_end = x_start + 2
to_replace = patch[1:3, 1:3]
res[y_start:y_end, x_start:x_end] = to_replace
res = res[1:self.original_shape[0] + 1, 1:self.original_shape[1] + 1]
return res
def check_patch(self, a, b, tolerance):
for x in range(1, 3):
for y in range(1, 3):
val1 = int(a[y][x])
val2 = int(b[y][x])
res = abs(val2 - val1)
if res > tolerance:
# print("CONVERGENCE %d/%d"%(res,tolerance))
return False
return True
def converged_patches(self, old: dict, new: dict, epsilon):
res = dict()
positions = old.keys()
for pos in positions:
res[pos] = self.check_patch(old[pos], new[pos], epsilon)
return res
# CONVERTER
class Converter:
# IMAGE CONVERTER
@staticmethod
def to_array(filename):
"""
Converts a PNG image into a greyscale representation. Returns a NumPy array instance of it
:param filename: Path of input image
:return: A NumPy array representing input image
"""
return np.array(Image.open(filename).convert("L"))
# ARRAY CONVERTER
@staticmethod
def to_image(array, filename):
"""
Converts a Numpy array into a PNG image and saves it as given filename
:param array: Input image array
:param filename: Path of output image
:return:
"""
new_image = Image.fromarray(array)
new_image.save(filename)
# SIMULATION CONVERTER
@staticmethod
def decode_image(answer: dict, target_array, color_size=8):
"""
Process simulator's results to be decoded into an image
:param answer: Simulator results
:param target_array: Array for storing result. Use one of the same shape used for encoding
:param color_size: Size of color registers. Use the value given for the simulated circuit
"""
# Processing
for measure in answer:
m = re.compile(r'\W+').split(measure)
x_coord = int(m[0], 2)
y_coord = int(m[1], 2)
val = int(m[2], 2)
val = val << (8 - color_size)
target_array[y_coord][x_coord] = val
# print("Inserting %d at x:%d y:%d" % (val, x_coord, y_coord))
# Output
return target_array
@staticmethod
def decode_pixel(answer: dict, color_size=8):
"""
Process simulator's results to be decoded into an image
:param answer: Simulator results
:param color_size: Size of color registers. Use the value given for the simulated circuit
"""
# Processing
for measure, num in answer.items():
m = re.compile(r'\W+').split(measure)
val = int(m[0], 2)
val = val << (8 - color_size)
return val
# SIMULATOR
class Simulator:
"""
An Aer Simulator for experimentation.
Default setting is "matrix_product_state"
"""
simulator = None
def __init__(self, mps_max_bond_dimension: int = None):
if mps_max_bond_dimension is not None:
self.simulator = AerSimulator(method="matrix_product_state",
matrix_product_state_max_bond_dimension=mps_max_bond_dimension,
max_parallel_experiments=0,
max_parallel_threads=48,
zero_threshold=1e-50
# mps_log_data=True
)
else:
self.simulator = StatevectorSimulator(max_parallel_experiments=0,
max_parallel_threads=48
)
def transpile(self, circuit: QuantumCircuit, optimization=0, qasm_filename=None, verbose=False):
"""
Transpile circuit
:param circuit: Target circuit to optimize
:param optimization: Optimization level for transpiler (0 to 3)
:param qasm_filename: If path is given, transpiled qobj will be saved as QASM string on file
:return: Transpiled circuit
"""
if verbose:
print(f'Transpiling {circuit.name}')
t1 = time.time()
qobj = transpile(circuit, self.simulator, optimization_level=optimization)
t2 = time.time()
duration = t2 - t1
if verbose: print(f'Transpiling time: {duration}')
if qasm_filename is not None:
if verbose: print(f'Saving circuit as {qasm_filename}')
save_qasm(qobj, filename=qasm_filename)
return qobj
def simulate(self, circuits, shots=1, verbose=False):
"""
Simulate experiment
:param circuits: Quantum circuit(s) to simulate
:param shots: Number of experiments
:param verbose: Debug printing
:return: A dictionary with all results.
"""
t1 = time.time()
results = self.simulator.run(circuits, shots=shots).result()
answer = results.get_counts()
t2 = time.time()
total = t2 - t1
if verbose:
print("---RESULTS---")
print(f"Time:{total}")
print(f"Integrity: {len(answer)}")
print("-------------")
return answer
def simulate_old(self, circuit: QuantumCircuit, shots=1024, verbose=False):
"""
Simulate experiment
:param circuit: A quantum circuit to execute
:param shots: Number of experiments
:param verbose: Debug printing
:return: A dictionary with all results.
"""
if verbose:
print(f'Simulating qobj {circuit.name}')
t1 = time.time()
results = self.simulator.run(circuit, shots=shots).result()
answer = results.get_counts(experiment=None)
t2 = time.time()
total = t2 - t1
if verbose:
print("---RESULTS---")
print(f"Time:{total}")
print(f"Integrity: {len(answer)}/16")
print("-------------")
if len(answer) != 16:
print("## WARNING ##")
return answer
# CIRCUITS
class Circuit:
# Setter
@staticmethod
def setter(number: int, size: int):
num = f'{number:08b}'[::-1]
n = QuantumRegister(size, "n")
circuit = QuantumCircuit(n, name=f'S{number}')
for ix in range(size):
if num[ix] == '1':
circuit.x(n[ix])
return circuit
# NEQR Module
@staticmethod
def __next_x(val: int, bit: int):
"""
FOR INTERNAL USAGE: Find next pixel's coordinates to encode
:param val:
:param bit:
:return:
"""
if (val % (2 ** bit)) == 0:
return bit
else:
return Circuit.__next_x(val, bit - 1)
@staticmethod
def neqr(imageArray, color_num=8, verbose=False):
"""
Encodes the loaded array into a NEQR circuit
:param color_num: Size of color register
:param imageArray: A NumPy Array encoding the input image. To create one, use Converter.to_array(...)
:param verbose: Prints out encoding phase.
:return: A QuantumCircuit class, encoding the NEQR image
"""
# PARAMETERS
if imageArray.shape[0] != imageArray.shape[1]:
raise Exception("Image array must be a square matrix")
size = imageArray.shape[1]
c_qb = color_num # Size of color register
n_qb = int(math.ceil(math.log(size, 2))) # Size of position registers
# REGISTERS
c = QuantumRegister(c_qb, "col")
x = QuantumRegister(n_qb, "x_coor")
y = QuantumRegister(n_qb, "y_coor")
pos = QuantumRegister(bits=qunion(x, y)) # Useful for mcx
qc = QuantumCircuit(c, y, x, name="NEQR")
# ENCODING
# Initialize position registers
qc.x(x)
qc.x(y)
# First barrier
qc.barrier()
# Encoding colors
total = 2 ** (n_qb + n_qb)
val = 0
i = 1
while i <= total:
to_change = Circuit.__next_x(i, n_qb + n_qb - 1)
val = val ^ (2 ** to_change) # XOR to get correct coordinate
x_index = (val >> 0) & (2 ** n_qb) - 1
y_index = (val >> n_qb)
pixel = imageArray[y_index][x_index]
# --debug--
if verbose:
print("Encoding %d at x:%d y:%d" % (pixel, x_index, y_index))
# Set barrier
qc.barrier()
# Set X-Gate
qc.x(pos[to_change])
# Set CX-Gate
for n in range(c_qb):
new_pixel = pixel >> (8 - color_num) # THIS IS WHERE COLOR ENCODING CHANGES!
bit = (new_pixel >> n) & 1
if bit == 1:
qc.mcx(pos, c[n])
# Increase counter
i += 1
# Set last barrier
qc.barrier()
# Reset coordinates
qc.x(x)
qc.x(y)
# RETURN
return qc
@staticmethod
def neqr_new(imageArray, color_num=8, verbose=False):
"""
Encodes the loaded array into a NEQR circuit
:param color_num: Size of color register
:param imageArray: A NumPy Array encoding the input image. To create one, use Converter.to_array(...)
:param verbose: Prints out encoding phase.
:return: A QuantumCircuit class, encoding the NEQR image
"""
# PARAMETERS
if imageArray.shape[0] != imageArray.shape[1]:
raise Exception("Image array must be a square matrix")
size = imageArray.shape[1]
c_qb = color_num # Size of color register
n_qb = int(math.ceil(math.log(size, 2))) # Size of position registers
# REGISTERS
c = QuantumRegister(c_qb, "col")
x = QuantumRegister(n_qb, "x_coor")
y = QuantumRegister(n_qb, "y_coor")
anc = AncillaRegister(1, "anc")
pos = QuantumRegister(bits=qunion(x, y)) # Useful for mcx
qc = QuantumCircuit(c, y, x, anc, name="NEQR")
# ENCODING
# Initialize position registers
qc.x(x)
qc.x(y)
# First barrier
qc.barrier()
# Encoding colors
total = 2 ** (n_qb + n_qb)
val = 0
i = 1
while i <= total:
to_change = Circuit.__next_x(i, n_qb + n_qb - 1)
val = val ^ (2 ** to_change) # XOR to get correct coordinate
x_index = (val >> 0) & (2 ** n_qb) - 1
y_index = (val >> n_qb)
pixel = imageArray[y_index][x_index]
# --debug--
if verbose:
print("Encoding %d at x:%d y:%d" % (pixel, x_index, y_index))
# Set barrier
qc.barrier()
# Set X-Gate
qc.x(pos[to_change])
# Set CX-Gate
qc.mcx(pos, anc)
for n in range(c_qb):
new_pixel = pixel >> (8 - color_num) # THIS IS WHERE COLOR ENCODING CHANGES!
bit = (new_pixel >> n) & 1
if bit == 1:
qc.mcx(anc, c[n])
qc.mcx(pos, anc)
# Increase counter
i += 1
# Set last barrier
qc.barrier()
# Reset coordinates
qc.x(x)
qc.x(y)
# RETURN
return qc
# Cycle-Shift Module
@staticmethod
def __counter(size, reg_name='q', add=True, module_name="CNTR"):
q = QuantumRegister(size, reg_name)
circuit = QuantumCircuit(q, name=f'{module_name}')
order = range(size)
if add:
order = order.__reversed__()
for i in order:
if i == 0:
circuit.x(i)
else:
circuit.mcx([n for n in range(i)], i)
return circuit
@staticmethod
def cycleshift_w(size):
"""
A CycleShift module. Translates Y coordinate up.
:param size: Size of coordinate's register
:return: A QuantumCircuit implementing the module
"""
return Circuit.__counter(size, 'y_coor', add=False, module_name="CSW")
@staticmethod
def cycleshift_a(size):
"""
A CycleShift module. Translates X coordinate left.
:param size: Size of coordinate's register
:return: A QuantumCircuit implementing the module
"""
return Circuit.__counter(size, 'x_coor', add=False, module_name="CSA")
@staticmethod
def cycleshift_s(size):
"""
A CycleShift module. Translates Y coordinate down.
:param size: Size of coordinate's register
:return: A QuantumCircuit implementing the module
"""
return Circuit.__counter(size, 'y_coor', module_name="CSS")
@staticmethod
def cycleshift_d(size):
"""
A CycleShift module. Translates X coordinate right.
:param size: Size of coordinate's register
:return: A QuantumCircuit implementing the module
"""
return Circuit.__counter(size, 'x_coor', module_name="CSD")
@staticmethod
def adder_single():
"""
A 5 qubit circuit with the following logic:
q0 = q0 -- A
q1 = q1 XOR (q2 XOR q0) -- B/Sum
q2 = q2 XOR ((q2 XOR q0) AND (q2 XOR q1)) --Cin/Cout
q3 = 0 -- q2 XOR q0
q4 = 0 -- q2 XOR q1
It adds up the first two qubits (A and B) and the third (C), putting the SUM on q1 and the Cout on q2
:return: A QuantumCircuit implementing the module
"""
circuit = QuantumCircuit(5, name="HA")
circuit.cx(2, 3) # q3 = C
circuit.cx(2, 4) # q4 = C
circuit.cx(0, 2) # q2 = C XOR A
circuit.cx(1, 3) # q3 = C XOR B
circuit.cx(2, 1) # q1 = B XOR ( C XOR A )
circuit.ccx(2, 3, 4) # q4 = C XOR ((C XOR A) AND (C XOR B))
circuit.reset(2) # q2 = 0
circuit.reset(3) # q3 = 0
circuit.cx(4, 2) # q2 = C XOR ((C XOR A) AND (C XOR B))
circuit.reset(4) # q4 = 0
return circuit
@staticmethod
def adder(size):
"""
A full adder mod(2**size)
:param size: Size of addendum registers
:return: A QuantumCircuit implementing the module
"""
a = QuantumRegister(size, name="a")
b = QuantumRegister(size, name="b")
c0 = AncillaRegister(1, name="c0")
c1 = AncillaRegister(1, name="c1")
c2 = AncillaRegister(1, name="c2")
circuit = QuantumCircuit(a, b, c0, c1, c2, name=f'ADD')
add = Circuit.adder_single()
for i in range(size):
circuit.compose(add.to_instruction(), qubits=[a[i], b[i], c0[0], c1[0], c2[0]], inplace=True)
# Cap value to 255 if c0 == 1
circuit.x(c0)
for i in range(size):
circuit.x(b[i])
circuit.ccx(c0[0], b[i], c1[0])
circuit.x(c1[0])
circuit.swap(b[i], c1[0])
circuit.reset(c1)
circuit.reset(c0)
return circuit
@staticmethod
def subtractor(size):
"""
A full subtractor mod(2**size)
:param size: Size of addendum registers
:return: A QuantumCircuit implementing the module
"""
a = QuantumRegister(size, name="a")
b = QuantumRegister(size, name="b")
c0 = AncillaRegister(1, name="c0")
c1 = AncillaRegister(1, name="c1")
c2 = AncillaRegister(1, name="c2")
circuit = QuantumCircuit(a, b, c0, c1, c2, name=f'SUB')
adder = Circuit.adder(size)
circuit.x(a)
circuit.compose(adder, qunion(a, b, c0, c1, c2), inplace=True)
circuit.x(a)
circuit.x(b)
return circuit
# Swap Module
@staticmethod
def swap(size, a_name="a", b_name="b"):
"""
A Swap module. Swaps the value of two given registers
:param size: Size of registers
:param a_name: Name of the first register
:param b_name: Name of the second register
:return: A QuantumCircuit implementing the module
"""
a = QuantumRegister(size, a_name)
b = QuantumRegister(size, b_name)
circuit = QuantumCircuit(a, b, name=f'SWAP')
for i in range(size):
circuit.swap(i, i + size)
return circuit
# Parallel Controlled-NOT Module
@staticmethod
def parallel_controlled_not(size, a_name="a", b_name="b"):
"""
A Parallel Controlled-NOT module. Copy the value of a given register into another
:param size: Size of registers
:param a_name: Name of the original register
:param b_name: Name of the target register
:return: A QuantumCircuit implementing the module
"""
a = QuantumRegister(size, a_name)
b = QuantumRegister(size, b_name)
circuit = QuantumCircuit(a, b, name="PCN")
for i in range(size):
circuit.cx(i, i + size)
return circuit
@staticmethod
def pcn(size, a_name="a", b_name="b"):
"""
A Parallel Controlled-NOT module. Copy the value of a given register into another
:param size: Size of registers
:param a_name: Name of the original register
:param b_name: Name of the target register
:return: A QuantumCircuit implementing the module
"""
return Circuit.parallel_controlled_not(size, a_name, b_name)
# Neighborhood Preparation
@staticmethod
def neighborhood_prep(neighborhood: dict, f: dict, loaded_circuits: dict, color_size=8, verbose=False):
"""
This module process a given image to be prepared for further processing.
It actually stores a 3x3 mask of the given image on 9 ancillary registers.
:param neighborhood: A dictionary containing pixel values
:param color_size: Size of the color registers
:param verbose: For debug usage
:return: A QuantumCircuit implementing the module
"""
# PARAMETERS
col_qb = color_size # Size of color register
f1 = int(abs(f['f1'])) >> (8 - color_size)
f2 = int(abs(f['f2'])) >> (8 - color_size)
f3 = int(abs(f['f3'])) >> (8 - color_size)
f4 = int(abs(f['f4'])) >> (8 - color_size)
f5 = int(abs(f['f5'])) >> (8 - color_size)
# QUANTUM REGISTERS
a1 = QuantumRegister(col_qb, "a1") # Neighbor F1 | |
a2 = QuantumRegister(col_qb, "a2") # Neighbor UP F1 | UP | F2
a3 = QuantumRegister(col_qb, "a3") # Neighbor F2 _ _ | _ | _ _
a4 = QuantumRegister(col_qb, "a4") # Neighbor LFT | |
a5 = QuantumRegister(col_qb, "a5") # Neighbor CNTR LFT | CNTR | RGHT
a6 = QuantumRegister(col_qb, "a6") # Neighbor RGHT _ _ | _ | _ _
a7 = QuantumRegister(col_qb, "a7") # Neighbor F3 | |
a8 = QuantumRegister(col_qb, "a8") # Neighbor DWN F3 | DWN | F4
a9 = QuantumRegister(col_qb, "a9") # Neighbor F4 | |
# ANCILLA REGISTERS
anc = AncillaRegister(3, "anc")
# MAIN CIRCUIT
circuit = QuantumCircuit(a1, a2, a3, a4, a5, a6, a7, a8, a9, anc, name="NBRHD")
# CIRCUITS
add = loaded_circuits["ADD"]
sub = loaded_circuits["SUB"]
q1 = Circuit.setter(f1, col_qb)
q2 = Circuit.setter(neighborhood["UP"], col_qb)
q3 = Circuit.setter(f2, col_qb)
q4 = Circuit.setter(neighborhood["LFT"], col_qb)
q5 = Circuit.setter(neighborhood["CNTR"], col_qb)
q6 = Circuit.setter(neighborhood["RGHT"], col_qb)
q7 = Circuit.setter(f4, col_qb)
q8 = Circuit.setter(neighborhood["DWN"], col_qb)
q9 = Circuit.setter(f5, col_qb)
# COMPOSITING
# 5
if verbose: print("Preparing Pixel:5")
circuit.compose(q5, a5, inplace=True)
# 6
if verbose: print("Preparing Pixel:6")
circuit.compose(q6, a6, inplace=True)
# 3
if verbose: print("Preparing Pixel:3")
circuit.compose(q3, a3, inplace=True)
circuit.compose(add, qunion(a5, a3, anc), inplace=True)
# 2
if verbose: print("Preparing Pixel:2")
circuit.compose(q2, a2, inplace=True)
# 1
if verbose: print("Preparing Pixel:1")
circuit.compose(q1, a1, inplace=True)
circuit.compose(add, qunion(a5, a1, anc), inplace=True)
# 4
if verbose: print("Preparing Pixel:4")
circuit.compose(q4, a4, inplace=True)
# 7
if verbose: print("Preparing Pixel:7")
circuit.compose(q7, a7, inplace=True)
circuit.compose(sub, qunion(a5, a7, anc), inplace=True)
# 8
if verbose: print("Preparing Pixel:8")
circuit.compose(q8, a8, inplace=True)
# 9
if verbose: print("Preparing Pixel:9")
circuit.compose(q9, a9, inplace=True)
circuit.compose(sub, qunion(a5, a9, anc), inplace=True)
# RETURN
if verbose: print("Done!")
return circuit
@staticmethod
def neighborhood_prep_old(img: np.array, f: dict, loaded_circuits: dict, color_size=8, neqr_circuit=None,
verbose=False):
"""
This module process a given image to be prepared for further processing.
It actually stores a 3x3 mask of the given image on 9 ancillary registers.
:param neqr_circuit: If given, will use the given NEQR circuit without having to compose it
:param img: A NumPy array representing the image
:param color_size: Size of the color registers
:param verbose: For debug usage
:return: A QuantumCircuit implementing the module
"""
# PARAMETERS
x_range = img.shape[1] # X size
y_range = img.shape[0] # Y size
col_qb = color_size # Size of color register
pos_qb = int(math.ceil(math.log(x_range, 2))) # Size of position registers
f1 = int(abs(f['f1'])) >> (8 - color_size)
f2 = int(abs(f['f2'])) >> (8 - color_size)
f3 = int(abs(f['f3'])) >> (8 - color_size)
f4 = int(abs(f['f4'])) >> (8 - color_size)
f5 = int(abs(f['f5'])) >> (8 - color_size)
# QUANTUM REGISTERS
c = QuantumRegister(col_qb, "col") # Color
x = QuantumRegister(pos_qb, "x_coor") # X coordinates
y = QuantumRegister(pos_qb, "y_coor") # Y coordinates
a1 = QuantumRegister(col_qb, "a1") # Neighbor 1 | |
a2 = QuantumRegister(col_qb, "a2") # Neighbor 2 1 | 2 | 3
a3 = QuantumRegister(col_qb, "a3") # Neighbor 3 _ _ | _ | _ _
a4 = QuantumRegister(col_qb, "a4") # Neighbor 4 | |
a5 = QuantumRegister(col_qb, "a5") # Neighbor 5 4 | 5 | 6
a6 = QuantumRegister(col_qb, "a6") # Neighbor 6 _ _ | _ | _ _
a7 = QuantumRegister(col_qb, "a7") # Neighbor 7 | |
a8 = QuantumRegister(col_qb, "a8") # Neighbor 8 7 | 8 | 9
a9 = QuantumRegister(col_qb, "a9") # Neighbor 9 | |
# ANCILLA REGISTERS
anc = AncillaRegister(3, "anc")
# MAIN CIRCUIT
circuit = QuantumCircuit(c, y, x, a1, a2, a3, a4, a5, a6, a7, a8, a9, anc, name="NBRHD")
# CIRCUITS
if neqr_circuit is None:
neqr = Circuit.neqr(img, color_num=col_qb, verbose=False)
else:
neqr = neqr_circuit
cs_w = loaded_circuits["CSW"]
cs_a = loaded_circuits["CSA"]
cs_s = loaded_circuits["CSS"]
cs_d = loaded_circuits["CSD"]
swp = loaded_circuits["SWAP"]
add = loaded_circuits["ADD"]
sub = loaded_circuits["SUB"]
q3 = Circuit.setter(f1, col_qb)
q1 = Circuit.setter(f2, col_qb)
q7 = Circuit.setter(f4, col_qb)
q9 = Circuit.setter(f5, col_qb)
# COMPOSITING
circuit.h(y)
circuit.h(x)
circuit.compose(q3, a3, inplace=True)
circuit.compose(q1, a1, inplace=True)
circuit.compose(q7, a7, inplace=True)
circuit.compose(q9, a9, inplace=True)
# 5
if verbose: print("Preparing Pixel:5")
circuit.compose(neqr, qunion(c, y, x), inplace=True)
circuit.compose(swp, qunion(c, a5), inplace=True)
# 6
if verbose: print("Preparing Pixel:6")
circuit.compose(cs_d, qunion(x), inplace=True)
circuit.compose(neqr, qunion(c, y, x), inplace=True)
circuit.compose(swp, qunion(c, a6), inplace=True)
# 3
if verbose: print("Preparing Pixel:3")
circuit.compose(cs_w, qunion(y), inplace=True)
circuit.compose(add, qunion(a5, a3, anc), inplace=True)
# 2
if verbose: print("Preparing Pixel:2")
circuit.compose(cs_a, qunion(x), inplace=True)
circuit.compose(neqr, qunion(c, y, x), inplace=True)
circuit.compose(swp, qunion(c, a2), inplace=True)
# 1
if verbose: print("Preparing Pixel:1")
circuit.compose(cs_a, qunion(x), inplace=True)
circuit.compose(add, qunion(a5, a1, anc), inplace=True)
# 4
if verbose: print("Preparing Pixel:4")
circuit.compose(cs_s, qunion(y), inplace=True)
circuit.compose(neqr, qunion(c, y, x), inplace=True)
circuit.compose(swp, qunion(c, a4), inplace=True)
# 7
if verbose: print("Preparing Pixel:7")
circuit.compose(cs_s, qunion(y), inplace=True)
circuit.compose(sub, qunion(a5, a7, anc), inplace=True)
# 8
if verbose: print("Preparing Pixel:8")
circuit.compose(cs_d, qunion(x), inplace=True)
circuit.compose(neqr, qunion(c, y, x), inplace=True)
circuit.compose(swp, qunion(c, a8), inplace=True)
# 9
if verbose: print("Preparing Pixel:9")
circuit.compose(cs_d, qunion(x), inplace=True)
circuit.compose(sub, qunion(a5, a9, anc), inplace=True)
# Reset
if verbose: print("Restoring...")
circuit.compose(cs_w, qunion(y), inplace=True)
circuit.compose(cs_a, qunion(x), inplace=True)
# RETURN
if verbose: print("Done!")
return circuit
@staticmethod
def neighborhood_prep_patch(img: np.array, pixel: int, f: dict, loaded_circuits: dict, color_size=8, verbose=False):
"""
This module process a given image to be prepared for further processing.
It actually stores a 3x3 mask of the given image on 9 ancillary registers.
:param f:
:param neqr_circuit: If given, will use the given NEQR circuit without having to compose it
:param img: A NumPy array representing the image
:param color_size: Size of the color registers
:param verbose: For debug usage
:return: A QuantumCircuit implementing the module
"""
# PARAMETERS
x_range = img.shape[1] # X size
y_range = img.shape[0] # Y size
col_qb = color_size # Size of color register
pos_qb = int(math.ceil(math.log(x_range, 2))) # Size of position registers
f1 = round(abs(f['f1'])) >> (8 - color_size)
f2 = round(abs(f['f2'])) >> (8 - color_size)
f3 = round(abs(f['f3'])) >> (8 - color_size)
f4 = round(abs(f['f4'])) >> (8 - color_size)
f5 = round(abs(f['f5'])) >> (8 - color_size)
# QUANTUM REGISTERS
c = QuantumRegister(col_qb, "col") # Color
x = QuantumRegister(pos_qb, "x_coor") # X coordinates
y = QuantumRegister(pos_qb, "y_coor") # Y coordinates
a1 = QuantumRegister(col_qb, "a1") # Neighbor UP
a2 = QuantumRegister(col_qb, "a2") # Neighbor RIGHT
a3 = QuantumRegister(col_qb, "a3") # Neighbor DOWN
a4 = QuantumRegister(col_qb, "a4") # Neighbor LEFT
a5 = QuantumRegister(col_qb, "a5") # PIXEL
a6 = QuantumRegister(col_qb, "a6") # F1
a7 = QuantumRegister(col_qb, "a7") # F2
a8 = QuantumRegister(col_qb, "a8") # F4
a9 = QuantumRegister(col_qb, "a9") # F5
# ANCILLA REGISTERS
anc = AncillaRegister(3, "anc")
# MAIN CIRCUIT
circuit = QuantumCircuit(c, y, x, a1, a2, a3, a4, a5, a6, a7, a8, a9, anc, name="NBRHD")
# CIRCUITS
neqr = Circuit.neqr(img, color_num=col_qb, verbose=False)
cs_w = loaded_circuits["CSW"]
cs_a = loaded_circuits["CSA"]
cs_s = loaded_circuits["CSS"]
cs_d = loaded_circuits["CSD"]
swp = loaded_circuits["SWAP"]
add = loaded_circuits["ADD"]
sub = loaded_circuits["SUB"]
q1 = Circuit.setter(f1, col_qb)
q2 = Circuit.setter(f2, col_qb)
q3 = Circuit.setter(pixel, col_qb)
q4 = Circuit.setter(f4, col_qb)
q5 = Circuit.setter(f5, col_qb)
# COMPOSITING
# 1
if verbose: print("Preparing A1")
circuit.compose(neqr, qunion(c, y, x), inplace=True)
circuit.compose(swp, qunion(c, a1), inplace=True)
# 2
if verbose: print("Preparing A2")
circuit.compose(cs_d, qunion(x), inplace=True)
circuit.compose(neqr, qunion(c, y, x), inplace=True)
circuit.compose(swp, qunion(c, a2), inplace=True)
# 3
if verbose: print("Preparing A3")
circuit.compose(cs_s, qunion(y), inplace=True)
circuit.compose(neqr, qunion(c, y, x), inplace=True)
circuit.compose(swp, qunion(c, a3), inplace=True)
# 4
if verbose: print("Preparing A4")
circuit.compose(cs_a, qunion(x), inplace=True)
circuit.compose(neqr, qunion(c, y, x), inplace=True)
circuit.compose(swp, qunion(c, a4), inplace=True)
# 5
if verbose: print("Preparing A5")
circuit.compose(q3, a5, inplace=True)
# 6
if verbose: print("Preparing A6")
circuit.compose(q1, a6, inplace=True)
circuit.compose(add, qunion(a5, a6, anc), inplace=True)
# 7
if verbose: print("Preparing A7")
circuit.compose(q2, a7, inplace=True)
circuit.compose(add, qunion(a5, a7, anc), inplace=True)
# 8
if verbose: print("Preparing A8")
circuit.compose(q4, a8, inplace=True)
circuit.compose(sub, qunion(a5, a8, anc), inplace=True)
# 9
if verbose: print("Preparing A9")
circuit.compose(q5, a9, inplace=True)
circuit.compose(sub, qunion(a5, a9, anc), inplace=True)
# Reset
if verbose: print("Restoring...")
circuit.compose(cs_w, qunion(y), inplace=True)
# RETURN
if verbose: print("Done!")
return circuit
# Comparator
@staticmethod
def comparator_new(size, a_name="a", b_name="b", res_name="e"):
"""
This module compares the binary encoding of two registers and stores the result on a third register.
The result register can result in:
0: A <= B
1: A > B
:param size: Size of the registers
:param a_name: Name of the first register
:param b_name: Name of the second register
:param res_name: Name of the result register
:return: A QuantumCircuit implementing the module
"""
# REGISTERS
a = QuantumRegister(size, a_name)
b = QuantumRegister(size, b_name)
anc = AncillaRegister(1, "anc")
res = AncillaRegister(1, res_name)
circuit = QuantumCircuit(a, b, res, anc, name="COMP")
# COMPOSING
for i in range(size):
circuit.cx(res, anc)
circuit.cx(anc, a[i])
circuit.cx(anc, b[i])
circuit.x(b[i])
circuit.toffoli(b[i], a[i], res)
circuit.x(b[i])
circuit.cx(anc, a[i])
circuit.cx(anc, b[i])
circuit.reset(anc) # 1 ancilla version
# RETURN
return circuit
@staticmethod
def comparator(size, a_name="a", b_name="b", res_name="e"):
"""
This module compares the binary encoding of two registers and stores the result on a third register.
The result register can result in:
00: equal
01: A greater than B
10: B greater than A
:param size: Size of the registers
:param a_name: Name of the first register
:param b_name: Name of the second register
:param res_name: Name of the result register
:return: A QuantumCircuit implementing the module
"""
# REGISTERS
anc_qb = (size - 1) * 2
a = QuantumRegister(size, a_name)
b = QuantumRegister(size, b_name)
anc = AncillaRegister(anc_qb, "anc")
res = AncillaRegister(2, res_name)
circuit = QuantumCircuit(a, b, res, anc, name="COMP")
# COMPOSING
add = []
for i in range(size).__reversed__():
if i != 0:
# Check a > b
circuit.x(b[i])
circuit.mcx([a[i], b[i]] + add, anc[i * 2 - 1])
circuit.mcx([a[i], b[i]] + add, res[0])
circuit.x(b[i])
# Check a < b
circuit.x(a[i])
circuit.mcx([a[i], b[i]] + add, anc[i * 2 - 2])
circuit.mcx([a[i], b[i]] + add, res[1])
circuit.x(a[i])
# Prepare ancilla
circuit.x(anc[i * 2 - 1])
circuit.x(anc[i * 2 - 2])
add.append(anc[i * 2 - 1])
add.append(anc[i * 2 - 2])
else:
mcmt = MCMT(XGate(), 2 + len(add), 1)
# Check a > b
circuit.x(b[i])
circuit.mcx([a[i], b[i]] + add, res[0])
circuit.x(b[i])
# Check b > a
circuit.x(a[i])
circuit.mcx([a[i], b[i]] + add, res[1])
circuit.x(a[i])
# circuit.barrier()
# RETURN
return circuit
# Swapper
@staticmethod
def swapper_new(size, a_name="a", b_name="b"):
"""
A Swapper is a composite module which "swaps" two registers based on their binary encoding:
A > B --> SWAP
A <= B --> PASS
:param size: Size of the register
:param a_name: Name of the first register
:param b_name: Name of the second register
:return: A QuantumCircuit implementing the module
"""
# REGISTERS
a = QuantumRegister(size, a_name)
b = QuantumRegister(size, b_name)
res = AncillaRegister(1, "e")
anc = AncillaRegister(1, "anc")
circuit = QuantumCircuit(a, b, res, anc, name="SWPPR")
# COMPOSING
comp = Circuit.comparator_new(size, a_name, b_name, res.name)
swp = Circuit.swap(size, a_name, b_name).control(1, ctrl_state='1')
circuit.append(comp.to_instruction(), circuit.qubits)
circuit.append(swp, qunion(res, a, b))
# RETURN
return circuit
@staticmethod
def swapper(size, a_name="a", b_name="b"):
"""
A Swapper is a composite module which "swaps" two registers based on their binary encoding:
A > B --> SWAP
A <= B --> PASS
:param size: Size of the register
:param a_name: Name of the first register
:param b_name: Name of the second register
:return: A QuantumCircuit implementing the module
"""
# REGISTERS
anc_qb = (size - 1) * 2
a = QuantumRegister(size, a_name)
b = QuantumRegister(size, b_name)
res = AncillaRegister(2, "e")
anc = AncillaRegister(anc_qb, "anc")
circuit = QuantumCircuit(a, b, res, anc, name="SWPPR")
# COMPOSING
comp = Circuit.comparator(size, a_name, b_name, res.name)
swp = Circuit.swap(size, a_name, b_name).control(2, ctrl_state='01')
circuit.append(comp.to_instruction(), circuit.qubits)
circuit.append(swp, qunion(res, a, b))
# RETURN
return circuit
# Sort Module
@staticmethod
def sort_new(size, a_name="a", b_name="b", c_name="c"):
"""
This module sorts a set of three registers.
:param size: Size of the registers
:param a_name: Name of the first register
:param b_name: Name of the second register
:param c_name: Name of the third register
:return: A QuantumCircuit implementing the module
"""
# REGISTERS
a = QuantumRegister(size, a_name)
b = QuantumRegister(size, b_name)
c = QuantumRegister(size, c_name)
res = AncillaRegister(1, "e")
anc = AncillaRegister(1, "anc")
circuit = QuantumCircuit(a, b, c, res, anc, name="SORT")
# COMPOSING
swppr_ab = Circuit.swapper_new(size, a_name=a_name, b_name=b_name).to_instruction()
swppr_ac = Circuit.swapper_new(size, a_name=a_name, b_name=c_name).to_instruction()
swppr_bc = Circuit.swapper_new(size, a_name=b_name, b_name=c_name).to_instruction()
# Sort A and B
circuit.append(swppr_ab, qunion(a, b, res, anc))
circuit.reset(res)
circuit.reset(anc)
# Sort A and C
circuit.append(swppr_ac, qunion(a, c, res, anc))
circuit.reset(res)
circuit.reset(anc)
# Sort B and C
circuit.append(swppr_bc, qunion(b, c, res, anc))
circuit.reset(res)
circuit.reset(anc)
# RETURN
return circuit
@staticmethod
def sort(size, a_name="a", b_name="b", c_name="c"):
"""
This module sorts a set of three registers.
:param size: Size of the registers
:param a_name: Name of the first register
:param b_name: Name of the second register
:param c_name: Name of the third register
:return: A QuantumCircuit implementing the module
"""
# REGISTERS
anc_qb = (size - 1) * 2
a = QuantumRegister(size, a_name)
b = QuantumRegister(size, b_name)
c = QuantumRegister(size, c_name)
res = AncillaRegister(2, "e")
anc = AncillaRegister(anc_qb, "anc")
circuit = QuantumCircuit(a, b, c, res, anc, name="SORT")
# COMPOSING
swppr_ab = Circuit.swapper(size, a_name=a_name, b_name=b_name).to_instruction()
swppr_ac = Circuit.swapper(size, a_name=a_name, b_name=c_name).to_instruction()
swppr_bc = Circuit.swapper(size, a_name=b_name, b_name=c_name).to_instruction()
# Sort A and B
circuit.append(swppr_ab, qunion(a, b, res, anc))
circuit.reset(res)
circuit.reset(anc)
# Sort A and C
circuit.append(swppr_ac, qunion(a, c, res, anc))
circuit.reset(res)
circuit.reset(anc)
# Sort B and C
circuit.append(swppr_bc, qunion(b, c, res, anc))
circuit.reset(res)
circuit.reset(anc)
# RETURN
return circuit
# Maximum-Median-Minimum Module
@staticmethod
def min_med_max(size):
"""
A module which sorts its input, which median is finally stored in the center register.
:param size: Size of the registers
:return: A QuantumCircuit implementing the module
"""
# REGISTERS
a1 = QuantumRegister(size, "a1")
a2 = QuantumRegister(size, "a2")
a3 = QuantumRegister(size, "a3")
a4 = QuantumRegister(size, "a4")
a5 = QuantumRegister(size, "a5")
a6 = QuantumRegister(size, "a6")
a7 = QuantumRegister(size, "a7")
a8 = QuantumRegister(size, "a8")
a9 = QuantumRegister(size, "a9")
res = AncillaRegister(1, "e")
anc = AncillaRegister(1, "anc")
circuit = QuantumCircuit(a1, a2, a3, a4, a5, a6, a7, a8, a9, res, anc,
name=f'MMM')
# COMPOSING
sort = Circuit.sort_new(size).to_instruction()
# Row sort
circuit.append(sort, qunion(a1, a2, a3, res, anc))
circuit.append(sort, qunion(a4, a5, a6, res, anc))
circuit.append(sort, qunion(a7, a8, a9, res, anc))
# Column sort
circuit.append(sort, qunion(a1, a4, a7, res, anc))
circuit.append(sort, qunion(a2, a5, a8, res, anc))
circuit.append(sort, qunion(a3, a6, a9, res, anc))
# Right diagonal sort
circuit.append(sort, qunion(a3, a5, a7, res, anc))
# RETURN
return circuit
# QUANTUM MEDIAN FILTER
class QuantumMedianFilter:
"""
A Quantum Median Filter.
OUTPUT: X Y C
X is a binary representation of pixel horizontal coordinate
Y is a binary representation of pixel vertical coordinate
C is a binary representation of pixel median value
"""
circuit = None
loaded_circuits = dict()
def generate(self, simulator: Simulator, color_size: int, coordinate_size: int, optimization_level=3):
# Circuits
mmm = Circuit.min_med_max(color_size)
swp = Circuit.swap(color_size)
cs_w = Circuit.cycleshift_w(coordinate_size)
cs_a = Circuit.cycleshift_a(coordinate_size)
cs_s = Circuit.cycleshift_s(coordinate_size)
cs_d = Circuit.cycleshift_d(coordinate_size)
add = Circuit.adder(color_size)
sub = Circuit.subtractor(color_size)
# Transpile and save
self.loaded_circuits["MMM"] = simulator.transpile(mmm, optimization=optimization_level, qasm_filename=mmm.name)
self.loaded_circuits["SWAP"] = simulator.transpile(swp, optimization=optimization_level, qasm_filename=swp.name)
self.loaded_circuits["CSW"] = simulator.transpile(cs_w, optimization=optimization_level,
qasm_filename=cs_w.name)
self.loaded_circuits["CSA"] = simulator.transpile(cs_a, optimization=optimization_level,
qasm_filename=cs_a.name)
self.loaded_circuits["CSS"] = simulator.transpile(cs_s, optimization=optimization_level,
qasm_filename=cs_s.name)
self.loaded_circuits["CSD"] = simulator.transpile(cs_d, optimization=optimization_level,
qasm_filename=cs_d.name)
self.loaded_circuits["ADD"] = simulator.transpile(add, optimization=optimization_level, qasm_filename=add.name)
self.loaded_circuits["SUB"] = simulator.transpile(sub, optimization=optimization_level, qasm_filename=sub.name)
def load_precompiled_circuits(self):
to_load = ["MMM", "SWAP", "CSW", "CSA", "CSS", "CSD", "ADD", "SUB"]
for c in to_load:
print(f"Loading {c} QASM file")
self.loaded_circuits[c] = load_qasm(c)
def prepare(self, neighborhood: dict, lambda_par=1, color_size=8):
"""
Prepare the circuit
:param lambda_par: Lambda parameter for filtering
:param neighborhood: A dictionary containing neighbor pixels
:param color_size: Size of the color registers (defult: 8)
"""
# QC PARAMETERS
col_qb = color_size # Size of color register
# FILTER PARAMETERS
w0_par = 1
u_par = 1 / lambda_par
const_par = (1 / (2 * u_par))
w1_par = 4 * w0_par - 0 * w0_par
w2_par = 3 * w0_par - 1 * w0_par
w3_par = 2 * w0_par - 2 * w0_par
w4_par = 1 * w0_par - 3 * w0_par
w5_par = 0 * w0_par - 4 * w0_par
f = dict()
f['f1'] = const_par * w1_par
f['f2'] = const_par * w2_par
f['f3'] = const_par * w3_par
f['f4'] = const_par * w4_par
f['f5'] = const_par * w5_par
# QUANTUM REGISTERS
a1 = QuantumRegister(col_qb, "a1")
a2 = QuantumRegister(col_qb, "a2")
a3 = QuantumRegister(col_qb, "a3")
a4 = QuantumRegister(col_qb, "a4")
a5 = QuantumRegister(col_qb, "a5")
a6 = QuantumRegister(col_qb, "a6")
a7 = QuantumRegister(col_qb, "a7")
a8 = QuantumRegister(col_qb, "a8")
a9 = QuantumRegister(col_qb, "a9")
# ANCILLA REGISTERS
res = AncillaRegister(1, "e")
anc1 = AncillaRegister(1, "anc1")
anc2 = AncillaRegister(3, "anc2")
# CLASSICAL REGISTERS
cm = ClassicalRegister(col_qb, "cm") # Color Measurement
# MAIN CIRCUIT
circuit = QuantumCircuit(a1, a2, a3, a4, a5, a6, a7, a8, a9, # QUANTUM REGISTERS
res, anc1, anc2, # ANCILLA REGISTERS
cm, # CLASSICAL REGISTERS
name="QuantumMedianFilter" # NAME
)
# CIRCUITS
if len(self.loaded_circuits) == 0:
print("Loading transpiled circuits")
self.load_precompiled_circuits()
prep = Circuit.neighborhood_prep(neighborhood, f, self.loaded_circuits, color_size=color_size)
mmm = self.loaded_circuits["MMM"]
# COMPOSITING
circuit.compose(prep, qunion(a1, a2, a3, a4, a5, a6, a7, a8, a9, anc2), inplace=True)
circuit.barrier()
circuit.compose(mmm, qunion(a1, a2, a3, a4, a5, a6, a7, a8, a9, res, anc1),
inplace=True)
circuit.barrier()
# MEASUREMENT
circuit.measure(a5, cm)
#
self.circuit = circuit
def prepare_old(self, img: np.array, lambda_par=1, color_size=8, neqr_circuit=None):
"""
Prepare the circuit. Uses NEQR
:param neqr_circuit: If given, this NEQR circuit will be used, avoiding to compose one
:param lambda_par: Lambda parameter for filtering
:param img: A NumPy image representation
:param color_size: Size of the color registers (defult: 8)
"""
# IMAGE PARAMETERS
x_range = img.shape[1] # X size
y_range = img.shape[0] # Y size
# QC PARAMETERS
col_qb = color_size # Size of color register
pos_qb = int(math.ceil(math.log(x_range, 2))) # Size of position registers
# FILTER PARAMETERS
w0_par = 1
u_par = 1 / lambda_par
const_par = (1 / (2 * u_par))
w1_par = 4 * w0_par - 0 * w0_par
w2_par = 3 * w0_par - 1 * w0_par
w3_par = 2 * w0_par - 2 * w0_par
w4_par = 1 * w0_par - 3 * w0_par
w5_par = 0 * w0_par - 4 * w0_par
f = dict()
f['f1'] = const_par * w1_par
f['f2'] = const_par * w2_par
f['f3'] = const_par * w3_par
f['f4'] = const_par * w4_par
f['f5'] = const_par * w5_par
# QUANTUM REGISTERS
c = QuantumRegister(col_qb, "col") # Color
x_coord = QuantumRegister(pos_qb, "x_coor") # X coordinates
y_coord = QuantumRegister(pos_qb, "y_coor") # Y coordinates
a1 = QuantumRegister(col_qb, "a1")
a2 = QuantumRegister(col_qb, "a2")
a3 = QuantumRegister(col_qb, "a3")
a4 = QuantumRegister(col_qb, "a4")
a5 = QuantumRegister(col_qb, "a5")
a6 = QuantumRegister(col_qb, "a6")
a7 = QuantumRegister(col_qb, "a7")
a8 = QuantumRegister(col_qb, "a8")
a9 = QuantumRegister(col_qb, "a9")
# ANCILLA REGISTERS
res = AncillaRegister(1, "e")
anc1 = AncillaRegister(1, "anc1")
anc2 = AncillaRegister(3, "anc2")
# CLASSICAL REGISTERS
cm = ClassicalRegister(col_qb, "cm") # Color Measurement (2)
xm = ClassicalRegister(pos_qb, "xm") # X Measurement (1)
ym = ClassicalRegister(pos_qb, "ym") # Y Measurement (0)
# MAIN CIRCUIT
circuit = QuantumCircuit(c, y_coord, x_coord, a1, a2, a3, a4, a5, a6, a7, a8, a9, # QUANTUM REGISTERS
res, anc1, anc2, # ANCILLA REGISTERS
cm, ym, xm, # CLASSICAL REGISTERS
name="QuantumMedianFilter" # NAME
)
# CIRCUITS
if len(self.loaded_circuits) == 0:
print("Loading transpiled circuits")
self.load_precompiled_circuits()
prep = Circuit.neighborhood_prep_old(img, f, self.loaded_circuits, color_size=color_size,
neqr_circuit=neqr_circuit)
mmm = self.loaded_circuits["MMM"]
swp = self.loaded_circuits["SWAP"]
# COMPOSITING
circuit.compose(prep, qunion(c, y_coord, x_coord, a1, a2, a3, a4, a5, a6, a7, a8, a9, anc2), inplace=True)
circuit.barrier()
circuit.compose(mmm, qunion(a1, a2, a3, a4, a5, a6, a7, a8, a9, res, anc1),
inplace=True)
circuit.barrier()
circuit.compose(swp, qunion(c, a5), inplace=True)
circuit.barrier()
# MEASUREMENT
circuit.measure(c, cm)
circuit.measure(y_coord, ym)
circuit.measure(x_coord, xm)
#
self.circuit = circuit
def prepare_patch(self, patch: np.array, pixel, lambda_par=2, color_size=8):
"""
Prepare the circuit. Uses NEQR
:param neqr_circuit: If given, this NEQR circuit will be used, avoiding to compose one
:param lambda_par: Lambda parameter for filtering
:param img: A NumPy image representation
:param color_size: Size of the color registers (defult: 8)
"""
# IMAGE PARAMETERS
x_range = 2 # X size
y_range = 2 # Y size
# QC PARAMETERS
col_qb = color_size # Size of color register
pos_qb = int(math.ceil(math.log(x_range, 2))) # Size of position registers
# FILTER PARAMETERS
w0_par = 1
const_par = lambda_par / 2
w1_par = 4 * w0_par - 0 * w0_par
w2_par = 3 * w0_par - 1 * w0_par
w3_par = 2 * w0_par - 2 * w0_par
w4_par = 1 * w0_par - 3 * w0_par
w5_par = 0 * w0_par - 4 * w0_par
f = dict()
f['f1'] = const_par * w1_par
f['f2'] = const_par * w2_par
f['f3'] = const_par * w3_par
f['f4'] = const_par * w4_par
f['f5'] = const_par * w5_par
# QUANTUM REGISTERS
c = QuantumRegister(col_qb, "col") # Color
x_coord = QuantumRegister(pos_qb, "x_coor") # X coordinates
y_coord = QuantumRegister(pos_qb, "y_coor") # Y coordinates
a1 = QuantumRegister(col_qb, "a1")
a2 = QuantumRegister(col_qb, "a2")
a3 = QuantumRegister(col_qb, "a3")
a4 = QuantumRegister(col_qb, "a4")
a5 = QuantumRegister(col_qb, "a5")
a6 = QuantumRegister(col_qb, "a6")
a7 = QuantumRegister(col_qb, "a7")
a8 = QuantumRegister(col_qb, "a8")
a9 = QuantumRegister(col_qb, "a9")
# ANCILLA REGISTERS
res = AncillaRegister(1, "e")
anc1 = AncillaRegister(1, "anc1")
anc2 = AncillaRegister(3, "anc2")
# CLASSICAL REGISTERS
cm = ClassicalRegister(col_qb, "cm") # Color Measurement
# MAIN CIRCUIT
circuit = QuantumCircuit(c, y_coord, x_coord, a1, a2, a3, a4, a5, a6, a7, a8, a9, # QUANTUM REGISTERS
res, anc1, anc2, # ANCILLA REGISTERS
cm, # CLASSICAL REGISTERS
name="QuantumMedianFilter" # NAME
)
# CIRCUITS
if len(self.loaded_circuits) == 0:
print("Loading transpiled circuits")
self.load_precompiled_circuits()
prep = Circuit.neighborhood_prep_patch(patch, pixel, f, self.loaded_circuits, color_size=color_size)
mmm = self.loaded_circuits["MMM"]
swp = self.loaded_circuits["SWAP"]
# COMPOSITING
circuit.compose(prep, qunion(c, y_coord, x_coord, a1, a2, a3, a4, a5, a6, a7, a8, a9, anc2), inplace=True)
circuit.barrier()
circuit.compose(mmm, qunion(a1, a2, a3, a4, a5, a6, a7, a8, a9, res, anc1),
inplace=True)
circuit.barrier()
# MEASUREMENT
circuit.measure(a5, cm)
#
self.circuit = circuit
def get(self):
"""
If prepared, returns the Quantum Median Filter module
:return: A QuantumCircuit implementing the module
"""
return self.circuit
|
https://github.com/TheClintest/QuantumMedianFilter
|
TheClintest
|
from QMF import *
filename = "lena.png"
#Trasformazione in array
img_array = Converter.to_array(filename)
#Processo...
#Trasformazione in immagine
Converter.to_image(img_array, "nuova_immagine.png")
patcher = ImagePatcher()
patcher.load_image(img_array) # Caricamento/Processing
patches = patcher.get_patches() # Suddivisione
result_patches = patches.copy() # Dizionario per i risultati
for pos, patch in patches.items():
# Simulazione...
result_patches[pos] = Converter.decode_image(answer, patch.copy(), color_size=8)
# Risultati
img_result = patcher.convert_patches(result_patches)
Converter.to_image(img_result, "result.png")
max_bond_dimension = 32
simulator = Simulator(max_bond_dimension)
qmf = QuantumMedianFilter()
lambda_parameter = 100 # Parametro di esecuzione
# Generazione dei circuiti
qmf.generate(simulator, color_size=8, coordinate_size=2, optimization=3)
for pos, patch in patches.items():
#Generazione NEQR
neqr = Circuit.neqr(patch, color_num=color_size, verbose=False)
neqr_transpiled = sim.transpile(neqr, optimization=0, verbose=False)
#Generazione QMF
qmf.prepare_old(np.array(patch), lambda_parameter, color_size, neqr_transpiled)
circuit = qmf.get()
#Simulazione
answer = sim.simulate_old(circuit, shots=128, verbose=False)
#Recupero dei risultati
result_patches[pos] = Converter.decode_image(answer, patch.copy(), color_size=8)
|
https://github.com/NirdevPaul/GroversAlgorithm
|
NirdevPaul
|
my_list = [1, 3, 5, 2, 4, 9, 5, 8, 0, 7, 6]
def the_oracle(my_input):
winner = 7
return my_input == winner
for index, trial_number in enumerate(my_list):
if the_oracle(trial_number):
print(f"Found the winner at index {index}!")
print(f"{index+1} calls made")
break
from qiskit import *
from qiskit.visualization import plot_histogram, array_to_latex
from qiskit.providers.ibmq import least_busy
import matplotlib.pyplot as plt
import numpy as np
grover_circuit = QuantumCircuit(2)
def init_state(qc, qubits):
for q in qubits:
qc.h(q)
return qc
grover_circuit = init_state(grover_circuit, [0, 1])
grover_circuit.draw("mpl")
#define the oracle circuit
def oracle(qc, qubits):
qc.cz(qubits[0], qubits[1])
qc = QuantumCircuit(2)
oracle(qc, [0, 1])
qc.draw("mpl")
usim = Aer.get_backend('aer_simulator')
qc.save_unitary()
qobj = assemble(qc)
unitary = usim.run(qobj).result().get_unitary()
array_to_latex(unitary, prefix="\\text{One can see that only the state }\ket{11}\\text{ has been flipped: }\n")
def diffusion(qc, qubits):
qc.h([0, 1])
qc.z([0, 1])
qc.cz(0, 1)
qc.h([0, 1])
grover_circuit.barrier()
oracle(grover_circuit, [0, 1])
grover_circuit.barrier()
diffusion(grover_circuit, [0, 1])
grover_circuit.measure_all()
grover_circuit.draw("mpl")
# Let's see if the final statevector matches our expectations
sv_sim = Aer.get_backend('statevector_simulator')
result = sv_sim.run(grover_circuit).result()
statevec = result.get_statevector()
statevec
aer_sim = Aer.get_backend('aer_simulator')
result = execute(grover_circuit, aer_sim, shots=1024).result()
result.get_counts()
# Load IBM Q account and get the least busy backend device
# Run the following line with your API token to use IBM's own quantum computers
#IBMQ.save_account('')
provider = IBMQ.load_account()
provider = IBMQ.get_provider("ibm-q")
device = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 3 and
not x.configuration().simulator and x.status().operational==True))
print("Running on current least busy device: ", device)
# Run our circuit on the least busy backend. Monitor the execution of the job in the queue
from qiskit.tools.monitor import job_monitor
transpiled_grover_circuit = transpile(grover_circuit, device, optimization_level=3)
job = device.run(transpiled_grover_circuit)
job_monitor(job, interval=2)
# Get the results from the computation
results = job.result()
answer = results.get_counts(grover_circuit)
plot_histogram(answer)
grover_circuit = QuantumCircuit(3)
grover_circuit = init_state(grover_circuit, [0, 1, 2])
grover_circuit.draw("mpl")
oracle_qc = QuantumCircuit(3)
oracle_qc.cz(0, 1)
oracle_qc.cz(0, 2)
oracle_gate = oracle_qc.to_gate()
oracle_gate.name = "U$_\omega$"
def diffuser(nqubits):
qc = QuantumCircuit(nqubits)
# Apply transformation |s> -> |00..0> -> |11..1>
for qubit in range(nqubits):
qc.h(qubit)
qc.x(qubit)
# When these are combined, they function as a multi-controlled Z gate
# A negative phase is added to |11..1> to flip the state
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> -> |s>
for qubit in range(nqubits):
qc.x(qubit)
qc.h(qubit)
# We will return the diffuser as a gate
U_s = qc.to_gate()
U_s.name = "U$_s$"
return U_s
num_qubits = 3
grover_circuit = QuantumCircuit(num_qubits)
grover_circuit = init_state(grover_circuit, [0, 1, 2])
grover_circuit.barrier()
grover_circuit.append(oracle_gate, [0, 1, 2])
grover_circuit.barrier()
grover_circuit.append(diffuser(num_qubits), [0, 1, 2])
grover_circuit.measure_all()
grover_circuit.draw("mpl")
qasm_sim = Aer.get_backend('qasm_simulator')
transpiled_grover_circuit = transpile(grover_circuit, qasm_sim)
results = qasm_sim.run(transpiled_grover_circuit).result()
counts = results.get_counts()
plot_histogram(counts)
backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 3 and
not x.configuration().simulator and x.status().operational==True))
print("least busy backend: ", backend)
# Run our circuit on the least busy backend. Monitor the execution of the job in the queue
from qiskit.tools.monitor import job_monitor
transpiled_grover_circuit = transpile(grover_circuit, device, optimization_level=3)
job = device.run(transpiled_grover_circuit)
job_monitor(job, interval=2)
# Get the results from the computation
results = job.result()
answer = results.get_counts(grover_circuit)
plot_histogram(answer)
|
https://github.com/riddheshMarkandeya/shors-algorithm-quantum
|
riddheshMarkandeya
|
from qiskit.quantum_info.operators import Operator
from qiskit.circuit.library import CU1Gate
#helper functions
def make_permutation_matrix(n, permutation):
r = np.zeros((n,n), dtype=int)
for i in range(n):
r[permutation(i), i] = 1
return r
def mult_mat(x,k,N):
n = math.ceil(math.log(N, 2))
return make_permutation_matrix(
2**n,
permutation=lambda y: y*pow(x,k) % N if y<N else y)
def c_mult_mat(x,k,N):
n = math.ceil(math.log(N, 2))
permutation = lambda y: y if y%2==0 or (y-1)/2 >= N else 2*(int((y-1)/2)*pow(x,k) % N) + 1
return make_permutation_matrix(2*(2**n), permutation )
def mult_op(x,k,N):
return Operator(mult_mat(x,k,N))
#controlled-U oracle
def c_mult_op(x,k,N):
return Operator(c_mult_mat(x,k,N))
# QFT and IQFT
def qft(circ, q, n):
"""n-qubit 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])
for i in range(n//2):
circ.swap(q[i], q[n-i-1])
def iqft(circ,q,n):
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])
gate = CU1Gate(-np.pi/float(2**(k-j)) )
circ.append(gate, [q[k],q[j]])
for i in range(n//2):
circ.swap(q[i], q[n-i-1])
|
https://github.com/riddheshMarkandeya/shors-algorithm-quantum
|
riddheshMarkandeya
|
import math
import numpy as np
from qiskit import QuantumCircuit, Aer, transpile, execute
from qiskit.visualization import plot_histogram, circuit_drawer
from math import gcd
from fractions import Fraction
# Constants
N = 15
x = 7
n_count = 9 # number of counting qubits
# Controlled Unitary Operation
def c_amod15(a, power):
"""Controlled multiplication by a mod 15"""
U = QuantumCircuit(4)
for _ in range(power):
if a in [2, 13]:
U.swap(2, 3)
U.swap(1, 2)
U.swap(0, 1)
if a in [7, 8]:
U.swap(0, 1)
U.swap(1, 2)
U.swap(2, 3)
if a in [4, 11]:
U.swap(1, 3)
U.swap(0, 2)
if a in [7, 11, 13]:
for q in range(4):
U.x(q)
U = U.to_gate()
U.name = f"{'U'}^{power}"
c_U = U.control()
return c_U
# Inverse Quantum Fourier Transform
def qft_dagger(n):
"""n-qubit QFTdagger the first n qubits in circ"""
qc = QuantumCircuit(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)
qc.name = "IQFT"
return qc
# Quantum Phase Estimation Circuit
qc = QuantumCircuit(n_count + 4, n_count)
qc.x(3 + n_count)
for q in range(n_count):
qc.h(q)
for q in range(n_count):
qc.append(c_amod15(x, 2**q), [q] + [i + n_count for i in range(4)])
qc.append(qft_dagger(n_count), range(n_count))
qc.measure(range(n_count), range(n_count))
# Visualize the Circuit
circuit_drawer(qc, output='mpl', scale=0.7, fold=-1)
# Simulate the Circuit
simulator = Aer.get_backend('aer_simulator')
transpiled_qc = transpile(qc, simulator)
result = simulator.run(transpiled_qc, shots=1024).result()
counts = result.get_counts(qc)
# Plot histogram
plot_histogram(counts)
# Determine the order r
def determine_order(counts):
measured_str = max(counts, key=counts.get)
measured = int(measured_str, 2)
phase = measured / (2**n_count)
frac = Fraction(phase).limit_denominator(N)
return frac.denominator
r = determine_order(counts)
print(f"Order r: {r}")
# Classical post-processing to factorize N
factor_found = False
if r % 2 == 0:
plus = gcd(pow(x, r//2) + 1, N)
minus = gcd(pow(x, r//2) - 1, N)
if plus not in [1, N]:
print(f"One factor of {N} is {plus}")
factor_found = True
if minus not in [1, N]:
print(f"One factor of {N} is {minus}")
factor_found = True
if not factor_found:
print("No factors found. Try a different random x.")
|
https://github.com/riddheshMarkandeya/shors-algorithm-quantum
|
riddheshMarkandeya
|
import math
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, Aer, execute
from qiskit.quantum_info.operators import Operator
from qiskit.circuit.library import CU1Gate
from qiskit.visualization import plot_histogram
from fractions import Fraction
# Provided helper functions and oracles
def make_permutation_matrix(n, permutation):
r = np.zeros((n,n), dtype=int)
for i in range(n):
r[permutation(i), i] = 1
return r
def mult_mat(x,k,N):
n = math.ceil(math.log(N, 2))
return make_permutation_matrix(
2**n,
permutation=lambda y: y*pow(x,k) % N if y<N else y)
def c_mult_mat(x,k,N):
n = math.ceil(math.log(N, 2))
permutation = lambda y: y if y%2==0 or (y-1)/2 >= N else 2*(int((y-1)/2)*pow(x,k) % N) + 1
return make_permutation_matrix(2*(2**n), permutation )
def mult_op(x,k,N):
return Operator(mult_mat(x,k,N))
#controlled-U oracle
def c_mult_op(x,k,N):
return Operator(c_mult_mat(x,k,N))
# QFT and IQFT
def qft(circ, q, n):
"""n-qubit 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])
for i in range(n//2):
circ.swap(q[i], q[n-i-1])
def iqft(circ,q,n):
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])
gate = CU1Gate(-np.pi/float(2**(k-j)) )
circ.append(gate, [q[k],q[j]])
for i in range(n//2):
circ.swap(q[i], q[n-i-1])
# Constants
N = 15
x = 7
# Quantum registers
n_control = math.ceil(math.log(N, 2)) * 2 # Number of qubits in the control register
control_qubits = QuantumRegister(n_control)
target_qubits = QuantumRegister(math.ceil(math.log(N, 2)) + 1) # Extra qubit for modulo multiplication
classical_bits = ClassicalRegister(n_control)
# Quantum circuit
circuit = QuantumCircuit(control_qubits, target_qubits, classical_bits)
# Initialize control qubits in superposition
circuit.h(control_qubits)
# Apply controlled unitary operations
for qubit in range(n_control):
k = 2 ** qubit
circuit.append(c_mult_op(x, k, N), [control_qubits[qubit]] + target_qubits[:])
# Apply inverse QFT
iqft(circuit, control_qubits, n_control)
# Measure control qubits
circuit.measure(control_qubits, classical_bits)
# Simulate the circuit
simulator = Aer.get_backend('qasm_simulator')
result = execute(circuit, simulator, shots=1024).result()
counts = result.get_counts(circuit)
# Display the histogram
plot_histogram(counts)
# Determine the order r
def determine_order(counts):
# Find the output with the highest probability
most_common_outcome = max(counts, key=counts.get)
phase = int(most_common_outcome, 2) / (2**n_control)
frac = Fraction(phase).limit_denominator(N)
return frac.denominator
r = determine_order(counts)
print(f"Order r: {r}")
# Post-processing: Find factors of N
factor_found = False
if r % 2 == 0:
plus = math.gcd(int(pow(x, r//2) + 1), N)
minus = math.gcd(int(pow(x, r//2) - 1), N)
if plus != 1 and plus != N:
print(f"One factor of {N} is {plus}")
factor_found = True
if minus != 1 and minus != N:
print(f"One factor of {N} is {minus}")
factor_found = True
if not factor_found:
print("No factors found. Try a different random x.")
|
https://github.com/riddheshMarkandeya/shors-algorithm-quantum
|
riddheshMarkandeya
|
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/riddheshMarkandeya/shors-algorithm-quantum
|
riddheshMarkandeya
|
import math
import numpy as np
from qiskit import QuantumCircuit, Aer, transpile, execute
from qiskit.visualization import plot_histogram, circuit_drawer
from qiskit.quantum_info.operators import Operator
from qiskit.circuit.library import CU1Gate, QFT
from math import gcd
from fractions import Fraction
#helper functions
def make_permutation_matrix(n, permutation):
r = np.zeros((n,n), dtype=int)
for i in range(n):
r[permutation(i), i] = 1
return r
def mult_mat(x,k,N):
n = math.ceil(math.log(N, 2))
return make_permutation_matrix(
2**n,
permutation=lambda y: y*pow(x,k) % N if y<N else y)
def c_mult_mat(x,k,N):
n = math.ceil(math.log(N, 2))
permutation = lambda y: y if y%2==0 or (y-1)/2 >= N else 2*(int((y-1)/2)*pow(x,k) % N) + 1
return make_permutation_matrix(2*(2**n), permutation )
def mult_op(x,k,N):
return Operator(mult_mat(x,k,N))
#controlled-U oracle
def c_mult_op(x,k,N):
return Operator(c_mult_mat(x,k,N))
# QFT and IQFT
def qft(circ, q, n):
"""n-qubit 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])
for i in range(n//2):
circ.swap(q[i], q[n-i-1])
def iqft(circ,q,n):
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])
gate = CU1Gate(-np.pi/float(2**(k-j)) )
circ.append(gate, [q[k],q[j]])
for i in range(n//2):
circ.swap(q[i], q[n-i-1])
# Constants
N = 119
# N = 133
x = 9
n_count = 2 * math.ceil(math.log2(N)) # number of counting qubits
o_qbits = math.ceil(math.log2(N)) # oracle qubits
# Quantum Phase Estimation Circuit
qc = QuantumCircuit(n_count + o_qbits, n_count)
qc.x(n_count) # converting to |1> eigenstate
for q in range(n_count):
qc.h(q)
for q in range(n_count):
qc.unitary(c_mult_op(x,2**q,N), [q] + [i + n_count for i in range(o_qbits)]) # Adding Unitary operation
qft_circuit = QFT(n_count)
iqft_circuit = qft_circuit.inverse() # Used inbuilt IQFT, provided IQFT wasn't working correctly for some reason
qc.append(iqft_circuit, range(n_count))
qc.measure(range(n_count), range(n_count))
# Visualize the Circuit
circuit_drawer(qc, output='mpl', scale=0.7, fold=-1)
# Simulate the Circuit
simulator = Aer.get_backend('aer_simulator')
transpiled_qc = transpile(qc, simulator)
result = simulator.run(transpiled_qc, shots=2*1024).result()
counts = result.get_counts(qc)
# Plot histogram
plot_histogram(counts)
# Determine the order r
def determine_order(counts):
measured_str = max(counts, key=counts.get)
measured = int(measured_str, 2) # converting binary to decimal
phase = measured / (2**n_count)
frac = Fraction(phase).limit_denominator(N) # compute s/r for phase
return frac.denominator
r = determine_order(counts)
print(f"Order r: {r}")
# Classical post-processing to factorize N
factor_found = False
if r % 2 == 0:
plus = gcd(pow(x, r//2) + 1, N)
minus = gcd(pow(x, r//2) - 1, N)
if plus not in [1, N]:
print(f"One factor of {N} is {plus}")
factor_found = True
if minus not in [1, N]:
print(f"One factor of {N} is {minus}")
factor_found = True
if not factor_found:
print("No factors found. Try a different random x or run from circuit cell again.")
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
"""
Constant: Output equal 0.
"""
""" Create the quantum Circuit. """
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
qrx = QuantumRegister(1, 'q0')
qry = QuantumRegister(1, 'q1')
cr = ClassicalRegister(1, 'c')
qc = QuantumCircuit(qrx, qry, cr)
qc.h(qrx)
qc.x(qry)
qc.h(qry)
qc.barrier()
qc.i(qry)
qc.barrier()
qc.h(qrx)
qc.h(qry)
qc.measure(qrx, cr)
qc.draw("mpl")
""" Proof through histogram. """
from qiskit import execute
from qiskit.providers.aer import AerSimulator
from qiskit.visualization import plot_histogram
sim = AerSimulator()
job = execute(qc, backend = sim, shots = 1000)
result = job.result()
counts = result.get_counts(qc)
print("Counts: ", counts)
plot_histogram(counts)
""" Also in Quantum Computer. """
from qiskit import QuantumCircuit, IBMQ, execute
from qiskit.tools.monitor import job_monitor
from qiskit.visualization import plot_histogram
IBMQ.save_account('your_token')
IBMQ.load_account()
IBMQ.providers()
provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')
qcomp = provider.get_backend('ibmq_manila')
job = execute(qc, backend = qcomp, shots = 1000)
job_monitor(job)
result = job.result()
counts = result.get_counts(qc)
print("Total counts for qubit states are:", counts)
plot_histogram(counts)
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
"""
Constant: Output equal 1.
"""
""" Create the quantum Circuit. """
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
qrx = QuantumRegister(1, 'q0')
qry = QuantumRegister(1, 'q1')
cr = ClassicalRegister(1, 'c')
qc = QuantumCircuit(qrx, qry, cr)
qc.h(qrx)
qc.x(qry)
qc.h(qry)
qc.barrier()
qc.x(qry)
qc.barrier()
qc.h(qrx)
qc.h(qry)
qc.measure(qrx, cr)
qc.draw("mpl")
""" Proof through histogram. """
from qiskit import execute
from qiskit.providers.aer import AerSimulator
from qiskit.visualization import plot_histogram
sim = AerSimulator()
job = execute(qc, backend = sim, shots = 1000)
result = job.result()
counts = result.get_counts(qc)
print("Counts: ", counts)
plot_histogram(counts)
""" Also in Quantum Computer. """
from qiskit import QuantumCircuit, IBMQ, execute
from qiskit.tools.monitor import job_monitor
from qiskit.visualization import plot_histogram
IBMQ.save_account('your_token')
IBMQ.load_account()
IBMQ.providers()
provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')
qcomp = provider.get_backend('ibmq_manila')
job = execute(qc, backend = qcomp, shots = 1000)
job_monitor(job)
result = job.result()
counts = result.get_counts(qc)
print("Total counts for qubit states are:", counts)
plot_histogram(counts)
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
"""
Balanced: Input equal Output.
"""
""" Create the quantum Circuit. """
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
qrx = QuantumRegister(1, 'q0')
qry = QuantumRegister(1, 'q1')
cr = ClassicalRegister(1, 'c')
qc = QuantumCircuit(qrx, qry, cr)
qc.h(qrx)
qc.x(qry)
qc.h(qry)
qc.barrier()
qc.cx(qrx, qry)
qc.barrier()
qc.h(qrx)
qc.h(qry)
qc.measure(qrx, cr)
qc.draw("mpl")
""" Proof through histogram. """
from qiskit import execute
from qiskit.providers.aer import AerSimulator
from qiskit.visualization import plot_histogram
sim = AerSimulator()
job = execute(qc, backend = sim, shots = 1000)
result = job.result()
counts = result.get_counts(qc)
print("Counts: ", counts)
plot_histogram(counts)
""" Also in Quantum Computer. """
from qiskit import QuantumCircuit, IBMQ, execute
from qiskit.tools.monitor import job_monitor
from qiskit.visualization import plot_histogram
IBMQ.save_account('your_token')
IBMQ.load_account()
IBMQ.providers()
provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')
qcomp = provider.get_backend('ibmq_manila')
job = execute(qc, backend = qcomp, shots = 1000)
job_monitor(job)
result = job.result()
counts = result.get_counts(qc)
print("Total counts for qubit states are:", counts)
plot_histogram(counts)
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
"""
Balanced: Input not equal Output.
"""
""" Create the quantum Circuit. """
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
qrx = QuantumRegister(1, 'q0')
qry = QuantumRegister(1, 'q1')
cr = ClassicalRegister(1, 'c')
qc = QuantumCircuit(qrx, qry, cr)
qc.h(qrx)
qc.x(qry)
qc.h(qry)
qc.barrier()
qc.x(qry)
qc.cx(qrx, qry)
qc.barrier()
qc.h(qrx)
qc.h(qry)
qc.measure(qrx, cr)
qc.draw("mpl")
""" Proof through histogram. """
from qiskit import execute
from qiskit.providers.aer import AerSimulator
from qiskit.visualization import plot_histogram
sim = AerSimulator()
job = execute(qc, backend = sim, shots = 1000)
result = job.result()
counts = result.get_counts(qc)
print("Counts: ", counts)
plot_histogram(counts)
""" Also in Quantum Computer. """
from qiskit import QuantumCircuit, IBMQ, execute
from qiskit.tools.monitor import job_monitor
from qiskit.visualization import plot_histogram
IBMQ.save_account('your_token')
IBMQ.load_account()
IBMQ.providers()
provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')
qcomp = provider.get_backend('ibmq_manila')
job = execute(qc, backend = qcomp, shots = 1000)
job_monitor(job)
result = job.result()
counts = result.get_counts(qc)
print("Total counts for qubit states are:", counts)
plot_histogram(counts)
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
"""
Test Script
"""
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
qrx = QuantumRegister(1, 'q0')
qry = QuantumRegister(1, 'q1')
cr = ClassicalRegister(1, 'c')
qc = QuantumCircuit(qrx, qry, cr)
qc.h(qrx)
qc.x(qry)
qc.h(qry)
qc.barrier()
qc.x(qry)
qc.barrier()
qc.h(qrx)
qc.h(qry)
qc.measure(qrx, cr)
qc.draw("mpl")
from qiskit import execute
from qiskit.providers.aer import AerSimulator
from qiskit.visualization import plot_histogram
sim = AerSimulator()
job = execute(qc, backend = sim, shots = 1000)
result = job.result()
counts = result.get_counts(qc)
print("Counts: ", counts)
plot_histogram(counts)
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit
qc = QuantumCircuit(2)
qc.cx(0, 1)
qc.draw("mpl")
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit, QuantumRegister
qrx = QuantumRegister(3, 'x')
qry = QuantumRegister(1, 'y')
qc = QuantumCircuit(qrx, qry)
qc.x(qry)
qc.draw("mpl")
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit, Aer
from qiskit.visualization import array_to_latex
sim = Aer.get_backend("aer_simulator")
qc = QuantumCircuit(2)
qc.cx(0, 1)
display(qc.draw("mpl"))
qc.save_unitary()
unitary = sim.run(qc).result().get_unitary()
display(array_to_latex(unitary, prefix="\\text{CNOT (LSB as Target) = }"))
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumRegister, QuantumCircuit
qrx = QuantumRegister(3, 'x')
qry = QuantumRegister(1, 'y')
qc = QuantumCircuit(qrx, qry)
qc.cx(qrx[0], qry)
qc.draw("mpl")
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.draw("mpl")
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit,execute
from qiskit.providers.aer import AerSimulator
from qiskit.visualization import plot_histogram
import math
qc = QuantumCircuit(2,2)
qc.h(0)
qc.h(1)
qc.measure([0,1],[0,1])
print("This is |++>:")
print(qc)
simulator=AerSimulator()
job=execute(qc, backend=simulator, shots=1000)
result=job.result()
counts=result.get_counts(qc)
print("Counts:",counts)
plot_histogram(counts)
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit
qc = QuantumCircuit(2)
qc.x(1)
qc.draw("mpl")
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
qc = QuantumCircuit(2)
qc.x(1)
qc.draw("mpl")
state = Statevector.from_instruction(qc)
state.draw('bloch')
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit
import math
from qiskit.quantum_info import Statevector
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_bloch_multivector
qc = QuantumCircuit(4,4)
qc.initialize([1,0],0)
qc.initialize([0,1],1)
qc.initialize([1/math.sqrt(2), 1/math.sqrt(2)],2)
qc.initialize([1/math.sqrt(2), -1/math.sqrt(2)],3)
qc.draw("mpl")
state = Statevector.from_instruction(qc)
plot_bloch_multivector(state)
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit, QuantumRegister
qrx = QuantumRegister(3, 'x')
qry = QuantumRegister(1, 'y')
qc = QuantumCircuit(qrx, qry)
qc.x(qry)
qc.draw("mpl")
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit, Aer
from qiskit.visualization import array_to_latex
sim = Aer.get_backend("aer_simulator")
qc = QuantumCircuit(2)
qc.cx(0, 1)
display(qc.draw("mpl"))
qc.save_unitary()
unitary = sim.run(qc).result().get_unitary()
display(array_to_latex(unitary, prefix="\\text{CNOT (LSB as Target) = }"))
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit
qc = QuantumCircuit(2)
qc.x(1)
qc.draw("mpl")
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
qc = QuantumCircuit(2)
qc.x(1)
qc.draw("mpl")
state = Statevector.from_instruction(qc)
state.draw('bloch')
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit,execute
from qiskit.providers.aer import AerSimulator
from qiskit.visualization import plot_histogram
import math
qc = QuantumCircuit(1,1)
qc.initialize([math.sqrt(1/3), math.sqrt(2/3)],0)
qc.measure([0],[0])
print(qc)
simulator=AerSimulator()
job=execute(qc, backend=simulator, shots=1000)
result=job.result()
counts=result.get_counts(qc)
print("Counts:",counts)
plot_histogram(counts)
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit,execute
from qiskit.providers.aer import AerSimulator
from qiskit.visualization import plot_histogram
import math
qc = QuantumCircuit(1,1)
qc.initialize([math.sqrt(1/3), math.sqrt(2/3)],0)
qc.x(0)
qc.measure([0],[0])
print(qc)
simulator=AerSimulator()
job=execute(qc, backend=simulator, shots=1000)
result=job.result()
counts=result.get_counts(qc)
print("Counts:",counts)
plot_histogram(counts)
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
qrx = QuantumRegister(3, 'x')
qry = QuantumRegister(1, 'y')
cr = ClassicalRegister(3, 'c')
qc = QuantumCircuit(qrx, qry, cr)
qc.h(qrx)
qc.x(qry)
qc.h(qry)
qc.barrier()
qc.x(qry)
qc.barrier()
qc.h(qrx)
qc.h(qry)
qc.measure(qrx, cr)
qc.draw("mpl")
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import execute
from qiskit.providers.aer import AerSimulator
from qiskit.visualization import plot_histogram
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
qrx = QuantumRegister(3, 'x')
qry = QuantumRegister(1, 'y')
cr = ClassicalRegister(3, 'c')
qc = QuantumCircuit(qrx, qry, cr)
qc.h(qrx)
qc.x(qry)
qc.h(qry)
qc.barrier()
qc.x(qry)
qc.barrier()
qc.h(qrx)
qc.h(qry)
qc.measure(qrx, cr)
qc.draw("mpl")
sim = AerSimulator()
job = execute(qc, backend = sim, shots = 1000)
result = job.result()
counts = result.get_counts(qc)
print("Counts: ", counts)
plot_histogram(counts)
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumRegister, QuantumCircuit
qrx = QuantumRegister(3, 'x')
qry = QuantumRegister(1, 'y')
qc = QuantumCircuit(qrx, qry)
qc.cx(qrx[0], qry)
qc.draw("mpl")
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.draw("mpl")
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit,execute
from qiskit.providers.aer import AerSimulator
from qiskit.visualization import plot_histogram
import math
qc = QuantumCircuit(2,2)
qc.h(0)
qc.h(1)
qc.measure([0,1],[0,1])
print("This is |++>:")
print(qc)
simulator=AerSimulator()
job=execute(qc, backend=simulator, shots=1000)
result=job.result()
counts=result.get_counts(qc)
print("Counts:",counts)
plot_histogram(counts)
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit
qc = QuantumCircuit(3)
qc.x(0)
qc.y(1)
qc.z(2)
print(qc)
qc.draw("mpl")
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
qc = QuantumCircuit(3)
qc.x(0)
qc.y(1)
qc.z(2)
print(qc)
qc.draw("mpl")
state = Statevector.from_instruction(qc)
state.draw('bloch')
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit
import math
qc = QuantumCircuit(3)
qc.rx(math.pi/2, 0)
qc.ry(math.pi/2, 1)
qc.rz(math.pi/2, 2)
qc.draw("mpl")
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit
import math
from qiskit.quantum_info import Statevector
qc = QuantumCircuit(3)
qc.rx(math.pi/2, 0)
qc.ry(math.pi/2, 1)
qc.rz(math.pi/2, 2)
qc.draw("mpl")
state = Statevector.from_instruction(qc)
state.draw('bloch')
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit
import math
qc = QuantumCircuit(4)
qc.rx(math.pi/2, [0,1,2,3])
qc.p(math.pi/8, 1)
qc.s(2)
qc.t(3)
qc.draw("mpl")
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit.quantum_info import Statevector
from qiskit import QuantumCircuit
import math
qc = QuantumCircuit(4)
qc.rx(math.pi/2, [0,1,2,3])
qc.p(math.pi/8, 1)
qc.s(2)
qc.t(3)
qc.draw("mpl")
state = Statevector.from_instruction(qc)
state.draw('bloch')
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit
import math
qc = QuantumCircuit(4)
qc.rx(math.pi/2, [0,1,2,3])
qc.i(1)
qc.u(math.pi/2, 0, math.pi, 2)
qc.u(0,0, math.pi/4, 3)
qc.draw("mpl")
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit.quantum_info import Statevector
from qiskit import QuantumCircuit
import math
qc = QuantumCircuit(4)
qc.rx(math.pi/2, [0,1,2,3])
qc.i(1)
qc.u(math.pi/2, 0, math.pi, 2)
qc.u(0,0, math.pi/4, 3)
qc.draw("mpl")
state = Statevector.from_instruction(qc)
state.draw('bloch')
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit
qc = QuantumCircuit(2)
qc.cx(0, 1)
qc.draw("mpl")
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit, QuantumRegister
qrx = QuantumRegister(3, 'x')
qry = QuantumRegister(1, 'y')
qc = QuantumCircuit(qrx, qry)
qc.x(qry)
qc.draw("mpl")
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.