def load_ibm_account(self):
IBMQ.save_account(self.ibm_set['token'])
IBMQ.load_account()
self.provider = IBMQ.get_provider("ibm-q")
import cv2
import matplotlib.pyplot as plt
import numpy as np
from qiskit import BasicAer, IBMQ
from utils.rand_gen import random_gen
########### Calling Quantum Computer######
api_file = open("API_token.txt", "r")
api_key = ""
if api_file.mode == 'r':
api_key = api_file.read()
#print("API_key: ", api_key)
IBMQ.save_account(api_key)
provider = IBMQ.load_account()
backend = provider.get_backend('ibmq_essex') #select which machine
##########################################
#backend = BasicAer.get_backend("qasm_simulator") #simulator
q_gen = random_gen(1, backend)
class Tile():
def __init__(self, img, idx):
self.img = img
self.idx = idx
self.neighbors = {
def loadAccount():
from qiskit import IBMQ
IBMQ.save_account(open('token.txt', 'r').read())
IBMQ.load_account()
def bernstein(error_correct=False):
API_TOKEN = '7cf33cd2f0d7044af8518c33321fa74d7380d3ba58d08b271404e8226aa1f5490818ba86e1635f89e6c3cfbf10aa091ff04c1f5ff61f0f391ed780b4484e0b18'
# initialize qiskit
IBMQ.save_account(API_TOKEN)
provider = IBMQ.load_account()
print(provider.backends())
backend = provider.backends.ibmq_16_melbourne
# initialize qubits with architecture in mind
qubits = [cirq.GridQubit(0, 5), cirq.GridQubit(1, 4),\
cirq.GridQubit(0, 6), cirq.GridQubit(2, 5),\
cirq.GridQubit(2, 3), cirq.GridQubit(1, 5),\
cirq.GridQubit(3, 4), cirq.GridQubit(2, 4)]
if error_correct:
error_qubits = [cirq.GridQubit(3, 4), cirq.GridQubit(3, 3),\
cirq.GridQubit(3, 2), cirq.GridQubit(4, 3)]
# construct circuit
circuit = cirq.Circuit()
# error correction setup. error correct qubit (2,3)
if error_correct:
circuit.append([cirq.CNOT(qubits[2], error_qubits[1])])
circuit.append([cirq.SWAP(error_qubits[0], error_qubits[1])])
circuit.append([cirq.CNOT(qubits[2], error_qubits[1])])
circuit.append([cirq.SWAP(error_qubits[0], error_qubits[1])])
# hadamards
circuit.append([cirq.H(q) for q in qubits])
# turn helper qubit to 1
circuit.append([cirq.Z(qubits[7])])
# oracle
circuit.append([cirq.CNOT(qubits[1], qubits[7])])
circuit.append([cirq.CNOT(qubits[3], qubits[7])])
circuit.append([cirq.CNOT(qubits[4], qubits[7])])
circuit.append([cirq.CNOT(qubits[6], qubits[7])])
# hadamards
circuit.append([cirq.H(q) for q in qubits[:-1]])
# error detection and correction
if error_correct:
circuit.append([cirq.SWAP(error_qubits[2], error_qubits[1])])
circuit.append([cirq.CNOT(qubits[2], error_qubits[1])])
circuit.append([cirq.SWAP(error_qubits[2], error_qubits[1])])
circuit.append([cirq.CNOT(error_qubits[1], error_qubits[2])])
circuit.append([cirq.SWAP(error_qubits[3], error_qubits[1])])
circuit.append([cirq.CNOT(qubits[2], error_qubits[1])])
circuit.append([cirq.CNOT(error_qubits[0], error_qubits[1])])
circuit.append([cirq.SWAP(error_qubits[1], error_qubits[3])])
circuit.append(
[cirq.measure(error_qubits[2]),
cirq.measure(error_qubits[3])])
circuit.append(
[cirq.CCNOT(qubits[2], error_qubits[1], error_qubits[0])])
# measure
circuit.append([cirq.measure(q) for q in qubits[:-1]])
# export to qasm
qasm_str = circuit.to_qasm()
# import qiskit from qasm
qiskit_circuit = qiskitqc.from_qasm_str(qasm_str)
# run qiskit
transpiled = transpile(qiskit_circuit, backend)
qobj = assemble(transpiled, backend, shots=100)
job = backend.run(qobj)
print(job.job_id())
result = job.result()
counts = result.get_counts()
delayed_result = backend.retrieve_job(job.job_id()).result()
delayed_counts = delayed_result.get_counts()
print(counts)
print(delayed_counts)
return requests.post(url, json=job_payload)
def test_load_from_disk(token):
IBMQ.save_account(token)
dev = IBMQDevice(wires=1)
assert dev.provider.credentials.is_ibmq()
IBMQ.delete_account()
# coding: utf-8
# In[2]:
import warnings
from qiskit.tools.jupyter import *
from qiskit import IBMQ
from qiskit import assemble
from qiskit import pulse
from qiskit.pulse import pulse_lib
import numpy as np
import matplotlib.pyplot as plt
# This is my token!
IBMQ.save_account('dc42f3bec0eb08d5702e81cdac45ee0278fedd659670e4acf130480e6851d50145d0669c91070c225ad916d237351200edb6ba79ed944e21c3b3a89e30fc00db')
warnings.filterwarnings('ignore')
IBMQ.load_account()
# # Pick your favorite (not busy) Backend
# In[3]:
# Try again using Johannesbourg!!!
provider = IBMQ.get_provider(hub='ibm-q-csic',group='internal')
backend = provider.get_backend('ibmq_johannesburg')
backend_config = backend.configuration()
assert backend_config.open_pulse, "Backend doesn't support OpenPulse"
from qiskit.aqua.components.optimizers import SPSA
from qiskit.aqua.components.variational_forms import RY
from qiskit.aqua import QuantumInstance, aqua_globals
from qiskit.optimization.ising.common import sample_most_likely
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
import webbrowser
import logging
from qiskit.aqua import set_qiskit_aqua_logging
from qiskit import IBMQ
IBMQ.save_account('(INSERT IBMQ KEY HERE)', overwrite=True)
IBMQ.load_account()
import networkx as nx
# Ding the distance matrix
locations = [
"135 Overlea Blvd, North York, ON M3C 1B3",
"1040 Broadview Ave, Toronto, ON M4K 2S2",
"4 Astor Ave, East York, ON M4G 3M2",
"455 Cosburn Ave, East York, ON M4J 2N2",
"1500 Woodbine Ave, East York, ON M4C 4G9"
]
coordinates = []
for i in locations:
coordinates.append(
def __init__(self, factor):
self.factor = factor
storedAccount = IBMQ.stored_account()
if storedAccount == None or storedAccount == {}:
IBMQ.save_account(token)
self.__provider = IBMQ.load_account()
from qiskit import Aer, IBMQ, execute
from qiskit.providers.aer import noise
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.tools.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor
from qiskit import IBMQ
from sympy.physics.continuum_mechanics.beam import matplotlib
IBMQ.save_account('a5718e05677118aa192e1baac686bb764972b28ff18f673b8bffbb6834fe874227f0c794da513898589645b757366711e1f3681e70ec2f3c74197df9bc0f8ef7')
IBMQ.load_accounts()
IBMQ.backends()
device = IBMQ.get_backend('ibmq_16_melbourne')
properties = device.properties()
coupling_map = device.configuration().coupling_map
# Construct quantum circuit
# qr = QuantumRegister(3, 'qr')
# cr = ClassicalRegister(3, 'cr')
# circ = QuantumCircuit(qr, cr)
# circ.h(qr[0])
# circ.cx(qr[0], qr[1])
# circ.cx(qr[1], qr[2])
# circ.measure(qr, cr)
from qiskit import IBMQ
IBMQ.save_account('Your_token_there', overwrite=True)
"""
Программа для инициализации токена на сайте IBM.
"""
def __init__(
self,
backend_name: str,
hub: Optional[str] = None,
group: Optional[str] = None,
project: Optional[str] = None,
monitor: bool = True,
):
"""A backend for running circuits on remote IBMQ devices.
The provider arguments of `hub`, `group` and `project` can
be specified here as parameters or set in the config file
using :py:meth:`pytket.extensions.qiskit.set_ibmq_config`.
This function can also be used to set the IBMQ API token.
:param backend_name: Name of the IBMQ device, e.g. `ibmqx4`,
`ibmq_16_melbourne`.
:type backend_name: str
:param hub: Name of the IBMQ hub to use for the provider.
If None, just uses the first hub found. Defaults to None.
:type hub: Optional[str], optional
:param group: Name of the IBMQ group to use for the provider. Defaults to None.
:type group: Optional[str], optional
:param project: Name of the IBMQ project to use for the provider.
Defaults to None.
:type project: Optional[str], optional
:param monitor: Use the IBM job monitor. Defaults to True.
:type monitor: bool, optional
:raises ValueError: If no IBMQ account is loaded and none exists on the disk.
"""
super().__init__()
self._pytket_config = QiskitConfig.from_default_config_file()
if not IBMQ.active_account():
if IBMQ.stored_account():
IBMQ.load_account()
else:
if self._pytket_config.ibmq_api_token is not None:
IBMQ.save_account(self._pytket_config.ibmq_api_token)
else:
raise NoIBMQAccountError()
provider_kwargs = {}
provider_kwargs["hub"] = hub if hub else self._pytket_config.hub
provider_kwargs[
"group"] = group if group else self._pytket_config.group
provider_kwargs[
"project"] = project if project else self._pytket_config.project
try:
if any(x is not None for x in provider_kwargs.values()):
provider = IBMQ.get_provider(**provider_kwargs)
else:
provider = IBMQ.providers()[0]
except qiskit.providers.ibmq.exceptions.IBMQProviderError as err:
logging.warn(
("Provider was not specified enough, specify hub,"
"group and project correctly (check your IBMQ account)."))
raise err
self._backend: "_QiskIBMQBackend" = provider.get_backend(backend_name)
self._config: "QasmBackendConfiguration" = self._backend.configuration(
)
self._gate_set: Set[OpType]
# simulator i.e. "ibmq_qasm_simulator" does not have `supported_instructions`
# attribute
self._gate_set = _tk_gate_set(self._backend)
self._mid_measure = self._config.simulator or self._config.multi_meas_enabled
self._legacy_gateset = OpType.SX not in self._gate_set
if self._legacy_gateset:
if not self._gate_set >= {
OpType.U1, OpType.U2, OpType.U3, OpType.CX
}:
raise NotImplementedError(
f"Gate set {self._gate_set} unsupported")
self._rebase_pass = RebaseIBM()
else:
if not self._gate_set >= {
OpType.X, OpType.SX, OpType.Rz, OpType.CX
}:
raise NotImplementedError(
f"Gate set {self._gate_set} unsupported")
self._rebase_pass = RebaseCustom(
{OpType.CX},
Circuit(2).CX(0, 1),
{OpType.X, OpType.SX, OpType.Rz},
_tk1_to_x_sx_rz,
)
if hasattr(self._config, "max_experiments"):
self._max_per_job = self._config.max_experiments
else:
self._max_per_job = 1
self._characterisation: Dict[str, Any] = process_characterisation(
self._backend)
self._device = Device(
self._characterisation.get("NodeErrors", {}),
self._characterisation.get("EdgeErrors", {}),
self._characterisation.get("Architecture", Architecture([])),
)
self._monitor = monitor
self._MACHINE_DEBUG = False
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
# from qiskit import execute
from qiskit import IBMQ
# token_string = 'abc123...321cba'
IBMQ.save_account('abc123...321cba')
# Sets a Quantum Register with n qubits
qr = QuantumRegister(3) # this case - 3 qubits
# Setup a Classical Register with n bits
cr = ClassicalRegister(3) # 3 bits
# In order to have a Quantum Circuit
circuit = QuantumCircuit(qr, cr)
# Quantum gate: CNOT
# Controlled NOT gate from qubit 0 to qubit 1
circuit.cx(qr[0], qr[1])
print('You setup your Controlled NOT gate, now go solve challenging problems!')
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import BasicAer
from qiskit import execute
from qiskit import IBMQ
# Solo es preciso la primera vez
IBMQ.save_account("3c999a701a95c71f427401a4fae986b7eae6a2366e45126fc15ad970849a0d98f0eff6d72b8edfdaf402101541b5076caef0c582d43b4bed78864a6121a400cc")
IBMQ.load_accounts()
quantum_register = QuantumRegister(1)
classical_register = ClassicalRegister(1)
circuit = QuantumCircuit(quantum_register, classical_register)
circuit.h(quantum_register[0])
circuit.measure(quantum_register, classical_register)
from qiskit.tools.monitor import job_monitor
from qiskit.providers.ibmq import least_busy
# Antes se elegían por nombre; ahora por objeto
large_enough_devices = IBMQ.backends(filters=lambda x: x.configuration().n_qubits > 4 and
not x.configuration().simulator)
backend = least_busy(large_enough_devices)
print(backend)
job_exp = execute(circuit, backend=backend, shots=1000)
# Este componente no existía y había que hacer a mano tanto la gestión de los errores HTTP como de lectura
job_monitor(job_exp)
from async_job.api.object_store import ObjectStore
from qiskit import *
from qiskit import IBMQ
import json
from client import QobjEncoder
from qiskit.compiler import transpile, assemble
from qiskit.qobj.qasm_qobj import QasmQobj as QasmQobj
import os
token = os.getenv('BACKEND_TOKEN')
IBMQ.save_account(token)
IBMQ.load_account() # Load account from disk
print(IBMQ.providers()) # List all available providers
provider = IBMQ.get_provider(hub='ibm-q')
IBMQ.get_provider(group='open')
print("The backends are:")
print(provider.backends())
print("Selecting backend ibmq_qasm_simulator...")
backend = provider.get_backend('ibmq_qasm_simulator')
print(backend)
#Asynchronous using run
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
mapped_circuit = transpile(qc, backend=backend)
qobj = assemble(mapped_circuit, backend=backend, shots=1024)
'shots': 1024,
'depth': 2,
'seed': 10598,
'local': False,
'qbits': 5,
'records': 10
}
if config['local']:
config['server'] = 'qasm_simulator'
else:
config['qbits'] = servers[config['server']]
data = json.load(open('data' + str(config['qbits']) + '.json', 'r'))
IBMQ.save_account(config['token'])
if config['local']:
IBMQ.load_accounts(hub=None)
feature_map = SecondOrderExpansion(feature_dimension=config['qbits'],
depth=config['depth'],
entanglement=config['entanglement'])
qsvm = QSVM(feature_map, data["train"], data["test"])
backend = BasicAer.get_backend(config['server'])
quantum_instance = QuantumInstance(backend,
shots=config['shots'],
seed_transpiler=config['seed'])
result = qsvm.run(quantum_instance)
print(result)
else:
IBMQ.load_accounts(hub=None)
feature_map = SecondOrderExpansion(feature_dimension=config['qbits'],
from qiskit.visualization import plot_gate_map
from qiskit.visualization import plot_error_map
import qiskit.pulse.pulse_lib as pulse_lib
from qiskit.exceptions import QiskitError
#import PyQt5
#import os
#import PySide2
#dirname = os.path.dirname(PySide2.__file__)
#plugin_path = os.path.join(dirname, 'plugins', 'platforms')
#os.environ['QT_QPA_PLATFORM_PLUGIN_PATH'] = plugin_path
#from PySide2.QtWidgets import *
IBMQ.save_account(
'e7b72db6919022a00d9a75557392311954b58280de131c451c9939ccb701b69a6d0d63e3fb912f086723d8cdcaf45c7f710d4c3ab1930c4df1a13768ad476202'
)
IBMQ.load_account()
from datetime import datetime
def get_unique_backends():
"""Gets the unique backends that are available.
Returns:
list: Unique available backends.
Raises:
QiskitError: No backends available.
ImportError: If qiskit-ibmq-provider is not installed
"""
circuit.cx(0, 2)
circuit.u1(pi/2, 2)
circuit.cx(0,2)
circuit.u1(pi/4, 1)
circuit.u1(pi/8, 2)
circuit.cx(1,2)
circuit.u1(-pi/4,2)
circuit.cx(1,2)
circuit.u1(pi/4,2)
circuit.h(2)
circuit.measure(list(range(0,4)), list(range(0,4)))
circuit.draw(output="mpl")
from qiskit.tools.monitor import job_monitor
from qiskit import IBMQ
IBMQ.save_account("token")
backend = provider.get_backend("ibmq_london")
job = q.execute(circuit, backend=backend, shots=500)
job_monitor(job)
from qiskit.visualization import plot_histogram
from matplotlib import style
style.use("dark_background")
# Dark theme is very cool.
result = job.result()
counts = result.get_counts(circuit)
v = plot_histogram([counts], legend=['Device'])
# Save v as png etc etc etc.
print("State vector: {}".format(statevector.real))
np.savetxt("phi_fourier.txt", statevector, fmt='%1.5f %1.5f')
fig1 = plt.bar(np.arange(np.power(2, n_qubits)), np.power(statevector.real, 2))
plt.xlabel("Probabilities")
plt.ylim(0, 0.01)
plt.savefig("state.jpg")
qc.measure(np.arange(n_qubits), np.arange(n_qubits))
num_medidas = 1500
backend1 = Aer.get_backend('qasm_simulator')
result = execute(qc, backend=backend1, shots=num_medidas).result()
counts = result.get_counts(qc)
print("Counts: {}".format(counts))
"""
IBMQ.save_account('bc0221c2c435408a718744a0e3388325cd4241375e15beefb8909a759a28201db7c6a425e8d07e09e54105e373aceccb175fa8eb46700b4db88ac50dbdc6fa84')
provider = IBMQ.load_account()
backend2 = least_busy(provider.backends(filters=lambda b: b.configuration().n_qubits >= n_qubits and not b.configuration().simulator and b.status().operational==True))
result = execute(qc, backend=backend2, shots=num_medidas).result()
counts = result.get_counts(qc)
print("Counts: {}".format(counts))
"""
mediciones = np.zeros([num_medidas, 1])
num_medidas = 0
for medida, cantidad in counts.items():
mediciones[num_medidas:num_medidas + cantidad] = medida
num_medidas += cantidad
np.random.shuffle(mediciones)
np.savetxt("data_fourier.txt", mediciones, fmt='%0{}i'.format(n_qubits))
import qiskit
from qiskit import IBMQ
IBMQ.save_account('key')
qiskit.__qiskit_version__
# qiskit
# python
# sha256
# WeGo_Delta
import hashlib
y = '23dc4da786eff8147c4e72b9807785afee48bb'
password = ["1004"]
#binarizes
def main():
thash = "1004"
thashd = thash.encode()
hash = hashlib.sha256(thashd)
hexa = hash.hexdigest()
return hexa
mainHs = main()
' '.join(format(ord(x), 'b') for x in mainHs)
binary = ' '.join(format(ord(x), 'b') for x in mainHs)
def qaoa(error_correct=False):
API_TOKEN = '7cf33cd2f0d7044af8518c33321fa74d7380d3ba58d08b271404e8226aa1f5490818ba86e1635f89e6c3cfbf10aa091ff04c1f5ff61f0f391ed780b4484e0b18'
# initialize qiskit
IBMQ.save_account(API_TOKEN)
provider = IBMQ.load_account()
print(provider.backends())
backend = provider.backends.ibmq_16_melbourne
# initialize qubits with architecture in mind
qubits = [cirq.GridQubit(1, 4), cirq.GridQubit(2, 4),\
cirq.GridQubit(3, 4)]
if error_correct:
error_qubits = [cirq.GridQubit(3, 4), cirq.GridQubit(3, 3),\
cirq.GridQubit(3, 2), cirq.GridQubit(4, 3)]
# initialize variables
beta = math.pi / 2
gamma = math.pi / 2
graph = nx.Graph()
graph.add_edge(0, 1)
graph.add_edge(1, 2)
graph.add_edge(2, 0)
# construct circuit
circuit = cirq.Circuit()
# error correction setup. error correct qubit (2,3)
if error_correct:
circuit.append([cirq.CNOT(qubits[2], error_qubits[1])])
circuit.append([cirq.SWAP(error_qubits[0], error_qubits[1])])
circuit.append([cirq.CNOT(qubits[2], error_qubits[1])])
circuit.append([cirq.SWAP(error_qubits[0], error_qubits[1])])
circuit.append([cirq.H(q) for q in qubits])
circuit.append([
cirq.ZZPowGate(exponent=2 * gamma / math.pi,
global_shift=-0.5).on(qubits[0], qubits[1])
])
circuit.append([
cirq.ZZPowGate(exponent=2 * gamma / math.pi,
global_shift=-0.5).on(qubits[1], qubits[2])
])
circuit.append([cirq.SWAP(qubits[1], qubits[2])])
circuit.append([
cirq.ZZPowGate(exponent=2 * gamma / math.pi,
global_shift=-0.5).on(qubits[0], qubits[1])
])
circuit.append([cirq.SWAP(qubits[1], qubits[2])])
circuit.append([cirq.rx(2 * beta).on_each(*qubits)])
# error detection and correction
if error_correct:
circuit.append([cirq.SWAP(error_qubits[2], error_qubits[1])])
circuit.append([cirq.CNOT(qubits[2], error_qubits[1])])
circuit.append([cirq.SWAP(error_qubits[2], error_qubits[1])])
circuit.append([cirq.CNOT(error_qubits[1], error_qubits[2])])
circuit.append([cirq.SWAP(error_qubits[3], error_qubits[1])])
circuit.append([cirq.CNOT(qubits[2], error_qubits[1])])
circuit.append([cirq.CNOT(error_qubits[0], error_qubits[1])])
circuit.append([cirq.SWAP(error_qubits[1], error_qubits[3])])
circuit.append(
[cirq.measure(error_qubits[2]),
cirq.measure(error_qubits[3])])
circuit.append(
[cirq.CCNOT(qubits[2], error_qubits[1], error_qubits[0])])
circuit.append([cirq.measure(*qubits)])
# export to qasm
qasm_str = circuit.to_qasm()
# import qiskit from qasm
qiskit_circuit = qiskitqc.from_qasm_str(qasm_str)
# run qiskit
transpiled = transpile(qiskit_circuit, backend)
qobj = assemble(transpiled, backend, shots=100)
job = backend.run(qobj)
print(job.job_id())
result = job.result()
counts = result.get_counts()
delayed_result = backend.retrieve_job(job.job_id()).result()
delayed_counts = delayed_result.get_counts()
print(counts)
print(delayed_counts)
i = 1 # Start from 1, as it would be dictionary accessed by result state length
for q_list in qubits_lists:
filters[i] = generate_error_mitigation_filter(q_list, noise_model)
i += 1
return filters
def generate_error_mitigation_filter(q_list, noise_model):
backend = get_sim_backend_from_name("qasm_simulator")
qr = QuantumRegister(5)
meas_cals, state_labels = complete_meas_cal(qubit_list=q_list, qr=qr)
calibration_job = execute(meas_cals,
backend=backend,
shots=8192,
noise_model=noise_model)
cal_results = calibration_job.result()
meas_fitter = CompleteMeasFitter(cal_results, state_labels)
em_filter = meas_fitter.filter
return em_filter
def draw_circuit(circuit, file_name='my_circuit.png'):
circuit.draw(output='mpl', filename=file_name)
IBMQ.save_account(Qconfig.APItoken, overwrite=True)
acc = IBMQ.load_account()
acc.credentials
from decouple import config
from qiskit import IBMQ
from datetime import datetime
def pdt():
print(datetime.now())
def interim_result_callback(job_id, interim_result):
print(f"interim result: {interim_result}")
IBMQ.save_account(config('IBM_API_KEY'), overwrite=True)
IBMQ.load_account()
IBMQ.providers()
provider = IBMQ.get_provider(hub='strangeworks-hub',
group='science-team',
project='science-test')
print(provider.backends())
if provider.has_service('runtime'):
pdt()
provider.runtime.pprint_programs()
program = provider.runtime.program('sample-program')
print(program)
backend = provider.get_backend('ibmq_montreal')
program_inputs = {'iterations': 3}
options = {'backend_name': backend.name()}
job = provider.runtime.run(program_id="sample-program",
from functions import QuantumNeuralNetwork, EffectiveDimension
from qiskit.aqua import QuantumInstance
from qiskit import IBMQ, Aer
from qiskit.providers.aer.noise.noise_model import NoiseModel
import numpy as np
from qiskit.circuit.library import ZZFeatureMap, RealAmplitudes
TOKEN = 'insert token here'
IBMQ.save_account(TOKEN, overwrite=True)
provider = IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q-internal', group='deployed', project='default')
backend_name = 'ibmq_montreal'
backend_ibmq = provider.get_backend(backend_name)
properties = backend_ibmq.properties()
coupling_map = backend_ibmq.configuration().coupling_map
noise_model = NoiseModel.from_backend(properties)
layout = [3, 5, 8, 11, 14, 13, 12, 10] # might need to change
qi_ibmq_noise_model = QuantumInstance(backend=Aer.get_backend('qasm_simulator'),
noise_model=noise_model, optimization_level=0, shots=8000,
seed_transpiler=2, initial_layout=layout)
qi = qi_ibmq_noise_model
compile_config = {'initial_layout': layout,
'seed_transpiler': 2,
'optimization_level': 3
}
n = [1000, 2000, 8000, 10000, 40000, 60000, 100000, 150000, 200000, 500000, 1000000, 10000000, 10000000000, 10000000000000]
qubits = 8
fm = ZZFeatureMap(qubits, reps=2, entanglement='full')
varform = RealAmplitudes(qubits, reps=9, entanglement='full')
qnet = QuantumNeuralNetwork(fm, varform)
ed = EffectiveDimension(qnet, 100, 100)
def load_IBMQ(token, hub, group, project):
IBMQ.save_account(token, overwrite=True)
IBMQ.load_account()
provider = IBMQ.get_provider(hub=hub, group=group, project=project)
return provider
#
# 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.
"""Example used in the README. In this example a Bell state is made."""
# Import Qiskit
from qiskit import QuantumCircuit
from qiskit import execute, IBMQ, BasicAer
from qiskit.providers.ibmq import least_busy
provider = IBMQ.save_account('MY_API_TOKEN', overwrite=True)
# Create a Quantum Circuit
qc = QuantumCircuit(2, 2)
# Add a H gate on qubit 0, putting this qubit in superposition.
qc.h(0)
# Add a CX (CNOT) gate on control qubit 0 and target qubit 1, putting
# the qubits in a Bell state.
qc.cx(0, 1)
# Add a Measure gate to see the state.
qc.measure([0, 1], [0, 1])
# See a list of available local simulators
print("BasicAer backends: ", BasicAer.backends())
backend_sim = BasicAer.get_backend('qasm_simulator')
# -*- coding: utf-8 -*- # @Time : 2019/1/7 9:24 # @Author : Tan Zhijie # @Email : [email protected] # @File : test01.py # @Software: PyCharm # If you want to execute your code on a quantum chip: My_token = 'f8513242b744d000bf38e991fab133505f6b8535ae48af9215f08a36c798a85446b833b7ea9045af5aea6c5a3601c5b8db43b052df88fcbce85ae833b42e4942' from qiskit import IBMQ IBMQ.save_account(My_token)
################################################################################
from __future__ import print_function
import tbvaccine as tb
tb.add_hook(isolate=False, show_vars=False)
import numpy as np
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_alice = QuantumRegister(2, "q(alice)")
q_bob = QuantumRegister(1, "q(bob)")
c0 = ClassicalRegister(1)
c1 = ClassicalRegister(1)
c_bob = ClassicalRegister(1, "c(bob)")
# c_alice = ClassicalRegister(1, "c(alice)")
# -*- coding: utf-8 -*-
"""
Created on Wed May 6 10:11:41 2020
@author: Ludovic
"""
from qiskit import *
from qiskit.visualization import plot_histogram
from qiskit.providers.ibmq import least_busy
from qiskit import IBMQ
IBMQ.save_account(
'ee21a38145df6f33181385a311fef503faacd13a50184ceb5594a846c586ce078cf8fb8f4aa2ff1f93577a38a270f19d9fa381dd5b3a3498293fd37d53f17001'
)
#number of qubit
nb_qubit = 3
qc = QuantumCircuit(nb_qubit)
#################################
### Step 1
### Superposition states
#################################
for i in range(0, nb_qubit, 1):
qc.h(i)
#################################
### Step 2
### Oracle
#################################
tensored_meas_cal,
CompleteMeasFitter,
TensoredMeasFitter)
from inspect import signature
import sys
import numpy as np
import itertools
import time
import datetime
import matplotlib.pyplot as plt
import func
from func import *
MY_API_KEY = 'b5c51e6cadaa798d2ca5b21a97e287c2f861f054dde9ef8908feb2ff66dbcf8f6004608cb967de6edaf30ec8cf19991c09255d57bd54ae764f233b1feb4c9f52'
IBMQ.save_account(MY_API_KEY)
provider = IBMQ.load_account()
small_devices = provider.backends(filters=lambda x: x.configuration().n_qubits
== 5 and not x.configuration().simulator)
backend = least_busy(small_devices)
# backend = provider.backends.ibmq_burlington
simulator = Aer.get_backend('qasm_simulator')
# U_f | x > | b > = | x > | b + f(x) >
# preserve the state of the first n qubits
# if f(x) == 0, we preserve the state of the helper qubit b
# otherwise, if f(x) == 1, we invert the state of the helper qubit
# U_f is just a 2^n by 2^n matrix where the "diagonal" consists of 2 by 2 blocks that are either the identity or Pauli X
# the i-th diagonal block corresponds to the i-th possible n-bit input x_i to f
## it is I if f(x_i) == 0
import qiskit
from qiskit import IBMQ
IBMQ.save_account('18b0689cff758ba84ee019f44bfcb11e4721ff0be5bce16b73e246637bf82a5b8e9c7bf189e8b06229622d1774a372a5df841714d8836e4e971d3b24fe7a381b')
IBMQ.load_account()
