Пример #1
0
    F1 = 3 - (np.sin(2 * a_beta)**2 * np.sin(2 * a_gamma)**2 - 0.5 * np.sin(
        4 * a_beta) * np.sin(4 * a_gamma)) * (1 + np.cos(4 * a_gamma)**2)

    result = np.where(F1 == np.amax(F1))
    a = list(zip(result[0], result[1]))[0]

    gamma = a[0] * step_size
    beta = a[1] * step_size

    prog = make_circuit(4)
    sample_shot = 3962
    writefile = open("../data/startQiskit_QC263.csv", "w")
    # prog.draw('mpl', filename=(kernel + '.png'))
    IBMQ.load_account()
    provider = IBMQ.get_provider(hub='ibm-q')
    provider.backends()
    backend = provider.get_backend("ibmq_5_yorktown")

    circuit1 = transpile(prog, FakeYorktown())
    circuit1.measure_all()
    prog = circuit1

    info = execute(prog, backend=backend,
                   shots=sample_shot).result().get_counts()

    print(info, file=writefile)
    print("results end", file=writefile)
    print(circuit1.depth(), file=writefile)
    print(circuit1, file=writefile)
    writefile.close()
# -*- 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(
    provider.backends(n_qubits=5, operational=True, simulator=False))
Пример #3
0
# In[10]:


result = execute(circuit, backend = simulator).result()


# In[11]:


plot_histogram(result.get_counts(circuit))


# In[12]:


provider = IBMQ.get_provider('ibm-q')


# In[14]:


qcomp = provider.get_backend('ibmq_16_melbourne')


# In[15]:


job = execute(circuit, backend = qcomp)


# In[ ]:
Пример #4
0
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)]


def shift_gate():
    q = QuantumRegister(3)
    circuit = QuantumCircuit(q, name='shift')

    circuit.ccx(0, 1, 2)
    circuit.cx(0, 1)
    circuit.x(0)
    circuit.x(1)
    circuit.ccx(0, 1, 2)
Пример #5
0
        # 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)
Пример #6
0
 def _initialize_backend(self, backend="ibmq_qasm_simulator"):
     #self.backend = IBMQ.get_backend(backend)
     #TO-DO once IBMQ.get_provider() actually works use that
     self.backend = IBMQ.get_provider().get_backend(backend)
Пример #7
0

# **1.3. Experimento:** Cuando un qubit esta inicializado en $|0>\rangle$ el resultado de la medición debe ser, en teoria, siempre $|0>\rangle$(con probabilidad del 100%). 1000 shots en computador cuantico real

# In[14]:


from qiskit import IBMQ
IBMQ.load_account()


# In[17]:


#Ejecución en un computador cuantico real
proveedor = IBMQ.get_provider('ibm-q')
comp_cuantico = proveedor.get_backend('ibmq_burlington')
ejecucion = execute(circuito_12, backend=comp_cuantico,shots=1000)

from qiskit.tools.monitor import job_monitor

job_monitor(ejecucion)

resultado = ejecucion.result()
conteos = resultado.get_counts()
print(conteos)


# In[20]:

Пример #8
0
    if not backend:
        backend = Aer.get_backend('qasm_simulator')

    elif type(backend) == str:

        if 'state' in backend:
            backend = Aer.get_backend('statevector_simulator')
            state_vector = execute(circuit, backend).result().get_statevector()
            return state_vector

        else:
            try:
                from warnings import filterwarnings
                filterwarnings("ignore")
                IBMQ.load_account()
                provider = IBMQ.get_provider("ibm-q")
                backend = provider.get_backend(backend)
            except Exception as e:
                print(f'Error: could not get IBMQ provider, {e}')
                assert None

    if display_job_status:
        print(f'running on: {backend.name()}')

    if measure:
        circuit.measure(range(len(circuit.clbits)), range(len(circuit.clbits)))

    if draw:
        print(circuit.draw())

    circuit.data = [e for e in circuit.data if type(e[0]) != Barrier]
Пример #9
0
import numpy as np
from qiskit import IBMQ
from qiskit import pulse  # This is where we access all of our Pulse features!
from qiskit.pulse import Play
from qiskit.pulse import pulse_lib  # This Pulse module helps us build sampled pulses for common pulse shapes
from qiskit import assemble
from qiskit.tools.monitor import job_monitor


"""
Программа для сбора данных с квантовго компьютера IBM Armonk
"""


IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')
backend = provider.get_backend('ibmq_armonk')
backend_config = backend.configuration()
assert backend_config.open_pulse, "Backend doesn't support Pulse"
dt = backend_config.dt
print(f"Sampling time: {dt * 1e9} ns")
backend_defaults = backend.defaults()

qubit = 0

# достаем из текстового файла частоту кубита и амплитуду pi импулса
with open("qubit_params.txt", "r") as f:
    rough_qubit_frequency, pi_amp = list(map(lambda x: float(x.strip()), f.readlines()))

us = 1.0e-6  # Microseconds
scale_factor = 1e-14
Пример #10
0
from functions import QuantumNeuralNetwork, EffectiveDimension
from qiskit.aqua import QuantumInstance
from qiskit import IBMQ, Aer
from qiskit.circuit.library import ZFeatureMap, RealAmplitudes
from qiskit.providers.aer.noise.noise_model import NoiseModel
import numpy as np

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 = [1, 2, 3, 5, 8, 11, 14, 13, 12, 10]
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 = 10
fm = ZFeatureMap(qubits, reps=1)
varform = RealAmplitudes(qubits, reps=9, entanglement='full')
qnet = QuantumNeuralNetwork(fm, varform)
ed = EffectiveDimension(qnet, 100, 100)