repo
stringclasses 900
values | file
stringclasses 754
values | content
stringlengths 4
215k
|
|---|---|---|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### added y gate ###
qc.cx(0, 1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
### added h gate ###
qc.h(0)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
### added x gate ###
qc.x(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### added z gate ###
qc.z(1)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
import unittest
import numpy as np
import hypothesis.strategies as st
from hypothesis import given, settings
from qiskit import QuantumCircuit, Aer
#####################################################################################
### Change the file to import from, in order to test a mutant version of the code ###
#####################################################################################
### e.g. from Add_mutant_1 import remove_garbage, generate_binary, encode_message, measure_message
#####################################################################################
from Add_mutant_1 import remove_garbage, generate_binary, encode_message, measure_message
###########################################################################
## Define composite strategies to generate lists of ints in equal length ##
###########################################################################
@st.composite
def single_list(draw):
arrayLengths = draw(st.integers(min_value=1, max_value=100))
fixed_length_list = st.lists(st.integers(min_value=0, max_value=1), min_size=arrayLengths, max_size=arrayLengths)
return (draw(fixed_length_list))
@st.composite
def pair_of_lists(draw):
arrayLengths = draw(st.integers(min_value=1, max_value=100))
fixed_length_list = st.lists(st.integers(min_value=0, max_value=1), min_size=arrayLengths, max_size=arrayLengths)
return (draw(fixed_length_list), draw(fixed_length_list))
@st.composite
def trio_of_lists(draw):
arrayLengths = draw(st.integers(min_value=1, max_value=100))
fixed_length_list = st.lists(st.integers(min_value=0, max_value=1), min_size=arrayLengths, max_size=arrayLengths)
return (draw(fixed_length_list), draw(fixed_length_list), draw(fixed_length_list))
@st.composite
def long_trio_of_lists(draw):
arrayLengths = draw(st.integers(min_value=100, max_value=110))
fixed_length_list = st.lists(st.integers(min_value=0, max_value=1), min_size=arrayLengths, max_size=arrayLengths)
return (draw(fixed_length_list), draw(fixed_length_list), draw(fixed_length_list))
##########################
## test generate binary ##
##########################
@given(testLength = st.integers(min_value=0, max_value=10000))
def test_created_message_is_binary(testLength):
binArr = generate_binary(testLength)
for i in binArr:
assert (i == 1 or i == 0)
@given(testLength = st.integers(min_value=1, max_value=10000))
def test_created_message_equal_length_to_int_passed_in(testLength):
binArr = generate_binary(testLength)
assert(len(binArr) == testLength)
############################
## encoding message tests ##
############################
@given(pair_of_lists())
@settings(deadline=None)
def test_encode_message_equal_length_to_base(lists):
alice_bits, alice_bases = lists
circuitArr = encode_message(alice_bits, alice_bases, len(alice_bits))
assert(len(circuitArr) == len(alice_bits))
############################
## decoding message tests ##
############################
@given(lists = trio_of_lists())
@settings(deadline=None)
def test_decode_message_length_equals_base_length(lists):
alice_bits, alice_bases, bob_base = lists
encoded_message = encode_message(alice_bits, alice_bases, len(bob_base))
msmtArr = measure_message(encoded_message, bob_base, len(bob_base))
assert len(msmtArr) == len(bob_base)
@given(lists = trio_of_lists())
@settings(deadline=None)
def test_decode_message_is_binary(lists):
alice_bits, alice_bases, bob_base = lists
encoded_message = encode_message(alice_bits, alice_bases, len(bob_base))
msmtArr = measure_message(encoded_message, bob_base, len(bob_base))
for i in msmtArr:
assert (i == 1 or i == 0)
@given(lists = pair_of_lists())
@settings(deadline=None)
def test_decode_with_same_base_returns_original_bits(lists):
alice_bits, alice_bases = lists
encoded_message = encode_message(alice_bits, alice_bases, len(alice_bits))
decodeWithSameBases = measure_message(encoded_message, alice_bases, len(alice_bases))
assert(np.array_equal(np.array(alice_bits), np.array(decodeWithSameBases)))
@given(lists = pair_of_lists())
@settings(deadline=None)
def test_decode_with_same_bases_return_same_array(lists):
alice_bits, alice_bases = lists
encoded_message = encode_message(alice_bits, alice_bases, len(alice_bits))
encoded_message2 = encode_message(alice_bits, alice_bases, len(alice_bits))
decodeWithSameBases = measure_message(encoded_message, alice_bases, len(alice_bases))
decodeWithSameBases2 = measure_message(encoded_message2, alice_bases, len(alice_bases))
assert(np.array_equal(np.array(decodeWithSameBases), np.array(decodeWithSameBases2)))
@given(lists = long_trio_of_lists())
@settings(deadline=None)
def test_decoding_runs_likely_different(lists):
alice_bits, alice_bases, bob_bases = lists
encoded_message = encode_message(alice_bits, alice_bases, len(bob_bases))
msmtArr = measure_message(encoded_message, alice_bases, len(alice_bases))
msmtArrRun2 = measure_message(encoded_message, bob_bases, len(bob_bases))
assert(not np.array_equal(np.array(msmtArr), np.array(msmtArrRun2)))
##############################
## remove garbage/key tests ##
##############################
@given(lists = trio_of_lists())
@settings(deadline=None)
def test_key_smaller_or_equal_len_to_original_bits(lists):
alice_bits, alice_bases, bob_base = lists
assert len(remove_garbage(alice_bits, alice_bases, bob_base, len(bob_base))) <= len(bob_base)
@given(lists = trio_of_lists())
@settings(deadline=None)
def test_check_keys_equal(lists):
alice_bits, alice_bases, bob_bases = lists
message = encode_message(alice_bits, alice_bases, len(bob_bases))
bob_results = measure_message(message, bob_bases, len(bob_bases))
alice_key = remove_garbage(alice_bases, bob_bases, alice_bits, len(bob_bases))
bob_key = remove_garbage(alice_bases, bob_bases, bob_results, len(bob_bases))
assert(np.array_equal(np.array(alice_key), np.array(bob_key)))
@given(lists = trio_of_lists())
@settings(deadline=None)
def test_key_is_binary(lists):
alice_bits, alice_bases, bob_bases = lists
alice_key = remove_garbage(alice_bases, bob_bases, alice_bits, len(bob_bases))
for i in alice_key:
assert (i == 1 or i == 0)
if __name__ == "__main__":
test_created_message_is_binary()
test_created_message_equal_length_to_int_passed_in()
test_encode_message_equal_length_to_base()
test_decode_message_length_equals_base_length()
test_decode_message_is_binary()
test_decode_with_same_base_returns_original_bits()
test_decode_with_same_bases_return_same_array()
###########
#test_decoding_runs_likely_different()
###########
test_key_smaller_or_equal_len_to_original_bits()
test_check_keys_equal()
test_key_is_binary()
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit, Aer, transpile, assemble, execute
from qiskit.visualization import plot_histogram, plot_bloch_multivector
from numpy.random import randint
import numpy as np
def generate_binary(len):
return randint(2, size=len)
def encode_message(bits, bases, messageLen):
message = []
for i in range(messageLen):
qc = QuantumCircuit(1,1)
if bases[i] == 0: # Prepare qubit in Z-basis
if bits[i] == 0:
pass
else:
qc.x(0)
else: # Prepare qubit in X-basis
if bits[i] == 0:
qc.h(0)
else:
qc.x(0)
qc.h(0)
qc.barrier()
message.append(qc)
return message
def measure_message(message, bases, messageLen):
backend = Aer.get_backend('aer_simulator')
measurements = []
for q in range(messageLen):
if bases[q] == 0: # measuring in Z-basis
message[q].measure(0,0)
if bases[q] == 1: # measuring in X-basis
message[q].h(0)
message[q].measure(0,0)
aer_sim = Aer.get_backend('aer_simulator')
qobj = assemble(message[q], shots=1, memory=True)
result = aer_sim.run(qobj).result()
measured_bit = int(result.get_memory()[0])
measurements.append(measured_bit)
return measurements
def remove_garbage(a_bases, b_bases, bits, messageLen):
good_bits = []
for q in range(messageLen):
if a_bases[q] == b_bases[q]:
# If both used the same basis, add
# this to the list of 'good' bits
good_bits.append(bits[q])
return good_bits
def sample_bits(bits, selection):
sample = []
for i in selection:
# use np.mod to make sure the
# bit we sample is always in
# the list range
i = np.mod(i, len(bits))
# pop(i) removes the element of the
# list at index 'i'
sample.append(bits.pop(i))
return sample
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### removed cx gate ###
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
### removed x gate ###
pass
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### removed h gate ###
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
### removed z gate ###
pass
return qc
def decode_message(qc):
### removed cx gate ###
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### removed cx gate ###
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### removed h gate ###
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### replaced cx gate ###
qc.cy(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
### replaced z gate ###
qc.x(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### replaced x gate ###
qc.x(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
### replaced x gate ###
qc.x(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### replaced x gate ###
qc.x(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
### replaced x gate ###
qc.z(qubit)
if msg[0] == "1":
### replaced z gate ###
qc.x(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
import unittest
import sys
import math
from qiskit import QuantumCircuit, Aer, transpile, assemble, execute
from qiskit.visualization import plot_histogram, plot_bloch_multivector
from qiskit.circuit.library import Barrier, HGate, XGate
from numpy.random import randint
import numpy as np
np.seterr(divide='ignore', invalid='ignore')
import hypothesis.strategies as st
from hypothesis import given, settings
def generate_binary(len):
return randint(2, size=len)
def encode_message(bits, bases, messageLen):
message = []
for i in range(messageLen):
qc = QuantumCircuit(1,1)
if bases[i] == 0: # Prepare qubit in Z-basis
if bits[i] == 0:
pass
else:
qc.x(0)
else: # Prepare qubit in X-basis
if bits[i] == 0:
qc.h(0)
else:
qc.x(0)
qc.h(0)
qc.barrier()
message.append(qc)
return message
def measure_message(message, bases, messageLen):
measurements = []
for q in range(messageLen):
if bases[q] == 0: # measuring in Z-basis
message[q].measure(0,0)
if bases[q] == 1: # measuring in X-basis
message[q].h(0)
message[q].measure(0,0)
aer_sim = Aer.get_backend('aer_simulator')
qobj = assemble(message[q], shots=1, memory=True)
result = aer_sim.run(qobj).result()
measured_bit = int(result.get_memory()[0])
measurements.append(measured_bit)
return measurements
def remove_garbage(a_bases, b_bases, bits, messageLen):
good_bits = []
for q in range(messageLen):
if a_bases[q] == b_bases[q]:
# If both used the same basis, add
# this to the list of 'good' bits
good_bits.append(bits[q])
return good_bits
def sample_bits(bits, selection):
sample = []
for i in selection:
# use np.mod to make sure the
# bit we sample is always in
# the list range
i = np.mod(i, len(bits))
# pop(i) removes the element of the
# list at index 'i'
sample.append(bits.pop(i))
return sample
np.random.seed(seed=10)
messageLen = 100
## Step 1
# Alice generates bits
alice_bits = generate_binary(messageLen)
## Step 2
# Create an array to tell us which qubits
# are encoded in which bases
alice_bases = generate_binary(messageLen)
message = encode_message(alice_bits, alice_bases, messageLen)
## Step 3
# Decide which basis to measure in:
bob_bases = generate_binary(messageLen)
bob_results = measure_message(message, bob_bases, messageLen)
## Step 4
alice_key = remove_garbage(alice_bases, bob_bases, alice_bits, messageLen)
bob_key = remove_garbage(alice_bases, bob_bases, bob_results, messageLen)
## Step 5
sample_size = 15
bit_selection = generate_binary(sample_size)
print(alice_key)
print(bob_key)
bob_sample = sample_bits(bob_key, bit_selection)
print(" bob_sample = " + str(bob_sample))
alice_sample = sample_bits(alice_key, bit_selection)
print("alice_sample = "+ str(alice_sample))
bob_sample == alice_sample
n = 100
# Step 1
alice_bits = generate_binary(messageLen)
alice_bases = generate_binary(messageLen)
# Step 2
message = encode_message(alice_bits, alice_bases, messageLen)
# Interception!
eve_bases = generate_binary(messageLen)
intercepted_message = measure_message(message, eve_bases, messageLen)
# Step 3
bob_bases = generate_binary(messageLen)
bob_results = measure_message(message, bob_bases, messageLen)
# Step 4
bob_key = remove_garbage(alice_bases, bob_bases, bob_results, messageLen)
alice_key = remove_garbage(alice_bases, bob_bases, alice_bits, messageLen)
# Step 5
sample_size = 1 # Change this to something lower and see if
# Eve can intercept the message without Alice
# and Bob finding out
bit_selection = generate_binary(sample_size)
bob_sample = sample_bits(bob_key, bit_selection)
alice_sample = sample_bits(alice_key, bit_selection)
if bob_sample != alice_sample:
print("Eve's interference was detected.")
else:
print("Eve went undetected!")
###########################################################################
## Define composite strategies to generate lists of ints in equal length ##
###########################################################################
@st.composite
def single_list(draw):
arrayLengths = draw(st.integers(min_value=1, max_value=100))
fixed_length_list = st.lists(st.integers(min_value=0, max_value=1), min_size=arrayLengths, max_size=arrayLengths)
return (draw(fixed_length_list))
@st.composite
def pair_of_lists(draw):
arrayLengths = draw(st.integers(min_value=1, max_value=100))
fixed_length_list = st.lists(st.integers(min_value=0, max_value=1), min_size=arrayLengths, max_size=arrayLengths)
return (draw(fixed_length_list), draw(fixed_length_list))
@st.composite
def trio_of_lists(draw):
arrayLengths = draw(st.integers(min_value=1, max_value=100))
fixed_length_list = st.lists(st.integers(min_value=0, max_value=1), min_size=arrayLengths, max_size=arrayLengths)
return (draw(fixed_length_list), draw(fixed_length_list), draw(fixed_length_list))
@st.composite
def long_trio_of_lists(draw):
arrayLengths = draw(st.integers(min_value=100, max_value=110))
fixed_length_list = st.lists(st.integers(min_value=0, max_value=1), min_size=arrayLengths, max_size=arrayLengths)
return (draw(fixed_length_list), draw(fixed_length_list), draw(fixed_length_list))
##########################
## test generate binary ##
##########################
@given(testLength = st.integers(min_value=0, max_value=10000))
def test_created_message_is_binary(testLength):
binArr = generate_binary(testLength)
for i in binArr:
assert (i == 1 or i == 0)
@given(testLength = st.integers(min_value=1, max_value=10000))
def test_created_message_equal_length_to_int_passed_in(testLength):
binArr = generate_binary(testLength)
assert(len(binArr) == testLength)
############################
## encoding message tests ##
############################
@given(pair_of_lists())
@settings(deadline=None)
def test_encode_message_equal_length_to_base(lists):
alice_bits, alice_bases = lists
circuitArr = encode_message(alice_bits, alice_bases, len(alice_bits))
assert(len(circuitArr) == len(alice_bits))
############################
## decoding message tests ##
############################
@given(lists = trio_of_lists())
@settings(deadline=None)
def test_decode_message_length_equals_base_length(lists):
alice_bits, alice_bases, bob_base = lists
encoded_message = encode_message(alice_bits, alice_bases, len(bob_base))
msmtArr = measure_message(encoded_message, bob_base, len(bob_base))
assert len(msmtArr) == len(bob_base)
@given(lists = trio_of_lists())
@settings(deadline=None)
def test_decode_message_is_binary(lists):
alice_bits, alice_bases, bob_base = lists
encoded_message = encode_message(alice_bits, alice_bases, len(bob_base))
msmtArr = measure_message(encoded_message, bob_base, len(bob_base))
for i in msmtArr:
assert (i == 1 or i == 0)
@given(lists = pair_of_lists())
@settings(deadline=None)
def test_decode_with_same_base_returns_original_bits(lists):
alice_bits, alice_bases = lists
encoded_message = encode_message(alice_bits, alice_bases, len(alice_bits))
decodeWithSameBases = measure_message(encoded_message, alice_bases, len(alice_bases))
assert(np.array_equal(np.array(alice_bits), np.array(decodeWithSameBases)))
@given(lists = pair_of_lists())
@settings(deadline=None)
def test_decode_with_same_bases_return_same_array(lists):
alice_bits, alice_bases = lists
encoded_message = encode_message(alice_bits, alice_bases, len(alice_bits))
encoded_message2 = encode_message(alice_bits, alice_bases, len(alice_bits))
decodeWithSameBases = measure_message(encoded_message, alice_bases, len(alice_bases))
decodeWithSameBases2 = measure_message(encoded_message2, alice_bases, len(alice_bases))
assert(np.array_equal(np.array(decodeWithSameBases), np.array(decodeWithSameBases2)))
@given(lists = long_trio_of_lists())
@settings(deadline=None)
def test_decoding_runs_likely_different(lists):
alice_bits, alice_bases, bob_base = lists
encoded_message = encode_message(alice_bits, alice_bases, len(bob_base))
msmtArr = measure_message(encoded_message, alice_bases, len(alice_bases))
msmtArrRun2 = measure_message(encoded_message, bob_bases, len(bob_base))
assert(not np.array_equal(np.array(msmtArr), np.array(msmtArrRun2)))
##############################
## remove garbage/key tests ##
##############################
@given(lists = trio_of_lists())
@settings(deadline=None)
def test_key_smaller_or_equal_len_to_original_bits(lists):
alice_bits, alice_bases, bob_base = lists
assert len(remove_garbage(alice_bits, alice_bases, bob_base, len(bob_base))) <= len(bob_base)
@given(lists = trio_of_lists())
@settings(deadline=None)
def test_check_keys_equal(lists):
alice_bits, alice_bases, bob_bases = lists
message = encode_message(alice_bits, alice_bases, len(bob_bases))
bob_results = measure_message(message, bob_bases, len(bob_bases))
alice_key = remove_garbage(alice_bases, bob_bases, alice_bits, len(bob_bases))
bob_key = remove_garbage(alice_bases, bob_bases, bob_results, len(bob_bases))
assert(np.array_equal(np.array(alice_key), np.array(bob_key)))
@given(lists = trio_of_lists())
@settings(deadline=None)
def test_key_is_binary(lists):
alice_bits, alice_bases, bob_bases = lists
alice_key = remove_garbage(alice_bases, bob_bases, alice_bits, len(bob_bases))
for i in alice_key:
assert (i == 1 or i == 0)
@given(pair_of_lists())
@settings(deadline=None, max_examples=10)
def test_encode_message_applies_correct_phase(lists):
backend = Aer.get_backend('aer_simulator')
alice_bits, alice_bases = lists
circuitArr = encode_message(alice_bits, alice_bases, len(alice_bits))
for idx, base in enumerate(alice_bases):
if (base == 0):
if(alice_bits[idx] == 0):
print("no assert")
else:
print("no assert")
else:
if(alice_bits[idx] == 0):
assertPhase(backend, circuitArr[idx], [0], [0], 100000, 0.0001)
else:
assertPhase(backend, circuitArr[idx], [0], [180], 100000, 0.0001)
if __name__ == "__main__":
# test_created_message_is_binary()
# test_created_message_equal_length_to_int_passed_in()
# test_encode_message_equal_length_to_base()
# test_decode_message_length_equals_base_length()
# test_decode_message_is_binary()
# test_decode_with_same_base_returns_original_bits()
# test_decode_with_same_bases_return_same_array()
#test_decoding_runs_likely_different()
# test_key_smaller_or_equal_len_to_original_bits()
# test_check_keys_equal()
# test_key_is_binary()
#test_encode_message_applies_correct_phase()
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
import cirq
import random
import matplotlib.pyplot as plt
import numpy as np
import math
def qft_dagger_cirq(qc, qubits, n):
for qubit in range(n//2):
qc.append(cirq.SWAP(qubits[qubit], qubits[n-qubit-1]))
for j in range(n):
for m in range(j):
qc.append((cirq.CZ**(-1/2**(j-m)))(qubits[m],qubits[j]))
qc.append(cirq.H(qubits[j]))
def generalised_qpe_cirq(amt_estimation_qubits, angle, shots = 10000):
# Create and set up circuit
qubits = cirq.LineQubit.range(amt_estimation_qubits+1)
circuit = cirq.Circuit()
# Apply H-Gates to counting qubits:
for qubit in range(amt_estimation_qubits):
circuit.append(cirq.H(qubits[qubit]))
#print(circuit)
# Prepare our eigenstate |psi>:
circuit.append(cirq.X(qubits[amt_estimation_qubits]))
#print(circuit)
repetitions = 1
for counting_qubit in range(amt_estimation_qubits):
for i in range(repetitions):
circuit.append((cirq.CZ**((angle/math.pi)))(qubits[counting_qubit],qubits[amt_estimation_qubits]));
repetitions *= 2
#print(circuit)
# Do the inverse QFT:
qft_dagger_cirq(circuit, qubits, amt_estimation_qubits)
# Measure of course!
circuit.append(cirq.measure(*qubits[:-1], key='m'))
simulator = cirq.Simulator()
results = simulator.run(circuit , repetitions = shots)
theta_estimates = np.sum(2 ** np.arange(amt_estimation_qubits) * results.measurements['m'], axis=1) / 2**amt_estimation_qubits
print(theta_estimates)
counts = dict()
for i in theta_estimates:
counts[i] = counts.get(i, 0) + 1
print(counts)
unique,pos = np.unique(theta_estimates,return_inverse=True)
counts = np.bincount(pos)
maxpos = counts.argmax()
print(unique[maxpos],counts[maxpos])
#generalised_qpe_cirq(7,(13*math.pi/9))
generalised_qpe_cirq(7,(13*math.pi/9))
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### added h gate ###
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
### added x gate ###
qc.x(qubit)
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### added y gate ###
qc.y(0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### added y gate ###
qc.cx(0, 1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
### added h gate ###
qc.h(0)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
### added x gate ###
qc.x(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### added z gate ###
qc.z(1)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
import unittest
import numpy as np
import hypothesis.strategies as st
from hypothesis import given, settings
from qiskit import QuantumCircuit, Aer, execute
from qiskit.circuit.library import QFT
from math import pi, degrees
# importing sys
import sys
from sympy import false
# adding Folder_2 to the system path
import pathlib
sys.path.insert(0, str(pathlib.Path().resolve())+f"/Property_Assertion")
from QuantumAssertions import assertPhase
#####################################################################################
### Change the file to import from, in order to test a mutant version of the code ###
#####################################################################################
### e.g. from Add_mutant_1 import remove_garbage, generate_binary, encode_message, measure_message
#####################################################################################
from QuantumPhaseEstimation import generalised_qpe
###########################################################################
## Define composite strategies to generate lists of ints in equal length ##
###########################################################################
@st.composite
def draw_a_small_and_bigger_number_theta(draw):
small = draw(st.integers(min_value=1, max_value=5))
big = draw(st.integers(min_value=small+1, max_value=7))
theta = draw(st.floats(min_value=0, max_value=1, exclude_max=True))
return(small,big, theta)
@st.composite
def draw_a_qubit_size_and_theta(draw):
size = draw(st.integers(min_value=2, max_value=7))
theta = draw(st.floats(min_value=0, max_value=1, exclude_max=True))
return(size, theta)
##########################
## test generate binary ##
##########################
@given(draw_a_small_and_bigger_number_theta())
@settings(deadline=None)
def more_qubits_better_estimation(vals):
small = vals[0]
big = vals[1]
theta = vals[2]
smallEst = generalised_qpe(small, theta*2*pi, shots=10000)
bigEst = generalised_qpe(big, theta*2*pi, shots=10000)
print("---")
print(smallEst)
print(bigEst)
print(theta)
print(abs(smallEst - theta))
print(abs(bigEst - theta))
assert(abs(smallEst - theta) <= abs(smallEst - theta))
@given(draw_a_qubit_size_and_theta())
@settings(deadline=None)
def accurate_to_2_minus_n_radians(vals):
size = vals[0]
theta = vals[1]
est = generalised_qpe(size, theta*2*pi, shots=10000)
if est == 0:
if abs(1 - theta) < abs(0 - theta):
est = 1
print("---")
print(f"size {size}")
print(f"est {est}")
print(f"theta {theta}")
print(f"abs(est - theta) {abs(est - theta)}")
print(2**-size)
assert(abs(est - theta) <= 2**-size)
if __name__ == "__main__":
more_qubits_better_estimation()
accurate_to_2_minus_n_radians()
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
import warnings
from qiskit import QuantumRegister, ClassicalRegister
from qiskit import QuantumCircuit, Aer, transpile, assemble
from qiskit.tools.monitor import job_monitor
from qiskit.circuit.library import QFT
from qiskit.visualization import plot_histogram, plot_bloch_multivector
warnings.filterwarnings("ignore", category=DeprecationWarning)
import numpy as np
pi = np.pi
def qft_dagger(qc, n):
"""n-qubit QFTdagger the first n qubits in circ"""
# 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(-pi/float(2**(j-m)), m, j)
qc.h(j)
def generalised_qpe(amt_estimation_qubits, angle, shots=10000):
go = True
while go:
# Create and set up circuit
qpe3 = QuantumCircuit(amt_estimation_qubits+1, amt_estimation_qubits)
# Apply H-Gates to counting qubits:
for qubit in range(amt_estimation_qubits):
qpe3.h(qubit)
# Prepare our eigenstate |psi>:
qpe3.x(amt_estimation_qubits)
repetitions = 1
for counting_qubit in range(amt_estimation_qubits):
for i in range(repetitions):
qpe3.cp(angle, counting_qubit, amt_estimation_qubits);
repetitions *= 2
# Do the inverse QFT:
qft_dagger(qpe3, amt_estimation_qubits)
# Measure of course!
qpe3.barrier()
for n in range(amt_estimation_qubits):
qpe3.measure(n,n)
aer_sim = Aer.get_backend('aer_simulator')
t_qpe3 = transpile(qpe3, aer_sim)
qobj = assemble(t_qpe3, shots=shots)
results = aer_sim.run(qobj).result()
answer = results.get_counts()
answer2 = {int(k,2)/2**amt_estimation_qubits: v for k, v in answer.items()}
print(answer2)
try:
freq = answer.most_frequent()
go = False
except:
pass
#print("Most frequent '" + answer.most_frequent() + "'")
print("Approx rotation angle by Z from the unitary in degrees '" + str(360 * int(answer.most_frequent(), 2)/2**amt_estimation_qubits) + "'")
#print("Phase Calculation " + answer.most_frequent())
##return(plot_histogram(answer))
##comment out the return if you want to see the histogram
return((int(answer.most_frequent(), 2)/2**amt_estimation_qubits))
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### removed cx gate ###
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
### removed x gate ###
pass
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### removed h gate ###
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
### removed z gate ###
pass
return qc
def decode_message(qc):
### removed cx gate ###
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### removed cx gate ###
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### removed h gate ###
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### replaced cx gate ###
qc.cy(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
### replaced z gate ###
qc.x(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### replaced x gate ###
qc.x(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
### replaced x gate ###
qc.x(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### replaced x gate ###
qc.x(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
### replaced x gate ###
qc.z(qubit)
if msg[0] == "1":
### replaced z gate ###
qc.x(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
#initialization
import matplotlib.pyplot as plt
import numpy as np
import math
# importing Qiskit
from qiskit import Aer, transpile, assemble
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit.circuit.library import QFT
# import basic plot tools
from qiskit.visualization import plot_histogram, plot_bloch_multivector
def qft_dagger(qc, n):
"""n-qubit QFTdagger the first n qubits in circ"""
# 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(-math.pi/float(2**(j-m)), m, j)
qc.h(j)
def generalised_qpe(amt_estimation_qubits, angle, shots=10000):
# Create and set up circuit
qpe3 = QuantumCircuit(amt_estimation_qubits+1, amt_estimation_qubits)
# Apply H-Gates to counting qubits:
for qubit in range(amt_estimation_qubits):
qpe3.h(qubit)
# Prepare our eigenstate |psi>:
qpe3.x(amt_estimation_qubits)
repetitions = 1
for counting_qubit in range(amt_estimation_qubits):
for i in range(repetitions):
qpe3.cp(angle, counting_qubit, amt_estimation_qubits);
repetitions *= 2
# Do the inverse QFT:
qft_dagger(qpe3, amt_estimation_qubits)
# Measure of course!
qpe3.barrier()
for n in range(amt_estimation_qubits):
qpe3.measure(n,n)
# Let's see the results!
aer_sim = Aer.get_backend('aer_simulator')
t_qpe3 = transpile(qpe3, aer_sim)
qobj = assemble(t_qpe3, shots=shots)
results = aer_sim.run(qobj).result()
answer = results.get_counts()
answer2 = {int(k,2)/2**amt_estimation_qubits: v for k, v in answer.items()}
print(answer2)
print("Most frequent '" + answer.most_frequent() + "'")
print("Approx rotation angle by Z from the unitary in degrees '" + str(360 * int(answer.most_frequent(), 2)/2**amt_estimation_qubits) + "'")
print("Phase Calculation " + answer.most_frequent())
##return(plot_histogram(answer))
##comment out the return if you want to see the histogram
return((int(answer.most_frequent(), 2)/2**amt_estimation_qubits))
#generalised_qpe(7,(13*math.pi/9))
#generalised_qpe(2,(3*math.pi/4))
generalised_qpe(7,(13*math.pi/9))
def visualise_rotation_angle(angle):
sim = Aer.get_backend('aer_simulator')
q = QuantumRegister(1,'q')
c = ClassicalRegister(1,'c')
qc = QuantumCircuit(q,c)
qc.h(0)
qc.p(angle, 0);
qc.save_statevector()
statevector = sim.run(qc).result().get_statevector()
return(plot_bloch_multivector(statevector))
visualise_rotation_angle((2*math.pi)/3)
visualise_rotation_angle(2*math.pi*(generalised_qpe(3,(2*math.pi)/3)))
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
import unittest
import hypothesis.strategies as st
from hypothesis import given, settings, note
import matplotlib.pyplot as plt
import numpy as np
import math
import cirq
from cirq.ops import H, X, I
from numpy.random import randint
import pandas as pd
from fractions import Fraction
from math import gcd # greatest common divisor
"""Function to compute the elements of Z_n."""
def multiplicative_group(n):
"""Returns the multiplicative group modulo n.
Args:
n: Modulus of the multiplicative group.
"""
print("multiplicative group")
assert n > 1
group = [1]
for x in range(2, n):
if math.gcd(x, n) == 1:
group.append(x)
return group
def qft_dagger_cirq(qc, qubits, n):
for qubit in range(n//2):
qc.append(cirq.SWAP(qubits[qubit], qubits[n-qubit-1]))
for j in range(n):
for m in range(j):
qc.append((cirq.CZ**(-1/2**(j-m)))(qubits[m],qubits[j]))
qc.append(cirq.H(qubits[j]))
def general_modular_exp(a, N, power):
mult_group = multiplicative_group(N)
if a not in mult_group:
raise ValueError("'a' must be in " + str(mult_group))
print(mult_group)
general_modular_exp(7, 15, 2)
def VBE_Adder(qubit_size, qubits):
#outputs a + b
#inverse outputs b - a (but in two's complement)
#move to carry
#qubits = cirq.LineQubit.range(3*qubit_size + 1)
qc = cirq.Circuit()
for i in range(qubit_size-1):
qc.append(cirq.CCNOT(qubits[i], qubits[i+qubit_size], qubits[2+i+(2*qubit_size)]))
#toffoli to second register
qc.append(cirq.CCNOT(qubits[qubit_size-1], qubits[(2*qubit_size)-1], qubits[2*qubit_size]))
#add a to b
for i in range(qubit_size):
qc.append(cirq.CNOT(qubits[i], qubits[i+qubit_size]))
#second register carry and last b
for i in range(qubit_size-1):
qc.append(cirq.CCNOT(qubits[i+qubit_size], qubits[1+i+(2*qubit_size)], qubits[2+i+(2*qubit_size)]))
qc.append(cirq.CCNOT(qubits[(2*qubit_size)-1], qubits[3*qubit_size], qubits[2*qubit_size]))
qc.append(cirq.CNOT(qubits[3*qubit_size], qubits[(2*qubit_size)-1]))
#adder overflow
for i in range(qubit_size-1):
qc.append(cirq.CCNOT(qubits[(2*qubit_size) - 2 - i], qubits[(3*qubit_size) - i - 1], qubits[(3*qubit_size) - i]))
qc.append(cirq.CNOT(qubits[(qubit_size) - 2 - i], qubits[(2*qubit_size) - 2 - i]))
qc.append(cirq.CCNOT(qubits[(qubit_size) - 2 - i], qubits[(2*qubit_size) - 2 - i], qubits[(3*qubit_size) - i]))
qc.append(cirq.CNOT(qubits[(qubit_size) - 2 - i], qubits[(2*qubit_size) - 2 - i]))
qc.append(cirq.CNOT(qubits[(3*qubit_size) - i - 1], qubits[(2*qubit_size) - 2 - i]))
#print(qc.draw(output='text'))
qc.name = "VBE ADDER"
return qc
#VBE_Adder(4)
def Modular_adder(qubit_size, N, qubits):
binN = bin(N)[2:].zfill(qubit_size)[::-1]
#move to carry
#qubits = cirq.LineQubit.range(4*qubit_size + 2)
qc = cirq.Circuit()
qc.append(VBE_Adder(qubit_size, qubits[0:3*qubit_size+1]))
for i in range(qubit_size):
qc.append(cirq.SWAP(qubits[i], qubits[i + 1 + 3*qubit_size]))
qc.append(cirq.inverse(VBE_Adder(qubit_size, qubits[0:3*qubit_size+1])))
qc.append(cirq.X(qubits[2*qubit_size]))
qc.append(cirq.CNOT(qubits[2*qubit_size], qubits[4*qubit_size+1]))
qc.append(cirq.X(qubits[2*qubit_size]))
for i in range(qubit_size):
if binN[i] == "1":
qc.append(cirq.CNOT(qubits[4*qubit_size + 1], qubits[i]))
qc.append(VBE_Adder(qubit_size, qubits[0:3*qubit_size+1]))
for i in range(qubit_size):
if binN[i] == "1":
qc.append(cirq.CNOT(qubits[4*qubit_size + 1], qubits[i]))
for i in range(qubit_size):
qc.append(cirq.SWAP(qubits[i], qubits[i + 1 + 3*qubit_size]))
qc.append(cirq.inverse(VBE_Adder(qubit_size, qubits[0:3*qubit_size+1])))
qc.append(cirq.CNOT(qubits[2*qubit_size], qubits[4*qubit_size+1]))
qc.append(VBE_Adder(qubit_size, qubits[0:3*qubit_size+1]))
qc.name = "MODULAR ADDER"
return qc
#Modular_adder(4,11,qubits)
# from IPython.core.display import display, HTML
# display(HTML("<style>.container { width:60% !important; }</style>"))
# size = 4
# N = 7
# qc = QuantumCircuit(4*size + 2)
# # a = 3,2,1,0
# #qc.x(3)
# qc.x(2)
# qc.x(1)
# qc.x(0)
# # b = 8,7,6,5,4
# #qc.x(7)
# qc.x(6)
# qc.x(5)
# qc.x(4)
# # carry = 12,11,10,9
# # modulus N = 16,15,14,13
# binN = bin(N)[2:].zfill(size)[::-1]
# for i in range(size):
# if binN[i] == "1":
# qc.x(3*size + 1 + i)
# # temporary carry = 17
# print(qc)
# qc.measure_all()
# qc.append(Modular_adder(size,N), [i for i in range(4*size+2)])
# qc.measure_all()
# backend = Aer.get_backend('aer_simulator')
# job = execute(qc, backend, shots=1, memory=True)
# readings = job.result().get_memory()
# second_set = readings[0][0:4*size+2]
# first_set = readings[0][(4*size)+3:(8*size)+6]
# print(readings)
# print(first_set)
# print(second_set)
# print('a = ' + str(first_set[3*size + 2: 4*size + 2]))
# print('b = ' + str(first_set[2*size + 1: 3*size + 2]))
# print('b out = ' + str(second_set[2*size + 1: 3*size + 2]))
# #print('carry = ' + str(second_set[0:size]))
def Modular_multiplier(qubit_size, N, a, qubits):
qc = cirq.Circuit()
for i in range(qubit_size):
mod = bin(a*(2**i) % N)[2:].zfill(qubit_size)[::-1]
for j in range(qubit_size):
if mod[j] == "1":
qc.append(cirq.CCNOT(qubits[0], qubits[i+1], qubits[qubit_size + 1 + j]))
qc.append(Modular_adder(qubit_size, N, qubits[qubit_size + 1:(5*qubit_size+3)]))
#can just repeat the above method, but this looks symmetric
#the circuit diagram is more intuitive
for j in range(qubit_size):
if mod[::-1][j] == "1":
qc.append(cirq.CCNOT(qubits[0], qubits[i+1], qubits[2*qubit_size - j]))
#set x if control is false
qc.append(cirq.X(qubits[0]))
for i in range(qubit_size):
qc.append(cirq.CCNOT(qubits[0], qubits[i+1], qubits[2*qubit_size + 1 + i]))
qc.append(cirq.X(qubits[0]))
qc.name = "MODULAR MULTIPLIER " + str(a) + "x mod " + str(N)
#print(qc.inverse().draw(output='text'))
return qc
#Modular_multiplier(4, 15, 13)
size = 2
N = 2
a = 1
qubits = cirq.LineQubit.range(5*size + 3)
qc = cirq.Circuit()
#control qubit
qc.append(cirq.X(qubits[0]))
# x = 4,3,2,1
#qc.append(cirq.X(qubits[4]))
#qc.append(cirq.X(qubits[3]))
#qc.append(cirq.X(qubits[2]))
#qc.append(cirq.X(qubits[1]))
# N = 21,20,19,18
binN = bin(N)[2:].zfill(size)[::-1]
for i in range(size):
if binN[i] == "1":
qc.append(cirq.X(qubits[4*size + 2 + i]))
# temporary carry = 17
#print(qc)
qc.append(cirq.measure(*qubits[0:5*size+3], key='m1'))
qc.append(Modular_multiplier(size, N, a, qubits[0:(5*size+3)]))
#print(qc)
qc.append(cirq.measure(*qubits[0:5*size+3], key='m2'))
simulator = cirq.Simulator()
results = simulator.run(qc , repetitions =1)
first_set = np.array2string(results.measurements['m1'][0], separator='')[1:-1][::-1]
second_set = np.array2string(results.measurements['m2'][0], separator='')[1:-1][::-1]
print(first_set)
print(second_set)
print('x = ' + str(first_set[4*size + 2: 5*size + 2]))
print('b = ' + str(first_set[2*size + 1: 3*size + 2]))
print('b out = ' + str(second_set[2*size + 1: 3*size + 2]))
#print('carry = ' + str(second_set[0:size]))
def Modular_exponentiation(qubit_size, N, a, qubits):
qc = cirq.Circuit()
#need to set x to 1
qc.append(cirq.X(qubits[qubit_size+1]))
for i in range(qubit_size):
qc.append(cirq.CNOT(qubits[i],qubits[qubit_size]))
qc.append(Modular_multiplier(qubit_size, N, a**(2**i)%N, qubits[qubit_size:(6*qubit_size+3)]))
for j in range(qubit_size):
qc.append(cirq.SWAP(qubits[qubit_size+1+j], qubits[3*qubit_size+1+j]))
#we dont use A for this multiplier because we need the modular multiplicative inverse
#print(a**(2**i)%N)
#print(pow(a**(2**i)%N, -1, N))
qc.append(cirq.inverse(Modular_multiplier(qubit_size, N, pow(a**(2**i)%N, -1, N), qubits[qubit_size:(6*qubit_size+3)])))
qc.append(cirq.CNOT(qubits[i],qubits[qubit_size]))
qc.name = "MODULAR EXPONENTIATION"
#print(qc.draw(output='text'))
return qc
#qubits = cirq.LineQubit.range(6*3 + 3)
#Modular_exponentiation(3, 7, 3,qubits)
# qubit_size = 2
# N = 3
# a = 1
# qc = QuantumCircuit(6*qubit_size + 3)
# # x = 3,2,1,0
# #qc.x(3)
# qc.x(2)
# #qc.x(1)
# #qc.x(0)
# # N = 21,20,19,18
# binN = bin(N)[2:].zfill(qubit_size)[::-1]
# print(binN)
# for i in range(qubit_size):
# if binN[i] == "1":
# qc.x(5*qubit_size + 2 + i)
# #print(qc)
# qc.measure_all()
# qc.append(Modular_exponentiation(qubit_size, N, a), [i for i in range(6*qubit_size+3)])
# qc.measure_all()
# #print(qc)
# backend = Aer.get_backend('aer_simulator')
# job = execute(qc, backend, shots=1, memory=True)
# readings = job.result().get_memory()[0].split(' ')
# second_set = readings[0]
# first_set = readings[1]
# print(first_set)
# print(second_set)
# first_set_exp = first_set[(5 * qubit_size) + 3 : (6 * qubit_size) + 3]
# first_set_x = first_set[(4 * qubit_size) + 2 : (5 * qubit_size) + 2]
# first_set_a = first_set[(3 * qubit_size) + 2 : (4 * qubit_size) + 2]
# first_set_b = first_set[(2 * qubit_size) + 1 : (3 * qubit_size) + 2]
# first_set_N = first_set[qubit_size + 1 : (2 * qubit_size) + 1]
# second_set_exp = second_set[(5 * qubit_size) + 3 : (6 * qubit_size) + 3]
# second_set_x = second_set[(4 * qubit_size) + 2 : (5 * qubit_size) + 2]
# second_set_a = second_set[(3 * qubit_size) + 2 : (4 * qubit_size) + 2]
# second_set_b = second_set[(2 * qubit_size) + 1 : (3 * qubit_size) + 2]
# second_set_N = second_set[qubit_size + 1 : (2 * qubit_size) + 1]
# print("A = " + str(a))
# print("exps 1 -> 2 = " + str(first_set_exp) + " -> " + str(second_set_exp))
# print("xs 1 -> 2 = " + str(first_set_x) + " -> " + str(second_set_x))
# print("as 1 -> 2 = " + str(first_set_a) + " -> " + str(second_set_a))
# print("bs 1 -> 2 = " + str(first_set_b) + " -> " + str(second_set_b))
# print("Ns 1 -> 2 = " + str(first_set_N) + " -> " + str(second_set_N))
# #print('carry = ' + str(second_set[0:size]))
def run_shors(qubit_size, N, a, run_amt):
qubits = cirq.LineQubit.range(6*qubit_size + 3)
qc = cirq.Circuit()
# N = 21,20,19,18
binN = bin(N)[2:].zfill(qubit_size)[::-1]
for i in range(qubit_size):
qc.append(cirq.H(qubits[i]))
for i in range(qubit_size):
if binN[i] == "1":
qc.append(cirq.X(qubits[5*qubit_size + 2 + i]))
qc.append(Modular_exponentiation(qubit_size, N, a, qubits[0:(6*qubit_size+3)]))
qft_dagger_cirq(qc, qubits[:qubit_size], qubit_size)
qc.append(cirq.measure(*qubits[:qubit_size]))
#backend = Aer.get_backend('aer_simulator')
#job = execute(qc, backend, shots=run_amt, memory=True)
# return(job.result().get_memory())
simulator = cirq.Simulator()
results = simulator.run(qc , repetitions =run_amt)
#readings = np.array2string(results.measurements['m'][0], separator='')[1:-1][::-1]
return results
#print(run_shors(3,7,3,1))
#%timeit run_shors(10,26,7,20)
# for loop at the bootom from qiskit textbook for postpro
# https://qiskit.org/textbook/ch-algorithms/shor.html#:~:text=if%20phase%20!%3D%200,guess)%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20factor_found%20%3D%20True
def shors_with_postpro(N, a, tries):
factors = []
if not a < N:
raise ValueError("a(%i) must be less than N(%i)"%(a,N))
common_denom = gcd(a,N)
if not common_denom == 1:
raise ValueError("a(%i) and N(%i) must be coprime but they have a gcd of (%i)"%(a, N, common_denom))
length_message = len(bin(N)[2:])*2
if length_message > 8:
print(f"The length of the number you are trying to factor is large ({length_message}), it may fail or take a long time")
res = run_shors(len(bin(N)[2:])*2, N, a, tries)
for result in res:
phase = (int(result,2)/(2**length_message))
frac = Fraction(phase).limit_denominator(N)
r = frac.denominator
print(r)
#if phase != 0:
# guesses = [gcd(a**(r//2)-1, N), gcd(a**(r//2)+1, N)]
# for guess in guesses:
# if guess not in [1,N] and (N % guess) == 0:
# factors += [guess]
# return factors
shors_with_postpro(7, 3, 4)
def twos_comp_to_int(binNum):
binNum = int(binNum,2) ^ ((2**len(binNum))-1)
binNum = bin(binNum + 1)
return -int(binNum,2)
@st.composite
def draw_pair_of_ints(draw):
size = draw(st.integers(min_value=1, max_value=6))
a = draw(st.integers(min_value=0, max_value=(2**size)-1))
b = draw(st.integers(min_value=0, max_value=(2**size)-1))
return(a, b, size)
@st.composite
def draw_shors_variables(draw):
size = draw(st.integers(min_value=2, max_value=5))
mod = draw(st.integers(min_value=3, max_value=(2**size)-1))
a = draw(st.integers(min_value=2, max_value=mod-1))
return(a, mod, size)
@st.composite
def draw_pair_of_ints_and_mod(draw):
size = draw(st.integers(min_value=2, max_value=4))
mod = draw(st.integers(min_value=2, max_value=(2**size)-1))
a = draw(st.integers(min_value=0, max_value=mod-1))
b = draw(st.integers(min_value=0, max_value=mod-1))
return(a, b, size, mod)
# @given(draw_shors_variables())
# @settings(deadline=None)
# def test_shors_with_postpro(vals):
# a = vals[0]
# N = vals[1]
# size = vals[2]
# for i in range(size):
# try:
# pow(a**(2**i)%N, -1, N)
# except ValueError:
# assert(not(math.gcd(a,N) == 1))
# if math.gcd(a,N) == 1:
# factors = shors_with_postpro(N, a, 20)
# for factor in factors:
# print(f"N {N}, factor {factor}")
# assert(N % factor == 0)
# @given(draw_pair_of_ints_and_mod())
# @settings(deadline=None)
# def test_modular_exponentiation(vals):
# a = vals[0]
# x = vals[1]
# size = vals[2]
# N = vals[3]
# for i in range(size):
# try:
# pow(a**(2**i)%N, -1, N)
# except ValueError:
# assert(not(math.gcd(a,N) == 1))
# if math.gcd(a,N) == 1:
# qubits = cirq.LineQubit.range(6*size + 3)
# qc = cirq.Circuit()
# binX = bin(x)[2:].zfill(size)[::-1]
# binN = bin(N)[2:].zfill(size)[::-1]
# print("size " + str(size))
# print("a " + str(a))
# print("x " + str(x))
# print("N " + str(N))
# print("\n")
# # x = 3,2,1,0
# for i in range(size):
# if binX[i] == "1":
# qc.x(i)
# for i in range(size):
# if binN[i] == "1":
# qc.x(5*size + 2 + i)
# #print(qc)
# qc.measure_all()
# qc.append(Modular_exponentiation(size, N, a), [i for i in range(6*size+3)])
# qc.measure_all()
# backend = Aer.get_backend('aer_simulator')
# job = execute(qc, backend, shots=1, memory=True)
# readings = job.result().get_memory()[0].split(' ')
# second_set = readings[0]
# first_set = readings[1]
# print(first_set)
# print(second_set)
# first_set_exp = first_set[(5 * size) + 3 : (6 * size) + 3]
# first_set_x = first_set[(4 * size) + 2 : (5 * size) + 2]
# first_set_a = first_set[(3 * size) + 2 : (4 * size) + 2]
# first_set_b = first_set[(2 * size) + 1 : (3 * size) + 2]
# first_set_N = first_set[size + 1 : (2 * size) + 1]
# second_set_exp = second_set[(5 * size) + 3 : (6 * size) + 3]
# second_set_x = second_set[(4 * size) + 2 : (5 * size) + 2]
# second_set_a = second_set[(3 * size) + 2 : (4 * size) + 2]
# second_set_b = second_set[(2 * size) + 1 : (3 * size) + 2]
# second_set_N = second_set[size + 1 : (2 * size) + 1]
# print("A = " + str(a))
# print("exps 1 -> 2 = " + str(first_set_exp) + " -> " + str(second_set_exp))
# print("xs 1 -> 2 = " + str(first_set_x) + " -> " + str(second_set_x))
# print("as 1 -> 2 = " + str(first_set_a) + " -> " + str(second_set_a))
# print("bs 1 -> 2 = " + str(first_set_b) + " -> " + str(second_set_b))
# print("Ns 1 -> 2 = " + str(first_set_N) + " -> " + str(second_set_N))
# print(a)
# print(x)
# print(N)
# print('\n\n')
# assert((a ** x) % N == int(second_set_x, 2))
# @given(draw_pair_of_ints_and_mod(), st.booleans())
# @settings(deadline=None)
# def test_modular_multiplier_then_inverse_returns_original_values(vals, control):
# a = vals[0]
# x = vals[1]
# size = vals[2]
# N = vals[3]
# qubits = cirq.LineQubit.range(5*size + 3)
# qc = cirq.Circuit()
# binX = bin(x)[2:].zfill(size)[::-1]
# binN = bin(N)[2:].zfill(size)[::-1]
# print("size " + str(size))
# print("a " + str(a))
# print("x " + str(x))
# print("N " + str(N))
# print("control " + str(control))
# print("\n")
# #control qubit
# if control == True:
# qc.x(0)
# # x = 3,2,1,0
# for i in range(size):
# if binX[i] == "1":
# qc.x(i+1)
# for i in range(size):
# if binN[i] == "1":
# qc.x(4*size + 2 + i)
# print(qc)
# qc.measure_all()
# qc.append(Modular_multiplier(size, N, a), [i for i in range(5*size+3)])
# qc.append(Modular_multiplier(size, N, a).inverse(), [i for i in range(5*size+3)])
# qc.measure_all()
# backend = Aer.get_backend('aer_simulator')
# job = execute(qc, backend, shots=1, memory=True)
# readings = job.result().get_memory()
# second_set = readings[0][0:5*size+3]
# first_set = readings[0][(5*size)+4:(10*size)+7]
# print("readings " + str(readings))
# print("first set " + str(first_set))
# print("second set " + str(second_set))
# assert(first_set == second_set)
@given(draw_pair_of_ints_and_mod(), st.booleans())
@settings(deadline=None)
def test_modular_multiplier(vals, control):
a = vals[0]
x = vals[1]
size = vals[2]
N = vals[3]
print(a)
print(x)
print(size)
print(N)
qubits = cirq.LineQubit.range(5*size + 3)
qc = cirq.Circuit()
binX = bin(x)[2:].zfill(size)[::-1]
binN = bin(N)[2:].zfill(size)[::-1]
#control qubit
if control == True:
qc.append(cirq.X(qubits[0]))
# x = 3,2,1,0
for i in range(size):
if binX[i] == "1":
qc.append(cirq.X(qubits[i+1]))
for i in range(size):
if binN[i] == "1":
qc.append(cirq.X(qubits[4*size + 2 + i]))
qc.append(cirq.measure(*qubits[0:5*size + 3], key='m1'))
qc.append(Modular_multiplier(size, N, a, qubits[0:(5*size+3)]))
qc.append(cirq.measure(*qubits[0:5*size + 3], key='m2'))
simulator = cirq.Simulator()
results = simulator.run(qc , repetitions =1)
first_set = np.array2string(results.measurements['m1'][0], separator='')[1:-1][::-1]
second_set = np.array2string(results.measurements['m2'][0], separator='')[1:-1][::-1]
print("f " + first_set)
print('s ' + second_set)
x = int(first_set[4*size + 2: 5*size + 2], 2)
print(first_set[4*size + 2: 5*size + 2])
b = int(first_set[2*size + 1: 3*size + 2], 2)
bout = int(second_set[2*size + 1: 3*size + 2], 2)
print("control " + str(control))
print("size = " + str(size))
print('b = ' + str(b))
print('a = ' + str(a))
print('x = ' + str(x))
print("N = " + str(N))
print('b out = ' + str(bout))
print('\n\n')
if (control == False):
assert(bout == x)
else:
assert((a * x) % N == bout)
@given(draw_pair_of_ints_and_mod())
@settings(deadline=None)
def test_modular_adder(vals):
a = vals[0]
b = vals[1]
size = vals[2]
N = vals[3]
qubits = cirq.LineQubit.range(4*size + 2)
qc = cirq.Circuit()
binA = bin(a)[2:].zfill(size)[::-1]
binB = bin(b)[2:].zfill(size)[::-1]
binN = bin(N)[2:].zfill(size)[::-1]
print("size " + str(size))
print("a " + str(a))
print("b " + str(b))
print("N " + str(N))
print("\n")
# a = 3,2,1,0
for i in range(size):
if binA[i] == "1":
qc.append(cirq.X(qubits[i]))
# b = 8,7,6,5,4
for i in range(size):
if binB[i] == "1":
qc.append(cirq.X(qubits[i+size]))
# carry = 12,11,10,9
# modulus N = 16,15,14,13
for i in range(size):
if binN[i] == "1":
qc.append(cirq.X(qubits[3*size + 1 + i]))
# temporary carry = 17
#print(qc)
qc.append(cirq.measure(*qubits[0:4*size+2], key='m1'))
qc.append(Modular_adder(size,N, qubits[0:4*size+2]))
qc.append(cirq.measure(*qubits[0:4*size+2], key='m2'))
simulator = cirq.Simulator()
results = simulator.run(qc , repetitions =1)
first_set = np.array2string(results.measurements['m1'][0], separator='')[1:-1][::-1]
second_set = np.array2string(results.measurements['m2'][0], separator='')[1:-1][::-1]
a = int(first_set[3*size + 2: 4*size + 2], 2)
b = int(first_set[2*size + 1: 3*size + 2], 2)
bout = int(second_set[2*size + 1: 3*size + 2], 2)
print('a = ' + str(a))
print('b = ' + str(b))
print('b out = ' + str(bout))
print('\n\n')
assert((a+b)%N == bout)
@given(draw_pair_of_ints())
@settings(deadline=None)
def test_add_using_VBE_Adder(vals):
a = vals[0]
b = vals[1]
size = vals[2]
qubits = cirq.LineQubit.range(3*size + 1)
qc = cirq.Circuit()
binA = bin(a)[2:].zfill(size)[::-1]
binB = bin(b)[2:].zfill(size)[::-1]
print("size " + str(size))
print("a " + str(a))
print(binA)
print("b " + str(b))
print(binB)
# a = 3,2,1,0
for i in range(size):
if binA[i] == "1":
qc.append(cirq.X(qubits[i]))
# b = 8,7,6,5,4
for i in range(size):
if binB[i] == "1":
qc.append(cirq.X(qubits[i+size]))
# carry = 12,11,10,9
qc.append(cirq.measure(*qubits[0:3*size+1], key='m1'))
qc.append(VBE_Adder(size, qubits[0:3*size+1]))
qc.append(cirq.measure(*qubits[0:3*size+1], key='m2'))
simulator = cirq.Simulator()
results = simulator.run(qc , repetitions =1)
first_set = np.array2string(results.measurements['m1'][0], separator='')[1:-1][::-1]
second_set = np.array2string(results.measurements['m2'][0], separator='')[1:-1][::-1]
a = int(first_set[2*size + 1: 3*size + 1],2)
b = int(first_set[size: 2*size + 1],2)
bout = int(second_set[size: 2*size + 1],2)
carry = int(second_set[0: size],2)
print('a = ' + str(a))
print('b = ' + str(b))
print('b out = ' + str(bout))
print('\n\n')
assert(a+b == bout)
assert(carry == 0)
@given(draw_pair_of_ints())
@settings(deadline=None)
def test_subtract_using_VBE_Adder_inverse(vals):
a = vals[0]
b = vals[1]
size = vals[2]
qubits = cirq.LineQubit.range(3*size + 1)
qc = cirq.Circuit()
binA = bin(a)[2:].zfill(size)[::-1]
binB = bin(b)[2:].zfill(size)[::-1]
print("size " + str(size))
print("a " + str(a))
print(binA)
print("b " + str(b))
print(binB)
# a = 3,2,1,0
for i in range(size):
if binA[i] == "1":
qc.append(cirq.X(qubits[i]))
# b = 8,7,6,5,4
for i in range(size):
if binB[i] == "1":
qc.append(cirq.X(qubits[i+size]))
# carry = 12,11,10,9
qc.append(cirq.measure(*qubits[0:3*size+1], key='m1'))
qc.append(cirq.inverse(VBE_Adder(size,qubits[0:3*size+1])))
qc.append(cirq.measure(*qubits[0:3*size+1], key='m2'))
simulator = cirq.Simulator()
results = simulator.run(qc , repetitions =1)
first_set = np.array2string(results.measurements['m1'][0], separator='')[1:-1][::-1]
second_set = np.array2string(results.measurements['m2'][0], separator='')[1:-1][::-1]
a = int(first_set[2*size + 1: 3*size + 1],2)
b = int(first_set[size: 2*size + 1],2)
if (b < a):
bout = twos_comp_to_int(second_set[size: 2*size + 1])
else:
bout = int(second_set[size: 2*size + 1],2)
carry = int(second_set[0: size],2)
print('a = ' + str(a))
print('b = ' + str(b))
print('b out = ' + str(bout))
print('\n\n')
assert(b-a == bout)
assert(carry == 0)
if __name__ == '__main__':
#test_shors_with_postpro()
#test_modular_exponentiation()
#test_modular_multiplier_then_inverse_returns_original_values()
test_modular_multiplier()
#test_modular_adder()
#test_add_using_VBE_Adder()
#test_subtract_using_VBE_Adder_inverse()
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
import unittest
import cirq
from cirq.ops import H, X, I
import random
import matplotlib.pyplot as plt
from math import gcd
import numpy as np
from numpy.random import randint
#import hypothesis.strategies as st
#from hypothesis import given, settings
from fractions import Fraction
from math import gcd # greatest common divisor
# Specify variables
n_count = 8 # number of counting qubits
a = 7
N = 15
class aMod15Gate(cirq.Gate):
def __init__(self, a, power):
super(aMod15Gate, self)
self.a = a
self.power = power
def _num_qubits_(self):
return 4
def _decompose_(self, qubits):
q0, q1, q2, q3 = qubits
if self.a not in [2,7,8,11,13]:
raise ValueError("'a' must be 2,7,8,11 or 13")
for iteration in range(self.power):
if self.a in [2,13]:
yield cirq.SWAP(q0,q1)
yield cirq.SWAP(q1,q2)
yield cirq.SWAP(q2,q3)
if self.a in [7,8]:
yield cirq.SWAP(q2,q3)
yield cirq.SWAP(q1,q2)
yield cirq.SWAP(q0,q1)
if self.a == 11:
yield cirq.SWAP(q1,q3)
yield cirq.SWAP(q0,q2)
if self.a in [7,11,13]:
yield cirq.X(q0)
yield cirq.X(q1)
yield cirq.X(q2)
yield cirq.X(q3)
def _circuit_diagram_info_(self, args):
return "a mod 15"
def qft_dagger_cirq(qc, qubits, n):
for qubit in range(n//2):
qc.append(cirq.SWAP(qubits[qubit], qubits[n-qubit-1]))
for j in range(n):
for m in range(j):
qc.append((cirq.CZ**(-1/2**(j-m)))(qubits[m],qubits[j]))
qc.append(cirq.H(qubits[j]))
def qpe_amod15(a):
n_count = 8
qubits = cirq.LineQubit.range(4+n_count)
qc = cirq.Circuit()
for q in range(n_count):
#print(q)
qc.append(cirq.H(qubits[q])) # Initialize counting qubits in state |+>
qc.append(cirq.X(qubits[3+n_count])) # And auxiliary register in state |1>
for q in range(n_count): # Do controlled-U operations
qc.append(aMod15Gate(a, 2**q).on(qubits[8],qubits[9],qubits[10],qubits[11]).controlled_by(qubits[q]))
qft_dagger_cirq(qc, qubits[:n_count], n_count) # Do inverse-QF
qc.append(cirq.measure(*qubits[:8], key='m'))
# Simulate Results
simulator = cirq.Simulator()
results = simulator.run(qc , repetitions =1)
readings = np.array2string(results.measurements['m'][0], separator='')[1:-1][::-1]
phase = int(readings,2)/(2**n_count)
return phase
phase = qpe_amod15(a) # Phase = s/r
Fraction(phase).limit_denominator(15)
frac = Fraction(phase).limit_denominator(15)
s, r = frac.numerator, frac.denominator
print(r)
guesses = [gcd(a**(r//2)-1, N), gcd(a**(r//2)+1, N)]
print(guesses)
def find_factor(coprime):
a = coprime
attempt = 0
factors = []
for i in range(100):
attempt += 1
#print("\nAttempt %i:" % attempt)
phase = qpe_amod15(a) # Phase = s/r
frac = Fraction(phase).limit_denominator(N) # Denominator should (hopefully!) tell us r
r = frac.denominator
#print("Result: r = %i" % r)
if phase != 0:
# Guesses for factors are gcd(x^{r/2} ±1 , 15)
guesses = [gcd(a**(r//2)-1, N), gcd(a**(r//2)+1, N)]
#print("Guessed Factors: %i and %i" % (guesses[0], guesses[1]))
for guess in guesses:
if guess not in [1,N] and (N % guess) == 0: # Check to see if guess is a factor
# print("*** Non-trivial factor found: %i ***" % guess)
factors += [guess]
return factors
find_factor(7)
import fractions
import math
import random
import numpy as np
import sympy
from typing import Callable, List, Optional, Sequence, Union
import cirq
"""Function to compute the elements of Z_n."""
def multiplicative_group(n: int) -> List[int]:
"""Returns the multiplicative group modulo n.
Args:
n: Modulus of the multiplicative group.
"""
print("multiplicative group")
assert n > 1
group = [1]
for x in range(2, n):
if math.gcd(x, n) == 1:
group.append(x)
return group
"""Defines the modular exponential operation used in Shor's algorithm."""
class ModularExp(cirq.ArithmeticOperation):
"""Quantum modular exponentiation.
This class represents the unitary which multiplies base raised to exponent
into the target modulo the given modulus. More precisely, it represents the
unitary V which computes modular exponentiation x**e mod n:
V|y⟩|e⟩ = |y * x**e mod n⟩ |e⟩ 0 <= y < n
V|y⟩|e⟩ = |y⟩ |e⟩ n <= y
where y is the target register, e is the exponent register, x is the base
and n is the modulus. Consequently,
V|y⟩|e⟩ = (U**e|y)|e⟩
where U is the unitary defined as
U|y⟩ = |y * x mod n⟩ 0 <= y < n
U|y⟩ = |y⟩ n <= y
"""
def __init__(
self,
target: Sequence[cirq.Qid],
exponent: Union[int, Sequence[cirq.Qid]],
base: int,
modulus: int
) -> None:
if len(target) < modulus.bit_length():
raise ValueError(f'Register with {len(target)} qubits is too small '
f'for modulus {modulus}')
self.target = target
self.exponent = exponent
self.base = base
self.modulus = modulus
def registers(self) -> Sequence[Union[int, Sequence[cirq.Qid]]]:
return self.target, self.exponent, self.base, self.modulus
def with_registers(
self,
*new_registers: Union[int, Sequence['cirq.Qid']],
) -> cirq.ArithmeticOperation:
if len(new_registers) != 4:
raise ValueError(f'Expected 4 registers (target, exponent, base, '
f'modulus), but got {len(new_registers)}')
target, exponent, base, modulus = new_registers
if not isinstance(target, Sequence):
raise ValueError(
f'Target must be a qubit register, got {type(target)}')
if not isinstance(base, int):
raise ValueError(
f'Base must be a classical constant, got {type(base)}')
if not isinstance(modulus, int):
raise ValueError(
f'Modulus must be a classical constant, got {type(modulus)}')
return ModularExp(target, exponent, base, modulus)
def apply(self, *register_values: int) -> int:
assert len(register_values) == 4
target, exponent, base, modulus = register_values
if target >= modulus:
return target
return (target * base**exponent) % modulus
def _circuit_diagram_info_(
self,
args: cirq.CircuitDiagramInfoArgs,
) -> cirq.CircuitDiagramInfo:
assert args.known_qubits is not None
wire_symbols: List[str] = []
t, e = 0, 0
for qubit in args.known_qubits:
if qubit in self.target:
if t == 0:
if isinstance(self.exponent, Sequence):
e_str = 'e'
else:
e_str = str(self.exponent)
wire_symbols.append(
f'ModularExp(t*{self.base}**{e_str} % {self.modulus})')
else:
wire_symbols.append('t' + str(t))
t += 1
if isinstance(self.exponent, Sequence) and qubit in self.exponent:
wire_symbols.append('e' + str(e))
e += 1
return cirq.CircuitDiagramInfo(wire_symbols=tuple(wire_symbols))
def make_order_finding_circuit(x: int, n: int) -> cirq.Circuit:
"""Returns quantum circuit which computes the order of x modulo n.
The circuit uses Quantum Phase Estimation to compute an eigenvalue of
the unitary
U|y⟩ = |y * x mod n⟩ 0 <= y < n
U|y⟩ = |y⟩ n <= y
Args:
x: positive integer whose order modulo n is to be found
n: modulus relative to which the order of x is to be found
Returns:
Quantum circuit for finding the order of x modulo n
"""
L = n.bit_length()
target = cirq.LineQubit.range(L)
exponent = cirq.LineQubit.range(L, 3 * L + 3)
return cirq.Circuit(
cirq.X(target[L - 1]),
cirq.H.on_each(*exponent),
ModularExp(target, exponent, x, n),
cirq.qft(*exponent, inverse=True),
cirq.measure(*exponent, key='exponent'),
)
def process_measurement(result: cirq.Result, x: int, n: int) -> Optional[int]:
"""Interprets the output of the order finding circuit.
Specifically, it determines s/r such that exp(2πis/r) is an eigenvalue
of the unitary
U|y⟩ = |xy mod n⟩ 0 <= y < n
U|y⟩ = |y⟩ n <= y
then computes r (by continued fractions) if possible, and returns it.
Args:
result: result obtained by sampling the output of the
circuit built by make_order_finding_circuit
Returns:
r, the order of x modulo n or None.
"""
print("process measurement")
# Read the output integer of the exponent register.
exponent_as_integer = result.data["exponent"][0]
exponent_num_bits = result.measurements["exponent"].shape[1]
eigenphase = float(exponent_as_integer / 2**exponent_num_bits)
# Run the continued fractions algorithm to determine f = s / r.
f = fractions.Fraction.from_float(eigenphase).limit_denominator(n)
# If the numerator is zero, the order finder failed.
if f.numerator == 0:
return None
# Else, return the denominator if it is valid.
r = f.denominator
if x**r % n != 1:
return None
return r
def quantum_order_finder(x: int, n: int) -> Optional[int]:
"""Computes smallest positive r such that x**r mod n == 1.
Args:
x: integer whose order is to be computed, must be greater than one
and belong to the multiplicative group of integers modulo n (which
consists of positive integers relatively prime to n),
n: modulus of the multiplicative group.
"""
print("quantum order finder")
# Check that the integer x is a valid element of the multiplicative group
# modulo n.
if x < 2 or n <= x or math.gcd(x, n) > 1:
raise ValueError(f'Invalid x={x} for modulus n={n}.')
# Create the order finding circuit.
circuit = make_order_finding_circuit(x, n)
print(circuit)
# Sample from the order finding circuit.
measurement = cirq.sample(circuit)
# Return the processed measurement result.
return process_measurement(measurement, x, n)
def find_factor_of_prime_power(n: int) -> Optional[int]:
"""Returns non-trivial factor of n if n is a prime power, else None."""
print("factor of prime power")
for k in range(2, math.floor(math.log2(n)) + 1):
c = math.pow(n, 1 / k)
c1 = math.floor(c)
if c1**k == n:
return c1
c2 = math.ceil(c)
if c2**k == n:
return c2
return None
def find_factor(
n: int,
order_finder: Callable[[int, int], Optional[int]] = quantum_order_finder,
max_attempts: int = 30
) -> Optional[int]:
"""Returns a non-trivial factor of composite integer n.
Args:
n: Integer to factor.
order_finder: Function for finding the order of elements of the
multiplicative group of integers modulo n.
max_attempts: number of random x's to try, also an upper limit
on the number of order_finder invocations.
Returns:
Non-trivial factor of n or None if no such factor was found.
Factor k of n is trivial if it is 1 or n.
"""
# If the number is prime, there are no non-trivial factors.
if sympy.isprime(n):
print("n is prime!")
return None
# If the number is even, two is a non-trivial factor.
#if n % 2 == 0:
# return 2
# If n is a prime power, we can find a non-trivial factor efficiently.
#c = find_factor_of_prime_power(n)
#if c is not None:
# return c
print("find factor")
for _ in range(max_attempts):
print("loop")
# Choose a random number between 2 and n - 1.
x = random.randint(2, n - 1)
print("x " + str(x))
# Most likely x and n will be relatively prime.
c = math.gcd(x, n)
print("c " + str(c))
# If x and n are not relatively prime, we got lucky and found
# a non-trivial factor.
if 1 < c < n:
return c
# Compute the order r of x modulo n using the order finder.
r = order_finder(x, n)
print(r)
# If the order finder failed, try again.
if r is None:
continue
# If the order r is even, try again.
if r % 2 != 0:
continue
# Compute the non-trivial factor.
y = x**(r // 2) % n
assert 1 < y < n
c = math.gcd(y - 1, n)
if 1 < c < n:
return c
print(f"Failed to find a non-trivial factor in {max_attempts} attempts.")
return None
find_factor(15)
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### added h gate ###
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
### added x gate ###
qc.x(qubit)
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### added y gate ###
qc.y(0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### added y gate ###
qc.cx(0, 1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
### added h gate ###
qc.h(0)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
### added x gate ###
qc.x(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### added z gate ###
qc.z(1)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### removed cx gate ###
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
### removed x gate ###
pass
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### removed h gate ###
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
### removed z gate ###
pass
return qc
def decode_message(qc):
### removed cx gate ###
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### removed cx gate ###
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### removed h gate ###
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### replaced cx gate ###
qc.cy(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
### replaced z gate ###
qc.x(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### replaced x gate ###
qc.x(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
### replaced x gate ###
qc.x(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### replaced x gate ###
qc.x(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
### replaced x gate ###
qc.z(qubit)
if msg[0] == "1":
### replaced z gate ###
qc.x(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
import numpy as np
from qiskit import QuantumCircuit, Aer, execute
from qiskit.circuit.library import CCXGate, CXGate, CSwapGate, HGate, SwapGate, CPhaseGate
from math import gcd
from numpy.random import randint
from fractions import Fraction
from math import gcd # greatest common divisor
N = 15
def c_amod15(a, power):
"""Controlled multiplication by a mod 15"""
if a not in [2,7,8,11,13]:
raise ValueError("'a' must be 2,7,8,11 or 13")
U = QuantumCircuit(4)
for iteration in range(power):
if a in [2,13]:
U.swap(0,1)
U.swap(1,2)
U.swap(2,3)
if a in [7,8]:
U.swap(2,3)
U.swap(1,2)
U.swap(0,1)
if a == 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 = "%i^%i mod 15" % (a, power)
c_U = U.control()
return c_U
def qft_dagger(n):
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
def qpe_amod15(a):
n_count = 8
qc = QuantumCircuit(4+n_count, n_count)
for q in range(n_count):
qc.h(q) # Initialize counting qubits in state |+>
qc.x(3+n_count) # And auxiliary register in state |1>
for q in range(n_count): # Do controlled-U operations
qc.append(c_amod15(a, 2**q),
[q] + [i+n_count for i in range(4)])
qc.append(qft_dagger(n_count), range(n_count)) # Do inverse-QFT
qc.measure(range(n_count), range(n_count))
# Simulate Results
aer_sim = Aer.get_backend('aer_simulator')
# Setting memory=True below allows us to see a list of each sequential reading
backend = Aer.get_backend('aer_simulator')
job = execute(qc, backend, shots=1, memory=True)
readings = job.result().get_memory()
phase = int(readings[0],2)/(2**n_count)
return phase
def find_factor(coprime):
a = coprime
factor_found = False
attempt = 0
factors = []
for i in range(30):
attempt += 1
print("\nAttempt %i:" % attempt)
phase = qpe_amod15(a) # Phase = s/r
frac = Fraction(phase).limit_denominator(N) # Denominator should (hopefully!) tell us r
r = frac.denominator
print("Result: r = %i" % r)
if phase != 0:
# Guesses for factors are gcd(x^{r/2} ±1 , 15)
guesses = [gcd(a**(r//2)-1, N), gcd(a**(r//2)+1, N)]
print("Guessed Factors: %i and %i" % (guesses[0], guesses[1]))
for guess in guesses:
if guess not in [1,N] and (N % guess) == 0: # Check to see if guess is a factor
print("*** Non-trivial factor found: %i ***" % guess)
factors += [guess]
return factors
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
import unittest
import hypothesis.strategies as st
from hypothesis import given, settings, note
import matplotlib.pyplot as plt
import numpy as np
import math
from qiskit import QuantumCircuit, Aer, transpile, assemble, execute
from qiskit.visualization import plot_histogram
from qiskit.circuit.library import CCXGate, CXGate, CSwapGate, HGate, SwapGate, CPhaseGate
from numpy.random import randint
import pandas as pd
from fractions import Fraction
from math import gcd # greatest common divisor
"""Function to compute the elements of Z_n."""
def multiplicative_group(n):
"""Returns the multiplicative group modulo n.
Args:
n: Modulus of the multiplicative group.
"""
print("multiplicative group")
assert n > 1
group = [1]
for x in range(2, n):
if math.gcd(x, n) == 1:
group.append(x)
return group
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
qft_dagger(8)
def general_modular_exp(a, N, power):
mult_group = multiplicative_group(N)
if a not in mult_group:
raise ValueError("'a' must be in " + str(mult_group))
print(mult_group)
general_modular_exp(7, 15, 2)
def VBE_Adder(qubit_size):
#outputs a + b
#inverse outputs b - a (but in two's complement)
#move to carry
qc = QuantumCircuit(3*qubit_size + 1)
for i in range(qubit_size-1):
qc.ccx(i, i+qubit_size, 2+i+(2*qubit_size))
#toffoli to second register
qc.ccx(qubit_size-1, (2*qubit_size)-1, 2*qubit_size)
#add a to b
for i in range(qubit_size):
qc.cx(i, i+qubit_size)
#second register carry and last b
for i in range(qubit_size-1):
qc.ccx(i+qubit_size, 1+i+(2*qubit_size), 2+i+(2*qubit_size))
qc.ccx((2*qubit_size)-1, 3*qubit_size, 2*qubit_size)
qc.cx(3*qubit_size, (2*qubit_size)-1)
#adder overflow
for i in range(qubit_size-1):
qc.ccx((2*qubit_size) - 2 - i, (3*qubit_size) - i - 1, (3*qubit_size) - i)
qc.cx((qubit_size) - 2 - i, (2*qubit_size) - 2 - i)
qc.ccx((qubit_size) - 2 - i, (2*qubit_size) - 2 - i, (3*qubit_size) - i)
qc.cx((qubit_size) - 2 - i, (2*qubit_size) - 2 - i)
qc.cx((3*qubit_size) - i - 1, (2*qubit_size) - 2 - i)
#print(qc.draw(output='text'))
qc.name = "VBE ADDER"
#qc.to_gate()
return qc
#print(VBE_Adder(4))
def Modular_adder(qubit_size, N):
binN = bin(N)[2:].zfill(qubit_size)[::-1]
#move to carry
qc = QuantumCircuit(4*qubit_size + 2)
qc.append(VBE_Adder(qubit_size), [i for i in range(3*qubit_size+1)])
for i in range(qubit_size):
qc.swap(i, i + 1 + 3*qubit_size)
qc.append(VBE_Adder(qubit_size).inverse(), [i for i in range(3*qubit_size+1)])
qc.x(2*qubit_size)
qc.cx(2*qubit_size, 4*qubit_size+1)
qc.x(2*qubit_size)
for i in range(qubit_size):
if binN[i] == "1":
qc.cx(4*qubit_size + 1, i)
qc.append(VBE_Adder(qubit_size), [i for i in range(3*qubit_size+1)])
for i in range(qubit_size):
if binN[i] == "1":
qc.cx(4*qubit_size + 1, i)
for i in range(qubit_size):
qc.swap(i, i + 1 + 3*qubit_size)
qc.append(VBE_Adder(qubit_size).inverse(), [i for i in range(3*qubit_size+1)])
qc.cx(2*qubit_size, 4*qubit_size+1)
qc.append(VBE_Adder(qubit_size), [i for i in range(3*qubit_size+1)])
qc.name = "MODULAR ADDER"
return qc
Modular_adder(4,11)
from IPython.core.display import display, HTML
display(HTML("<style>.container { width:60% !important; }</style>"))
size = 4
N = 7
qc = QuantumCircuit(4*size + 2)
# a = 3,2,1,0
#qc.x(3)
qc.x(2)
qc.x(1)
qc.x(0)
# b = 8,7,6,5,4
#qc.x(7)
qc.x(6)
qc.x(5)
qc.x(4)
# carry = 12,11,10,9
# modulus N = 16,15,14,13
binN = bin(N)[2:].zfill(size)[::-1]
for i in range(size):
if binN[i] == "1":
qc.x(3*size + 1 + i)
# temporary carry = 17
print(qc)
qc.measure_all()
qc.append(Modular_adder(size,N), [i for i in range(4*size+2)])
qc.measure_all()
backend = Aer.get_backend('aer_simulator')
job = execute(qc, backend, shots=1, memory=True)
readings = job.result().get_memory()
second_set = readings[0][0:4*size+2]
first_set = readings[0][(4*size)+3:(8*size)+6]
print(readings)
print(first_set)
print(second_set)
print('a = ' + str(first_set[3*size + 2: 4*size + 2]))
print('b = ' + str(first_set[2*size + 1: 3*size + 2]))
print('b out = ' + str(second_set[2*size + 1: 3*size + 2]))
#print('carry = ' + str(second_set[0:size]))
def Modular_multiplier(qubit_size, N, a):
qc = QuantumCircuit(5*qubit_size + 3)
for i in range(qubit_size):
mod = bin(a*(2**i) % N)[2:].zfill(qubit_size)[::-1]
for j in range(qubit_size):
if mod[j] == "1":
qc.ccx(0, i+1, qubit_size + 1 + j)
#print([qubit_size + i + 1 for i in range(4*qubit_size+2)])
qc.append(Modular_adder(qubit_size, N), [qubit_size + i + 1 for i in range(4*qubit_size+2)])
#can just repeat the above method, but this looks symmetric
#the circuit diagram is more intuitive
for j in range(qubit_size):
if mod[::-1][j] == "1":
qc.ccx(0, i+1, 2*qubit_size - j)
#set x if control is false
qc.x(0)
for i in range(qubit_size):
qc.ccx(0,i+1,2*qubit_size + 1 + i)
qc.x(0)
qc.name = "MODULAR MULTIPLIER " + str(a) + "x mod " + str(N)
#print(qc.draw(output='text'))
return qc
Modular_multiplier(4, 15, 13)
size = 2
N = 2
a = 1
qc = QuantumCircuit(5*size + 3)
#control qubit
qc.x(0)
# x = 4,3,2,1
#qc.x(4)
#qc.x(3)
#qc.x(2)
#qc.x(1)
# N = 21,20,19,18
binN = bin(N)[2:].zfill(size)[::-1]
for i in range(size):
if binN[i] == "1":
qc.x(4*size + 2 + i)
# temporary carry = 17
#print(qc)
qc.measure_all()
qc.append(Modular_multiplier(size, N, a), [i for i in range(5*size+3)])
#print(qc)
qc.measure_all()
backend = Aer.get_backend('aer_simulator')
job = execute(qc, backend, shots=1, memory=True)
readings = job.result().get_memory()
second_set = readings[0][0:5*size+3]
first_set = readings[0][(5*size)+4:(10*size)+8]
print(readings)
print(first_set)
print(second_set)
print('x = ' + str(first_set[4*size + 2: 5*size + 2]))
print('b = ' + str(first_set[2*size + 1: 3*size + 2]))
print('b out = ' + str(second_set[2*size + 1: 3*size + 2]))
#print('carry = ' + str(second_set[0:size]))
def Modular_exponentiation(qubit_size, N, a):
qc = QuantumCircuit(6*qubit_size + 3)
#need to set x to 1
qc.x(qubit_size+1)
for i in range(qubit_size):
#for i in range(1):
qc.cx(i,qubit_size)
print([i + qubit_size for i in range(5*qubit_size+3)])
qc.append(Modular_multiplier(qubit_size, N, a**(2**i)%N), [i + qubit_size for i in range(5*qubit_size+3)])
for j in range(qubit_size):
qc.swap(qubit_size+1+j, 3*qubit_size+1+j)
#we dont use A for this multiplier because we need the modular multiplicative inverse
#print(a**(2**i)%N)
#print(pow(a**(2**i)%N, -1, N))
qc.append(Modular_multiplier(qubit_size, N, pow(a**(2**i)%N, -1, N)).inverse(), [i + qubit_size for i in range(5*qubit_size+3)])
qc.cx(i,qubit_size)
qc.name = "MODULAR EXPONENTIATION"
#print(qc.draw(output='text'))
return qc
Modular_exponentiation(3, 7, 3)
qubit_size = 2
N = 3
a = 1
qc = QuantumCircuit(6*qubit_size + 3)
# x = 3,2,1,0
#qc.x(3)
qc.x(2)
#qc.x(1)
#qc.x(0)
# N = 21,20,19,18
binN = bin(N)[2:].zfill(qubit_size)[::-1]
print(binN)
for i in range(qubit_size):
if binN[i] == "1":
qc.x(5*qubit_size + 2 + i)
#print(qc)
qc.measure_all()
qc.append(Modular_exponentiation(qubit_size, N, a), [i for i in range(6*qubit_size+3)])
qc.measure_all()
print(qc)
backend = Aer.get_backend('aer_simulator')
job = execute(qc, backend, shots=1, memory=True)
readings = job.result().get_memory()[0].split(' ')
second_set = readings[0]
first_set = readings[1]
print(first_set)
print(second_set)
first_set_exp = first_set[(5 * qubit_size) + 3 : (6 * qubit_size) + 3]
first_set_x = first_set[(4 * qubit_size) + 2 : (5 * qubit_size) + 2]
first_set_a = first_set[(3 * qubit_size) + 2 : (4 * qubit_size) + 2]
first_set_b = first_set[(2 * qubit_size) + 1 : (3 * qubit_size) + 2]
first_set_N = first_set[qubit_size + 1 : (2 * qubit_size) + 1]
second_set_exp = second_set[(5 * qubit_size) + 3 : (6 * qubit_size) + 3]
second_set_x = second_set[(4 * qubit_size) + 2 : (5 * qubit_size) + 2]
second_set_a = second_set[(3 * qubit_size) + 2 : (4 * qubit_size) + 2]
second_set_b = second_set[(2 * qubit_size) + 1 : (3 * qubit_size) + 2]
second_set_N = second_set[qubit_size + 1 : (2 * qubit_size) + 1]
print("A = " + str(a))
print("exps 1 -> 2 = " + str(first_set_exp) + " -> " + str(second_set_exp))
print("xs 1 -> 2 = " + str(first_set_x) + " -> " + str(second_set_x))
print("as 1 -> 2 = " + str(first_set_a) + " -> " + str(second_set_a))
print("bs 1 -> 2 = " + str(first_set_b) + " -> " + str(second_set_b))
print("Ns 1 -> 2 = " + str(first_set_N) + " -> " + str(second_set_N))
#print('carry = ' + str(second_set[0:size]))
def run_shors(qubit_size, N, a, run_amt):
qc = QuantumCircuit(6*qubit_size + 3, qubit_size)
# N = 21,20,19,18
binN = bin(N)[2:].zfill(qubit_size)[::-1]
for i in range(qubit_size):
qc.h(i)
for i in range(qubit_size):
if binN[i] == "1":
qc.x(5*qubit_size + 2 + i)
qc.append(Modular_exponentiation(qubit_size, N, a), [i for i in range(6*qubit_size+3)])
qc.append(qft_dagger(qubit_size), [i for i in range(qubit_size)])
qc.measure([i for i in range(qubit_size)],[i for i in range(qubit_size)])
print(qc)
backend = Aer.get_backend('aer_simulator')
job = execute(qc, backend, shots=run_amt, memory=True)
return(job.result().get_memory())
print(run_shors(8,14,9,20))
%timeit run_shors(10,26,7,20)
# for loop at the bootom from qiskit textbook for postpro
# https://qiskit.org/textbook/ch-algorithms/shor.html#:~:text=if%20phase%20!%3D%200,guess)%0A%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20factor_found%20%3D%20True
def shors_with_postpro(N, a, tries):
factors = []
if not a < N:
raise ValueError("a(%i) must be less than N(%i)"%(a,N))
common_denom = gcd(a,N)
if not common_denom == 1:
raise ValueError("a(%i) and N(%i) must be coprime but they have a gcd of (%i)"%(a, N, common_denom))
length_message = len(bin(N)[2:])*2
if length_message > 8:
print(f"The length of the number you are trying to factor is large ({length_message}), it may fail or take a long time")
res = run_shors(len(bin(N)[2:])*2, N, a, tries)
for result in res:
phase = (int(result,2)/(2**length_message))
frac = Fraction(phase).limit_denominator(N)
r = frac.denominator
if phase != 0:
guesses = [gcd(a**(r//2)-1, N), gcd(a**(r//2)+1, N)]
for guess in guesses:
if guess not in [1,N] and (N % guess) == 0:
factors += [guess]
return factors
shors_with_postpro(30, 7, 20)
def twos_comp_to_int(binNum):
binNum = int(binNum,2) ^ ((2**len(binNum))-1)
binNum = bin(binNum + 1)
return -int(binNum,2)
@st.composite
def draw_pair_of_ints(draw):
size = draw(st.integers(min_value=1, max_value=6))
a = draw(st.integers(min_value=0, max_value=(2**size)-1))
b = draw(st.integers(min_value=0, max_value=(2**size)-1))
return(a, b, size)
@st.composite
def draw_shors_variables(draw):
size = draw(st.integers(min_value=2, max_value=5))
mod = draw(st.integers(min_value=3, max_value=(2**size)-1))
a = draw(st.integers(min_value=2, max_value=mod-1))
return(a, mod, size)
@st.composite
def draw_pair_of_ints_and_mod(draw):
size = draw(st.integers(min_value=2, max_value=3))
mod = draw(st.integers(min_value=2, max_value=(2**size)-1))
a = draw(st.integers(min_value=0, max_value=mod-1))
b = draw(st.integers(min_value=0, max_value=mod-1))
return(a, b, size, mod)
@given(draw_shors_variables())
@settings(deadline=None)
def test_shors_with_postpro(vals):
a = vals[0]
N = vals[1]
size = vals[2]
for i in range(size):
try:
pow(a**(2**i)%N, -1, N)
except ValueError:
assert(not(math.gcd(a,N) == 1))
if math.gcd(a,N) == 1:
factors = shors_with_postpro(N, a, 20)
for factor in factors:
print(f"N {N}, factor {factor}")
assert(N % factor == 0)
@given(draw_pair_of_ints_and_mod())
@settings(deadline=None)
def test_modular_exponentiation(vals):
a = vals[0]
x = vals[1]
size = vals[2]
N = vals[3]
for i in range(size):
try:
pow(a**(2**i)%N, -1, N)
except ValueError:
assert(not(math.gcd(a,N) == 1))
if math.gcd(a,N) == 1:
qc = QuantumCircuit(6*size + 3)
binX = bin(x)[2:].zfill(size)[::-1]
binN = bin(N)[2:].zfill(size)[::-1]
print("size " + str(size))
print("a " + str(a))
print("x " + str(x))
print("N " + str(N))
print("\n")
# x = 3,2,1,0
for i in range(size):
if binX[i] == "1":
qc.x(i)
for i in range(size):
if binN[i] == "1":
qc.x(5*size + 2 + i)
#print(qc)
qc.measure_all()
qc.append(Modular_exponentiation(size, N, a), [i for i in range(6*size+3)])
qc.measure_all()
backend = Aer.get_backend('aer_simulator')
job = execute(qc, backend, shots=1, memory=True)
readings = job.result().get_memory()[0].split(' ')
second_set = readings[0]
first_set = readings[1]
print(first_set)
print(second_set)
first_set_exp = first_set[(5 * size) + 3 : (6 * size) + 3]
first_set_x = first_set[(4 * size) + 2 : (5 * size) + 2]
first_set_a = first_set[(3 * size) + 2 : (4 * size) + 2]
first_set_b = first_set[(2 * size) + 1 : (3 * size) + 2]
first_set_N = first_set[size + 1 : (2 * size) + 1]
second_set_exp = second_set[(5 * size) + 3 : (6 * size) + 3]
second_set_x = second_set[(4 * size) + 2 : (5 * size) + 2]
second_set_a = second_set[(3 * size) + 2 : (4 * size) + 2]
second_set_b = second_set[(2 * size) + 1 : (3 * size) + 2]
second_set_N = second_set[size + 1 : (2 * size) + 1]
print("A = " + str(a))
print("exps 1 -> 2 = " + str(first_set_exp) + " -> " + str(second_set_exp))
print("xs 1 -> 2 = " + str(first_set_x) + " -> " + str(second_set_x))
print("as 1 -> 2 = " + str(first_set_a) + " -> " + str(second_set_a))
print("bs 1 -> 2 = " + str(first_set_b) + " -> " + str(second_set_b))
print("Ns 1 -> 2 = " + str(first_set_N) + " -> " + str(second_set_N))
print(a)
print(x)
print(N)
print('\n\n')
assert((a ** x) % N == int(second_set_x, 2))
@given(draw_pair_of_ints_and_mod(), st.booleans())
@settings(deadline=None)
def test_modular_multiplier_then_inverse_returns_original_values(vals, control):
a = vals[0]
x = vals[1]
size = vals[2]
N = vals[3]
qc = QuantumCircuit(5*size + 3)
binX = bin(x)[2:].zfill(size)[::-1]
binN = bin(N)[2:].zfill(size)[::-1]
print("size " + str(size))
print("a " + str(a))
print("x " + str(x))
print("N " + str(N))
print("control " + str(control))
print("\n")
#control qubit
if control == True:
qc.x(0)
# x = 3,2,1,0
for i in range(size):
if binX[i] == "1":
qc.x(i+1)
for i in range(size):
if binN[i] == "1":
qc.x(4*size + 2 + i)
print(qc)
qc.measure_all()
qc.append(Modular_multiplier(size, N, a), [i for i in range(5*size+3)])
qc.append(Modular_multiplier(size, N, a).inverse(), [i for i in range(5*size+3)])
qc.measure_all()
backend = Aer.get_backend('aer_simulator')
job = execute(qc, backend, shots=1, memory=True)
readings = job.result().get_memory()
second_set = readings[0][0:5*size+3]
first_set = readings[0][(5*size)+4:(10*size)+7]
print("readings " + str(readings))
print("first set " + str(first_set))
print("second set " + str(second_set))
assert(first_set == second_set)
@given(draw_pair_of_ints_and_mod(), st.booleans())
@settings(deadline=None)
def test_modular_multiplier(vals, control):
a = vals[0]
x = vals[1]
size = vals[2]
N = vals[3]
qc = QuantumCircuit(5*size + 3)
binX = bin(x)[2:].zfill(size)[::-1]
binN = bin(N)[2:].zfill(size)[::-1]
#control qubit
if control == True:
qc.x(0)
# x = 3,2,1,0
for i in range(size):
if binX[i] == "1":
qc.x(i+1)
for i in range(size):
if binN[i] == "1":
qc.x(4*size + 2 + i)
qc.measure_all()
qc.append(Modular_multiplier(size, N, a), [i for i in range(5*size+3)])
qc.measure_all()
backend = Aer.get_backend('aer_simulator')
job = execute(qc, backend, shots=1, memory=True)
readings = job.result().get_memory()
second_set = readings[0][0:5*size+3]
first_set = readings[0][(5*size)+3:(10*size)+7]
print("readings " + str(readings))
print("first set " + str(first_set))
print("x " + str(first_set[4*size + 3: 5*size + 3]))
x = int(first_set[4*size + 3: 5*size + 3], 2)
print("b " + str(first_set[2*size + 1: 3*size + 2]))
b = int(first_set[2*size + 1: 3*size + 2], 2)
print("bout " + str(second_set[2*size + 1: 3*size + 2]))
bout = int(second_set[2*size + 1: 3*size + 2], 2)
print("control " + str(control))
print("N " + str(N))
print('b = ' + str(b))
print('a = ' + str(a))
print('x = ' + str(x))
print('b out = ' + str(bout))
print('\n\n')
if (control == False):
assert(bout == x)
else:
assert((a * x) % N == bout)
#assert(carry == 0)
@given(draw_pair_of_ints_and_mod())
@settings(deadline=None)
def test_modular_adder(vals):
a = vals[0]
b = vals[1]
size = vals[2]
N = vals[3]
qc = QuantumCircuit(4*size + 2)
binA = bin(a)[2:].zfill(size)[::-1]
binB = bin(b)[2:].zfill(size)[::-1]
binN = bin(N)[2:].zfill(size)[::-1]
print("size " + str(size))
print("a " + str(a))
print("b " + str(b))
print("N " + str(N))
print("\n")
# a = 3,2,1,0
for i in range(size):
if binA[i] == "1":
qc.x(i)
# b = 8,7,6,5,4
for i in range(size):
if binB[i] == "1":
qc.x(i+size)
# carry = 12,11,10,9
# modulus N = 16,15,14,13
for i in range(size):
if binN[i] == "1":
qc.x(3*size + 1 + i)
# temporary carry = 17
#print(qc)
qc.measure_all()
qc.append(Modular_adder(size,N), [i for i in range(4*size+2)])
qc.measure_all()
backend = Aer.get_backend('aer_simulator')
job = execute(qc, backend, shots=1, memory=True)
readings = job.result().get_memory()
second_set = readings[0][0:4*size+2]
first_set = readings[0][(4*size)+3:(8*size)+6]
print(readings)
a = int(first_set[3*size + 2: 4*size + 2], 2)
b = int(first_set[2*size + 1: 3*size + 2], 2)
bout = int(second_set[2*size + 1: 3*size + 2], 2)
print('a = ' + str(a))
print('b = ' + str(b))
print('b out = ' + str(bout))
print('\n\n')
assert((a+b)%N == bout)
#assert(carry == 0)
@given(draw_pair_of_ints())
@settings(deadline=None)
def test_add_using_VBE_Adder(vals):
a = vals[0]
b = vals[1]
size = vals[2]
qc = QuantumCircuit(3*size + 1)
binA = bin(a)[2:].zfill(size)[::-1]
binB = bin(b)[2:].zfill(size)[::-1]
print("size " + str(size))
print("a " + str(a))
print(binA)
print("b " + str(b))
print(binB)
# a = 3,2,1,0
for i in range(size):
if binA[i] == "1":
qc.x(i)
# b = 8,7,6,5,4
for i in range(size):
if binB[i] == "1":
qc.x(i+size)
# carry = 12,11,10,9
qc.measure_all()
qc.append(VBE_Adder(size), [i for i in range(3*size+1)])
qc.measure_all()
backend = Aer.get_backend('aer_simulator')
job = execute(qc, backend, shots=1, memory=True)
readings = job.result().get_memory()
second_set = readings[0][0:3*size+1]
first_set = readings[0][(3*size)+2:(6*size)+4]
print(readings)
a = int(first_set[2*size + 1: 3*size + 1],2)
b = int(first_set[size: 2*size + 1],2)
bout = int(second_set[size: 2*size + 1],2)
carry = int(second_set[0: size],2)
print('a = ' + str(a))
print('b = ' + str(b))
print('b out = ' + str(bout))
print('\n\n')
assert(a+b == bout)
assert(carry == 0)
@given(draw_pair_of_ints())
@settings(deadline=None)
def test_subtract_using_VBE_Adder_inverse(vals):
a = vals[0]
b = vals[1]
size = vals[2]
qc = QuantumCircuit(3*size + 1)
binA = bin(a)[2:].zfill(size)[::-1]
binB = bin(b)[2:].zfill(size)[::-1]
print("size " + str(size))
print("a " + str(a))
print(binA)
print("b " + str(b))
print(binB)
# a = 3,2,1,0
for i in range(size):
if binA[i] == "1":
qc.x(i)
# b = 8,7,6,5,4
for i in range(size):
if binB[i] == "1":
qc.x(i+size)
# carry = 12,11,10,9
qc.measure_all()
qc.append(VBE_Adder(size).inverse(), [i for i in range(3*size+1)])
qc.measure_all()
backend = Aer.get_backend('aer_simulator')
job = execute(qc, backend, shots=1, memory=True)
readings = job.result().get_memory()
second_set = readings[0][0:3*size+1]
first_set = readings[0][(3*size)+2:(6*size)+4]
print(readings)
a = int(first_set[2*size + 1: 3*size + 1],2)
b = int(first_set[size: 2*size + 1],2)
if (b < a):
bout = twos_comp_to_int(second_set[size: 2*size + 1])
else:
bout = int(second_set[size: 2*size + 1],2)
carry = int(second_set[0: size],2)
print('a = ' + str(a))
print('b = ' + str(b))
print('b out = ' + str(bout))
print('\n\n')
assert(b-a == bout)
assert(carry == 0)
if __name__ == '__main__':
#test_shors_with_postpro()
#test_modular_exponentiation()
#test_modular_multiplier_then_inverse_returns_original_values()
test_modular_multiplier()
#test_modular_adder()
#test_add_using_VBE_Adder()
#test_subtract_using_VBE_Adder_inverse()
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
import unittest
import hypothesis.strategies as st
from hypothesis import given, settings, note
import matplotlib.pyplot as plt
import numpy as np
import math
from qiskit import QuantumCircuit, Aer, transpile, assemble, execute
from qiskit.visualization import plot_histogram
from qiskit.circuit.library import CCXGate, CXGate, CSwapGate, HGate, SwapGate, CPhaseGate
from math import gcd
from numpy.random import randint
import pandas as pd
from fractions import Fraction
from math import gcd # greatest common divisor
# Specify variables
n_count = 8 # number of counting qubits
a = 7
N = 15
def c_amod15(a, power):
"""Controlled multiplication by a mod 15"""
if a not in [2,7,8,11,13]:
raise ValueError("'a' must be 2,7,8,11 or 13")
U = QuantumCircuit(4)
for iteration in range(power):
if a in [2,13]:
U.swap(0,1)
U.swap(1,2)
U.swap(2,3)
if a in [7,8]:
U.swap(2,3)
U.swap(1,2)
U.swap(0,1)
if a == 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 = "%i^%i mod 15" % (a, power)
c_U = U.control()
return c_U
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
def qpe_amod15(a):
n_count = 8
qc = QuantumCircuit(4+n_count, n_count)
for q in range(n_count):
qc.h(q) # Initialize counting qubits in state |+>
qc.x(3+n_count) # And auxiliary register in state |1>
for q in range(n_count): # Do controlled-U operations
qc.append(c_amod15(a, 2**q),
[q] + [i+n_count for i in range(4)])
qc.append(qft_dagger(n_count), range(n_count)) # Do inverse-QFT
qc.measure(range(n_count), range(n_count))
# Simulate Results
aer_sim = Aer.get_backend('aer_simulator')
# Setting memory=True below allows us to see a list of each sequential reading
backend = Aer.get_backend('aer_simulator')
job = execute(qc, backend, shots=1, memory=True)
readings = job.result().get_memory()
phase = int(readings[0],2)/(2**n_count)
print(qc)
return phase
phase = qpe_amod15(a) # Phase = s/r
Fraction(phase).limit_denominator(15)
frac = Fraction(phase).limit_denominator(15)
s, r = frac.numerator, frac.denominator
print(r)
guesses = [gcd(a**(r//2)-1, N), gcd(a**(r//2)+1, N)]
print(guesses)
def find_factor(coprime):
a = coprime
attempt = 0
factors = []
for i in range(100):
attempt += 1
#print("\nAttempt %i:" % attempt)
phase = qpe_amod15(a) # Phase = s/r
frac = Fraction(phase).limit_denominator(N) # Denominator should (hopefully!) tell us r
r = frac.denominator
#print("Result: r = %i" % r)
if phase != 0:
# Guesses for factors are gcd(x^{r/2} ±1 , 15)
guesses = [gcd(a**(r//2)-1, N), gcd(a**(r//2)+1, N)]
#print("Guessed Factors: %i and %i" % (guesses[0], guesses[1]))
for guess in guesses:
if guess not in [1,N] and (N % guess) == 0: # Check to see if guess is a factor
# print("*** Non-trivial factor found: %i ***" % guess)
factors += [guess]
return factors
find_factor(7)
@st.composite
def draw_coprime_int(draw):
return draw(st.sampled_from([2,7,8,11,13]))
@st.composite
def draw_non_coprime_int(draw):
return draw(st.sampled_from([1,3,4,5,6,9,10,12,14,15]))
# @given(draw_coprime_int(), st.integers(min_value=0, max_value=7))
# @settings(deadline=None)
# def test_modular_exponentiation_uses_CSWap_CCX_CX_gates(coprime_int, power):
# note("coprime integer %i and power %i"%(coprime_int, power))
# circuit = (c_amod15(coprime_int, power).definition)
# note(circuit)
# for gate in circuit:
# note(type(gate[0]))
# assert(isinstance(gate[0], CSwapGate)
# or isinstance(gate[0], CCXGate)
# or isinstance(gate[0], CXGate))
@given(draw_non_coprime_int(), st.integers(min_value=0, max_value=7))
@settings(deadline=None)
def test_modular_exponentiation_non_coprime_int_throws_exception(non_coprime_int, power):
note("non coprime integer %i and power %i"%(non_coprime_int, power))
# we expect an assertion to be thrown if a non coprime int is supplied
# ussing assertRaises() is challenging in jupyter notebook so we just use a try block
try:
c_amod15(non_coprime_int, power)
except ValueError:
assert(True)
else:
assert(False)
# @given(st.integers(min_value=1, max_value=25))
# @settings(deadline=None)
# def test_qft_dagger_uses_H_Swap_CPhase_gates(qft_dagger_length):
# note("qft dagger circuit length %i"%(qft_dagger_length))
# circuit = qft_dagger(qft_dagger_length)
# note(circuit)
# for gate in circuit:
# note(type(gate[0]))
# assert(isinstance(gate[0], HGate)
# or isinstance(gate[0], SwapGate)
# or isinstance(gate[0], CPhaseGate))
@given(draw_coprime_int())
@settings(deadline=None)
def test_qpe_amod_15_phase_between_0_and_1(coprime_integer):
note("coprime integer %i"%coprime_integer)
phase = qpe_amod15(coprime_integer)
note("phase %i"%phase)
assert(phase >= 0 and phase <= 1)
@given(draw_non_coprime_int())
@settings(deadline=None)
def test_qpe_amod_15_non_coprime_int_throws_exception(non_coprime_int):
note("non coprime integer %i"%(non_coprime_int))
# we expect an assertion to be thrown if a non coprime int is supplied
# ussing assertRaises() is challenging in jupyter notebook so we just use a try block
try:
qpe_amod15(non_coprime_int)
except ValueError:
assert(True)
else:
assert(False)
@given(draw_coprime_int())
@settings(deadline=None)
def test_find_factor_is_3_or_5(coprime_integer):
note("coprime integer %i"%coprime_integer)
guesses = find_factor(coprime_integer)
note(guesses)
assert(len(guesses)>0)
for guess in guesses:
note("guess %i"%guess)
assert guess in [3,5]
@given(draw_non_coprime_int())
@settings(deadline=None)
def test_find_factor_non_coprime_int_throws_exception(non_coprime_int):
note("non coprime integer %i"%(non_coprime_int))
# we expect an assertion to be thrown if a non coprime int is supplied
# ussing assertRaises() is challenging in jupyter notebook so we just use a try block
try:
find_factor(non_coprime_int)
except ValueError:
assert(True)
else:
assert(False)
@st.composite
def draw_pair_of_ints(draw):
drawnInt = draw(st.integers(min_value=0, max_value=6))
randIncrease = 7 - drawnInt
drawnLarger = draw(st.integers(min_value=drawnInt+1, max_value=drawnInt+randIncrease))
return(drawnInt, drawnLarger)
@st.composite
def draw_larger_pair_of_ints(draw):
drawnInt = draw(st.integers(min_value=1, max_value=24))
randIncrease = 25 - drawnInt
drawnLarger = draw(st.integers(min_value=drawnInt+1, max_value=drawnInt+randIncrease))
return(drawnInt, drawnLarger)
# @given(draw_coprime_int(), draw_pair_of_ints())
# @settings(deadline=None)
# def test_modular_exponentiation_circuit_longer_with_larger_power(coprime_int, powers):
# smaller, larger = powers
# note("coprime integer %i and powers %i, %i"%(coprime_int, smaller, larger))
# circuit = (c_amod15(coprime_int, smaller).definition)
# circuitLarger = (c_amod15(coprime_int, larger).definition)
# note("smaller circuit length = %i, larger circuit length = %i"%(len(circuit.data), len(circuitLarger.data)))
# assert(len(circuit.data) < len(circuitLarger.data))
# @given(draw_coprime_int(), st.integers(min_value=0, max_value=7))
# @settings(deadline=None)
# def test_modular_exponentiation_circuit_same_length_with_equal_power(coprime_int, power):
# note("coprime integer %i and power %i"%(coprime_int, power))
# circuit = (c_amod15(coprime_int, power).definition)
# circuitEqual = (c_amod15(coprime_int, power).definition)
# note("circuit 1 length = %i, circuit 2 length = %i"%(len(circuit.data), len(circuitEqual.data)))
# assert(len(circuit.data) == len(circuitEqual.data))
# @given(draw_larger_pair_of_ints())
# @settings(deadline=None)
# def test_qft_dagger_circuit_is_longer_with_higher_length_parameter(qft_lengths):
# length1, length2 = qft_lengths
# note("smaller length %i and larger length %i"%(length1, length2))
# circuit = qft_dagger(length1)
# circuitLarger = qft_dagger(length2)
# note("smaller circuit length = %i, larger circuit length = %i"%(len(circuit.data), len(circuitLarger.data)))
# assert(len(circuit.data) < len(circuitLarger.data))
# @given(st.integers(min_value=1, max_value=25))
# @settings(deadline=None)
# def test_qft_dagger_circuit_same_length_with_length_parameter(qft_length):
# note("length %i"%(qft_length))
# circuit = qft_dagger(qft_length)
# circuitEqual = qft_dagger(qft_length)
# note("circuit 1 length = %i, circuit 2 length = %i"%(len(circuit.data), len(circuitEqual.data)))
# assert(len(circuit.data) == len(circuitEqual.data))
if __name__ == '__main__':
# test_modular_exponentiation_uses_CSWap_CCX_CX_gates()
test_modular_exponentiation_non_coprime_int_throws_exception()
# test_qft_dagger_uses_H_Swap_CPhase_gates()
test_qpe_amod_15_phase_between_0_and_1()
test_qpe_amod_15_non_coprime_int_throws_exception()
test_find_factor_is_3_or_5()
test_find_factor_non_coprime_int_throws_exception()
# test_modular_exponentiation_circuit_longer_with_larger_power()
# test_modular_exponentiation_circuit_same_length_with_equal_power()
# test_qft_dagger_circuit_is_longer_with_higher_length_parameter()
# test_qft_dagger_circuit_same_length_with_length_parameter()
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
import unittest
import cirq
import random
import numpy as np
import hypothesis.strategies as st
from hypothesis import given, settings
def create_bell_pair(qubits):
qc = cirq.Circuit()
qc.append(cirq.H(qubits[1]))
qc.append(cirq.CNOT(qubits[1],qubits[0]))
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.append(cirq.X(qubit))
if msg[0] == "1":
qc.append(cirq.Z(qubit))
return qc
def decode_message(qc, qubits):
qc.append(cirq.CNOT(qubits[1],qubits[0]))
qc.append(cirq.H(qubits[1]))
return qc
qubits = cirq.LineQubit.range(2)
qc = create_bell_pair(qubits)
message = '11'
qc = encode_message(qc, qubits[1], message)
qc = decode_message(qc, qubits)
qc.append(cirq.measure(*qubits, key='m'))
print(qc)
simulator = cirq.Simulator()
results = simulator.run(qc , repetitions =1)
readings = np.array2string(results.measurements['m'][0], separator='')[1:-1][::-1]
print(readings)
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### added h gate ###
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
### added x gate ###
qc.x(qubit)
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### added y gate ###
qc.y(0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### added y gate ###
qc.cx(0, 1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
### added h gate ###
qc.h(0)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
### added x gate ###
qc.x(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### added z gate ###
qc.z(1)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
import unittest
import hypothesis.strategies as st
from hypothesis import given, settings, note
from qiskit import QuantumCircuit
from qiskit import Aer, execute
from qiskit.circuit.library import Barrier, XGate, HGate, CXGate, ZGate, Measure
#####################################################################################
### Change the file to import from, in order to test a mutant version of the code ###
#####################################################################################
### e.g. from Add_mutant_1 import ...
#####################################################################################
from Replace_Mutant_5 import create_bell_pair, encode_message, decode_message
#############################
### Postcondition testing ###
#############################
@st.composite
def draw_message(draw):
drawnInt = draw(st.integers(min_value=0, max_value=1))
drawnInt2 = draw(st.integers(min_value=0, max_value=1))
return(str(drawnInt)+str(drawnInt2))
@given(draw_message())
@settings(deadline=None)
def test_encode_message_returns_only_sets_of_bell_pair_values(message):
qc = create_bell_pair()
qc = encode_message(qc, 1, message)
qc.measure_all()
note(message)
backend = Aer.get_backend('aer_simulator')
job = execute(qc, backend, shots=1000, memory=True)
readings = job.result().get_memory()
note(readings)
note(not(set(readings) == set(['11','00']) and set(readings) == set(['01','10'])))
note(set(readings) == set(['11','00']) or set(readings) == set(['01','10']))
assert(not(set(readings) == set(['11','00']) and set(readings) == set(['01','10'])))
assert(set(readings) == set(['11','00']) or set(readings) == set(['01','10']))
@given(draw_message())
def test_decode_message_equal_to_encode_message(message):
note(message)
qc = create_bell_pair()
qc = encode_message(qc, 1, message)
qc = decode_message(qc)
qc.measure_all()
backend = Aer.get_backend('aer_simulator')
job = execute(qc, backend, shots=1, memory=True)
readings = job.result().get_memory()
note(readings)
assert(readings == [message])
if __name__ == '__main__':
test_encode_message_returns_only_sets_of_bell_pair_values()
test_decode_message_equal_to_encode_message()
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### removed cx gate ###
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
### removed x gate ###
pass
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### removed h gate ###
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
### removed z gate ###
pass
return qc
def decode_message(qc):
### removed cx gate ###
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### removed cx gate ###
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### removed h gate ###
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### replaced cx gate ###
qc.cy(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
### replaced z gate ###
qc.x(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### replaced x gate ###
qc.x(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
### replaced x gate ###
qc.x(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### replaced x gate ###
qc.x(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
### replaced x gate ###
qc.z(qubit)
if msg[0] == "1":
### replaced z gate ###
qc.x(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
# Importing everything
from qiskit import *
from qiskit.visualization import plot_histogram
# For Jupyter Notebooks, change the settings to get nicer images
%config InlineBackend.figure_format = 'svg'
def create_bell_pair(qc, a, b):
qc.h(a)
qc.cx(a, b)
def encode_message(qc, qubit, message):
if message == "00":
pass
elif message == "01":
qc.z(qubit)
elif message == "10":
qc.x(qubit)
elif message == "11":
qc.z(qubit)
qz.x(qubit)
else:
print("Enter Valid message please")
def decode_message(qc, a, b):
qc.cx(a, b)
qc.h(a)
# Create the quantum circuit with 2 qubits
qc = QuantumCircuit(2)
# First, Eve creates the entangled pair between Alice and Bob
create_bell_pair(qc, 0, 1)
qc.barrier() # This adds a barrier to our circuit. A barrier
# separates the gates in our diagram and makes it
# clear which part of the circuit is which
# At this point, qubit 0 goes to Alice and qubit 1 goes to Bob
# Next, Alice encodes her message onto qubit 0. In this case,
# we want to send the message '10'. You can try changing this
# value and see how it affects the circuit
message = "10"
encode_message(qc, 0, message)
qc.barrier()
# Alice then sends her qubit to Bob.
# After recieving qubit 0, Bob applies the recovery protocol:
decode_message(qc, 0, 1)
# Finally, Bob measures his qubits to read Alice's message
qc.measure_all()
# Draw our output
qc.draw(output = "mpl")
backend = Aer.get_backend('qasm_simulator')
job_sim = execute(qc, backend, shots=1024)
sim_result = job_sim.result()
measurement_result = sim_result.get_counts(qc)
print(measurement_result)
plot_histogram(measurement_result)
from qiskit import IBMQ
from qiskit.providers.ibmq import least_busy
shots = 256
# Load local account information
IBMQ.load_account()
# Get the least busy backend
provider = IBMQ.get_provider(hub='ibm-q')
backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 2
and not x.configuration().simulator
and x.status().operational==True))
print("least busy backend: ", backend)
# Run our circuit
job = execute(qc, backend=backend, shots=shots)
from qiskit.tools.monitor import job_monitor
job_monitor(job)
result = job.result()
plot_histogram(result.get_counts(qc))
|
https://github.com/rochisha0/stock-picking
|
rochisha0
|
from qiskit.finance.data_providers import RandomDataProvider
import numpy as np
import matplotlib.pyplot as plt
import datetime
import pandas as pd
from nsepy import get_history
from docplex.mp.model import Model
from qiskit.optimization import QuadraticProgram
from qiskit.optimization.converters import LinearEqualityToPenalty
from qiskit.aqua.algorithms import NumPyMinimumEigensolver
import pennylane as qml
num_assets = 3
# Generate expected return and covariance matrix from (random) time-series
stocks = [("TICKER%s" % i) for i in range(num_assets)]
data = RandomDataProvider(tickers=stocks,
start=datetime.datetime(2016,1,1),
end=datetime.datetime(2016,1,30))
data.run()
mu = data.get_period_return_mean_vector()
sigma = data.get_period_return_covariance_matrix()
q = 0.5 # set risk factor
budget = 2 # set budget
penalty = num_assets # set parameter to scale the budget penalty term
mdl = Model('docplex model')
x = mdl.binary_var_list(num_assets)
# set objective function:
#
# maximize { mu^T * x - q * x^T * sigma * x }
#
objective = mdl.sum([mu[i] * x[i] for i in range(num_assets)]) # mu^T * x
objective -= q * mdl.sum([sigma[i][j]*x[i]*x[j] for i in range(num_assets) for j in range(num_assets)])
mdl.maximize(objective)
# add budget constraint:
#
# 1^T * x == budget
#
cost = mdl.sum([x[i] for i in range(num_assets)])
mdl.add_constraint(cost == budget, ctname='budget')
# converting to Quadratic Program
mod = QuadraticProgram()
mod.from_docplex(mdl)
#removing the constraint to create the QUBO
lineq2penalty = LinearEqualityToPenalty(penalty)
qubo = lineq2penalty.convert(mod)
#converting QUBO to an Ising Hamiltonian
H, offset = qubo.to_ising()
H.num_qubits
H = H.to_legacy_op()
H.print_details()
def ansatz(theta):
qml.RX(theta[0], wires=0)
qml.RX(theta[1], wires=1)
qml.RX(theta[2], wires=2)
qml.CNOT(wires=[0,1])
qml.CNOT(wires=[0,2])
qml.CNOT(wires=[1,2])
qml.RX(theta[3], wires=0)
qml.RX(theta[4], wires=1)
qml.RX(theta[5], wires=2)
qml.CNOT(wires=[0,1])
qml.CNOT(wires=[0,2])
qml.CNOT(wires=[1,2])
qml.RX(theta[6], wires=0)
qml.RX(theta[7], wires=1)
qml.RX(theta[8], wires=2)
return ansatz
dev1 = qml.device("default.qubit", wires=3)
@qml.qnode(dev1)
def circuit_IIZ(params):
ansatz(params)
return qml.expval(qml.Identity(0)@qml.Identity(1)@qml.PauliZ(2))
@qml.qnode(dev1)
def circuit_IZI(params):
ansatz(params)
return qml.expval(qml.Identity(0)@qml.PauliZ(1)@qml.Identity(2))
@qml.qnode(dev1)
def circuit_ZII(params):
ansatz(params)
return qml.expval(qml.PauliZ(0)@qml.Identity(1)@qml.Identity(2))
@qml.qnode(dev1)
def circuit_IZZ(params):
ansatz(params)
return qml.expval(qml.Identity(0)@qml.PauliZ(1)@qml.PauliZ(2))
@qml.qnode(dev1)
def circuit_ZIZ(params):
ansatz(params)
return qml.expval(qml.PauliZ(0)@qml.Identity(1)@qml.PauliZ(2))
@qml.qnode(dev1)
def circuit_ZZI(params):
ansatz(params)
return qml.expval(qml.PauliZ(0)@qml.PauliZ(1)@qml.Identity(2))
def pauli_operator_to_dict(pauli_operator):
d = pauli_operator.to_dict()
paulis = d['paulis']
paulis_dict = {}
for x in paulis:
label = x['label']
coeff = x['coeff']['real']
paulis_dict[label] = coeff
return paulis_dict
pauli_dict = pauli_operator_to_dict(H)
def vqe(parameters):
expval_ZII = pauli_dict['ZII'] * circuit_ZII(parameters)
expval_IIZ = pauli_dict['IIZ'] * circuit_IIZ(parameters)
expval_IZI = pauli_dict['IZI'] * circuit_IZI(parameters)
expval_ZZI = pauli_dict['ZZI'] * circuit_ZZI(parameters)
expval_ZIZ = pauli_dict['ZIZ'] * circuit_ZIZ(parameters)
expval_IZZ = pauli_dict['IZZ'] * circuit_IZZ(parameters)
# summing the measurement results
classical_adder = expval_ZII + expval_IIZ + expval_ZIZ + expval_ZZI + expval_ZIZ + expval_IZZ
return classical_adder
opt = qml.GradientDescentOptimizer(stepsize=0.5)
value = []
# optimize parameters in objective
params = np.random.rand(9)
steps = 200
for i in range(steps):
params = opt.step(vqe, params)
value.append(vqe(params))
plt.plot(value)
@qml.qnode(dev1)
def final_circ(params):
ansatz(params)
return qml.probs(wires=[0,1,2])
params
plt.bar(['000', '001', '010', '011', '100', '101', '110', '111'], final_circ(params))
from qiskit.optimization.applications.ising.common import sample_most_likely
exact_eigensolver = NumPyMinimumEigensolver(H)
result = exact_eigensolver.run()
sample_most_likely(result.eigenstate)
pauli_dict
H.print_details()
|
https://github.com/rochisha0/stock-picking
|
rochisha0
|
from qiskit.finance.data_providers import RandomDataProvider
import numpy as np
import matplotlib.pyplot as plt
import datetime
import pandas as pd
from nsepy import get_history
from docplex.mp.model import Model
from qiskit.optimization import QuadraticProgram
from qiskit.optimization.converters import LinearEqualityToPenalty
from qiskit.aqua.algorithms import NumPyMinimumEigensolver
import pennylane as qml
assets = [ 'INFY', 'TCS', 'YESBANK']
stockStartDate = datetime.date(2018,8,20)
stockEndDate = datetime.date(2019,8,20)
df = pd.DataFrame()
for stock in assets:
df[stock] = get_history(symbol=stock, start=stockStartDate, end=stockEndDate)['Close']
returns = df.pct_change()
cov_matrix_annual = returns.cov() * 249
mu = returns.mean().to_numpy() #expected returns
sigma = cov_matrix_annual.to_numpy() #covariance
q = 0.1 # set risk factor
budget = 2 # set budget
penalty = num_assets # set parameter to scale the budget penalty term
mdl = Model('docplex model')
x = mdl.binary_var_list(num_assets)
# set objective function:
#
# maximize { mu^T * x - q * x^T * sigma * x }
#
objective = mdl.sum([mu[i] * x[i] for i in range(num_assets)]) # mu^T * x
objective -= q * mdl.sum([sigma[i][j]*x[i]*x[j] for i in range(num_assets) for j in range(num_assets)])
mdl.maximize(objective)
# add budget constraint:
#
# 1^T * x == budget
#
cost = mdl.sum([x[i] for i in range(num_assets)])
mdl.add_constraint(cost == budget, ctname='budget')
# converting to Quadratic Program
mod = QuadraticProgram()
mod.from_docplex(mdl)
#removing the constraint to create the QUBO
lineq2penalty = LinearEqualityToPenalty(penalty)
qubo = lineq2penalty.convert(mod)
#converting QUBO to an Ising Hamiltonian
H, offset = qubo.to_ising()
H.num_qubits
H = H.to_legacy_op()
H.print_details()
def ansatz(theta):
qml.RX(theta[0], wires=0)
qml.RX(theta[1], wires=1)
qml.RX(theta[2], wires=2)
qml.CNOT(wires=[0,1])
qml.CNOT(wires=[0,2])
qml.CNOT(wires=[1,2])
qml.RX(theta[3], wires=0)
qml.RX(theta[4], wires=1)
qml.RX(theta[5], wires=2)
qml.CNOT(wires=[0,1])
qml.CNOT(wires=[0,2])
qml.CNOT(wires=[1,2])
qml.RX(theta[6], wires=0)
qml.RX(theta[7], wires=1)
qml.RX(theta[8], wires=2)
return ansatz
dev1 = qml.device("qiskit.aer", wires=3)
@qml.qnode(dev1)
def circuit_IIZ(params):
ansatz(params)
return qml.expval(qml.Identity(0)@qml.Identity(1)@qml.PauliZ(2))
@qml.qnode(dev1)
def circuit_IZI(params):
ansatz(params)
return qml.expval(qml.Identity(0)@qml.PauliZ(1)@qml.Identity(2))
@qml.qnode(dev1)
def circuit_ZII(params):
ansatz(params)
return qml.expval(qml.PauliZ(0)@qml.Identity(1)@qml.Identity(2))
@qml.qnode(dev1)
def circuit_IZZ(params):
ansatz(params)
return qml.expval(qml.Identity(0)@qml.PauliZ(1)@qml.PauliZ(2))
@qml.qnode(dev1)
def circuit_ZIZ(params):
ansatz(params)
return qml.expval(qml.PauliZ(0)@qml.Identity(1)@qml.PauliZ(2))
@qml.qnode(dev1)
def circuit_ZZI(params):
ansatz(params)
return qml.expval(qml.PauliZ(0)@qml.PauliZ(1)@qml.Identity(2))
def pauli_operator_to_dict(pauli_operator):
d = pauli_operator.to_dict()
paulis = d['paulis']
paulis_dict = {}
for x in paulis:
label = x['label']
coeff = x['coeff']['real']
paulis_dict[label] = coeff
return paulis_dict
pauli_dict = pauli_operator_to_dict(H)
def vqe(parameters):
expval_ZII = pauli_dict['ZII'] * circuit_ZII(parameters)
expval_IIZ = pauli_dict['IIZ'] * circuit_IIZ(parameters)
expval_IZI = pauli_dict['IZI'] * circuit_IZI(parameters)
expval_ZZI = pauli_dict['ZZI'] * circuit_ZZI(parameters)
expval_ZIZ = pauli_dict['ZIZ'] * circuit_ZIZ(parameters)
expval_IZZ = pauli_dict['IZZ'] * circuit_IZZ(parameters)
# summing the measurement results
classical_adder = expval_ZII + expval_IIZ + expval_ZIZ + expval_ZZI + expval_ZIZ + expval_IZZ
return classical_adder
opt = qml.GradientDescentOptimizer(stepsize=0.5)
value = []
# optimize parameters in objective
params = np.random.rand(9)*2
init_params = params
steps = 100
for i in range(steps):
params = opt.step(vqe, params)
value.append(vqe(params))
plt.bar(['000', '001', '010', '011', '100', '101', '110', '111'], final_circ(params))
@qml.qnode(dev1)
def final_circ(params):
ansatz(params)
return qml.probs(wires=[0,1,2])
params
plt.bar(['000', '001', '010', '011', '100', '101', '110', '111'], final_circ(params), color='midnightblue')
pauli_dict
H.print_details()
from qiskit import QuantumCircuit
circ = QuantumCircuit(3)
circ.rx(params[0], 0)
circ.rx(params[1], 1)
circ.rx(params[2], 2)
circ.cx(0,1)
circ.cx(0,2)
circ.cx(1,2)
circ.rx(params[3], 0)
circ.rx(params[4], 1)
circ.rx(params[5], 2)
circ.cx(0,1)
circ.cx(0,2)
circ.cx(1,2)
circ.rx(params[6], 0)
circ.rx(params[7], 1)
circ.rx(params[8], 2)
circ.draw('mpl')
|
https://github.com/rochisha0/stock-picking
|
rochisha0
|
from qiskit.finance.data_providers import RandomDataProvider
import numpy as np
import matplotlib.pyplot as plt
import datetime
import pandas as pd
from nsepy import get_history
from docplex.mp.model import Model
from qiskit.optimization import QuadraticProgram
from qiskit.optimization.converters import LinearEqualityToPenalty
import pennylane as qml
assets = ['INFY', 'TCS', 'DRREDDY']
num_assets = len(assets)
print('The total number of assets {0}'.format(num_assets))
stockStartDate = datetime.date(2019,8,20)
stockEndDate = datetime.date(2020,8,20)
df = pd.DataFrame()
for stock in assets:
df[stock] = get_history(symbol=stock, start=stockStartDate, end=stockEndDate)['Close']
title = 'Portfolio Adj. Close Price History '
#Get the stocks
my_stocks = df
#Create and plot the graph
plt.figure(figsize=(12.2,4.5)) #width = 12.2in, height = 4.5
# Loop through each stock and plot the Adj Close for each day
for c in my_stocks.columns.values:
plt.plot( my_stocks[c], label=c)#plt.plot( X-Axis , Y-Axis, line_width, alpha_for_blending, label)
plt.title(title)
plt.xlabel('Date',fontsize=18)
plt.ylabel('Adj. Price Rs.',fontsize=18)
plt.legend(my_stocks.columns.values, loc='upper left')
plt.show()
returns = df.pct_change()
cov_matrix_annual = returns.cov() * 249
mu = returns.mean().to_numpy()
sigma = cov_matrix_annual.to_numpy()
q = 0.5 # set risk factor
budget = 2 # set budget
penalty = num_assets # set parameter to scale the budget penalty term
mdl = Model('docplex model')
x = mdl.binary_var_list(num_assets)
# set objective function:
#
# maximize { mu^T * x - q * x^T * sigma * x }
#
objective = mdl.sum([mu[i] * x[i] for i in range(num_assets)]) # mu^T * x
objective -= q * mdl.sum([sigma[i][j]*x[i]*x[j] for i in range(num_assets) for j in range(num_assets)])
mdl.maximize(objective)
# add budget constraint:
#
# 1^T * x == budget
#
cost = mdl.sum([x[i] for i in range(num_assets)])
mdl.add_constraint(cost == budget, ctname='budget')
# converting to Quadratic Program
mod = QuadraticProgram()
mod.from_docplex(mdl)
#removing the constraint to create the QUBO
lineq2penalty = LinearEqualityToPenalty(penalty)
qubo = lineq2penalty.convert(mod)
#converting QUBO to an Ising Hamiltonian
H, offset = qubo.to_ising()
H.num_qubits
H = H.to_legacy_op()
H.print_details()
def anstanz(theta):
qml.RX(theta[0], wires=0)
qml.RX(theta[1], wires=1)
qml.RX(theta[2], wires=2)
qml.CNOT(wires=[0,1])
qml.CNOT(wires=[0,2])
qml.CNOT(wires=[1,2])
qml.RX(theta[3], wires=0)
qml.RX(theta[4], wires=1)
qml.RX(theta[5], wires=2)
qml.CNOT(wires=[0,1])
qml.CNOT(wires=[0,2])
qml.CNOT(wires=[1,2])
qml.RX(theta[6], wires=0)
qml.RX(theta[7], wires=1)
qml.RX(theta[8], wires=2)
return anstanz
dev1 = qml.device("default.qubit", wires=3)
@qml.qnode(dev1)
def circuit_IIZ(params):
anstanz(params)
return qml.expval(qml.Identity(0)@qml.Identity(1)@qml.PauliZ(2))
@qml.qnode(dev1)
def circuit_IZI(params):
anstanz(params)
return qml.expval(qml.Identity(0)@qml.PauliZ(1)@qml.Identity(2))
@qml.qnode(dev1)
def circuit_ZII(params):
anstanz(params)
return qml.expval(qml.PauliZ(0)@qml.Identity(1)@qml.Identity(2))
@qml.qnode(dev1)
def circuit_IZZ(params):
anstanz(params)
return qml.expval(qml.Identity(0)@qml.PauliZ(1)@qml.PauliZ(2))
@qml.qnode(dev1)
def circuit_ZIZ(params):
anstanz(params)
return qml.expval(qml.PauliZ(0)@qml.Identity(1)@qml.PauliZ(2))
@qml.qnode(dev1)
def circuit_ZZI(params):
anstanz(params)
return qml.expval(qml.PauliZ(0)@qml.PauliZ(1)@qml.Identity(2))
def pauli_operator_to_dict(pauli_operator):
d = pauli_operator.to_dict()
paulis = d['paulis']
paulis_dict = {}
for x in paulis:
label = x['label']
coeff = x['coeff']['real']
paulis_dict[label] = coeff
return paulis_dict
pauli_dict = pauli_operator_to_dict(H)
def vqe(parameters):
expval_ZII = pauli_dict['ZII'] * circuit_ZII(parameters)
expval_IIZ = pauli_dict['IIZ'] * circuit_IIZ(parameters)
expval_IZI = pauli_dict['IZI'] * circuit_IZI(parameters)
expval_ZZI = pauli_dict['ZZI'] * circuit_ZZI(parameters)
expval_ZIZ = pauli_dict['ZIZ'] * circuit_ZIZ(parameters)
expval_IZZ = pauli_dict['IZZ'] * circuit_IZZ(parameters)
# summing the measurement results
classical_adder = expval_ZII + expval_IIZ + expval_ZIZ + expval_ZZI + expval_ZIZ + expval_IZZ
return classical_adder
opt = qml.GradientDescentOptimizer(stepsize=0.5)
value = []
params = [0.01, 0.02, 0.01, np.pi, 0.1, np.pi/2, np.pi, np.pi/2, np.pi] ## Random initial parameters
steps = 100
for i in range(steps):
#print(i)
params = opt.step(vqe, params)
value.append(vqe(params))
@qml.qnode(dev1)
def final_circ(params):
anstanz(params)
return qml.probs(wires=[0,1,2])
plt.bar(['000', '001', '010', '011', '100', '101', '110', '111'], final_circ(params))
from qiskit.optimization.applications.ising.common import sample_most_likely
exact_eigensolver = NumPyMinimumEigensolver(H)
result = exact_eigensolver.run()
sample_most_likely(result.eigenstate)
|
https://github.com/rochisha0/stock-picking
|
rochisha0
|
from qiskit.finance.data_providers import RandomDataProvider
import numpy as np
import matplotlib.pyplot as plt
import datetime
import pandas as pd
from nsepy import get_history
from docplex.mp.model import Model
from qiskit.optimization import QuadraticProgram
from qiskit.optimization.converters import LinearEqualityToPenalty
from qiskit.aqua.algorithms import NumPyMinimumEigensolver
import pennylane as qml
num_assets = 3
# Generate expected return and covariance matrix from (random) time-series
stocks = [("TICKER%s" % i) for i in range(num_assets)]
data = RandomDataProvider(tickers=stocks,
start=datetime.datetime(2016,1,1),
end=datetime.datetime(2016,1,30))
data.run()
mu = data.get_period_return_mean_vector()
sigma = data.get_period_return_covariance_matrix()
q = 0.5 # set risk factor
budget = 2 # set budget
penalty = num_assets # set parameter to scale the budget penalty term
mdl = Model('docplex model')
x = mdl.binary_var_list(num_assets)
# set objective function:
#
# maximize { mu^T * x - q * x^T * sigma * x }
#
objective = mdl.sum([mu[i] * x[i] for i in range(num_assets)]) # mu^T * x
objective -= q * mdl.sum([sigma[i][j]*x[i]*x[j] for i in range(num_assets) for j in range(num_assets)])
mdl.maximize(objective)
# add budget constraint:
#
# 1^T * x == budget
#
cost = mdl.sum([x[i] for i in range(num_assets)])
mdl.add_constraint(cost == budget, ctname='budget')
# converting to Quadratic Program
mod = QuadraticProgram()
mod.from_docplex(mdl)
#removing the constraint to create the QUBO
lineq2penalty = LinearEqualityToPenalty(penalty)
qubo = lineq2penalty.convert(mod)
#converting QUBO to an Ising Hamiltonian
H, offset = qubo.to_ising()
H.num_qubits
H = H.to_legacy_op()
H.print_details()
def ansatz(theta):
qml.RX(theta[0], wires=0)
qml.RX(theta[1], wires=1)
qml.RX(theta[2], wires=2)
qml.CNOT(wires=[0,1])
qml.CNOT(wires=[0,2])
qml.CNOT(wires=[1,2])
qml.RX(theta[3], wires=0)
qml.RX(theta[4], wires=1)
qml.RX(theta[5], wires=2)
qml.CNOT(wires=[0,1])
qml.CNOT(wires=[0,2])
qml.CNOT(wires=[1,2])
qml.RX(theta[6], wires=0)
qml.RX(theta[7], wires=1)
qml.RX(theta[8], wires=2)
return ansatz
dev1 = qml.device("default.qubit", wires=3)
@qml.qnode(dev1)
def circuit_IIZ(params):
ansatz(params)
return qml.expval(qml.Identity(0)@qml.Identity(1)@qml.PauliZ(2))
@qml.qnode(dev1)
def circuit_IZI(params):
ansatz(params)
return qml.expval(qml.Identity(0)@qml.PauliZ(1)@qml.Identity(2))
@qml.qnode(dev1)
def circuit_ZII(params):
ansatz(params)
return qml.expval(qml.PauliZ(0)@qml.Identity(1)@qml.Identity(2))
@qml.qnode(dev1)
def circuit_IZZ(params):
ansatz(params)
return qml.expval(qml.Identity(0)@qml.PauliZ(1)@qml.PauliZ(2))
@qml.qnode(dev1)
def circuit_ZIZ(params):
ansatz(params)
return qml.expval(qml.PauliZ(0)@qml.Identity(1)@qml.PauliZ(2))
@qml.qnode(dev1)
def circuit_ZZI(params):
ansatz(params)
return qml.expval(qml.PauliZ(0)@qml.PauliZ(1)@qml.Identity(2))
def pauli_operator_to_dict(pauli_operator):
d = pauli_operator.to_dict()
paulis = d['paulis']
paulis_dict = {}
for x in paulis:
label = x['label']
coeff = x['coeff']['real']
paulis_dict[label] = coeff
return paulis_dict
pauli_dict = pauli_operator_to_dict(H)
def vqe(parameters):
expval_ZII = pauli_dict['ZII'] * circuit_ZII(parameters)
expval_IIZ = pauli_dict['IIZ'] * circuit_IIZ(parameters)
expval_IZI = pauli_dict['IZI'] * circuit_IZI(parameters)
expval_ZZI = pauli_dict['ZZI'] * circuit_ZZI(parameters)
expval_ZIZ = pauli_dict['ZIZ'] * circuit_ZIZ(parameters)
expval_IZZ = pauli_dict['IZZ'] * circuit_IZZ(parameters)
# summing the measurement results
classical_adder = expval_ZII + expval_IIZ + expval_ZIZ + expval_ZZI + expval_ZIZ + expval_IZZ
return classical_adder
opt = qml.GradientDescentOptimizer(stepsize=0.5)
value = []
# optimize parameters in objective
params = np.random.rand(9)
steps = 200
for i in range(steps):
params = opt.step(vqe, params)
value.append(vqe(params))
plt.plot(value)
@qml.qnode(dev1)
def final_circ(params):
ansatz(params)
return qml.probs(wires=[0,1,2])
params
plt.bar(['000', '001', '010', '011', '100', '101', '110', '111'], final_circ(params))
from qiskit.optimization.applications.ising.common import sample_most_likely
exact_eigensolver = NumPyMinimumEigensolver(H)
result = exact_eigensolver.run()
sample_most_likely(result.eigenstate)
pauli_dict
H.print_details()
|
https://github.com/vimarsh6739/quant-algos
|
vimarsh6739
|
# importing QISKit
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, QISKitError, QuantumJob
from qiskit import available_backends, execute, register, get_backend, compile
from qiskit.tools import visualization
from qiskit.tools.visualization import circuit_drawer
q = QuantumRegister(6)
qc = QuantumCircuit(q)
qc.x(q[2])
qc.cx(q[1], q[5])
qc.cx(q[2], q[5])
qc.cx(q[3], q[5])
qc.ccx(q[1], q[2], q[4])
qc.ccx(q[3], q[4], q[5])
qc.ccx(q[1], q[2], q[4])
qc.x(q[2])
circuit_drawer(qc)
def black_box_u_f(circuit, f_in, f_out, aux, n, exactly_1_3_sat_formula):
"""Circuit that computes the black-box function from f_in to f_out.
Create a circuit that verifies whether a given exactly-1 3-SAT
formula is satisfied by the input. The exactly-1 version
requires exactly one literal out of every clause to be satisfied.
"""
num_clauses = len(exactly_1_3_sat_formula)
for (k, clause) in enumerate(exactly_1_3_sat_formula):
# This loop ensures aux[k] is 1 if an odd number of literals
# are true
for literal in clause:
if literal > 0:
circuit.cx(f_in[literal-1], aux[k])
else:
circuit.x(f_in[-literal-1])
circuit.cx(f_in[-literal-1], aux[k])
# Flip aux[k] if all literals are true, using auxiliary qubit
# (ancilla) aux[num_clauses]
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
circuit.ccx(f_in[2], aux[num_clauses], aux[k])
# Flip back to reverse state of negative literals and ancilla
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
for literal in clause:
if literal < 0:
circuit.x(f_in[-literal-1])
# The formula is satisfied if and only if all auxiliary qubits
# except aux[num_clauses] are 1
if (num_clauses == 1):
circuit.cx(aux[0], f_out[0])
elif (num_clauses == 2):
circuit.ccx(aux[0], aux[1], f_out[0])
elif (num_clauses == 3):
circuit.ccx(aux[0], aux[1], aux[num_clauses])
circuit.ccx(aux[2], aux[num_clauses], f_out[0])
circuit.ccx(aux[0], aux[1], aux[num_clauses])
else:
raise ValueError('We only allow at most 3 clauses')
# Flip back any auxiliary qubits to make sure state is consistent
# for future executions of this routine; same loop as above.
for (k, clause) in enumerate(exactly_1_3_sat_formula):
for literal in clause:
if literal > 0:
circuit.cx(f_in[literal-1], aux[k])
else:
circuit.x(f_in[-literal-1])
circuit.cx(f_in[-literal-1], aux[k])
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
circuit.ccx(f_in[2], aux[num_clauses], aux[k])
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
for literal in clause:
if literal < 0:
circuit.x(f_in[-literal-1])
# -- end function
def n_controlled_Z(circuit, controls, target):
"""Implement a Z gate with multiple controls"""
if (len(controls) > 2):
raise ValueError('The controlled Z with more than 2 ' +
'controls is not implemented')
elif (len(controls) == 1):
circuit.h(target)
circuit.cx(controls[0], target)
circuit.h(target)
elif (len(controls) == 2):
circuit.h(target)
circuit.ccx(controls[0], controls[1], target)
circuit.h(target)
# -- end function
def inversion_about_average(circuit, f_in, n):
"""Apply inversion about the average step of Grover's algorithm."""
# Hadamards everywhere
for j in range(n):
circuit.h(f_in[j])
# D matrix: flips the sign of the state |000> only
for j in range(n):
circuit.x(f_in[j])
n_controlled_Z(circuit, [f_in[j] for j in range(n-1)], f_in[n-1])
for j in range(n):
circuit.x(f_in[j])
# Hadamards everywhere again
for j in range(n):
circuit.h(f_in[j])
# -- end function
"""
Grover search implemented in QISKit.
This module contains the code necessary to run Grover search on 3
qubits, both with a simulator and with a real quantum computing
device. This code is the companion for the paper
"An introduction to quantum computing, without the physics",
Giacomo Nannicini, https://arxiv.org/abs/1708.03684.
"""
def input_state(circuit, f_in, f_out, n):
"""(n+1)-qubit input state for Grover search."""
for j in range(n):
circuit.h(f_in[j])
circuit.x(f_out)
circuit.h(f_out)
# -- end function
# Make a quantum program for the n-bit Grover search.
n = 3
# Exactly-1 3-SAT formula to be satisfied, in conjunctive
# normal form. We represent literals with integers, positive or
# negative, to indicate a Boolean variable or its negation.
exactly_1_3_sat_formula = [[1, 2, -3], [-1, -2, -3], [-1, 2, 3]]
# Define three quantum registers: 'f_in' is the search space (input
# to the function f), 'f_out' is bit used for the output of function
# f, aux are the auxiliary bits used by f to perform its
# computation.
f_in = QuantumRegister(n)
f_out = QuantumRegister(1)
aux = QuantumRegister(len(exactly_1_3_sat_formula) + 1)
# Define classical register for algorithm result
ans = ClassicalRegister(n)
# Define quantum circuit with above registers
grover = QuantumCircuit()
grover.add(f_in)
grover.add(f_out)
grover.add(aux)
grover.add(ans)
input_state(grover, f_in, f_out, n)
T = 2
for t in range(T):
# Apply T full iterations
black_box_u_f(grover, f_in, f_out, aux, n, exactly_1_3_sat_formula)
inversion_about_average(grover, f_in, n)
# Measure the output register in the computational basis
for j in range(n):
grover.measure(f_in[j], ans[j])
# Execute circuit
job = execute([grover], backend='local_qasm_simulator', shots=1000)
result = job.result()
# Get counts and plot histogram
counts = result.get_counts(grover)
visualization.plot_histogram(counts)
|
https://github.com/duartefrazao/Quantum-Finance-Algorithms
|
duartefrazao
|
from qiskit import BasicAer,Aer
from qiskit.aqua import aqua_globals, QuantumInstance
from qiskit.aqua.algorithms import QAOA, NumPyMinimumEigensolver,VQE
from qiskit.circuit.parameter import Parameter
from qiskit.optimization.algorithms import MinimumEigenOptimizer, RecursiveMinimumEigenOptimizer,GroverOptimizer
from qiskit.optimization import QuadraticProgram
from qiskit import Aer
from qiskit.circuit.library import TwoLocal
from qiskit.aqua import QuantumInstance
from qiskit.finance.applications.ising import portfolio
from qiskit.optimization.applications.ising.common import sample_most_likely
from qiskit.finance.data_providers import RandomDataProvider
from qiskit.aqua.algorithms import VQE, QAOA, NumPyMinimumEigensolver
from qiskit.aqua.components.optimizers import SLSQP
import numpy as np
import matplotlib.pyplot as plt
import datetime
import math as math
from math import sin,cos
from itertools import combinations
from qiskit.aqua.operators import PrimitiveOp, SummedOp
from qiskit.quantum_info.operators import Pauli,Operator
from qiskit import QuantumCircuit
from qiskit.extensions import HamiltonianGate
from qiskit.aqua.operators import (OperatorBase, Swap,X, I,Y, H, CircuitStateFn,
EvolutionFactory, LegacyBaseOperator)
aqua_globals.massive = True
from time import time
def qaoa(qubo,num_assets,num_assets_wanted, alternating):
num_ancila_qubits = 2
p = 1
maxiter = 10
specify_maxiter = True
ansatz = ((X^num_assets_wanted)^(I^(num_assets-num_assets_wanted)))#^(I^num_ancila_qubits)
mixer_iterations = math.ceil((num_assets/2))
""" print(mixer_iterations)
mixer = QuantumCircuit(num_assets+ 1)
theta = Parameter('θ')
cos = math.cos(theta / 2)
sin = math.sin(theta / 2)
np.array([[cos, -1j * sin],
[-1j * sin, cos]], dtype=dtype)
op = Operator(op)
for i in range(num_assets-1):
mixer.unitary(iswap_op, [i, i+1], label='iswap') """
""" num_qubits = num_assets + 2
mixer = QuantumCircuit(num_qubits)
num_iterations = math.ceil((num_assets) /2) - 1
theta = Parameter('θ1')
mixer.rx(theta,0)
mixer.rx(theta,1)
for iteration in range(num_iterations):
ancila = 0
for i in range(0,num_qubits - 3,+2):
mixer.cswap(num_qubits-1,i,i+1)
for i in range(1,num_qubits - 3,+2):
mixer.cswap(num_qubits-1,i,i+1)
if num_qubits%2 == 1:
mixer.cswap(num_qubits-1,num_qubits-3,0)
for i in range(3,num_qubits-1,+2):
mixer.cswap(0 + ancila%2,i,i+1)
ancila = ancila + 1
for i in range(2,num_qubits-1,+2):
mixer.cswap(0 + ancila%2,i,i+1)
ancila = ancila + 1
if num_qubits%2 == 1:
mixer.cswap(0 + ancila%2,num_qubits-1,2)
mixer.rx(-theta,0)
mixer.rx(-theta,1) """
#mixer = I^num_qubits
quantum_instance = QuantumInstance(Aer.get_backend('qasm_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed,shots=20000)
if alternating:
#qaoa_mes = QAOA(quantum_instance=quantum_instance,p=p,initial_state=ansatz,optimizer=COBYLA(rhobeg=(np.pi/4)), alternating=alternating)
if specify_maxiter == True:
qaoa_mes = QAOA(quantum_instance=quantum_instance,p=p,initial_state=ansatz,optimizer=SLSQP(maxiter=maxiter),alternating=alternating)
else:
qaoa_mes = QAOA(quantum_instance=quantum_instance,p=p,initial_state=ansatz,optimizer=SLSQP(),alternating=alternating)
else:
if specify_maxiter == True:
qaoa_mes = QAOA(quantum_instance=quantum_instance,p=p,optimizer=SLSQP(maxiter=maxiter))
else:
qaoa_mes = QAOA(quantum_instance=quantum_instance,p=p,optimizer=SLSQP())
qaoa = MinimumEigenOptimizer(qaoa_mes)
start = time()
qaoa_result = qaoa.solve(qubo)
print(time()-start)
return qaoa_result
def vqe(qubo):
quantum_instance = QuantumInstance(BasicAer.get_backend('statevector_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
vqe_mes = VQE(quantum_instance=quantum_instance, initial_point=[0., 0.])
vqe = MinimumEigenOptimizer(vqe_mes)
vqe_result = vqe.solve(qubo)
return vqe_result
def grover_optimizer(qubo,num_stocks):
quantum_instance = QuantumInstance(BasicAer.get_backend('statevector_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
grover_mes =GroverOptimizer(6, quantum_instance=quantum_instance)
grover_result = grover_mes.solve(qubo)
return grover_result
def minimum_eigen(qubo):
quantum_instance = QuantumInstance(BasicAer.get_backend('statevector_simulator'),
seed_simulator=aqua_globals.random_seed,
seed_transpiler=aqua_globals.random_seed)
exact_mes = NumPyMinimumEigensolver()
exact = MinimumEigenOptimizer(exact_mes)
exact_result = exact.solve(qubo)
return exact_result
|
https://github.com/duartefrazao/Quantum-Finance-Algorithms
|
duartefrazao
|
from qiskit import Aer
from qiskit.circuit.library import TwoLocal
from qiskit.aqua import QuantumInstance
from qiskit.optimization.applications.ising.common import sample_most_likely
from qiskit.aqua.algorithms import VQE, QAOA, NumPyMinimumEigensolver
from qiskit.aqua.components.optimizers import COBYLA
from .aux_functions import IncompatibleArguments
import numpy as np
import matplotlib.pyplot as plt
# initialization
import numpy as np
# importing Qiskit
from qiskit import IBMQ, Aer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, assemble, transpile
# import basic plot tools
from qiskit.visualization import plot_histogram
#Quadratic
from qiskit.optimization import QuadraticProgram
from docplex.mp.advmodel import AdvModel
from qiskit.optimization.converters import IntegerToBinary,LinearEqualityToPenalty,InequalityToEquality,QuadraticProgramToQubo
def portfolio_optimization(assets,mu,sigma,num_assets_portfolio,risk_aversion,penalty,alternating):
if len(mu) != sigma.shape[0] or len(mu) != sigma.shape[1] or len(mu) != len(assets):
raise IncompatibleArguments("Sigma, mu and assets need to be equal in size")
""" if not 0 <= risk_aversion <= 1:
raise IncompatibleArguments("Risk aversion needs to be in [0,1]") """
if not 0 < num_assets_portfolio <= len(assets):
raise IncompatibleArguments("Number of assets to include in the portfolio needs to be smaller or equal to the number of assets passed")
#Initialize binary variable array
mdl = AdvModel('docplex model')
mdl.init_numpy()
decision_vars = np.array([])
""" if qaoa:
ancila_odd = mdl.binary_var("ancila_odd")
ancila_even = mdl.binary_var("ancila_even") """
for asset in assets:
decision_vars = np.append(decision_vars,[mdl.binary_var(str(asset))])
#Terms
vec_ones = np.ones(len(decision_vars)) #helper vector
num_assets_chosen = np.matmul(vec_ones.T,decision_vars)
expected_returns_portfolio = np.matmul(mu.T,decision_vars)/num_assets_portfolio
variance_portfolio = np.matmul(decision_vars.T,np.dot(sigma,decision_vars))/num_assets_portfolio #*2 as covariance is a symetric matrix
#Objective function
#if not qaoa:
if alternating:
mdl.minimize(- expected_returns_portfolio + (risk_aversion * variance_portfolio))
#mdl.minimize(- expected_returns_portfolio + (risk_aversion * variance_portfolio) + ancila_even*0 + ancila_odd*0 )
else:
mdl.minimize(- expected_returns_portfolio + (risk_aversion * variance_portfolio) + penalty*((num_assets_chosen - num_assets_portfolio)**2))
qubo = QuadraticProgram()
qubo.from_docplex(mdl)
#print(qubo.export_as_lp_string())
#qubo.binary_var("ancila")
return qubo
def portfolio_optimization_binary(assets,mu,sigma,num_assets_portfolio,risk_aversion,penalty,max_allocation):
if len(mu) != sigma.shape[0] or len(mu) != sigma.shape[1] or len(mu) != len(assets):
raise IncompatibleArguments("Sigma, mu and assets need to be equal in size")
""" if not 0 <= risk_aversion <= 1:
raise IncompatibleArguments("Risk aversion needs to be in [0,1]") """
""" if not 0 < num_assets_portfolio <= len(assets):
raise IncompatibleArguments("Number of assets to include in the portfolio needs to be smaller or equal to the number of assets passed")
"""
#Initialize binary variable array
mdl = AdvModel('docplex model')
mdl.init_numpy()
decision_vars = np.array([])
for asset in assets:
decision_vars = np.append(decision_vars,[mdl.integer_var(name=str(asset),lb=0,ub=max_allocation)])
#Terms
vec_ones = np.ones(len(decision_vars)) #helper vector
num_assets_chosen = np.matmul(vec_ones.T,decision_vars)
expected_returns_portfolio = np.matmul(mu.T,decision_vars)
variance_portfolio = np.matmul(decision_vars.T,np.dot(sigma,decision_vars)) #*2 as covariance is a symetric matrix
#Objective function
#mdl.minimize(- expected_returns_portfolio + (risk_aversion * variance_portfolio) + penalty*((num_assets_chosen - max_allocation)**2))
mdl.minimize(((num_assets_chosen - max_allocation)**2))
qubo = QuadraticProgram()
qubo.from_docplex(mdl)
""" int2bin = IntegerToBinary()
qp_eq_bin = int2bin.convert(qubo) """
conv = QuadraticProgramToQubo()
qp_eq_bin = conv.convert(qubo)
print(qp_eq_bin.export_as_lp_string())
return qubo
def portfolio_optimization_binary_count(assets,mu,sigma,max_assets,risk_aversion,penalty,max_allocation):
if len(mu) != sigma.shape[0] or len(mu) != sigma.shape[1] or len(mu) != len(assets):
raise IncompatibleArguments("Sigma, mu and assets need to be equal in size")
""" if not 0 <= risk_aversion <= 1:
raise IncompatibleArguments("Risk aversion needs to be in [0,1]") """
""" if not 0 < num_assets_portfolio <= len(assets):
raise IncompatibleArguments("Number of assets to include in the portfolio needs to be smaller or equal to the number of assets passed")
"""
#Initialize binary variable array
mdl = AdvModel('docplex model')
mdl.init_numpy()
allocation_vars = np.array([])
presence_vars = np.array([])
for asset in assets:
allocation_vars = np.append(allocation_vars,[mdl.integer_var(name=str(asset),lb=0,ub=max_allocation)])
presence_vars = np.append(presence_vars,[mdl.binary_var(name=('b'+str(asset)))])
#Terms
vec_ones = np.ones(len(allocation_vars)) #helper vector
num_allocations = np.matmul(vec_ones.T,allocation_vars)
expected_returns_portfolio = 10000*np.matmul(mu.T,allocation_vars)
variance_portfolio = 10000*np.matmul(allocation_vars.T,np.dot(sigma,allocation_vars)) / 2 #*2 as covariance is a symetric matrix
#Objective function
mdl.minimize(- expected_returns_portfolio
+ (risk_aversion * variance_portfolio)
+ penalty*((num_allocations - max_allocation)**2))
for asset in range(len(presence_vars)):
mdl.add_constraint(allocation_vars[0]>=presence_vars[0])
mdl.add_constraint(allocation_vars[0]<= max_allocation * presence_vars[0])
#mdl.add_constraint(allocation_vars[0] <= presence_vars[0] + allocation_vars[0]*presence_vars[0])
qubo = QuadraticProgram()
qubo.from_docplex(mdl)
conv = QuadraticProgramToQubo()
qp_eq_bin = conv.convert(qubo)
"""
int2bin = IntegerToBinary()
qp_eq_bin = int2bin.convert(qubo)
lineq2penalty = LinearEqualityToPenalty()
qp_eq_bin = lineq2penalty.convert(qp_eq_bin) """
#mdl.add_constraint(allocation_vars[0]*presence_vars[0] >= 0)
print(qp_eq_bin.export_as_lp_string())
return qubo
|
https://github.com/duartefrazao/Quantum-Finance-Algorithms
|
duartefrazao
|
from qiskit import Aer
from qiskit.circuit.library import TwoLocal
from qiskit.aqua import QuantumInstance
from qiskit.optimization.applications.ising.common import sample_most_likely
from qiskit.aqua.algorithms import VQE, QAOA, NumPyMinimumEigensolver
from qiskit.aqua.components.optimizers import COBYLA
from aux_functions import IncompatibleArguments
import numpy as np
import matplotlib.pyplot as plt
# initialization
import numpy as np
# importing Qiskit
from qiskit import IBMQ, Aer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, assemble, transpile
# import basic plot tools
from qiskit.visualization import plot_histogram
#Quadratic
from qiskit.optimization import QuadraticProgram
from docplex.mp.advmodel import AdvModel
def portfolio_optimization3(assets,assets_to_include,mu,sigma,num_assets_portfolio,risk_aversion,penalty):
if len(mu) != sigma.shape[0] or len(mu) != sigma.shape[1] or len(mu) != len(assets):
raise IncompatibleArguments("Sigma, mu and assets need to be equal in size")
if not 0 <= risk_aversion <= 1:
raise IncompatibleArguments("Risk aversion needs to be in [0,1]")
if not 0 < num_assets_portfolio <= len(assets):
raise IncompatibleArguments("Number of assets to include in the portfolio needs to be smaller or equal to the number of assets passed")
if len(assets_to_include) > num_assets_portfolio:
raise IncompatibleArguments("Can't include stocks mentioned, they are more than the number of assets to include")
for asset in assets_to_include:
if not asset in assets:
raise IncompatibleArguments("Asset " + asset + " not contained in asset list")
#Initialize binary variable array
mdl = AdvModel('docplex model')
mdl.init_numpy()
decision_vars = np.array([])
to_choose_assets = np.zeros(len(assets))
for i in range(len(assets)):
curr_asset = assets[i]
if curr_asset in assets_to_include:
to_choose_assets[i]=1
decision_vars = np.append(decision_vars,[mdl.binary_var(str(curr_asset))])
#Terms
vec_ones = np.ones(len(decision_vars)) #helper vector
num_assets_chosen = np.matmul(vec_ones.T,decision_vars)
num_necessary_assets_chosen = np.matmul(to_choose_assets.T,decision_vars)
expected_num_assets_chosen = len(assets_to_include)
expected_returns_portfolio = np.matmul(mu.T,decision_vars)
variance_portfolio = np.matmul(decision_vars.T,np.dot(sigma,decision_vars)) / 2
#Objective function
mdl.minimize(
- expected_returns_portfolio
+ (risk_aversion * variance_portfolio)
+ penalty * ((expected_num_assets_chosen - num_necessary_assets_chosen)**2)
+ penalty*(num_assets_chosen - num_assets_portfolio)**2)
qubo = QuadraticProgram()
qubo.from_docplex(mdl)
if DEBUG:
print(mdl.export_as_lp_string())
return qubo
|
https://github.com/duartefrazao/Quantum-Finance-Algorithms
|
duartefrazao
|
from qiskit import Aer
from qiskit.circuit.library import TwoLocal
from qiskit.aqua import QuantumInstance
from qiskit.optimization.applications.ising.common import sample_most_likely
from qiskit.aqua.algorithms import VQE, QAOA, NumPyMinimumEigensolver
from qiskit.aqua.components.optimizers import COBYLA
from aux_functions import IncompatibleArguments
import numpy as np
import matplotlib.pyplot as plt
# initialization
import numpy as np
# importing Qiskit
from qiskit import IBMQ, Aer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, assemble, transpile
# import basic plot tools
from qiskit.visualization import plot_histogram
#Quadratic
from qiskit.optimization import QuadraticProgram
from docplex.mp.advmodel import AdvModel
sector_dictinary = {
"tech":["AAPL","MSFT"],
"automotive":["TSLA","GM"],
"consumer":["JWN","NKE"]
}
def portfolio_optimization(assets,sectors_to_favour,mu,sigma,num_assets_portfolio,risk_aversion,penalty):
if len(mu) != sigma.shape[0] or len(mu) != sigma.shape[1] or len(mu) != len(assets):
raise IncompatibleArguments("Sigma, mu and assets need to be equal in size")
if not 0 <= risk_aversion <= 1:
raise IncompatibleArguments("Risk aversion needs to be in [0,1]")
if not 0 < num_assets_portfolio <= len(assets):
raise IncompatibleArguments("Number of assets to include in the portfolio needs to be smaller or equal to the number of assets passed")
#Join dictionary stocks to make lookup easy
stocks_in_sectors_to_favour = []
for sector in sector_dictinary:
if sector in sectors_to_favour:
stocks_in_sectors_to_favour = stocks_in_sectors_to_favour + sector_dictinary[sector]
#Initialize binary variable array
mdl = AdvModel('docplex model')
mdl.init_numpy()
decision_vars = np.array([])
to_favour_sector = np.zeros(len(assets))
for i in range(len(assets)):
curr_asset = assets[i]
if curr_asset in stocks_in_sectors_to_favour:
to_favour_sector[i]=1
decision_vars = np.append(decision_vars,[mdl.binary_var(str(curr_asset))])
#Terms
vec_ones = np.ones(len(decision_vars)) #helper vector
num_assets_chosen = np.matmul(vec_ones.T,decision_vars)
num_stocks_chosen_from_sectors_to_favour = np.matmul(to_favour_sector.T,decision_vars)
expected_returns_portfolio = np.matmul(mu.T,decision_vars)
variance_portfolio = np.matmul(decision_vars.T,np.dot(sigma,decision_vars)) / 2
#Objective function
mdl.minimize(- expected_returns_portfolio
+ (risk_aversion * variance_portfolio)
- penalty * num_stocks_chosen_from_sectors_to_favour
+ penalty * (num_assets_chosen - num_assets_portfolio)**2)
qubo = QuadraticProgram()
qubo.from_docplex(mdl)
return qubo
|
https://github.com/duartefrazao/Quantum-Finance-Algorithms
|
duartefrazao
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2018, 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
import numpy as np
from functools import reduce
from qiskit import QuantumRegister, QuantumCircuit
from qiskit.quantum_info import Pauli
from qiskit.aqua import Operator
class QAOAVarForm:
"""Global X phases and parameterized problem hamiltonian."""
def __init__(self, cost_operator, p, initial_state=None, mixer_operator=None):
self._cost_operator = cost_operator
self._p = p
self._initial_state = initial_state
self.num_parameters = 2 * p
self.parameter_bounds = [(0, np.pi)] * p + [(0, 2 * np.pi)] * p
self.preferred_init_points = [0] * p * 2
# prepare the mixer operator
v = np.zeros(self._cost_operator.num_qubits)
ws = np.eye(self._cost_operator.num_qubits)
if mixer_operator is None:
self._mixer_operator = reduce(
lambda x, y: x + y,
[
Operator([[1, Pauli(v, ws[i, :])]])
for i in range(self._cost_operator.num_qubits)
]
)
else:
if not type(mixer_operator) == Operator:
raise TypeError('The mixer should be a qiskit.aqua.Operator '
+ 'object, found {} instead'.format(type(mixer_operator)))
self._mixer_operator = mixer_operator
def construct_circuit(self, angles):
if not len(angles) == self.num_parameters:
raise ValueError('Incorrect number of angles: expecting {}, but {} given.'.format(
self.num_parameters, len(angles)
))
circuit = QuantumCircuit()
if self._initial_state:
circuit += self._initial_state.construct_circuit('circuit')
if len(circuit.qregs) == 0:
q = QuantumRegister(self._cost_operator.num_qubits, name='q')
circuit.add_register(q)
elif len(circuit.qregs) == 1:
q = circuit.qregs[0]
else:
raise NotImplementedError
circuit.u2(0, np.pi, q)
for idx in range(self._p):
beta, gamma = angles[idx], angles[idx + self._p]
circuit += self._cost_operator.evolve(
evo_time=gamma, evo_mode='circuit', num_time_slices=1, quantum_registers=q
)
circuit += self._mixer_operator.evolve(
evo_time=beta, evo_mode='circuit', num_time_slices=1, quantum_registers=q
)
return circuit
@property
def setting(self):
ret = "Variational Form: {}\n".format(self.__class__.__name__)
params = ""
for key, value in self.__dict__.items():
if key != "_configuration" and key[0] == "_":
params += "-- {}: {}\n".format(key[1:], value)
ret += "{}".format(params)
return ret
|
https://github.com/duartefrazao/Quantum-Finance-Algorithms
|
duartefrazao
|
from qiskit import QuantumCircuit
from qiskit import transpiler
from qiskit import Aer,BasicAer,execute,execute_function
import time
import math
#circ.measure(1,1)
backend = Aer.get_backend('aer_simulator')
means = {
"h":0,
"cx":0,
"x":0,
"rx":0,
"rz":0,
"sdg":0
}
iterations = 3
sleep_time = 0.2
#Hadamard
times = 0
for i in range(iterations):
circ = QuantumCircuit(1,1)
circ.h(0)
circ.measure(0,0)
job = execute(circ, backend)
times = times + job.result().time_taken
time.sleep(sleep_time)
means['h'] = 100*times/iterations
#X
times = 0
for i in range(iterations):
circ = QuantumCircuit(1,1)
circ.x(0)
circ.measure(0,0)
job = execute(circ, backend)
times = times + job.result().time_taken
time.sleep(sleep_time)
means['x'] = 100*times/iterations
#RZ
times = 0
for i in range(iterations):
circ = QuantumCircuit(1,1)
circ.rz(math.pi/2,0)
circ.measure(0,0)
job = execute(circ, backend)
times = times + job.result().time_taken
time.sleep(sleep_time)
means['rz'] = 100*times/iterations
#RX
times = 0
for i in range(iterations):
circ = QuantumCircuit(1,1)
circ.rx(math.pi/2,0)
circ.measure(0,0)
job = execute(circ, backend)
times = times + job.result().time_taken
time.sleep(sleep_time)
means['rx'] = 100*times/iterations
#CX
times = 0
for i in range(iterations):
circ = QuantumCircuit(2,2)
circ.cx(0,1)
circ.measure(0,0)
circ.measure(1,1)
job = execute(circ, backend)
times = times + job.result().time_taken
time.sleep(sleep_time)
means['cx'] = 100*times/iterations
#SDG
times = 0
for i in range(iterations):
circ = QuantumCircuit(1,1)
circ.sdg(0)
circ.measure(0,0)
job = execute(circ, backend)
times = times + job.result().time_taken
time.sleep(sleep_time)
means['sdg'] = 100*times/iterations
f = open('gate_costs.txt', 'w')
for gate in means:
f.write(gate + ((4-len(gate))*" ") + "- " +str(means[gate]) + "\n")
f.close()
backend = BasicAer.get_backend('qasm_simulator')
from time import time
circ = QuantumCircuit(1,1)
circ.h(0)
job = execute(circ, backend)
times = job.result().time_taken
print(times)
|
https://github.com/duartefrazao/Quantum-Finance-Algorithms
|
duartefrazao
|
"""
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/TuomasLe/Extended-basis-encoding-and-amplitude-encoding-algorithms-for-Qiskit
|
TuomasLe
|
from qiskit import IBMQ
IBMQ.load_account()
%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 *
from qiskit.circuit.library.standard_gates import RYGate
from qiskit.circuit import Parameter
provider = IBMQ.load_account()
from qiskit import QuantumCircuit, IBMQ, execute, Aer, QuantumRegister, ClassicalRegister
from qiskit.providers.ibmq import least_busy
from qiskit.tools.monitor import job_monitor,backend_overview
from qiskit.visualization import plot_histogram
import math
def parabola(l):
data_ = []
for i in range(l):
value = math.pow(l/2, 2) - math.pow(abs(i - l/2), 2)
print(value)
data_.append(value)
return data_
def sine(l):
data_ = []
for i in range(l):
value = 1 + math.sin(((i/(l/720)) / 180) * math.pi)
print(value)
data_.append(value)
return data_
def pi(l):
the_pi = "3141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481117450284102701938521105559644622948954930381964428810975665933446128475648233786783165271201909145648566923460348610454326648213393607260249141273724587006606315588174881520920962829254091715364367892590360011330530548820466521384146951941511609433057270365759591953092186117381932611793105118548074462379962749567351885752724891227938183011949129833673362440656643086021394946395224737190702179860943702770539217176293176752384674818467669405132000568127145263560827785771342757789609173637178721468440901224953430146549585371050792279689258923542019956112129021960864034418159813629774771309960518707211349999998372978049951059731732816096318595024459455346908302642522308253344685035261931188171010003137838752886587533208381420617177669147303598253490428755468731159562863882353787593751957781857780532171226806613001927876611195909216420198938095257201065485863278865936153381827968230301952035301852968995773622599413891249721775283479131515574857242454150695950829533116861727855889075098381754637464939319255060400927701671139009848824012858361603563707660104710181942955596198946767"
data_ = []
for i in range(l):
value = int(the_pi[i])
data_.append(value)
return data_
def normalizeData(data_points):
divider = 0
sum = 0
print("Amplitudes: ")
for point in data_points:
divider += math.pow(point, 2)
divider = math.sqrt(divider)
normalized = []
for i in range(len(data_points)):
x = data_points[i] / divider
x2 = math.pow(data_points[i] / divider, 2)
print(round(x2, 3))
sum += x2
normalized.append(x)
return (normalized, divider)
def gen_angles(data):
if len(data) > 1:
new_length = int(len(data) / 2)
new_data = []
for k in range(new_length):
new_data.append(math.sqrt(math.pow(data[2*k], 2) + math.pow(data[2*k + 1], 2)))
#print("value")
#print(new_data)
inner_angles:List[float] = gen_angles(new_data)
angles = []
for k in range(len(new_data)):
if new_data[k] != 0:
inside = data[2*k + 1] / new_data[k]
print(round(inside, 4))
if (data[2*k] > 0):
angles.append(2 * math.asin(inside))
else:
angles.append(2 * math.pi - 2 * math.asin(inside))
else:
angles.append(0.0)
angles = inner_angles + angles
return angles
else:
return []
def getCtrlState(level, k):
ctrl_decimal = int(abs(k - (math.pow(2, level) - 1)))
ctrl_bin = str(bin(ctrl_decimal))
ctrl_str = ctrl_bin.split('b')[1].zfill(level)
ctrl_str = ''.join(reversed(ctrl_str)) ### Reverse because of Qiskit's most significant bit convention
return ctrl_str
### Main program
pi_result = True # change to true if using pi() function
data_length = 32 # this must be powers of two
data_points = pi(data_length) # 2^n long data vector, can also be changed manually or using the test functions
pair = normalizeData(data_points)
data = pair[0]
key = pair[1]
print("Key")
print(key)
print("")
print("Angles: ")
angles = gen_angles(data)
nqubits = int(math.log2(len(data_points)))
nclassical = nqubits
q = QuantumRegister(nqubits)
c = ClassicalRegister(nclassical)
circ = QuantumCircuit(q, c)
a = Parameter('a')
CCRY = RYGate(a).control(2, ctrl_state = '10') # example how to create multi-qubit controlled ry gate
print("Levels:")
for k in range(len(angles)):
j = 0
if (k > 0):
j = int(math.log2(k + 1)) # level in the binary tree
print(j)
if (j == 0):
circ.ry(angles[k], nqubits - 1 - j)
if (k == 1):
circ.cry(angles[k], nqubits - 1, nqubits - 1 - j, ctrl_state = 0)
elif(k == 2):
circ.cry(angles[k], nqubits - 1, nqubits - 1 - j, ctrl_state = 1)
elif(k > 2):
ctrl = getCtrlState(j, k)
CCRY = RYGate(angles[k]).control(j, ctrl_state = ctrl)
qubits = []
for i in range(j + 1):
qubits.append(nqubits - 1 - i)
circ.append(CCRY, qubits)
circ.barrier()
circ.measure(q, c)
circ.draw(output='mpl')
provider = IBMQ.get_provider()
provider.backends()
local_sim_backend = Aer.get_backend('qasm_simulator')
sim_backend = provider.get_backend('ibmq_qasm_simulator')
real_backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= nqubits
and not x.configuration().simulator
and x.status().operational==True))
print("least busy backend: ", real_backend)
print(real_backend)
job1 = execute(circ,local_sim_backend)
job2 = execute(circ,sim_backend)
job3 = execute(circ,real_backend)
job_monitor(job3)
counts1 = job1.result().get_counts()
counts2 = job2.result().get_counts()
counts3 = job3.result().get_counts()
test_job = job2 # the job which results get printed
test_counts = counts2 # the counts for the same job as above
shots = test_job.result().to_dict()["results"][0]["shots"]
time_taken = test_job.result().time_taken
print("Time taken: ", time_taken)
measured_results = []
binaries = sorted(test_counts.keys())
if (pi_result):
for dict_key in binaries:
binary_state = dict_key
print(binary_state, end = ' | ')
measured_result = math.sqrt(test_counts[''.join(binary_state)] / shots) * key
measured_results.append(measured_result)
print("%3.3f" % measured_result, end = ' \n')
str_result = ""
for k in range(len(measured_results)):
if (k == 0):
str_result = str_result + str(round(measured_results[k]))
str_result = str_result + "."
else:
str_result = str_result + str(round(measured_results[k]))
print(str_result)
legend = ['Local simulator', 'Remote simulator', 'Real processor']
circ.draw()
plot_histogram([counts1, counts2, counts3], legend=legend, bar_labels = True)
the_pi = "3.141592653589793238462643383279502884197169399"
|
https://github.com/TuomasLe/Extended-basis-encoding-and-amplitude-encoding-algorithms-for-Qiskit
|
TuomasLe
|
from qiskit import IBMQ
IBMQ.load_account()
%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 *
provider = IBMQ.load_account()
from qiskit import QuantumCircuit, IBMQ, execute, Aer, QuantumRegister, ClassicalRegister, AncillaRegister
from qiskit.providers.ibmq import least_busy
from qiskit.tools.monitor import job_monitor,backend_overview
from qiskit.visualization import plot_histogram
from qiskit.quantum_info.states.statevector import Statevector
from qiskit.circuit.library.standard_gates import RYGate, CXGate, XGate
from qiskit.circuit import Parameter
import math
data = ['1111', '1111'] ### each data value must have the same length, but the length can be changed
### the length of the data vector must be a power of two
nancilla = int(math.log2(len(data)))
print(nancilla)
nqubits = len(data[0]) + nancilla
nclassical = nqubits
q = QuantumRegister(nqubits)
c = ClassicalRegister(nclassical)
# anc = AncillaRegister(nancilla)
circ = QuantumCircuit(q, c)
def getCtrlState(j, ancillalength):
ctrl_bin = str(bin(j))
ctrl_str = ctrl_bin.split('b')[1].zfill(ancillalength)
ctrl_str = ''.join(reversed(ctrl_str)) ### Reverse because of Qiskit's most significant bit convention
return ctrl_str
maxqubit = nqubits - 1
max_encodable_qubit = maxqubit - nancilla
for h in range(nancilla):
circ.h(maxqubit - h)
for i in range(len(data[0])):
for j in range(len(data)):
if (data[j][i] == '1'):
ctrl = getCtrlState(j, nancilla)
cx0 = XGate().control(nancilla, ctrl_state = ctrl)
ancillaqubits = []
for k in range(nancilla):
ancillaqubits.append(maxqubit - k)
ancillaqubits.append(max_encodable_qubit - i)
circ.append(cx0, ancillaqubits)
circ.barrier()
circ.measure(q, c)
circ.draw(output='mpl')
provider = IBMQ.get_provider()
provider.backends()
local_sim_backend = Aer.get_backend('qasm_simulator')
sim_backend = provider.get_backend('ibmq_qasm_simulator')
real_backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= nqubits
and not x.configuration().simulator
and x.status().operational==True))
print("least busy backend: ", real_backend)
print(real_backend)
job1 = execute(circ,local_sim_backend)
job2 = execute(circ,sim_backend)
job3 = execute(circ,real_backend)
job_monitor(job3)
counts1 = job1.result().get_counts()
counts2 = job2.result().get_counts()
counts3 = job3.result().get_counts()
legend = ['Local simulator', 'Remote simulator', 'Real processor']
circ.draw()
plot_histogram([counts1, counts2, counts3], legend=legend)
|
https://github.com/mickahell/quantum_pokemon-fight
|
mickahell
|
%pip install qiskit
%pip install qiskit[visualization]
%pip install numpy
%pip install matplotlib
import math
from random import *
from IPython.display import Image, display, YouTubeVideo
import numpy as np
import qiskit
from qiskit import Aer, QuantumCircuit, execute, IBMQ, QuantumRegister, ClassicalRegister
from qiskit.visualization import plot_histogram, plot_bloch_multivector
qiskit.__qiskit_version__
# Initialize Qasm simulator backend
qasm = Aer.get_backend('qasm_simulator')
# Initialize Real Quantum computer
# If you run qiskit on a real computer for the first time, you will need to create an account on https://quantum-computing.ibm.com/login
# and run the following line with you token.
#IBMQ.save_account('MY_API_TOKEN')
IBMQ.load_account()
provider = IBMQ.get_provider('ibm-q')
quantum_computer = provider.get_backend('ibmq_16_melbourne')
# Here we will use the local simulator --> Aer
backend_sim = qasm # Choose your backend : <quantum_computer> or <qasm>
YouTubeVideo('C19O5xm51dk')
Image("images_jupyter/structure.png", width="700")
attack = 0.7 # Accuracy of the attack, most of the attacks are of precision 100%, 90% or 70%
crit = 0.0417 # Critical
burn = 0.1
poison = 0.3
para = 0.3
freeze = 0.1
speedtie = 0.5
qc = QuantumCircuit(1, 1)
qc.rx(math.pi * attack, 0) # The gate RX is like a NOT gate which allows us to define the angle theta and apply rotation
qc.measure(0, 0)
qc.draw()
job = execute(qc, backend_sim, shots=1, memory=True)
result_job = job.result().get_memory()
to_return = int(result_job[0], 2)
if to_return == 1:
print("Result : {}, the attack succeeded!".format(to_return))
else:
print("Result : {}, the attack missed the target!".format(to_return))
Image("images_jupyter/types_graph.png", width="500")
def diffuser(nqubits):
qc = QuantumCircuit(nqubits)
for qubit in range(nqubits):
qc.h(qubit)
for qubit in range(nqubits):
qc.x(qubit)
qc.h(nqubits - 1)
qc.mct(list(range(nqubits - 1)), nqubits - 1)
qc.h(nqubits - 1)
for qubit in range(nqubits):
qc.x(qubit)
for qubit in range(nqubits):
qc.h(qubit)
U_s = qc.to_gate()
U_s.name = "$Diff$"
return U_s
algo = QuantumRegister(3, 'algo')
oracle = QuantumRegister(1, 'oracle')
c = ClassicalRegister(3, 'measurement')
qc = QuantumCircuit(algo, oracle, c)
qc.append(diffuser(3), [0, 1, 2])
qc.draw()
algo = QuantumRegister(3, 'algo')
oracle = QuantumRegister(1, 'oracle')
c = ClassicalRegister(3, 'measurement')
qc = QuantumCircuit(algo, oracle, c)
# Init
qc.h(algo)
qc.x(oracle)
qc.h(oracle)
qc.barrier()
# Algorithm
qc.mcx(algo, oracle)
qc.barrier()
# Diffuser
qc.append(diffuser(3), [0, 1, 2])
# Measure of the ouputs
qc.barrier()
qc.measure(algo, c)
qc.draw()
job = execute(qc, backend_sim, shots=512)
result_job = job.result()
plot_histogram(result_job.get_counts())
# We have our Blastoise (Tortank in French) with 4 attacks : hydroblast, earthquake, ice beam, giga-impact
# We want to map all our attacks to their respective type(s) like:
# [hydroblast : water, earthquake : ground , ice beam : ice , giga-impact : normal]
# Init register
qram_q = QuantumRegister(2, 'qram') # We have 4 elements to map to 2 qubits are enough
normal_q = QuantumRegister(1, 'normal')
fire_q = QuantumRegister(1, 'fire')
grass_q = QuantumRegister(1, 'grass')
ground_q = QuantumRegister(1, 'ground')
fly_q = QuantumRegister(1, 'fly')
water_q = QuantumRegister(1, 'water')
elec_q = QuantumRegister(1, 'electric')
ice_q = QuantumRegister(1, 'ice')
bug_q = QuantumRegister(1, 'bug')
steel_q = QuantumRegister(1, 'steel')
qc_init = QuantumCircuit(qram_q)
# Init qubits
qc_init.h(qram_q) # Init our inputs to superposition
#qc.barrier()
qc_qram = QuantumCircuit(qram_q, normal_q, fire_q, grass_q, ground_q, fly_q, water_q, elec_q, ice_q, bug_q, steel_q, c)
# Mapping attacks
## First attack is going to be on the address 00, hydroblast
qc_qram.x(qram_q)
qc_qram.ccx(qram_q[0], qram_q[1], water_q)
qc_qram.x(qram_q)
qc_qram.barrier()
## Second attack -> 01, earthquake
qc_qram.x(qram_q[0])
qc_qram.ccx(qram_q[0], qram_q[1], ground_q)
qc_qram.x(qram_q[0])
qc_qram.barrier()
## Third attack -> 10, ice beam
qc_qram.x(qram_q[1])
qc_qram.ccx(qram_q[0], qram_q[1], ice_q)
qc_qram.x(qram_q[1])
qc_qram.barrier()
## Fourth attack -> 11, giga impact
qc_qram.ccx(qram_q[0], qram_q[1], normal_q)
qc_qram.barrier()
qc_initQram = qc_init + qc_qram
qc_initQram.draw()
c = ClassicalRegister(8, 'measure')
qram_measure = QuantumCircuit(c)
qc = qc_initQram + qram_measure
qc.measure(range(8), range(8))
qc = qc.reverse_bits()
job = execute(qc, backend_sim, shots=512)
result_job = job.result()
plot_histogram(result_job.get_counts())
# Init type qubits
fire_q = QuantumRegister(1, 'fire')
grass_q = QuantumRegister(1, 'grass')
ground_q = QuantumRegister(1, 'ground')
fly_q = QuantumRegister(1, 'fly')
water_q = QuantumRegister(1, 'water')
elec_q = QuantumRegister(1, 'electrick')
ice_q = QuantumRegister(1, 'ice')
bug_q = QuantumRegister(1, 'bug')
steel_q = QuantumRegister(1, 'steel')
qc_types = QuantumCircuit(fire_q, grass_q, ground_q, fly_q, water_q, elec_q, ice_q, bug_q, steel_q)
# Init charizard
fire_weak = [water_q, ground_q]
fly_weak = [elec_q, ice_q]
fire_resist = [fire_q, bug_q, grass_q, steel_q, ice_q]
fly_resist = [grass_q, bug_q]
fire_immune = ["None"]
fly_immune = [ground_q]
# Charamenter type map
weakFire_q = QuantumRegister(1, 'weak_fire')
weakFly_q = QuantumRegister(1, 'weak_fly')
checkWeak_q = QuantumRegister(1, 'check_weak')
resistFire_q = QuantumRegister(1, 'resist_fire')
resistFly_q = QuantumRegister(1, 'resist_fly')
immuneFire_q = QuantumRegister(1, 'immunity_fire')
immuneFly_q = QuantumRegister(1, 'immunity_fly')
qc_charizard = QuantumCircuit(weakFire_q, weakFly_q, checkWeak_q, resistFire_q, resistFly_q, immuneFire_q, immuneFly_q)
qc_defenderMapping = qc_types + qc_charizard
# Apply gates
## Weakness
if fire_weak[0] != "None":
for i in fire_weak:
qc_defenderMapping.cx(i, weakFire_q)
if fly_weak[0] != "None":
for i in fly_weak:
qc_defenderMapping.cx(i, weakFly_q)
qc_defenderMapping.barrier()
## Resistances
if fire_resist[0] != "None":
for i in fire_resist:
qc_defenderMapping.cx(i, resistFire_q)
if fly_resist[0] != "None":
for i in fly_resist:
qc_defenderMapping.cx(i, resistFly_q)
qc_defenderMapping.barrier()
## Immunity
if fire_immune[0] != "None":
for i in fire_immune:
qc_defenderMapping.cx(i, immuneFire_q)
if fly_immune[0] != "None":
for i in fly_immune:
qc_defenderMapping.cx(i, immuneFly_q)
# Check of the weakness
def or_weak(qc):
qc.barrier()
qc.cx(weakFire_q[0], checkWeak_q[0])
qc.cx(weakFly_q[0], checkWeak_q[0])
qc.ccx(weakFly_q[0], weakFire_q[0], checkWeak_q[0])
qc.barrier()
qc_orweak = qc_types + qc_charizard
or_weak(qc_orweak)
(qc_defenderMapping + qc_orweak).draw()
qc_algo = qc_init + qc_qram + qc_defenderMapping + qc_orweak
qc_algo.draw()
oracle_q = QuantumRegister(1, 'oracle')
qc_oracle = QuantumCircuit(oracle_q)
qc_oracle.x(oracle_q)
qc_oracle.h(oracle_q)
# Glueing everything together
qc_finale = qc_oracle + qc_init + qc_qram + qc_defenderMapping + qc_orweak
qc_finale.x([resistFire_q[0], resistFly_q[0], immuneFire_q[0], immuneFly_q[0]])
qc_finale.mcx([checkWeak_q, resistFire_q, resistFly_q, immuneFire_q, immuneFly_q], oracle_q)
qc_finale.x([resistFire_q[0], resistFly_q[0], immuneFire_q[0], immuneFly_q[0]])
qc_finale.barrier()
qc_finale.draw()
def diffuser(nqubits):
qc = QuantumCircuit(nqubits)
for qubit in range(nqubits):
qc.h(qubit)
for qubit in range(nqubits):
qc.x(qubit)
qc.h(nqubits - 1)
qc.mct(list(range(nqubits - 1)), nqubits - 1)
qc.h(nqubits - 1)
for qubit in range(nqubits):
qc.x(qubit)
for qubit in range(nqubits):
qc.h(qubit)
U_s = qc.to_gate()
U_s.name = "$U_s$"
return qc
qc_finale = qc_oracle + qc_init
for i in range(1):
qc_finale = qc_finale + qc_qram + qc_defenderMapping + qc_orweak
qc_finale.x([resistFire_q[0], resistFly_q[0], immuneFire_q[0], immuneFly_q[0]])
qc_finale.mcx([checkWeak_q, resistFire_q, resistFly_q, immuneFire_q, immuneFly_q], oracle_q)
qc_finale.x([resistFire_q[0], resistFly_q[0], immuneFire_q[0], immuneFly_q[0]])
qc_finale = qc_finale + qc_orweak + qc_defenderMapping + qc_qram
qc_finale.append(diffuser(2), [1, 2])
qc_finale.barrier()
qc_finale.measure(qram_q, range(2))
qc_finale.draw()
qc = qc_finale.reverse_bits()
job = execute(qc, backend_sim, shots=512)
result_job = job.result()
plot_histogram(result_job.get_counts())
oracle_q = QuantumRegister(1, 'oracle')
qram_q = QuantumRegister(2, 'qram')
fire_q = QuantumRegister(1, 'fire')
grass_q = QuantumRegister(1, 'grass')
ground_q = QuantumRegister(1, 'ground')
fly_q = QuantumRegister(1, 'fly')
water_q = QuantumRegister(1, 'water')
elec_q = QuantumRegister(1, 'electrick')
ice_q = QuantumRegister(1, 'ice')
bug_q = QuantumRegister(1, 'bug')
steel_q = QuantumRegister(1, 'steel')
normal_q = QuantumRegister(1, 'normal')
resistFire_q = QuantumRegister(1, 'resist_fire')
resistFly_q = QuantumRegister(1, 'resist_fly')
immuneFire_q = QuantumRegister(1, 'immunity_fire')
immuneFly_q = QuantumRegister(1, 'immunity_fly')
weakFire_q = QuantumRegister(1, 'weak_fire')
weakFly_q = QuantumRegister(1, 'weak_fly')
checkWeak_q = QuantumRegister(1, 'check_weak')
c = ClassicalRegister(2, 'measure')
qc = QuantumCircuit(oracle_q, qram_q, fire_q, grass_q, ground_q, fly_q, water_q, elec_q, ice_q, bug_q,
steel_q, normal_q, resistFire_q, resistFly_q, immuneFire_q, immuneFly_q,
weakFire_q, weakFly_q, checkWeak_q, c)
def qram(nqubits):
qc = QuantumCircuit(nqubits)
U_s = qc.to_gate()
U_s.name = "$QRAM$"
return U_s
def defenderMapping(nqubits):
qc = QuantumCircuit(nqubits)
U_s = qc.to_gate()
U_s.name = "$mappingChara$"
return U_s
def orweak(nqubits):
qc = QuantumCircuit(nqubits)
U_s = qc.to_gate()
U_s.name = "$weakCheck$"
return U_s
def diffuser(nqubits):
qc = QuantumCircuit(nqubits)
U_s = qc.to_gate()
U_s.name = "$diffuser$"
return U_s
# Init
qc.x(oracle_q)
qc.h(oracle_q)
qc.h(qram_q)
qc.barrier()
for i in range(1):
# Qram
qc.append(qram(12), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
# Algo
qc.append(defenderMapping(16), [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18])
qc.append(orweak(3), [17, 18, 19])
# Oracle
qc.barrier()
qc.x([resistFire_q[0], resistFly_q[0], immuneFire_q[0], immuneFly_q[0]])
qc.mcx([checkWeak_q, resistFire_q, resistFly_q, immuneFire_q, immuneFly_q], oracle_q)
qc.x([resistFire_q[0], resistFly_q[0], immuneFire_q[0], immuneFly_q[0]])
qc.barrier()
# Uncompute
qc.append(orweak(3), [17, 18, 19])
qc.append(defenderMapping(16), [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18])
qc.append(qram(12), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
# Diffuser
qc.append(diffuser(2), [1, 2])
qc.barrier()
qc.measure(qram_q, range(2))
qc.draw()
|
https://github.com/mickahell/quantum_pokemon-fight
|
mickahell
|
import math
from qiskit import QuantumCircuit, execute
def quantum_fight(psi, backend_sim):
qc = QuantumCircuit(1, 1)
qc.rx(math.pi * psi, 0)
qc.measure(0, 0)
job = execute(qc, backend_sim, shots=1, memory=True)
result_job = job.result().get_memory()
to_return = int(result_job[0], 2)
return to_return
def calcul_dommage(attac, pokemon_att, pokemon_def, backend_sim):
quantum_precision = quantum_fight(attac.precision, backend_sim)
if quantum_precision == 1:
STAB = 1
RESISTANCE = 1
CRIT = 1
if attac.type in pokemon_att.types:
STAB = 1.5
for i in pokemon_def.types:
if attac.type in i.weakness:
RESISTANCE *= 2
elif attac.type in i.resistance:
RESISTANCE *= 0.5
elif attac.type in i.imunite:
RESISTANCE *= 0
quantum_crit = quantum_fight(0.0417, backend_sim)
if quantum_crit == 1:
CRIT = 1.5
print("critical hit !")
if attac.status == "physical":
dommages = (
(
(
((100 * 0.4 + 2) * pokemon_att.points_attack * attac.power)
/ (pokemon_def.points_defense * 50)
)
+ 2
)
* STAB
* RESISTANCE
* CRIT
)
else:
dommages = (
(
(
((100 * 0.4 + 2) * pokemon_att.points_att_sp * attac.power)
/ (pokemon_def.points_def_sp * 50)
)
+ 2
)
* STAB
* RESISTANCE
* CRIT
)
if RESISTANCE > 1:
print("It's super efficient !")
if RESISTANCE < 1:
if RESISTANCE == 0:
print("{} is not affected by this attack !".format(pokemon_def.name))
else:
print("It is not very effective !")
if attac.type.name == "Poison" and RESISTANCE > 0:
if quantum_fight(0.3, backend_sim) == 1 and pokemon_def.malus == "None":
pokemon_def.malus = "poison"
print("{} is poisoned.".format(pokemon_def.name))
if attac.type.name == "Fire" and RESISTANCE > 0:
if quantum_fight(0.1, backend_sim) == 1 and pokemon_def.malus == "None":
pokemon_def.malus = "burn"
pokemon_def.points_attack *= 0.5
print("{} is burnt.".format(pokemon_def.name))
if attac.type.name == "Ice" and RESISTANCE > 0:
if quantum_fight(0.1, backend_sim) == 1 and pokemon_def.malus == "None":
pokemon_def.malus = "freeze"
print("{} is frozen.".format(pokemon_def.name))
if attac.type.name == "Electric" and RESISTANCE > 0:
if quantum_fight(0.3, backend_sim) == 1 and pokemon_def.malus == "None":
pokemon_def.malus = "paralysis"
pokemon_def.speed *= 0.5
print("{} is paralyzed.".format(pokemon_def.name))
else:
print("{} miss !".format(pokemon_att.name))
dommages = 0
return dommages
def action_attack(attaque, player_att, player_def, backend_sim):
player_att.action = 0
thaw = 1
paralysis = 1
if player_att.pokemon.malus == "freeze":
thaw = quantum_fight(0.2, backend_sim)
if thaw == 1:
print("{} is thawed.".format(player_att.pokemon.name))
player_att.pokemon.malus = "None"
else:
print("{} is still frozen.".format(player_att.pokemon.name))
if player_att.pokemon.malus == "paralysis":
paralysis = quantum_fight(0.75, backend_sim)
if paralysis == 0:
print("{} is paralyzed, he cannot attack.".format(player_att.pokemon.name))
if thaw == 1 and paralysis == 1:
print("{} is using {}".format(player_att.pokemon.name, attaque.name))
player_def.pokemon.dommages = player_def.pokemon.dommages + calcul_dommage(
attaque, player_att.pokemon, player_def.pokemon, backend_sim
)
if round(player_def.pokemon.pv - player_def.pokemon.dommages) < 0:
print(
"{} - 0 / {} pv".format(player_def.pokemon.name, player_def.pokemon.pv)
)
else:
print(
"{} - {} / {} pv".format(
player_def.pokemon.name,
round(player_def.pokemon.pv - player_def.pokemon.dommages),
player_def.pokemon.pv,
)
)
if player_def.pokemon.dommages >= player_def.pokemon.pv:
player_def.pokemon.status = 0
player_def.action = 0
def control_input(options, input_ctl):
if input_ctl is not None:
if 0 <= input_ctl < options:
return True
print("Please give a number between 0 and {}.".format(options - 1))
return False
|
https://github.com/mickahell/quantum_pokemon-fight
|
mickahell
|
from src.main import team, battle
from stats.data import stats, team_stats
from src.class_custom.attacks import Attack
from src.class_custom.player import Player
from src.class_custom.pokemon import Pokemon
from src.class_custom.type import Type
from qiskit import Aer, QuantumCircuit, QuantumRegister
import warnings
class Game:
def __init__(self):
warnings.filterwarnings("ignore", category=DeprecationWarning)
# Init Qasm simulator backend
qasm = Aer.get_backend("qasm_simulator")
backend_sim = qasm # Choose your backend : <quantum_computer> or <qasm>
# Types creation --> Sources : https://boutique-pokemon.com/blogs/blog-pokemon/table-types-pokemon
fire = Type("Fire")
normal = Type("Normal")
water = Type("Water")
grass = Type("Grass")
electric = Type("Electric")
fly = Type("Fly")
poison = Type("Poison")
bug = Type("Bug")
ghost = Type("Ghost")
ground = Type("Ground")
dark = Type("Dark")
ice = Type("Ice")
steel = Type("Steel")
resistance = [bug, grass, fire, ice, steel]
weakness = [water, ground]
imunite = ["None"]
fire.add_info(resistance, weakness, imunite)
resistance = ["None"]
weakness = ["None"]
imunite = [ghost]
normal.add_info(resistance, weakness, imunite)
resistance = [grass, ground]
weakness = [fire, fly]
imunite = ["None"]
bug.add_info(resistance, weakness, imunite)
resistance = [water, fire, steel]
weakness = [grass, electric]
imunite = ["None"]
water.add_info(resistance, weakness, imunite)
resistance = [water, electric, grass, ground]
weakness = [fire, bug, poison, fly, ice]
imunite = ["None"]
grass.add_info(resistance, weakness, imunite)
resistance = [electric, fly, steel]
weakness = [ground]
imunite = ["None"]
electric.add_info(resistance, weakness, imunite)
resistance = [bug, grass]
weakness = [electric, ice]
imunite = [ground]
fly.add_info(resistance, weakness, imunite)
resistance = [ghost, dark]
weakness = [bug]
imunite = ["None"]
dark.add_info(resistance, weakness, imunite)
resistance = [bug, poison]
weakness = [ghost, dark]
imunite = [normal]
ghost.add_info(resistance, weakness, imunite)
resistance = [bug, grass, poison]
weakness = [ground]
imunite = ["None"]
poison.add_info(resistance, weakness, imunite)
resistance = [poison]
weakness = [water, grass, ice]
imunite = [electric]
ground.add_info(resistance, weakness, imunite)
resistance = [ice]
weakness = [fire, steel]
imunite = ["None"]
ice.add_info(resistance, weakness, imunite)
resistance = [steel, ice, bug, normal, grass, fly]
weakness = [fire, ground]
imunite = [poison]
steel.add_info(resistance, weakness, imunite)
# type qubits creation
fire.qubit = QuantumRegister(1, "fire")
normal.qubit = QuantumRegister(1, "normal")
water.qubit = QuantumRegister(1, "water")
grass.qubit = QuantumRegister(1, "grass")
electric.qubit = QuantumRegister(1, "electric")
fly.qubit = QuantumRegister(1, "fly")
poison.qubit = QuantumRegister(1, "poison")
bug.qubit = QuantumRegister(1, "bug")
ghost.qubit = QuantumRegister(1, "ghost")
ground.qubit = QuantumRegister(1, "ground")
dark.qubit = QuantumRegister(1, "dark")
ice.qubit = QuantumRegister(1, "ice")
steel.qubit = QuantumRegister(1, "steel")
qc_type = QuantumCircuit(
steel.qubit,
fire.qubit,
normal.qubit,
water.qubit,
grass.qubit,
electric.qubit,
fly.qubit,
poison.qubit,
bug.qubit,
ghost.qubit,
ground.qubit,
dark.qubit,
ice.qubit,
)
# Attacks creation
fire_blast = Attack("Fire Blast", fire, 110, 0.85, "special")
hurricane = Attack("Hurricane", fly, 110, 0.70, "special")
earthquake = Attack("Earthquake", ground, 100, 1, "physical")
leaf_storm = Attack("Leaf Storm", grass, 90, 1, "special")
shadow_ball = Attack("Shadow Ball", ghost, 80, 1, "special")
sludge_bomb = Attack("Sludge Bomb", poison, 90, 1, "special")
thunder = Attack("Thunder", electric, 110, 0.70, "special")
dark_pulse = Attack("Dark Pulse", dark, 80, 1, "special")
ice_beam = Attack("Ice Beam", ice, 90, 1, "special")
hydroblast = Attack("Hydroblast", water, 110, 0.8, "special")
iron_tail = Attack("Iron Tail", steel, 100, 0.75, "physical")
slam = Attack("Slam", normal, 80, 0.75, "physical")
grass_knot = Attack("Grass Knot", grass, 80, 1, "special")
flash_cannon = Attack("Flash Cannon", steel, 80, 1, "special")
giga_impact = Attack("Giga-Impact", normal, 150, 0.9, "physical")
bite = Attack("Bite", dark, 60, 1, "physical")
tri_attack = Attack("Triplattaque", normal, 80, 1, "special")
#hyper_beam = Attack("Hyper Beam", normal, 150, 0.9, "special")
throat_chop = Attack("Throat Chop", dark, 80, 1, "physical")
fire_punch = Attack("Fire Punch", fire, 75, 1, "physical")
# Pokémon creation --> Sources : https://www.pokepedia.fr/Pikachu#Statistiques-remarques1
charizard = Pokemon("Charizard", [fire, fly], 360, 267, 255, 317, 269, 299)
gengar = Pokemon("Gengar", [ghost, poison], 324, 229, 219, 359, 249, 319)
blastoise = Pokemon("Blastoise", [water], 362, 265, 299, 269, 309, 255)
pikachu = Pokemon("Pikachu", [electric], 294, 259, 199, 249, 219, 339)
glaceon = Pokemon("Glaceon", [ice], 334, 219, 319, 359, 289, 229)
porygonz = Pokemon("Porygon-Z", [normal], 374, 259, 239, 369, 249, 279)
abomasnow = Pokemon("Abomasnow", [grass, ice], 384, 283, 249, 283, 269, 219)
toxtricity = Pokemon(
"Toxtricity", [electric, poison], 354, 295, 239, 327, 239, 249
)
# Attacks learning
charizard.learn_attacks([fire_blast, hurricane, earthquake, leaf_storm])
gengar.learn_attacks([sludge_bomb, dark_pulse, shadow_ball, thunder])
blastoise.learn_attacks([ice_beam, hydroblast, flash_cannon, giga_impact])
pikachu.learn_attacks([thunder, iron_tail, slam, grass_knot])
glaceon.learn_attacks([ice_beam, slam, iron_tail, bite])
porygonz.learn_attacks([thunder, ice_beam, tri_attack, dark_pulse])
abomasnow.learn_attacks([ice_beam, leaf_storm, earthquake, giga_impact])
toxtricity.learn_attacks([sludge_bomb, thunder, throat_chop, fire_punch])
# Player creation
me = Player("Oak", "j1", "human")
him = Player("Agatha", "j2", "robot")
##############################################################
# GAME
print(
"""
###################################################
# Welcome in the Quantum Pokémon fight - CLI
# Will you succeed to win against the Quantum AI ?
#
# Good Luck !!!
###################################################
"""
)
team(me, him, nb_team=3)
winner, looser = battle(me, him, qc_type, backend_sim)
stats(winner.being)
team_stats(winner=winner.register_team, looser=looser.register_team)
print("The fight is over !")
str(input("Push enter to auto F5 the page") or "42")
|
https://github.com/mickahell/quantum_pokemon-fight
|
mickahell
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute
def quantum_attaq(attacker, defender, qc_type, backend_sim):
def diffuser(qc):
qc.h(qram_q)
qc.z(qram_q)
qc.cz(qram_q[0], qram_q[1])
qc.h(qram_q)
def or_weak(qc):
qc.barrier()
qc.cx(advweak_q[0], weakcheck_q[0])
qc.cx(advweak_q[1], weakcheck_q[0])
qc.ccx(advweak_q[1], advweak_q[0], weakcheck_q[0])
qc.barrier()
def or_resist(qc):
qc.barrier()
qc.cx(advresist_q[0], resistcheck_q[0])
qc.cx(advresist_q[1], resistcheck_q[0])
qc.ccx(advresist_q[1], advresist_q[0], resistcheck_q[0])
qc.barrier()
def immunite(defender, qc):
for i in defender.types:
if i.imunite[0] != "None":
qc.cx(i.imunite[0].qubit, immu_q)
def calcul_resist(defender, qc):
resist_count = 0
for i in defender.types:
for u in i.resistance:
if i.resistance[0] != "None":
qc.cx(u.qubit, advresist_q[resist_count])
resist_count += 1
def calcul_weak(defender, qc):
weak_count = 0
for i in defender.types:
for u in i.weakness:
if i.weakness[0] != "None":
qc.cx(u.qubit, advweak_q[weak_count])
weak_count += 1
def qram_att(attacker, qc):
# 00
qc.x(qram_q)
qc.ccx(qram_q[0], qram_q[1], attacker.attacks[0].type.qubit)
qc.x(qram_q)
# 01
qc.x(qram_q[1])
qc.ccx(qram_q[0], qram_q[1], attacker.attacks[1].type.qubit)
qc.x(qram_q[1])
# 10
qc.x(qram_q[0])
qc.ccx(qram_q[0], qram_q[1], attacker.attacks[2].type.qubit)
qc.x(qram_q[0])
# 11
qc.ccx(qram_q[0], qram_q[1], attacker.attacks[3].type.qubit)
qram_q = QuantumRegister(2, "attacks")
qc_qram = QuantumCircuit(qram_q)
advweak_q = QuantumRegister(2, "weakness_map")
weakcheck_q = QuantumRegister(1, "check_weakness")
advresist_q = QuantumRegister(2, "resistance_map")
resistcheck_q = QuantumRegister(1, "check_resistance")
immu_q = QuantumRegister(1, "immunity")
qc_weak = QuantumCircuit(advweak_q, weakcheck_q, advresist_q, resistcheck_q, immu_q)
check_q = QuantumRegister(1, "check")
out_q = QuantumRegister(1, "flag")
c = ClassicalRegister(2, "c")
qc_c = QuantumCircuit(check_q, out_q, c)
# Circuit final
qc = qc_qram + qc_type + qc_weak + qc_c
# Init
qc.h(qram_q)
qc.x(immu_q)
qc.x(resistcheck_q)
qc.x(out_q)
qc.h(out_q)
qc.barrier()
for i in range(1):
# Compute
qram_att(attacker, qc)
calcul_weak(defender, qc)
calcul_resist(defender, qc)
or_weak(qc)
or_resist(qc)
immunite(defender, qc)
# Flag
qc.mcx([weakcheck_q, resistcheck_q, immu_q], check_q)
qc.cx(check_q, out_q)
qc.mcx([weakcheck_q, resistcheck_q, immu_q], check_q)
# Uncompute
immunite(defender, qc)
or_resist(qc)
or_weak(qc)
calcul_resist(defender, qc)
calcul_weak(defender, qc)
qram_att(attacker, qc)
# Apply generic diffuser
diffuser(qc)
qc.measure(qram_q, c)
# Interprete result
job = execute(qc, backend_sim, shots=512, memory=True)
result_job = job.result().get_counts()
result_memory = job.result().get_memory()
if len(result_job) == 1:
to_return = int(result_memory[0], 2)
else:
to_return = max(result_job, key=result_job.get)
to_return = int(to_return, 2)
return to_return
def quantum_action(defender, attacker, qc_type, backend_sim):
def diffuser(qc):
qc.h(qram_q)
qc.z(qram_q)
qc.cz(qram_q[0], qram_q[1])
qc.h(qram_q)
def immunite(defender, qc):
for i in defender.types:
if i.imunite[0] != "None":
qc.cx(i.imunite[0].qubit, immu_q)
def calcul_resist(defender, qc):
resist_count = 0
for i in defender.types:
for u in i.resistance:
if i.resistance[0] != "None":
qc.cx(u.qubit, resist_q[resist_count])
resist_count += 1
def calcul_weak(defender, qc):
weak_count = 0
for i in defender.types:
for u in i.weakness:
if i.weakness[0] != "None":
qc.cx(u.qubit, weak_q[weak_count])
weak_count += 1
def or_weak(qc):
qc.barrier()
qc.cx(weak_q[0], weakcheck_q[0])
qc.cx(weak_q[1], weakcheck_q[0])
qc.ccx(weak_q[1], weak_q[0], weakcheck_q[0])
qc.barrier()
def qram_att(attacker, qc):
# 00
qc.x(qram_q)
qc.ccx(qram_q[0], qram_q[1], attacker.types[0].qubit)
qc.x(qram_q)
# 11
if len(attacker.types) > 1:
qc.ccx(qram_q[0], qram_q[1], attacker.types[1].qubit)
qram_q = QuantumRegister(2, "attacks")
qc_qram = QuantumCircuit(qram_q)
weak_q = QuantumRegister(2, "weakness_map")
weakcheck_q = QuantumRegister(1, "check_weakness")
resist_q = QuantumRegister(2, "resistance_map")
immu_q = QuantumRegister(1, "immunity")
qc_weak = QuantumCircuit(weak_q, weakcheck_q, resist_q, immu_q)
check_q = QuantumRegister(1, "check")
out_q = QuantumRegister(1, "flag")
c = ClassicalRegister(2, "c")
qc_c = QuantumCircuit(check_q, out_q, c)
# Circuit final
qc = qc_qram + qc_type + qc_weak + qc_c
# Init
qc.h(qram_q)
qc.x(resist_q)
qc.x(immu_q)
qc.x(out_q)
qc.h(out_q)
qc.barrier()
for i in range(1):
# Compute
qram_att(attacker, qc)
calcul_weak(defender, qc)
calcul_resist(defender, qc)
or_weak(qc)
immunite(defender, qc)
# Flag
qc.mcx([weakcheck_q, resist_q[0], resist_q[1], immu_q], check_q)
qc.cx(check_q, out_q)
qc.mcx([weakcheck_q, resist_q[0], resist_q[1], immu_q], check_q)
# Uncompute
immunite(defender, qc)
or_weak(qc)
calcul_resist(defender, qc)
calcul_weak(defender, qc)
qram_att(attacker, qc)
# Apply generic diffuser
diffuser(qc)
qc.measure(qram_q, c)
# Interprete result
job = execute(qc, backend_sim, shots=512, memory=True)
result_job = job.result().get_counts()
if len(result_job) == 1:
to_return = 1
else:
to_return = 0
return to_return
def quantum_switch(attacker, defender, qc_type, backend_sim):
def diffuser(nqubits):
qc = QuantumCircuit(nqubits)
for qubit in range(nqubits):
qc.h(qubit)
for qubit in range(nqubits):
qc.x(qubit)
qc.h(nqubits - 1)
qc.mct(list(range(nqubits - 1)), nqubits - 1)
qc.h(nqubits - 1)
for qubit in range(nqubits):
qc.x(qubit)
for qubit in range(nqubits):
qc.h(qubit)
U_s = qc.to_gate()
U_s.name = "$U_s$"
return qc
def immunite(defender, qc):
for i in defender.types:
if i.imunite[0] != "None":
qc.cx(i.imunite[0].qubit, immu_q)
def calcul_resist(defender, qc):
resist_count = 0
for i in defender.types:
for u in i.resistance:
if i.resistance[0] != "None":
qc.cx(u.qubit, resist_q[resist_count])
resist_count += 1
def calcul_weak(defender, qc):
weak_count = 0
for i in defender.types:
for u in i.weakness:
if i.weakness[0] != "None":
qc.cx(u.qubit, weak_q[weak_count])
weak_count += 1
def or_weak(qc):
qc.barrier()
qc.cx(weak_q[0], weakcheck_q[0])
qc.cx(weak_q[1], weakcheck_q[0])
qc.ccx(weak_q[1], weak_q[0], weakcheck_q[0])
qc.barrier()
def qram_att(attacker, qc):
# 0
qc.x(qrampoke_q)
# 00 0
qc.x(qramatt_q)
qc.mcx(
[qrampoke_q[0], qramatt_q[0], qramatt_q[1]],
attacker[0].attacks[0].type.qubit,
)
qc.x(qramatt_q)
# 01 0
qc.x(qramatt_q[1])
qc.mcx(
[qrampoke_q[0], qramatt_q[0], qramatt_q[1]],
attacker[0].attacks[1].type.qubit,
)
qc.x(qramatt_q[1])
# 10 0
qc.x(qramatt_q[0])
qc.mcx(
[qrampoke_q[0], qramatt_q[0], qramatt_q[1]],
attacker[0].attacks[2].type.qubit,
)
qc.x(qramatt_q[0])
# 11 0
qc.mcx(
[qrampoke_q[0], qramatt_q[0], qramatt_q[1]],
attacker[0].attacks[3].type.qubit,
)
qc.x(qrampoke_q)
# 1
if len(attacker) > 1:
# 00 1
qc.x(qramatt_q)
qc.mcx(
[qrampoke_q[0], qramatt_q[0], qramatt_q[1]],
attacker[1].attacks[0].type.qubit,
)
qc.x(qramatt_q)
# 01 1
qc.x(qramatt_q[1])
qc.mcx(
[qrampoke_q[0], qramatt_q[0], qramatt_q[1]],
attacker[1].attacks[1].type.qubit,
)
qc.x(qramatt_q[1])
# 10 1
qc.x(qramatt_q[0])
qc.mcx(
[qrampoke_q[0], qramatt_q[0], qramatt_q[1]],
attacker[1].attacks[2].type.qubit,
)
qc.x(qramatt_q[0])
# 11 1
qc.mcx(
[qrampoke_q[0], qramatt_q[0], qramatt_q[1]],
attacker[1].attacks[3].type.qubit,
)
qrampoke_q = QuantumRegister(1, "team")
qramatt_q = QuantumRegister(2, "attacks")
qc_qram = QuantumCircuit(qrampoke_q, qramatt_q)
weak_q = QuantumRegister(2, "weakness_map")
weakcheck_q = QuantumRegister(1, "check_weakness")
resist_q = QuantumRegister(2, "resistance_map")
immu_q = QuantumRegister(1, "immunite")
qc_weak = QuantumCircuit(weak_q, weakcheck_q, resist_q, immu_q)
check_q = QuantumRegister(1, "check")
out_q = QuantumRegister(1, "flag")
c = ClassicalRegister(1, "c")
qc_c = QuantumCircuit(check_q, out_q, c)
# Circuit final
qc = qc_qram + qc_type + qc_weak + qc_c
# Init
qc.h(qrampoke_q)
qc.h(qramatt_q)
qc.x(resist_q)
qc.x(immu_q)
qc.x(out_q)
qc.h(out_q)
qc.barrier()
for i in range(1):
# Compute
qram_att(attacker, qc)
calcul_weak(defender, qc)
calcul_resist(defender, qc)
or_weak(qc)
immunite(defender, qc)
# Flag
qc.mcx([weakcheck_q, resist_q[0], resist_q[1], immu_q], check_q)
qc.cx(check_q, out_q)
qc.mcx([weakcheck_q, resist_q[0], resist_q[1], immu_q], check_q)
# Uncompute
immunite(defender, qc)
or_weak(qc)
calcul_resist(defender, qc)
calcul_weak(defender, qc)
qram_att(attacker, qc)
# Apply generic diffuser
qc.append(diffuser(3), [0, 1, 2])
qc.measure(qrampoke_q, c)
# Interprete result
job = execute(qc, backend_sim, shots=512, memory=True)
result_job = job.result().get_counts()
result_memory = job.result().get_memory()
if len(result_job) == 1:
to_return = int(result_memory[0], 2)
else:
to_return = max(result_job, key=result_job.get)
to_return = int(to_return, 2)
return to_return
|
https://github.com/mickahell/quantum_pokemon-fight
|
mickahell
|
from train.robot_vs_robot import team, battle
from stats.gen_data import gen_team_data
from src.class_custom.attacks import Attack
from src.class_custom.player import Player
from src.class_custom.pokemon import Pokemon
from src.class_custom.type import Type
from qiskit import Aer, QuantumCircuit, QuantumRegister
import warnings
class Team:
def __init__(self):
warnings.filterwarnings("ignore", category=DeprecationWarning)
# Init Qasm simulator backend
qasm = Aer.get_backend("qasm_simulator")
backend_sim = qasm # Choose your backend : <quantum_computer> or <qasm>
for u in range(2):
# Types creation --> Sources : https://boutique-pokemon.com/blogs/blog-pokemon/table-types-pokemon
fire = Type("Fire")
normal = Type("Normal")
water = Type("Water")
grass = Type("Grass")
electric = Type("Electric")
fly = Type("Fly")
poison = Type("Poison")
bug = Type("Bug")
ghost = Type("Ghost")
ground = Type("Ground")
dark = Type("Dark")
ice = Type("Ice")
steel = Type("Steel")
resistance = [bug, grass, fire, ice, steel]
weakness = [water, ground]
imunite = ["None"]
fire.add_info(resistance, weakness, imunite)
resistance = ["None"]
weakness = ["None"]
imunite = [ghost]
normal.add_info(resistance, weakness, imunite)
resistance = [grass, ground]
weakness = [fire, fly]
imunite = ["None"]
bug.add_info(resistance, weakness, imunite)
resistance = [water, fire, steel]
weakness = [grass, electric]
imunite = ["None"]
water.add_info(resistance, weakness, imunite)
resistance = [water, electric, grass, ground]
weakness = [fire, bug, poison, fly, ice]
imunite = ["None"]
grass.add_info(resistance, weakness, imunite)
resistance = [electric, fly, steel]
weakness = [ground]
imunite = ["None"]
electric.add_info(resistance, weakness, imunite)
resistance = [bug, grass]
weakness = [electric, ice]
imunite = [ground]
fly.add_info(resistance, weakness, imunite)
resistance = [ghost, dark]
weakness = [bug]
imunite = ["None"]
dark.add_info(resistance, weakness, imunite)
resistance = [bug, poison]
weakness = [ghost, dark]
imunite = [normal]
ghost.add_info(resistance, weakness, imunite)
resistance = [bug, grass, poison]
weakness = [ground]
imunite = ["None"]
poison.add_info(resistance, weakness, imunite)
resistance = [poison]
weakness = [water, grass, ice]
imunite = [electric]
ground.add_info(resistance, weakness, imunite)
resistance = [ice]
weakness = [fire, steel]
imunite = ["None"]
ice.add_info(resistance, weakness, imunite)
resistance = [steel, ice, bug, normal, grass, fly]
weakness = [fire, ground]
imunite = [poison]
steel.add_info(resistance, weakness, imunite)
# type qubits creation
fire.qubit = QuantumRegister(1, "fire")
normal.qubit = QuantumRegister(1, "normal")
water.qubit = QuantumRegister(1, "water")
grass.qubit = QuantumRegister(1, "grass")
electric.qubit = QuantumRegister(1, "electric")
fly.qubit = QuantumRegister(1, "fly")
poison.qubit = QuantumRegister(1, "poison")
bug.qubit = QuantumRegister(1, "bug")
ghost.qubit = QuantumRegister(1, "ghost")
ground.qubit = QuantumRegister(1, "ground")
dark.qubit = QuantumRegister(1, "dark")
ice.qubit = QuantumRegister(1, "ice")
steel.qubit = QuantumRegister(1, "steel")
qc_type = QuantumCircuit(
steel.qubit,
fire.qubit,
normal.qubit,
water.qubit,
grass.qubit,
electric.qubit,
fly.qubit,
poison.qubit,
bug.qubit,
ghost.qubit,
ground.qubit,
dark.qubit,
ice.qubit,
)
# Attacks creation
fire_blast = Attack("Fire Blast", fire, 110, 0.85, "special")
hurricane = Attack("Hurricane", fly, 110, 0.70, "special")
earthquake = Attack("Earthquake", ground, 100, 1, "physical")
leaf_storm = Attack("Leaf Storm", grass, 90, 1, "special")
shadow_ball = Attack("Shadow Ball", ghost, 80, 1, "special")
sludge_bomb = Attack("Sludge Bomb", poison, 90, 1, "special")
thunder = Attack("Thunder", electric, 110, 0.70, "special")
dark_pulse = Attack("Dark Pulse", dark, 80, 1, "special")
ice_beam = Attack("Ice Beam", ice, 90, 1, "special")
hydroblast = Attack("Hydroblast", water, 110, 0.8, "special")
iron_tail = Attack("Iron Tail", steel, 100, 0.75, "physical")
slam = Attack("Slam", normal, 80, 0.75, "physical")
grass_knot = Attack("Grass Knot", grass, 80, 1, "special")
flash_cannon = Attack("Flash Cannon", steel, 80, 1, "special")
giga_impact = Attack("Giga-Impact", normal, 150, 0.9, "physical")
bite = Attack("Bite", dark, 60, 1, "physical")
tri_attack = Attack("Triplattaque", normal, 80, 1, "special")
#hyper_beam = Attack("Hyper Beam", normal, 150, 0.9, "special")
throat_chop = Attack("Throat Chop", dark, 80, 1, "physical")
fire_punch = Attack("Fire Punch", fire, 75, 1, "physical")
# Pokémon creation --> Sources : https://www.pokepedia.fr/Pikachu#Statistiques-remarques1
charizard = Pokemon("Charizard", [fire, fly], 360, 267, 255, 317, 269, 299)
gengar = Pokemon("Gengar", [ghost, poison], 324, 229, 219, 359, 249, 319)
blastoise = Pokemon("Blastoise", [water], 362, 265, 299, 269, 309, 255)
pikachu = Pokemon("Pikachu", [electric], 294, 259, 199, 249, 219, 339)
glaceon = Pokemon("Glaceon", [ice], 334, 219, 319, 359, 289, 229)
porygonz = Pokemon("Porygon-Z", [normal], 374, 259, 239, 369, 249, 279)
abomasnow = Pokemon("Abomasnow", [grass, ice], 384, 283, 249, 283, 269, 219)
toxtricity = Pokemon(
"Toxtricity", [electric, poison], 354, 295, 239, 327, 239, 249
)
# Attacks learning
charizard.learn_attacks([fire_blast, hurricane, earthquake, leaf_storm])
gengar.learn_attacks([sludge_bomb, dark_pulse, shadow_ball, thunder])
blastoise.learn_attacks([ice_beam, hydroblast, flash_cannon, giga_impact])
pikachu.learn_attacks([thunder, iron_tail, slam, grass_knot])
glaceon.learn_attacks([ice_beam, slam, iron_tail, bite])
porygonz.learn_attacks([thunder, ice_beam, tri_attack, dark_pulse])
abomasnow.learn_attacks([ice_beam, leaf_storm, earthquake, giga_impact])
toxtricity.learn_attacks([sludge_bomb, thunder, throat_chop, fire_punch])
# Player creation
me = Player("Oak", "j1", "human")
him = Player("Agatha", "j2", "robot")
##############################################################
# GAME
print(
"""
###################################################
# Welcome in the Quantum Pokémon fight - CLI
# Will you succeed to win against the Quantum AI ?
#
# Good Luck !!!
###################################################
"""
)
team(me, him, nb_team=3)
winner, looser = battle(me, him, qc_type, backend_sim)
for i, y in zip(winner.register_team, looser.register_team):
gen_team_data(pokemon=i, has_win="yes")
gen_team_data(pokemon=y, has_win="no")
print("Fight {} is finished !".format(u + 1))
print("Gen team data program ended !")
|
https://github.com/mickahell/quantum_pokemon-fight
|
mickahell
|
from train.robot_vs_robot import team, battle
from stats.gen_data import gen_unity_data
from src.class_custom.attacks import Attack
from src.class_custom.player import Player
from src.class_custom.pokemon import Pokemon
from src.class_custom.type import Type
from qiskit import Aer, QuantumCircuit, QuantumRegister
import warnings
class Unity:
def __init__(self):
warnings.filterwarnings("ignore", category=DeprecationWarning)
# Init Qasm simulator backend
qasm = Aer.get_backend("qasm_simulator")
backend_sim = qasm # Choose your backend : <quantum_computer> or <qasm>
for u in range(2):
# Types creation --> Sources : https://boutique-pokemon.com/blogs/blog-pokemon/table-types-pokemon
fire = Type("Fire")
normal = Type("Normal")
water = Type("Water")
grass = Type("Grass")
electric = Type("Electric")
fly = Type("Fly")
poison = Type("Poison")
bug = Type("Bug")
ghost = Type("Ghost")
ground = Type("Ground")
dark = Type("Dark")
ice = Type("Ice")
steel = Type("Steel")
resistance = [bug, grass, fire, ice, steel]
weakness = [water, ground]
imunite = ["None"]
fire.add_info(resistance, weakness, imunite)
resistance = ["None"]
weakness = ["None"]
imunite = [ghost]
normal.add_info(resistance, weakness, imunite)
resistance = [grass, ground]
weakness = [fire, fly]
imunite = ["None"]
bug.add_info(resistance, weakness, imunite)
resistance = [water, fire, steel]
weakness = [grass, electric]
imunite = ["None"]
water.add_info(resistance, weakness, imunite)
resistance = [water, electric, grass, ground]
weakness = [fire, bug, poison, fly, ice]
imunite = ["None"]
grass.add_info(resistance, weakness, imunite)
resistance = [electric, fly, steel]
weakness = [ground]
imunite = ["None"]
electric.add_info(resistance, weakness, imunite)
resistance = [bug, grass]
weakness = [electric, ice]
imunite = [ground]
fly.add_info(resistance, weakness, imunite)
resistance = [ghost, dark]
weakness = [bug]
imunite = ["None"]
dark.add_info(resistance, weakness, imunite)
resistance = [bug, poison]
weakness = [ghost, dark]
imunite = [normal]
ghost.add_info(resistance, weakness, imunite)
resistance = [bug, grass, poison]
weakness = [ground]
imunite = ["None"]
poison.add_info(resistance, weakness, imunite)
resistance = [poison]
weakness = [water, grass, ice]
imunite = [electric]
ground.add_info(resistance, weakness, imunite)
resistance = [ice]
weakness = [fire, steel]
imunite = ["None"]
ice.add_info(resistance, weakness, imunite)
resistance = [steel, ice, bug, normal, grass, fly]
weakness = [fire, ground]
imunite = [poison]
steel.add_info(resistance, weakness, imunite)
# type qubits creation
fire.qubit = QuantumRegister(1, "fire")
normal.qubit = QuantumRegister(1, "normal")
water.qubit = QuantumRegister(1, "water")
grass.qubit = QuantumRegister(1, "grass")
electric.qubit = QuantumRegister(1, "electric")
fly.qubit = QuantumRegister(1, "fly")
poison.qubit = QuantumRegister(1, "poison")
bug.qubit = QuantumRegister(1, "bug")
ghost.qubit = QuantumRegister(1, "ghost")
ground.qubit = QuantumRegister(1, "ground")
dark.qubit = QuantumRegister(1, "dark")
ice.qubit = QuantumRegister(1, "ice")
steel.qubit = QuantumRegister(1, "steel")
qc_type = QuantumCircuit(
steel.qubit,
fire.qubit,
normal.qubit,
water.qubit,
grass.qubit,
electric.qubit,
fly.qubit,
poison.qubit,
bug.qubit,
ghost.qubit,
ground.qubit,
dark.qubit,
ice.qubit,
)
# Attacks creation
fire_blast = Attack("Fire Blast", fire, 110, 0.85, "special")
hurricane = Attack("Hurricane", fly, 110, 0.70, "special")
earthquake = Attack("Earthquake", ground, 100, 1, "physical")
leaf_storm = Attack("Leaf Storm", grass, 90, 1, "special")
shadow_ball = Attack("Shadow Ball", ghost, 80, 1, "special")
sludge_bomb = Attack("Sludge Bomb", poison, 90, 1, "special")
thunder = Attack("Thunder", electric, 110, 0.70, "special")
dark_pulse = Attack("Dark Pulse", dark, 80, 1, "special")
ice_beam = Attack("Ice Beam", ice, 90, 1, "special")
hydroblast = Attack("Hydroblast", water, 110, 0.8, "special")
iron_tail = Attack("Iron Tail", steel, 100, 0.75, "physical")
slam = Attack("Slam", normal, 80, 0.75, "physical")
grass_knot = Attack("Grass Knot", grass, 80, 1, "special")
flash_cannon = Attack("Flash Cannon", steel, 80, 1, "special")
giga_impact = Attack("Giga-Impact", normal, 150, 0.9, "physical")
bite = Attack("Bite", dark, 60, 1, "physical")
tri_attack = Attack("Triplattaque", normal, 80, 1, "special")
#hyper_beam = Attack("Hyper Beam", normal, 150, 0.9, "special")
throat_chop = Attack("Throat Chop", dark, 80, 1, "physical")
fire_punch = Attack("Fire Punch", fire, 75, 1, "physical")
# Pokémon creation --> Sources : https://www.pokepedia.fr/Pikachu#Statistiques-remarques1
charizard = Pokemon("Charizard", [fire, fly], 360, 267, 255, 317, 269, 299)
gengar = Pokemon("Gengar", [ghost, poison], 324, 229, 219, 359, 249, 319)
blastoise = Pokemon("Blastoise", [water], 362, 265, 299, 269, 309, 255)
pikachu = Pokemon("Pikachu", [electric], 294, 259, 199, 249, 219, 339)
glaceon = Pokemon("Glaceon", [ice], 334, 219, 319, 359, 289, 229)
porygonz = Pokemon("Porygon-Z", [normal], 374, 259, 239, 369, 249, 279)
abomasnow = Pokemon("Abomasnow", [grass, ice], 384, 283, 249, 283, 269, 219)
toxtricity = Pokemon(
"Toxtricity", [electric, poison], 354, 295, 239, 327, 239, 249
)
# Attacks learning
charizard.learn_attacks([fire_blast, hurricane, earthquake, leaf_storm])
gengar.learn_attacks([sludge_bomb, dark_pulse, shadow_ball, thunder])
blastoise.learn_attacks([ice_beam, hydroblast, flash_cannon, giga_impact])
pikachu.learn_attacks([thunder, iron_tail, slam, grass_knot])
glaceon.learn_attacks([ice_beam, slam, iron_tail, bite])
porygonz.learn_attacks([thunder, ice_beam, tri_attack, dark_pulse])
abomasnow.learn_attacks([ice_beam, leaf_storm, earthquake, giga_impact])
toxtricity.learn_attacks([sludge_bomb, thunder, throat_chop, fire_punch])
# Player creation
me = Player("Oak", "j1", "human")
him = Player("Agatha", "j2", "robot")
##############################################################
# GAME
print(
"""
###################################################
# Welcome in the Quantum Pokémon fight - CLI
# Will you succeed to win against the Quantum AI ?
#
# Good Luck !!!
###################################################
"""
)
team(me, him, nb_team=1)
winner, looser = battle(me, him, qc_type, backend_sim)
for i, y in zip(winner.register_team, looser.register_team):
gen_unity_data(winner=i, looser=y)
print("Fight {} is finished !".format(u + 1))
print("Gen team data program ended !")
|
https://github.com/ukzncqt/QC_Tuts
|
ukzncqt
|
!pip install qiskit
import numpy as np
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute
q = QuantumRegister(1)
c = ClassicalRegister(1)
qc = QuantumCircuit(q,c)
qc.x(q[0])
qc.barrier(q)
qc.measure(q,c)
qc.draw()
from qiskit import BasicAer
backend = BasicAer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=1024)
res = job.result()
res.get_counts()
q = QuantumRegister(1)
c = ClassicalRegister(1)
qc = QuantumCircuit(q,c)
qc.h(q[0])
qc.barrier(q)
qc.measure(q,c)
qc.draw()
job=execute(qc,backend,shots=1024)
res=job.result()
res.get_counts()
from qiskit.tools.visualization import plot_histogram
plot_histogram(res.get_counts())
q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.x(q[0])
qc.h(q[0])
qc.draw()
backend = BasicAer.get_backend('statevector_simulator')
job = execute(qc,backend)
res = job.result()
vector = res.get_statevector(qc,decimals=3)
print(vector)
from sympy import Matrix , pprint
pprint(Matrix(vector))
from qiskit.tools.visualization import plot_bloch_vector
qc1 = QuantumCircuit(q)
qc1.iden(q[0])
job = execute(qc1,backend)
res =job.result()
vector = res.get_statevector(qc1,decimals=3)
print(vector)
p = np.outer(vector,vector.conj())
px = np.array([[0,1],[1,0]])
py = np.array([[0,-1j],[1j,0]])
pz = np.array([[1,0],[0,-1]])
x = float(np.trace(np.dot(px,p)))
y = float(np.trace(np.dot(py,p)))
z = float(np.trace(np.dot(pz,p)))
vec=[x,y,z]
plot_bloch_vector(vec)
qc1 = QuantumCircuit(q)
qc1.x(q[0])
job = execute(qc1,backend)
res = job.result()
vector = res.get_statevector(qc1,decimals=3)
print(vector)
p = np.outer(vector,vector.conj())
x = float(np.trace(np.dot(px,p)))
y = float(np.trace(np.dot(py,p)))
z = float(np.trace(np.dot(pz,p)))
vec = [x,y,z]
plot_bloch_vector(vec)
qc1 = QuantumCircuit(q)
qc1.h(q[0])
job = execute(qc1,backend)
res = job.result()
vector = res.get_statevector(qc1,decimals=3)
print(vector)
p = np.outer(vector,vector.conj())
x = float(np.trace(np.dot(px,p)))
y = float(np.trace(np.dot(py,p)))
z = float(np.trace(np.dot(pz,p)))
vec = [x,y,z]
plot_bloch_vector(vec)
qc1 = QuantumCircuit(q)
qc1.h(q[0])
qc1.y(q[0])
job = execute(qc1,backend)
res = job.result()
vector = res.get_statevector(qc1,decimals=3)
print(vector)
p = np.outer(vector,vector.conj())
x = float(np.trace(np.dot(px,p)))
y = float(np.trace(np.dot(py,p)))
z = float(np.trace(np.dot(pz,p)))
vec = [x,y,z]
plot_bloch_vector(vec)
qc1=QuantumCircuit(q)
qc1.h(q[0])
qc1.z(q[0])
job=execute(qc1,backend)
res=job.result()
vector = res.get_statevector(qc1,decimals=3)
print(vector)
p=np.outer(vector,vector.conj())
x=float(np.trace(np.dot(px,p)))
y=float(np.trace(np.dot(py,p)))
z=float(np.trace(np.dot(pz,p)))
vec=[x,y,z]
plot_bloch_vector(vec)
qc1 = QuantumCircuit(q)
qc1.h(q[0])
qc1.t(q[0])
job = execute(qc1,backend)
res = job.result()
vector = res.get_statevector(qc1,decimals=3)
print(vector)
p = np.outer(vector,vector.conj())
x = float(np.trace(np.dot(px,p)))
y = float(np.trace(np.dot(py,p)))
z = float(np.trace(np.dot(pz,p)))
vec = [x,y,z]
plot_bloch_vector(vec)
qc1 = QuantumCircuit(q)
qc1.h(q[0])
qc1.tdg(q[0])
job = execute(qc1,backend)
res = job.result()
vector = res.get_statevector(qc1,decimals=3)
print(vector)
p = np.outer(vector,vector.conj())
x = float(np.trace(np.dot(px,p)))
y = float(np.trace(np.dot(py,p)))
z = float(np.trace(np.dot(pz,p)))
vec = [x,y,z]
plot_bloch_vector(vec)
qc1 = QuantumCircuit(q)
qc1.h(q[0])
qc1.s(q[0])
job = execute(qc1,backend)
res = job.result()
vector = res.get_statevector(qc1,decimals=3)
print(vector)
p = np.outer(vector,vector.conj())
x = float(np.trace(np.dot(px,p)))
y = float(np.trace(np.dot(py,p)))
z = float(np.trace(np.dot(pz,p)))
vec = [x,y,z]
plot_bloch_vector(vec)
qc1 = QuantumCircuit(q)
qc1.h(q[0])
qc1.sdg(q[0])
job = execute(qc1,backend)
res = job.result()
vector = res.get_statevector(qc1,decimals=3)
print(vector)
p = np.outer(vector,vector.conj())
x = float(np.trace(np.dot(px,p)))
y = float(np.trace(np.dot(py,p)))
z = float(np.trace(np.dot(pz,p)))
vec = [x,y,z]
plot_bloch_vector(vec)
qc1 = QuantumCircuit(q)
qc1.u3(np.pi/7,5*np.pi/14,np.pi/8,q[0])
job = execute(qc1,backend)
res = job.result()
vector = res.get_statevector(qc1,decimals=3)
print(vector)
pprint(Matrix(vector))
p = np.outer(vector,vector.conj())
x = float(np.trace(np.dot(px,p)))
y = float(np.trace(np.dot(py,p)))
z = float(np.trace(np.dot(pz,p)))
vec = [x,y,z]
plot_bloch_vector(vec)
q = QuantumRegister(2)
qc1 = QuantumCircuit(q)
qc1.h(q[0])
qc1.cx(q[0],q[1])
qc1.draw()
job = execute(qc1,backend)
res = job.result()
vector = res.get_statevector(qc1,decimals=3)
print(vector)
pprint(Matrix(vector))
q = QuantumRegister(2)
c = ClassicalRegister(2)
qc1 = QuantumCircuit(q,c)
qc1.h(q[0])
qc1.cx(q[0],q[1])
qc1.barrier(q)
qc1.measure(q,c)
from qiskit import BasicAer
backend = BasicAer.get_backend('qasm_simulator')
job = execute(qc1,backend,shots=1000)
res = job.result()
counts = res.get_counts()
print(counts)
plot_histogram(counts)
q = QuantumRegister(2)
qc = QuantumCircuit(q)
qc.ch(q[0],q[1])
qc.draw()
q = QuantumRegister(2)
qc = QuantumCircuit(q)
qc.cy(q[0],q[1])
qc.draw()
q = QuantumRegister(2)
qc = QuantumCircuit(q)
qc.cz(q[0],q[1])
qc.draw()
q = QuantumRegister(2)
qc = QuantumCircuit(q)
qc.cu3(np.pi/3,np.pi/4,np.pi,q[0],q[1])
qc.draw()
q = QuantumRegister(3)
c = ClassicalRegister(3)
qc = QuantumCircuit(q,c)
qc.h(q[0])
qc.cx(q[0],q[1])
qc.cx(q[0],q[2])
qc.barrier(q)
qc.measure(q,c)
qc.draw()
backend = BasicAer.get_backend('qasm_simulator')
job = execute(qc,backend,shots=1000)
res = job.result()
res.get_counts()
plot_histogram(res.get_counts())
backend=BasicAer.get_backend('statevector_simulator')
job=execute(qc,backend)
res=job.result()
v=res.get_statevector(qc,decimals=3)
pprint(Matrix(v))
|
https://github.com/ukzncqt/QC_Tuts
|
ukzncqt
|
!pip install qiskit
from qiskit import IBMQ
IBMQ.backends()
IBMQ.stored_accounts()
IBMQ.enable_account("7099aa657902a0c2289d1f31dfcd2166e8491773275a1c891362c73facd343a1aa9d4c77c27328bfca8de4ec42047f50c90ff7df5af406807251b7c7cab96223")
IBMQ.backends()
IBMQ.load_accounts()
IBMQ.backends(operational=True, simulator=False)
backend=IBMQ.get_backend('ibmqx4')
backend.name()
backend.status()
from qiskit import execute, QuantumRegister, ClassicalRegister, QuantumCircuit
q = QuantumRegister(2)
c = ClassicalRegister(2)
qc = QuantumCircuit(q,c)
qc.h(q[0])
qc.cx(q[0],q[1])
qc.barrier(q)
qc.measure(q,c)
qc.draw()
job=execute(qc,backend=backend,shots=1024)
job.status()
res=job.result()
res.get_counts()
from qiskit.tools.visualization import plot_histogram
plot_histogram(res.get_counts())
|
https://github.com/ukzncqt/QC_Tuts
|
ukzncqt
|
!pip install qiskit
from qiskit import BasicAer
from qiskit import QuantumRegister ,ClassicalRegister ,QuantumCircuit ,execute
from qiskit.tools.visualization import plot_histogram ,circuit_drawer
from numpy import pi
qr = QuantumRegister(3)
cr = ClassicalRegister(3)
qc = QuantumCircuit(qr,cr)
qc.u3(pi/7,13*pi/4,0,qr[0])
qc.h(qr[1])
qc.cx(qr[1],qr[2])
qc.cx(qr[0],qr[1])
qc.h(qr[0])
qc.cx(qr[1],qr[2])
qc.cz(qr[0],qr[2])
qc.barrier()
qc.measure(qr,cr)
qc.draw()
backend = BasicAer.get_backend("qasm_simulator")
job = execute(qc,backend = backend, shots = 8192)
res = job.result()
counts1 = res.get_counts()
counts1
plot_histogram(counts1)
backend1 = BasicAer.get_backend("statevector_simulator")
qr = QuantumRegister(1)
qc = QuantumCircuit(qr,cr)
qc.u3(pi/7,13*pi/4,0,qr[0])
job = execute(qc,backend=backend1)
res = job.result()
message = res.get_statevector(qc,decimals=3)
message
from numpy import abs
prob0=(abs(message[0]))**2
prob0
prob1=(abs(message[1]))**2
prob1
prob_bob_0=0.232+0.245+0.238+0.237
prob_bob_0
prob_bob_1=0.013+0.012+0.012+0.011
prob_bob_1
|
https://github.com/maryrbarros2/QuantumAlgorithms_Qiskit
|
maryrbarros2
|
from qiskit import QuantumCircuit, assemble, Aer
from qiskit.visualization import plot_histogram
from qiskit_textbook.widgets import binary_widget
binary_widget(nbits=6)
n = 8
n_q = n #number of qubits in the circuit.
n_b = n #number of output bits we will extract from the circuit at the end.
qc_output = QuantumCircuit(n_q,n_b)
#adding a measure operation to each of our eight qubits
#.measure(j,j): adds a measurement to our circuit that tells qubit j to write an output to bit j
for j in range(n):
qc_output.measure(j,j)
#Visualing the circuit
qc_output.draw()
sim = Aer.get_backend('aer_simulator') # this is the simulator we'll use
qobj = assemble(qc_output) # this turns the circuit into an object our backend can run
result = sim.run(qobj).result() # we run the experiment and get the result from that experiment
# from the results, we get a dictionary containing the number of times (counts)
# each result appeared
counts = result.get_counts()
# and display it on a histogram
plot_histogram(counts)
#NOT gate - i.e., X quantum gate
qc_encode = QuantumCircuit(n) #creating a quantum circuit of n qbits
qc_encode.x(7) #applying x gate into the 7th qubit
qc_encode.draw() #drawing the circuit
#obs: remember here that we already setted n = 8.
#creating a new circuit that contains the n qbits + the measuremnt part
qc = qc_encode + qc_output
qc.draw()
#running and ploting the results
qobj = assemble(qc)
counts = sim.run(qobj).result().get_counts()
plot_histogram(counts)
#### Exercice: trying a new number: 36 = 100100
qc_encode2 = QuantumCircuit(6)
qc_encode2.x(2)
qc_encode2.x(5)
qc_encode2.draw()
n_q = 6 #number of qubits in the circuit.
n_b = 6 #number of output bits we will extract from the circuit at the end.
qc_output2 = QuantumCircuit(n_q,n_b)
for j in range(6):
qc_output2.measure(j,j)
qc_output2.draw()
qc2 = qc_encode2 + qc_output2
qc2.draw()
qobj2 = assemble(qc_output2) # this turns the circuit into an object our backend can run
result2 = sim.run(qobj2).result() # we run the experiment and get the result from that experiment
# from the results, we get a dictionary containing the number of times (counts)
# each result appeared
counts2 = result2.get_counts()
# and display it on a histogram
plot_histogram(counts2)
qobj2 = assemble(qc2)
counts2 = sim.run(qobj2).result().get_counts()
plot_histogram(counts2)
qc_cnot = QuantumCircuit(2) #quantum circuit of 2 qubits
qc_cnot.cx(0,1) #cnot between qubits 0 and 1
qc_cnot.draw() #draw the circuit
qc = QuantumCircuit(2,2)
qc.x(0) #apply x on qubit 0; It becomes 1
qc.cx(0,1) #apply cnot between qbit 0 and 1
qc.measure(0,0)
qc.measure(1,1)
qc.draw()
qobja = assemble(qc) # this turns the circuit into an object our backend can run
resulta = sim.run(qobja).result() # we run the experiment and get the result from that experiment
# from the results, we get a dictionary containing the number of times (counts)
# each result appeared
countsa = resulta.get_counts()
# and display it on a histogram
plot_histogram(countsa)
qc_ha = QuantumCircuit(4,2)
# encode inputs in qubits 0 and 1
qc_ha.x(0) # For a=0, remove the this line. For a=1, leave it.
qc_ha.x(1) # For b=0, remove the this line. For b=1, leave it.
qc_ha.barrier()
# use cnots to write the XOR of the inputs on qubit 2
qc_ha.cx(0,2)
qc_ha.cx(1,2)
# use ccx to write the AND of the inputs on qubit 3
qc_ha.ccx(0,1,3)
qc_ha.barrier()
# extract outputs
qc_ha.measure(2,0) # extract XOR value
qc_ha.measure(3,1) # extract AND value
qc_ha.draw()
qobj = assemble(qc_ha)
counts = sim.run(qobj).result().get_counts()
plot_histogram(counts)
|
https://github.com/maryrbarros2/QuantumAlgorithms_Qiskit
|
maryrbarros2
|
from qiskit import QuantumCircuit, assemble, Aer
from qiskit.visualization import plot_histogram, plot_bloch_vector
from math import sqrt, pi
qc = QuantumCircuit(1) #Quantum circuit with one qubit
initial_state = [0,1] # Define initial_state as |1>
qc.initialize(initial_state, 0) # Apply initialisation operation to the 0th qubit
qc.draw() # Let's view our circuit
sim = Aer.get_backend('aer_simulator') # Tell Qiskit how to simulate our circuit
qc.save_statevector() # Tell simulator to save statevector
qobj = assemble(qc) # Create a Qobj from the circuit for the simulator to run
result = sim.run(qobj).result() # Do the simulation and return the result
out_state = result.get_statevector()
print(out_state) # Display the output state vector
qc.measure_all()
qc.draw()
#instead of the statevector we will get the counts for the 0 and 1 results using .get_counts():
qobj = assemble(qc)
result = sim.run(qobj).result()
counts = result.get_counts()
plot_histogram(counts)
initial_state = [1/sqrt(2), 1j/sqrt(2)] # Define state |q_0>
qc = QuantumCircuit(1) # Must redefine qc
qc.initialize(initial_state, 0) # Initialize the 0th qubit in the state `initial_state`
qc.save_statevector() # Save statevector
qobj = assemble(qc) # # Create a Qobj from the circuit for the simulator to run
state = sim.run(qobj).result().get_statevector() # Execute the circuit
print(state)
results = sim.run(qobj).result().get_counts()
plot_histogram(results)
#State with 1/3 probability of measuring |0> and 2/3 of measuring |1>
initial_state2 = [1/sqrt(3), sqrt(2)/sqrt(3)] # Define state |q_0>
qc2 = QuantumCircuit(1) # Must redefine qc
qc2.initialize(initial_state2, 0) # Initialize the 0th qubit in the state `initial_state`
qc2.save_statevector() # Save statevector
qobj2 = assemble(qc2) # # Create a Qobj from the circuit for the simulator to run
state2 = sim.run(qobj2).result().get_statevector() # Execute the circuit
print(state)
results2 = sim.run(qobj2).result().get_counts()
plot_histogram(results2)
from qiskit_textbook.widgets import plot_bloch_vector_spherical
coords = [pi/2,0,1] # [Theta, Phi, Radius]
plot_bloch_vector_spherical(coords) # Bloch Vector with spherical coordinates
#Plotting \0>
coords = [0,1,1] # [Theta, Phi, Radius]
plot_bloch_vector_spherical(coords)
#Plotting \1>
coords = [pi,1,1] # [Theta, Phi, Radius]
plot_bloch_vector_spherical(coords)
from qiskit_textbook.widgets import bloch_calc
bloch_calc()
|
https://github.com/maryrbarros2/QuantumAlgorithms_Qiskit
|
maryrbarros2
|
from qiskit import QuantumCircuit, assemble, Aer
from math import pi, sqrt
from qiskit.visualization import plot_bloch_multivector, plot_histogram
sim = Aer.get_backend('aer_simulator')
# Let's do an X-gate on a |0> qubit
qc = QuantumCircuit(1)
qc.x(0)
qc.draw()
# Let's see the result
qc.save_statevector()
qobj = assemble(qc)
state = sim.run(qobj).result().get_statevector()
plot_bloch_multivector(state)
# Let's do an Y-gate on a |0> qubit
qc = QuantumCircuit(1)
qc.y(0)
qc.draw()
qc.save_statevector()
qobj = assemble(qc)
state = sim.run(qobj).result().get_statevector()
plot_bloch_multivector(state)
#### Z gate
# Let's do an Z-gate on a |0> qubit
qc = QuantumCircuit(1)
qc.z(0)
qc.draw()
qc.save_statevector()
qobj = assemble(qc)
state = sim.run(qobj).result().get_statevector()
plot_bloch_multivector(state)
# Run the code in this cell to see the widget
from qiskit_textbook.widgets import gate_demo
gate_demo(gates='pauli')
# Run the code in this cell to see the widget
from qiskit_textbook.widgets import gate_demo
gate_demo(gates='pauli+h')
# Create the X-measurement function:
def x_measurement(qc, qubit, cbit):
"""Measure 'qubit' in the X-basis, and store the result in 'cbit'"""
qc.h(qubit)
qc.measure(qubit, cbit)
return qc
initial_state = [1/sqrt(2), -1/sqrt(2)]
# Initialize our qubit and measure it
qc = QuantumCircuit(1,1)
qc.initialize(initial_state, 0)
x_measurement(qc, 0, 0) # measure qubit 0 to classical bit 0
qc.draw()
qobj = assemble(qc) # Assemble circuit into a Qobj that can be run
counts = sim.run(qobj).result().get_counts() # Do the simulation, returning the state vector
plot_histogram(counts) # Display the output on measurement of state vector
# Run the code in this cell to see the widget
from qiskit_textbook.widgets import gate_demo
gate_demo(gates='pauli+h+p')
#Specifically,using a P-gate:
qc = QuantumCircuit(1)
qc.p(pi/4, 0)
qc.draw()
qc = QuantumCircuit(1)
qc.s(0) # Apply S-gate to qubit 0
qc.sdg(0) # Apply Sdg-gate to qubit 0
qc.draw()
qc = QuantumCircuit(1)
qc.t(0) # Apply T-gate to qubit 0
qc.tdg(0) # Apply Tdg-gate to qubit 0
qc.draw()
|
https://github.com/maryrbarros2/QuantumAlgorithms_Qiskit
|
maryrbarros2
|
from qiskit import QuantumCircuit, Aer, assemble
from math import pi
import numpy as np
from qiskit.visualization import plot_histogram, plot_bloch_multivector
qc = QuantumCircuit(3)
# Apply H-gate to each qubit:
for qubit in range(3):
qc.h(qubit)
# See the circuit:
qc.draw()
# Let's see the result
svsim = Aer.get_backend('aer_simulator')
qc.save_statevector()
qobj = assemble(qc)
final_state = svsim.run(qobj).result().get_statevector()
# In Jupyter Notebooks we can display this nicely using Latex.
# If not using Jupyter Notebooks you may need to remove the
# array_to_latex function and use print(final_state) instead.
from qiskit.visualization import array_to_latex
array_to_latex(final_state, prefix="\\text{Statevector} = ")
qc2 = QuantumCircuit(2)
qc2.h(0)
qc2.x(1)
# See the circuit:
qc2.draw()
# Let's see the result
svsim = Aer.get_backend('aer_simulator')
qc2.save_statevector()
qobj2 = assemble(qc2)
final_state2 = svsim.run(qobj2).result().get_statevector()
# In Jupyter Notebooks we can display this nicely using Latex.
# If not using Jupyter Notebooks you may need to remove the
# array_to_latex function and use print(final_state) instead.
from qiskit.visualization import array_to_latex
array_to_latex(final_state2, prefix="\\text{Statevector} = ")
qc = QuantumCircuit(2)
qc.h(0)
qc.x(1)
qc.draw()
usim = Aer.get_backend('aer_simulator')
qc.save_unitary()
qobj = assemble(qc)
unitary = usim.run(qobj).result().get_unitary()
# In Jupyter Notebooks we can display this nicely using Latex.
# If not using Jupyter Notebooks you may need to remove the
# array_to_latex function and use print(unitary) instead.
from qiskit.visualization import array_to_latex
array_to_latex(unitary, prefix="\\text{Circuit = }\n")
qc = QuantumCircuit(2)
qc.x(1)
qc.draw()
# Simulate the unitary
usim = Aer.get_backend('aer_simulator')
qc.save_unitary()
qobj = assemble(qc)
unitary = usim.run(qobj).result().get_unitary()
# Display the results:
array_to_latex(unitary, prefix="\\text{Circuit = } ")
qc = QuantumCircuit(2)
# Apply CNOT
qc.cx(0,1)
# See the circuit:
qc.draw()
#Writting (and checking) the initial state |0+>:
qc = QuantumCircuit(2)
# Apply H-gate to the first:
qc.h(0)
# Let's see the result:
svsim = Aer.get_backend('aer_simulator')
qc.save_statevector()
qobj = assemble(qc)
final_state = svsim.run(qobj).result().get_statevector()
# Print the statevector neatly:
array_to_latex(final_state, prefix="\\text{Statevector = }")
#Now,applying h to the |0+> state:
qc = QuantumCircuit(2)
# Apply H-gate to the first:
qc.h(0)
# Apply a CNOT:
qc.cx(0,1)
qc.draw()
# Let's get the result:
qc.save_statevector()
qobj = assemble(qc)
result = svsim.run(qobj).result()
# Print the statevector neatly:
final_state = result.get_statevector()
array_to_latex(final_state, prefix="\\text{Statevector = }")
plot_histogram(result.get_counts())
from qiskit.visualization import plot_state_qsphere
plot_state_qsphere(final_state)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.