def ask_for_device ():
d = input("Do you want to play on the real device? (y/n)\n").upper()
if (d=="Y"):
device = IBMQ.get_backend('ibmq_5_tenerife') # if real, we use ibmqx4
else:
device = Aer.get_backend('qasm_simulator') # otherwise, we use a simulator
return device
# Initial dataset
real_data = take_from_dist_1(N)
print('Data bounds:', bounds)
print('Batch size:', batch_size)
print('Number of qubits:', num_qubits)
print('Target relative entropy:', target_rel_ent)
print('Initial data length:', N)
print('Initial data:', real_data)
print('Unknown target probabilities:', unknown_target_data_prob)
print('')
# Set quantum instance to run the quantum generator
if real_backend:
print('Real backend loading...')
IBMQ.load_account() # Load account from disk
IBMQ.providers() # List all available providers
provider = IBMQ.get_provider(hub='ibm-q')
backend = provider.get_backend('ibmq_santiago')
quantum_instance = QuantumInstance(backend=backend)
print('Backend:', backend)
print('')
else:
quantum_instance = QuantumInstance(backend=BasicAer.get_backend('statevector_simulator'))
# Initialize qGAN
iqgan = IQGAN(
real_data,
target_rel_ent,
num_qubits,
bounds,
from qiskit.aqua.components.oracles import TruthTableOracle
from qiskit.aqua.circuits.gates import mcmt, mct
from math import *
import qconfig
#n = int(sys.argv[1])
threshold = float(sys.argv[1])
delta = float(sys.argv[2])
vflag = int(sys.argv[3])
#print('delta : ', delta);
#print('thresh : ', threshold);
vprint = print if vflag else lambda *a, **k: None
IBMQ.save_account(qconfig.APItoken, overwrite=True)
IBMQ.load_accounts()
backend = IBMQ.get_backend('ibmq_qasm_simulator')
def swap(qc, q1, q2, anc):
ln = range(len(q1))
for i in ln:
qc.cx(q1[i], q2[i])
qc.cx(q2[i], q1[i])
qc.cx(q1[i], q2[i])
s = ''
dat_file = open('data.txt', 'r')
import qiskit as q
from qiskit import Aer, execute
from qiskit import IBMQ
from qiskit.tools.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor
import matplotlib
f = open('ibmtoken.txt')
token = f.read()
IBMQ.load_account()
qr = q.QuantumRegister(2)
cr = q.ClassicalRegister(2)
circuit = q.QuantumCircuit(qr, cr)
circuit.x(qr[0])
circuit.cx(qr[0], qr[1])
##circuit.measure([qr[0],qr[1]],[cr[0],cr[1]])#measureing and storing result in classical bits
##simulator=Aer.get_backend('qasm_simulator')#using the qasm simulator
##Result=execute(circuit,backend=simulator).result()
##plot_histogram(Result.get_counts(circuit)).show()
##print(circuit)
##circuit.draw(output = 'mpl',filename='ckt.png')
provider = IBMQ.get_provider('ibm-q') #using actual quantum computer
qcomp = provider.get_backend('ibmq_16_melbourne') #using the ibmq_16_melbourne
job = execute(circuit, backend=qcomp)
job_monitor(job) #monitoring for the completion of our job
result = job.result()
plot_histogram(result.get_counts(circuit)).show() #plotting the results
import qiskit
from qiskit import IBMQ, ClassicalRegister, QuantumRegister, QuantumCircuit, execute, Aer
from qiskit.providers.ibmq import least_busy
from configparser import RawConfigParser
# Setup the API key for the real quantum computer.
parser = RawConfigParser()
parser.read('config.ini')
IBMQ.enable_account(parser.get('IBM', 'key'))
# Setup 3 qubits.
q = QuantumRegister(3)
c = ClassicalRegister(3)
qc = QuantumCircuit(q, c)
# Place the qubits into superposition so the qubits no longer hold a distinct value, but instead are both 0 and 1 at the same time (50% 0, 50% 1).
qc.h(q)
qc.measure(q, c)
# Using the qubits and their random value, form a response.
def answer(result):
for key in result.keys():
state = key
print("The Quantum 8-ball says:")
if state == '000':
print('It is certain.')
elif state == '001':
print('Without a doubt.')
elif state == '010':
print('Yes - deinitely.')
from qiskit import ClassicalRegister, QuantumRegister, QuantumCircuit, Aer from qiskit.tools.visualization import circuit_drawer import math as m from qiskit import IBMQ IBMQ.load_account() S_simulator = Aer.backends(name='statevector_simulator')[0] M_simulator = Aer.backends(name='qasm_simulator')[0] q = QuantumRegister(1, name='q') c = ClassicalRegister(1, name='c') qc = QuantumCircuit(q, c, name='qc') qc.rx(m.pi / 4, q[0]) print(circuit_drawer(qc)) qc.ry(m.pi / 4, q[0]) print(circuit_drawer(qc)) qc.rz(m.pi / 4, q[0]) print(circuit_drawer(qc))
# In[1]:
import qiskit
# In[2]:
from qiskit import IBMQ
# In[3]:
IBMQ.save_account('e09fd3916c85a0a4c4eb21ffec6ee48758d13a8e3b76c50e6301b7f3e28656d157dd4f406530ae18ccbee21bc6f4685b6271433292b424a81eeb3cebcb04d85b')
# In[4]:
IBMQ.load_account()
# In[5]:
from qiskit import *
# In[6]:
import tensorflow as tf
import os
import qiskit
from qiskit import IBMQ
from qiskit.providers.aer.noise import NoiseModel
##################################################################################################
# Use default.qubit for default pennylane simulation
# use tf.interface for TF integration
USE_GPU = (os.environ["CUDA_VISIBLE_DEVICES"] != '-1')
# Read token from file
f = open("qnetworks/.ibmq_token", "r")
token = f.readline()
f.close()
# connect IBM and get device noise information
IBMQ.save_account(token)
provider = IBMQ.load_account()
backend = provider.get_backend('ibmq_16_melbourne')
noise_model = NoiseModel.from_backend(backend)
dev1 = qml.device('qiskit.aer', wires=8, noise_model=noise_model)
@qml.qnode(dev1, interface='tf')
def TTN_edge_forward(edge_array, theta_learn):
# Takes the input and learning variables and applies the
# network to obtain the output
# STATE PREPARATION
for i in range(8):
qml.RY(edge_array[i], wires=i)
# First Layer
# Needed for functions
import numpy as np
import time
# Import Qiskit classes
import qiskit
from qiskit import QuantumRegister, QuantumCircuit, ClassicalRegister, Aer
from qiskit.quantum_info import state_fidelity
from qiskit import Aer, IBMQ, execute
from qiskit.providers.aer import noise
IBMQ.load_accounts()
IBMQ.backends()
device = IBMQ.get_backend('ibmq_16_melbourne')
properties = device.properties()
coupling_map = device.configuration().coupling_map
gate_times = [('u1', None, 0), ('u2', None, 100), ('u3', None, 200),
('cx', [1, 0], 678), ('cx', [1, 2], 547), ('cx', [2, 3], 721),
('cx', [4, 3], 733), ('cx', [4, 10], 721), ('cx', [5, 4], 800),
('cx', [5, 6], 800), ('cx', [5, 9], 895), ('cx', [6, 8], 895),
('cx', [7, 8], 640), ('cx', [9, 8], 895), ('cx', [9, 10], 800),
('cx', [11, 10], 721), ('cx', [11, 3], 634), ('cx', [12,
2], 773),
('cx', [13, 1], 2286), ('cx', [13, 12], 1504), ('cx', [], 800)]
noise_model = noise.device.basic_device_noise_model(properties,
gate_times=gate_times)
import sys, os
#sys.path.append('/Users/atanteck/Desktop/project/qiskit-ignis/qiskit/ignis')
from verification import tomography as tomo
from mitigation import measurement as mc
# uncompute
for i in range(self.n - 1, 1, -1):
self.circ.ccx(self.ctrl[i], self.anc[i - 2], self.anc[i - 1])
self.circ.ccx(self.ctrl[0], self.ctrl[1], self.anc[0])
def calc_theta(self, p1, p0):
return 2 * np.arctan(np.sqrt((p1) / (p0)))
#if __name__=='__main__':
from jupyterthemes import jtplot
jtplot.style(theme='monokai', context='notebook', ticks=True, grid=False)
from qiskit.tools.jupyter import *
from qiskit import IBMQ
IBMQ.load_account()
# provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')
provider = IBMQ.get_provider(hub='ibm-q-oxford',
group='on-boarding',
project='on-boarding-proj')
from qiskit import BasicAer
backend = BasicAer.get_backend('unitary_simulator')
n = 3
parents = np.random.rand(n * 2)
child = np.random.rand(2**(n + 1))
b = byskit(provider, backend, n, parents, child)
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created Nov 2020
@author: hassi
"""
from qiskit import QuantumCircuit, execute
from qiskit import IBMQ
from qiskit.tools.monitor import job_monitor
from IPython.core.display import display
print("Getting provider...")
if not IBMQ.active_account():
IBMQ.load_account()
provider = IBMQ.get_provider()
print("Ch 4: Quantum coin toss on IBM Q backend")
print("----------------------------------------")
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
display(qc.draw('mpl'))
from qiskit.providers.ibmq import least_busy
backend = least_busy(
from __future__ import print_function
import tbvaccine as tb
tb.add_hook(isolate=False, show_vars=False)
import numpy as np
from qiskit.quantum_info.operators import Operator
from qiskit import (IBMQ, QuantumRegister, ClassicalRegister, QuantumCircuit,
Aer, execute, transpile)
################################################################################
##################################################
################### Token auth ###################
##################################################
token_path = "../IBMQ_token"
with open(token_path, "r") as file:
token = file.read()
IBMQ.save_account(token, overwrite=True)
################################################################################
##################################### Main #####################################
################################################################################
def main():
##################################################
################## Make circuit ##################
##################################################
q = QuantumRegister(3)
c = ClassicalRegister(3)
circ = QuantumCircuit(q, c)
circ.x(q[0]) # |psi> = |1>
########## Encoding ##########
circ.barrier()
# <IBMQBackend('ibmq_16_melbourne') from IBMQ()>,
# <IBMQBackend('ibmq_qasm_simulator') from IBMQ()>
# ]
# IBMQ device information:
# https://www.research.ibm.com/ibm-q/technology/devices/#ibmqx4
backend = qiskit.Aer.get_backend('qasm_simulator')
shots = 1024
backend_result = qiskit.execute(circs, backend, shots=shots).result()
for i in range(len(circs)):
print(backend_result.get_counts(circs[i]))
# print(backend_result.get_counts(circs[0]))
print(xdata) # gate_time * num_of_gates
# Run on an IBMQ device
# Ref:
# https://qiskit.org/documentation/advanced_use_of_ibm_q_devices.html
IBMQ.load_accounts()
backend = IBMQ.get_backend('ibmqx2')
for i in range(len(circs)):
qobj = compile(circs[i], backend=backend, shots=1024)
job = backend.run(qobj)
result = job.result()
counts = result.get_counts()
print(counts)
# Measure the value of T*2 (decoherence) time
# https://github.com/Qiskit/qiskit-tutorials/blob/master/community/ignis/coherence-overview.ipynb
import matplotlib.pyplot as plt
from qiskit import BasicAer, Aer, QuantumCircuit, QuantumRegister, ClassicalRegister, execute, IBMQ
from qiskit.visualization import *
from qiskit.tools.monitor import job_monitor
import math
#########################################################
#########################################################
# #INIT
qasm = Aer.get_backend('qasm_simulator')
IBMQ.load_account() # Init Real Quantum computeur
provider = IBMQ.get_provider('ibm-q')
quantum_computer = provider.get_backend('ibmq_burlington')
backend_sim = qasm # Choose your backend : <quantom_computer> or <qasm>
statevector_sim = Aer.get_backend("statevector_simulator")
ship = ["petit", "moyen", "grand"]
nb_qubits = len(ship)
qubits = [1, 2, 3, 4, 5]
fake_qubit = 5 - nb_qubits
play = True
#########################################################
#########################################################
# #Circuit
# Quantum Circuit
from qiskit import IBMQ
IBMQ.save_account('API_KEY')
from qiskit import (QuantumCircuit, execute, Aer)
from qiskit.ignis.mitigation.measurement import (complete_meas_cal,
CompleteMeasFitter)
import math
import random
# To run as a simulation, replace all 'backend' with 'simulator', and uncomment:
# simulator = Aer.get_backend('qasm_simulator')
qc = QuantumCircuit(5, 5)
qc.h(0)
qc.h(1)
qc.h(2)
qc.h(3)
qc.h(4)
qc.measure([0, 1, 2, 3, 4], [0, 1, 2, 3, 4])
IBMQ.load_account()
provider = IBMQ.get_provider('ibm-q')
backend = provider.get_backend('ibmq_ourense')
# If no mitigation is applied, add ', memory=True', and .get_memory() to job.result()
job = execute(qc, backend, shots=4096, optimization_level=0)
results = job.result()
# Mitigation Measurement, will run twice
#!/usr/bin/env python
# coding: utf-8
# In[1]:
import qiskit
# In[2]:
qiskit.__qiskit_version__
# In[3]:
from qiskit import IBMQ
# In[4]:
IBMQ.save_account(
'3911c2d0a5d9bf2e5e04c515e91669718a1aceb5465035e11e71d8ad57b65d99316ab8da9610dd12e72bf925bf347f080b6067ce942cd7fb6b828e15784b09c3'
)
# In[5]:
IBMQ.load_account()
# In[ ]:
from qiskit import IBMQ, Aer
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
import matplotlib.pyplot as plt
import os
from rwutil import *
OUTPUT = "output"
IBMQ.load_account()
Prov = IBMQ.get_provider(group='open')
BACKENDS = {
'qasm_simulator': (Aer.get_backend('qasm_simulator'), True),
'ibmq_qasm_simulator': (Prov.get_backend('ibmq_qasm_simulator'), False),
'ibmq_london': (Prov.get_backend('ibmq_qasm_simulator'), False),
'ibmq_vigo': (Prov.get_backend('ibmq_qasm_simulator'), False)
}
SHOTS = 1000
T = [*range(0, 5)]
N = [2, 3, 4, 5]
def add_gate():
# 0 = cin, 1 = q, 2 = cout
q = QuantumRegister(3)
circuit = QuantumCircuit(q, name='add')
circuit.ccx(0, 1, 2)
circuit.cx(0, 1)
return circuit.to_instruction()
def main():
st.header("Моделирование. Лабораторная работа №1")
st.write("Исследование последовательности псевдослучайных чисел")
random_type = st.radio(
"Выберите метод получения чисел",
("Алгоритмическая генерация", "Пользовательский ввод", "Пуассон",
"Квантовая генерация"))
if random_type == "Алгоритмическая генерация":
st.markdown("---")
random_table = RAND_TABLE.replace(" ", "").replace("\n", "")
table_cap_1 = random_table[:10]
table_cap_2 = random_table[11:31]
table_cap_3 = random_table[32:62]
tbl_1 = np.array([int(s) for s in table_cap_1], dtype=np.int16)
tbl_2 = np.array(
[table_cap_2[i:i + 2] for i in range(0, len(table_cap_2), 2)],
dtype=np.int16)
tbl_3 = np.array(
[table_cap_3[i:i + 3] for i in range(0, len(table_cap_3), 3)],
dtype=np.int16)
alg_1 = gen_rnd_smpl(0, 9)
alg_2 = gen_rnd_smpl(10, 99)
alg_3 = gen_rnd_smpl(100, 999)
st.write(
"Табличный и алгоритмический метод получения псевдослучайных чисел."
)
generate_table(data=np.array([
tbl_1,
tbl_2,
tbl_3,
alg_1,
alg_2,
alg_3,
]),
columns=["Табл.", "Алг."])
st.button("Сгенерировать")
if st.checkbox("Показать графики"):
st.line_chart(tbl_1)
st.line_chart(tbl_2)
st.line_chart(tbl_3)
st.line_chart(alg_1)
st.line_chart(alg_2)
st.line_chart(alg_3)
elif random_type == "Пользовательский ввод":
st.markdown("---")
st.write("Пользовательский ввод случайных чисел.")
user_nums_cap_1 = user_input_handler(digit_capacity=1, key=1)
user_nums_cap_2 = user_input_handler(digit_capacity=2, key=2)
user_nums_cap_3 = user_input_handler(digit_capacity=3, key=3)
if user_nums_cap_1.shape[0] + user_nums_cap_2.shape[
0] + user_nums_cap_3.shape[0] == 30:
generate_table(data=np.array(
[user_nums_cap_1, user_nums_cap_2, user_nums_cap_3]),
columns=["Польз."])
if st.checkbox("Показать графики"):
st.line_chart(user_nums_cap_1)
st.line_chart(user_nums_cap_2)
st.line_chart(user_nums_cap_3)
elif random_type == "Пуассон":
st.markdown("---")
st.write(
"Генерация случайных чисел с использованием распределения Пуассона"
)
poisson_cap_1 = np.random.poisson(3, 10)
poisson_cap_2 = np.random.poisson(33, 10)
poisson_cap_3 = np.random.poisson(333, 10)
generate_table(data=np.array(
[poisson_cap_1, poisson_cap_2, poisson_cap_3]),
columns=["Пуассон"])
st.button("Сгенерировать")
elif random_type == "Квантовая генерация":
st.markdown("---")
st.write(
"Генерация случайных чисел с использованием квантового компьютера IBM."
)
api_key = None
try:
IBMQ.load_account()
except Exception as e:
api_key = st.text_input("Введите IBMQ API Key:")
if not api_key:
IBMQ.save_account(api_key, overwrite=True)
IBMQ.load_account()
rng_provider = IBMQ.get_provider(hub='ibm-q')
device = st.selectbox("Select Quantum Device",
[str(each) for each in rng_provider.backends()])
backend = rng_provider.get_backend(device)
generator = Generator(backend=backend)
if device == "ibmq_qasm_simulator":
num_q = 32
else:
num_q = 5
quantum_nums_cap_1 = []
quantum_nums_cap_2 = []
quantum_nums_cap_3 = []
for i in range(10):
quantum_nums_cap_1.append(ibmq_qrng(num_q, 0, 9))
quantum_nums_cap_2.append(ibmq_qrng(num_q, 10, 99))
quantum_nums_cap_3.append(ibmq_qrng(num_q, 100, 999))
generate_table(data=np.array(
[quantum_nums_cap_1, quantum_nums_cap_2, quantum_nums_cap_3]),
columns=["Квант."])
st.button("Сгенерировать")
if st.checkbox("Показать графики"):
st.line_chart(quantum_nums_cap_1)
st.line_chart(quantum_nums_cap_2)
st.line_chart(quantum_nums_cap_3)
import numpy as np
from qiskit import(
QuantumCircuit,
execute,
Aer,
IBMQ)
from qiskit.visualization import plot_histogram
from matplotlib import pyplot as plt
#IBMQ.save_account('c650f2a6e47504e201bd6e1422e89efbb3b1ac24264be980a0555746424cd5d8469e1511b86a10f0f3fd1581245d864bcbe03b0802ce48dff35adc57a44da5f6')
IBMQ.load_account()
provider = IBMQ.get_provider(group='open', project='main')
backend = provider.get_backend('ibmq_vigo')
#backend = Aer.get_backend('qasm_simulator')
circuit = QuantumCircuit(2, 2)
circuit.h(0)
circuit.cx(0,1)
circuit.measure([0,1],[0,1])
job = execute(circuit,backend, shots=1000)
result = job.result()
counts = result.get_counts()
print("\nTotal count for 00 and 11 are:",counts)
print(circuit.draw(output="text",filename=None))
plot_histogram(counts)
plt.show()
# Create a GHZ state
qc.h(q[0])
for i in range(4):
qc.cx(q[i], q[i + 1])
# Insert a barrier before measurement
qc.barrier()
# Measure all of the qubits in the standard basis
for i in range(5):
qc.measure(q[i], c[i])
###############################################################
# Set up the API and execute the program.
###############################################################
try:
IBMQ.load_accounts()
except:
print("""WARNING: There's no connection with the API for remote backends.
Have you initialized a file with your personal token?
For now, there's only access to local simulator backends...""")
# First version: simulator
sim_backend = Simulators.get_backend('qasm_simulator')
job = execute(qc, sim_backend, shots=1024)
result = job.result()
print('Qasm simulator')
print(result)
print(result.get_counts(qc))
# Second version: real device
least_busy_device = least_busy(
from qiskit import QuantumRegister, ClassicalRegister
from qiskit import QuantumCircuit, execute,IBMQ
from qiskit.tools.monitor import job_monitor
from qiskit.circuit.library import QFT
import numpy as np
pi = np.pi
IBMQ.enable_account(‘ENTER API KEY HERE’)
provider = IBMQ.get_provider(hub='ibm-q')
backend = provider.get_backend('ibmq_qasm_simulator')
q = QuantumRegister(5,'q')
c = ClassicalRegister(5,'c')
circuit = QuantumCircuit(q,c)
circuit.x(q[4])
circuit.x(q[2])
circuit.x(q[0])
circuit += QFT(num_qubits=5, approximation_degree=0, do_swaps=True, inverse=False, insert_barriers=False, name='qft')
circuit.measure(q,c)
circuit.draw(output='mpl', filename='qft1.png')
print(circuit)
job = execute(circuit, backend, shots=1000)
job_monitor(job)
counts = job.result().get_counts()
from qiskit.circuit import QuantumCircuit,QuantumRegister,ClassicalRegister
from qiskit import execute
from qiskit import IBMQ
from qiskit import BasicAer
#IBMQ.save_account('83a95fc7efba05f250ed50ff6bdf1638541ebd4f9e46396f26c8dc12f15b2331ea24d9db4f59c30b6e397c2268e40ddc1dae4772091baa73d7e99c91e8d8c56b')
provider = IBMQ.load_account()
backend = provider.get_backend('ibmq_quito')
qr = QuantumRegister(3)
cr =ClassicalRegister(3)
qc = QuantumCircuit(qr,cr)
qc.h(0)
qc.cx(0,1)
qc.cx(0,2)
qc.measure(qr[0:],cr[0:])
for _ in range(20):
job = execute(qc,backend = backend,shots = 1024)
counts = job.result().get_counts()
print(counts)
#!/usr/bin/env python
# coding: utf-8
# In[1]:
from qiskit import QuantumRegister
from qiskit import QuantumRegister, ClassicalRegister
from qiskit import QuantumCircuit, execute, IBMQ
from qiskit.tools.monitor import job_monitor
print('\nSign Flip Code')
print('----------------')
IBMQ.enable_account(
'7a14c59cb5d061ddf7b9287874a80aa122f1cae65910e33fa678220ec5d475a637b83a0e9f8f54a43e3a128d5e5154f084a924dbfdef0da5a3e777c940a15b55'
)
provider = IBMQ.get_provider(hub='ibm-q')
backend = provider.get_backend('ibmq_qasm_simulator')
# Creating Qubits
q = QuantumRegister(3)
# Creating qubits
circuit = QuantumCircuit(q)
# Hadamard Gate on the first Qubit
circuit.h(q[0])
# Pauli Z Gate on the the first qubit
circuit.z(0)
# Pauli Z Gate on the the second qubit
circuit.z(1)
# CNOT Gate on the first and second Qubits
# Create a GHZ state
qc.h(q[0])
for i in range(num_qubits-1):
qc.cx(q[i], q[i+1])
# Insert a barrier before measurement
qc.barrier()
# Measure all of the qubits in the standard basis
for i in range(num_qubits):
qc.measure(q[i], c[i])
###############################################################
# Set up the API and execute the program.
###############################################################
try:
IBMQ.load_accounts()
except:
print("""WARNING: There's no connection with the API for remote backends.
Have you initialized a file with your personal token?
For now, there's only access to local simulator backends...""")
# First version: simulator
sim_backend = BasicAer.get_backend('qasm_simulator')
job = execute(qc, sim_backend, shots=1024)
result = job.result()
print('Qasm simulator : ')
print(result.get_counts(qc))
# Second version: real device
least_busy_device = least_busy(IBMQ.backends(simulator=False,
filters=lambda x: x.configuration().n_qubits > 4))
#!/usr/bin/env python
# coding: utf-8
print("Ch 8: Aer out of the box, a perfect quantum computer")
print("----------------------------------------------------")
# Import Qiskit
from qiskit import QuantumCircuit
from qiskit import Aer, IBMQ, execute
# Import visualization tools
from qiskit.tools.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor
# Load account
IBMQ.load_account()
provider = IBMQ.get_provider()
# Enter number of SWAP gates to include with your circuit with (default 20)
user_input = input("Enter number of SWAP gates to use: ")
try:
n = int(user_input)
except ValueError:
n = 10
n_gates = n
# Construct quantum circuit
circ = QuantumCircuit(2, 2)
circ.x(0)
while n > 0:
circ.swap(0, 1)
import csv
import datetime
import os
from qiskit import IBMQ
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q-education', group='technion-Weinste')
log_time = datetime.datetime.now()
def write_log_to_file(csv_writer):
for backend in provider.backends():
try:
for qubit_idx, qubit_prop in enumerate(
backend.properties().qubits):
for prop in qubit_prop:
csv_writer.writerow([
backend.name(), qubit_idx,
prop.date.isoformat(), prop.name, prop.unit,
prop.value,
log_time.isoformat()
])
id_gate = [
i for i in backend.properties().gates
if i.gate == 'id' and qubit_idx in i.qubits
][0]
id_gate_length = [
p for p in id_gate.parameters if p.name == 'gate_length'
][0]
csv_writer.writerow([
def run_algorithm(params, algo_input=None, json_output=False, backend=None):
"""
Run algorithm as named in params, using params and algo_input as input data
and returning a result dictionary
Args:
params (dict): Dictionary of params for algo and dependent objects
algo_input (AlgorithmInput): Main input data for algorithm. Optional, an algo may run entirely from params
json_output (bool): False for regular python dictionary return, True for json conversion
backend (BaseBackend): Backend object to be used in place of backend name
Returns:
Result dictionary containing result of algorithm computation
"""
_discover_on_demand()
inputparser = InputParser(params)
inputparser.parse()
inputparser.validate_merge_defaults()
logger.debug('Algorithm Input: {}'.format(
json.dumps(inputparser.get_sections(), sort_keys=True, indent=4)))
algo_name = inputparser.get_section_property(PluggableType.ALGORITHM.value,
JSONSchema.NAME)
if algo_name is None:
raise AquaError('Missing algorithm name')
if algo_name not in local_pluggables(PluggableType.ALGORITHM):
raise AquaError(
'Algorithm "{0}" missing in local algorithms'.format(algo_name))
if algo_input is None:
input_name = inputparser.get_section_property('input', JSONSchema.NAME)
if input_name is not None:
input_params = copy.deepcopy(
inputparser.get_section_properties('input'))
del input_params[JSONSchema.NAME]
convert_json_to_dict(input_params)
algo_input = get_pluggable_class(
PluggableType.INPUT, input_name).from_params(input_params)
algo_params = copy.deepcopy(inputparser.get_sections())
algorithm = get_pluggable_class(PluggableType.ALGORITHM,
algo_name).init_params(
algo_params, algo_input)
random_seed = inputparser.get_section_property(JSONSchema.PROBLEM,
'random_seed')
algorithm.random_seed = random_seed
quantum_instance = None
# setup backend
backend_name = inputparser.get_section_property(JSONSchema.BACKEND,
JSONSchema.NAME)
if backend_name is not None: # quantum algorithm
backend_cfg = {
k: v
for k, v in inputparser.get_section(JSONSchema.BACKEND).items()
if k != 'name'
}
noise_params = backend_cfg.pop('noise_params', None)
backend_cfg['config'] = {}
backend_cfg['config']['noise_params'] = noise_params
backend_cfg['seed'] = random_seed
backend_cfg['seed_mapper'] = random_seed
pass_manager = PassManager() if backend_cfg.pop(
'skip_transpiler', False) else None
if pass_manager is not None:
backend_cfg['pass_manager'] = pass_manager
if backend is not None and isinstance(backend, BaseBackend):
backend_cfg['backend'] = backend
else:
try:
backend_from_name = get_aer_backend(backend_name)
except:
QuantumInstance.register_and_get_operational_backends()
backend_from_name = IBMQ.get_backend(backend_name)
backend_cfg['backend'] = backend_from_name
quantum_instance = QuantumInstance(**backend_cfg)
value = algorithm.run(quantum_instance)
if isinstance(value, dict) and json_output:
convert_dict_to_json(value)
return value
elif quantumChoice == "10":
print("The Quantum Computer chose: Scissors")
else:
print("The Quantum Computer chose: Quantum")
#---------------------Program starts here---------------------
choice = userChoice()
while choice == "default":
print("Please try again: ")
choice = userChoice()
print("Loading quantum opponent...")
# Load IBMQ account
IBMQ.load_accounts()
# Finds the least busy IBM quantum computer to use as the backend
backend = BasicAer.get_backend('statevector_simulator') # Run a simulation
#backend = least_busy(IBMQ.backends(simulator=False)) # Run it on IBM's computer
print("The least busy device:", backend.name())
# Set up Quantum Register and Classical Register for 2 qubits
q = QuantumRegister(2)
c = ClassicalRegister(2)
# Create a Quantum Circuit
qc = QuantumCircuit(q, c)
qc.h(q) # Hadamard gate that give the qubits an equal opportunity
#qc.measure(q,c)
#print(qc.draw()) # Display circuit
prog.x(input_qubit[0]) # number=19
prog.x(input_qubit[0]) # number=20
# circuit end
for i in range(n):
prog.measure(input_qubit[i], classical[i])
return prog
if __name__ == '__main__':
a = "111"
b = "0"
f = lambda rep: bitwise_xor(bitwise_dot(a, rep), b)
prog = make_circuit(4, f)
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
provider.backends()
backend = least_busy(
provider.backends(
filters=lambda x: x.configuration().n_qubits >= 2 and not x.
configuration().simulator and x.status().operational == True))
sample_shot = 8000
info = execute(prog, backend=backend,
shots=sample_shot).result().get_counts()
backend = FakeVigo()
circuit1 = transpile(prog, backend, optimization_level=2)
writefile = open("../data/startQiskit_QC2594.csv", "w")
print(info, file=writefile)
print('\nPhase Flip Code')
print('----------------')
from qiskit import QuantumRegister
from qiskit import QuantumRegister, ClassicalRegister
from qiskit import QuantumCircuit, execute, IBMQ
from qiskit.tools.monitor import job_monitor
IBMQ.enable_account('Enter API key here')
provider = IBMQ.get_provider(hub='ibm-q')
backend = provider.get_backend('ibmq_qasm_simulator')
q = QuantumRegister(3, 'q')
c = ClassicalRegister(1, 'c')
circuit = QuantumCircuit(q, c)
circuit.cx(q[0], q[1])
circuit.cx(q[0], q[2])
circuit.h(q[0])
circuit.h(q[1])
circuit.h(q[2])
circuit.z(q[0]) #Add this to simulate a phase flip error
circuit.h(q[0])
circuit.h(q[1])
circuit.h(q[2])
circuit.cx(q[0], q[1])
circuit.cx(q[0], q[2])
circuit.ccx(q[2], q[1], q[0])
circuit.measure(q[0], c[0])
from qiskit import IBMQ
from qiskit import BasicAer as Aer
from qiskit import ClassicalRegister, QuantumRegister, QuantumCircuit
from qiskit import execute
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.patches import Circle, Rectangle
import copy
from ipywidgets import widgets
from IPython.display import display, clear_output
try:
IBMQ.load_accounts()
except:
pass
class run_game():
# Implements a puzzle, which is defined by the given inputs.
def __init__(self,initialize, success_condition, allowed_gates, vi, qubit_names, eps=0.1, backend=Aer.get_backend('qasm_simulator'), shots=1024,mode='circle',verbose=False):
"""
initialize
List of gates applied to the initial 00 state to get the starting state of the puzzle.
Supported single qubit gates (applied to qubit '0' or '1') are 'x', 'y', 'z', 'h', 'ry(pi/4)'.
Supported two qubit gates are 'cz' and 'cx'. Specify only the target qubit.
success_condition
Values for pauli observables that must be obtained for the puzzle to declare success.
allowed_gates
For each qubit, specify which operations are allowed in this puzzle. 'both' should be used only for operations that don't need a qubit to be specified ('cz' and 'unbloch').
Gates are expressed as a dict with an int as value. If this is non-zero, it specifies the number of times the gate is must be used (no more or less) for the puzzle to be successfully solved. If the value is zero, the player can use the gate any number of times.
QX_TOKEN = APItoken
"""
Authenticate with the IBM Q API in order to use online devices.
You need the API Token.
The account information is need to be stored locally on disk only once.
To store account information locally on disk, uncomment the next line.
"""
# print("Storing account information locally on disk ...")
# IBMQ.save_account(QX_TOKEN)
# The next line is mandatory to load the account infos stored
print("\nLoading account ...")
IBMQ.load_accounts()
# print_dict(IBMQ.stored_accounts()[0])
"""
########### CREATING THE CIRCUIT ##########
"""
print("\nCreating the circuit ...")
# Numbers of qubits that will be used in the circuit
numbers_of_qubits = 4
# Create a Quantum Register with n qubits.
q = QuantumRegister(numbers_of_qubits)
