repo
stringclasses 900
values | file
stringclasses 754
values | content
stringlengths 4
215k
|
|---|---|---|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
!pip install -U -r grading_tools/requirements.txt
from IPython.display import clear_output
clear_output()
import numpy as np; pi = np.pi
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
from copy import deepcopy as make_copy
def prepare_hets_circuit(depth, angle1, angle2):
hets_circ = QuantumCircuit(depth)
hets_circ.ry(angle1, 0)
hets_circ.rz(angle1, 0)
hets_circ.ry(angle1, 1)
hets_circ.rz(angle1, 1)
for ii in range(depth):
hets_circ.cx(0,1)
hets_circ.ry(angle2,0)
hets_circ.rz(angle2,0)
hets_circ.ry(angle2,1)
hets_circ.rz(angle2,1)
return hets_circ
hets_circuit = prepare_hets_circuit(2, pi/2, pi/2)
hets_circuit.draw()
def measure_zz_circuit(given_circuit):
zz_meas = make_copy(given_circuit)
zz_meas.measure_all()
return zz_meas
zz_meas = measure_zz_circuit(hets_circuit)
zz_meas.draw()
simulator = Aer.get_backend('qasm_simulator')
result = execute(zz_meas, backend = simulator, shots=10000).result()
counts = result.get_counts(zz_meas)
plot_histogram(counts)
def measure_zz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zz = counts['00'] + counts['11'] - counts['01'] - counts['10']
zz = zz / total_counts
return zz
zz = measure_zz(hets_circuit)
print("<ZZ> =", str(zz))
def measure_zi(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zi = counts['00'] - counts['11'] + counts['01'] - counts['10']
zi = zi / total_counts
return zi
def measure_iz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
iz = counts['00'] - counts['11'] - counts['01'] + counts['10']
iz = iz / total_counts
return iz
zi = measure_zi(hets_circuit)
print("<ZI> =", str(zi))
iz = measure_iz(hets_circuit)
print("<IZ> =", str(iz))
def measure_xx_circuit(given_circuit):
xx_meas = make_copy(given_circuit)
### WRITE YOUR CODE BETWEEN THESE LINES - START
xx_meas.h(0)
xx_meas.h(1)
xx_meas.measure_all()
### WRITE YOUR CODE BETWEEN THESE LINES - END
return xx_meas
xx_meas = measure_xx_circuit(hets_circuit)
xx_meas.draw()
def measure_xx(given_circuit, num_shots = 10000):
xx_meas = measure_xx_circuit(given_circuit)
result = execute(xx_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(xx_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
xx = counts['00'] + counts['11'] - counts['01'] - counts['10']
xx = xx / total_counts
return xx
xx = measure_xx(hets_circuit)
print("<XX> =", str(xx))
def get_energy(given_circuit, num_shots = 10000):
zz = measure_zz(given_circuit, num_shots = num_shots)
iz = measure_iz(given_circuit, num_shots = num_shots)
zi = measure_zi(given_circuit, num_shots = num_shots)
xx = measure_xx(given_circuit, num_shots = num_shots)
energy = (-1.0523732)*1 + (0.39793742)*iz + (-0.3979374)*zi + (-0.0112801)*zz + (0.18093119)*xx
return energy
energy = get_energy(hets_circuit)
print("The energy of the trial state is", str(energy))
hets_circuit_plus = None
hets_circuit_minus = None
### WRITE YOUR CODE BETWEEN THESE LINES - START
hets_circuit_plus = prepare_hets_circuit(2, pi/2 + 0.1*pi/2, pi/2)
hets_circuit_minus = prepare_hets_circuit(2, pi/2 - 0.1*pi/2, pi/2)
### WRITE YOUR CODE BETWEEN THESE LINES - END
energy_plus = get_energy(hets_circuit_plus, num_shots=100000)
energy_minus = get_energy(hets_circuit_minus, num_shots=100000)
print(energy_plus, energy_minus)
name = 'Pon Rahul M'
email = 'ponrahul.21it@licet.ac.in'
### Do not change the lines below
from grading_tools import grade
grade(answer=measure_xx_circuit(hets_circuit), name=name, email=email, labid='lab9', exerciseid='ex1')
grade(answer=hets_circuit_plus, name=name, email=email, labid='lab9', exerciseid='ex2')
grade(answer=hets_circuit_minus, name=name, email=email, labid='lab9', exerciseid='ex3')
energy_plus_100, energy_plus_1000, energy_plus_10000 = 0, 0, 0
energy_minus_100, energy_minus_1000, energy_minus_10000 = 0, 0, 0
### WRITE YOUR CODE BETWEEN THESE LINES - START
energy_plus_100 = get_energy(hets_circuit_plus, num_shots = 100)
energy_minus_100 = get_energy(hets_circuit_minus, num_shots = 100)
energy_plus_1000 = get_energy(hets_circuit_plus, num_shots = 1000)
energy_minus_1000 = get_energy(hets_circuit_minus, num_shots = 1000)
energy_plus_10000 = get_energy(hets_circuit_plus, num_shots = 10000)
energy_minus_10000 = get_energy(hets_circuit_minus, num_shots = 10000)
### WRITE YOUR CODE BETWEEN THESE LINES - END
print(energy_plus_100, energy_minus_100, "difference = ", energy_minus_100 - energy_plus_100)
print(energy_plus_1000, energy_minus_1000, "difference = ", energy_minus_1000 - energy_plus_1000)
print(energy_plus_10000, energy_minus_10000, "difference = ", energy_minus_10000 - energy_plus_10000)
### WRITE YOUR CODE BETWEEN THESE LINES - START
I = np.array([
[1, 0],
[0, 1]
])
X = np.array([
[0, 1],
[1, 0]
])
Z = np.array([
[1, 0],
[0, -1]
])
h2_hamiltonian = (-1.0523732) * np.kron(I, I) + \
(0.39793742) * np.kron(I, Z) + \
(-0.3979374) * np.kron(Z, I) + \
(-0.0112801) * np.kron(Z, Z) + \
(0.18093119) * np.kron(X, X)
from numpy import linalg as LA
eigenvalues, eigenvectors = LA.eig(h2_hamiltonian)
for ii, eigenvalue in enumerate(eigenvalues):
print(f"Eigenvector {eigenvectors[:,ii]} has energy {eigenvalue}")
exact_eigenvector = eigenvectors[:,np.argmin(eigenvalues)]
exact_eigenvalue = np.min(eigenvalues)
print()
print("Minimum energy is", exact_eigenvalue)
### WRITE YOUR CODE BETWEEN THESE LINES - END
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
!pip install -U -r grading_tools/requirements.txt
from IPython.display import clear_output
clear_output()
import numpy as np; pi = np.pi
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
from copy import deepcopy as make_copy
def prepare_hets_circuit(depth, angle1, angle2):
hets_circ = QuantumCircuit(depth)
hets_circ.ry(angle1, 0)
hets_circ.rz(angle1, 0)
hets_circ.ry(angle1, 1)
hets_circ.rz(angle1, 1)
for ii in range(depth):
hets_circ.cx(0,1)
hets_circ.ry(angle2,0)
hets_circ.rz(angle2,0)
hets_circ.ry(angle2,1)
hets_circ.rz(angle2,1)
return hets_circ
hets_circuit = prepare_hets_circuit(2, pi/2, pi/2)
hets_circuit.draw()
def measure_zz_circuit(given_circuit):
zz_meas = make_copy(given_circuit)
zz_meas.measure_all()
return zz_meas
zz_meas = measure_zz_circuit(hets_circuit)
zz_meas.draw()
simulator = Aer.get_backend('qasm_simulator')
result = execute(zz_meas, backend = simulator, shots=10000).result()
counts = result.get_counts(zz_meas)
plot_histogram(counts)
def measure_zz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zz = counts['00'] + counts['11'] - counts['01'] - counts['10']
zz = zz / total_counts
return zz
zz = measure_zz(hets_circuit)
print("<ZZ> =", str(zz))
def measure_zi(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zi = counts['00'] - counts['11'] + counts['01'] - counts['10']
zi = zi / total_counts
return zi
def measure_iz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
iz = counts['00'] - counts['11'] - counts['01'] + counts['10']
iz = iz / total_counts
return iz
zi = measure_zi(hets_circuit)
print("<ZI> =", str(zi))
iz = measure_iz(hets_circuit)
print("<IZ> =", str(iz))
def measure_xx_circuit(given_circuit):
xx_meas = make_copy(given_circuit)
### WRITE YOUR CODE BETWEEN THESE LINES - START
xx_meas.h(0)
xx_meas.h(1)
xx_meas.measure_all()
### WRITE YOUR CODE BETWEEN THESE LINES - END
return xx_meas
xx_meas = measure_xx_circuit(hets_circuit)
xx_meas.draw()
def measure_xx(given_circuit, num_shots = 10000):
xx_meas = measure_xx_circuit(given_circuit)
result = execute(xx_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(xx_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
xx = counts['00'] + counts['11'] - counts['01'] - counts['10']
xx = xx / total_counts
return xx
xx = measure_xx(hets_circuit)
print("<XX> =", str(xx))
def get_energy(given_circuit, num_shots = 10000):
zz = measure_zz(given_circuit, num_shots = num_shots)
iz = measure_iz(given_circuit, num_shots = num_shots)
zi = measure_zi(given_circuit, num_shots = num_shots)
xx = measure_xx(given_circuit, num_shots = num_shots)
energy = (-1.0523732)*1 + (0.39793742)*iz + (-0.3979374)*zi + (-0.0112801)*zz + (0.18093119)*xx
return energy
energy = get_energy(hets_circuit)
print("The energy of the trial state is", str(energy))
hets_circuit_plus = None
hets_circuit_minus = None
### WRITE YOUR CODE BETWEEN THESE LINES - START
hets_circuit_plus = prepare_hets_circuit(2, pi/2 + 0.1*pi/2, pi/2)
hets_circuit_minus = prepare_hets_circuit(2, pi/2 - 0.1*pi/2, pi/2)
### WRITE YOUR CODE BETWEEN THESE LINES - END
energy_plus = get_energy(hets_circuit_plus, num_shots=100000)
energy_minus = get_energy(hets_circuit_minus, num_shots=100000)
print(energy_plus, energy_minus)
name = 'Pon Rahul M'
email = 'ponrahul.21it@licet.ac.in'
### Do not change the lines below
from grading_tools import grade
grade(answer=measure_xx_circuit(hets_circuit), name=name, email=email, labid='lab9', exerciseid='ex1')
grade(answer=hets_circuit_plus, name=name, email=email, labid='lab9', exerciseid='ex2')
grade(answer=hets_circuit_minus, name=name, email=email, labid='lab9', exerciseid='ex3')
energy_plus_100, energy_plus_1000, energy_plus_10000 = 0, 0, 0
energy_minus_100, energy_minus_1000, energy_minus_10000 = 0, 0, 0
### WRITE YOUR CODE BETWEEN THESE LINES - START
energy_plus_100 = get_energy(hets_circuit_plus, num_shots = 100)
energy_minus_100 = get_energy(hets_circuit_minus, num_shots = 100)
energy_plus_1000 = get_energy(hets_circuit_plus, num_shots = 1000)
energy_minus_1000 = get_energy(hets_circuit_minus, num_shots = 1000)
energy_plus_10000 = get_energy(hets_circuit_plus, num_shots = 10000)
energy_minus_10000 = get_energy(hets_circuit_minus, num_shots = 10000)
### WRITE YOUR CODE BETWEEN THESE LINES - END
print(energy_plus_100, energy_minus_100, "difference = ", energy_minus_100 - energy_plus_100)
print(energy_plus_1000, energy_minus_1000, "difference = ", energy_minus_1000 - energy_plus_1000)
print(energy_plus_10000, energy_minus_10000, "difference = ", energy_minus_10000 - energy_plus_10000)
### WRITE YOUR CODE BETWEEN THESE LINES - START
I = np.array([
[1, 0],
[0, 1]
])
X = np.array([
[0, 1],
[1, 0]
])
Z = np.array([
[1, 0],
[0, -1]
])
h2_hamiltonian = (-1.0523732) * np.kron(I, I) + \
(0.39793742) * np.kron(I, Z) + \
(-0.3979374) * np.kron(Z, I) + \
(-0.0112801) * np.kron(Z, Z) + \
(0.18093119) * np.kron(X, X)
from numpy import linalg as LA
eigenvalues, eigenvectors = LA.eig(h2_hamiltonian)
for ii, eigenvalue in enumerate(eigenvalues):
print(f"Eigenvector {eigenvectors[:,ii]} has energy {eigenvalue}")
exact_eigenvector = eigenvectors[:,np.argmin(eigenvalues)]
exact_eigenvalue = np.min(eigenvalues)
print()
print("Minimum energy is", exact_eigenvalue)
### WRITE YOUR CODE BETWEEN THESE LINES - END
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# (C) Copyright IBM 2020.
#
# 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 json
from typing import Any, Callable, Optional, Tuple, Union
from urllib.parse import urljoin
from qiskit import QuantumCircuit, execute
from qiskit.providers import JobStatus
from qiskit.providers.ibmq.job import IBMQJob
from .api import get_server_endpoint, send_request, get_access_token, get_submission_endpoint
from .exercises import get_question_id
from .util import compute_cost, get_provider, get_job, circuit_to_json, get_job_urls, uses_multiqubit_gate
def _circuit_criteria(
circuit: QuantumCircuit,
max_qubits: Optional[int] = None,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False
) -> Tuple[Optional[int], Optional[int]]:
if max_qubits is not None and circuit.num_qubits > max_qubits:
print(f'Your circuit has {circuit.num_qubits} qubits, which exceeds the maximum allowed.')
print(f'Please reduce the number of qubits in your circuit to below {max_qubits}.')
return None, None
try:
if check_gates and not uses_multiqubit_gate(circuit):
print('Your circuit appears to not use any multi-quibit gates.')
print('Please review your circuit and try again.')
return None, None
cost = compute_cost(circuit)
if min_cost is not None and cost < min_cost:
print(f'Your circuit cost ({cost}) is too low. But if you are convinced that your circuit\n'
'is correct, please let us know in the `#ibm-quantum-challenge-2020` Slack channel.')
return None, None
return circuit.num_qubits, cost
except Exception as err:
print(f'Unable to compute cost: {err}')
return None, None
def _circuit_grading(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False,
max_qubits: Optional[int] = None,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
payload = None
server = None
if not isinstance(circuit, QuantumCircuit):
print(f'Expected a QuantumCircuit, but was given {type(circuit)}')
print(f'Please provide a circuit as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or '
'the grading servers are down right now.')
return None, None
else:
server = None
_, cost = _circuit_criteria(
circuit,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if cost is not None:
payload = {
'answer': circuit_to_json(circuit)
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def _job_grading(
job_or_id: Union[IBMQJob, str],
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
if not isinstance(job_or_id, IBMQJob) and not isinstance(job_or_id, str):
print(f'Expected an IBMQJob or a job ID, but was given {type(job_or_id)}')
print(f'Please submit a job as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or the grading '
'servers are down right now.')
return None, None
else:
server = None
job = get_job(job_or_id) if isinstance(job_or_id, str) else job_or_id
if not job:
print('An invalid or non-existent job was specified.')
return None, None
job_status = job.status()
if job_status in [JobStatus.CANCELLED, JobStatus.ERROR]:
print(f'Job did not successfully complete: {job_status.value}.')
return None, None
elif job_status is not JobStatus.DONE:
print(f'Job has not yet completed: {job_status.value}.')
print(f'Please wait for the job (id: {job.job_id()}) to complete then try again.')
return None, None
header = job.result().header.to_dict()
if 'qc_cost' not in header:
if is_submit:
print('An unprepared answer was specified. '
'Please prepare() and grade() answer before submitting.')
else:
print('An unprepared answer was specified. Please prepare() answer before grading.')
return None, None
download_url, result_url = get_job_urls(job)
if not download_url or not result_url:
print('Unable to obtain job URLs')
return None, None
payload = {
'answer': json.dumps({
'download_url': download_url,
'result_url': result_url
})
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def _number_grading(
answer: int,
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
if not isinstance(answer, int):
print(f'Expected a integer, but was given {type(answer)}')
print(f'Please provide a number as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server '
'or the grading servers are down right now.')
return None, None
else:
server = None
payload = {
'answer': str(answer)
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def prepare_circuit(
circuit: QuantumCircuit,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False,
**kwargs
) -> Optional[IBMQJob]:
job = None
if not isinstance(circuit, QuantumCircuit):
print(f'Expected a QuantumCircuit, but was given {type(circuit)}')
print(f'Please provide a circuit.')
return None
_, cost = _circuit_criteria(
circuit,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if cost is not None:
if 'backend' not in kwargs:
kwargs['backend'] = get_provider().get_backend('ibmq_qasm_simulator')
# execute experiments
print('Starting experiment. Please wait...')
job = execute(
circuit,
qobj_header={
'qc_cost': cost
},
**kwargs
)
print(f'You may monitor the job (id: {job.job_id()}) status '
'and proceed to grading when it successfully completes.')
return job
def prepare_solver(
solver_func: Callable,
lab_id: str,
ex_id: str,
problem_set: Optional[Any] = None,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False,
**kwargs
) -> Optional[IBMQJob]:
job = None
if not callable(solver_func):
print(f'Expected a function, but was given {type(solver_func)}')
print(f'Please provide a function that returns a QuantumCircuit.')
return None
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or the grading servers are down right now.')
return
endpoint = server + 'problem-set'
index, value = get_problem_set(lab_id, ex_id, endpoint)
print(f'Running {solver_func.__name__}...')
qc_1 = solver_func(problem_set)
_, cost = _circuit_criteria(
qc_1,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if value and index is not None and index >= 0 and cost is not None:
qc_2 = solver_func(value)
if 'backend' not in kwargs:
kwargs['backend'] = get_provider().get_backend('ibmq_qasm_simulator')
# execute experiments
print('Starting experiments. Please wait...')
job = execute(
[qc_1, qc_2],
qobj_header={
'qc_index': [None, index],
'qc_cost': cost
},
**kwargs
)
print(f'You may monitor the job (id: {job.job_id()}) status '
'and proceed to grading when it successfully completes.')
return job
def grade_circuit(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None
) -> bool:
payload, server = _circuit_grading(
circuit,
lab_id,
ex_id,
is_submit=False,
max_qubits=max_qubits,
min_cost=min_cost
)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def grade_job(
job_or_id: Union[IBMQJob, str],
lab_id: str,
ex_id: str
) -> bool:
payload, server = _job_grading(job_or_id, lab_id, ex_id, is_submit=False)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def grade_number(
answer: int,
lab_id: str,
ex_id: str
) -> bool:
payload, server = _number_grading(answer, lab_id, ex_id, is_submit=False)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def submit_circuit(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None
) -> bool:
payload, _ = _circuit_grading(
circuit,
lab_id,
ex_id,
is_submit=True,
max_qubits=max_qubits,
min_cost=min_cost
)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def submit_job(
job_or_id: IBMQJob,
lab_id: str,
ex_id: str,
) -> bool:
payload, _ = _job_grading(job_or_id, lab_id, ex_id, is_submit=True)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def submit_number(
answer: int,
lab_id: str,
ex_id: str
) -> bool:
payload, _ = _number_grading(answer, lab_id, ex_id, is_submit=True)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def get_problem_set(
lab_id: str, ex_id: str, endpoint: str
) -> Tuple[Optional[int], Optional[Any]]:
problem_set_response = None
try:
payload = {'question_id': get_question_id(lab_id, ex_id)}
problem_set_response = send_request(endpoint, query=payload, method='GET')
except Exception as err:
print('Unable to obtain the problem set')
if problem_set_response:
status = problem_set_response.get('status')
if status == 'valid':
try:
index = problem_set_response.get('index')
value = json.loads(problem_set_response.get('value'))
return index, value
except Exception as err:
print(f'Problem set could not be processed: {err}')
else:
cause = problem_set_response.get('cause')
print(f'Problem set failed: {cause}')
return None, None
def grade_answer(payload: dict, endpoint: str, cost: Optional[int] = None) -> bool:
try:
answer_response = send_request(endpoint, body=payload)
status = answer_response.get('status', None)
cause = answer_response.get('cause', None)
score = cost if cost else answer_response.get('score', None)
handle_grade_response(status, score=score, cause=cause)
return status == 'valid' or status is True
except Exception as err:
print(f'Failed: {err}')
return False
def submit_answer(payload: dict) -> bool:
try:
access_token = get_access_token()
baseurl = get_submission_endpoint()
endpoint = urljoin(baseurl, './challenges/answers')
submit_response = send_request(
endpoint,
body=payload,
query={'access_token': access_token}
)
status = submit_response.get('status', None)
if status is None:
status = submit_response.get('valid', None)
cause = submit_response.get('cause', None)
handle_submit_response(status, cause=cause)
return status == 'valid' or status is True
except Exception as err:
print(f'Failed: {err}')
return False
def handle_grade_response(
status: Optional[str], score: Optional[int] = None, cause: Optional[str] = None
) -> None:
if status == 'valid':
print('\nCongratulations 🎉! Your answer is correct.')
if score is not None:
print(f'Your score is {score}.')
elif status == 'invalid':
print(f'\nOops 😕! {cause}')
print('Please review your answer and try again.')
elif status == 'notFinished':
print(f'Job has not finished: {cause}')
print(f'Please wait for the job to complete then try again.')
else:
print(f'Failed: {cause}')
print('Unable to grade your answer.')
def handle_submit_response(
status: Union[str, bool], cause: Optional[str] = None
) -> None:
if status == 'valid' or status is True:
print('\nSuccess 🎉! Your answer has been submitted.')
elif status == 'invalid' or status is False:
print(f'\nOops 😕! {"Your answer is incorrect" if cause is None else cause}')
print('Make sure your answer is correct and successfully graded before submitting.')
elif status == 'notFinished':
print(f'Job has not finished: {cause}')
print(f'Please wait for the job to complete, grade it, and then try to submit again.')
else:
print(f'Failed: {cause}')
print('Unable to submit your answer at this time.')
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017.
#
# 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.
# pylint: disable=wrong-import-order
"""Main Qiskit public functionality."""
import pkgutil
# First, check for required Python and API version
from . import util
# qiskit errors operator
from .exceptions import QiskitError
# The main qiskit operators
from qiskit.circuit import ClassicalRegister
from qiskit.circuit import QuantumRegister
from qiskit.circuit import QuantumCircuit
# pylint: disable=redefined-builtin
from qiskit.tools.compiler import compile # TODO remove after 0.8
from qiskit.execute import execute
# The qiskit.extensions.x imports needs to be placed here due to the
# mechanism for adding gates dynamically.
import qiskit.extensions
import qiskit.circuit.measure
import qiskit.circuit.reset
# Allow extending this namespace. Please note that currently this line needs
# to be placed *before* the wrapper imports or any non-import code AND *before*
# importing the package you want to allow extensions for (in this case `backends`).
__path__ = pkgutil.extend_path(__path__, __name__)
# Please note these are global instances, not modules.
from qiskit.providers.basicaer import BasicAer
# Try to import the Aer provider if installed.
try:
from qiskit.providers.aer import Aer
except ImportError:
pass
# Try to import the IBMQ provider if installed.
try:
from qiskit.providers.ibmq import IBMQ
except ImportError:
pass
from .version import __version__
from .version import __qiskit_version__
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
!pip install -U -r grading_tools/requirements.txt
from IPython.display import clear_output
clear_output()
import numpy as np; pi = np.pi
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
from copy import deepcopy as make_copy
def prepare_hets_circuit(depth, angle1, angle2):
hets_circ = QuantumCircuit(depth)
hets_circ.ry(angle1, 0)
hets_circ.rz(angle1, 0)
hets_circ.ry(angle1, 1)
hets_circ.rz(angle1, 1)
for ii in range(depth):
hets_circ.cx(0,1)
hets_circ.ry(angle2,0)
hets_circ.rz(angle2,0)
hets_circ.ry(angle2,1)
hets_circ.rz(angle2,1)
return hets_circ
hets_circuit = prepare_hets_circuit(2, pi/2, pi/2)
hets_circuit.draw()
def measure_zz_circuit(given_circuit):
zz_meas = make_copy(given_circuit)
zz_meas.measure_all()
return zz_meas
zz_meas = measure_zz_circuit(hets_circuit)
zz_meas.draw()
simulator = Aer.get_backend('qasm_simulator')
result = execute(zz_meas, backend = simulator, shots=10000).result()
counts = result.get_counts(zz_meas)
plot_histogram(counts)
def measure_zz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zz = counts['00'] + counts['11'] - counts['01'] - counts['10']
zz = zz / total_counts
return zz
zz = measure_zz(hets_circuit)
print("<ZZ> =", str(zz))
def measure_zi(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zi = counts['00'] - counts['11'] + counts['01'] - counts['10']
zi = zi / total_counts
return zi
def measure_iz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
iz = counts['00'] - counts['11'] - counts['01'] + counts['10']
iz = iz / total_counts
return iz
zi = measure_zi(hets_circuit)
print("<ZI> =", str(zi))
iz = measure_iz(hets_circuit)
print("<IZ> =", str(iz))
def measure_xx_circuit(given_circuit):
xx_meas = make_copy(given_circuit)
### WRITE YOUR CODE BETWEEN THESE LINES - START
xx_meas.h(0)
xx_meas.h(1)
xx_meas.measure_all()
### WRITE YOUR CODE BETWEEN THESE LINES - END
return xx_meas
xx_meas = measure_xx_circuit(hets_circuit)
xx_meas.draw()
def measure_xx(given_circuit, num_shots = 10000):
xx_meas = measure_xx_circuit(given_circuit)
result = execute(xx_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(xx_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
xx = counts['00'] + counts['11'] - counts['01'] - counts['10']
xx = xx / total_counts
return xx
xx = measure_xx(hets_circuit)
print("<XX> =", str(xx))
def get_energy(given_circuit, num_shots = 10000):
zz = measure_zz(given_circuit, num_shots = num_shots)
iz = measure_iz(given_circuit, num_shots = num_shots)
zi = measure_zi(given_circuit, num_shots = num_shots)
xx = measure_xx(given_circuit, num_shots = num_shots)
energy = (-1.0523732)*1 + (0.39793742)*iz + (-0.3979374)*zi + (-0.0112801)*zz + (0.18093119)*xx
return energy
energy = get_energy(hets_circuit)
print("The energy of the trial state is", str(energy))
hets_circuit_plus = None
hets_circuit_minus = None
### WRITE YOUR CODE BETWEEN THESE LINES - START
hets_circuit_plus = prepare_hets_circuit(2, pi/2 + 0.1*pi/2, pi/2)
hets_circuit_minus = prepare_hets_circuit(2, pi/2 - 0.1*pi/2, pi/2)
### WRITE YOUR CODE BETWEEN THESE LINES - END
energy_plus = get_energy(hets_circuit_plus, num_shots=100000)
energy_minus = get_energy(hets_circuit_minus, num_shots=100000)
print(energy_plus, energy_minus)
name = 'Pon Rahul M'
email = 'ponrahul.21it@licet.ac.in'
### Do not change the lines below
from grading_tools import grade
grade(answer=measure_xx_circuit(hets_circuit), name=name, email=email, labid='lab9', exerciseid='ex1')
grade(answer=hets_circuit_plus, name=name, email=email, labid='lab9', exerciseid='ex2')
grade(answer=hets_circuit_minus, name=name, email=email, labid='lab9', exerciseid='ex3')
energy_plus_100, energy_plus_1000, energy_plus_10000 = 0, 0, 0
energy_minus_100, energy_minus_1000, energy_minus_10000 = 0, 0, 0
### WRITE YOUR CODE BETWEEN THESE LINES - START
energy_plus_100 = get_energy(hets_circuit_plus, num_shots = 100)
energy_minus_100 = get_energy(hets_circuit_minus, num_shots = 100)
energy_plus_1000 = get_energy(hets_circuit_plus, num_shots = 1000)
energy_minus_1000 = get_energy(hets_circuit_minus, num_shots = 1000)
energy_plus_10000 = get_energy(hets_circuit_plus, num_shots = 10000)
energy_minus_10000 = get_energy(hets_circuit_minus, num_shots = 10000)
### WRITE YOUR CODE BETWEEN THESE LINES - END
print(energy_plus_100, energy_minus_100, "difference = ", energy_minus_100 - energy_plus_100)
print(energy_plus_1000, energy_minus_1000, "difference = ", energy_minus_1000 - energy_plus_1000)
print(energy_plus_10000, energy_minus_10000, "difference = ", energy_minus_10000 - energy_plus_10000)
### WRITE YOUR CODE BETWEEN THESE LINES - START
I = np.array([
[1, 0],
[0, 1]
])
X = np.array([
[0, 1],
[1, 0]
])
Z = np.array([
[1, 0],
[0, -1]
])
h2_hamiltonian = (-1.0523732) * np.kron(I, I) + \
(0.39793742) * np.kron(I, Z) + \
(-0.3979374) * np.kron(Z, I) + \
(-0.0112801) * np.kron(Z, Z) + \
(0.18093119) * np.kron(X, X)
from numpy import linalg as LA
eigenvalues, eigenvectors = LA.eig(h2_hamiltonian)
for ii, eigenvalue in enumerate(eigenvalues):
print(f"Eigenvector {eigenvectors[:,ii]} has energy {eigenvalue}")
exact_eigenvector = eigenvectors[:,np.argmin(eigenvalues)]
exact_eigenvalue = np.min(eigenvalues)
print()
print("Minimum energy is", exact_eigenvalue)
### WRITE YOUR CODE BETWEEN THESE LINES - END
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
!pip install -U -r grading_tools/requirements.txt
from IPython.display import clear_output
clear_output()
import numpy as np; pi = np.pi
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
from copy import deepcopy as make_copy
def prepare_hets_circuit(depth, angle1, angle2):
hets_circ = QuantumCircuit(depth)
hets_circ.ry(angle1, 0)
hets_circ.rz(angle1, 0)
hets_circ.ry(angle1, 1)
hets_circ.rz(angle1, 1)
for ii in range(depth):
hets_circ.cx(0,1)
hets_circ.ry(angle2,0)
hets_circ.rz(angle2,0)
hets_circ.ry(angle2,1)
hets_circ.rz(angle2,1)
return hets_circ
hets_circuit = prepare_hets_circuit(2, pi/2, pi/2)
hets_circuit.draw()
def measure_zz_circuit(given_circuit):
zz_meas = make_copy(given_circuit)
zz_meas.measure_all()
return zz_meas
zz_meas = measure_zz_circuit(hets_circuit)
zz_meas.draw()
simulator = Aer.get_backend('qasm_simulator')
result = execute(zz_meas, backend = simulator, shots=10000).result()
counts = result.get_counts(zz_meas)
plot_histogram(counts)
def measure_zz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zz = counts['00'] + counts['11'] - counts['01'] - counts['10']
zz = zz / total_counts
return zz
zz = measure_zz(hets_circuit)
print("<ZZ> =", str(zz))
def measure_zi(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zi = counts['00'] - counts['11'] + counts['01'] - counts['10']
zi = zi / total_counts
return zi
def measure_iz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
iz = counts['00'] - counts['11'] - counts['01'] + counts['10']
iz = iz / total_counts
return iz
zi = measure_zi(hets_circuit)
print("<ZI> =", str(zi))
iz = measure_iz(hets_circuit)
print("<IZ> =", str(iz))
def measure_xx_circuit(given_circuit):
xx_meas = make_copy(given_circuit)
### WRITE YOUR CODE BETWEEN THESE LINES - START
xx_meas.h(0)
xx_meas.h(1)
xx_meas.measure_all()
### WRITE YOUR CODE BETWEEN THESE LINES - END
return xx_meas
xx_meas = measure_xx_circuit(hets_circuit)
xx_meas.draw()
def measure_xx(given_circuit, num_shots = 10000):
xx_meas = measure_xx_circuit(given_circuit)
result = execute(xx_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(xx_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
xx = counts['00'] + counts['11'] - counts['01'] - counts['10']
xx = xx / total_counts
return xx
xx = measure_xx(hets_circuit)
print("<XX> =", str(xx))
def get_energy(given_circuit, num_shots = 10000):
zz = measure_zz(given_circuit, num_shots = num_shots)
iz = measure_iz(given_circuit, num_shots = num_shots)
zi = measure_zi(given_circuit, num_shots = num_shots)
xx = measure_xx(given_circuit, num_shots = num_shots)
energy = (-1.0523732)*1 + (0.39793742)*iz + (-0.3979374)*zi + (-0.0112801)*zz + (0.18093119)*xx
return energy
energy = get_energy(hets_circuit)
print("The energy of the trial state is", str(energy))
hets_circuit_plus = None
hets_circuit_minus = None
### WRITE YOUR CODE BETWEEN THESE LINES - START
hets_circuit_plus = prepare_hets_circuit(2, pi/2 + 0.1*pi/2, pi/2)
hets_circuit_minus = prepare_hets_circuit(2, pi/2 - 0.1*pi/2, pi/2)
### WRITE YOUR CODE BETWEEN THESE LINES - END
energy_plus = get_energy(hets_circuit_plus, num_shots=100000)
energy_minus = get_energy(hets_circuit_minus, num_shots=100000)
print(energy_plus, energy_minus)
name = 'Pon Rahul M'
email = 'ponrahul.21it@licet.ac.in'
### Do not change the lines below
from grading_tools import grade
grade(answer=measure_xx_circuit(hets_circuit), name=name, email=email, labid='lab9', exerciseid='ex1')
grade(answer=hets_circuit_plus, name=name, email=email, labid='lab9', exerciseid='ex2')
grade(answer=hets_circuit_minus, name=name, email=email, labid='lab9', exerciseid='ex3')
energy_plus_100, energy_plus_1000, energy_plus_10000 = 0, 0, 0
energy_minus_100, energy_minus_1000, energy_minus_10000 = 0, 0, 0
### WRITE YOUR CODE BETWEEN THESE LINES - START
energy_plus_100 = get_energy(hets_circuit_plus, num_shots = 100)
energy_minus_100 = get_energy(hets_circuit_minus, num_shots = 100)
energy_plus_1000 = get_energy(hets_circuit_plus, num_shots = 1000)
energy_minus_1000 = get_energy(hets_circuit_minus, num_shots = 1000)
energy_plus_10000 = get_energy(hets_circuit_plus, num_shots = 10000)
energy_minus_10000 = get_energy(hets_circuit_minus, num_shots = 10000)
### WRITE YOUR CODE BETWEEN THESE LINES - END
print(energy_plus_100, energy_minus_100, "difference = ", energy_minus_100 - energy_plus_100)
print(energy_plus_1000, energy_minus_1000, "difference = ", energy_minus_1000 - energy_plus_1000)
print(energy_plus_10000, energy_minus_10000, "difference = ", energy_minus_10000 - energy_plus_10000)
### WRITE YOUR CODE BETWEEN THESE LINES - START
I = np.array([
[1, 0],
[0, 1]
])
X = np.array([
[0, 1],
[1, 0]
])
Z = np.array([
[1, 0],
[0, -1]
])
h2_hamiltonian = (-1.0523732) * np.kron(I, I) + \
(0.39793742) * np.kron(I, Z) + \
(-0.3979374) * np.kron(Z, I) + \
(-0.0112801) * np.kron(Z, Z) + \
(0.18093119) * np.kron(X, X)
from numpy import linalg as LA
eigenvalues, eigenvectors = LA.eig(h2_hamiltonian)
for ii, eigenvalue in enumerate(eigenvalues):
print(f"Eigenvector {eigenvectors[:,ii]} has energy {eigenvalue}")
exact_eigenvector = eigenvectors[:,np.argmin(eigenvalues)]
exact_eigenvalue = np.min(eigenvalues)
print()
print("Minimum energy is", exact_eigenvalue)
### WRITE YOUR CODE BETWEEN THESE LINES - END
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# (C) Copyright IBM 2020.
#
# 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 json
from typing import Any, Callable, Optional, Tuple, Union
from urllib.parse import urljoin
from qiskit import QuantumCircuit, execute
from qiskit.providers import JobStatus
from qiskit.providers.ibmq.job import IBMQJob
from .api import get_server_endpoint, send_request, get_access_token, get_submission_endpoint
from .exercises import get_question_id
from .util import compute_cost, get_provider, get_job, circuit_to_json, get_job_urls, uses_multiqubit_gate
def _circuit_criteria(
circuit: QuantumCircuit,
max_qubits: Optional[int] = None,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False
) -> Tuple[Optional[int], Optional[int]]:
if max_qubits is not None and circuit.num_qubits > max_qubits:
print(f'Your circuit has {circuit.num_qubits} qubits, which exceeds the maximum allowed.')
print(f'Please reduce the number of qubits in your circuit to below {max_qubits}.')
return None, None
try:
if check_gates and not uses_multiqubit_gate(circuit):
print('Your circuit appears to not use any multi-quibit gates.')
print('Please review your circuit and try again.')
return None, None
cost = compute_cost(circuit)
if min_cost is not None and cost < min_cost:
print(f'Your circuit cost ({cost}) is too low. But if you are convinced that your circuit\n'
'is correct, please let us know in the `#ibm-quantum-challenge-2020` Slack channel.')
return None, None
return circuit.num_qubits, cost
except Exception as err:
print(f'Unable to compute cost: {err}')
return None, None
def _circuit_grading(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False,
max_qubits: Optional[int] = None,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
payload = None
server = None
if not isinstance(circuit, QuantumCircuit):
print(f'Expected a QuantumCircuit, but was given {type(circuit)}')
print(f'Please provide a circuit as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or '
'the grading servers are down right now.')
return None, None
else:
server = None
_, cost = _circuit_criteria(
circuit,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if cost is not None:
payload = {
'answer': circuit_to_json(circuit)
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def _job_grading(
job_or_id: Union[IBMQJob, str],
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
if not isinstance(job_or_id, IBMQJob) and not isinstance(job_or_id, str):
print(f'Expected an IBMQJob or a job ID, but was given {type(job_or_id)}')
print(f'Please submit a job as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or the grading '
'servers are down right now.')
return None, None
else:
server = None
job = get_job(job_or_id) if isinstance(job_or_id, str) else job_or_id
if not job:
print('An invalid or non-existent job was specified.')
return None, None
job_status = job.status()
if job_status in [JobStatus.CANCELLED, JobStatus.ERROR]:
print(f'Job did not successfully complete: {job_status.value}.')
return None, None
elif job_status is not JobStatus.DONE:
print(f'Job has not yet completed: {job_status.value}.')
print(f'Please wait for the job (id: {job.job_id()}) to complete then try again.')
return None, None
header = job.result().header.to_dict()
if 'qc_cost' not in header:
if is_submit:
print('An unprepared answer was specified. '
'Please prepare() and grade() answer before submitting.')
else:
print('An unprepared answer was specified. Please prepare() answer before grading.')
return None, None
download_url, result_url = get_job_urls(job)
if not download_url or not result_url:
print('Unable to obtain job URLs')
return None, None
payload = {
'answer': json.dumps({
'download_url': download_url,
'result_url': result_url
})
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def _number_grading(
answer: int,
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
if not isinstance(answer, int):
print(f'Expected a integer, but was given {type(answer)}')
print(f'Please provide a number as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server '
'or the grading servers are down right now.')
return None, None
else:
server = None
payload = {
'answer': str(answer)
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def prepare_circuit(
circuit: QuantumCircuit,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False,
**kwargs
) -> Optional[IBMQJob]:
job = None
if not isinstance(circuit, QuantumCircuit):
print(f'Expected a QuantumCircuit, but was given {type(circuit)}')
print(f'Please provide a circuit.')
return None
_, cost = _circuit_criteria(
circuit,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if cost is not None:
if 'backend' not in kwargs:
kwargs['backend'] = get_provider().get_backend('ibmq_qasm_simulator')
# execute experiments
print('Starting experiment. Please wait...')
job = execute(
circuit,
qobj_header={
'qc_cost': cost
},
**kwargs
)
print(f'You may monitor the job (id: {job.job_id()}) status '
'and proceed to grading when it successfully completes.')
return job
def prepare_solver(
solver_func: Callable,
lab_id: str,
ex_id: str,
problem_set: Optional[Any] = None,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False,
**kwargs
) -> Optional[IBMQJob]:
job = None
if not callable(solver_func):
print(f'Expected a function, but was given {type(solver_func)}')
print(f'Please provide a function that returns a QuantumCircuit.')
return None
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or the grading servers are down right now.')
return
endpoint = server + 'problem-set'
index, value = get_problem_set(lab_id, ex_id, endpoint)
print(f'Running {solver_func.__name__}...')
qc_1 = solver_func(problem_set)
_, cost = _circuit_criteria(
qc_1,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if value and index is not None and index >= 0 and cost is not None:
qc_2 = solver_func(value)
if 'backend' not in kwargs:
kwargs['backend'] = get_provider().get_backend('ibmq_qasm_simulator')
# execute experiments
print('Starting experiments. Please wait...')
job = execute(
[qc_1, qc_2],
qobj_header={
'qc_index': [None, index],
'qc_cost': cost
},
**kwargs
)
print(f'You may monitor the job (id: {job.job_id()}) status '
'and proceed to grading when it successfully completes.')
return job
def grade_circuit(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None
) -> bool:
payload, server = _circuit_grading(
circuit,
lab_id,
ex_id,
is_submit=False,
max_qubits=max_qubits,
min_cost=min_cost
)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def grade_job(
job_or_id: Union[IBMQJob, str],
lab_id: str,
ex_id: str
) -> bool:
payload, server = _job_grading(job_or_id, lab_id, ex_id, is_submit=False)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def grade_number(
answer: int,
lab_id: str,
ex_id: str
) -> bool:
payload, server = _number_grading(answer, lab_id, ex_id, is_submit=False)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def submit_circuit(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None
) -> bool:
payload, _ = _circuit_grading(
circuit,
lab_id,
ex_id,
is_submit=True,
max_qubits=max_qubits,
min_cost=min_cost
)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def submit_job(
job_or_id: IBMQJob,
lab_id: str,
ex_id: str,
) -> bool:
payload, _ = _job_grading(job_or_id, lab_id, ex_id, is_submit=True)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def submit_number(
answer: int,
lab_id: str,
ex_id: str
) -> bool:
payload, _ = _number_grading(answer, lab_id, ex_id, is_submit=True)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def get_problem_set(
lab_id: str, ex_id: str, endpoint: str
) -> Tuple[Optional[int], Optional[Any]]:
problem_set_response = None
try:
payload = {'question_id': get_question_id(lab_id, ex_id)}
problem_set_response = send_request(endpoint, query=payload, method='GET')
except Exception as err:
print('Unable to obtain the problem set')
if problem_set_response:
status = problem_set_response.get('status')
if status == 'valid':
try:
index = problem_set_response.get('index')
value = json.loads(problem_set_response.get('value'))
return index, value
except Exception as err:
print(f'Problem set could not be processed: {err}')
else:
cause = problem_set_response.get('cause')
print(f'Problem set failed: {cause}')
return None, None
def grade_answer(payload: dict, endpoint: str, cost: Optional[int] = None) -> bool:
try:
answer_response = send_request(endpoint, body=payload)
status = answer_response.get('status', None)
cause = answer_response.get('cause', None)
score = cost if cost else answer_response.get('score', None)
handle_grade_response(status, score=score, cause=cause)
return status == 'valid' or status is True
except Exception as err:
print(f'Failed: {err}')
return False
def submit_answer(payload: dict) -> bool:
try:
access_token = get_access_token()
baseurl = get_submission_endpoint()
endpoint = urljoin(baseurl, './challenges/answers')
submit_response = send_request(
endpoint,
body=payload,
query={'access_token': access_token}
)
status = submit_response.get('status', None)
if status is None:
status = submit_response.get('valid', None)
cause = submit_response.get('cause', None)
handle_submit_response(status, cause=cause)
return status == 'valid' or status is True
except Exception as err:
print(f'Failed: {err}')
return False
def handle_grade_response(
status: Optional[str], score: Optional[int] = None, cause: Optional[str] = None
) -> None:
if status == 'valid':
print('\nCongratulations 🎉! Your answer is correct.')
if score is not None:
print(f'Your score is {score}.')
elif status == 'invalid':
print(f'\nOops 😕! {cause}')
print('Please review your answer and try again.')
elif status == 'notFinished':
print(f'Job has not finished: {cause}')
print(f'Please wait for the job to complete then try again.')
else:
print(f'Failed: {cause}')
print('Unable to grade your answer.')
def handle_submit_response(
status: Union[str, bool], cause: Optional[str] = None
) -> None:
if status == 'valid' or status is True:
print('\nSuccess 🎉! Your answer has been submitted.')
elif status == 'invalid' or status is False:
print(f'\nOops 😕! {"Your answer is incorrect" if cause is None else cause}')
print('Make sure your answer is correct and successfully graded before submitting.')
elif status == 'notFinished':
print(f'Job has not finished: {cause}')
print(f'Please wait for the job to complete, grade it, and then try to submit again.')
else:
print(f'Failed: {cause}')
print('Unable to submit your answer at this time.')
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017.
#
# 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.
# pylint: disable=wrong-import-order
"""Main Qiskit public functionality."""
import pkgutil
# First, check for required Python and API version
from . import util
# qiskit errors operator
from .exceptions import QiskitError
# The main qiskit operators
from qiskit.circuit import ClassicalRegister
from qiskit.circuit import QuantumRegister
from qiskit.circuit import QuantumCircuit
# pylint: disable=redefined-builtin
from qiskit.tools.compiler import compile # TODO remove after 0.8
from qiskit.execute import execute
# The qiskit.extensions.x imports needs to be placed here due to the
# mechanism for adding gates dynamically.
import qiskit.extensions
import qiskit.circuit.measure
import qiskit.circuit.reset
# Allow extending this namespace. Please note that currently this line needs
# to be placed *before* the wrapper imports or any non-import code AND *before*
# importing the package you want to allow extensions for (in this case `backends`).
__path__ = pkgutil.extend_path(__path__, __name__)
# Please note these are global instances, not modules.
from qiskit.providers.basicaer import BasicAer
# Try to import the Aer provider if installed.
try:
from qiskit.providers.aer import Aer
except ImportError:
pass
# Try to import the IBMQ provider if installed.
try:
from qiskit.providers.ibmq import IBMQ
except ImportError:
pass
from .version import __version__
from .version import __qiskit_version__
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
!pip install -U -r grading_tools/requirements.txt
from IPython.display import clear_output
clear_output()
import numpy as np; pi = np.pi
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
from copy import deepcopy as make_copy
def prepare_hets_circuit(depth, angle1, angle2):
hets_circ = QuantumCircuit(depth)
hets_circ.ry(angle1, 0)
hets_circ.rz(angle1, 0)
hets_circ.ry(angle1, 1)
hets_circ.rz(angle1, 1)
for ii in range(depth):
hets_circ.cx(0,1)
hets_circ.ry(angle2,0)
hets_circ.rz(angle2,0)
hets_circ.ry(angle2,1)
hets_circ.rz(angle2,1)
return hets_circ
hets_circuit = prepare_hets_circuit(2, pi/2, pi/2)
hets_circuit.draw()
def measure_zz_circuit(given_circuit):
zz_meas = make_copy(given_circuit)
zz_meas.measure_all()
return zz_meas
zz_meas = measure_zz_circuit(hets_circuit)
zz_meas.draw()
simulator = Aer.get_backend('qasm_simulator')
result = execute(zz_meas, backend = simulator, shots=10000).result()
counts = result.get_counts(zz_meas)
plot_histogram(counts)
def measure_zz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zz = counts['00'] + counts['11'] - counts['01'] - counts['10']
zz = zz / total_counts
return zz
zz = measure_zz(hets_circuit)
print("<ZZ> =", str(zz))
def measure_zi(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zi = counts['00'] - counts['11'] + counts['01'] - counts['10']
zi = zi / total_counts
return zi
def measure_iz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
iz = counts['00'] - counts['11'] - counts['01'] + counts['10']
iz = iz / total_counts
return iz
zi = measure_zi(hets_circuit)
print("<ZI> =", str(zi))
iz = measure_iz(hets_circuit)
print("<IZ> =", str(iz))
def measure_xx_circuit(given_circuit):
xx_meas = make_copy(given_circuit)
### WRITE YOUR CODE BETWEEN THESE LINES - START
xx_meas.h(0)
xx_meas.h(1)
xx_meas.measure_all()
### WRITE YOUR CODE BETWEEN THESE LINES - END
return xx_meas
xx_meas = measure_xx_circuit(hets_circuit)
xx_meas.draw()
def measure_xx(given_circuit, num_shots = 10000):
xx_meas = measure_xx_circuit(given_circuit)
result = execute(xx_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(xx_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
xx = counts['00'] + counts['11'] - counts['01'] - counts['10']
xx = xx / total_counts
return xx
xx = measure_xx(hets_circuit)
print("<XX> =", str(xx))
def get_energy(given_circuit, num_shots = 10000):
zz = measure_zz(given_circuit, num_shots = num_shots)
iz = measure_iz(given_circuit, num_shots = num_shots)
zi = measure_zi(given_circuit, num_shots = num_shots)
xx = measure_xx(given_circuit, num_shots = num_shots)
energy = (-1.0523732)*1 + (0.39793742)*iz + (-0.3979374)*zi + (-0.0112801)*zz + (0.18093119)*xx
return energy
energy = get_energy(hets_circuit)
print("The energy of the trial state is", str(energy))
hets_circuit_plus = None
hets_circuit_minus = None
### WRITE YOUR CODE BETWEEN THESE LINES - START
hets_circuit_plus = prepare_hets_circuit(2, pi/2 + 0.1*pi/2, pi/2)
hets_circuit_minus = prepare_hets_circuit(2, pi/2 - 0.1*pi/2, pi/2)
### WRITE YOUR CODE BETWEEN THESE LINES - END
energy_plus = get_energy(hets_circuit_plus, num_shots=100000)
energy_minus = get_energy(hets_circuit_minus, num_shots=100000)
print(energy_plus, energy_minus)
name = 'Pon Rahul M'
email = 'ponrahul.21it@licet.ac.in'
### Do not change the lines below
from grading_tools import grade
grade(answer=measure_xx_circuit(hets_circuit), name=name, email=email, labid='lab9', exerciseid='ex1')
grade(answer=hets_circuit_plus, name=name, email=email, labid='lab9', exerciseid='ex2')
grade(answer=hets_circuit_minus, name=name, email=email, labid='lab9', exerciseid='ex3')
energy_plus_100, energy_plus_1000, energy_plus_10000 = 0, 0, 0
energy_minus_100, energy_minus_1000, energy_minus_10000 = 0, 0, 0
### WRITE YOUR CODE BETWEEN THESE LINES - START
energy_plus_100 = get_energy(hets_circuit_plus, num_shots = 100)
energy_minus_100 = get_energy(hets_circuit_minus, num_shots = 100)
energy_plus_1000 = get_energy(hets_circuit_plus, num_shots = 1000)
energy_minus_1000 = get_energy(hets_circuit_minus, num_shots = 1000)
energy_plus_10000 = get_energy(hets_circuit_plus, num_shots = 10000)
energy_minus_10000 = get_energy(hets_circuit_minus, num_shots = 10000)
### WRITE YOUR CODE BETWEEN THESE LINES - END
print(energy_plus_100, energy_minus_100, "difference = ", energy_minus_100 - energy_plus_100)
print(energy_plus_1000, energy_minus_1000, "difference = ", energy_minus_1000 - energy_plus_1000)
print(energy_plus_10000, energy_minus_10000, "difference = ", energy_minus_10000 - energy_plus_10000)
### WRITE YOUR CODE BETWEEN THESE LINES - START
I = np.array([
[1, 0],
[0, 1]
])
X = np.array([
[0, 1],
[1, 0]
])
Z = np.array([
[1, 0],
[0, -1]
])
h2_hamiltonian = (-1.0523732) * np.kron(I, I) + \
(0.39793742) * np.kron(I, Z) + \
(-0.3979374) * np.kron(Z, I) + \
(-0.0112801) * np.kron(Z, Z) + \
(0.18093119) * np.kron(X, X)
from numpy import linalg as LA
eigenvalues, eigenvectors = LA.eig(h2_hamiltonian)
for ii, eigenvalue in enumerate(eigenvalues):
print(f"Eigenvector {eigenvectors[:,ii]} has energy {eigenvalue}")
exact_eigenvector = eigenvectors[:,np.argmin(eigenvalues)]
exact_eigenvalue = np.min(eigenvalues)
print()
print("Minimum energy is", exact_eigenvalue)
### WRITE YOUR CODE BETWEEN THESE LINES - END
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
!pip install -U -r grading_tools/requirements.txt
from IPython.display import clear_output
clear_output()
import numpy as np; pi = np.pi
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
from copy import deepcopy as make_copy
def prepare_hets_circuit(depth, angle1, angle2):
hets_circ = QuantumCircuit(depth)
hets_circ.ry(angle1, 0)
hets_circ.rz(angle1, 0)
hets_circ.ry(angle1, 1)
hets_circ.rz(angle1, 1)
for ii in range(depth):
hets_circ.cx(0,1)
hets_circ.ry(angle2,0)
hets_circ.rz(angle2,0)
hets_circ.ry(angle2,1)
hets_circ.rz(angle2,1)
return hets_circ
hets_circuit = prepare_hets_circuit(2, pi/2, pi/2)
hets_circuit.draw()
def measure_zz_circuit(given_circuit):
zz_meas = make_copy(given_circuit)
zz_meas.measure_all()
return zz_meas
zz_meas = measure_zz_circuit(hets_circuit)
zz_meas.draw()
simulator = Aer.get_backend('qasm_simulator')
result = execute(zz_meas, backend = simulator, shots=10000).result()
counts = result.get_counts(zz_meas)
plot_histogram(counts)
def measure_zz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zz = counts['00'] + counts['11'] - counts['01'] - counts['10']
zz = zz / total_counts
return zz
zz = measure_zz(hets_circuit)
print("<ZZ> =", str(zz))
def measure_zi(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zi = counts['00'] - counts['11'] + counts['01'] - counts['10']
zi = zi / total_counts
return zi
def measure_iz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
iz = counts['00'] - counts['11'] - counts['01'] + counts['10']
iz = iz / total_counts
return iz
zi = measure_zi(hets_circuit)
print("<ZI> =", str(zi))
iz = measure_iz(hets_circuit)
print("<IZ> =", str(iz))
def measure_xx_circuit(given_circuit):
xx_meas = make_copy(given_circuit)
### WRITE YOUR CODE BETWEEN THESE LINES - START
xx_meas.h(0)
xx_meas.h(1)
xx_meas.measure_all()
### WRITE YOUR CODE BETWEEN THESE LINES - END
return xx_meas
xx_meas = measure_xx_circuit(hets_circuit)
xx_meas.draw()
def measure_xx(given_circuit, num_shots = 10000):
xx_meas = measure_xx_circuit(given_circuit)
result = execute(xx_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(xx_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
xx = counts['00'] + counts['11'] - counts['01'] - counts['10']
xx = xx / total_counts
return xx
xx = measure_xx(hets_circuit)
print("<XX> =", str(xx))
def get_energy(given_circuit, num_shots = 10000):
zz = measure_zz(given_circuit, num_shots = num_shots)
iz = measure_iz(given_circuit, num_shots = num_shots)
zi = measure_zi(given_circuit, num_shots = num_shots)
xx = measure_xx(given_circuit, num_shots = num_shots)
energy = (-1.0523732)*1 + (0.39793742)*iz + (-0.3979374)*zi + (-0.0112801)*zz + (0.18093119)*xx
return energy
energy = get_energy(hets_circuit)
print("The energy of the trial state is", str(energy))
hets_circuit_plus = None
hets_circuit_minus = None
### WRITE YOUR CODE BETWEEN THESE LINES - START
hets_circuit_plus = prepare_hets_circuit(2, pi/2 + 0.1*pi/2, pi/2)
hets_circuit_minus = prepare_hets_circuit(2, pi/2 - 0.1*pi/2, pi/2)
### WRITE YOUR CODE BETWEEN THESE LINES - END
energy_plus = get_energy(hets_circuit_plus, num_shots=100000)
energy_minus = get_energy(hets_circuit_minus, num_shots=100000)
print(energy_plus, energy_minus)
name = 'Pon Rahul M'
email = 'ponrahul.21it@licet.ac.in'
### Do not change the lines below
from grading_tools import grade
grade(answer=measure_xx_circuit(hets_circuit), name=name, email=email, labid='lab9', exerciseid='ex1')
grade(answer=hets_circuit_plus, name=name, email=email, labid='lab9', exerciseid='ex2')
grade(answer=hets_circuit_minus, name=name, email=email, labid='lab9', exerciseid='ex3')
energy_plus_100, energy_plus_1000, energy_plus_10000 = 0, 0, 0
energy_minus_100, energy_minus_1000, energy_minus_10000 = 0, 0, 0
### WRITE YOUR CODE BETWEEN THESE LINES - START
energy_plus_100 = get_energy(hets_circuit_plus, num_shots = 100)
energy_minus_100 = get_energy(hets_circuit_minus, num_shots = 100)
energy_plus_1000 = get_energy(hets_circuit_plus, num_shots = 1000)
energy_minus_1000 = get_energy(hets_circuit_minus, num_shots = 1000)
energy_plus_10000 = get_energy(hets_circuit_plus, num_shots = 10000)
energy_minus_10000 = get_energy(hets_circuit_minus, num_shots = 10000)
### WRITE YOUR CODE BETWEEN THESE LINES - END
print(energy_plus_100, energy_minus_100, "difference = ", energy_minus_100 - energy_plus_100)
print(energy_plus_1000, energy_minus_1000, "difference = ", energy_minus_1000 - energy_plus_1000)
print(energy_plus_10000, energy_minus_10000, "difference = ", energy_minus_10000 - energy_plus_10000)
### WRITE YOUR CODE BETWEEN THESE LINES - START
I = np.array([
[1, 0],
[0, 1]
])
X = np.array([
[0, 1],
[1, 0]
])
Z = np.array([
[1, 0],
[0, -1]
])
h2_hamiltonian = (-1.0523732) * np.kron(I, I) + \
(0.39793742) * np.kron(I, Z) + \
(-0.3979374) * np.kron(Z, I) + \
(-0.0112801) * np.kron(Z, Z) + \
(0.18093119) * np.kron(X, X)
from numpy import linalg as LA
eigenvalues, eigenvectors = LA.eig(h2_hamiltonian)
for ii, eigenvalue in enumerate(eigenvalues):
print(f"Eigenvector {eigenvectors[:,ii]} has energy {eigenvalue}")
exact_eigenvector = eigenvectors[:,np.argmin(eigenvalues)]
exact_eigenvalue = np.min(eigenvalues)
print()
print("Minimum energy is", exact_eigenvalue)
### WRITE YOUR CODE BETWEEN THESE LINES - END
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# (C) Copyright IBM 2020.
#
# 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 json
from typing import Any, Callable, Optional, Tuple, Union
from urllib.parse import urljoin
from qiskit import QuantumCircuit, execute
from qiskit.providers import JobStatus
from qiskit.providers.ibmq.job import IBMQJob
from .api import get_server_endpoint, send_request, get_access_token, get_submission_endpoint
from .exercises import get_question_id
from .util import compute_cost, get_provider, get_job, circuit_to_json, get_job_urls, uses_multiqubit_gate
def _circuit_criteria(
circuit: QuantumCircuit,
max_qubits: Optional[int] = None,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False
) -> Tuple[Optional[int], Optional[int]]:
if max_qubits is not None and circuit.num_qubits > max_qubits:
print(f'Your circuit has {circuit.num_qubits} qubits, which exceeds the maximum allowed.')
print(f'Please reduce the number of qubits in your circuit to below {max_qubits}.')
return None, None
try:
if check_gates and not uses_multiqubit_gate(circuit):
print('Your circuit appears to not use any multi-quibit gates.')
print('Please review your circuit and try again.')
return None, None
cost = compute_cost(circuit)
if min_cost is not None and cost < min_cost:
print(f'Your circuit cost ({cost}) is too low. But if you are convinced that your circuit\n'
'is correct, please let us know in the `#ibm-quantum-challenge-2020` Slack channel.')
return None, None
return circuit.num_qubits, cost
except Exception as err:
print(f'Unable to compute cost: {err}')
return None, None
def _circuit_grading(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False,
max_qubits: Optional[int] = None,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
payload = None
server = None
if not isinstance(circuit, QuantumCircuit):
print(f'Expected a QuantumCircuit, but was given {type(circuit)}')
print(f'Please provide a circuit as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or '
'the grading servers are down right now.')
return None, None
else:
server = None
_, cost = _circuit_criteria(
circuit,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if cost is not None:
payload = {
'answer': circuit_to_json(circuit)
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def _job_grading(
job_or_id: Union[IBMQJob, str],
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
if not isinstance(job_or_id, IBMQJob) and not isinstance(job_or_id, str):
print(f'Expected an IBMQJob or a job ID, but was given {type(job_or_id)}')
print(f'Please submit a job as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or the grading '
'servers are down right now.')
return None, None
else:
server = None
job = get_job(job_or_id) if isinstance(job_or_id, str) else job_or_id
if not job:
print('An invalid or non-existent job was specified.')
return None, None
job_status = job.status()
if job_status in [JobStatus.CANCELLED, JobStatus.ERROR]:
print(f'Job did not successfully complete: {job_status.value}.')
return None, None
elif job_status is not JobStatus.DONE:
print(f'Job has not yet completed: {job_status.value}.')
print(f'Please wait for the job (id: {job.job_id()}) to complete then try again.')
return None, None
header = job.result().header.to_dict()
if 'qc_cost' not in header:
if is_submit:
print('An unprepared answer was specified. '
'Please prepare() and grade() answer before submitting.')
else:
print('An unprepared answer was specified. Please prepare() answer before grading.')
return None, None
download_url, result_url = get_job_urls(job)
if not download_url or not result_url:
print('Unable to obtain job URLs')
return None, None
payload = {
'answer': json.dumps({
'download_url': download_url,
'result_url': result_url
})
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def _number_grading(
answer: int,
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
if not isinstance(answer, int):
print(f'Expected a integer, but was given {type(answer)}')
print(f'Please provide a number as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server '
'or the grading servers are down right now.')
return None, None
else:
server = None
payload = {
'answer': str(answer)
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def prepare_circuit(
circuit: QuantumCircuit,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False,
**kwargs
) -> Optional[IBMQJob]:
job = None
if not isinstance(circuit, QuantumCircuit):
print(f'Expected a QuantumCircuit, but was given {type(circuit)}')
print(f'Please provide a circuit.')
return None
_, cost = _circuit_criteria(
circuit,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if cost is not None:
if 'backend' not in kwargs:
kwargs['backend'] = get_provider().get_backend('ibmq_qasm_simulator')
# execute experiments
print('Starting experiment. Please wait...')
job = execute(
circuit,
qobj_header={
'qc_cost': cost
},
**kwargs
)
print(f'You may monitor the job (id: {job.job_id()}) status '
'and proceed to grading when it successfully completes.')
return job
def prepare_solver(
solver_func: Callable,
lab_id: str,
ex_id: str,
problem_set: Optional[Any] = None,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False,
**kwargs
) -> Optional[IBMQJob]:
job = None
if not callable(solver_func):
print(f'Expected a function, but was given {type(solver_func)}')
print(f'Please provide a function that returns a QuantumCircuit.')
return None
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or the grading servers are down right now.')
return
endpoint = server + 'problem-set'
index, value = get_problem_set(lab_id, ex_id, endpoint)
print(f'Running {solver_func.__name__}...')
qc_1 = solver_func(problem_set)
_, cost = _circuit_criteria(
qc_1,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if value and index is not None and index >= 0 and cost is not None:
qc_2 = solver_func(value)
if 'backend' not in kwargs:
kwargs['backend'] = get_provider().get_backend('ibmq_qasm_simulator')
# execute experiments
print('Starting experiments. Please wait...')
job = execute(
[qc_1, qc_2],
qobj_header={
'qc_index': [None, index],
'qc_cost': cost
},
**kwargs
)
print(f'You may monitor the job (id: {job.job_id()}) status '
'and proceed to grading when it successfully completes.')
return job
def grade_circuit(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None
) -> bool:
payload, server = _circuit_grading(
circuit,
lab_id,
ex_id,
is_submit=False,
max_qubits=max_qubits,
min_cost=min_cost
)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def grade_job(
job_or_id: Union[IBMQJob, str],
lab_id: str,
ex_id: str
) -> bool:
payload, server = _job_grading(job_or_id, lab_id, ex_id, is_submit=False)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def grade_number(
answer: int,
lab_id: str,
ex_id: str
) -> bool:
payload, server = _number_grading(answer, lab_id, ex_id, is_submit=False)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def submit_circuit(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None
) -> bool:
payload, _ = _circuit_grading(
circuit,
lab_id,
ex_id,
is_submit=True,
max_qubits=max_qubits,
min_cost=min_cost
)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def submit_job(
job_or_id: IBMQJob,
lab_id: str,
ex_id: str,
) -> bool:
payload, _ = _job_grading(job_or_id, lab_id, ex_id, is_submit=True)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def submit_number(
answer: int,
lab_id: str,
ex_id: str
) -> bool:
payload, _ = _number_grading(answer, lab_id, ex_id, is_submit=True)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def get_problem_set(
lab_id: str, ex_id: str, endpoint: str
) -> Tuple[Optional[int], Optional[Any]]:
problem_set_response = None
try:
payload = {'question_id': get_question_id(lab_id, ex_id)}
problem_set_response = send_request(endpoint, query=payload, method='GET')
except Exception as err:
print('Unable to obtain the problem set')
if problem_set_response:
status = problem_set_response.get('status')
if status == 'valid':
try:
index = problem_set_response.get('index')
value = json.loads(problem_set_response.get('value'))
return index, value
except Exception as err:
print(f'Problem set could not be processed: {err}')
else:
cause = problem_set_response.get('cause')
print(f'Problem set failed: {cause}')
return None, None
def grade_answer(payload: dict, endpoint: str, cost: Optional[int] = None) -> bool:
try:
answer_response = send_request(endpoint, body=payload)
status = answer_response.get('status', None)
cause = answer_response.get('cause', None)
score = cost if cost else answer_response.get('score', None)
handle_grade_response(status, score=score, cause=cause)
return status == 'valid' or status is True
except Exception as err:
print(f'Failed: {err}')
return False
def submit_answer(payload: dict) -> bool:
try:
access_token = get_access_token()
baseurl = get_submission_endpoint()
endpoint = urljoin(baseurl, './challenges/answers')
submit_response = send_request(
endpoint,
body=payload,
query={'access_token': access_token}
)
status = submit_response.get('status', None)
if status is None:
status = submit_response.get('valid', None)
cause = submit_response.get('cause', None)
handle_submit_response(status, cause=cause)
return status == 'valid' or status is True
except Exception as err:
print(f'Failed: {err}')
return False
def handle_grade_response(
status: Optional[str], score: Optional[int] = None, cause: Optional[str] = None
) -> None:
if status == 'valid':
print('\nCongratulations 🎉! Your answer is correct.')
if score is not None:
print(f'Your score is {score}.')
elif status == 'invalid':
print(f'\nOops 😕! {cause}')
print('Please review your answer and try again.')
elif status == 'notFinished':
print(f'Job has not finished: {cause}')
print(f'Please wait for the job to complete then try again.')
else:
print(f'Failed: {cause}')
print('Unable to grade your answer.')
def handle_submit_response(
status: Union[str, bool], cause: Optional[str] = None
) -> None:
if status == 'valid' or status is True:
print('\nSuccess 🎉! Your answer has been submitted.')
elif status == 'invalid' or status is False:
print(f'\nOops 😕! {"Your answer is incorrect" if cause is None else cause}')
print('Make sure your answer is correct and successfully graded before submitting.')
elif status == 'notFinished':
print(f'Job has not finished: {cause}')
print(f'Please wait for the job to complete, grade it, and then try to submit again.')
else:
print(f'Failed: {cause}')
print('Unable to submit your answer at this time.')
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017.
#
# 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.
# pylint: disable=wrong-import-order
"""Main Qiskit public functionality."""
import pkgutil
# First, check for required Python and API version
from . import util
# qiskit errors operator
from .exceptions import QiskitError
# The main qiskit operators
from qiskit.circuit import ClassicalRegister
from qiskit.circuit import QuantumRegister
from qiskit.circuit import QuantumCircuit
# pylint: disable=redefined-builtin
from qiskit.tools.compiler import compile # TODO remove after 0.8
from qiskit.execute import execute
# The qiskit.extensions.x imports needs to be placed here due to the
# mechanism for adding gates dynamically.
import qiskit.extensions
import qiskit.circuit.measure
import qiskit.circuit.reset
# Allow extending this namespace. Please note that currently this line needs
# to be placed *before* the wrapper imports or any non-import code AND *before*
# importing the package you want to allow extensions for (in this case `backends`).
__path__ = pkgutil.extend_path(__path__, __name__)
# Please note these are global instances, not modules.
from qiskit.providers.basicaer import BasicAer
# Try to import the Aer provider if installed.
try:
from qiskit.providers.aer import Aer
except ImportError:
pass
# Try to import the IBMQ provider if installed.
try:
from qiskit.providers.ibmq import IBMQ
except ImportError:
pass
from .version import __version__
from .version import __qiskit_version__
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
!pip install -U -r grading_tools/requirements.txt
from IPython.display import clear_output
clear_output()
import numpy as np; pi = np.pi
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
from copy import deepcopy as make_copy
def prepare_hets_circuit(depth, angle1, angle2):
hets_circ = QuantumCircuit(depth)
hets_circ.ry(angle1, 0)
hets_circ.rz(angle1, 0)
hets_circ.ry(angle1, 1)
hets_circ.rz(angle1, 1)
for ii in range(depth):
hets_circ.cx(0,1)
hets_circ.ry(angle2,0)
hets_circ.rz(angle2,0)
hets_circ.ry(angle2,1)
hets_circ.rz(angle2,1)
return hets_circ
hets_circuit = prepare_hets_circuit(2, pi/2, pi/2)
hets_circuit.draw()
def measure_zz_circuit(given_circuit):
zz_meas = make_copy(given_circuit)
zz_meas.measure_all()
return zz_meas
zz_meas = measure_zz_circuit(hets_circuit)
zz_meas.draw()
simulator = Aer.get_backend('qasm_simulator')
result = execute(zz_meas, backend = simulator, shots=10000).result()
counts = result.get_counts(zz_meas)
plot_histogram(counts)
def measure_zz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zz = counts['00'] + counts['11'] - counts['01'] - counts['10']
zz = zz / total_counts
return zz
zz = measure_zz(hets_circuit)
print("<ZZ> =", str(zz))
def measure_zi(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zi = counts['00'] - counts['11'] + counts['01'] - counts['10']
zi = zi / total_counts
return zi
def measure_iz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
iz = counts['00'] - counts['11'] - counts['01'] + counts['10']
iz = iz / total_counts
return iz
zi = measure_zi(hets_circuit)
print("<ZI> =", str(zi))
iz = measure_iz(hets_circuit)
print("<IZ> =", str(iz))
def measure_xx_circuit(given_circuit):
xx_meas = make_copy(given_circuit)
### WRITE YOUR CODE BETWEEN THESE LINES - START
xx_meas.h(0)
xx_meas.h(1)
xx_meas.measure_all()
### WRITE YOUR CODE BETWEEN THESE LINES - END
return xx_meas
xx_meas = measure_xx_circuit(hets_circuit)
xx_meas.draw()
def measure_xx(given_circuit, num_shots = 10000):
xx_meas = measure_xx_circuit(given_circuit)
result = execute(xx_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(xx_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
xx = counts['00'] + counts['11'] - counts['01'] - counts['10']
xx = xx / total_counts
return xx
xx = measure_xx(hets_circuit)
print("<XX> =", str(xx))
def get_energy(given_circuit, num_shots = 10000):
zz = measure_zz(given_circuit, num_shots = num_shots)
iz = measure_iz(given_circuit, num_shots = num_shots)
zi = measure_zi(given_circuit, num_shots = num_shots)
xx = measure_xx(given_circuit, num_shots = num_shots)
energy = (-1.0523732)*1 + (0.39793742)*iz + (-0.3979374)*zi + (-0.0112801)*zz + (0.18093119)*xx
return energy
energy = get_energy(hets_circuit)
print("The energy of the trial state is", str(energy))
hets_circuit_plus = None
hets_circuit_minus = None
### WRITE YOUR CODE BETWEEN THESE LINES - START
hets_circuit_plus = prepare_hets_circuit(2, pi/2 + 0.1*pi/2, pi/2)
hets_circuit_minus = prepare_hets_circuit(2, pi/2 - 0.1*pi/2, pi/2)
### WRITE YOUR CODE BETWEEN THESE LINES - END
energy_plus = get_energy(hets_circuit_plus, num_shots=100000)
energy_minus = get_energy(hets_circuit_minus, num_shots=100000)
print(energy_plus, energy_minus)
name = 'Pon Rahul M'
email = 'ponrahul.21it@licet.ac.in'
### Do not change the lines below
from grading_tools import grade
grade(answer=measure_xx_circuit(hets_circuit), name=name, email=email, labid='lab9', exerciseid='ex1')
grade(answer=hets_circuit_plus, name=name, email=email, labid='lab9', exerciseid='ex2')
grade(answer=hets_circuit_minus, name=name, email=email, labid='lab9', exerciseid='ex3')
energy_plus_100, energy_plus_1000, energy_plus_10000 = 0, 0, 0
energy_minus_100, energy_minus_1000, energy_minus_10000 = 0, 0, 0
### WRITE YOUR CODE BETWEEN THESE LINES - START
energy_plus_100 = get_energy(hets_circuit_plus, num_shots = 100)
energy_minus_100 = get_energy(hets_circuit_minus, num_shots = 100)
energy_plus_1000 = get_energy(hets_circuit_plus, num_shots = 1000)
energy_minus_1000 = get_energy(hets_circuit_minus, num_shots = 1000)
energy_plus_10000 = get_energy(hets_circuit_plus, num_shots = 10000)
energy_minus_10000 = get_energy(hets_circuit_minus, num_shots = 10000)
### WRITE YOUR CODE BETWEEN THESE LINES - END
print(energy_plus_100, energy_minus_100, "difference = ", energy_minus_100 - energy_plus_100)
print(energy_plus_1000, energy_minus_1000, "difference = ", energy_minus_1000 - energy_plus_1000)
print(energy_plus_10000, energy_minus_10000, "difference = ", energy_minus_10000 - energy_plus_10000)
### WRITE YOUR CODE BETWEEN THESE LINES - START
I = np.array([
[1, 0],
[0, 1]
])
X = np.array([
[0, 1],
[1, 0]
])
Z = np.array([
[1, 0],
[0, -1]
])
h2_hamiltonian = (-1.0523732) * np.kron(I, I) + \
(0.39793742) * np.kron(I, Z) + \
(-0.3979374) * np.kron(Z, I) + \
(-0.0112801) * np.kron(Z, Z) + \
(0.18093119) * np.kron(X, X)
from numpy import linalg as LA
eigenvalues, eigenvectors = LA.eig(h2_hamiltonian)
for ii, eigenvalue in enumerate(eigenvalues):
print(f"Eigenvector {eigenvectors[:,ii]} has energy {eigenvalue}")
exact_eigenvector = eigenvectors[:,np.argmin(eigenvalues)]
exact_eigenvalue = np.min(eigenvalues)
print()
print("Minimum energy is", exact_eigenvalue)
### WRITE YOUR CODE BETWEEN THESE LINES - END
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
!pip install -U -r grading_tools/requirements.txt
from IPython.display import clear_output
clear_output()
import numpy as np; pi = np.pi
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
from copy import deepcopy as make_copy
def prepare_hets_circuit(depth, angle1, angle2):
hets_circ = QuantumCircuit(depth)
hets_circ.ry(angle1, 0)
hets_circ.rz(angle1, 0)
hets_circ.ry(angle1, 1)
hets_circ.rz(angle1, 1)
for ii in range(depth):
hets_circ.cx(0,1)
hets_circ.ry(angle2,0)
hets_circ.rz(angle2,0)
hets_circ.ry(angle2,1)
hets_circ.rz(angle2,1)
return hets_circ
hets_circuit = prepare_hets_circuit(2, pi/2, pi/2)
hets_circuit.draw()
def measure_zz_circuit(given_circuit):
zz_meas = make_copy(given_circuit)
zz_meas.measure_all()
return zz_meas
zz_meas = measure_zz_circuit(hets_circuit)
zz_meas.draw()
simulator = Aer.get_backend('qasm_simulator')
result = execute(zz_meas, backend = simulator, shots=10000).result()
counts = result.get_counts(zz_meas)
plot_histogram(counts)
def measure_zz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zz = counts['00'] + counts['11'] - counts['01'] - counts['10']
zz = zz / total_counts
return zz
zz = measure_zz(hets_circuit)
print("<ZZ> =", str(zz))
def measure_zi(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zi = counts['00'] - counts['11'] + counts['01'] - counts['10']
zi = zi / total_counts
return zi
def measure_iz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
iz = counts['00'] - counts['11'] - counts['01'] + counts['10']
iz = iz / total_counts
return iz
zi = measure_zi(hets_circuit)
print("<ZI> =", str(zi))
iz = measure_iz(hets_circuit)
print("<IZ> =", str(iz))
def measure_xx_circuit(given_circuit):
xx_meas = make_copy(given_circuit)
### WRITE YOUR CODE BETWEEN THESE LINES - START
xx_meas.h(0)
xx_meas.h(1)
xx_meas.measure_all()
### WRITE YOUR CODE BETWEEN THESE LINES - END
return xx_meas
xx_meas = measure_xx_circuit(hets_circuit)
xx_meas.draw()
def measure_xx(given_circuit, num_shots = 10000):
xx_meas = measure_xx_circuit(given_circuit)
result = execute(xx_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(xx_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
xx = counts['00'] + counts['11'] - counts['01'] - counts['10']
xx = xx / total_counts
return xx
xx = measure_xx(hets_circuit)
print("<XX> =", str(xx))
def get_energy(given_circuit, num_shots = 10000):
zz = measure_zz(given_circuit, num_shots = num_shots)
iz = measure_iz(given_circuit, num_shots = num_shots)
zi = measure_zi(given_circuit, num_shots = num_shots)
xx = measure_xx(given_circuit, num_shots = num_shots)
energy = (-1.0523732)*1 + (0.39793742)*iz + (-0.3979374)*zi + (-0.0112801)*zz + (0.18093119)*xx
return energy
energy = get_energy(hets_circuit)
print("The energy of the trial state is", str(energy))
hets_circuit_plus = None
hets_circuit_minus = None
### WRITE YOUR CODE BETWEEN THESE LINES - START
hets_circuit_plus = prepare_hets_circuit(2, pi/2 + 0.1*pi/2, pi/2)
hets_circuit_minus = prepare_hets_circuit(2, pi/2 - 0.1*pi/2, pi/2)
### WRITE YOUR CODE BETWEEN THESE LINES - END
energy_plus = get_energy(hets_circuit_plus, num_shots=100000)
energy_minus = get_energy(hets_circuit_minus, num_shots=100000)
print(energy_plus, energy_minus)
name = 'Pon Rahul M'
email = 'ponrahul.21it@licet.ac.in'
### Do not change the lines below
from grading_tools import grade
grade(answer=measure_xx_circuit(hets_circuit), name=name, email=email, labid='lab9', exerciseid='ex1')
grade(answer=hets_circuit_plus, name=name, email=email, labid='lab9', exerciseid='ex2')
grade(answer=hets_circuit_minus, name=name, email=email, labid='lab9', exerciseid='ex3')
energy_plus_100, energy_plus_1000, energy_plus_10000 = 0, 0, 0
energy_minus_100, energy_minus_1000, energy_minus_10000 = 0, 0, 0
### WRITE YOUR CODE BETWEEN THESE LINES - START
energy_plus_100 = get_energy(hets_circuit_plus, num_shots = 100)
energy_minus_100 = get_energy(hets_circuit_minus, num_shots = 100)
energy_plus_1000 = get_energy(hets_circuit_plus, num_shots = 1000)
energy_minus_1000 = get_energy(hets_circuit_minus, num_shots = 1000)
energy_plus_10000 = get_energy(hets_circuit_plus, num_shots = 10000)
energy_minus_10000 = get_energy(hets_circuit_minus, num_shots = 10000)
### WRITE YOUR CODE BETWEEN THESE LINES - END
print(energy_plus_100, energy_minus_100, "difference = ", energy_minus_100 - energy_plus_100)
print(energy_plus_1000, energy_minus_1000, "difference = ", energy_minus_1000 - energy_plus_1000)
print(energy_plus_10000, energy_minus_10000, "difference = ", energy_minus_10000 - energy_plus_10000)
### WRITE YOUR CODE BETWEEN THESE LINES - START
I = np.array([
[1, 0],
[0, 1]
])
X = np.array([
[0, 1],
[1, 0]
])
Z = np.array([
[1, 0],
[0, -1]
])
h2_hamiltonian = (-1.0523732) * np.kron(I, I) + \
(0.39793742) * np.kron(I, Z) + \
(-0.3979374) * np.kron(Z, I) + \
(-0.0112801) * np.kron(Z, Z) + \
(0.18093119) * np.kron(X, X)
from numpy import linalg as LA
eigenvalues, eigenvectors = LA.eig(h2_hamiltonian)
for ii, eigenvalue in enumerate(eigenvalues):
print(f"Eigenvector {eigenvectors[:,ii]} has energy {eigenvalue}")
exact_eigenvector = eigenvectors[:,np.argmin(eigenvalues)]
exact_eigenvalue = np.min(eigenvalues)
print()
print("Minimum energy is", exact_eigenvalue)
### WRITE YOUR CODE BETWEEN THESE LINES - END
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# (C) Copyright IBM 2020.
#
# 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 json
from typing import Any, Callable, Optional, Tuple, Union
from urllib.parse import urljoin
from qiskit import QuantumCircuit, execute
from qiskit.providers import JobStatus
from qiskit.providers.ibmq.job import IBMQJob
from .api import get_server_endpoint, send_request, get_access_token, get_submission_endpoint
from .exercises import get_question_id
from .util import compute_cost, get_provider, get_job, circuit_to_json, get_job_urls, uses_multiqubit_gate
def _circuit_criteria(
circuit: QuantumCircuit,
max_qubits: Optional[int] = None,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False
) -> Tuple[Optional[int], Optional[int]]:
if max_qubits is not None and circuit.num_qubits > max_qubits:
print(f'Your circuit has {circuit.num_qubits} qubits, which exceeds the maximum allowed.')
print(f'Please reduce the number of qubits in your circuit to below {max_qubits}.')
return None, None
try:
if check_gates and not uses_multiqubit_gate(circuit):
print('Your circuit appears to not use any multi-quibit gates.')
print('Please review your circuit and try again.')
return None, None
cost = compute_cost(circuit)
if min_cost is not None and cost < min_cost:
print(f'Your circuit cost ({cost}) is too low. But if you are convinced that your circuit\n'
'is correct, please let us know in the `#ibm-quantum-challenge-2020` Slack channel.')
return None, None
return circuit.num_qubits, cost
except Exception as err:
print(f'Unable to compute cost: {err}')
return None, None
def _circuit_grading(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False,
max_qubits: Optional[int] = None,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
payload = None
server = None
if not isinstance(circuit, QuantumCircuit):
print(f'Expected a QuantumCircuit, but was given {type(circuit)}')
print(f'Please provide a circuit as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or '
'the grading servers are down right now.')
return None, None
else:
server = None
_, cost = _circuit_criteria(
circuit,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if cost is not None:
payload = {
'answer': circuit_to_json(circuit)
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def _job_grading(
job_or_id: Union[IBMQJob, str],
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
if not isinstance(job_or_id, IBMQJob) and not isinstance(job_or_id, str):
print(f'Expected an IBMQJob or a job ID, but was given {type(job_or_id)}')
print(f'Please submit a job as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or the grading '
'servers are down right now.')
return None, None
else:
server = None
job = get_job(job_or_id) if isinstance(job_or_id, str) else job_or_id
if not job:
print('An invalid or non-existent job was specified.')
return None, None
job_status = job.status()
if job_status in [JobStatus.CANCELLED, JobStatus.ERROR]:
print(f'Job did not successfully complete: {job_status.value}.')
return None, None
elif job_status is not JobStatus.DONE:
print(f'Job has not yet completed: {job_status.value}.')
print(f'Please wait for the job (id: {job.job_id()}) to complete then try again.')
return None, None
header = job.result().header.to_dict()
if 'qc_cost' not in header:
if is_submit:
print('An unprepared answer was specified. '
'Please prepare() and grade() answer before submitting.')
else:
print('An unprepared answer was specified. Please prepare() answer before grading.')
return None, None
download_url, result_url = get_job_urls(job)
if not download_url or not result_url:
print('Unable to obtain job URLs')
return None, None
payload = {
'answer': json.dumps({
'download_url': download_url,
'result_url': result_url
})
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def _number_grading(
answer: int,
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
if not isinstance(answer, int):
print(f'Expected a integer, but was given {type(answer)}')
print(f'Please provide a number as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server '
'or the grading servers are down right now.')
return None, None
else:
server = None
payload = {
'answer': str(answer)
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def prepare_circuit(
circuit: QuantumCircuit,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False,
**kwargs
) -> Optional[IBMQJob]:
job = None
if not isinstance(circuit, QuantumCircuit):
print(f'Expected a QuantumCircuit, but was given {type(circuit)}')
print(f'Please provide a circuit.')
return None
_, cost = _circuit_criteria(
circuit,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if cost is not None:
if 'backend' not in kwargs:
kwargs['backend'] = get_provider().get_backend('ibmq_qasm_simulator')
# execute experiments
print('Starting experiment. Please wait...')
job = execute(
circuit,
qobj_header={
'qc_cost': cost
},
**kwargs
)
print(f'You may monitor the job (id: {job.job_id()}) status '
'and proceed to grading when it successfully completes.')
return job
def prepare_solver(
solver_func: Callable,
lab_id: str,
ex_id: str,
problem_set: Optional[Any] = None,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False,
**kwargs
) -> Optional[IBMQJob]:
job = None
if not callable(solver_func):
print(f'Expected a function, but was given {type(solver_func)}')
print(f'Please provide a function that returns a QuantumCircuit.')
return None
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or the grading servers are down right now.')
return
endpoint = server + 'problem-set'
index, value = get_problem_set(lab_id, ex_id, endpoint)
print(f'Running {solver_func.__name__}...')
qc_1 = solver_func(problem_set)
_, cost = _circuit_criteria(
qc_1,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if value and index is not None and index >= 0 and cost is not None:
qc_2 = solver_func(value)
if 'backend' not in kwargs:
kwargs['backend'] = get_provider().get_backend('ibmq_qasm_simulator')
# execute experiments
print('Starting experiments. Please wait...')
job = execute(
[qc_1, qc_2],
qobj_header={
'qc_index': [None, index],
'qc_cost': cost
},
**kwargs
)
print(f'You may monitor the job (id: {job.job_id()}) status '
'and proceed to grading when it successfully completes.')
return job
def grade_circuit(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None
) -> bool:
payload, server = _circuit_grading(
circuit,
lab_id,
ex_id,
is_submit=False,
max_qubits=max_qubits,
min_cost=min_cost
)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def grade_job(
job_or_id: Union[IBMQJob, str],
lab_id: str,
ex_id: str
) -> bool:
payload, server = _job_grading(job_or_id, lab_id, ex_id, is_submit=False)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def grade_number(
answer: int,
lab_id: str,
ex_id: str
) -> bool:
payload, server = _number_grading(answer, lab_id, ex_id, is_submit=False)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def submit_circuit(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None
) -> bool:
payload, _ = _circuit_grading(
circuit,
lab_id,
ex_id,
is_submit=True,
max_qubits=max_qubits,
min_cost=min_cost
)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def submit_job(
job_or_id: IBMQJob,
lab_id: str,
ex_id: str,
) -> bool:
payload, _ = _job_grading(job_or_id, lab_id, ex_id, is_submit=True)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def submit_number(
answer: int,
lab_id: str,
ex_id: str
) -> bool:
payload, _ = _number_grading(answer, lab_id, ex_id, is_submit=True)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def get_problem_set(
lab_id: str, ex_id: str, endpoint: str
) -> Tuple[Optional[int], Optional[Any]]:
problem_set_response = None
try:
payload = {'question_id': get_question_id(lab_id, ex_id)}
problem_set_response = send_request(endpoint, query=payload, method='GET')
except Exception as err:
print('Unable to obtain the problem set')
if problem_set_response:
status = problem_set_response.get('status')
if status == 'valid':
try:
index = problem_set_response.get('index')
value = json.loads(problem_set_response.get('value'))
return index, value
except Exception as err:
print(f'Problem set could not be processed: {err}')
else:
cause = problem_set_response.get('cause')
print(f'Problem set failed: {cause}')
return None, None
def grade_answer(payload: dict, endpoint: str, cost: Optional[int] = None) -> bool:
try:
answer_response = send_request(endpoint, body=payload)
status = answer_response.get('status', None)
cause = answer_response.get('cause', None)
score = cost if cost else answer_response.get('score', None)
handle_grade_response(status, score=score, cause=cause)
return status == 'valid' or status is True
except Exception as err:
print(f'Failed: {err}')
return False
def submit_answer(payload: dict) -> bool:
try:
access_token = get_access_token()
baseurl = get_submission_endpoint()
endpoint = urljoin(baseurl, './challenges/answers')
submit_response = send_request(
endpoint,
body=payload,
query={'access_token': access_token}
)
status = submit_response.get('status', None)
if status is None:
status = submit_response.get('valid', None)
cause = submit_response.get('cause', None)
handle_submit_response(status, cause=cause)
return status == 'valid' or status is True
except Exception as err:
print(f'Failed: {err}')
return False
def handle_grade_response(
status: Optional[str], score: Optional[int] = None, cause: Optional[str] = None
) -> None:
if status == 'valid':
print('\nCongratulations 🎉! Your answer is correct.')
if score is not None:
print(f'Your score is {score}.')
elif status == 'invalid':
print(f'\nOops 😕! {cause}')
print('Please review your answer and try again.')
elif status == 'notFinished':
print(f'Job has not finished: {cause}')
print(f'Please wait for the job to complete then try again.')
else:
print(f'Failed: {cause}')
print('Unable to grade your answer.')
def handle_submit_response(
status: Union[str, bool], cause: Optional[str] = None
) -> None:
if status == 'valid' or status is True:
print('\nSuccess 🎉! Your answer has been submitted.')
elif status == 'invalid' or status is False:
print(f'\nOops 😕! {"Your answer is incorrect" if cause is None else cause}')
print('Make sure your answer is correct and successfully graded before submitting.')
elif status == 'notFinished':
print(f'Job has not finished: {cause}')
print(f'Please wait for the job to complete, grade it, and then try to submit again.')
else:
print(f'Failed: {cause}')
print('Unable to submit your answer at this time.')
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
!pip install -U -r grading_tools/requirements.txt
from IPython.display import clear_output
clear_output()
import numpy as np; pi = np.pi
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
from copy import deepcopy as make_copy
def prepare_hets_circuit(depth, angle1, angle2):
hets_circ = QuantumCircuit(depth)
hets_circ.ry(angle1, 0)
hets_circ.rz(angle1, 0)
hets_circ.ry(angle1, 1)
hets_circ.rz(angle1, 1)
for ii in range(depth):
hets_circ.cx(0,1)
hets_circ.ry(angle2,0)
hets_circ.rz(angle2,0)
hets_circ.ry(angle2,1)
hets_circ.rz(angle2,1)
return hets_circ
hets_circuit = prepare_hets_circuit(2, pi/2, pi/2)
hets_circuit.draw()
def measure_zz_circuit(given_circuit):
zz_meas = make_copy(given_circuit)
zz_meas.measure_all()
return zz_meas
zz_meas = measure_zz_circuit(hets_circuit)
zz_meas.draw()
simulator = Aer.get_backend('qasm_simulator')
result = execute(zz_meas, backend = simulator, shots=10000).result()
counts = result.get_counts(zz_meas)
plot_histogram(counts)
def measure_zz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zz = counts['00'] + counts['11'] - counts['01'] - counts['10']
zz = zz / total_counts
return zz
zz = measure_zz(hets_circuit)
print("<ZZ> =", str(zz))
def measure_zi(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zi = counts['00'] - counts['11'] + counts['01'] - counts['10']
zi = zi / total_counts
return zi
def measure_iz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
iz = counts['00'] - counts['11'] - counts['01'] + counts['10']
iz = iz / total_counts
return iz
zi = measure_zi(hets_circuit)
print("<ZI> =", str(zi))
iz = measure_iz(hets_circuit)
print("<IZ> =", str(iz))
def measure_xx_circuit(given_circuit):
xx_meas = make_copy(given_circuit)
### WRITE YOUR CODE BETWEEN THESE LINES - START
xx_meas.h(0)
xx_meas.h(1)
xx_meas.measure_all()
### WRITE YOUR CODE BETWEEN THESE LINES - END
return xx_meas
xx_meas = measure_xx_circuit(hets_circuit)
xx_meas.draw()
def measure_xx(given_circuit, num_shots = 10000):
xx_meas = measure_xx_circuit(given_circuit)
result = execute(xx_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(xx_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
xx = counts['00'] + counts['11'] - counts['01'] - counts['10']
xx = xx / total_counts
return xx
xx = measure_xx(hets_circuit)
print("<XX> =", str(xx))
def get_energy(given_circuit, num_shots = 10000):
zz = measure_zz(given_circuit, num_shots = num_shots)
iz = measure_iz(given_circuit, num_shots = num_shots)
zi = measure_zi(given_circuit, num_shots = num_shots)
xx = measure_xx(given_circuit, num_shots = num_shots)
energy = (-1.0523732)*1 + (0.39793742)*iz + (-0.3979374)*zi + (-0.0112801)*zz + (0.18093119)*xx
return energy
energy = get_energy(hets_circuit)
print("The energy of the trial state is", str(energy))
hets_circuit_plus = None
hets_circuit_minus = None
### WRITE YOUR CODE BETWEEN THESE LINES - START
hets_circuit_plus = prepare_hets_circuit(2, pi/2 + 0.1*pi/2, pi/2)
hets_circuit_minus = prepare_hets_circuit(2, pi/2 - 0.1*pi/2, pi/2)
### WRITE YOUR CODE BETWEEN THESE LINES - END
energy_plus = get_energy(hets_circuit_plus, num_shots=100000)
energy_minus = get_energy(hets_circuit_minus, num_shots=100000)
print(energy_plus, energy_minus)
name = 'Pon Rahul M'
email = 'ponrahul.21it@licet.ac.in'
### Do not change the lines below
from grading_tools import grade
grade(answer=measure_xx_circuit(hets_circuit), name=name, email=email, labid='lab9', exerciseid='ex1')
grade(answer=hets_circuit_plus, name=name, email=email, labid='lab9', exerciseid='ex2')
grade(answer=hets_circuit_minus, name=name, email=email, labid='lab9', exerciseid='ex3')
energy_plus_100, energy_plus_1000, energy_plus_10000 = 0, 0, 0
energy_minus_100, energy_minus_1000, energy_minus_10000 = 0, 0, 0
### WRITE YOUR CODE BETWEEN THESE LINES - START
energy_plus_100 = get_energy(hets_circuit_plus, num_shots = 100)
energy_minus_100 = get_energy(hets_circuit_minus, num_shots = 100)
energy_plus_1000 = get_energy(hets_circuit_plus, num_shots = 1000)
energy_minus_1000 = get_energy(hets_circuit_minus, num_shots = 1000)
energy_plus_10000 = get_energy(hets_circuit_plus, num_shots = 10000)
energy_minus_10000 = get_energy(hets_circuit_minus, num_shots = 10000)
### WRITE YOUR CODE BETWEEN THESE LINES - END
print(energy_plus_100, energy_minus_100, "difference = ", energy_minus_100 - energy_plus_100)
print(energy_plus_1000, energy_minus_1000, "difference = ", energy_minus_1000 - energy_plus_1000)
print(energy_plus_10000, energy_minus_10000, "difference = ", energy_minus_10000 - energy_plus_10000)
### WRITE YOUR CODE BETWEEN THESE LINES - START
I = np.array([
[1, 0],
[0, 1]
])
X = np.array([
[0, 1],
[1, 0]
])
Z = np.array([
[1, 0],
[0, -1]
])
h2_hamiltonian = (-1.0523732) * np.kron(I, I) + \
(0.39793742) * np.kron(I, Z) + \
(-0.3979374) * np.kron(Z, I) + \
(-0.0112801) * np.kron(Z, Z) + \
(0.18093119) * np.kron(X, X)
from numpy import linalg as LA
eigenvalues, eigenvectors = LA.eig(h2_hamiltonian)
for ii, eigenvalue in enumerate(eigenvalues):
print(f"Eigenvector {eigenvectors[:,ii]} has energy {eigenvalue}")
exact_eigenvector = eigenvectors[:,np.argmin(eigenvalues)]
exact_eigenvalue = np.min(eigenvalues)
print()
print("Minimum energy is", exact_eigenvalue)
### WRITE YOUR CODE BETWEEN THESE LINES - END
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_bloch_multivector
excited = Statevector.from_int(1, 2)
plot_bloch_multivector(excited.data)
from qiskit.tools.jupyter import *
from qiskit import IBMQ
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()
import numpy as np
# unit conversion factors -> all backend properties returned in SI (Hz, sec, etc)
GHz = 1.0e9 # Gigahertz
MHz = 1.0e6 # Megahertz
us = 1.0e-6 # Microseconds
ns = 1.0e-9 # Nanoseconds
# We will find the qubit frequency for the following qubit.
qubit = 0
# The Rabi sweep will be at the given qubit frequency.
center_frequency_Hz = backend_defaults.qubit_freq_est[qubit] # The default frequency is given in Hz
# warning: this will change in a future release
print(f"Qubit {qubit} has an estimated frequency of {center_frequency_Hz / GHz} GHz.")
from qiskit import pulse, assemble # 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
### Collect the necessary channels
drive_chan = pulse.DriveChannel(qubit)
meas_chan = pulse.MeasureChannel(qubit)
acq_chan = pulse.AcquireChannel(qubit)
inst_sched_map = backend_defaults.instruction_schedule_map
measure = inst_sched_map.get('measure', qubits=[0])
# Rabi experiment parameters
# Drive amplitude values to iterate over: 50 amplitudes evenly spaced from 0 to 0.75
num_rabi_points = 50
drive_amp_min = 0
drive_amp_max = 0.75
drive_amps = np.linspace(drive_amp_min, drive_amp_max, num_rabi_points)
# drive waveforms mush be in units of 16
drive_sigma = 80 # in dt
drive_samples = 8*drive_sigma # in dt
# Build the Rabi experiments:
# A drive pulse at the qubit frequency, followed by a measurement,
# where we vary the drive amplitude each time.
rabi_schedules = []
for drive_amp in drive_amps:
rabi_pulse = pulse_lib.gaussian(duration=drive_samples, amp=drive_amp,
sigma=drive_sigma, name=f"Rabi drive amplitude = {drive_amp}")
this_schedule = pulse.Schedule(name=f"Rabi drive amplitude = {drive_amp}")
this_schedule += Play(rabi_pulse, drive_chan)
# The left shift `<<` is special syntax meaning to shift the start time of the schedule by some duration
this_schedule += measure << this_schedule.duration
rabi_schedules.append(this_schedule)
rabi_schedules[-1].draw(label=True, scaling=1.0)
# assemble the schedules into a Qobj
num_shots_per_point = 1024
rabi_experiment_program = assemble(rabi_schedules,
backend=backend,
meas_level=1,
meas_return='avg',
shots=num_shots_per_point,
schedule_los=[{drive_chan: center_frequency_Hz}]
* num_rabi_points)
# RUN the job on a real device
#job = backend.run(rabi_experiment_program)
#print(job.job_id())
#from qiskit.tools.monitor import job_monitor
#job_monitor(job)
# OR retreive result from previous run
job = backend.retrieve_job("5ef3bf17dc3044001186c011")
rabi_results = job.result()
import matplotlib.pyplot as plt
plt.style.use('dark_background')
scale_factor = 1e-14
# center data around 0
def baseline_remove(values):
return np.array(values) - np.mean(values)
rabi_values = []
for i in range(num_rabi_points):
# Get the results for `qubit` from the ith experiment
rabi_values.append(rabi_results.get_memory(i)[qubit]*scale_factor)
rabi_values = np.real(baseline_remove(rabi_values))
plt.xlabel("Drive amp [a.u.]")
plt.ylabel("Measured signal [a.u.]")
plt.scatter(drive_amps, rabi_values, color='white') # plot real part of Rabi values
plt.show()
from scipy.optimize import curve_fit
def fit_function(x_values, y_values, function, init_params):
fitparams, conv = curve_fit(function, x_values, y_values, init_params)
y_fit = function(x_values, *fitparams)
return fitparams, y_fit
fit_params, y_fit = fit_function(drive_amps,
rabi_values,
lambda x, A, B, drive_period, phi: (A*np.cos(2*np.pi*x/drive_period - phi) + B),
[10, 0.1, 0.6, 0])
plt.scatter(drive_amps, rabi_values, color='white')
plt.plot(drive_amps, y_fit, color='red')
drive_period = fit_params[2] # get period of rabi oscillation
plt.axvline(drive_period/2, color='red', linestyle='--')
plt.axvline(drive_period, color='red', linestyle='--')
plt.annotate("", xy=(drive_period, 0), xytext=(drive_period/2,0), arrowprops=dict(arrowstyle="<->", color='red'))
plt.xlabel("Drive amp [a.u.]", fontsize=15)
plt.ylabel("Measured signal [a.u.]", fontsize=15)
plt.show()
pi_amp = abs(drive_period / 2)
print(f"Pi Amplitude = {pi_amp}")
# Drive parameters
# The drive amplitude for pi/2 is simply half the amplitude of the pi pulse
drive_amp = pi_amp / 2
# x_90 is a concise way to say pi_over_2; i.e., an X rotation of 90 degrees
x90_pulse = pulse_lib.gaussian(duration=drive_samples,
amp=drive_amp,
sigma=drive_sigma,
name='x90_pulse')
# Ramsey experiment parameters
time_max_us = 1.8
time_step_us = 0.025
times_us = np.arange(0.1, time_max_us, time_step_us)
# Convert to units of dt
delay_times_dt = times_us * us / dt
# create schedules for Ramsey experiment
ramsey_schedules = []
for delay in delay_times_dt:
this_schedule = pulse.Schedule(name=f"Ramsey delay = {delay * dt / us} us")
this_schedule += Play(x90_pulse, drive_chan)
this_schedule += Play(x90_pulse, drive_chan) << this_schedule.duration + int(delay)
this_schedule += measure << this_schedule.duration
ramsey_schedules.append(this_schedule)
ramsey_schedules[-1].draw(label=True, scaling=1.0)
# Execution settings
num_shots = 256
detuning_MHz = 2
ramsey_frequency = round(center_frequency_Hz + detuning_MHz * MHz, 6) # need ramsey freq in Hz
ramsey_program = assemble(ramsey_schedules,
backend=backend,
meas_level=1,
meas_return='avg',
shots=num_shots,
schedule_los=[{drive_chan: ramsey_frequency}]*len(ramsey_schedules)
)
# RUN the job on a real device
#job = backend.run(ramsey_experiment_program)
#print(job.job_id())
#from qiskit.tools.monitor import job_monitor
#job_monitor(job)
# OR retreive job from previous run
job = backend.retrieve_job('5ef3ed3a84b1b70012374317')
ramsey_results = job.result()
ramsey_values = []
for i in range(len(times_us)):
ramsey_values.append(ramsey_results.get_memory(i)[qubit]*scale_factor)
fit_params, y_fit = fit_function(times_us, np.real(ramsey_values),
lambda x, A, del_f_MHz, C, B: (
A * np.cos(2*np.pi*del_f_MHz*x - C) + B
),
[5, 1./0.4, 0, 0.25]
)
# Off-resonance component
_, del_f_MHz, _, _, = fit_params # freq is MHz since times in us
plt.scatter(times_us, np.real(ramsey_values), color='white')
plt.plot(times_us, y_fit, color='red', label=f"df = {del_f_MHz:.2f} MHz")
plt.xlim(0, np.max(times_us))
plt.xlabel('Delay between X90 pulses [$\mu$s]', fontsize=15)
plt.ylabel('Measured Signal [a.u.]', fontsize=15)
plt.title('Ramsey Experiment', fontsize=15)
plt.legend()
plt.show()
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
!pip install -U -r grading_tools/requirements.txt
from IPython.display import clear_output
clear_output()
import numpy as np; pi = np.pi
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
from copy import deepcopy as make_copy
def prepare_hets_circuit(depth, angle1, angle2):
hets_circ = QuantumCircuit(depth)
hets_circ.ry(angle1, 0)
hets_circ.rz(angle1, 0)
hets_circ.ry(angle1, 1)
hets_circ.rz(angle1, 1)
for ii in range(depth):
hets_circ.cx(0,1)
hets_circ.ry(angle2,0)
hets_circ.rz(angle2,0)
hets_circ.ry(angle2,1)
hets_circ.rz(angle2,1)
return hets_circ
hets_circuit = prepare_hets_circuit(2, pi/2, pi/2)
hets_circuit.draw()
def measure_zz_circuit(given_circuit):
zz_meas = make_copy(given_circuit)
zz_meas.measure_all()
return zz_meas
zz_meas = measure_zz_circuit(hets_circuit)
zz_meas.draw()
simulator = Aer.get_backend('qasm_simulator')
result = execute(zz_meas, backend = simulator, shots=10000).result()
counts = result.get_counts(zz_meas)
plot_histogram(counts)
def measure_zz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zz = counts['00'] + counts['11'] - counts['01'] - counts['10']
zz = zz / total_counts
return zz
zz = measure_zz(hets_circuit)
print("<ZZ> =", str(zz))
def measure_zi(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zi = counts['00'] - counts['11'] + counts['01'] - counts['10']
zi = zi / total_counts
return zi
def measure_iz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
iz = counts['00'] - counts['11'] - counts['01'] + counts['10']
iz = iz / total_counts
return iz
zi = measure_zi(hets_circuit)
print("<ZI> =", str(zi))
iz = measure_iz(hets_circuit)
print("<IZ> =", str(iz))
def measure_xx_circuit(given_circuit):
xx_meas = make_copy(given_circuit)
### WRITE YOUR CODE BETWEEN THESE LINES - START
xx_meas.h(0)
xx_meas.h(1)
xx_meas.measure_all()
### WRITE YOUR CODE BETWEEN THESE LINES - END
return xx_meas
xx_meas = measure_xx_circuit(hets_circuit)
xx_meas.draw()
def measure_xx(given_circuit, num_shots = 10000):
xx_meas = measure_xx_circuit(given_circuit)
result = execute(xx_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(xx_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
xx = counts['00'] + counts['11'] - counts['01'] - counts['10']
xx = xx / total_counts
return xx
xx = measure_xx(hets_circuit)
print("<XX> =", str(xx))
def get_energy(given_circuit, num_shots = 10000):
zz = measure_zz(given_circuit, num_shots = num_shots)
iz = measure_iz(given_circuit, num_shots = num_shots)
zi = measure_zi(given_circuit, num_shots = num_shots)
xx = measure_xx(given_circuit, num_shots = num_shots)
energy = (-1.0523732)*1 + (0.39793742)*iz + (-0.3979374)*zi + (-0.0112801)*zz + (0.18093119)*xx
return energy
energy = get_energy(hets_circuit)
print("The energy of the trial state is", str(energy))
hets_circuit_plus = None
hets_circuit_minus = None
### WRITE YOUR CODE BETWEEN THESE LINES - START
hets_circuit_plus = prepare_hets_circuit(2, pi/2 + 0.1*pi/2, pi/2)
hets_circuit_minus = prepare_hets_circuit(2, pi/2 - 0.1*pi/2, pi/2)
### WRITE YOUR CODE BETWEEN THESE LINES - END
energy_plus = get_energy(hets_circuit_plus, num_shots=100000)
energy_minus = get_energy(hets_circuit_minus, num_shots=100000)
print(energy_plus, energy_minus)
name = 'Pon Rahul M'
email = 'ponrahul.21it@licet.ac.in'
### Do not change the lines below
from grading_tools import grade
grade(answer=measure_xx_circuit(hets_circuit), name=name, email=email, labid='lab9', exerciseid='ex1')
grade(answer=hets_circuit_plus, name=name, email=email, labid='lab9', exerciseid='ex2')
grade(answer=hets_circuit_minus, name=name, email=email, labid='lab9', exerciseid='ex3')
energy_plus_100, energy_plus_1000, energy_plus_10000 = 0, 0, 0
energy_minus_100, energy_minus_1000, energy_minus_10000 = 0, 0, 0
### WRITE YOUR CODE BETWEEN THESE LINES - START
energy_plus_100 = get_energy(hets_circuit_plus, num_shots = 100)
energy_minus_100 = get_energy(hets_circuit_minus, num_shots = 100)
energy_plus_1000 = get_energy(hets_circuit_plus, num_shots = 1000)
energy_minus_1000 = get_energy(hets_circuit_minus, num_shots = 1000)
energy_plus_10000 = get_energy(hets_circuit_plus, num_shots = 10000)
energy_minus_10000 = get_energy(hets_circuit_minus, num_shots = 10000)
### WRITE YOUR CODE BETWEEN THESE LINES - END
print(energy_plus_100, energy_minus_100, "difference = ", energy_minus_100 - energy_plus_100)
print(energy_plus_1000, energy_minus_1000, "difference = ", energy_minus_1000 - energy_plus_1000)
print(energy_plus_10000, energy_minus_10000, "difference = ", energy_minus_10000 - energy_plus_10000)
### WRITE YOUR CODE BETWEEN THESE LINES - START
I = np.array([
[1, 0],
[0, 1]
])
X = np.array([
[0, 1],
[1, 0]
])
Z = np.array([
[1, 0],
[0, -1]
])
h2_hamiltonian = (-1.0523732) * np.kron(I, I) + \
(0.39793742) * np.kron(I, Z) + \
(-0.3979374) * np.kron(Z, I) + \
(-0.0112801) * np.kron(Z, Z) + \
(0.18093119) * np.kron(X, X)
from numpy import linalg as LA
eigenvalues, eigenvectors = LA.eig(h2_hamiltonian)
for ii, eigenvalue in enumerate(eigenvalues):
print(f"Eigenvector {eigenvectors[:,ii]} has energy {eigenvalue}")
exact_eigenvector = eigenvectors[:,np.argmin(eigenvalues)]
exact_eigenvalue = np.min(eigenvalues)
print()
print("Minimum energy is", exact_eigenvalue)
### WRITE YOUR CODE BETWEEN THESE LINES - END
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_bloch_multivector
excited = Statevector.from_int(1, 2)
plot_bloch_multivector(excited.data)
from qiskit.tools.jupyter import *
from qiskit import IBMQ
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()
import numpy as np
# unit conversion factors -> all backend properties returned in SI (Hz, sec, etc)
GHz = 1.0e9 # Gigahertz
MHz = 1.0e6 # Megahertz
us = 1.0e-6 # Microseconds
ns = 1.0e-9 # Nanoseconds
# We will find the qubit frequency for the following qubit.
qubit = 0
# The Rabi sweep will be at the given qubit frequency.
center_frequency_Hz = backend_defaults.qubit_freq_est[qubit] # The default frequency is given in Hz
# warning: this will change in a future release
print(f"Qubit {qubit} has an estimated frequency of {center_frequency_Hz / GHz} GHz.")
from qiskit import pulse, assemble # 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
### Collect the necessary channels
drive_chan = pulse.DriveChannel(qubit)
meas_chan = pulse.MeasureChannel(qubit)
acq_chan = pulse.AcquireChannel(qubit)
inst_sched_map = backend_defaults.instruction_schedule_map
measure = inst_sched_map.get('measure', qubits=[0])
# Rabi experiment parameters
# Drive amplitude values to iterate over: 50 amplitudes evenly spaced from 0 to 0.75
num_rabi_points = 50
drive_amp_min = 0
drive_amp_max = 0.75
drive_amps = np.linspace(drive_amp_min, drive_amp_max, num_rabi_points)
# drive waveforms mush be in units of 16
drive_sigma = 80 # in dt
drive_samples = 8*drive_sigma # in dt
# Build the Rabi experiments:
# A drive pulse at the qubit frequency, followed by a measurement,
# where we vary the drive amplitude each time.
rabi_schedules = []
for drive_amp in drive_amps:
rabi_pulse = pulse_lib.gaussian(duration=drive_samples, amp=drive_amp,
sigma=drive_sigma, name=f"Rabi drive amplitude = {drive_amp}")
this_schedule = pulse.Schedule(name=f"Rabi drive amplitude = {drive_amp}")
this_schedule += Play(rabi_pulse, drive_chan)
# The left shift `<<` is special syntax meaning to shift the start time of the schedule by some duration
this_schedule += measure << this_schedule.duration
rabi_schedules.append(this_schedule)
rabi_schedules[-1].draw(label=True, scaling=1.0)
# assemble the schedules into a Qobj
num_shots_per_point = 1024
rabi_experiment_program = assemble(rabi_schedules,
backend=backend,
meas_level=1,
meas_return='avg',
shots=num_shots_per_point,
schedule_los=[{drive_chan: center_frequency_Hz}]
* num_rabi_points)
# RUN the job on a real device
#job = backend.run(rabi_experiment_program)
#print(job.job_id())
#from qiskit.tools.monitor import job_monitor
#job_monitor(job)
# OR retreive result from previous run
job = backend.retrieve_job("5ef3bf17dc3044001186c011")
rabi_results = job.result()
import matplotlib.pyplot as plt
plt.style.use('dark_background')
scale_factor = 1e-14
# center data around 0
def baseline_remove(values):
return np.array(values) - np.mean(values)
rabi_values = []
for i in range(num_rabi_points):
# Get the results for `qubit` from the ith experiment
rabi_values.append(rabi_results.get_memory(i)[qubit]*scale_factor)
rabi_values = np.real(baseline_remove(rabi_values))
plt.xlabel("Drive amp [a.u.]")
plt.ylabel("Measured signal [a.u.]")
plt.scatter(drive_amps, rabi_values, color='white') # plot real part of Rabi values
plt.show()
from scipy.optimize import curve_fit
def fit_function(x_values, y_values, function, init_params):
fitparams, conv = curve_fit(function, x_values, y_values, init_params)
y_fit = function(x_values, *fitparams)
return fitparams, y_fit
fit_params, y_fit = fit_function(drive_amps,
rabi_values,
lambda x, A, B, drive_period, phi: (A*np.cos(2*np.pi*x/drive_period - phi) + B),
[10, 0.1, 0.6, 0])
plt.scatter(drive_amps, rabi_values, color='white')
plt.plot(drive_amps, y_fit, color='red')
drive_period = fit_params[2] # get period of rabi oscillation
plt.axvline(drive_period/2, color='red', linestyle='--')
plt.axvline(drive_period, color='red', linestyle='--')
plt.annotate("", xy=(drive_period, 0), xytext=(drive_period/2,0), arrowprops=dict(arrowstyle="<->", color='red'))
plt.xlabel("Drive amp [a.u.]", fontsize=15)
plt.ylabel("Measured signal [a.u.]", fontsize=15)
plt.show()
pi_amp = abs(drive_period / 2)
print(f"Pi Amplitude = {pi_amp}")
# Drive parameters
# The drive amplitude for pi/2 is simply half the amplitude of the pi pulse
drive_amp = pi_amp / 2
# x_90 is a concise way to say pi_over_2; i.e., an X rotation of 90 degrees
x90_pulse = pulse_lib.gaussian(duration=drive_samples,
amp=drive_amp,
sigma=drive_sigma,
name='x90_pulse')
# Ramsey experiment parameters
time_max_us = 1.8
time_step_us = 0.025
times_us = np.arange(0.1, time_max_us, time_step_us)
# Convert to units of dt
delay_times_dt = times_us * us / dt
# create schedules for Ramsey experiment
ramsey_schedules = []
for delay in delay_times_dt:
this_schedule = pulse.Schedule(name=f"Ramsey delay = {delay * dt / us} us")
this_schedule += Play(x90_pulse, drive_chan)
this_schedule += Play(x90_pulse, drive_chan) << this_schedule.duration + int(delay)
this_schedule += measure << this_schedule.duration
ramsey_schedules.append(this_schedule)
ramsey_schedules[-1].draw(label=True, scaling=1.0)
# Execution settings
num_shots = 256
detuning_MHz = 2
ramsey_frequency = round(center_frequency_Hz + detuning_MHz * MHz, 6) # need ramsey freq in Hz
ramsey_program = assemble(ramsey_schedules,
backend=backend,
meas_level=1,
meas_return='avg',
shots=num_shots,
schedule_los=[{drive_chan: ramsey_frequency}]*len(ramsey_schedules)
)
# RUN the job on a real device
#job = backend.run(ramsey_experiment_program)
#print(job.job_id())
#from qiskit.tools.monitor import job_monitor
#job_monitor(job)
# OR retreive job from previous run
job = backend.retrieve_job('5ef3ed3a84b1b70012374317')
ramsey_results = job.result()
ramsey_values = []
for i in range(len(times_us)):
ramsey_values.append(ramsey_results.get_memory(i)[qubit]*scale_factor)
fit_params, y_fit = fit_function(times_us, np.real(ramsey_values),
lambda x, A, del_f_MHz, C, B: (
A * np.cos(2*np.pi*del_f_MHz*x - C) + B
),
[5, 1./0.4, 0, 0.25]
)
# Off-resonance component
_, del_f_MHz, _, _, = fit_params # freq is MHz since times in us
plt.scatter(times_us, np.real(ramsey_values), color='white')
plt.plot(times_us, y_fit, color='red', label=f"df = {del_f_MHz:.2f} MHz")
plt.xlim(0, np.max(times_us))
plt.xlabel('Delay between X90 pulses [$\mu$s]', fontsize=15)
plt.ylabel('Measured Signal [a.u.]', fontsize=15)
plt.title('Ramsey Experiment', fontsize=15)
plt.legend()
plt.show()
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# (C) Copyright IBM 2020.
#
# 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 json
from typing import Any, Callable, Optional, Tuple, Union
from urllib.parse import urljoin
from qiskit import QuantumCircuit, execute
from qiskit.providers import JobStatus
from qiskit.providers.ibmq.job import IBMQJob
from .api import get_server_endpoint, send_request, get_access_token, get_submission_endpoint
from .exercises import get_question_id
from .util import compute_cost, get_provider, get_job, circuit_to_json, get_job_urls, uses_multiqubit_gate
def _circuit_criteria(
circuit: QuantumCircuit,
max_qubits: Optional[int] = None,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False
) -> Tuple[Optional[int], Optional[int]]:
if max_qubits is not None and circuit.num_qubits > max_qubits:
print(f'Your circuit has {circuit.num_qubits} qubits, which exceeds the maximum allowed.')
print(f'Please reduce the number of qubits in your circuit to below {max_qubits}.')
return None, None
try:
if check_gates and not uses_multiqubit_gate(circuit):
print('Your circuit appears to not use any multi-quibit gates.')
print('Please review your circuit and try again.')
return None, None
cost = compute_cost(circuit)
if min_cost is not None and cost < min_cost:
print(f'Your circuit cost ({cost}) is too low. But if you are convinced that your circuit\n'
'is correct, please let us know in the `#ibm-quantum-challenge-2020` Slack channel.')
return None, None
return circuit.num_qubits, cost
except Exception as err:
print(f'Unable to compute cost: {err}')
return None, None
def _circuit_grading(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False,
max_qubits: Optional[int] = None,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
payload = None
server = None
if not isinstance(circuit, QuantumCircuit):
print(f'Expected a QuantumCircuit, but was given {type(circuit)}')
print(f'Please provide a circuit as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or '
'the grading servers are down right now.')
return None, None
else:
server = None
_, cost = _circuit_criteria(
circuit,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if cost is not None:
payload = {
'answer': circuit_to_json(circuit)
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def _job_grading(
job_or_id: Union[IBMQJob, str],
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
if not isinstance(job_or_id, IBMQJob) and not isinstance(job_or_id, str):
print(f'Expected an IBMQJob or a job ID, but was given {type(job_or_id)}')
print(f'Please submit a job as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or the grading '
'servers are down right now.')
return None, None
else:
server = None
job = get_job(job_or_id) if isinstance(job_or_id, str) else job_or_id
if not job:
print('An invalid or non-existent job was specified.')
return None, None
job_status = job.status()
if job_status in [JobStatus.CANCELLED, JobStatus.ERROR]:
print(f'Job did not successfully complete: {job_status.value}.')
return None, None
elif job_status is not JobStatus.DONE:
print(f'Job has not yet completed: {job_status.value}.')
print(f'Please wait for the job (id: {job.job_id()}) to complete then try again.')
return None, None
header = job.result().header.to_dict()
if 'qc_cost' not in header:
if is_submit:
print('An unprepared answer was specified. '
'Please prepare() and grade() answer before submitting.')
else:
print('An unprepared answer was specified. Please prepare() answer before grading.')
return None, None
download_url, result_url = get_job_urls(job)
if not download_url or not result_url:
print('Unable to obtain job URLs')
return None, None
payload = {
'answer': json.dumps({
'download_url': download_url,
'result_url': result_url
})
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def _number_grading(
answer: int,
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
if not isinstance(answer, int):
print(f'Expected a integer, but was given {type(answer)}')
print(f'Please provide a number as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server '
'or the grading servers are down right now.')
return None, None
else:
server = None
payload = {
'answer': str(answer)
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def prepare_circuit(
circuit: QuantumCircuit,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False,
**kwargs
) -> Optional[IBMQJob]:
job = None
if not isinstance(circuit, QuantumCircuit):
print(f'Expected a QuantumCircuit, but was given {type(circuit)}')
print(f'Please provide a circuit.')
return None
_, cost = _circuit_criteria(
circuit,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if cost is not None:
if 'backend' not in kwargs:
kwargs['backend'] = get_provider().get_backend('ibmq_qasm_simulator')
# execute experiments
print('Starting experiment. Please wait...')
job = execute(
circuit,
qobj_header={
'qc_cost': cost
},
**kwargs
)
print(f'You may monitor the job (id: {job.job_id()}) status '
'and proceed to grading when it successfully completes.')
return job
def prepare_solver(
solver_func: Callable,
lab_id: str,
ex_id: str,
problem_set: Optional[Any] = None,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False,
**kwargs
) -> Optional[IBMQJob]:
job = None
if not callable(solver_func):
print(f'Expected a function, but was given {type(solver_func)}')
print(f'Please provide a function that returns a QuantumCircuit.')
return None
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or the grading servers are down right now.')
return
endpoint = server + 'problem-set'
index, value = get_problem_set(lab_id, ex_id, endpoint)
print(f'Running {solver_func.__name__}...')
qc_1 = solver_func(problem_set)
_, cost = _circuit_criteria(
qc_1,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if value and index is not None and index >= 0 and cost is not None:
qc_2 = solver_func(value)
if 'backend' not in kwargs:
kwargs['backend'] = get_provider().get_backend('ibmq_qasm_simulator')
# execute experiments
print('Starting experiments. Please wait...')
job = execute(
[qc_1, qc_2],
qobj_header={
'qc_index': [None, index],
'qc_cost': cost
},
**kwargs
)
print(f'You may monitor the job (id: {job.job_id()}) status '
'and proceed to grading when it successfully completes.')
return job
def grade_circuit(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None
) -> bool:
payload, server = _circuit_grading(
circuit,
lab_id,
ex_id,
is_submit=False,
max_qubits=max_qubits,
min_cost=min_cost
)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def grade_job(
job_or_id: Union[IBMQJob, str],
lab_id: str,
ex_id: str
) -> bool:
payload, server = _job_grading(job_or_id, lab_id, ex_id, is_submit=False)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def grade_number(
answer: int,
lab_id: str,
ex_id: str
) -> bool:
payload, server = _number_grading(answer, lab_id, ex_id, is_submit=False)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def submit_circuit(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None
) -> bool:
payload, _ = _circuit_grading(
circuit,
lab_id,
ex_id,
is_submit=True,
max_qubits=max_qubits,
min_cost=min_cost
)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def submit_job(
job_or_id: IBMQJob,
lab_id: str,
ex_id: str,
) -> bool:
payload, _ = _job_grading(job_or_id, lab_id, ex_id, is_submit=True)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def submit_number(
answer: int,
lab_id: str,
ex_id: str
) -> bool:
payload, _ = _number_grading(answer, lab_id, ex_id, is_submit=True)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def get_problem_set(
lab_id: str, ex_id: str, endpoint: str
) -> Tuple[Optional[int], Optional[Any]]:
problem_set_response = None
try:
payload = {'question_id': get_question_id(lab_id, ex_id)}
problem_set_response = send_request(endpoint, query=payload, method='GET')
except Exception as err:
print('Unable to obtain the problem set')
if problem_set_response:
status = problem_set_response.get('status')
if status == 'valid':
try:
index = problem_set_response.get('index')
value = json.loads(problem_set_response.get('value'))
return index, value
except Exception as err:
print(f'Problem set could not be processed: {err}')
else:
cause = problem_set_response.get('cause')
print(f'Problem set failed: {cause}')
return None, None
def grade_answer(payload: dict, endpoint: str, cost: Optional[int] = None) -> bool:
try:
answer_response = send_request(endpoint, body=payload)
status = answer_response.get('status', None)
cause = answer_response.get('cause', None)
score = cost if cost else answer_response.get('score', None)
handle_grade_response(status, score=score, cause=cause)
return status == 'valid' or status is True
except Exception as err:
print(f'Failed: {err}')
return False
def submit_answer(payload: dict) -> bool:
try:
access_token = get_access_token()
baseurl = get_submission_endpoint()
endpoint = urljoin(baseurl, './challenges/answers')
submit_response = send_request(
endpoint,
body=payload,
query={'access_token': access_token}
)
status = submit_response.get('status', None)
if status is None:
status = submit_response.get('valid', None)
cause = submit_response.get('cause', None)
handle_submit_response(status, cause=cause)
return status == 'valid' or status is True
except Exception as err:
print(f'Failed: {err}')
return False
def handle_grade_response(
status: Optional[str], score: Optional[int] = None, cause: Optional[str] = None
) -> None:
if status == 'valid':
print('\nCongratulations 🎉! Your answer is correct.')
if score is not None:
print(f'Your score is {score}.')
elif status == 'invalid':
print(f'\nOops 😕! {cause}')
print('Please review your answer and try again.')
elif status == 'notFinished':
print(f'Job has not finished: {cause}')
print(f'Please wait for the job to complete then try again.')
else:
print(f'Failed: {cause}')
print('Unable to grade your answer.')
def handle_submit_response(
status: Union[str, bool], cause: Optional[str] = None
) -> None:
if status == 'valid' or status is True:
print('\nSuccess 🎉! Your answer has been submitted.')
elif status == 'invalid' or status is False:
print(f'\nOops 😕! {"Your answer is incorrect" if cause is None else cause}')
print('Make sure your answer is correct and successfully graded before submitting.')
elif status == 'notFinished':
print(f'Job has not finished: {cause}')
print(f'Please wait for the job to complete, grade it, and then try to submit again.')
else:
print(f'Failed: {cause}')
print('Unable to submit your answer at this time.')
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
!pip install -U -r grading_tools/requirements.txt
from IPython.display import clear_output
clear_output()
import numpy as np; pi = np.pi
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
from copy import deepcopy as make_copy
def prepare_hets_circuit(depth, angle1, angle2):
hets_circ = QuantumCircuit(depth)
hets_circ.ry(angle1, 0)
hets_circ.rz(angle1, 0)
hets_circ.ry(angle1, 1)
hets_circ.rz(angle1, 1)
for ii in range(depth):
hets_circ.cx(0,1)
hets_circ.ry(angle2,0)
hets_circ.rz(angle2,0)
hets_circ.ry(angle2,1)
hets_circ.rz(angle2,1)
return hets_circ
hets_circuit = prepare_hets_circuit(2, pi/2, pi/2)
hets_circuit.draw()
def measure_zz_circuit(given_circuit):
zz_meas = make_copy(given_circuit)
zz_meas.measure_all()
return zz_meas
zz_meas = measure_zz_circuit(hets_circuit)
zz_meas.draw()
simulator = Aer.get_backend('qasm_simulator')
result = execute(zz_meas, backend = simulator, shots=10000).result()
counts = result.get_counts(zz_meas)
plot_histogram(counts)
def measure_zz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zz = counts['00'] + counts['11'] - counts['01'] - counts['10']
zz = zz / total_counts
return zz
zz = measure_zz(hets_circuit)
print("<ZZ> =", str(zz))
def measure_zi(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zi = counts['00'] - counts['11'] + counts['01'] - counts['10']
zi = zi / total_counts
return zi
def measure_iz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
iz = counts['00'] - counts['11'] - counts['01'] + counts['10']
iz = iz / total_counts
return iz
zi = measure_zi(hets_circuit)
print("<ZI> =", str(zi))
iz = measure_iz(hets_circuit)
print("<IZ> =", str(iz))
def measure_xx_circuit(given_circuit):
xx_meas = make_copy(given_circuit)
### WRITE YOUR CODE BETWEEN THESE LINES - START
xx_meas.h(0)
xx_meas.h(1)
xx_meas.measure_all()
### WRITE YOUR CODE BETWEEN THESE LINES - END
return xx_meas
xx_meas = measure_xx_circuit(hets_circuit)
xx_meas.draw()
def measure_xx(given_circuit, num_shots = 10000):
xx_meas = measure_xx_circuit(given_circuit)
result = execute(xx_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(xx_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
xx = counts['00'] + counts['11'] - counts['01'] - counts['10']
xx = xx / total_counts
return xx
xx = measure_xx(hets_circuit)
print("<XX> =", str(xx))
def get_energy(given_circuit, num_shots = 10000):
zz = measure_zz(given_circuit, num_shots = num_shots)
iz = measure_iz(given_circuit, num_shots = num_shots)
zi = measure_zi(given_circuit, num_shots = num_shots)
xx = measure_xx(given_circuit, num_shots = num_shots)
energy = (-1.0523732)*1 + (0.39793742)*iz + (-0.3979374)*zi + (-0.0112801)*zz + (0.18093119)*xx
return energy
energy = get_energy(hets_circuit)
print("The energy of the trial state is", str(energy))
hets_circuit_plus = None
hets_circuit_minus = None
### WRITE YOUR CODE BETWEEN THESE LINES - START
hets_circuit_plus = prepare_hets_circuit(2, pi/2 + 0.1*pi/2, pi/2)
hets_circuit_minus = prepare_hets_circuit(2, pi/2 - 0.1*pi/2, pi/2)
### WRITE YOUR CODE BETWEEN THESE LINES - END
energy_plus = get_energy(hets_circuit_plus, num_shots=100000)
energy_minus = get_energy(hets_circuit_minus, num_shots=100000)
print(energy_plus, energy_minus)
name = 'Pon Rahul M'
email = 'ponrahul.21it@licet.ac.in'
### Do not change the lines below
from grading_tools import grade
grade(answer=measure_xx_circuit(hets_circuit), name=name, email=email, labid='lab9', exerciseid='ex1')
grade(answer=hets_circuit_plus, name=name, email=email, labid='lab9', exerciseid='ex2')
grade(answer=hets_circuit_minus, name=name, email=email, labid='lab9', exerciseid='ex3')
energy_plus_100, energy_plus_1000, energy_plus_10000 = 0, 0, 0
energy_minus_100, energy_minus_1000, energy_minus_10000 = 0, 0, 0
### WRITE YOUR CODE BETWEEN THESE LINES - START
energy_plus_100 = get_energy(hets_circuit_plus, num_shots = 100)
energy_minus_100 = get_energy(hets_circuit_minus, num_shots = 100)
energy_plus_1000 = get_energy(hets_circuit_plus, num_shots = 1000)
energy_minus_1000 = get_energy(hets_circuit_minus, num_shots = 1000)
energy_plus_10000 = get_energy(hets_circuit_plus, num_shots = 10000)
energy_minus_10000 = get_energy(hets_circuit_minus, num_shots = 10000)
### WRITE YOUR CODE BETWEEN THESE LINES - END
print(energy_plus_100, energy_minus_100, "difference = ", energy_minus_100 - energy_plus_100)
print(energy_plus_1000, energy_minus_1000, "difference = ", energy_minus_1000 - energy_plus_1000)
print(energy_plus_10000, energy_minus_10000, "difference = ", energy_minus_10000 - energy_plus_10000)
### WRITE YOUR CODE BETWEEN THESE LINES - START
I = np.array([
[1, 0],
[0, 1]
])
X = np.array([
[0, 1],
[1, 0]
])
Z = np.array([
[1, 0],
[0, -1]
])
h2_hamiltonian = (-1.0523732) * np.kron(I, I) + \
(0.39793742) * np.kron(I, Z) + \
(-0.3979374) * np.kron(Z, I) + \
(-0.0112801) * np.kron(Z, Z) + \
(0.18093119) * np.kron(X, X)
from numpy import linalg as LA
eigenvalues, eigenvectors = LA.eig(h2_hamiltonian)
for ii, eigenvalue in enumerate(eigenvalues):
print(f"Eigenvector {eigenvectors[:,ii]} has energy {eigenvalue}")
exact_eigenvector = eigenvectors[:,np.argmin(eigenvalues)]
exact_eigenvalue = np.min(eigenvalues)
print()
print("Minimum energy is", exact_eigenvalue)
### WRITE YOUR CODE BETWEEN THESE LINES - END
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
# import SymPy and define symbols
import sympy as sp
sp.init_printing(use_unicode=True)
wr = sp.Symbol('\omega_r') # resonator frequency
wq = sp.Symbol('\omega_q') # qubit frequency
g = sp.Symbol('g', real=True) # vacuum Rabi coupling
Delta = sp.Symbol('Delta', real=True) # wr - wq; defined later
# import operator relations and define them
from sympy.physics.quantum.boson import BosonOp
a = BosonOp('a') # resonator photon annihilation operator
from sympy.physics.quantum import pauli, Dagger, Commutator
from sympy.physics.quantum.operatorordering import normal_ordered_form
# Pauli matrices
sx = pauli.SigmaX()
sy = pauli.SigmaY()
sz = pauli.SigmaZ()
# qubit raising and lowering operators
splus = pauli.SigmaPlus()
sminus = pauli.SigmaMinus()
# define J-C Hamiltonian in terms of diagonal and non-block diagonal terms
H0 = wr*Dagger(a)*a - (1/2)*wq*sz;
H1 = 0
H2 = g*(Dagger(a)*sminus + a*splus);
HJC = H0 + H1 + H2; HJC # print
# using the above method for finding the ansatz
eta = Commutator(H0, H2); eta
pauli.qsimplify_pauli(normal_ordered_form(eta.doit().expand()))
A = sp.Symbol('A')
B = sp.Symbol('B')
eta = A * Dagger(a) * sminus - B * a * splus;
pauli.qsimplify_pauli(normal_ordered_form(Commutator(H0, eta).doit().expand()))
H2
S1 = eta.subs(A, g/Delta)
S1 = S1.subs(B, g/Delta); S1.factor()
Heff = H0 + H1 + 0.5*pauli.qsimplify_pauli(normal_ordered_form(Commutator(H2, S1).doit().expand())).simplify(); Heff
from qiskit.tools.jupyter import *
from qiskit import IBMQ
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()
import numpy as np
# unit conversion factors -> all backend properties returned in SI (Hz, sec, etc)
GHz = 1.0e9 # Gigahertz
MHz = 1.0e6 # Megahertz
kHz = 1.0e3
us = 1.0e-6 # Microseconds
ns = 1.0e-9 # Nanoseconds
# We will find the qubit frequency for the following qubit.
qubit = 0
# The sweep will be centered around the estimated qubit frequency.
center_frequency_Hz = backend_defaults.qubit_freq_est[qubit] # The default frequency is given in Hz
# warning: this will change in a future release
print(f"Qubit {qubit} has an estimated frequency of {center_frequency_Hz / GHz} GHz.")
# scale factor to remove factors of 10 from the data
scale_factor = 1e-14
# We will sweep 40 MHz around the estimated frequency
frequency_span_Hz = 40 * MHz
# in steps of 1 MHz.
frequency_step_Hz = 1 * MHz
# We will sweep 20 MHz above and 20 MHz below the estimated frequency
frequency_min = center_frequency_Hz - frequency_span_Hz / 2
frequency_max = center_frequency_Hz + frequency_span_Hz / 2
# Construct an np array of the frequencies for our experiment
frequencies_GHz = np.arange(frequency_min / GHz,
frequency_max / GHz,
frequency_step_Hz / GHz)
print(f"The sweep will go from {frequency_min / GHz} GHz to {frequency_max / GHz} GHz \
in steps of {frequency_step_Hz / MHz} MHz.")
from qiskit import pulse # This is where we access all of our Pulse features!
inst_sched_map = backend_defaults.instruction_schedule_map
measure = inst_sched_map.get('measure', qubits=[qubit])
x_pulse = inst_sched_map.get('x', qubits=[qubit])
### Collect the necessary channels
drive_chan = pulse.DriveChannel(qubit)
meas_chan = pulse.MeasureChannel(qubit)
acq_chan = pulse.AcquireChannel(qubit)
# Create the base schedule
# Start with drive pulse acting on the drive channel
schedule = pulse.Schedule(name='Frequency sweep')
schedule += x_pulse
# The left shift `<<` is special syntax meaning to shift the start time of the schedule by some duration
schedule += measure << schedule.duration
# Create the frequency settings for the sweep (MUST BE IN HZ)
frequencies_Hz = frequencies_GHz*GHz
schedule_frequencies = [{drive_chan: freq} for freq in frequencies_Hz]
schedule.draw(label=True, scaling=0.8)
from qiskit import assemble
frequency_sweep_program = assemble(schedule,
backend=backend,
meas_level=1,
meas_return='avg',
shots=1024,
schedule_los=schedule_frequencies)
# RUN the job on a real device
#job = backend.run(rabi_experiment_program)
#print(job.job_id())
#from qiskit.tools.monitor import job_monitor
#job_monitor(job)
# OR retreive result from previous run
job = backend.retrieve_job('5ef3b081fbc24b001275b03b')
frequency_sweep_results = job.result()
import matplotlib.pyplot as plt
plt.style.use('dark_background')
sweep_values = []
for i in range(len(frequency_sweep_results.results)):
# Get the results from the ith experiment
res = frequency_sweep_results.get_memory(i)*scale_factor
# Get the results for `qubit` from this experiment
sweep_values.append(res[qubit])
plt.scatter(frequencies_GHz, np.real(sweep_values), color='white') # plot real part of sweep values
plt.xlim([min(frequencies_GHz), max(frequencies_GHz)])
plt.xlabel("Frequency [GHz]")
plt.ylabel("Measured signal [a.u.]")
plt.show()
from scipy.optimize import curve_fit
def fit_function(x_values, y_values, function, init_params):
fitparams, conv = curve_fit(function, x_values, y_values, init_params)
y_fit = function(x_values, *fitparams)
return fitparams, y_fit
fit_params, y_fit = fit_function(frequencies_GHz,
np.real(sweep_values),
lambda x, A, q_freq, B, C: (A / np.pi) * (B / ((x - q_freq)**2 + B**2)) + C,
[5, 4.975, 1, 3] # initial parameters for curve_fit
)
plt.scatter(frequencies_GHz, np.real(sweep_values), color='white')
plt.plot(frequencies_GHz, y_fit, color='red')
plt.xlim([min(frequencies_GHz), max(frequencies_GHz)])
plt.xlabel("Frequency [GHz]")
plt.ylabel("Measured Signal [a.u.]")
plt.show()
# Create the schedules for 0 and 1
schedule_0 = pulse.Schedule(name='0')
schedule_0 += measure
schedule_1 = pulse.Schedule(name='1')
schedule_1 += x_pulse
schedule_1 += measure << schedule_1.duration
schedule_0.draw()
schedule_1.draw()
frequency_span_Hz = 320 * kHz
frequency_step_Hz = 8 * kHz
center_frequency_Hz = backend_defaults.meas_freq_est[qubit]
print(f"Qubit {qubit} has an estimated readout frequency of {center_frequency_Hz / GHz} GHz.")
frequency_min = center_frequency_Hz - frequency_span_Hz / 2
frequency_max = center_frequency_Hz + frequency_span_Hz / 2
frequencies_GHz = np.arange(frequency_min / GHz,
frequency_max / GHz,
frequency_step_Hz / GHz)
print(f"The sweep will go from {frequency_min / GHz} GHz to {frequency_max / GHz} GHz\
in steps of {frequency_step_Hz / MHz} MHz.")
num_shots_per_frequency = 2048
frequencies_Hz = frequencies_GHz*GHz
schedule_los = [{meas_chan: freq} for freq in frequencies_Hz]
cavity_sweep_0 = assemble(schedule_0,
backend=backend,
meas_level=1,
meas_return='avg',
shots=num_shots_per_frequency,
schedule_los=schedule_los)
cavity_sweep_1 = assemble(schedule_1,
backend=backend,
meas_level=1,
meas_return='avg',
shots=num_shots_per_frequency,
schedule_los=schedule_los)
# RUN the job on a real device
#job_0 = backend.run(cavity_sweep_0)
#job_monitor(job_0)
#job_0.error_message()
#job_1 = backend.run(cavity_sweep_1)
#job_monitor(job_1)
#job_1.error_message()
# OR retreive result from previous run
job_0 = backend.retrieve_job('5efa5b447c0d6800137fff1c')
job_1 = backend.retrieve_job('5efa6b2720eee10013be46b4')
cavity_sweep_0_results = job_0.result()
cavity_sweep_1_results = job_1.result()
scale_factor = 1e-14
sweep_values_0 = []
for i in range(len(cavity_sweep_0_results.results)):
res_0 = cavity_sweep_0_results.get_memory(i)*scale_factor
sweep_values_0.append(res_0[qubit])
sweep_values_1 = []
for i in range(len(cavity_sweep_1_results.results)):
res_1 = cavity_sweep_1_results.get_memory(i)*scale_factor
sweep_values_1.append(res_1[qubit])
plotx = frequencies_Hz/kHz
ploty_0 = np.abs(sweep_values_0)
ploty_1 = np.abs(sweep_values_1)
plt.plot(plotx, ploty_0, color='blue', marker='.') # plot real part of sweep values
plt.plot(plotx, ploty_1, color='red', marker='.') # plot real part of sweep values
plt.legend([r'$\vert0\rangle$', r'$\vert1\rangle$'])
plt.grid()
plt.xlabel("Frequency [kHz]")
plt.ylabel("Measured signal [a.u.]")
plt.yscale('log')
plt.show()
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
!pip install -U -r grading_tools/requirements.txt
from IPython.display import clear_output
clear_output()
import numpy as np; pi = np.pi
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
from copy import deepcopy as make_copy
def prepare_hets_circuit(depth, angle1, angle2):
hets_circ = QuantumCircuit(depth)
hets_circ.ry(angle1, 0)
hets_circ.rz(angle1, 0)
hets_circ.ry(angle1, 1)
hets_circ.rz(angle1, 1)
for ii in range(depth):
hets_circ.cx(0,1)
hets_circ.ry(angle2,0)
hets_circ.rz(angle2,0)
hets_circ.ry(angle2,1)
hets_circ.rz(angle2,1)
return hets_circ
hets_circuit = prepare_hets_circuit(2, pi/2, pi/2)
hets_circuit.draw()
def measure_zz_circuit(given_circuit):
zz_meas = make_copy(given_circuit)
zz_meas.measure_all()
return zz_meas
zz_meas = measure_zz_circuit(hets_circuit)
zz_meas.draw()
simulator = Aer.get_backend('qasm_simulator')
result = execute(zz_meas, backend = simulator, shots=10000).result()
counts = result.get_counts(zz_meas)
plot_histogram(counts)
def measure_zz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zz = counts['00'] + counts['11'] - counts['01'] - counts['10']
zz = zz / total_counts
return zz
zz = measure_zz(hets_circuit)
print("<ZZ> =", str(zz))
def measure_zi(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zi = counts['00'] - counts['11'] + counts['01'] - counts['10']
zi = zi / total_counts
return zi
def measure_iz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
iz = counts['00'] - counts['11'] - counts['01'] + counts['10']
iz = iz / total_counts
return iz
zi = measure_zi(hets_circuit)
print("<ZI> =", str(zi))
iz = measure_iz(hets_circuit)
print("<IZ> =", str(iz))
def measure_xx_circuit(given_circuit):
xx_meas = make_copy(given_circuit)
### WRITE YOUR CODE BETWEEN THESE LINES - START
xx_meas.h(0)
xx_meas.h(1)
xx_meas.measure_all()
### WRITE YOUR CODE BETWEEN THESE LINES - END
return xx_meas
xx_meas = measure_xx_circuit(hets_circuit)
xx_meas.draw()
def measure_xx(given_circuit, num_shots = 10000):
xx_meas = measure_xx_circuit(given_circuit)
result = execute(xx_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(xx_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
xx = counts['00'] + counts['11'] - counts['01'] - counts['10']
xx = xx / total_counts
return xx
xx = measure_xx(hets_circuit)
print("<XX> =", str(xx))
def get_energy(given_circuit, num_shots = 10000):
zz = measure_zz(given_circuit, num_shots = num_shots)
iz = measure_iz(given_circuit, num_shots = num_shots)
zi = measure_zi(given_circuit, num_shots = num_shots)
xx = measure_xx(given_circuit, num_shots = num_shots)
energy = (-1.0523732)*1 + (0.39793742)*iz + (-0.3979374)*zi + (-0.0112801)*zz + (0.18093119)*xx
return energy
energy = get_energy(hets_circuit)
print("The energy of the trial state is", str(energy))
hets_circuit_plus = None
hets_circuit_minus = None
### WRITE YOUR CODE BETWEEN THESE LINES - START
hets_circuit_plus = prepare_hets_circuit(2, pi/2 + 0.1*pi/2, pi/2)
hets_circuit_minus = prepare_hets_circuit(2, pi/2 - 0.1*pi/2, pi/2)
### WRITE YOUR CODE BETWEEN THESE LINES - END
energy_plus = get_energy(hets_circuit_plus, num_shots=100000)
energy_minus = get_energy(hets_circuit_minus, num_shots=100000)
print(energy_plus, energy_minus)
name = 'Pon Rahul M'
email = 'ponrahul.21it@licet.ac.in'
### Do not change the lines below
from grading_tools import grade
grade(answer=measure_xx_circuit(hets_circuit), name=name, email=email, labid='lab9', exerciseid='ex1')
grade(answer=hets_circuit_plus, name=name, email=email, labid='lab9', exerciseid='ex2')
grade(answer=hets_circuit_minus, name=name, email=email, labid='lab9', exerciseid='ex3')
energy_plus_100, energy_plus_1000, energy_plus_10000 = 0, 0, 0
energy_minus_100, energy_minus_1000, energy_minus_10000 = 0, 0, 0
### WRITE YOUR CODE BETWEEN THESE LINES - START
energy_plus_100 = get_energy(hets_circuit_plus, num_shots = 100)
energy_minus_100 = get_energy(hets_circuit_minus, num_shots = 100)
energy_plus_1000 = get_energy(hets_circuit_plus, num_shots = 1000)
energy_minus_1000 = get_energy(hets_circuit_minus, num_shots = 1000)
energy_plus_10000 = get_energy(hets_circuit_plus, num_shots = 10000)
energy_minus_10000 = get_energy(hets_circuit_minus, num_shots = 10000)
### WRITE YOUR CODE BETWEEN THESE LINES - END
print(energy_plus_100, energy_minus_100, "difference = ", energy_minus_100 - energy_plus_100)
print(energy_plus_1000, energy_minus_1000, "difference = ", energy_minus_1000 - energy_plus_1000)
print(energy_plus_10000, energy_minus_10000, "difference = ", energy_minus_10000 - energy_plus_10000)
### WRITE YOUR CODE BETWEEN THESE LINES - START
I = np.array([
[1, 0],
[0, 1]
])
X = np.array([
[0, 1],
[1, 0]
])
Z = np.array([
[1, 0],
[0, -1]
])
h2_hamiltonian = (-1.0523732) * np.kron(I, I) + \
(0.39793742) * np.kron(I, Z) + \
(-0.3979374) * np.kron(Z, I) + \
(-0.0112801) * np.kron(Z, Z) + \
(0.18093119) * np.kron(X, X)
from numpy import linalg as LA
eigenvalues, eigenvectors = LA.eig(h2_hamiltonian)
for ii, eigenvalue in enumerate(eigenvalues):
print(f"Eigenvector {eigenvectors[:,ii]} has energy {eigenvalue}")
exact_eigenvector = eigenvectors[:,np.argmin(eigenvalues)]
exact_eigenvalue = np.min(eigenvalues)
print()
print("Minimum energy is", exact_eigenvalue)
### WRITE YOUR CODE BETWEEN THESE LINES - END
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# (C) Copyright IBM 2020.
#
# 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 json
from typing import Any, Callable, Optional, Tuple, Union
from urllib.parse import urljoin
from qiskit import QuantumCircuit, execute
from qiskit.providers import JobStatus
from qiskit.providers.ibmq.job import IBMQJob
from .api import get_server_endpoint, send_request, get_access_token, get_submission_endpoint
from .exercises import get_question_id
from .util import compute_cost, get_provider, get_job, circuit_to_json, get_job_urls, uses_multiqubit_gate
def _circuit_criteria(
circuit: QuantumCircuit,
max_qubits: Optional[int] = None,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False
) -> Tuple[Optional[int], Optional[int]]:
if max_qubits is not None and circuit.num_qubits > max_qubits:
print(f'Your circuit has {circuit.num_qubits} qubits, which exceeds the maximum allowed.')
print(f'Please reduce the number of qubits in your circuit to below {max_qubits}.')
return None, None
try:
if check_gates and not uses_multiqubit_gate(circuit):
print('Your circuit appears to not use any multi-quibit gates.')
print('Please review your circuit and try again.')
return None, None
cost = compute_cost(circuit)
if min_cost is not None and cost < min_cost:
print(f'Your circuit cost ({cost}) is too low. But if you are convinced that your circuit\n'
'is correct, please let us know in the `#ibm-quantum-challenge-2020` Slack channel.')
return None, None
return circuit.num_qubits, cost
except Exception as err:
print(f'Unable to compute cost: {err}')
return None, None
def _circuit_grading(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False,
max_qubits: Optional[int] = None,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
payload = None
server = None
if not isinstance(circuit, QuantumCircuit):
print(f'Expected a QuantumCircuit, but was given {type(circuit)}')
print(f'Please provide a circuit as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or '
'the grading servers are down right now.')
return None, None
else:
server = None
_, cost = _circuit_criteria(
circuit,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if cost is not None:
payload = {
'answer': circuit_to_json(circuit)
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def _job_grading(
job_or_id: Union[IBMQJob, str],
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
if not isinstance(job_or_id, IBMQJob) and not isinstance(job_or_id, str):
print(f'Expected an IBMQJob or a job ID, but was given {type(job_or_id)}')
print(f'Please submit a job as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or the grading '
'servers are down right now.')
return None, None
else:
server = None
job = get_job(job_or_id) if isinstance(job_or_id, str) else job_or_id
if not job:
print('An invalid or non-existent job was specified.')
return None, None
job_status = job.status()
if job_status in [JobStatus.CANCELLED, JobStatus.ERROR]:
print(f'Job did not successfully complete: {job_status.value}.')
return None, None
elif job_status is not JobStatus.DONE:
print(f'Job has not yet completed: {job_status.value}.')
print(f'Please wait for the job (id: {job.job_id()}) to complete then try again.')
return None, None
header = job.result().header.to_dict()
if 'qc_cost' not in header:
if is_submit:
print('An unprepared answer was specified. '
'Please prepare() and grade() answer before submitting.')
else:
print('An unprepared answer was specified. Please prepare() answer before grading.')
return None, None
download_url, result_url = get_job_urls(job)
if not download_url or not result_url:
print('Unable to obtain job URLs')
return None, None
payload = {
'answer': json.dumps({
'download_url': download_url,
'result_url': result_url
})
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def _number_grading(
answer: int,
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
if not isinstance(answer, int):
print(f'Expected a integer, but was given {type(answer)}')
print(f'Please provide a number as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server '
'or the grading servers are down right now.')
return None, None
else:
server = None
payload = {
'answer': str(answer)
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def prepare_circuit(
circuit: QuantumCircuit,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False,
**kwargs
) -> Optional[IBMQJob]:
job = None
if not isinstance(circuit, QuantumCircuit):
print(f'Expected a QuantumCircuit, but was given {type(circuit)}')
print(f'Please provide a circuit.')
return None
_, cost = _circuit_criteria(
circuit,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if cost is not None:
if 'backend' not in kwargs:
kwargs['backend'] = get_provider().get_backend('ibmq_qasm_simulator')
# execute experiments
print('Starting experiment. Please wait...')
job = execute(
circuit,
qobj_header={
'qc_cost': cost
},
**kwargs
)
print(f'You may monitor the job (id: {job.job_id()}) status '
'and proceed to grading when it successfully completes.')
return job
def prepare_solver(
solver_func: Callable,
lab_id: str,
ex_id: str,
problem_set: Optional[Any] = None,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False,
**kwargs
) -> Optional[IBMQJob]:
job = None
if not callable(solver_func):
print(f'Expected a function, but was given {type(solver_func)}')
print(f'Please provide a function that returns a QuantumCircuit.')
return None
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or the grading servers are down right now.')
return
endpoint = server + 'problem-set'
index, value = get_problem_set(lab_id, ex_id, endpoint)
print(f'Running {solver_func.__name__}...')
qc_1 = solver_func(problem_set)
_, cost = _circuit_criteria(
qc_1,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if value and index is not None and index >= 0 and cost is not None:
qc_2 = solver_func(value)
if 'backend' not in kwargs:
kwargs['backend'] = get_provider().get_backend('ibmq_qasm_simulator')
# execute experiments
print('Starting experiments. Please wait...')
job = execute(
[qc_1, qc_2],
qobj_header={
'qc_index': [None, index],
'qc_cost': cost
},
**kwargs
)
print(f'You may monitor the job (id: {job.job_id()}) status '
'and proceed to grading when it successfully completes.')
return job
def grade_circuit(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None
) -> bool:
payload, server = _circuit_grading(
circuit,
lab_id,
ex_id,
is_submit=False,
max_qubits=max_qubits,
min_cost=min_cost
)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def grade_job(
job_or_id: Union[IBMQJob, str],
lab_id: str,
ex_id: str
) -> bool:
payload, server = _job_grading(job_or_id, lab_id, ex_id, is_submit=False)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def grade_number(
answer: int,
lab_id: str,
ex_id: str
) -> bool:
payload, server = _number_grading(answer, lab_id, ex_id, is_submit=False)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def submit_circuit(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None
) -> bool:
payload, _ = _circuit_grading(
circuit,
lab_id,
ex_id,
is_submit=True,
max_qubits=max_qubits,
min_cost=min_cost
)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def submit_job(
job_or_id: IBMQJob,
lab_id: str,
ex_id: str,
) -> bool:
payload, _ = _job_grading(job_or_id, lab_id, ex_id, is_submit=True)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def submit_number(
answer: int,
lab_id: str,
ex_id: str
) -> bool:
payload, _ = _number_grading(answer, lab_id, ex_id, is_submit=True)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def get_problem_set(
lab_id: str, ex_id: str, endpoint: str
) -> Tuple[Optional[int], Optional[Any]]:
problem_set_response = None
try:
payload = {'question_id': get_question_id(lab_id, ex_id)}
problem_set_response = send_request(endpoint, query=payload, method='GET')
except Exception as err:
print('Unable to obtain the problem set')
if problem_set_response:
status = problem_set_response.get('status')
if status == 'valid':
try:
index = problem_set_response.get('index')
value = json.loads(problem_set_response.get('value'))
return index, value
except Exception as err:
print(f'Problem set could not be processed: {err}')
else:
cause = problem_set_response.get('cause')
print(f'Problem set failed: {cause}')
return None, None
def grade_answer(payload: dict, endpoint: str, cost: Optional[int] = None) -> bool:
try:
answer_response = send_request(endpoint, body=payload)
status = answer_response.get('status', None)
cause = answer_response.get('cause', None)
score = cost if cost else answer_response.get('score', None)
handle_grade_response(status, score=score, cause=cause)
return status == 'valid' or status is True
except Exception as err:
print(f'Failed: {err}')
return False
def submit_answer(payload: dict) -> bool:
try:
access_token = get_access_token()
baseurl = get_submission_endpoint()
endpoint = urljoin(baseurl, './challenges/answers')
submit_response = send_request(
endpoint,
body=payload,
query={'access_token': access_token}
)
status = submit_response.get('status', None)
if status is None:
status = submit_response.get('valid', None)
cause = submit_response.get('cause', None)
handle_submit_response(status, cause=cause)
return status == 'valid' or status is True
except Exception as err:
print(f'Failed: {err}')
return False
def handle_grade_response(
status: Optional[str], score: Optional[int] = None, cause: Optional[str] = None
) -> None:
if status == 'valid':
print('\nCongratulations 🎉! Your answer is correct.')
if score is not None:
print(f'Your score is {score}.')
elif status == 'invalid':
print(f'\nOops 😕! {cause}')
print('Please review your answer and try again.')
elif status == 'notFinished':
print(f'Job has not finished: {cause}')
print(f'Please wait for the job to complete then try again.')
else:
print(f'Failed: {cause}')
print('Unable to grade your answer.')
def handle_submit_response(
status: Union[str, bool], cause: Optional[str] = None
) -> None:
if status == 'valid' or status is True:
print('\nSuccess 🎉! Your answer has been submitted.')
elif status == 'invalid' or status is False:
print(f'\nOops 😕! {"Your answer is incorrect" if cause is None else cause}')
print('Make sure your answer is correct and successfully graded before submitting.')
elif status == 'notFinished':
print(f'Job has not finished: {cause}')
print(f'Please wait for the job to complete, grade it, and then try to submit again.')
else:
print(f'Failed: {cause}')
print('Unable to submit your answer at this time.')
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
!pip install -U -r grading_tools/requirements.txt
from IPython.display import clear_output
clear_output()
import numpy as np; pi = np.pi
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
from copy import deepcopy as make_copy
def prepare_hets_circuit(depth, angle1, angle2):
hets_circ = QuantumCircuit(depth)
hets_circ.ry(angle1, 0)
hets_circ.rz(angle1, 0)
hets_circ.ry(angle1, 1)
hets_circ.rz(angle1, 1)
for ii in range(depth):
hets_circ.cx(0,1)
hets_circ.ry(angle2,0)
hets_circ.rz(angle2,0)
hets_circ.ry(angle2,1)
hets_circ.rz(angle2,1)
return hets_circ
hets_circuit = prepare_hets_circuit(2, pi/2, pi/2)
hets_circuit.draw()
def measure_zz_circuit(given_circuit):
zz_meas = make_copy(given_circuit)
zz_meas.measure_all()
return zz_meas
zz_meas = measure_zz_circuit(hets_circuit)
zz_meas.draw()
simulator = Aer.get_backend('qasm_simulator')
result = execute(zz_meas, backend = simulator, shots=10000).result()
counts = result.get_counts(zz_meas)
plot_histogram(counts)
def measure_zz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zz = counts['00'] + counts['11'] - counts['01'] - counts['10']
zz = zz / total_counts
return zz
zz = measure_zz(hets_circuit)
print("<ZZ> =", str(zz))
def measure_zi(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zi = counts['00'] - counts['11'] + counts['01'] - counts['10']
zi = zi / total_counts
return zi
def measure_iz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
iz = counts['00'] - counts['11'] - counts['01'] + counts['10']
iz = iz / total_counts
return iz
zi = measure_zi(hets_circuit)
print("<ZI> =", str(zi))
iz = measure_iz(hets_circuit)
print("<IZ> =", str(iz))
def measure_xx_circuit(given_circuit):
xx_meas = make_copy(given_circuit)
### WRITE YOUR CODE BETWEEN THESE LINES - START
xx_meas.h(0)
xx_meas.h(1)
xx_meas.measure_all()
### WRITE YOUR CODE BETWEEN THESE LINES - END
return xx_meas
xx_meas = measure_xx_circuit(hets_circuit)
xx_meas.draw()
def measure_xx(given_circuit, num_shots = 10000):
xx_meas = measure_xx_circuit(given_circuit)
result = execute(xx_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(xx_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
xx = counts['00'] + counts['11'] - counts['01'] - counts['10']
xx = xx / total_counts
return xx
xx = measure_xx(hets_circuit)
print("<XX> =", str(xx))
def get_energy(given_circuit, num_shots = 10000):
zz = measure_zz(given_circuit, num_shots = num_shots)
iz = measure_iz(given_circuit, num_shots = num_shots)
zi = measure_zi(given_circuit, num_shots = num_shots)
xx = measure_xx(given_circuit, num_shots = num_shots)
energy = (-1.0523732)*1 + (0.39793742)*iz + (-0.3979374)*zi + (-0.0112801)*zz + (0.18093119)*xx
return energy
energy = get_energy(hets_circuit)
print("The energy of the trial state is", str(energy))
hets_circuit_plus = None
hets_circuit_minus = None
### WRITE YOUR CODE BETWEEN THESE LINES - START
hets_circuit_plus = prepare_hets_circuit(2, pi/2 + 0.1*pi/2, pi/2)
hets_circuit_minus = prepare_hets_circuit(2, pi/2 - 0.1*pi/2, pi/2)
### WRITE YOUR CODE BETWEEN THESE LINES - END
energy_plus = get_energy(hets_circuit_plus, num_shots=100000)
energy_minus = get_energy(hets_circuit_minus, num_shots=100000)
print(energy_plus, energy_minus)
name = 'Pon Rahul M'
email = 'ponrahul.21it@licet.ac.in'
### Do not change the lines below
from grading_tools import grade
grade(answer=measure_xx_circuit(hets_circuit), name=name, email=email, labid='lab9', exerciseid='ex1')
grade(answer=hets_circuit_plus, name=name, email=email, labid='lab9', exerciseid='ex2')
grade(answer=hets_circuit_minus, name=name, email=email, labid='lab9', exerciseid='ex3')
energy_plus_100, energy_plus_1000, energy_plus_10000 = 0, 0, 0
energy_minus_100, energy_minus_1000, energy_minus_10000 = 0, 0, 0
### WRITE YOUR CODE BETWEEN THESE LINES - START
energy_plus_100 = get_energy(hets_circuit_plus, num_shots = 100)
energy_minus_100 = get_energy(hets_circuit_minus, num_shots = 100)
energy_plus_1000 = get_energy(hets_circuit_plus, num_shots = 1000)
energy_minus_1000 = get_energy(hets_circuit_minus, num_shots = 1000)
energy_plus_10000 = get_energy(hets_circuit_plus, num_shots = 10000)
energy_minus_10000 = get_energy(hets_circuit_minus, num_shots = 10000)
### WRITE YOUR CODE BETWEEN THESE LINES - END
print(energy_plus_100, energy_minus_100, "difference = ", energy_minus_100 - energy_plus_100)
print(energy_plus_1000, energy_minus_1000, "difference = ", energy_minus_1000 - energy_plus_1000)
print(energy_plus_10000, energy_minus_10000, "difference = ", energy_minus_10000 - energy_plus_10000)
### WRITE YOUR CODE BETWEEN THESE LINES - START
I = np.array([
[1, 0],
[0, 1]
])
X = np.array([
[0, 1],
[1, 0]
])
Z = np.array([
[1, 0],
[0, -1]
])
h2_hamiltonian = (-1.0523732) * np.kron(I, I) + \
(0.39793742) * np.kron(I, Z) + \
(-0.3979374) * np.kron(Z, I) + \
(-0.0112801) * np.kron(Z, Z) + \
(0.18093119) * np.kron(X, X)
from numpy import linalg as LA
eigenvalues, eigenvectors = LA.eig(h2_hamiltonian)
for ii, eigenvalue in enumerate(eigenvalues):
print(f"Eigenvector {eigenvectors[:,ii]} has energy {eigenvalue}")
exact_eigenvector = eigenvectors[:,np.argmin(eigenvalues)]
exact_eigenvalue = np.min(eigenvalues)
print()
print("Minimum energy is", exact_eigenvalue)
### WRITE YOUR CODE BETWEEN THESE LINES - END
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
!pip install -U -r grading_tools/requirements.txt
from IPython.display import clear_output
clear_output()
import numpy as np; pi = np.pi
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
from copy import deepcopy as make_copy
def prepare_hets_circuit(depth, angle1, angle2):
hets_circ = QuantumCircuit(depth)
hets_circ.ry(angle1, 0)
hets_circ.rz(angle1, 0)
hets_circ.ry(angle1, 1)
hets_circ.rz(angle1, 1)
for ii in range(depth):
hets_circ.cx(0,1)
hets_circ.ry(angle2,0)
hets_circ.rz(angle2,0)
hets_circ.ry(angle2,1)
hets_circ.rz(angle2,1)
return hets_circ
hets_circuit = prepare_hets_circuit(2, pi/2, pi/2)
hets_circuit.draw()
def measure_zz_circuit(given_circuit):
zz_meas = make_copy(given_circuit)
zz_meas.measure_all()
return zz_meas
zz_meas = measure_zz_circuit(hets_circuit)
zz_meas.draw()
simulator = Aer.get_backend('qasm_simulator')
result = execute(zz_meas, backend = simulator, shots=10000).result()
counts = result.get_counts(zz_meas)
plot_histogram(counts)
def measure_zz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zz = counts['00'] + counts['11'] - counts['01'] - counts['10']
zz = zz / total_counts
return zz
zz = measure_zz(hets_circuit)
print("<ZZ> =", str(zz))
def measure_zi(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zi = counts['00'] - counts['11'] + counts['01'] - counts['10']
zi = zi / total_counts
return zi
def measure_iz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
iz = counts['00'] - counts['11'] - counts['01'] + counts['10']
iz = iz / total_counts
return iz
zi = measure_zi(hets_circuit)
print("<ZI> =", str(zi))
iz = measure_iz(hets_circuit)
print("<IZ> =", str(iz))
def measure_xx_circuit(given_circuit):
xx_meas = make_copy(given_circuit)
### WRITE YOUR CODE BETWEEN THESE LINES - START
xx_meas.h(0)
xx_meas.h(1)
xx_meas.measure_all()
### WRITE YOUR CODE BETWEEN THESE LINES - END
return xx_meas
xx_meas = measure_xx_circuit(hets_circuit)
xx_meas.draw()
def measure_xx(given_circuit, num_shots = 10000):
xx_meas = measure_xx_circuit(given_circuit)
result = execute(xx_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(xx_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
xx = counts['00'] + counts['11'] - counts['01'] - counts['10']
xx = xx / total_counts
return xx
xx = measure_xx(hets_circuit)
print("<XX> =", str(xx))
def get_energy(given_circuit, num_shots = 10000):
zz = measure_zz(given_circuit, num_shots = num_shots)
iz = measure_iz(given_circuit, num_shots = num_shots)
zi = measure_zi(given_circuit, num_shots = num_shots)
xx = measure_xx(given_circuit, num_shots = num_shots)
energy = (-1.0523732)*1 + (0.39793742)*iz + (-0.3979374)*zi + (-0.0112801)*zz + (0.18093119)*xx
return energy
energy = get_energy(hets_circuit)
print("The energy of the trial state is", str(energy))
hets_circuit_plus = None
hets_circuit_minus = None
### WRITE YOUR CODE BETWEEN THESE LINES - START
hets_circuit_plus = prepare_hets_circuit(2, pi/2 + 0.1*pi/2, pi/2)
hets_circuit_minus = prepare_hets_circuit(2, pi/2 - 0.1*pi/2, pi/2)
### WRITE YOUR CODE BETWEEN THESE LINES - END
energy_plus = get_energy(hets_circuit_plus, num_shots=100000)
energy_minus = get_energy(hets_circuit_minus, num_shots=100000)
print(energy_plus, energy_minus)
name = 'Pon Rahul M'
email = 'ponrahul.21it@licet.ac.in'
### Do not change the lines below
from grading_tools import grade
grade(answer=measure_xx_circuit(hets_circuit), name=name, email=email, labid='lab9', exerciseid='ex1')
grade(answer=hets_circuit_plus, name=name, email=email, labid='lab9', exerciseid='ex2')
grade(answer=hets_circuit_minus, name=name, email=email, labid='lab9', exerciseid='ex3')
energy_plus_100, energy_plus_1000, energy_plus_10000 = 0, 0, 0
energy_minus_100, energy_minus_1000, energy_minus_10000 = 0, 0, 0
### WRITE YOUR CODE BETWEEN THESE LINES - START
energy_plus_100 = get_energy(hets_circuit_plus, num_shots = 100)
energy_minus_100 = get_energy(hets_circuit_minus, num_shots = 100)
energy_plus_1000 = get_energy(hets_circuit_plus, num_shots = 1000)
energy_minus_1000 = get_energy(hets_circuit_minus, num_shots = 1000)
energy_plus_10000 = get_energy(hets_circuit_plus, num_shots = 10000)
energy_minus_10000 = get_energy(hets_circuit_minus, num_shots = 10000)
### WRITE YOUR CODE BETWEEN THESE LINES - END
print(energy_plus_100, energy_minus_100, "difference = ", energy_minus_100 - energy_plus_100)
print(energy_plus_1000, energy_minus_1000, "difference = ", energy_minus_1000 - energy_plus_1000)
print(energy_plus_10000, energy_minus_10000, "difference = ", energy_minus_10000 - energy_plus_10000)
### WRITE YOUR CODE BETWEEN THESE LINES - START
I = np.array([
[1, 0],
[0, 1]
])
X = np.array([
[0, 1],
[1, 0]
])
Z = np.array([
[1, 0],
[0, -1]
])
h2_hamiltonian = (-1.0523732) * np.kron(I, I) + \
(0.39793742) * np.kron(I, Z) + \
(-0.3979374) * np.kron(Z, I) + \
(-0.0112801) * np.kron(Z, Z) + \
(0.18093119) * np.kron(X, X)
from numpy import linalg as LA
eigenvalues, eigenvectors = LA.eig(h2_hamiltonian)
for ii, eigenvalue in enumerate(eigenvalues):
print(f"Eigenvector {eigenvectors[:,ii]} has energy {eigenvalue}")
exact_eigenvector = eigenvectors[:,np.argmin(eigenvalues)]
exact_eigenvalue = np.min(eigenvalues)
print()
print("Minimum energy is", exact_eigenvalue)
### WRITE YOUR CODE BETWEEN THESE LINES - END
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
!pip install -U -r grading_tools/requirements.txt
from IPython.display import clear_output
clear_output()
import numpy as np; pi = np.pi
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
from copy import deepcopy as make_copy
def prepare_hets_circuit(depth, angle1, angle2):
hets_circ = QuantumCircuit(depth)
hets_circ.ry(angle1, 0)
hets_circ.rz(angle1, 0)
hets_circ.ry(angle1, 1)
hets_circ.rz(angle1, 1)
for ii in range(depth):
hets_circ.cx(0,1)
hets_circ.ry(angle2,0)
hets_circ.rz(angle2,0)
hets_circ.ry(angle2,1)
hets_circ.rz(angle2,1)
return hets_circ
hets_circuit = prepare_hets_circuit(2, pi/2, pi/2)
hets_circuit.draw()
def measure_zz_circuit(given_circuit):
zz_meas = make_copy(given_circuit)
zz_meas.measure_all()
return zz_meas
zz_meas = measure_zz_circuit(hets_circuit)
zz_meas.draw()
simulator = Aer.get_backend('qasm_simulator')
result = execute(zz_meas, backend = simulator, shots=10000).result()
counts = result.get_counts(zz_meas)
plot_histogram(counts)
def measure_zz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zz = counts['00'] + counts['11'] - counts['01'] - counts['10']
zz = zz / total_counts
return zz
zz = measure_zz(hets_circuit)
print("<ZZ> =", str(zz))
def measure_zi(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zi = counts['00'] - counts['11'] + counts['01'] - counts['10']
zi = zi / total_counts
return zi
def measure_iz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
iz = counts['00'] - counts['11'] - counts['01'] + counts['10']
iz = iz / total_counts
return iz
zi = measure_zi(hets_circuit)
print("<ZI> =", str(zi))
iz = measure_iz(hets_circuit)
print("<IZ> =", str(iz))
def measure_xx_circuit(given_circuit):
xx_meas = make_copy(given_circuit)
### WRITE YOUR CODE BETWEEN THESE LINES - START
xx_meas.h(0)
xx_meas.h(1)
xx_meas.measure_all()
### WRITE YOUR CODE BETWEEN THESE LINES - END
return xx_meas
xx_meas = measure_xx_circuit(hets_circuit)
xx_meas.draw()
def measure_xx(given_circuit, num_shots = 10000):
xx_meas = measure_xx_circuit(given_circuit)
result = execute(xx_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(xx_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
xx = counts['00'] + counts['11'] - counts['01'] - counts['10']
xx = xx / total_counts
return xx
xx = measure_xx(hets_circuit)
print("<XX> =", str(xx))
def get_energy(given_circuit, num_shots = 10000):
zz = measure_zz(given_circuit, num_shots = num_shots)
iz = measure_iz(given_circuit, num_shots = num_shots)
zi = measure_zi(given_circuit, num_shots = num_shots)
xx = measure_xx(given_circuit, num_shots = num_shots)
energy = (-1.0523732)*1 + (0.39793742)*iz + (-0.3979374)*zi + (-0.0112801)*zz + (0.18093119)*xx
return energy
energy = get_energy(hets_circuit)
print("The energy of the trial state is", str(energy))
hets_circuit_plus = None
hets_circuit_minus = None
### WRITE YOUR CODE BETWEEN THESE LINES - START
hets_circuit_plus = prepare_hets_circuit(2, pi/2 + 0.1*pi/2, pi/2)
hets_circuit_minus = prepare_hets_circuit(2, pi/2 - 0.1*pi/2, pi/2)
### WRITE YOUR CODE BETWEEN THESE LINES - END
energy_plus = get_energy(hets_circuit_plus, num_shots=100000)
energy_minus = get_energy(hets_circuit_minus, num_shots=100000)
print(energy_plus, energy_minus)
name = 'Pon Rahul M'
email = 'ponrahul.21it@licet.ac.in'
### Do not change the lines below
from grading_tools import grade
grade(answer=measure_xx_circuit(hets_circuit), name=name, email=email, labid='lab9', exerciseid='ex1')
grade(answer=hets_circuit_plus, name=name, email=email, labid='lab9', exerciseid='ex2')
grade(answer=hets_circuit_minus, name=name, email=email, labid='lab9', exerciseid='ex3')
energy_plus_100, energy_plus_1000, energy_plus_10000 = 0, 0, 0
energy_minus_100, energy_minus_1000, energy_minus_10000 = 0, 0, 0
### WRITE YOUR CODE BETWEEN THESE LINES - START
energy_plus_100 = get_energy(hets_circuit_plus, num_shots = 100)
energy_minus_100 = get_energy(hets_circuit_minus, num_shots = 100)
energy_plus_1000 = get_energy(hets_circuit_plus, num_shots = 1000)
energy_minus_1000 = get_energy(hets_circuit_minus, num_shots = 1000)
energy_plus_10000 = get_energy(hets_circuit_plus, num_shots = 10000)
energy_minus_10000 = get_energy(hets_circuit_minus, num_shots = 10000)
### WRITE YOUR CODE BETWEEN THESE LINES - END
print(energy_plus_100, energy_minus_100, "difference = ", energy_minus_100 - energy_plus_100)
print(energy_plus_1000, energy_minus_1000, "difference = ", energy_minus_1000 - energy_plus_1000)
print(energy_plus_10000, energy_minus_10000, "difference = ", energy_minus_10000 - energy_plus_10000)
### WRITE YOUR CODE BETWEEN THESE LINES - START
I = np.array([
[1, 0],
[0, 1]
])
X = np.array([
[0, 1],
[1, 0]
])
Z = np.array([
[1, 0],
[0, -1]
])
h2_hamiltonian = (-1.0523732) * np.kron(I, I) + \
(0.39793742) * np.kron(I, Z) + \
(-0.3979374) * np.kron(Z, I) + \
(-0.0112801) * np.kron(Z, Z) + \
(0.18093119) * np.kron(X, X)
from numpy import linalg as LA
eigenvalues, eigenvectors = LA.eig(h2_hamiltonian)
for ii, eigenvalue in enumerate(eigenvalues):
print(f"Eigenvector {eigenvectors[:,ii]} has energy {eigenvalue}")
exact_eigenvector = eigenvectors[:,np.argmin(eigenvalues)]
exact_eigenvalue = np.min(eigenvalues)
print()
print("Minimum energy is", exact_eigenvalue)
### WRITE YOUR CODE BETWEEN THESE LINES - END
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
!pip install -U -r grading_tools/requirements.txt
from IPython.display import clear_output
clear_output()
import numpy as np; pi = np.pi
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
from copy import deepcopy as make_copy
def prepare_hets_circuit(depth, angle1, angle2):
hets_circ = QuantumCircuit(depth)
hets_circ.ry(angle1, 0)
hets_circ.rz(angle1, 0)
hets_circ.ry(angle1, 1)
hets_circ.rz(angle1, 1)
for ii in range(depth):
hets_circ.cx(0,1)
hets_circ.ry(angle2,0)
hets_circ.rz(angle2,0)
hets_circ.ry(angle2,1)
hets_circ.rz(angle2,1)
return hets_circ
hets_circuit = prepare_hets_circuit(2, pi/2, pi/2)
hets_circuit.draw()
def measure_zz_circuit(given_circuit):
zz_meas = make_copy(given_circuit)
zz_meas.measure_all()
return zz_meas
zz_meas = measure_zz_circuit(hets_circuit)
zz_meas.draw()
simulator = Aer.get_backend('qasm_simulator')
result = execute(zz_meas, backend = simulator, shots=10000).result()
counts = result.get_counts(zz_meas)
plot_histogram(counts)
def measure_zz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zz = counts['00'] + counts['11'] - counts['01'] - counts['10']
zz = zz / total_counts
return zz
zz = measure_zz(hets_circuit)
print("<ZZ> =", str(zz))
def measure_zi(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zi = counts['00'] - counts['11'] + counts['01'] - counts['10']
zi = zi / total_counts
return zi
def measure_iz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
iz = counts['00'] - counts['11'] - counts['01'] + counts['10']
iz = iz / total_counts
return iz
zi = measure_zi(hets_circuit)
print("<ZI> =", str(zi))
iz = measure_iz(hets_circuit)
print("<IZ> =", str(iz))
def measure_xx_circuit(given_circuit):
xx_meas = make_copy(given_circuit)
### WRITE YOUR CODE BETWEEN THESE LINES - START
xx_meas.h(0)
xx_meas.h(1)
xx_meas.measure_all()
### WRITE YOUR CODE BETWEEN THESE LINES - END
return xx_meas
xx_meas = measure_xx_circuit(hets_circuit)
xx_meas.draw()
def measure_xx(given_circuit, num_shots = 10000):
xx_meas = measure_xx_circuit(given_circuit)
result = execute(xx_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(xx_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
xx = counts['00'] + counts['11'] - counts['01'] - counts['10']
xx = xx / total_counts
return xx
xx = measure_xx(hets_circuit)
print("<XX> =", str(xx))
def get_energy(given_circuit, num_shots = 10000):
zz = measure_zz(given_circuit, num_shots = num_shots)
iz = measure_iz(given_circuit, num_shots = num_shots)
zi = measure_zi(given_circuit, num_shots = num_shots)
xx = measure_xx(given_circuit, num_shots = num_shots)
energy = (-1.0523732)*1 + (0.39793742)*iz + (-0.3979374)*zi + (-0.0112801)*zz + (0.18093119)*xx
return energy
energy = get_energy(hets_circuit)
print("The energy of the trial state is", str(energy))
hets_circuit_plus = None
hets_circuit_minus = None
### WRITE YOUR CODE BETWEEN THESE LINES - START
hets_circuit_plus = prepare_hets_circuit(2, pi/2 + 0.1*pi/2, pi/2)
hets_circuit_minus = prepare_hets_circuit(2, pi/2 - 0.1*pi/2, pi/2)
### WRITE YOUR CODE BETWEEN THESE LINES - END
energy_plus = get_energy(hets_circuit_plus, num_shots=100000)
energy_minus = get_energy(hets_circuit_minus, num_shots=100000)
print(energy_plus, energy_minus)
name = 'Pon Rahul M'
email = 'ponrahul.21it@licet.ac.in'
### Do not change the lines below
from grading_tools import grade
grade(answer=measure_xx_circuit(hets_circuit), name=name, email=email, labid='lab9', exerciseid='ex1')
grade(answer=hets_circuit_plus, name=name, email=email, labid='lab9', exerciseid='ex2')
grade(answer=hets_circuit_minus, name=name, email=email, labid='lab9', exerciseid='ex3')
energy_plus_100, energy_plus_1000, energy_plus_10000 = 0, 0, 0
energy_minus_100, energy_minus_1000, energy_minus_10000 = 0, 0, 0
### WRITE YOUR CODE BETWEEN THESE LINES - START
energy_plus_100 = get_energy(hets_circuit_plus, num_shots = 100)
energy_minus_100 = get_energy(hets_circuit_minus, num_shots = 100)
energy_plus_1000 = get_energy(hets_circuit_plus, num_shots = 1000)
energy_minus_1000 = get_energy(hets_circuit_minus, num_shots = 1000)
energy_plus_10000 = get_energy(hets_circuit_plus, num_shots = 10000)
energy_minus_10000 = get_energy(hets_circuit_minus, num_shots = 10000)
### WRITE YOUR CODE BETWEEN THESE LINES - END
print(energy_plus_100, energy_minus_100, "difference = ", energy_minus_100 - energy_plus_100)
print(energy_plus_1000, energy_minus_1000, "difference = ", energy_minus_1000 - energy_plus_1000)
print(energy_plus_10000, energy_minus_10000, "difference = ", energy_minus_10000 - energy_plus_10000)
### WRITE YOUR CODE BETWEEN THESE LINES - START
I = np.array([
[1, 0],
[0, 1]
])
X = np.array([
[0, 1],
[1, 0]
])
Z = np.array([
[1, 0],
[0, -1]
])
h2_hamiltonian = (-1.0523732) * np.kron(I, I) + \
(0.39793742) * np.kron(I, Z) + \
(-0.3979374) * np.kron(Z, I) + \
(-0.0112801) * np.kron(Z, Z) + \
(0.18093119) * np.kron(X, X)
from numpy import linalg as LA
eigenvalues, eigenvectors = LA.eig(h2_hamiltonian)
for ii, eigenvalue in enumerate(eigenvalues):
print(f"Eigenvector {eigenvectors[:,ii]} has energy {eigenvalue}")
exact_eigenvector = eigenvectors[:,np.argmin(eigenvalues)]
exact_eigenvalue = np.min(eigenvalues)
print()
print("Minimum energy is", exact_eigenvalue)
### WRITE YOUR CODE BETWEEN THESE LINES - END
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# (C) Copyright IBM 2020.
#
# 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 json
from typing import Any, Callable, Optional, Tuple, Union
from urllib.parse import urljoin
from qiskit import QuantumCircuit, execute
from qiskit.providers import JobStatus
from qiskit.providers.ibmq.job import IBMQJob
from .api import get_server_endpoint, send_request, get_access_token, get_submission_endpoint
from .exercises import get_question_id
from .util import compute_cost, get_provider, get_job, circuit_to_json, get_job_urls, uses_multiqubit_gate
def _circuit_criteria(
circuit: QuantumCircuit,
max_qubits: Optional[int] = None,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False
) -> Tuple[Optional[int], Optional[int]]:
if max_qubits is not None and circuit.num_qubits > max_qubits:
print(f'Your circuit has {circuit.num_qubits} qubits, which exceeds the maximum allowed.')
print(f'Please reduce the number of qubits in your circuit to below {max_qubits}.')
return None, None
try:
if check_gates and not uses_multiqubit_gate(circuit):
print('Your circuit appears to not use any multi-quibit gates.')
print('Please review your circuit and try again.')
return None, None
cost = compute_cost(circuit)
if min_cost is not None and cost < min_cost:
print(f'Your circuit cost ({cost}) is too low. But if you are convinced that your circuit\n'
'is correct, please let us know in the `#ibm-quantum-challenge-2020` Slack channel.')
return None, None
return circuit.num_qubits, cost
except Exception as err:
print(f'Unable to compute cost: {err}')
return None, None
def _circuit_grading(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False,
max_qubits: Optional[int] = None,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
payload = None
server = None
if not isinstance(circuit, QuantumCircuit):
print(f'Expected a QuantumCircuit, but was given {type(circuit)}')
print(f'Please provide a circuit as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or '
'the grading servers are down right now.')
return None, None
else:
server = None
_, cost = _circuit_criteria(
circuit,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if cost is not None:
payload = {
'answer': circuit_to_json(circuit)
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def _job_grading(
job_or_id: Union[IBMQJob, str],
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
if not isinstance(job_or_id, IBMQJob) and not isinstance(job_or_id, str):
print(f'Expected an IBMQJob or a job ID, but was given {type(job_or_id)}')
print(f'Please submit a job as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or the grading '
'servers are down right now.')
return None, None
else:
server = None
job = get_job(job_or_id) if isinstance(job_or_id, str) else job_or_id
if not job:
print('An invalid or non-existent job was specified.')
return None, None
job_status = job.status()
if job_status in [JobStatus.CANCELLED, JobStatus.ERROR]:
print(f'Job did not successfully complete: {job_status.value}.')
return None, None
elif job_status is not JobStatus.DONE:
print(f'Job has not yet completed: {job_status.value}.')
print(f'Please wait for the job (id: {job.job_id()}) to complete then try again.')
return None, None
header = job.result().header.to_dict()
if 'qc_cost' not in header:
if is_submit:
print('An unprepared answer was specified. '
'Please prepare() and grade() answer before submitting.')
else:
print('An unprepared answer was specified. Please prepare() answer before grading.')
return None, None
download_url, result_url = get_job_urls(job)
if not download_url or not result_url:
print('Unable to obtain job URLs')
return None, None
payload = {
'answer': json.dumps({
'download_url': download_url,
'result_url': result_url
})
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def _number_grading(
answer: int,
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
if not isinstance(answer, int):
print(f'Expected a integer, but was given {type(answer)}')
print(f'Please provide a number as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server '
'or the grading servers are down right now.')
return None, None
else:
server = None
payload = {
'answer': str(answer)
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def prepare_circuit(
circuit: QuantumCircuit,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False,
**kwargs
) -> Optional[IBMQJob]:
job = None
if not isinstance(circuit, QuantumCircuit):
print(f'Expected a QuantumCircuit, but was given {type(circuit)}')
print(f'Please provide a circuit.')
return None
_, cost = _circuit_criteria(
circuit,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if cost is not None:
if 'backend' not in kwargs:
kwargs['backend'] = get_provider().get_backend('ibmq_qasm_simulator')
# execute experiments
print('Starting experiment. Please wait...')
job = execute(
circuit,
qobj_header={
'qc_cost': cost
},
**kwargs
)
print(f'You may monitor the job (id: {job.job_id()}) status '
'and proceed to grading when it successfully completes.')
return job
def prepare_solver(
solver_func: Callable,
lab_id: str,
ex_id: str,
problem_set: Optional[Any] = None,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False,
**kwargs
) -> Optional[IBMQJob]:
job = None
if not callable(solver_func):
print(f'Expected a function, but was given {type(solver_func)}')
print(f'Please provide a function that returns a QuantumCircuit.')
return None
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or the grading servers are down right now.')
return
endpoint = server + 'problem-set'
index, value = get_problem_set(lab_id, ex_id, endpoint)
print(f'Running {solver_func.__name__}...')
qc_1 = solver_func(problem_set)
_, cost = _circuit_criteria(
qc_1,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if value and index is not None and index >= 0 and cost is not None:
qc_2 = solver_func(value)
if 'backend' not in kwargs:
kwargs['backend'] = get_provider().get_backend('ibmq_qasm_simulator')
# execute experiments
print('Starting experiments. Please wait...')
job = execute(
[qc_1, qc_2],
qobj_header={
'qc_index': [None, index],
'qc_cost': cost
},
**kwargs
)
print(f'You may monitor the job (id: {job.job_id()}) status '
'and proceed to grading when it successfully completes.')
return job
def grade_circuit(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None
) -> bool:
payload, server = _circuit_grading(
circuit,
lab_id,
ex_id,
is_submit=False,
max_qubits=max_qubits,
min_cost=min_cost
)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def grade_job(
job_or_id: Union[IBMQJob, str],
lab_id: str,
ex_id: str
) -> bool:
payload, server = _job_grading(job_or_id, lab_id, ex_id, is_submit=False)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def grade_number(
answer: int,
lab_id: str,
ex_id: str
) -> bool:
payload, server = _number_grading(answer, lab_id, ex_id, is_submit=False)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def submit_circuit(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None
) -> bool:
payload, _ = _circuit_grading(
circuit,
lab_id,
ex_id,
is_submit=True,
max_qubits=max_qubits,
min_cost=min_cost
)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def submit_job(
job_or_id: IBMQJob,
lab_id: str,
ex_id: str,
) -> bool:
payload, _ = _job_grading(job_or_id, lab_id, ex_id, is_submit=True)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def submit_number(
answer: int,
lab_id: str,
ex_id: str
) -> bool:
payload, _ = _number_grading(answer, lab_id, ex_id, is_submit=True)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def get_problem_set(
lab_id: str, ex_id: str, endpoint: str
) -> Tuple[Optional[int], Optional[Any]]:
problem_set_response = None
try:
payload = {'question_id': get_question_id(lab_id, ex_id)}
problem_set_response = send_request(endpoint, query=payload, method='GET')
except Exception as err:
print('Unable to obtain the problem set')
if problem_set_response:
status = problem_set_response.get('status')
if status == 'valid':
try:
index = problem_set_response.get('index')
value = json.loads(problem_set_response.get('value'))
return index, value
except Exception as err:
print(f'Problem set could not be processed: {err}')
else:
cause = problem_set_response.get('cause')
print(f'Problem set failed: {cause}')
return None, None
def grade_answer(payload: dict, endpoint: str, cost: Optional[int] = None) -> bool:
try:
answer_response = send_request(endpoint, body=payload)
status = answer_response.get('status', None)
cause = answer_response.get('cause', None)
score = cost if cost else answer_response.get('score', None)
handle_grade_response(status, score=score, cause=cause)
return status == 'valid' or status is True
except Exception as err:
print(f'Failed: {err}')
return False
def submit_answer(payload: dict) -> bool:
try:
access_token = get_access_token()
baseurl = get_submission_endpoint()
endpoint = urljoin(baseurl, './challenges/answers')
submit_response = send_request(
endpoint,
body=payload,
query={'access_token': access_token}
)
status = submit_response.get('status', None)
if status is None:
status = submit_response.get('valid', None)
cause = submit_response.get('cause', None)
handle_submit_response(status, cause=cause)
return status == 'valid' or status is True
except Exception as err:
print(f'Failed: {err}')
return False
def handle_grade_response(
status: Optional[str], score: Optional[int] = None, cause: Optional[str] = None
) -> None:
if status == 'valid':
print('\nCongratulations 🎉! Your answer is correct.')
if score is not None:
print(f'Your score is {score}.')
elif status == 'invalid':
print(f'\nOops 😕! {cause}')
print('Please review your answer and try again.')
elif status == 'notFinished':
print(f'Job has not finished: {cause}')
print(f'Please wait for the job to complete then try again.')
else:
print(f'Failed: {cause}')
print('Unable to grade your answer.')
def handle_submit_response(
status: Union[str, bool], cause: Optional[str] = None
) -> None:
if status == 'valid' or status is True:
print('\nSuccess 🎉! Your answer has been submitted.')
elif status == 'invalid' or status is False:
print(f'\nOops 😕! {"Your answer is incorrect" if cause is None else cause}')
print('Make sure your answer is correct and successfully graded before submitting.')
elif status == 'notFinished':
print(f'Job has not finished: {cause}')
print(f'Please wait for the job to complete, grade it, and then try to submit again.')
else:
print(f'Failed: {cause}')
print('Unable to submit your answer at this time.')
|
https://github.com/W-Bernau/QiskitAlgorithms
|
W-Bernau
|
from qiskit import *
from math import pi
import numpy as np
from qiskit_aer import Aer
from qiskit.visualization import *
import matplotlib.pyplot as plt
from qutip import *
qc = QuantumCircuit(2)
qc.h(1)
qc.barrier()
qc.cu(np.pi/2, 0, 1, 0, 0 ,1)
qc.barrier()
qc.h(0)
qc.barrier()
qc.swap(0,1)
qc.draw()
backend = Aer.get_backend('statevector_simulator')
out = (backend.run(transpile(qc,backend))).result().get_statevector()
print(out)
def qft3():
n = 3
q = QuantumRegister(n)
c = ClassicalRegister(n)
qc = QuantumCircuit(q,c)
qc.h(q[2])
qc.barrier()
qc.cu(np.pi/2, 0, 0, 0, q[1], q[2])
qc.barrier()
qc.h(q[1])
qc.barrier()
qc.cu(np.pi/4, 0, 0, 0, q[0], q[2])
qc.barrier()
qc.cu(np.pi/2, 0, 0, 0, q[0], q[1])
qc.barrier()
qc.h(q[0])
qc.barrier()
qc.swap(q[0], q[2])
return q,c,qc
q,c,qc = qft3()
qc.barrier()
qc.draw()
|
https://github.com/W-Bernau/QiskitAlgorithms
|
W-Bernau
|
#Importing Libraries
from qiskit import *
from qiskit_aer import Aer
from math import pi, gcd
import numpy as np
from qiskit.visualization import plot_bloch_multivector,plot_state_qsphere
import matplotlib.pyplot as plt
#Drawing a Basic Circuit
qc = QuantumCircuit(2)
qc.barrier()
qc1 = qc.copy()
qc.h(0)
qc.barrier()
qc2 =qc.copy()
qc.draw('mpl')
#Showing two different states
backend = Aer.get_backend('statevector_simulator')
q1 = transpile(qc1,backend)
job1 = (backend.run(q1)).result().get_statevector()
backend = Aer.get_backend('statevector_simulator')
q2 = transpile(qc2,backend)
job2 = (backend.run(q2)).result().get_statevector()
print(job1,job2)
#Showing the Pauli & Hardaman Gate (controlled NOT)
q = QuantumRegister(2)
qc = QuantumCircuit(2)
qc.cx(0,1)
qc.ch(0,1)
qc.y(0)
qc.draw(output='mpl')
backend = Aer.get_backend('unitary_simulator')
job = transpile(qc, backend)
result = (backend.run(job)).result()
print(result.get_unitary(qc, decimals=3))
#Showing an elementary three qubit gates
q = QuantumRegister(3)
qc = QuantumCircuit(3)
qc.cx(0,2)
qc.ccx(0,1,2)
qc.draw(output='mpl')
#Showing U Operator and Phase Gates
q = QuantumRegister(3)
qc = QuantumCircuit(q)
qc.u(pi/2,pi/2,pi/2,q[0])
qc.cu(pi/2, 0, 0, 0, 0, 1)
qc.u(pi/2,pi/2,pi/2,q[1])
qc.cu(pi/2, 0, 0, 0, 1, 2)
qc.u(pi/2,pi/2,pi/2,q[2])
qc.draw(output='mpl')
from qiskit.circuit.library import QFT
from fractions import Fraction
def modular_exponentiation(given_circuit, n, m, a):
for x in range(n):
exponent = 2**x
given_circuit.append(a_x_mod15(a, exponent),
[x] + list(range(n, n+m)))
def shor_circuit(a,n,m):
# Input : a - guess for factor of 15
# n - number of measurements
# m - number of target qubits
# Setting up circuit
shor = QuantumCircuit(n+m, n)
# Initializing firsts n qubits with Hadamard
shor.h(range(n))
# Applying sigma_x gate to last qubit
shor.x(n+m-1)
shor.barrier()
#Apply modular exponentiation gates
modular_exponentiation(shor, n, m, a)
shor.barrier()
#Apply inverse QFT
shor.append(QFT(n, do_swaps=False).inverse(), range(n))
# measure the first n qubits
shor.measure(range(n), range(n))
return shor
n = 4; m = 4; a = 2
shor_example = shor_circuit(a,n,m)
shor_example.draw(output = 'mpl')
#Shor's Algorithm for 15
backend = Aer.get_backend('qasm_simulator')
def factor(N=15,backend=backend):
found_factors = False
n = len(bin(N))-2
m = n
valid_a = [2,7,8,11,13]
while found_factors == False:
# STEP 1: Choose a randomly in valid a's
if len(valid_a)==0:
break
a = np.random.choice(valid_a)
print(f"Trying a = {a}")
r = 1 #defining a wrong r
# STEP 2: Find period r
while a**r%N != 1: #Adding loop because QPE + continued fractions can find wrong r
## Substep 2.1: Find phase s/r
#Defining Shor's Circuits (QPE):
qc = shor_circuit(a,n,m)
#Doing the measurement (binary):
measure = (transpile(qc, backend=backend))
job = (backend.run(measure, shots=1,memory=True)).result().get_memory()[0]
#Converting to decimal base:
job = int(job,2)
phase = job/(2**(n-1))
## Substep 2.2: Find denominator r (Continued fraction algorithm)
r = Fraction(phase).limit_denominator(N).denominator
# STEPS 3 and 4: check if r is even and a^(r/2) != -1 (mod N)
if r%2==0 and (a**(r/2)+1)%N!=0:
#STEP 5: Compute factors
factors = [gcd(a**(r//2)-1,N),gcd(a**(r//2)+1,N)]
print(f" --- order r = {r}")
if factors[0] not in [1,N]: # Check to see if factor is a non trivial one
found_factors = True
print(f" --- Sucessfully found factors {factors}")
else:
print(f" --- Trivial factors found: [1,15]")
if found_factors == False:
print(f" --- a={a} failed!")
valid_a.remove(a)
factor()
|
https://github.com/W-Bernau/QiskitAlgorithms
|
W-Bernau
|
from qiskit.circuit.library import TwoLocal, ZZFeatureMap
from qiskit_algorithms.optimizers import COBYLA
from qiskit_algorithms.utils import algorithm_globals
from sklearn.datasets import load_breast_cancer
from sklearn.preprocessing import MinMaxScaler
from qiskit_machine_learning.algorithms import VQC
from qiskit.circuit.library import ZZFeatureMap
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
seed = 1376
algorithm_globals.random_seed = seed
cancerData = load_breast_cancer()
print(cancerData.DESCR)
import pandas as pd
import seaborn as sns
from sklearn.decomposition import PCA
from sklearn.svm import SVC
features = cancerData.data
labels = cancerData.target
features = MinMaxScaler().fit_transform(features)
num_features = features.shape[1]
feature_map = ZZFeatureMap(feature_dimension=num_features, reps=1)
feature_map.decompose().draw(style="clifford")
from qiskit.circuit.library import RealAmplitudes
from qiskit.primitives import Sampler
from IPython.display import clear_output
ansatz = RealAmplitudes(num_qubits=num_features, reps=3)
optimizer = COBYLA(maxiter=100)
sampler = Sampler()
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)
def callback_graph(weights, obj_func_eval):
clear_output(wait=True)
objective_func_vals.append(obj_func_eval)
plt.title("Objective function value against iteration")
plt.xlabel("Iteration")
plt.ylabel("Objective function value")
plt.plot(range(len(objective_func_vals)), objective_func_vals)
plt.show()
df = pd.DataFrame(cancerData.data, columns=cancerData.feature_names)
df["class"] = pd.Series(cancerData.target)
sns.pairplot(df, hue="class", palette="tab10")
import time
from qiskit_machine_learning.algorithms.classifiers import VQC
algorithm_globals.random_seed = 12
train_features, test_features, train_labels, test_labels = train_test_split(
features, labels, train_size=0.8, random_state=algorithm_globals.random_seed
)
svc = SVC()
_ = svc.fit(train_features, train_labels) # suppress printing the return value
train_score_c4 = svc.score(train_features, train_labels)
test_score_c4 = svc.score(test_features, test_labels)
print(f"Classical SVC on the training dataset: {train_score_c4:.2f}")
print(f"Classical SVC on the test dataset: {test_score_c4:.2f}")
vqc = VQC(
sampler=sampler,
feature_map=feature_map,
ansatz=ansatz,
optimizer=optimizer,
callback=callback_graph,
)
# clear objective value history
objective_func_vals = []
start = time.time()
vqc.fit(train_features, train_labels)
train_score_q4 = vqc.score(train_features, train_labels)
test_score_q4 = vqc.score(test_features, test_labels)
print(f"Quantum VQC on the training dataset: {train_score_q4:.2f}")
print(f"Quantum VQC on the test dataset: {test_score_q4:.2f}")
|
https://github.com/helionagamachi/QISKit
|
helionagamachi
|
from qiskit import QuantumProgram
import Qconfig
import sys
qp = QuantumProgram()
qp.set_api(Qconfig.APItoken, Qconfig.config['url']) # set the APIToken and API url
# set up registers and program
qr = qp.create_quantum_register('qr', 16)
cr = qp.create_classical_register('cr', 16)
qc = qp.create_circuit('smiley_writer', [qr], [cr])
# rightmost eight (qu)bits have ')' = 00101001
qc.x(qr[0])
qc.x(qr[3])
qc.x(qr[5])
# second eight (qu)bits have superposition of
# '8' = 00111000
# ';' = 00111011
# these differ only on the rightmost two bits
qc.h(qr[9]) # create superposition on 9
qc.cx(qr[9],qr[8]) # spread it to 8 with a cnot
qc.x(qr[11])
qc.x(qr[12])
qc.x(qr[13])
# measure
for j in range(16):
qc.measure(qr[j], cr[j])
backend = 'ibmqx_qasm_simulator'
if len(sys.argv) > 1:
backend = sys.argv[1]
# run and get results
print('Executing..')
results = qp.execute(['smiley_writer'], backend, shots=1024)
print('waiting for results')
stats = results.get_counts('smiley_writer')
print(stats)
|
https://github.com/chaitanya-bhargava/QiskitSolutions
|
chaitanya-bhargava
|
## Enter Team ID
import os
os.environ["TEAMID"] = "Excalibur"
from qiskit import QuantumCircuit
def make_bell_state():
qc = QuantumCircuit(2)
### your code here
qc.x(0)
qc.h(0)
qc.cx(0,1)
### your code here
return qc
def test_function_1():
circuit = make_bell_state()
return circuit
test_function_1().draw()
from grader.graders.problem_1.grader import grader1
grader1.evaluate(make_bell_state)
def superposition_operation(n):
qc = QuantumCircuit(n)
### Your code here
for i in range(n):
qc.h(i)
### Your code here
return qc
def test_function_2():
n = 5
operation = superposition_operation(n)
return operation
test_function_2().draw()
from grader.graders.problem_1.grader import grader2
grader2.evaluate(superposition_operation)
def make_even_odd(n):
even = QuantumCircuit(n)
odd = QuantumCircuit(n)
### your code here
for i in range(1,n):
even.h(i)
odd.h(i)
odd.x(0)
### your code here
return (even, odd)
def test_function_3():
n = 3
even, odd = make_even_odd(n)
return even, odd
even, odd = test_function_3()
display(even.draw('mpl'))
odd.draw('mpl')
from grader.graders.problem_1.grader import grader3
grader3.evaluate(make_even_odd)
|
https://github.com/chaitanya-bhargava/QiskitSolutions
|
chaitanya-bhargava
|
## Enter Team ID
import os
os.environ["TEAMID"] = "Excalibur"
def get_min_swaps_line(N, controls, targets, connectivity_map):
min_swaps = []
### You code goes here
length=len(controls)
for i in range(length):
if(targets[i] in connectivity_map[controls[i]]):
min_swaps.append(0)
else:
min_swaps.append(abs(targets[i]-controls[i])-1)
### your code goes here
return min_swaps
def test_function_1():
controls = [1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5]
targets = [2,3,4,5,1,3,4,5,1,2,4,5,1,2,3,5,1,2,3,4]
connectivity_map = {
1 : [2],
2 : [1,3],
3 : [2,4],
4 : [3,5],
5 : [4]
}
N = 5
min_swaps = get_min_swaps_line(N, controls, targets, connectivity_map)
return min_swaps
test_function_1()
from grader.graders.problem_2.grader import grader1
grader1.evaluate(get_min_swaps_line)
import sys
def get_min_swaps_graph(N, M, controls, targets, connectivity_map):
min_swaps = []
### You code goes here
length=len(controls)
for i in range(length):
if(targets[i] in connectivity_map[controls[i]]):
min_swaps.append(0)
else:
u=controls[i]
v=targets[i]
visited=[]
distance=[]
q=[]
for i in range(N):
visited.append(0)
distance.append(sys.maxsize)
for k in connectivity_map[u]:
distance[k-1]=1
distance[u-1]=0
q.append(u)
visited[u-1]=1
while(q):
x=q.pop(0)
templist=connectivity_map[x]
length2=len(templist)
for j in range(length2):
if(visited[templist[j]-1]==1):
continue
if((distance[x-1]+1)<distance[templist[j]-1]):
distance[templist[j]-1]=distance[x-1]+1
q.append(templist[j])
visited[templist[j]-1]=1
if(distance[v-1]==sys.maxsize):
min_swaps.append(-1)
continue
min_swaps.append(distance[v-1]-1)
### your code goes here
return min_swaps
def test_function_2():
controls = [1, 2]
targets = [2, 5]
connectivity_map = {
1 : [2],
2 : [1,3],
3 : [2,4,5],
4 : [3],
5 : [3]
}
N = 5
M = 4
min_swaps = get_min_swaps_graph(N, M, controls, targets, connectivity_map)
return min_swaps
test_function_2()
from grader.graders.problem_2.grader import grader2
grader2.evaluate(get_min_swaps_graph)
|
https://github.com/chaitanya-bhargava/QiskitSolutions
|
chaitanya-bhargava
|
## Enter Team ID
import os
os.environ["TEAMID"] = "Excalibur"
from qiskit import QuantumCircuit
from qiskit.visualization import visualize_transition
import numpy as np
# build the quantum circuit
q = QuantumCircuit(1)
# init the state
q.h(0)
q.rz(np.pi/2,0)
# already |0>
# apply transformation
q.rz(0, 0)
q.rx(np.pi/2, 0)
q.ry(0, 0)
visualize_transition(q)
def generate_bloch_operation(state):
rotation = [0,0,0]
### Your code goes here
if(state=='1'):
rotation=[0,0,-2]
elif(state=='+'):
rotation=[0,0,-1]
elif(state=='-'):
rotation=[0,0,1]
elif(state=='r'):
rotation=[0,1,0]
elif(state=='l'):
rotation=[0,-1,0]
### Your code goes here
return rotation
def test_function_1():
state = '+'
rotation = generate_bloch_operation(state)
return rotation
test_function_1()
from grader.graders.problem_3.grader import grader1
grader1.evaluate(generate_bloch_operation)
def get_total_bloch_ops(state, arz, arx, ary):
total = 0
qc=QuantumCircuit(1)
### Your code goes here
for i in arz:
for j in arx:
for k in ary:
qc.reset(0)
if(state=='1'):
qc.x(0)
elif(state=='+'):
qc.h(0)
elif(state=='-'):
qc.x(0)
qc.h(0)
elif(state=='r'):
qc.h(0)
qc.rz(np.pi/2,0)
elif(state=='l'):
qc.h(0)
qc.rz(-np.pi/2,0)
qc.rz(i*np.pi/2,0)
qc.rx(j*np.pi/2,0)
qc.ry(k*np.pi/2,0)
### Your code goes here
return total
def test_function_2():
# say we have these arrays
arz = [2]
arx = [-2]
ary = [0, 2]
# initial state is |0>
state = '0'
# your function would return these two things
total = get_total_bloch_ops(state, arz, arx, ary)
return total
test_function_2()
from grader.graders.problem_3.grader import grader2
grader2.evaluate(get_total_bloch_ops)
def get_larger_total_bloch_ops(state, arz, arx, ary):
total = 0
### Your code goes here
### Your code goes here
return total
def test_function_3():
# say we have these arrays
arz = [2]
arx = [-2]
ary = [0, 2]
# initial state is |0>
state = '0'
# your function would return these two things
total = get_larger_total_bloch_ops(state, arz, arx, ary)
return total
test_function_3()
from grader.graders.problem_3.grader import grader3
grader3.evaluate(get_larger_total_bloch_ops)
|
https://github.com/chaitanya-bhargava/QiskitSolutions
|
chaitanya-bhargava
|
## Enter Team ID
import os
os.environ["TEAMID"] = "Excalibur"
from qiskit import QuantumCircuit
def dj_circuit_2q(oracle):
dj_circuit = QuantumCircuit(3,2)
### Your code here
dj_circuit.x(2)
dj_circuit.barrier()
dj_circuit.h(range(3))
dj_circuit.barrier()
dj_circuit.compose(oracle, inplace = True)
dj_circuit.barrier()
dj_circuit.h(range(2))
dj_circuit.measure(range(2), range(2))
### Your code here
return dj_circuit
def test_function_1():
# a constant oracle with f(x)=0 for all inputs
oracle = QuantumCircuit(3)
oracle.id(2)
dj_circuit = dj_circuit_2q(oracle)
return dj_circuit
test_function_1().draw()
from grader.graders.problem_4.grader import grader1
grader1.evaluate(dj_circuit_2q)
def dj_circuit_4q(oracle):
circuit = QuantumCircuit(5, 4)
### Your code here
circuit.x(4)
circuit.barrier()
circuit.h(range(5))
circuit.barrier()
circuit.compose(oracle, inplace = True)
circuit.barrier()
circuit.h(range(4))
circuit.measure(range(4), range(4))
### Your code here
return circuit
def test_function_2():
oracle = QuantumCircuit(5)
oracle.id(4)
dj_circuit = dj_circuit_4q(oracle)
return dj_circuit
test_function_2().draw()
from grader.graders.problem_4.grader import grader2
grader2.evaluate(dj_circuit_4q)
from qiskit import QuantumCircuit
def dj_circuit_general(n, oracle):
dj_circuit = QuantumCircuit(n+1, n)
### Your code here
dj_circuit.x(n)
dj_circuit.barrier()
dj_circuit.h(range(n+1))
dj_circuit.barrier()
dj_circuit.compose(oracle, inplace = True)
dj_circuit.barrier()
dj_circuit.h(range(n))
dj_circuit.measure(range(n), range(n))
### Your code here
return dj_circuit
def test_function_3():
N = 6
# constant oracle with f(x) = 0
oracle = QuantumCircuit(7)
oracle.id(6)
circuit = dj_circuit_general(N, oracle)
return circuit
test_function_3().draw()
from grader.graders.problem_4.grader import grader3
grader3.evaluate(dj_circuit_general)
|
https://github.com/chaitanya-bhargava/QiskitSolutions
|
chaitanya-bhargava
|
## Enter Team ID
import os
os.environ["TEAMID"] = "Excalibur"
from qiskit import QuantumCircuit
from numpy import *
def qram_4q(m, array):
### your code here
size=int(floor(log2(m))+3)
n=size-2
qc=QuantumCircuit(size)
binary=[]
k=str(n)
for i in array:
binary.append(format(i, f'0{k}b'))
i=0
qc.h(0)
qc.h(1)
qc.x(0)
qc.x(1)
for j in range(1,n+1):
if(binary[i][j-1]=='1'):
qc.ccx(0,1,size-j)
i=i+1
qc.x(0)
qc.x(1)
qc.x(1)
for j in range(1,n+1):
if(binary[i][j-1]=='1'):
qc.ccx(0,1,size-j)
i=i+1
qc.x(1)
qc.x(0)
for j in range(1,n+1):
if(binary[i][j-1]=='1'):
qc.ccx(0,1,size-j)
i=i+1
qc.x(0)
for j in range(1,n+1):
if(binary[i][j-1]=='1'):
qc.ccx(0,1,size-j)
return qc
### your code here
def test_function_1():
m = 6
array = [3, 4, 5, 6]
qram = qram_4q(m, array)
return qram
test_function_1().draw('mpl')
from grader.graders.problem_5.grader import grader1
grader1.evaluate(qram_4q)
def qram_general(n, m, array):
### your code here
k=int(floor(log2(m))+1)
l=int(log2(n))
size=k+l
qc=QuantumCircuit(size)
index=list(range(l))
binary=[]
for i in array:
binary.append(format(i, f'0{k}b'))
qc.h(index)
for i in range(n):
b=format(i,f'0{l}b')
inverted=[]
for p in range(0,l):
if(b[p]=='0'):
qc.x(l-p-1)
inverted.append(l-p-1)
for j in range(1,k+1):
if(binary[i][j-1]=='1'):
qc.mct(index,size-j)
for q in inverted:
qc.x(q)
return qc
### your code here
def test_function_2():
n = 4
m = 4
array = [3,4,5,6]
qram = qram_general(n, m, array)
return qram
test_function_2().draw('mpl')
from grader.graders.problem_5.grader import grader2
grader2.evaluate(qram_general)
from qiskit.circuit.library import RYGate,RXGate,RZGate
def qram_rotations(n, rotations):
### your code here
l=int(log2(n))
size=l+1
qc=QuantumCircuit(size)
index=list(range(l))
full=list(range(size))
qc.h(index)
for i in range(n):
b=format(i,f'0{l}b')
inverted=[]
for p in range(0,l):
if(b[p]=='0'):
qc.x(l-p-1)
inverted.append(l-p-1)
qc.barrier()
if(rotations[i][0]=='x'):
multirx = RXGate(rotations[i][1]*2*pi).control(l,label=None)
qc.append(multirx,full)
elif(rotations[i][0]=='y'):
multiry = RYGate(rotations[i][1]*2*pi).control(l,label=None)
qc.append(multiry,full)
elif(rotations[i][0]=='z'):
multirz = RZGate(rotations[i][1]*2*pi).control(l,label=None)
qc.append(multirz,full)
qc.barrier()
for q in inverted:
qc.x(q)
qc.barrier()
return qc
### your code here
def test_function_3():
n = 8
rotations = [('x', 0.123), ('y', -0.912),('z',-0.12),('x', 0.5),('z',0.5),('y', -0.5),('z',0.5),('x', 0.5)]
qram = qram_rotations(n, rotations)
return qram
test_function_3().draw('mpl')
from grader.graders.problem_5.grader import grader3
grader3.evaluate(qram_rotations)
|
https://github.com/Hayatto9217/Qiskit7
|
Hayatto9217
|
from qiskit import QuantumCircuit
circ= QuantumCircuit(2,2)
circ.h(0)
circ.cx(0,1)
circ.measure(0,0)
circ.measure(1,1)
circ.draw('mpl')
from qiskit import pulse
from qiskit.pulse.library import Gaussian
from qiskit.providers.fake_provider import FakeValencia
backend = FakeValencia()
with pulse.build(backend, name='hadamard') as h_q0:
pulse.play(Gaussian(duration=128, amp=0.1, sigma=16),
pulse.drive_channel(0))
h_q0.draw()
circ.add_calibration('h',[0], h_q0)
from qiskit import transpile
from qiskit.providers.fake_provider import FakeHanoi
backend =FakeHanoi()
circ = transpile(circ, backend)
print(backend.configuration().basis_gates)
circ.draw('mpl', idle_wires=False)
from qiskit import QuantumCircuit
from qiskit.circuit import Gate
circ = QuantumCircuit(1,1)
custom_gate = Gate('my_custom_gate', 1, [3.14, 1])
circ.append(custom_gate, [0])
circ.measure(0,0)
circ.draw('mpl')
with pulse.build(backend, name='custom') as my_schedule:
pulse.play(Gaussian(duration=64, amp=0.2, sigma=8),
pulse.drive_channel(0))
circ.add_calibration('my_custom_gate', [0], my_schedule, [3.14, 1])
circ =transpile(circ, backend)
circ.draw('mpl', idle_wires=False)
circ = QuantumCircuit(2,2)
circ.append(custom_gate, [1])
from qiskit import QiskitError
try:
circ = transpile(circ, backend
|
https://github.com/Hayatto9217/Qiskit2
|
Hayatto9217
|
import matplotlib.pyplot as plt
import numpy as np
from math import pi
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, transpile
from qiskit.tools.visualization import circuit_drawer
from qiskit.quantum_info import state_fidelity
from qiskit import BasicAer
backend = BasicAer.get_backend('unitary_simulator')
q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.u(pi/2, pi/4,pi/8,q)
qc.draw()
job =backend.run(transpile(qc, backend))
job.result().get_unitary(qc, decimals=3)
#Pゲート
qc =QuantumCircuit(q)
qc.p(pi/2, q)
qc.draw()
job = backend.run(transpile(qc, backend))
job.result().get_unitary(qc, decimals=3)
#恒等ゲートId = p(0)
qc = QuantumCircuit(q)
qc.id(q)
qc.draw()
job =backend.run(transpile(qc, backend))
job.result().get_unitary(qc, decimals=3)
#パウリゲート
qc = QuantumCircuit(q)
qc.x(q)
qc.draw()
job = backend.run(transpile(qc, backend))
job.result().get_unitary(qc, decimals=3)
#ビットアンドフェーズフリップゲート
qc = QuantumCircuit(q)
qc.y(q)
qc.draw()
job =backend.run(transpile(qc, backend))
job.result().get_unitary(qc, decimals=3)
#S=√Zフェーズ
qc = QuantumCircuit(q)
qc.s(q)
qc.draw()
job = backend.run(transpile(qc, backend))
job.result().get_unitary(qc, decimals=3)
#H アダマールゲート
qc = QuantumCircuit(q)
qc.h(q)
qc.draw()
job = backend.run(transpile(qc, backend))
job.result().get_unitary(qc, decimals=3)
#S転置共役
qc = QuantumCircuit(q)
qc.sdg(q)
qc.draw()
job = backend.run(transpile(qc, backend))
job.result().get_unitary(qc, decimals=3)
qc = QuantumCircuit(q)
qc.t(q)
qc.draw()
job =backend.run(transpile(qc,backend))
job.result().get_unitary(qc, decimals=3)
#標準回転
qc = QuantumCircuit(q)
qc.rx(pi/2, q)
qc.draw()
job = backend.run(transpile(qc, backend))
job.result().get_unitary(qc, decimals=3)
#Y軸まわりの回転
qc = QuantumCircuit(q)
qc.ry(pi/2, q)
qc.draw()
job = backend.run(transpile(qc, backend))
job.result().get_unitary(qc, decimals=3)
#Zまわりの回転
qc= QuantumCircuit(q)
qc.rz(pi/2,q)
qc.draw()
job = backend.run(transpile(qc, backend))
job.result().get_unitary(qc, decimals=3)
#2量子ビット場合
q= QuantumRegister(2)
#制御パウリゲート
qc = QuantumCircuit(q)
qc.cx(q[0],q[1])
qc.draw()
job = backend.run(transpile(qc, backend))
job.result().get_unitary(qc, decimals=3)
#制御Ｙゲート
qc = QuantumCircuit(q)
qc.cy(q[0],q[1])
qc.draw()
job = backend.run(transpile(qc, backend))
job.result().get_unitary(qc, decimals=3)
#制御Ｚゲート
qc = QuantumCircuit(q)
qc.cz(q[0],q[1])
qc.draw()
job = backend.run(transpile(qc, backend))
job.result().get_unitary(qc, decimals=3)
#制御回転ゲート
qc = QuantumCircuit(q)
qc.crz(pi/2,q[0],q[1])
qc.draw()
job = backend.run(transpile(qc, backend))
job.result().get_unitary(qc, decimals=3)
#制御位相回転
qc = QuantumCircuit(q)
qc.cp(pi/2,q[0],q[1])
qc.draw()
job = backend.run(transpile(qc, backend))
job.result().get_unitary(qc, decimals=3)
#制御u回転
qc = QuantumCircuit(q)
qc.cu(pi/2,pi/2,pi/2,0,q[0],q[1])
qc.draw()
job = backend.run(transpile(qc, backend))
job.result().get_unitary(qc, decimals=3)
#SWAPGETA
qc = QuantumCircuit(q)
qc.swap(q[0],[1])
qc.draw()
job = backend.run(transpile(qc, backend))
job.result().get_unitary(qc, decimals=3)
q = QuantumRegister(3)
#ToffoliゲートCXXゲート
qc = QuantumCircuit(q)
qc.ccx(q[0],q[1],q[2])
qc.draw()
job = backend.run(transpile(qc, backend))
job.result().get_unitary(qc, decimals=3)
#CSWAPゲート
qc = QuantumCircuit(q)
qc.cswap(q[0],q[1],q[2])
qc.draw()
job = backend.run(transpile(qc, backend))
job.result().get_unitary(qc, decimals=3)
#非ユニタリ操作
q = QuantumRegister(1)
c = ClassicalRegister(1)
qc = QuantumCircuit(q, c)
qc.measure(q,c)
qc.draw()
backend =BasicAer.get_backend('qasm_simulator')
job = backend.run(transpile(qc,backend))
job.result().get_counts(qc)
qc = QuantumCircuit(q,c)
qc.h(q)
qc.measure(q,c)
qc.draw()
job = backend.run(transpile(qc,backend))
job.result().get_counts(qc)
#reset
qc = QuantumCircuit(q,c)
qc.h(q)
qc.reset(q[0])
qc.measure(q,c)
qc.draw()
job = backend.run(transpile(qc, backend))
job.result().get_counts(qc)
qc = QuantumCircuit(q,c)
qc.h(q)
qc.measure(q,c)
qc.x(q[0]).c_if(c,0)
qc.measure(q, c)
qc.draw()
import math
desired_vector = [
1 / math.sqrt(16) * complex(0, 1),
1 / math.sqrt(8) * complex(1, 0),
1 / math.sqrt(16) * complex(1, 1),
0,
0,
1 / math.sqrt(8) * complex(1, 2),
1 / math.sqrt(16) * complex(1, 0),
0]
q = QuantumRegister(3)
qc = QuantumCircuit(q)
qc.initialize(desired_vector, [q[0],q[1],q[2]])
qc.draw()
backend = BasicAer.get_backend('statevector_simulator')
job =backend.run(transpile(qc, backend))
qc_state = job.result().get_statevector(qc)
qc_state
state_fidelity(desired_vector, qc_state)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/Hayatto9217/Qiskit6
|
Hayatto9217
|
from qiskit import QuantumCircuit
from qiskit.compiler import transpile
from qiskit.transpiler import PassManager
circ = QuantumCircuit(3)
circ.ccx(0, 1, 2)
circ.draw(output='mpl')
from qiskit.transpiler.passes import Unroller
pass_ = Unroller(['u1', 'u2', 'u3', 'cx'])
pm = PassManager(pass_)
new_circ = pm.run(circ)
new_circ.draw(output='mpl')
#同じパスの異なる実装
from qiskit.transpiler import CouplingMap, Layout
from qiskit.transpiler.passes import BasicSwap, LookaheadSwap, StochasticSwap
coupling = [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6]]
circuit = QuantumCircuit(7)
circuit.h(3)
circuit.cx(0, 6)
circuit.cx(6, 0)
circuit.cx(0, 1)
circuit.cx(3, 1)
circuit.cx(3, 0)
coupling_map = CouplingMap(couplinglist=coupling)
bs = BasicSwap(coupling_map=coupling_map)
pass_manager = PassManager(bs)
basic_circ = pass_manager.run(circuit)
ls = LookaheadSwap(coupling_map=coupling_map)
pass_manager = PassManager(ls)
lookahead_circ = pass_manager.run(circuit)
ss = StochasticSwap(coupling_map=coupling_map)
pass_manager = PassManager(ss)
stochastic_circ = pass_manager.run(circuit)
circuit.draw(output='mpl')
lookahead_circ.draw(output='mpl')
stochastic_circ.draw(output='mpl')
basic_circ.draw(output='mpl')
#プリセット パスマネージャー
import math
from qiskit.providers.fake_provider import FakeTokyo
backend=FakeTokyo()
qc = QuantumCircuit(10)
random_state = [
1 / math.sqrt(4) * complex(0,1),
1 / math.sqrt(8) * complex(1,0),
0,
0,
0,
0,
0,
0,
1 / math.sqrt(8) * complex(1,0),
1 / math.sqrt(8) * complex(0,1),
0,
0,
0,
0,
1 / math.sqrt(4) * complex(1,0),
1 / math.sqrt(8) * complex(1,0)]
qc.initialize(random_state, range(4))
qc.draw()
#異なる最適化
optimized_0 =transpile(qc, backend=backend, seed_transpiler=11, optimization_level=0)
print('gates = ', optimized_0.count_ops())
print('depth = ', optimized_0.depth())
optimized_1 = transpile(qc, backend=backend, seed_transpiler=11, optimization_level=1)
print('gates = ', optimized_1.count_ops())
print('depth = ', optimized_1.depth())
optimized_2 =transpile(qc, backend=backend,seed_transpiler=11, optimization_level=2)
print('gates =', optimized_2.count_ops())
print('depth =', optimized_2.depth())
optimized_3 =transpile(qc, backend=backend, seed_transpiler=11, optimization_level=3)
print('gates =', optimized_3.count_ops())
print('depth =', optimized_3.depth())
#有向非巡回グラフ
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.dagcircuit import DAGCircuit
q = QuantumRegister(3, 'q')
c = ClassicalRegister(3, 'c')
circ = QuantumCircuit(q,c)
circ.h(q[0])
circ.cx(q[0], q[1])
circ.measure(q[0],c[0])
circ.rz(0.5, q[1]).c_if(c,2)
circ.draw(output='mpl')
|
https://github.com/adamg0709/QiskitFun
|
adamg0709
|
import numpy as np
from numpy import pi
# importing Qiskit
from qiskit import QuantumCircuit, transpile, assemble, Aer, IBMQ
from qiskit.providers.ibmq import least_busy
from qiskit.tools.monitor import job_monitor
from qiskit.visualization import plot_histogram, plot_bloch_multivector
# Qiskit's way of implementing QFT:
def qft_rotations(circuit, n):
"""Performs qft on the first n qubits in circuit (without swaps)"""
if n == 0:
return circuit
n -= 1
circuit.h(n)
for qubit in range(n):
circuit.cp(pi/2**(n-qubit), qubit, n)
# At the end of our function, we call the same function again on
# the next qubits (we reduced n by one earlier in the function)
qft_rotations(circuit, n)
def swap_registers(circuit, n):
for qubit in range(n//2):
circuit.swap(qubit, n-qubit-1)
return circuit
def qft(circuit, n):
"""QFT on the first n qubits in circuit"""
qft_rotations(circuit, n)
swap_registers(circuit, n)
return circuit
# See network archetechture for 4 qubits. There's a clear pattern with the Hadamard gates and CROT gates.
qc = QuantumCircuit(4)
qc = qft(qc,4)
qc.draw()
# My way, which doesn't use recursion:
def qft_new(circuit, n):
for qubit in range(n):
idx = n-qubit-1
circuit.h(idx)
for i in range(idx):
circuit.cp(pi/2**(idx-i), i, idx)
for j in range(n//2):
circuit.swap(j, n-j-1)
return circuit
# Outputs the same circuit for 4 qubits as the original way.
qc = QuantumCircuit(4)
qc = qft_new(qc,4)
qc.draw()
# Inverse QFT can be be found by simply using the .inverse() method:
qft_circ = qft_new(QuantumCircuit(4), 4)
inv = qft_circ.inverse()
inv.draw()
# The following example was given in the textbook:
qc = QuantumCircuit(3)
# Encode the state |1,0,1>
qc.x(0)
qc.x(2)
sim = Aer.get_backend("aer_simulator")
qc_init = qc.copy()
qc_init.save_statevector()
statevector = sim.run(qc_init).result().get_statevector()
plot_bloch_multivector(statevector)
# Perform QFT, then see the transformed states
qft_new(qc,3)
qc.save_statevector()
statevector = sim.run(qc).result().get_statevector()
plot_bloch_multivector(statevector)
# New example
qc_new = QuantumCircuit(2)
# Encode a custom entangled state
qc_new.initialize([0,1/(2**0.5),0,-1/(2**0.5)])
qc_init = qc_new.copy()
qc_init.save_statevector()
statevector = sim.run(qc_init).result().get_statevector()
plot_bloch_multivector(statevector)
# Note: Bloch sphere images might not provide any insight into encoded state since the two qubits are entangled
# Perform QFT
qc_transformed = qft_new(qc_new,2)
qc_final = qc_transformed.copy()
qc_final.save_statevector()
statevector = sim.run(qc_final).result().get_statevector()
plot_bloch_multivector(statevector)
# Note: once again, Bloch sphere images might not provide any insight
|
https://github.com/QuantumComputingKorea/QiskitRuntime
|
QuantumComputingKorea
|
from IPython.display import Image
Image("runtime.png")
from IPython.display import HTML
HTML('<iframe width="560" height="315" src="https://www.youtube.com/embed/1kRfHNUbkrg?rel=0&controls=0&showinfo=0" frameborder="0" allowfullscreen></iframe>')
#!pip install 'qiskit[all]'
#!pip install qiskit-ibm-runtime
#!pip install matplotlib
#!pip install pylatexenc
from qiskit_ibm_runtime import IBMRuntimeService
# Save account on disk. if you need to overwrite the account info, please add overwrite=True)
IBMRuntimeService.save_account(auth="cloud", token="Your Token", instance="your_crn", overwrite=True)
service = IBMRuntimeService()
service.pprint_programs()
service.backends()
from qiskit.test.reference_circuits import ReferenceCircuits
program_inputs = {'iterations': 1}
options = {"backend_name": "ibmq_qasm_simulator"}
job = service.run(program_id="hello-world",
#options=options,
inputs=program_inputs
)
print(f"job id: {job.job_id}")
result = job.result()
print(result)
from qiskit import QuantumCircuit
N = 10
qc = QuantumCircuit(N)
qc.h(0)
for kk in range(0, N -1):
qc.cx(kk, kk + 1)
qc.measure_all()
qc.draw('mpl', fold=-1)
from qiskit import Aer, transpile
from qiskit.visualization import plot_histogram
simulator = Aer.get_backend('aer_simulator_statevector')
circ = transpile(qc, simulator)
job_statevector = simulator.run(circ, shots=20000)
counts_statevector = job_statevector.result().get_counts(0)
plot_histogram(counts_statevector)
from qiskit.test.mock import FakeMontreal
fake_backend = FakeMontreal()
from qiskit.tools.jupyter import *
fake_backend
job_noisy = fake_backend.run(circ, shots=20000)
counts_moisy = job_noisy.result().get_counts(0)
plot_histogram(counts_moisy)
service = IBMRuntimeService()
# Specify the program inputs here.
program_inputs = {
"circuits": qc,
"circuit_indices": [0],
# "shots":20000
}
# Specify the backend name.
job = service.run(
program_id="sampler",
inputs=program_inputs,
)
# Printing the job ID in case we need to retrieve it later.
print(f"Job ID: {job.job_id}")
# Get the job result - this is blocking and control may not return immediately.
result = job.result()
print(result)
plot_histogram(result.get('quasi_dists'))
# Specify the program inputs here.
program_inputs = {
"circuits": qc,
"circuit_indices": [0],
# "shots":2048
}
# Specify the backend name.
options = {"backend_name": "ibmq_qasm_simulator"}
job = service.run(
program_id="sampler",
options=options,
inputs=program_inputs,
)
# Printing the job ID in case we need to retrieve it later.
print(f"Job ID: {job.job_id}")
# Get the job result - this is blocking and control may not return immediately.
qasm_result = job.result()
print(qasm_result)
plot_histogram(qasm_result.get('quasi_dists'))
IBMRuntimeService.save_account(auth="cloud", token="your token", instance="your _ crn", overwrite=True)
service = IBMRuntimeService()
service.backends()
# Specify the program inputs here.
program_inputs = {
"circuits": qc,
"circuit_indices": [0],
# "shots":10000
}
# Specify the backend name.
options = {"backend_name": "ibm_algiers"}
job = service.run(
program_id="sampler",
options=options,
inputs=program_inputs,
)
# Printing the job ID in case we need to retrieve it later.
print(f"Job ID: {job.job_id}")
# Get the job result - this is blocking and control may not return immediately.
real_result = job.result()
print(real_result)
plot_histogram(real_result.get('quasi_dists'))
|
https://github.com/Tim-Li/Qiskit-NTU-hackathon-2022_QGEN
|
Tim-Li
|
import numpy as np
import matplotlib.pyplot as plt
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile, Aer, IBMQ
from qiskit.tools.jupyter import *
from qiskit.visualization import *
# from ibm_quantum_widgetsets import *
from qiskit.providers.aer import QasmSimulator
from qiskit.algorithms.optimizers import *
from qiskit.utils import algorithm_globals
from qiskit.circuit.library import TwoLocal
from qiskit_optimization.algorithms import MinimumEigenOptimizer
from qiskit.algorithms import VQE, QAOA, NumPyMinimumEigensolver
from qiskit.utils import QuantumInstance
from qiskit_optimization import QuadraticProgram
from qiskit.opflow import Z, I
from ibm_quantum_widgets import *
from qiskit.visualization import plot_histogram
# from qiskit.quantum_info.operators import Operator, Pauli
from qiskit.opflow import PauliExpectation, CVaRExpectation
from qiskit.circuit.library import RealAmplitudes
from qiskit_optimization.converters import LinearEqualityToPenalty
from qiskit_optimization.algorithms import GroverOptimizer, MinimumEigenOptimizer
# Loading your IBM Quantum account(s)
provider = IBMQ.load_account()
def output(result, prob_path, fval_path):
prob = {}
fval = {}
for i in range(len(result.samples)):
tmp = ""
count = 0
for num in range(8):
tmp += str(int(result.samples[i].x[num]))
count += int(result.samples[i].x[num])
prob[tmp] = result.samples[i].probability
fval[tmp] = result.samples[i].fval
np.save(prob_path, prob)
np.save(fval_path, fval)
def unnormalized_h(adj_mtx):
qubit_num = len(adj_mtx)
iden = I
for i in range(1,qubit_num):
iden = iden^I
op = iden-iden
# print(op)
for i in range(qubit_num):
for j in range(qubit_num):
if i > j:
# 2ZiZj
temp = np.ones(qubit_num)*I
temp[i] = Z
temp[j] = Z
op_0 = temp[0]
for k in range(1, qubit_num):
op_0 = op_0^temp[k]
print(op_0)
op = op + 2*op_0
# 0.5*I - 0.5*ZiZj
if adj_mtx[i][j] == 1:
op = op + (0.5*iden - 0.5 * op_0)
op = op + qubit_num * iden
return op
def normalized_h(adj_mtx,ratio):
qubit_num = len(adj_mtx)
iden = I
for i in range(1,qubit_num):
iden = iden^I
op = iden-iden
#print(op)
# for 1/m * 0.5*sum(I-zizj) term
first_term = iden-iden
m=0
# for zizj term
second_term = iden - iden
for i in range(qubit_num):
for j in range(qubit_num):
if i>j:
# 2ZiZj
temp = np.ones(qubit_num)*I
temp[i] = Z
temp[j] = Z
op_0 = temp[0]
for k in range(1,qubit_num):
op_0 = op_0^temp[k]
#print(op_0)
second_term = second_term + 2*op_0
# 0.5*I - 0.5*ZiZj
if adj_mtx[i][j] == 1:
first_term = first_term + 0.5*iden - 0.5 * op_0
m+=1
#unweighted_h = op + first_term + second_term + qubit_num * iden
k = ((ratio/qubit_num**2))
weighted_h = op + first_term/m + float(k)*(second_term + qubit_num * iden)
return weighted_h
def adjacency_matrix(graph):
matrix = []
for i in range(len(graph)):
matrix.append([0]*(len(graph)))
for j in graph[i]:
matrix[i][j] = 1
return matrix
lst = [[1,4,6],[0,2],[1,5,7],[4],[0,3,5],[2,4],[0],[2]]
adj_mtx = adjacency_matrix(lst)
op = unnormalized_h(adj_mtx)
# op.to_matrix_op() # See the operator with matrix form
qp = QuadraticProgram()
qp.from_ising(op)
print(qp)
# solving Quadratic Program using exact classical eigensolver
exact = MinimumEigenOptimizer(NumPyMinimumEigensolver())
result = exact.solve(qp)
print(result.prettyprint())
lst = [[1,4,6],[0,2],[1,5,7],[4],[0,3,5],[2,4],[0],[2]]
adj_mtx = adjacency_matrix(lst)
op = unnormalized_h(adj_mtx)
# op.to_matrix_op() # See the operator with matrix form
qp = QuadraticProgram()
qp.from_ising(op)
print(qp)
optimizer = SLSQP(maxiter=10000)
algorithm_globals.random_seed = 1234
seed = 11234
num = 8
backend = Aer.get_backend('statevector_simulator')
ry = TwoLocal(num, 'ry', 'cz', reps=4, entanglement='full')
quantum_instance = QuantumInstance(backend=backend, seed_simulator=seed, seed_transpiler=seed)
vqe = VQE(ry, optimizer=optimizer, quantum_instance=quantum_instance)
vqe_meo = MinimumEigenOptimizer(vqe)
result = vqe_meo.solve(qp)
print(result.samples)
for opt in range(4):
for it in range(1, 11):
if opt == 0:
optimizer = SLSQP(maxiter=1000)
elif opt == 1:
optimizer = COBYLA(maxiter=1000)
elif opt == 2:
optimizer = NELDER_MEAD(maxiter=1000)
elif opt == 3:
optimizer = POWELL(maxiter=1000)
algorithm_globals.random_seed = 1234
seed = 12345
backend = Aer.get_backend('statevector_simulator')
qNum = 8
ry = TwoLocal(qNum, 'ry', 'cz', reps=it, entanglement='full')
quantum_instance = QuantumInstance(backend=backend, seed_simulator=seed, seed_transpiler=seed)
vqe = VQE(ry, optimizer=optimizer, quantum_instance=quantum_instance)
vqe_meo = MinimumEigenOptimizer(vqe)
result = vqe_meo.solve(qp)
print(result)
# use dictionary form to output result
output(result, f"data/VQE/prob_all_opt{opt}_layer{it}.npy", f"data/VQE/fval_all_opt{opt}_layer{it}.npy")
classical_exp = 2
probability = np.zeros([4, 10])
cost = np.zeros([4, 10])
pdepth = np.arange(1, 11)
expectation = np.zeros([4, 10])
for opt in range(4):
for it in range(1, 11):
df = np.load(f"data/VQE/prob_all_opt{opt}_layer{it}.npy",allow_pickle='TRUE').item()
df2 = np.load(f"data/VQE/fval_all_opt{opt}_layer{it}.npy",allow_pickle='TRUE').item()
probability[opt, it-1] = df.get('10011010', 0)
probability[opt, it-1] += df.get('01100101', 0)
cost[opt, it-1] = df2.get('10011010', 0)
for key in df:
expectation[opt, it-1] += df[key] * df2[key]
alpha = (expectation - classical_exp) / np.abs(classical_exp)
plt.figure(figsize=(10,8))
for opt in range(4):
plt.plot(pdepth, probability[opt])
plt.legend(["SLSQP", "COBYLA", "NELDER_MEAD", "POWELL"])
plt.xlim(0.5, 10.5)
plt.ylim(0, 1)
plt.xticks(np.arange(1, 11), ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"], fontsize=18)
plt.title("VQE, Probability of Finding Right Answer\n (10011010 or 01100101)", fontsize=18)
plt.xlabel("p-depth", fontsize=18)
plt.ylabel("Probability", fontsize=18)
plt.grid("--")
plt.savefig(f"graph/VQE/prob.png", bbox_inches='tight',pad_inches = 0,dpi=300)
plt.close()
plt.figure(figsize=(10,8))
for opt in range(4):
plt.plot(pdepth, expectation[opt])
plt.legend(["SLSQP", "COBYLA", "NELDER_MEAD", "POWELL"])
plt.xlim(0.5, 10.5)
plt.ylim(2, 8)
plt.xticks(np.arange(1, 11), ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"], fontsize=18)
plt.title("VQE, Expectation of Cost Function\n (Right Answer: 2)", fontsize=18)
plt.xlabel("p-depth", fontsize=18)
plt.ylabel("Expectation Value", fontsize=18)
plt.grid("--")
plt.savefig(f"graph/VQE/expect.png", bbox_inches='tight',pad_inches = 0,dpi=300)
plt.close()
plt.figure(figsize=(15,8))
for opt in range(4):
plt.plot(pdepth, alpha[opt])
plt.legend(["SLSQP", "COBYLA", "ADAM", "CG", "Gradient descent"])
plt.xlim(0.5, 10.5)
plt.ylim(0, 5)
plt.xticks(np.arange(1, 11), ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"], fontsize=18)
plt.title(r"VQE, $\frac{expectation - classical\ expectation}{|classical\ expectation|}$", fontsize=18)
plt.xlabel("p-depth", fontsize=18)
plt.ylabel("Error rate", fontsize=18)
plt.grid("--")
plt.savefig(f"graph/VQE/alpha.png", bbox_inches='tight',pad_inches = 0,dpi=300)
plt.show()
plt.close()
dd = np.load(f"data/QAOA/prob_all_opt0_layer1.npy",allow_pickle='TRUE').item()
new_ans = {}
x = []
for key in dd:
tmp = 0
for i in range(8):
tmp += int(key[i])
if tmp == 4:
x.append(key)
for it in range(1,11):
df = np.load(f"data/VQE/prob_all_opt0_layer{it}.npy",allow_pickle='TRUE').item()
df2 = np.load(f"data/VQE/prob_all_opt1_layer{it}.npy",allow_pickle='TRUE').item()
df3 = np.load(f"data/VQE/prob_all_opt2_layer{it}.npy",allow_pickle='TRUE').item()
df4 = np.load(f"data/VQE/prob_all_opt3_layer{it}.npy",allow_pickle='TRUE').item()
y = np.zeros(len(x))
y2 = np.zeros(len(x))
y3 = np.zeros(len(x))
y4 = np.zeros(len(x))
for i in range(len(x)):
y[i] = float(df.get(x[i], 0.))
y2[i] = float(df2.get(x[i], 0.))
y3[i] = float(df3.get(x[i], 0.))
y4[i] = float(df4.get(x[i], 0.))
wid = 0.5
X = np.linspace(0, 150, len(x))
plt.figure(figsize=(25, 8))
plt.xlim(-2, 155)
# plt.ylim(0, 1)
plt.title(f"VQE, Reps={it}", fontsize=16)
plt.bar(X, y, width=wid, color='r')
plt.bar(X+0.5, y2, width=wid, color='b')
plt.bar(X+1, y3, width=wid, color='k')
plt.bar(X+1.5, y4, width=wid, color='g')
plt.legend(labels=["SLSQP", "COBYLA", "NELDER_MEAD", "POWELL"])
plt.xticks(X, x)
plt.ylabel("Probabilities", fontsize=16)
plt.xticks(rotation=90, fontsize=16)
plt.savefig(f"graph/VQE/few_{it}.png", bbox_inches='tight',pad_inches = 0,dpi=200)
plt.show()
plt.close()
lst = [[1,4,6],[0,2],[1,5,7],[4],[0,3,5],[2,4],[0],[2]]
adj_mtx = adjacency_matrix(lst)
op_w = normalized_h(adj_mtx, 1)
# op.to_matrix_op() # See the operator with matrix form
qp_w = QuadraticProgram()
qp_w.from_ising(op_w)
print(qp_w)
optimizer = SLSQP(maxiter=10000)
algorithm_globals.random_seed = 1234
seed = 11234
num = 8
backend = Aer.get_backend('statevector_simulator')
ry = TwoLocal(num, 'ry', 'cz', reps=4, entanglement='full')
quantum_instance = QuantumInstance(backend=backend, seed_simulator=seed, seed_transpiler=seed)
vqe = VQE(ry, optimizer=optimizer, quantum_instance=quantum_instance)
vqe_meo = MinimumEigenOptimizer(vqe)
result = vqe_meo.solve(qp_w)
print(result.samples)
# VQE data
ratio_arr = np.linspace(0.2,2,5)
for opt in range(2):
for it in range(1, 11):
for ratio_idx in range(len(ratio_arr)):
if opt == 0:
optimizer = SLSQP(maxiter=1000)
elif opt == 1:
optimizer = COBYLA(maxiter=1000)
#elif opt == 2:
#optimizer = NELDER_MEAD(maxiter=1000)
#elif opt == 3:
# optimizer = POWELL(maxiter=1000)
algorithm_globals.random_seed = 1234
seed = 12345
backend = Aer.get_backend('statevector_simulator')
qNum = 8
ry = TwoLocal(qNum, 'ry', 'cz', reps=it, entanglement='full')
quantum_instance = QuantumInstance(backend=backend, seed_simulator=seed, seed_transpiler=seed)
vqe = VQE(ry, optimizer=optimizer, quantum_instance=quantum_instance)
vqe_meo = MinimumEigenOptimizer(vqe)
ratio = ratio_arr[ratio_idx]
op_w = normalized_h(adj_mtx, ratio)
qp = QuadraticProgram()
qp.from_ising(op_w)
result = vqe_meo.solve(qp)
print(result)
output(result, f"data_normalized/VQE/prob_all_opt{opt}_layer{it}_ratio{ratio}.npy", f"data_normalized/VQE/fval_all_opt{opt}_layer{it}_ratio{ratio}.npy")
classical_exp = np.load("data/normalized/classical_exp_arr.npy")
classical_exp_arr = np.zeros([50])
for i in range(5):
classical_exp_arr[10*i:10*(i+1)] = classical_exp[i]
print(classical_exp_arr)
df = np.load(f"data/normalized/VQE/prob_all_opt{0}_layer{1}_ratio{0.2}.npy",allow_pickle='TRUE').item()
classical_exp = np.load("data/normalized/classical_exp_arr.npy")
probability = np.zeros([4, 10])
cost = np.zeros([4, 10])
pdepth = np.arange(1, 11)
expectation = np.zeros([4, 10])
ratMax = [0.2, 0.65, 1.1, 1.55, 2.0]
output_prob = np.zeros([50, 3])
output_expectation = np.zeros([50, 3])
output_error_rate = np.zeros([50, 3])
count = 0
for opt in range(0, 2):
for it in range(1, 11):
for ra in ratMax:
df = np.load(f"data/normalized/VQE/prob_all_opt{opt}_layer{it}_ratio{ra}.npy",allow_pickle='TRUE').item()
df2 = np.load(f"data/normalized/VQE/fval_all_opt{opt}_layer{it}_ratio{ra}.npy",allow_pickle='TRUE').item()
output_prob[count, 0] = output_expectation[count, 0] = output_error_rate[count, 0] = it
output_prob[count, 1] = output_expectation[count, 1] = output_error_rate[count, 1] = ra
output_prob[count, 2] = df.get('10011010', 0) + df.get('01100101', 0)
for key in df:
output_expectation[count, 2] += df[key] * df2[key]
count += 1
for i in range(50):
output_error_rate[i, 2] = (output_expectation[i, 2] - classical_exp_arr[i]) / np.abs(classical_exp_arr[i])
if opt == 0:
np.savetxt("data/normalized/VQE_output/probability.csv", output_prob, delimiter=",")
np.savetxt("data/normalized/VQE_output/expectation.csv", output_expectation, delimiter=",")
np.savetxt("data/normalized/VQE_output/error_rate.csv", output_error_rate, delimiter=",")
np.save("data/normalized/VQE_output_reprocessed/probability.npy", output_prob)
np.save("data/normalized/VQE_output_reprocessed/expectation.npy", output_expectation)
np.save("data/normalized/VQE_output_reprocessed/error_rate.npy", output_error_rate)
if opt == 1:
np.savetxt("data/normalized/VQE_output/probability_2.csv", output_prob, delimiter=",")
np.savetxt("data/normalized/VQE_output/expectation_2.csv", output_expectation, delimiter=",")
np.savetxt("data/normalized/VQE_output/error_rate_2.csv", output_error_rate, delimiter=",")
np.save("data/normalized/VQE_output_reprocessed/probability_2.npy", output_prob)
np.save("data/normalized/VQE_output_reprocessed/expectation_2.npy", output_expectation)
np.save("data/normalized/VQE_output_reprocessed/error_rate_2.npy", output_error_rate)
lst = [[1,4,6],[0,2],[1,5,7],[4],[0,3,5],[2,4],[0],[2]]
adj_mtx = adjacency_matrix(lst)
op = unnormalized_h(adj_mtx)
# op.to_matrix_op() # See the operator with matrix form
qp = QuadraticProgram()
qp.from_ising(op)
print(qp)
optimizer = SLSQP(maxiter=10000)
algorithm_globals.random_seed = 1234
seed = 11234
backend = Aer.get_backend('statevector_simulator')
quantum_instance = QuantumInstance(backend=backend, seed_simulator=seed, seed_transpiler=seed)
qaoa = QAOA(optimizer=optimizer, reps=3, quantum_instance=quantum_instance)
meo = MinimumEigenOptimizer(qaoa)
qaoa_meo = MinimumEigenOptimizer(qaoa)
result = qaoa_meo.solve(qp)
print(result.samples)
for opt in range(4):
for it in range(1, 11):
if opt == 0:
optimizer = SLSQP(maxiter=1000)
elif opt == 1:
optimizer = COBYLA(maxiter=1000)
elif opt == 2:
optimizer = NELDER_MEAD(maxiter=1000)
elif opt == 3:
optimizer = POWELL(maxiter=1000)
algorithm_globals.random_seed = 1234
seed = 12345
backend = Aer.get_backend('statevector_simulator')
qNum = 8
qaoa = QAOA(optimizer=optimizer, reps=3, quantum_instance=quantum_instance)
meo = MinimumEigenOptimizer(qaoa)
qaoa_meo = MinimumEigenOptimizer(qaoa)
result = qaoa_meo.solve(qp)
print(result)
output(result, f"data/QAOA/prob_all_opt{opt}_layer{it}.npy", f"data/QAOA/fval_all_opt{opt}_layer{it}.npy")
classical_exp = 2
probability = np.zeros([4, 10])
cost = np.zeros([4, 10])
pdepth = np.arange(1, 11)
expectation = np.zeros([4, 10])
for opt in range(4):
for it in range(1, 11):
df = np.load(f"data/QAOA/prob_all_opt{opt}_layer{it}.npy",allow_pickle='TRUE').item()
df2 = np.load(f"data/QAOA/fval_all_opt{opt}_layer{it}.npy",allow_pickle='TRUE').item()
probability[opt, it-1] = df.get('10011010', 0)
probability[opt, it-1] += df.get('01100101', 0)
cost[opt, it-1] = df2.get('10011010', 0)
for key in df:
expectation[opt, it-1] += df[key] * df2[key]
alpha = (expectation - classical_exp) / np.abs(classical_exp)
plt.figure(figsize=(10,8))
for opt in range(4):
plt.plot(pdepth, probability[opt])
plt.legend(["SLSQP", "COBYLA", "NELDER_MEAD", "POWELL"])
plt.xlim(0.5, 10.5)
plt.ylim(0, 1)
plt.xticks(np.arange(1, 11), ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"], fontsize=18)
plt.title("QAOA, Probability of Finding Right Answer\n (10011010 or 01100101)", fontsize=18)
plt.xlabel("p-depth", fontsize=18)
plt.ylabel("Probability", fontsize=18)
plt.grid("--")
plt.savefig(f"graph/QAOA/prob.png", bbox_inches='tight',pad_inches = 0,dpi=300)
plt.close()
plt.figure(figsize=(10,8))
for opt in range(4):
plt.plot(pdepth, expectation[opt])
plt.legend(["SLSQP", "COBYLA", "NELDER_MEAD", "POWELL"])
plt.xlim(0.5, 10.5)
# plt.ylim(2, 8)
plt.xticks(np.arange(1, 11), ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"], fontsize=18)
plt.title("QAOA, Expectation of Cost Function\n (Right Answer: 2)", fontsize=18)
plt.xlabel("p-depth", fontsize=18)
plt.ylabel("Expectation Value", fontsize=18)
plt.grid("--")
plt.savefig(f"graph/QAOA/expect.png", bbox_inches='tight',pad_inches = 0,dpi=300)
plt.close()
plt.figure(figsize=(15,8))
for opt in range(4):
plt.plot(pdepth, alpha[opt])
plt.legend(["SLSQP", "COBYLA", "NELDER_MEAD", "POWELL"])
plt.xlim(0.5, 10.5)
plt.ylim(0, 5)
plt.xticks(np.arange(1, 11), ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"], fontsize=18)
plt.title(r"QAOA, $\frac{expectation - classical\ expectation}{|classical\ expectation|}$", fontsize=18)
plt.xlabel("p-depth", fontsize=18)
plt.ylabel("Error rate", fontsize=18)
plt.grid("--")
plt.savefig(f"graph/QAOA/alpha.png", bbox_inches='tight',pad_inches = 0,dpi=300)
plt.show()
plt.close()
lst = [[1,4,6],[0,2],[1,5,7],[4],[0,3,5],[2,4],[0],[2]]
adj_mtx = adjacency_matrix(lst)
op_w = normalized_h(adj_mtx, 1)
# op.to_matrix_op() # See the operator with matrix form
qp_w = QuadraticProgram()
qp_w.from_ising(op_w)
print(qp_w)
optimizer = SLSQP(maxiter=10000)
algorithm_globals.random_seed = 1234
seed = 11234
backend = Aer.get_backend('statevector_simulator')
quantum_instance = QuantumInstance(backend=backend, seed_simulator=seed, seed_transpiler=seed)
qaoa = QAOA(optimizer=optimizer, reps=3, quantum_instance=quantum_instance)
meo = MinimumEigenOptimizer(qaoa)
qaoa_meo = MinimumEigenOptimizer(qaoa)
result = qaoa_meo.solve(qp_w)
print(result.samples)
x = []
prob = np.zeros([4, 10])
func = np.zeros([4, 10])
ratio_arr = np.linspace(0.2,2,5)
for opt in range(2):
for it in range(1, 11):
for ratio_idx in range(len(ratio_arr)):
if opt == 0:
optimizer = SLSQP(maxiter=1000)
elif opt == 1:
optimizer = COBYLA(maxiter=1000)
# if opt == 2:
# optimizer = NELDER_MEAD(maxiter=1000)
# elif opt == 3:
# optimizer = POWELL(maxiter=1000)
algorithm_globals.random_seed = 1234
seed = 12345
backend = Aer.get_backend('statevector_simulator')
qNum = 8
quantum_instance = QuantumInstance(backend=backend, seed_simulator=seed, seed_transpiler=seed)
qaoa = QAOA(optimizer=optimizer, reps=it, quantum_instance=quantum_instance)
meo = MinimumEigenOptimizer(qaoa)
qaoa_meo = MinimumEigenOptimizer(qaoa)
#prepare qp
ratio = ratio_arr[ratio_idx]
op_w = normalized_h(adj_mtx, ratio)
qp = QuadraticProgram()
qp.from_ising(op_w)
result = qaoa_meo.solve(qp)
print(result)
output(result, f"data_normalized/QAOA/prob_all_opt{opt}_layer{it}_ratio{ratio}.npy", f"data_normalized/QAOA/fval_all_opt{opt}_layer{it}_ratio{ratio}.npy")
df = np.load(f"data/normalized/QAOA/prob_all_opt{0}_layer{1}_ratio{0.2}.npy",allow_pickle='TRUE').item()
classical_exp = np.load("data/normalized/classical_exp_arr.npy")
probability = np.zeros([4, 10])
cost = np.zeros([4, 10])
pdepth = np.arange(1, 11)
expectation = np.zeros([4, 10])
ratMax = [0.2, 0.65, 1.1, 1.55, 2.0]
output_prob = np.zeros([50, 3])
output_expectation = np.zeros([50, 3])
output_error_rate = np.zeros([50, 3])
count = 0
for opt in range(0, 1):
for it in range(1, 11):
for ra in ratMax:
df = np.load(f"data/normalized/QAOA/prob_all_opt{opt}_layer{it}_ratio{ra}.npy",allow_pickle='TRUE').item()
df2 = np.load(f"data/normalized/QAOA/fval_all_opt{opt}_layer{it}_ratio{ra}.npy",allow_pickle='TRUE').item()
output_prob[count, 0] = output_expectation[count, 0] = output_error_rate[count, 0] = it
output_prob[count, 1] = output_expectation[count, 1] = output_error_rate[count, 1] = ra
output_prob[count, 2] = df.get('10011010', 0) + df.get('01100101', 0)
for key in df:
output_expectation[count, 2] += df[key] * df2[key]
count += 1
for i in range(50):
output_error_rate[i, 2] = (output_expectation[i, 2] - classical_exp_arr[i]) / np.abs(classical_exp_arr[i])
if opt == 0:
np.savetxt("data/normalized/QAOA_output/probability.csv", output_prob, delimiter=",")
np.savetxt("data/normalized/QAOA_output/expectation.csv", output_expectation, delimiter=",")
np.savetxt("data/normalized/QAOA_output/error_rate.csv", output_error_rate, delimiter=",")
np.save("data/normalized/QAOA_output_reprocessed/probability.npy", output_prob)
np.save("data/normalized/QAOA_output_reprocessed/expectation.npy", output_expectation)
np.save("data/normalized/QAOA_output_reprocessed/error_rate.npy", output_error_rate)
if opt == 1:
np.savetxt("data/normalized/QAOA_output/probability_2.csv", output_prob, delimiter=",")
np.savetxt("data/normalized/QAOA_output/expectation_2.csv", output_expectation, delimiter=",")
np.savetxt("data/normalized/QAOA_output/error_rate_2.csv", output_error_rate, delimiter=",")
np.save("data/normalized/QAOA_output_reprocessed/probability_2.npy", output_prob)
np.save("data/normalized/QAOA_output_reprocessed/expectation_2.npy", output_expectation)
np.save("data/normalized/QAOA_output_reprocessed/error_rate_2.npy", output_error_rate)
iter_arr = np.linspace(1,8,8)
ratio_arr = np.linspace(0.2,2,5)
op = operator_from_adjacency_matrix(adj_mtx)
for iter_idx in range(len(iter_arr)):
iter_num = iter_arr[iter_idx]
qp = QuadraticProgram()
qp.from_ising(op)
backend = Aer.get_backend('statevector_simulator')
grover_optimizer = GroverOptimizer(8, num_iterations=iter_num, quantum_instance=backend)
result = grover_optimizer.solve(qp)
print(result.prettyprint())
output(result, f"data/GROVER/prob_iter{iter_num}.npy", f"data/GROVER/fval_iter{iter_num}.npy")
plt.figure(figsize=(15,8))
legend_arr = []
for i in range(len(ratio_arr)):
legend_arr.append("ratio = "+str(ratio_arr[i]))
plt.plot(iter_arr, alpha[i])
legend_arr.append("Unnormalized")
plt.plot(iter_arr,unnormalized_alpha)
xticks_arr = []
for i in range(len(iter_arr)):
xticks_arr.append(str(iter_arr[i]))
plt.legend(legend_arr)
plt.xlim(0.5, 8.5)
plt.xticks(iter_arr, xticks_arr, fontsize=18)
plt.title(r"GROVER, $\frac{expectation - classical\ expectation}{|classical\ expectation|}$", fontsize=18)
plt.xlabel("Number of iteration", fontsize=18)
plt.ylabel("Error rate", fontsize=18)
plt.grid("--")
plt.savefig(f"graph/GROVER/NORMALIZED/error_rate.png", bbox_inches='tight',pad_inches = 0,dpi=300)
plt.show()
normalized_error_rate = np.load("data/normalized/VQE_output_reprocessed/error_rate.npy")
# df = pd.read_csv('data/normalized/VQE_output/probability.csv', sep=',',header=None)
x = np.arange(1, 11)
y = np.zeros([5, 10])
ratio_arr = np.linspace(0.2,2,5)
# print(normalized_error_rate)
normalized_error_rate = normalized_error_rate[:, 2:]
for i in range(5):
y[i] = normalized_error_rate[i::5].T
classical_exp = 2
probability = np.zeros([4, 10])
cost = np.zeros([4, 10])
pdepth = np.arange(1, 11)
expectation = np.zeros([4, 10])
for opt in range(4):
for it in range(1, 11):
df = np.load(f"data/VQE/prob_all_opt{opt}_layer{it}.npy",allow_pickle='TRUE').item()
df2 = np.load(f"data/VQE/fval_all_opt{opt}_layer{it}.npy",allow_pickle='TRUE').item()
probability[opt, it-1] = df.get('10011010', 0)
probability[opt, it-1] += df.get('01100101', 0)
cost[opt, it-1] = df2.get('10011010', 0)
for key in df:
expectation[opt, it-1] += df[key] * df2[key]
alpha = (expectation - classical_exp) / np.abs(classical_exp)
plt.figure(figsize=(15,8))
for i in range(5):
plt.plot(x, y[i])
plt.plot(x, alpha[0])
plt.legend(["ratio = 0.2", "ratio = 0.65", "ratio = 1.1", "ratio = 1.55", "ratio = 2", "Unnormalized"])
plt.xlim(0.5, 10.5)
# plt.ylim(0, 5)
plt.xticks(np.arange(1, 11), ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"], fontsize=18)
plt.title(r"VQE with SLSQP, $\frac{expectation - classical\ expectation}{|classical\ expectation|}$", fontsize=18)
plt.xlabel("p-depth", fontsize=18)
plt.ylabel("Error rate", fontsize=18)
plt.grid("--")
plt.savefig(f"graph/VQE_compare.png", bbox_inches='tight',pad_inches = 0,dpi=300)
plt.show()
plt.close()
normalized_error_rate = np.load("data/normalized/QAOA_output_reprocessed/error_rate.npy")
# df = pd.read_csv('data/normalized/VQE_output/probability.csv', sep=',',header=None)
x = np.arange(1, 11)
y = np.zeros([5, 10])
ratio_arr = np.linspace(0.2,2,5)
# print(normalized_error_rate)
normalized_error_rate = normalized_error_rate[:, 2:]
for i in range(5):
y[i] = normalized_error_rate[i::5].T
classical_exp = 2
probability = np.zeros([4, 10])
cost = np.zeros([4, 10])
pdepth = np.arange(1, 11)
expectation = np.zeros([4, 10])
for opt in range(4):
for it in range(1, 11):
df = np.load(f"data/QAOA/prob_all_opt{opt}_layer{it}.npy",allow_pickle='TRUE').item()
df2 = np.load(f"data/QAOA/fval_all_opt{opt}_layer{it}.npy",allow_pickle='TRUE').item()
probability[opt, it-1] = df.get('10011010', 0)
probability[opt, it-1] += df.get('01100101', 0)
cost[opt, it-1] = df2.get('10011010', 0)
for key in df:
expectation[opt, it-1] += df[key] * df2[key]
alpha = (expectation - classical_exp) / np.abs(classical_exp)
plt.figure(figsize=(15,8))
for i in range(5):
plt.plot(x, y[i])
plt.plot(x, alpha[0])
plt.legend(["ratio = 0.2", "ratio = 0.65", "ratio = 1.1", "ratio = 1.55", "ratio = 2", "Unnormalized"])
plt.xlim(0.5, 10.5)
# plt.ylim(0, 5)
plt.xticks(np.arange(1, 11), ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10"], fontsize=18)
plt.title(r"QAOA with SLSQP, $\frac{expectation - classical\ expectation}{|classical\ expectation|}$", fontsize=18)
plt.xlabel("p-depth", fontsize=18)
plt.ylabel("Error rate", fontsize=18)
plt.grid("--")
plt.savefig(f"graph/QAOA_compare.png", bbox_inches='tight',pad_inches = 0,dpi=300)
plt.show()
plt.close()
n = 8
penalty = 2 * n
linear2penalty = LinearEqualityToPenalty(penalty=penalty)
qp = linear2penalty.convert(qp)
_, offset = qp.to_ising()
# set classical optimizer
maxiter = 1000
optimizer = COBYLA(maxiter=maxiter)
# set variational ansatz
ansatz = RealAmplitudes(n, reps=1)
m = ansatz.num_parameters
# set backend
backend_name = "qasm_simulator" # use this for QASM simulator
# backend_name = 'aer_simulator_statevector' # use this for statevector simlator
backend = Aer.get_backend(backend_name)
# run variational optimization for different values of alpha
alphas = [1.0, 0.50, 0.25] # confidence levels to be evaluated
# dictionaries to store optimization progress and results
objectives = {alpha: [] for alpha in alphas} # set of tested objective functions w.r.t. alpha
results = {} # results of minimum eigensolver w.r.t alpha
# callback to store intermediate results
def callback(i, params, obj, stddev, alpha):
# we translate the objective from the internal Ising representation
# to the original optimization problem
objectives[alpha] += [-(obj + offset)]
for alpha in alphas:
# initialize CVaR_alpha objective
cvar_exp = CVaRExpectation(alpha, PauliExpectation())
cvar_exp.compute_variance = lambda x: [0] # to be fixed in PR #1373
# initialize VQE using CVaR
vqe = VQE(
expectation=cvar_exp,
optimizer=optimizer,
ansatz=ansatz,
quantum_instance=backend,
callback=lambda i, params, obj, stddev: callback(i, params, obj, stddev, alpha),
)
# initialize optimization algorithm based on CVaR-VQE
opt_alg = MinimumEigenOptimizer(vqe)
# solve problem
results[alpha] = opt_alg.solve(qp)
# print results
print("alpha = {}:".format(alpha))
print(results[alpha].prettyprint())
print()
|
https://github.com/jdellaverson19/qiskit2020
|
jdellaverson19
|
# -*- 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.
"""
The Bernstein-Vazirani algorithm.
"""
import logging
import operator
import numpy as np
from qiskit import ClassicalRegister, QuantumCircuit
from qiskit.aqua import AquaError, Pluggable, PluggableType, get_pluggable_class
from qiskit.aqua.algorithms import QuantumAlgorithm
from qiskit.aqua.utils import get_subsystem_density_matrix
logger = logging.getLogger(__name__)
class BernsteinVazirani(QuantumAlgorithm):
"""The Bernstein-Vazirani algorithm."""
CONFIGURATION = {
'name': 'BernsteinVazirani',
'description': 'Bernstein Vazirani',
'input_schema': {
'$schema': 'http://json-schema.org/schema#',
'id': 'bv_schema',
'type': 'object',
'properties': {
},
'additionalProperties': False
},
'problems': ['hiddenstringfinding'],
'depends': [
{
'pluggable_type': 'oracle',
'default': {
'name': 'TruthTableOracle',
},
},
],
}
def __init__(self, oracle):
self.validate(locals())
super().__init__()
self._oracle = oracle
self._circuit = None
self._ret = {}
@classmethod
def init_params(cls, params, algo_input):
if algo_input is not None:
raise AquaError("Input instance not supported.")
oracle_params = params.get(Pluggable.SECTION_KEY_ORACLE)
oracle = get_pluggable_class(
PluggableType.ORACLE,
oracle_params['name']).init_params(params)
return cls(oracle)
def construct_circuit(self, measurement=False):
"""
Construct the quantum circuit
Args:
measurement (bool): Boolean flag to indicate if measurement should be included in the circuit.
Returns:
the QuantumCircuit object for the constructed circuit
"""
if self._circuit is not None:
return self._circuit
qc_preoracle = QuantumCircuit(
self._oracle.variable_register,
self._oracle.output_register,
)
qc_preoracle.h(self._oracle.variable_register)
qc_preoracle.x(self._oracle.output_register)
qc_preoracle.h(self._oracle.output_register)
qc_preoracle.barrier()
# oracle circuit
qc_oracle = self._oracle.circuit
qc_oracle.barrier()
# postoracle circuit
qc_postoracle = QuantumCircuit(
self._oracle.variable_register,
self._oracle.output_register,
)
qc_postoracle.h(self._oracle.variable_register)
self._circuit = qc_preoracle + qc_oracle + qc_postoracle
# measurement circuit
if measurement:
measurement_cr = ClassicalRegister(len(self._oracle.variable_register), name='m')
self._circuit.add_register(measurement_cr)
self._circuit.measure(self._oracle.variable_register, measurement_cr)
return self._circuit
def _run(self):
if self._quantum_instance.is_statevector:
qc = self.construct_circuit(measurement=False)
result = self._quantum_instance.execute(qc)
complete_state_vec = result.get_statevector(qc)
variable_register_density_matrix = get_subsystem_density_matrix(
complete_state_vec,
range(len(self._oracle.variable_register), qc.width())
)
variable_register_density_matrix_diag = np.diag(variable_register_density_matrix)
max_amplitude = max(
variable_register_density_matrix_diag.min(),
variable_register_density_matrix_diag.max(),
key=abs
)
max_amplitude_idx = np.where(variable_register_density_matrix_diag == max_amplitude)[0][0]
top_measurement = np.binary_repr(max_amplitude_idx, len(self._oracle.variable_register))
else:
qc = self.construct_circuit(measurement=True)
measurement = self._quantum_instance.execute(qc).get_counts(qc)
self._ret['measurement'] = measurement
top_measurement = max(measurement.items(), key=operator.itemgetter(1))[0]
self._ret['result'] = top_measurement
return self._ret
|
https://github.com/jdellaverson19/qiskit2020
|
jdellaverson19
|
# -*- 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.
"""
The Deutsch-Jozsa algorithm.
"""
import logging
import operator
import numpy as np
from qiskit import ClassicalRegister, QuantumCircuit
from qiskit.aqua import AquaError, Pluggable, PluggableType, get_pluggable_class
from qiskit.aqua.algorithms import QuantumAlgorithm
from qiskit.aqua.utils import get_subsystem_density_matrix
logger = logging.getLogger(__name__)
class DeutschJozsa(QuantumAlgorithm):
"""The Deutsch-Jozsa algorithm."""
CONFIGURATION = {
'name': 'DeutschJozsa',
'description': 'Deutsch Jozsa',
'input_schema': {
'$schema': 'http://json-schema.org/schema#',
'id': 'dj_schema',
'type': 'object',
'properties': {
},
'additionalProperties': False
},
'problems': ['functionevaluation'],
'depends': [
{
'pluggable_type': 'oracle',
'default': {
'name': 'TruthTableOracle',
},
},
],
}
def __init__(self, oracle):
self.validate(locals())
super().__init__()
self._oracle = oracle
self._circuit = None
self._ret = {}
@classmethod
def init_params(cls, params, algo_input):
if algo_input is not None:
raise AquaError("Input instance not supported.")
oracle_params = params.get(Pluggable.SECTION_KEY_ORACLE)
oracle = get_pluggable_class(
PluggableType.ORACLE,
oracle_params['name']).init_params(params)
return cls(oracle)
def construct_circuit(self, measurement=False):
"""
Construct the quantum circuit
Args:
measurement (bool): Boolean flag to indicate if measurement should be included in the circuit.
Returns:
the QuantumCircuit object for the constructed circuit
"""
if self._circuit is not None:
return self._circuit
# preoracle circuit
qc_preoracle = QuantumCircuit(
self._oracle.variable_register,
self._oracle.output_register,
)
qc_preoracle.h(self._oracle.variable_register)
qc_preoracle.x(self._oracle.output_register)
qc_preoracle.h(self._oracle.output_register)
qc_preoracle.barrier()
# oracle circuit
qc_oracle = self._oracle.circuit
# postoracle circuit
qc_postoracle = QuantumCircuit(
self._oracle.variable_register,
self._oracle.output_register,
)
qc_postoracle.h(self._oracle.variable_register)
qc_postoracle.barrier()
self._circuit = qc_preoracle + qc_oracle + qc_postoracle
# measurement circuit
if measurement:
measurement_cr = ClassicalRegister(len(self._oracle.variable_register), name='m')
self._circuit.add_register(measurement_cr)
self._circuit.measure(self._oracle.variable_register, measurement_cr)
return self._circuit
def _run(self):
if self._quantum_instance.is_statevector:
qc = self.construct_circuit(measurement=False)
result = self._quantum_instance.execute(qc)
complete_state_vec = result.get_statevector(qc)
variable_register_density_matrix = get_subsystem_density_matrix(
complete_state_vec,
range(len(self._oracle.variable_register), qc.width())
)
variable_register_density_matrix_diag = np.diag(variable_register_density_matrix)
max_amplitude = max(
variable_register_density_matrix_diag.min(),
variable_register_density_matrix_diag.max(),
key=abs
)
max_amplitude_idx = np.where(variable_register_density_matrix_diag == max_amplitude)[0][0]
top_measurement = np.binary_repr(max_amplitude_idx, len(self._oracle.variable_register))
else:
qc = self.construct_circuit(measurement=True)
measurement = self._quantum_instance.execute(qc).get_counts(qc)
self._ret['measurement'] = measurement
top_measurement = max(measurement.items(), key=operator.itemgetter(1))[0]
self._ret['result'] = 'constant' if int(top_measurement) == 0 else 'balanced'
return self._ret
|
https://github.com/jdellaverson19/qiskit2020
|
jdellaverson19
|
from dj import DeutschJozsa
import dj
import time
import sys
from random import seed
from random import randint
import numpy as np
import matplotlib.pyplot as plt
import numpy as np
from qiskit import *
def main():
djObject = DeutschJozsa()
# constants
QUBIT_RANGE = 65
ITERATIONS = 10
worked = np.zeros(shape=(QUBIT_RANGE, ITERATIONS))
timing = np.zeros(shape=(QUBIT_RANGE, ITERATIONS))
print('Testing out Deutsch-Jozsa alorithm...')
seed(3)
for n in range(0,QUBIT_RANGE):
print(f'Trying {n+2}-qubit machine...')
for j in range(ITERATIONS):
print(f'Iteration {j+1}...')
# randomly decide f
const_val = randint(0,1)
def f_constant(_):
return const_val
def f_balanced(x):
return x%2
constant = randint(0,1)
f = f_constant if constant else f_balanced
print(constant)
oracle = dj.dj_oracle(constant, n+2)
start = time.perf_counter()
result = djObject.run(f,oracle, n+2)
end = time.perf_counter()
# print('worked' if result == constant else 'failed')
timing[n][j] = (end - start)
qubit_values = []
for i in range(QUBIT_RANGE):
qubit_values += [i+2]
average_runtimes = []
for i in range(QUBIT_RANGE):
average_runtimes += [np.mean(timing[i])]
plt.plot(qubit_values, average_runtimes)
plt.ylabel('Runtime (s)')
plt.xlabel('Number of Qubits')
plt.xticks(qubit_values)
plt.title('Quantum Simulation Scaling for Deutsch-Jozsa Algorithm')
plt.show()
if __name__ == "__main__":
main()
|
https://github.com/jdellaverson19/qiskit2020
|
jdellaverson19
|
import numpy as np
from qiskit import(
QuantumCircuit,
execute,
Aer)
from qiskit.visualization import plot_histogram
# Use Aer's qasm_simulator
simulator = Aer.get_backend('qasm_simulator')
# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(2, 2)
# Add a H gate on qubit 0
circuit.h(0)
# Add a CX (CNOT) gate on control qubit 0 and target qubit 1
circuit.cx(0, 1)
# Map the quantum measurement to the classical bits
circuit.measure([0,1], [0,1])
# Execute the circuit on the qasm simulator
job = execute(circuit, simulator, shots=1000)
# Grab results from the job
result = job.result()
# Returns counts
counts = result.get_counts(circuit)
print(counts)
# Draw the circuit
circuit.draw()
print(circuit)
|
https://github.com/jdellaverson19/qiskit2020
|
jdellaverson19
|
"""Python implementation of Grovers algorithm through use of the Qiskit library to find the value 3 (|11>)
out of four possible values."""
#import numpy and plot library
import matplotlib.pyplot as plt
import numpy as np
# importing Qiskit
from qiskit import IBMQ, Aer, QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.providers.ibmq import least_busy
from qiskit.quantum_info import Statevector
# import basic plot tools
from qiskit.visualization import plot_histogram
# define variables, 1) initialize qubits to zero
n = 2
grover_circuit = QuantumCircuit(n)
#define initialization function
def initialize_s(qc, qubits):
'''Apply a H-gate to 'qubits' in qc'''
for q in qubits:
qc.h(q)
return qc
### begin grovers circuit ###
#2) Put qubits in equal state of superposition
grover_circuit = initialize_s(grover_circuit, [0,1])
# 3) Apply oracle reflection to marked instance x_0 = 3, (|11>)
grover_circuit.cz(0,1)
statevec = job_sim.result().get_statevector()
from qiskit_textbook.tools import vector2latex
vector2latex(statevec, pretext="|\\psi\\rangle =")
# 4) apply additional reflection (diffusion operator)
grover_circuit.h([0,1])
grover_circuit.z([0,1])
grover_circuit.cz(0,1)
grover_circuit.h([0,1])
# 5) measure the qubits
grover_circuit.measure_all()
# Load IBM Q account and get the least busy backend device
provider = IBMQ.load_account()
device = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 3 and
not x.configuration().simulator and x.status().operational==True))
print("Running on current least busy device: ", device)
from qiskit.tools.monitor import job_monitor
job = execute(grover_circuit, backend=device, shots=1024, optimization_level=3)
job_monitor(job, interval = 2)
results = job.result()
answer = results.get_counts(grover_circuit)
plot_histogram(answer)
#highest amplitude should correspond with marked value x_0 (|11>)
|
https://github.com/jdellaverson19/qiskit2020
|
jdellaverson19
|
"""Qiskit code for running Simon's algorithm on quantum hardware for 2 qubits and b = '11' """
# importing Qiskit
from qiskit import IBMQ, BasicAer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, execute
# import basic plot tools
from qiskit.visualization import plot_histogram
from qiskit_textbook.tools import simon_oracle
#set b equal to '11'
b = '11'
#1) initialize qubits
n = 2
simon_circuit_2 = QuantumCircuit(n*2, n)
#2) Apply Hadamard gates before querying the oracle
simon_circuit_2.h(range(n))
#3) Query oracle
simon_circuit_2 += simon_oracle(b)
#5) Apply Hadamard gates to the input register
simon_circuit_2.h(range(n))
#3) and 6) Measure qubits
simon_circuit_2.measure(range(n), range(n))
# Load saved IBMQ accounts and get the least busy backend device
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= n and
not x.configuration().simulator and x.status().operational==True))
print("least busy backend: ", backend)
# Execute and monitor the job
from qiskit.tools.monitor import job_monitor
shots = 1024
job = execute(simon_circuit_2, backend=backend, shots=shots, optimization_level=3)
job_monitor(job, interval = 2)
# Get results and plot counts
device_counts = job.result().get_counts()
plot_histogram(device_counts)
#additionally, function for calculating dot product of results
def bdotz(b, z):
accum = 0
for i in range(len(b)):
accum += int(b[i]) * int(z[i])
return (accum % 2)
print('b = ' + b)
for z in device_counts:
print( '{}.{} = {} (mod 2) ({:.1f}%)'.format(b, z, bdotz(b,z), device_counts[z]*100/shots))
#the most significant results are those for which b dot z=0(mod 2).
'''b = 11
11.00 = 0 (mod 2) (45.0%)
11.01 = 1 (mod 2) (6.2%)
11.10 = 1 (mod 2) (6.4%)
11.11 = 0 (mod 2) (42.4%)'''
|
https://github.com/khalilguy/QiskitHackathon
|
khalilguy
|
import qiskit as qiskit
import numpy as np
from random import randint
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit import IBMQ
IBMQ.save_account('7e245f54848bdbcc6bedd42fcafcd2fbe8f81b765b2537e32d39f812c3ccc2e9c755a6ac3e3edc7529982f02954bff4b84cba76cef7fe71928b9f01b092feedf')
IBMQ.load_account()
from qiskit.providers.aer.noise import NoiseModel
import copy
import pandas as pd
import keras
from keras.layers import Dense, LSTM, Dropout, GRU, TimeDistributed, Bidirectional
from keras.models import Sequential
from keras.regularizers import l1, l2, l1_l2
from keras.constraints import max_norm
import matplotlib.pyplot as plt
def create_circuit():
"""This function takes no inputs and outputs a random circuit in neural network representation
as well as a quantum circuit object"""
num_qubits = randint(2,5) #Set the circuit width
len_circuit = randint(10,30) #Set the circuit depth
circ = np.zeros((num_qubits,len_circuit)) #Initialize the circuit representation for the Neural Net
qc = qiskit.QuantumCircuit(num_qubits) #Initialize the actual quantum circuit
operators = {0:qc.id,1:qc.x,2:qc.y,3:qc.z,4:qc.h,5:qc.cx,6:qc.swap} #Define the operators and their corresponding Neural Net representations
for i in range(len_circuit):
num_gates = randint(0,num_qubits-1)
gates = []
ctrls = []
for j in range(num_gates):
if j != num_gates-1:
gates.append(randint(0,4))
ctrls.append(j)
elif num_gates != num_qubits:
gates.append(randint(0,6))
ctrls.append(j)
targ = randint(num_gates,num_qubits-1) #Choose a target qubit for a 2 qubit gate to act on
for j,gate_num in enumerate(gates):
try:
#Implement the gate if it is a single qubit gate and add it to the neural net representation
operators.get(gate_num)(ctrls[j])
circ[ctrls[j]][i] = gate_num
except:
try:
#Implement the gate if it is a 2 qubit gate and add it to the neural net representation
operators.get(gate_num)(ctrls[j],targ)
circ[ctrls[j]][i] = gate_num
circ[targ][i] = gate_num
except:
gate_num = randint(1,6)
qc.measure_all()
return circ, qc
def list_of_circuits(num_of_circuits):
circuits = [0]*num_of_circuits #initialize list by number of desired circuits
circuit_arrays = [0]*num_of_circuits #initialize list by number of desired circuits
for i in range(num_of_circuits):
#calls create_circuits function desired number of times and puts objects into the arrays
circuit_arrays[i], circuits[i] = create_circuit()
return circuit_arrays, circuits
def kl_divergence(p, q):
return np.sum(np.where(p != 0, p * np.log(p / q), 0))
num_circuits = 2000
circuit_arrays, circuits = list_of_circuits(num_circuits)
list_of_backends = IBMQ.get_provider('ibm-q').backends()
list_of_backends.remove(IBMQ.get_provider('ibm-q').get_backend('ibmq_qasm_simulator'))
simulator = Aer.get_backend('qasm_simulator')
validation_set = np.zeros((len(circuits),len(list_of_backends)))
shots = 10000
for i in range(len(circuits)):
previous_divergence = 1
best_backend = 0;
for j in range(len(list_of_backends)):
if np.shape(circuit_arrays[i])[0] < list_of_backends[j].configuration().num_qubits:
coupling_map = list_of_backends[j].configuration().coupling_map
basis_gates = list_of_backends[j].configuration().basis_gates
noise_model = NoiseModel.from_backend(list_of_backends[j])
psi_0 = execute(circuits[i], simulator, shots = shots, coupling_map = coupling_map, basis_gates = basis_gates, optimization_level = 3).result().get_counts()
psi_1 = execute(circuits[i], simulator, shots = shots, coupling_map = coupling_map, basis_gates = basis_gates, noise_model = noise_model, optimization_level = 3).result().get_counts()
psi_00 = copy.deepcopy(psi_1)
for bit in psi_0.keys():
psi_00[bit] = psi_0.get(bit)
psi_0 = np.asarray([value/shots for value in psi_00.values()])
psi_1 = np.asarray([value/shots for value in psi_1.values()])
divergence = np.abs(kl_divergence(psi_0, psi_1))
if divergence < previous_divergence:
best_backend = j
previous_divergence = divergence
validation_set[i, best_backend] = 1
print("done")
max_len = max([len(circuit[0]) for circuit in circuit_arrays])
max_width = max([len(circuit) for circuit in circuit_arrays])
print(max_len)
print(max_width)
new_circuit_arrays = []
for circuit in circuit_arrays:
diff_length = max_len - np.size(circuit,1)
diff_width = max_width - len(circuit)
columns = np.full((circuit.shape[0] , diff_length), 7)
new_circuit = np.concatenate((circuit, columns),1)
rows = np.full((diff_width,new_circuit.shape[1]),7)
new_circuit = np.concatenate((new_circuit, rows))
new_circuit_arrays.append(new_circuit)
circuits[0].draw()
new_circuit_arrays[0]
batch_size = 50
epochs = 300
valsplit = .5
opt = 'rmsprop' # optimizer
model = Sequential()
model.add(Dense(512, input_dim=max_len*max_width, activation='relu', activity_regularizer=l2(0.001)))
model.add(Dropout(0.3))
model.add(Dense(256, activation='sigmoid', activity_regularizer=l2(0.001)))
model.add(Dropout(0.2))
model.add(Dense(128, activation='sigmoid', activity_regularizer=l2(0.0005)))
model.add(Dropout(0.1))
model.add(Dense(9, activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy'])
model.summary()
%%time
modelpath = 'simple.h5'
hist = model.fit(np.array(new_circuit_arrays).reshape(num_circuits,max_len*max_width), validation_set, epochs=epochs, batch_size=batch_size,
verbose=1, validation_split=valsplit,
#callbacks=[keras.callbacks.ModelCheckpoint(filepath=modelpath, verbose=0)]
)
plt.plot(hist.history['acc'])
plt.plot(hist.history['val_acc'])
plt.title('model accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train', 'test'], loc='upper left')
plt.show()
plt.plot(hist.history['loss'])
plt.plot(hist.history['val_loss'])
plt.title('model loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['train', 'test'], loc='upper left')
plt.show()
def baseline_model():
model = Sequential()
model.add(Dense(512, input_dim=max_len*max_width, activation='relu', activity_regularizer=l2(0.001)))
model.add(Dropout(0.3))
model.add(Dense(256, activation='sigmoid', activity_regularizer=l2(0.001)))
model.add(Dropout(0.2))
model.add(Dense(128, activation='sigmoid', activity_regularizer=l2(0.0005)))
model.add(Dropout(0.1))
model.add(Dense(9, activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
return model
from keras.wrappers.scikit_learn import KerasClassifier
from keras.utils import np_utils
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import KFold
estimator = KerasClassifier(build_fn=baseline_model, epochs=200, batch_size=32, verbose=0)
kfold = KFold(n_splits=10, shuffle=True)
results = cross_val_score(estimator,np.array(new_circuit_arrays).reshape(num_circuits,max_len*max_width), validation_set, cv=kfold)
print("Baseline: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))
sum_vals = sum(validation_set)
dist_of_backends = {a.name():sum_vals[i] for i,a in enumerate(list_of_backends)}
plt.figure(figsize=(15, 3)) # width:20, height:3
plt.bar(dist_of_backends.keys(),dist_of_backends.values(), align='center', width=0.8, color="g")
plt.ylabel("Number of Circuits")
plt.xlabel("Best Backend")
plt.title("Distribution of Circuits")
|
https://github.com/khalilguy/QiskitHackathon
|
khalilguy
|
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
import qiskit
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
from qiskit import IBMQ
IBMQ.save_account('7e245f54848bdbcc6bedd42fcafcd2fbe8f81b765b2537e32d39f812c3ccc2e9c755a6ac3e3edc7529982f02954bff4b84cba76cef7fe71928b9f01b092feedf')
simulator = Aer.get_backend('qasm_simulator')
gs = simulator.configuration().basis_gates
len(gs)
gate_dictionary = {}
for i in range(len(gs)):
gate_dictionary[i] = gs[i]
print(gate_dictionary)
g = [i for i in range(33)]
print(g)
single_qubit_gate_dictionary = {0:'id',1:"u1", 2:"u2",3:"u3"}
rand_number_of_qubits = np.random.randint(1,15)
rand_number_of_gates = np.random.randint(2,4)
rand_qubit_for_gate = np.random.randint(1,rand_number_of_qubits)
random_circuit = QuantumCircuit(1,1)
single_qubit_gate_dictionary[0]
from inspect import getmembers, isfunction
functions_list = [o for o in getmembers(qiskit.circuit.library.standard_gates)]
functions_list
|
https://github.com/khalilguy/QiskitHackathon
|
khalilguy
|
import qiskit as qiskit
import numpy as np
from random import randint
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit import IBMQ
IBMQ.save_account('7e245f54848bdbcc6bedd42fcafcd2fbe8f81b765b2537e32d39f812c3ccc2e9c755a6ac3e3edc7529982f02954bff4b84cba76cef7fe71928b9f01b092feedf')
IBMQ.load_account()
from qiskit.providers.aer.noise import NoiseModel
import copy
import pandas as pd
import keras
from keras.layers import Dense, LSTM, Dropout, GRU, TimeDistributed, Bidirectional
from keras.models import Sequential
from keras.regularizers import l1, l2, l1_l2
from keras.constraints import max_norm
import matplotlib.pyplot as plt
def create_circuit():
"""This function takes no inputs and outputs a random circuit in neural network representation
as well as a quantum circuit object"""
num_qubits = randint(2,5) #Set the circuit width
len_circuit = randint(10,30) #Set the circuit depth
circ = np.zeros((num_qubits,len_circuit)) #Initialize the circuit representation for the Neural Net
qc = qiskit.QuantumCircuit(num_qubits) #Initialize the actual quantum circuit
operators = {0:qc.id,1:qc.x,2:qc.y,3:qc.z,4:qc.h,5:qc.cx,6:qc.swap} #Define the operators and their corresponding Neural Net representations
for i in range(len_circuit):
num_gates = randint(0,num_qubits-1)
gates = []
ctrls = []
for j in range(num_gates):
if j != num_gates-1:
gates.append(randint(0,4))
ctrls.append(j)
elif num_gates != num_qubits:
gates.append(randint(0,6))
ctrls.append(j)
targ = randint(num_gates,num_qubits-1) #Choose a target qubit for a 2 qubit gate to act on
for j,gate_num in enumerate(gates):
try:
#Implement the gate if it is a single qubit gate and add it to the neural net representation
operators.get(gate_num)(ctrls[j])
circ[ctrls[j]][i] = gate_num
except:
try:
#Implement the gate if it is a 2 qubit gate and add it to the neural net representation
operators.get(gate_num)(ctrls[j],targ)
circ[ctrls[j]][i] = gate_num
circ[targ][i] = gate_num
except:
gate_num = randint(1,6)
qc.measure_all()
return circ, qc
def list_of_circuits(num_of_circuits):
circuits = [0]*num_of_circuits #initialize list by number of desired circuits
circuit_arrays = [0]*num_of_circuits #initialize list by number of desired circuits
for i in range(num_of_circuits):
#calls create_circuits function desired number of times and puts objects into the arrays
circuit_arrays[i], circuits[i] = create_circuit()
return circuit_arrays, circuits
def kl_divergence(p, q):
return np.sum(np.where(p != 0, p * np.log(p / q), 0))
num_circuits = 2000
circuit_arrays, circuits = list_of_circuits(num_circuits)
list_of_backends = IBMQ.get_provider('ibm-q').backends()
list_of_backends.remove(IBMQ.get_provider('ibm-q').get_backend('ibmq_qasm_simulator'))
simulator = Aer.get_backend('qasm_simulator')
validation_set = np.zeros((len(circuits),len(list_of_backends)))
shots = 10000
for i in range(len(circuits)):
previous_divergence = 1
best_backend = 0;
for j in range(len(list_of_backends)):
if np.shape(circuit_arrays[i])[0] < list_of_backends[j].configuration().num_qubits:
coupling_map = list_of_backends[j].configuration().coupling_map
basis_gates = list_of_backends[j].configuration().basis_gates
noise_model = NoiseModel.from_backend(list_of_backends[j])
psi_0 = execute(circuits[i], simulator, shots = shots, coupling_map = coupling_map, basis_gates = basis_gates, optimization_level = 3).result().get_counts()
psi_1 = execute(circuits[i], simulator, shots = shots, coupling_map = coupling_map, basis_gates = basis_gates, noise_model = noise_model, optimization_level = 3).result().get_counts()
psi_00 = copy.deepcopy(psi_1)
for bit in psi_0.keys():
psi_00[bit] = psi_0.get(bit)
psi_0 = np.asarray([value/shots for value in psi_00.values()])
psi_1 = np.asarray([value/shots for value in psi_1.values()])
divergence = np.abs(kl_divergence(psi_0, psi_1))
if divergence < previous_divergence:
best_backend = j
previous_divergence = divergence
validation_set[i, best_backend] = 1
print("done")
max_len = max([len(circuit[0]) for circuit in circuit_arrays])
max_width = max([len(circuit) for circuit in circuit_arrays])
print(max_len)
print(max_width)
new_circuit_arrays = []
for circuit in circuit_arrays:
diff_length = max_len - np.size(circuit,1)
diff_width = max_width - len(circuit)
columns = np.full((circuit.shape[0] , diff_length), 7)
new_circuit = np.concatenate((circuit, columns),1)
rows = np.full((diff_width,new_circuit.shape[1]),7)
new_circuit = np.concatenate((new_circuit, rows))
new_circuit_arrays.append(new_circuit)
circuits[0].draw()
new_circuit_arrays[0]
batch_size = 50
epochs = 300
valsplit = .5
opt = 'rmsprop' # optimizer
model = Sequential()
model.add(Dense(512, input_dim=max_len*max_width, activation='relu', activity_regularizer=l2(0.001)))
model.add(Dropout(0.3))
model.add(Dense(256, activation='sigmoid', activity_regularizer=l2(0.001)))
model.add(Dropout(0.2))
model.add(Dense(128, activation='sigmoid', activity_regularizer=l2(0.0005)))
model.add(Dropout(0.1))
model.add(Dense(9, activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy'])
model.summary()
%%time
modelpath = 'simple.h5'
hist = model.fit(np.array(new_circuit_arrays).reshape(num_circuits,max_len*max_width), validation_set, epochs=epochs, batch_size=batch_size,
verbose=1, validation_split=valsplit,
#callbacks=[keras.callbacks.ModelCheckpoint(filepath=modelpath, verbose=0)]
)
plt.plot(hist.history['acc'])
plt.plot(hist.history['val_acc'])
plt.title('model accuracy')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(['train', 'test'], loc='upper left')
plt.show()
plt.plot(hist.history['loss'])
plt.plot(hist.history['val_loss'])
plt.title('model loss')
plt.ylabel('loss')
plt.xlabel('epoch')
plt.legend(['train', 'test'], loc='upper left')
plt.show()
def baseline_model():
model = Sequential()
model.add(Dense(512, input_dim=max_len*max_width, activation='relu', activity_regularizer=l2(0.001)))
model.add(Dropout(0.3))
model.add(Dense(256, activation='sigmoid', activity_regularizer=l2(0.001)))
model.add(Dropout(0.2))
model.add(Dense(128, activation='sigmoid', activity_regularizer=l2(0.0005)))
model.add(Dropout(0.1))
model.add(Dense(9, activation='softmax'))
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
return model
from keras.wrappers.scikit_learn import KerasClassifier
from keras.utils import np_utils
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import KFold
estimator = KerasClassifier(build_fn=baseline_model, epochs=200, batch_size=32, verbose=0)
kfold = KFold(n_splits=10, shuffle=True)
results = cross_val_score(estimator,np.array(new_circuit_arrays).reshape(num_circuits,max_len*max_width), validation_set, cv=kfold)
print("Baseline: %.2f%% (%.2f%%)" % (results.mean()*100, results.std()*100))
sum_vals = sum(validation_set)
dist_of_backends = {a.name():sum_vals[i] for i,a in enumerate(list_of_backends)}
plt.figure(figsize=(15, 3)) # width:20, height:3
plt.bar(dist_of_backends.keys(),dist_of_backends.values(), align='center', width=0.8, color="g")
plt.ylabel("Number of Circuits")
plt.xlabel("Best Backend")
plt.title("Distribution of Circuits")
|
https://github.com/khalilguy/QiskitHackathon
|
khalilguy
|
%matplotlib notebook
import os
os.environ["CUDA_VISIBLE_DEVICES"] = "2"
from tracker3d import utils
from tracker3d import metrics
from tracker3d import loader
import numpy as np
import pandas as pd
import keras
order = ("phi", "r", "z")
train, target = loader.from_file("datasets/npz/unif25_prz_n10.npz")
#test = train[int(0.2 * len(train)):]
#train = train[:int(0.2 * len(train))]
#print(test.shape)
#print(train.shape)
#testTarget = target[int(0.2 * len(target)):]
#target = target[:int(0.2 * len(target))]
#print(testTarget.shape)
#print(target.shape)
test, testTarget = loader.from_file("datasets/npz/ramp_prz_n10.npz")
event = 1025
utils.display_side_by_side(train[event], target[event], order=order)
from keras.layers import Dense, LSTM, Dropout, GRU, TimeDistributed, Bidirectional
from keras.models import Sequential
from keras.regularizers import l1, l2, l1_l2
input_shape = train[0].shape # Shape of an event.
output_shape = len(target[0][0]) # Number of tracks per event
batch_size = 32
epochs = 32
valsplit = .1
opt = 'rmsprop' # optimizer
model = Sequential()
model.add(Bidirectional(GRU(256, return_sequences=True, recurrent_dropout=0.4, implementation=2, bias_regularizer=l2(0.02)), input_shape=input_shape, merge_mode="mul"))
model.add(Dropout(0.4))
model.add(Bidirectional(GRU(256, return_sequences=True, recurrent_dropout=0.4, implementation=2, bias_regularizer=l2(0.02)), merge_mode="mul"))
model.add(Dropout(0.4))
model.add(Bidirectional(GRU(256, return_sequences=True, recurrent_dropout=0.4, implementation=2, bias_regularizer=l2(0.02)), merge_mode="mul"))
model.add(Dropout(0.4))
model.add(TimeDistributed(Dense(output_shape, activation='softmax')))
model.compile(loss='categorical_crossentropy', optimizer=opt, metrics=['accuracy'])
model.summary()
%%time
modelpath = 'simple.h5'
hist = model.fit(train, target, epochs=epochs, batch_size=batch_size,
verbose=1, validation_split=valsplit,
#callbacks=[keras.callbacks.ModelCheckpoint(filepath=modelpath, verbose=0)]
)
predictions = model.predict(test, batch_size=batch_size)
utils.print_scores(model, train, target, batch_size)
utils.graph_losses([("Categorical Cross Entropy", hist)])
tracks, acc = metrics.accuracy_vs_tracks(predictions, testTarget, has_noise=True, has_padding=True)
np.save("testTarget.npy", testTarget)
np.save("predictions.npy", predictions)
print(metrics.discrete_accuracy_all(test, testTarget, predictions))
print(acc)
%matplotlib inline
import matplotlib.pyplot as plt
plt.figure(2)
fig = plt.scatter(tracks, acc)
plt.show(fig)
numTracks = int(np.amax(tracks))
accuracy = np.zeros(numTracks)
for i in range(numTracks):
tot_acc = 0
count = 0
for j, track in enumerate(tracks):
print(acc[j])
if track == i + 1:
tot_acc = tot_acc + acc[j]
count += 1
if count > 0:
accuracy[i] = tot_acc/count
track = np.zeros(numTracks)
for i in range(numTracks):
track[i] = i + 1
print(accuracy)
print(track)
plt.scatter(track, accuracy)
plt.plot(np.unique(track), np.poly1d(np.polyfit(track, accuracy, 1))(np.unique(track)))
plt.title("Average Accuracy vs. Number of Tracks")
plt.xlabel("Number of Tracks")
plt.ylabel("Accuracy")
plt.show(fig)
for i, cell in enumerate(acc):
if cell < 0.3:
print(cell)
print(tracks[i])
|
https://github.com/khalilguy/QiskitHackathon
|
khalilguy
|
%matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
import qiskit
import numpy as np
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
from qiskit import IBMQ
IBMQ.save_account('7e245f54848bdbcc6bedd42fcafcd2fbe8f81b765b2537e32d39f812c3ccc2e9c755a6ac3e3edc7529982f02954bff4b84cba76cef7fe71928b9f01b092feedf')
simulator = Aer.get_backend('qasm_simulator')
gates = simulator.configuration().basis_gates
len(gates)
gate_dictionary = {}
for i in range(len(gates)):
gate_dictionary =
single_qubit_gate_dictionary = {0:'id',1:"u1", 2:"u2",3:"u3"}
rand_number_of_qubits = np.random.randint(1,15)
rand_number_of_gates = np.random.randint(2,4)
rand_qubit_for_gate = np.random.randint(1,rand_number_of_qubits)
random_circuit = QuantumCircuit(1,1)
single_qubit_gate_dictionary[0]
from inspect import getmembers, isfunction
functions_list = [o for o in getmembers(qiskit.circuit.library.standard_gates)]
function_list.pop()
|
https://github.com/EACMichiels/QiskitDutch
|
EACMichiels
|
# initialization
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
# importing Qiskit
from qiskit import IBMQ, BasicAer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
# import basic plot tools
from qiskit.tools.visualization import plot_histogram
nQubits = 2 # number of physical qubits used to represent s
s = 3 # the hidden integer
# make sure that a can be represented with nqubits
s = s % 2**(nQubits)
# Creating registers
# qubits for querying the oracle and finding the hidden integer
qr = QuantumRegister(nQubits)
# bits for recording the measurement on qr
cr = ClassicalRegister(nQubits)
bvCircuit = QuantumCircuit(qr, cr)
barriers = True
# Apply Hadamard gates before querying the oracle
for i in range(nQubits):
bvCircuit.h(qr[i])
# Apply barrier
if barriers:
bvCircuit.barrier()
# Apply the inner-product oracle
for i in range(nQubits):
if (s & (1 << i)):
bvCircuit.z(qr[i])
else:
bvCircuit.iden(qr[i])
# Apply barrier
if barriers:
bvCircuit.barrier()
#Apply Hadamard gates after querying the oracle
for i in range(nQubits):
bvCircuit.h(qr[i])
# Apply barrier
if barriers:
bvCircuit.barrier()
# Measurement
bvCircuit.measure(qr, cr)
bvCircuit.draw(output='mpl')
# use local simulator
backend = BasicAer.get_backend('qasm_simulator')
shots = 1024
results = execute(bvCircuit, backend=backend, shots=shots).result()
answer = results.get_counts()
plot_histogram(answer)
# Load our saved IBMQ accounts and get the least busy backend device with less than or equal to 5 qubits
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
provider.backends()
backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits <= 5 and
not x.configuration().simulator and x.status().operational==True))
print("least busy backend: ", backend)
# Run our circuit on the least busy backend. Monitor the execution of the job in the queue
from qiskit.tools.monitor import job_monitor
shots = 1024
job = execute(bvCircuit, backend=backend, shots=shots)
job_monitor(job, interval = 2)
# Get the results from the computation
results = job.result()
answer = results.get_counts()
plot_histogram(answer)
import qiskit
qiskit.__qiskit_version__
|
https://github.com/EACMichiels/QiskitDutch
|
EACMichiels
|
# We starten met de noodzakelijke imports
import numpy as np
from qiskit import *
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, BasicAer, IBMQ, execute
from qiskit.visualization import plot_histogram, plot_bloch_multivector
from qiskit.extensions import Initialize
%matplotlib inline
qreg = QuantumRegister(3) # Het protocol gebruikt 3 qubits
cregz = ClassicalRegister(1) # Het protocol gebruikt 2 classical bits in 2 verschillende registers
cregx = ClassicalRegister(1) # Omwille van de leesbaarheid geven we deze verschillende namen
teleportation_circuit = QuantumCircuit(qreg, cregz, cregx)
def create_bell_pair(qc, x, y):
"""Creëert een Bell paar in qc met behulp van de qubits x & y"""
qc.h(x) # Plaats de qubit a in de "superposition" toestand |+>
qc.cx(x,y) # Vervolgens gebruiken we CNOT om "entanglement" te bekomen met a als "control" and b als "target"
# Dit is één van de 4 bekende zogenaamde "Bell States" in Quantum Computing
## Initieel Opzetten
qreg = QuantumRegister(3) # Het protocol gebruikt 3 qubits
cregz = ClassicalRegister(1) # Het protocol gebruikt 2 classical bits in 2 verschillende registers
cregx = ClassicalRegister(1) # Omwille van de leesbaarheid geven we deze verschillende namen
teleportation_circuit = QuantumCircuit(qreg, cregz, cregx)
## STAP 1
# In ons geval zorgt Jommeke ervoor dat qubits q1 en q2 verstrengeld ("entangled") zijn.
# We passen dit toe op ons circuit
create_bell_pair(teleportation_circuit, 1, 2)
# We bekijken ook even hoe het circuit eruit ziet tot nu toe
teleportation_circuit.draw(output='mpl')
def alice_gates(qc, psi, a):
qc.cx(psi, a)
qc.h(psi)
## Initieel Opzetten
qreg = QuantumRegister(3) # Het protocol gebruikt 3 qubits
cregz = ClassicalRegister(1) # Het protocol gebruikt 2 classical bits in 2 verschillende registers
cregx = ClassicalRegister(1) # Omwille van de leesbaarheid geven we deze verschillende namen
teleportation_circuit = QuantumCircuit(qreg, cregz, cregx)
## STAP 2.1
create_bell_pair(teleportation_circuit, 1, 2)
## STEP 2.2
teleportation_circuit.barrier() # We gebruiken een "barrier" om de stappen te onderscheiden
alice_gates(teleportation_circuit, 0, 1)
# We bekijken ook even hoe het circuit eruit ziet tot nu toe
teleportation_circuit.draw(output='mpl')
def measure_and_send(qc, a, b):
"""Opmeten van qubits a & b and 'stuurt' de resultaten naar Bob"""
qc.barrier()
qc.measure(a,0)
qc.measure(b,1)
## Initieel Opzetten
qreg = QuantumRegister(3) # Het protocol gebruikt 3 qubits
cregz = ClassicalRegister(1) # Het protocol gebruikt 2 classical bits in 2 verschillende registers
cregx = ClassicalRegister(1) # Omwille van de leesbaarheid geven we deze verschillende namen
teleportation_circuit = QuantumCircuit(qreg, cregz, cregx)
## STAP 3.1
create_bell_pair(teleportation_circuit, 1, 2)
## STAP 3.2
teleportation_circuit.barrier() # We gebruiken een "barrier" om de stappen te onderscheiden
alice_gates(teleportation_circuit, 0, 1)
## STAP 3.3
measure_and_send(teleportation_circuit, 0 ,1)
# We bekijken ook even hoe het circuit eruit ziet tot nu toe
teleportation_circuit.draw(output='mpl')
# De onderstaande functie start van een QuantumCircuit (qc), en een geheel getal of "integer" (qubit),
# alsook van de Classical Registers crz en crx, om te beslissen welke gates er moeten toegepast worden
def bob_gates(qc, qubit, crz, crx):
# Hieronder gebruiken we een c_if om onze gates te controleren met een
# classical bit en GEEN qubit. De term "c_if" staat voor "classical if".
qc.x(qubit).c_if(crx, 1) # Pas de gates toe als de registers in toestand '1' zijn.
qc.z(qubit).c_if(crz, 1)
## Initieel Opzetten
qreg = QuantumRegister(3) # Het protocol gebruikt 3 qubits
cregz = ClassicalRegister(1) # Het protocol gebruikt 2 classical bits in 2 verschillende registers
cregx = ClassicalRegister(1) # Omwille van de leesbaarheid geven we deze verschillende namen
teleportation_circuit = QuantumCircuit(qreg, cregz, cregx)
## STAP 4.1
create_bell_pair(teleportation_circuit, 1, 2)
## STAP 4.2
teleportation_circuit.barrier() # Om de stappen te onderscheiden, gebruiken we een "barrier"
alice_gates(teleportation_circuit, 0, 1)
## STAP 4.3
measure_and_send(teleportation_circuit, 0 ,1)
## STAP 4.4
teleportation_circuit.barrier() # Gebruik terug een barriere om de stappen te onderscheiden
bob_gates(teleportation_circuit, 2, cregz, cregx)
# We bekijken ook terug eens hoe het circuit eruit ziet
teleportation_circuit.draw(output='mpl')
# Creëer status van 1 qubit, bijvoorbeeld als volgt:
psi = [np.sqrt(0.70), np.sqrt(0.30)]
print(psi)
# Aarzel niet om een andere waarde voor psi op te geven.
# Maar waak erover dat de som van de absolute waarden van de coëficienten 1 is.
# We tonen de psi op een Bloch Sphere
plot_bloch_multivector(psi)
init_gate = Initialize(psi)
init_gate.label = "init"
## Initieel Opzetten
qreg = QuantumRegister(3) # Het protocol gebruikt 3 qubits
cregz = ClassicalRegister(1) # Het protocol gebruikt 2 classical bits in 2 verschillende registers
cregx = ClassicalRegister(1) # Omwille van de leesbaarheid geven we deze verschillende namen
qcirc = QuantumCircuit(qreg, cregz, cregx)
## STAP 3.2.0
# Eerst initiaiseren we de q0 van Alice
qcirc.append(init_gate, [0])
qcirc.barrier()
## STAP 3.2.1
# Nu begint het teleportatie protocol
create_bell_pair(qcirc, 1, 2)
qcirc.barrier()
## STAP 3.2.2
# Stuur q1 naar Alice en q2 naar Bob
alice_gates(qcirc, 0, 1)
## STAP 3.2.3
# Alice stuurt haar classical bits naar Bob
measure_and_send(qcirc, 0, 1)
## STAP 3.2.4
# Bob decodeert qubits
bob_gates(qcirc, 2, cregz, cregx)
# Display the circuit
qcirc.draw(output='mpl')
backend = BasicAer.get_backend('statevector_simulator')
output_vector = execute(qcirc, backend).result().get_statevector()
plot_bloch_multivector(output_vector)
inverse_init_gate = init_gate.gates_to_uncompute()
## Initieel Opzetten
qreg = QuantumRegister(3) # Het protocol gebruikt 3 qubits
cregz = ClassicalRegister(1) # Het protocol gebruikt 2 classical bits in 2 verschillende registers
cregx = ClassicalRegister(1) # Omwille van de leesbaarheid geven we deze verschillende namen
qcirc = QuantumCircuit(qreg, cregz, cregx)
## STEP 3.3.0
# We initialiseren eerst de q0 van Aice
qcirc.append(init_gate, [0])
qcirc.barrier()
## STEP 3.3.1
# Nu begit het teleportatie protocal
create_bell_pair(qcirc, 1, 2)
qcirc.barrier()
## STEP 3.3.2
# Stuur q1 naar Alice en q2 naar Bob
alice_gates(qcirc, 0, 1)
## STEP 3.3.3
# Alice stuurt dan haar "classical bits" naar Bob
measure_and_send(qcirc, 0, 1)
## STEP 3.3. 4
# Bob decodeert de qubits
bob_gates(qcirc, 2, cregz, cregx)
## STEP 3.3.5
# Keer het initialisatie process om
qcirc.append(inverse_init_gate, [2])
# Teken the circuit
qcirc.draw(output='mpl')
# We moeten een bijkimend ClassicalRegister toevoegen om het resultaat te zien
cr_result = ClassicalRegister(1)
qcirc.add_register(cr_result)
qcirc.measure(2,2)
qcirc.draw(output='mpl')
backend = BasicAer.get_backend('qasm_simulator')
counts = execute(qcirc, backend, shots=1024).result().get_counts()
plot_histogram(counts)
# Tot slot tonen we nog even de gebruikte versies
import qiskit
qiskit.__qiskit_version__
|
https://github.com/Hayatto9217/QIskit12
|
Hayatto9217
|
#量子エラー研究.平均誤差率
from qiskit import IBMQ, transpile
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit.tools.visualization import plot_histogram
from qiskit.providers.fake_provider import FakeVigo
device_backend =FakeVigo()
circ = QuantumCircuit(3, 3)
circ.h(0)
circ.cx(0, 1)
circ.cx(1, 2)
circ.measure([0,1,2],[0,1,2])
sim_ideal = AerSimulator()
result = sim_ideal.run(transpile(circ, sim_ideal)).result()
counts =result.get_counts(0)
plot_histogram(counts, title='Ideal counts for 3-qubit GHZ state')
#ibmq-vigo のsimulator
sim_vigo = AerSimulator.from_backend(device_backend)
tcirc = transpile(circ,sim_vigo)
result_noise =sim_vigo.run(tcirc).result()
counts_noise = result_noise.get_counts(0)
plot_histogram(counts_noise, title="Counts for 3-qubit GHZ device noise model")
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/Praween-em/QiskitBasics
|
Praween-em
|
from qiskit import Aer, QuantumCircuit, transpile, assemble, execute
from math import gcd
from numpy.random import randint
def a_mod_N(a, power, N, quantum_reg):
# Function to perform modular exponentiation using quantum gates
circuit = QuantumCircuit(quantum_reg, 1)
circuit.x(quantum_reg[0]) # Set the last qubit to |1>
circuit.h(quantum_reg[1]).c_if(quantum_reg[1], 1) # Conditional H gate
circuit.h(quantum_reg[0]).c_if(quantum_reg[0], 1) # Conditional H gate
circuit.x(quantum_reg[0]).c_if(quantum_reg[0], 1) # Conditional X gate
circuit.cx(quantum_reg[0], quantum_reg[1]) # Conditional CX gate
circuit.x(quantum_reg[0]).c_if(quantum_reg[0], 1) # Conditional X gate
circuit.x(quantum_reg[1]).c_if(quantum_reg[1], 1) # Conditional X gate
circuit.measure(quantum_reg[1], 0) # Measure the result
# Execute the quantum circuit on the simulator
backend = Aer.get_backend('qasm_simulator')
result = execute(circuit, backend, shots=1).result()
outcome = int(result.get_counts().popitem()[0])
return outcome
def shors_algorithm_quantum(N):
a = randint(2, N) # Choose a random integer a between 2 and N-1
# Check if the chosen 'a' shares a non-trivial factor with N
if gcd(a, N) > 1:
return gcd(a, N)
r = 2 # Initialize a guess for the period
quantum_reg = QuantumCircuit(4, 2) # Quantum register with 4 qubits
# Modify the a_mod_N function to use the quantum version
while True:
outcome = a_mod_N(a, r, N, quantum_reg)
if outcome == 1:
break
r += 1
# ... (continue with the rest of the code)
# Test Shor's algorithm with a sample number N
N = 21
result = shors_algorithm_quantum(N)
print(f"Non-trivial factor of {N}: {result}")
|
https://github.com/Praween-em/QiskitBasics
|
Praween-em
|
#!/usr/bin/env python
# coding: utf-8
# In[1]:
from qiskit import *
# In[2]:
qr = QuantumRegister(2)
# In[3]:
cr = ClassicalRegister(2)
# In[4]:
circuit = QuantumCircuit(qr,cr)
# In[5]:
get_ipython().run_line_magic('matplotlib', 'inline')
# In[6]:
circuit.draw()
# In[7]:
circuit.h(qr[0])
# In[8]:
circuit.draw(output='mpl')
# In[9]:
circuit.cx(qr[0], qr[1])
# In[10]:
circuit.draw(output='mpl')
# In[11]:
circuit.measure(qr,cr)
# In[12]:
circuit.draw(output='mpl')
# In[15]:
simulator = Aer.get_backend('qasm_simulator')
# In[17]:
result = execute(circuit, backend=simulator).result()
# In[18]:
from qiskit.tools.visualization import plot_histogram
# In[19]:
plot_histogram(result.get_counts(circuit))
# In[20]:
IBMQ.load_account()
# In[21]:
provider = IBMQ.get_provider('ibm-q')
# In[26]:
qcomp = provider.get_backend('ibm_brisbane')
# In[27]:
job = execute(circuit, backend=qcomp)
# In[28]:
from qiskit.tools.monitor import job_monitor
# In[32]:
job_monitor(job)
# In[33]:
result=job.result()
# In[34]:
plot_histogram(result.get_counts(circuit))
# In[ ]:
|
https://github.com/ggridin/QiskitTests
|
ggridin
|
import qiskit
from qiskit.providers import JobStatus
from QCTest import get_test_qc, get_qc_random_generator
from QuantumPlatform import QuantumPlatform
def get_quantum_circuit():
return get_test_qc()
def main():
wait_for_results = True
try:
platform_backend = QuantumPlatform(qiskit.Aer, 'aer_simulator')
except Exception as e:
print(f'Error during quantum platform initialization: {e}')
exit(1)
qc = get_qc_random_generator(1024)
job = platform_backend.schedule_job(qc, shots=100, dry_run=False,
qc_filename='qc.qasm', qc_image_filename='qc.png',
transpiled_filename = 'transpiled.qasm', transpiled_image_filename='transpiled.png')
if job is None:
print('Job is not scheduled!')
exit(1)
print(f'Job id={job.job_id}')
print(f'Job={job}')
if wait_for_results is False:
exit(0)
job.wait_for_final_state()
print(f'Job status={job.status()}')
if job.status() == JobStatus.DONE:
print(f'Job result={job.result()}')
print(f'Counts={job.result().get_counts(qc)}')
main()
|
https://github.com/ggridin/QiskitTests
|
ggridin
|
from qiskit import transpile, transpiler, qasm2
class QuantumPlatform:
def __init__(self, provider = None, backend_name = None):
self.provider = None
self.backend = None
self.transpiled_qc = None
self.provider = provider
if self.provider is None:
raise "Cannot initialize quantum provider"
if backend_name is not None:
self.backend = self.provider.get_backend(backend_name)
if self.backend is None:
raise f'Cannot initialize backend {backend_name}'
def get_provider(self):
return self.provider
def get_backend_info(self, coupling_map_filename=None, target_info_filename=None):
print(f'Backends={self.provider.backends()}')
print(f'Operation names={self.backend.operation_names}')
# print(f'Properties={self.backend.properties()}')
# print(f'Configuration={self.backend.configuration()}')
# print(f'Status={self.backend.status()}')
print(f'Options={self.backend.options}')
# if target_info_filename is not None:
# f = open(target_info_filename, "w")
# f.write(self.backend.target)
# f.close()
if coupling_map_filename is not None:
coupling_map = transpiler.CouplingMap(self.backend.coupling_map)
image = coupling_map.draw()
image.save(coupling_map_filename)
def get_backend(self):
return self.backend
def schedule_job(self, circuit, shots=1, dry_run=False,
qc_filename=None, qc_image_filename=None,
transpiled_filename=None, transpiled_image_filename=None):
if qc_filename is not None:
qasm2.dump(circuit, qc_filename)
if qc_image_filename is not None:
circuit.draw(output='mpl', filename=qc_image_filename)
self.transpiled_qc = transpile(circuit, self.backend)
if transpiled_filename is not None:
qasm2.dump(self.transpiled_qc, transpiled_filename)
if transpiled_image_filename is not None:
self.transpiled_qc.draw(output='mpl', filename=transpiled_image_filename)
if dry_run is True: return None
return self.backend.run(self.transpiled_qc, shots=shots)
def get_async_job(self, job_id):
return self.provider.retrieve_job(job_id)
|
https://github.com/ggridin/QiskitTests
|
ggridin
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, Aer
from QuantumPlatform import QuantumPlatform
# Set up the program
def get_quantum_spy_circuit():
alice = QuantumRegister(1, name='alice')
fiber = QuantumRegister(1, name='fiber')
bob = QuantumRegister(1, name='bob')
alice_had = ClassicalRegister(1, name='ahad')
alice_val = ClassicalRegister(1, name='aval')
fiber_val = ClassicalRegister(1, name='fval')
bob_had = ClassicalRegister(1, name='bhad')
bob_val = ClassicalRegister(1, name='bval')
qc = QuantumCircuit(alice, fiber, bob, alice_had, alice_val, fiber_val, bob_had, bob_val)
# Use Alice's QPU to generate two random bits
qc.reset(alice) # write the value 0
qc.h(alice)
qc.measure(alice, alice_had)
qc.reset(alice) # write the value 0
qc.h(alice)
qc.measure(alice, alice_val)
# Prepare Alice's qubit
qc.reset(alice) # write the value 0
qc.x(alice).c_if(alice_val, 1)
qc.h(alice).c_if(alice_had, 1)
# Send the qubit!
qc.swap(alice, fiber)
# Activate the spy
spy_is_present = True
if spy_is_present:
qc.barrier()
spy_had = True
if spy_had:
qc.h(fiber)
qc.measure(fiber, fiber_val)
qc.reset(fiber)
qc.x(fiber).c_if(fiber_val, 1)
if spy_had:
qc.h(fiber)
qc.barrier()
# Use Bob's QPU to generate a random bit
qc.reset(bob)
qc.h(bob)
qc.measure(bob, bob_had)
# Receive the qubit!
qc.swap(fiber, bob)
qc.h(bob).c_if(bob_had, 1)
qc.measure(bob, bob_val)
return qc
def main():
qc = get_quantum_spy_circuit()
platform_backend = QuantumPlatform(Aer, 'statevector_simulator')
job = platform_backend.schedule_job(qc)
result = job.result()
# Now Alice emails Bob to tell
# him her had setting and value.
# If the had setting matches and the
# value does not, there's a spy!
counts = result.get_counts(qc)
print('counts:',counts)
caught = False
for key,val in counts.items():
ahad,aval,f,bhad,bval = (int(x) for x in key.split(' '))
if ahad == bhad:
if aval != bval:
print('Caught a spy!')
caught = True
if not caught:
print('No spies detected.')
outputstate = result.get_statevector(qc, decimals=3)
print(outputstate)
# qc.draw() # draw the circuit
main()
|
https://github.com/ggridin/QiskitTests
|
ggridin
|
# Do the necessary imports
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import Aer
from qiskit.extensions import Initialize
from qiskit.quantum_info import random_statevector, Statevector,partial_trace
def trace01(out_vector):
return Statevector([sum([out_vector[i] for i in range(0,4)]), sum([out_vector[i] for i in range(4,8)])])
def teleportation():
# Create random 1-qubit state
psi = random_statevector(2)
print(psi)
init_gate = Initialize(psi)
init_gate.label = "init"
## SETUP
qr = QuantumRegister(3, name="q") # Protocol uses 3 qubits
crz = ClassicalRegister(1, name="crz") # and 2 classical registers
crx = ClassicalRegister(1, name="crx")
qc = QuantumCircuit(qr, crz, crx)
# Don't modify the code above
## Put your code below
# ----------------------------
qc.initialize(psi, qr[0])
qc.h(qr[1])
qc.cx(qr[1],qr[2])
qc.cx(qr[0],qr[1])
qc.h(qr[0])
qc.measure(qr[0],crz[0])
qc.measure(qr[1],crx[0])
qc.x(qr[2]).c_if(crx[0], 1)
qc.z(qr[2]).c_if(crz[0], 1)
# ----------------------------
# Don't modify the code below
sim = Aer.get_backend('aer_simulator')
qc.save_statevector()
out_vector = sim.run(qc).result().get_statevector()
result = trace01(out_vector)
return psi, result
# (psi,res) = teleportation()
# print(psi)
# print(res)
# if psi == res:
# print('1')
# else:
# print('0')
|
https://github.com/magn5452/QiskitQaoa
|
magn5452
|
from abc import abstractmethod, ABC
from qiskit import Aer
from qiskit.algorithms import NumPyMinimumEigensolver, QAOA
from qiskit.algorithms.optimizers import optimizer, COBYLA
from qiskit_optimization.algorithms import MinimumEigenOptimizer
from qiskit_optimization.problems import quadratic_program
class MinimumEigenSolver(ABC):
@abstractmethod
def solve(self, quadratic_program):
pass
|
https://github.com/magn5452/QiskitQaoa
|
magn5452
|
from abc import ABC, abstractmethod
from qiskit import QuantumCircuit
class InitialStrategy(ABC):
@abstractmethod
def set_up_initial_state_circuit(self, quantum_circuit: QuantumCircuit):
pass
class PhaseStrategy(ABC):
@abstractmethod
def set_up_phase_circuit(self, gamma, quantum_circuit: QuantumCircuit):
pass
class MixerStrategy(ABC):
@abstractmethod
def set_up_mixer_circuit(self, beta, quantum_circuit: QuantumCircuit):
pass
class MeasurementStrategy(ABC):
@abstractmethod
def set_up_measurement_circuit(self, quantum_circuit: QuantumCircuit):
pass
|
https://github.com/magn5452/QiskitQaoa
|
magn5452
|
from qiskit import Aer
from qiskit import QuantumCircuit
from VehicleRouting.standard.CostCalculator import CostCalculator
def maxcut_obj(x, G):
"""
Given a bitstring as a solution, this function returns
the number of edges shared between the two partitions
of the graph.
Args:
x: str
solution bitstring
G: networkx graph
Returns:
obj: float
Objective
"""
obj = 0
for i, j in G.couplings():
if x[i] != x[j]:
obj -= 1
return obj
def compute_expectation(counts, G):
"""
Computes expectation value based on measurement results
Args:
counts: dict
key as bitstring, val as count
G: networkx graph
Returns:
avg: float
expectation value
"""
avg = 0
sum_count = 0
for bitstring, count in counts.items():
obj = maxcut_obj(bitstring, G)
avg += obj * count
sum_count += count
return avg / sum_count
# We will also bring the different circuit components that
# build the qaoa circuit under a single function
def create_qaoa_circuit(graph, theta):
"""
Creates a parametrized qaoa circuit
Args:
graph: networkx graph
theta: list
unitary parameters
Returns:
qc: qiskit circuit
"""
nqubits = len(graph.nodes())
p = len(theta) // 2 # number of alternating unitaries
qc = QuantumCircuit(nqubits)
beta = theta[:p]
gamma = theta[p:]
# initial_state
for i in range(0, nqubits):
qc.h(i)
for irep in range(0, p):
# problem unitary
for pair in list(graph.couplings()):
qc.rzz(2 * gamma[irep], pair[0], pair[1])
qc.barrier()
# mixer unitary
for i in range(0, nqubits):
qc.rx(2 * beta[irep], i)
qc.measure_all()
return qc
# Finally we write a function that executes the circuit on the chosen backend
def get_expectation(graph, p, shots=512):
"""
Runs parametrized circuit
Args:
graph: networkx graph
p: int,
Number of repetitions of unitaries
"""
backend = Aer.get_backend('qasm_simulator')
backend.shots = shots
def execute_circ(theta):
qc = create_qaoa_circuit(graph, theta)
counts = backend.run(qc, seed_simulator=10,
nshots=512).result().get_counts()
return compute_expectation(counts, graph)
return execute_circ
# Finally we write a function that executes the circuit on the chosen backend
def get_execute_circuit(graph, shots=512):
"""
Runs parametrized circuit
Args:
G: networkx graph
p: int,
Number of repetitions of unitaries
"""
backend = Aer.get_backend('qasm_simulator')
backend.shots = shots
def execute_circ(theta):
qc = create_qaoa_circuit(graph, theta)
counts = backend.run(qc, seed_simulator=10,
nshots=512).result().get_counts()
return compute_expectation(counts, graph)
return execute_circ
|
https://github.com/magn5452/QiskitQaoa
|
magn5452
|
import numpy as np
from qiskit import Aer
from qiskit import QuantumCircuit
from VehicleRouting.standard.CostCalculator import CostCalculator
def compute_expectation(counts, graph):
"""
Computes expectation value based on measurement results
Args:
counts: dict
key as bitstring, val as count
graph: networkx graph
Returns:
avg: float
expectation value
"""
sum_cost = 0
sum_count = 0
for bitstring, count in counts.items():
cost_calculator = CostCalculator(bitstring, graph, 1, 100)
cost = cost_calculator.vehicle_routing_cost()
sum_cost += cost * count
sum_count += count
expectation_value = sum_cost / sum_count
return expectation_value
# We will also bring the different circuit components that
# build the qaoa circuit under a single function
def create_qaoa_circuit(graph, theta):
"""
Creates qaoa circuit
Args:
graph: networkx graph
theta: qaoa parameters
"""
number_of_nodes = len(graph.nodes())
number_of_qubits = number_of_nodes * (number_of_nodes-1) # n*(n-1)
precision = len(theta) // 2 # number of alternating unitaries p
quantum_circuit = QuantumCircuit(number_of_qubits)
beta = theta[:precision]
gamma = theta[precision:]
# initial_state
for index_qubit in range(0, number_of_qubits):
quantum_circuit.h(index_qubit)
quantum_circuit.barrier()
for index_repetition in range(0, precision):
# problem unitary
for i in range(0, number_of_qubits):
for j in range(0, i):
J = 1
quantum_circuit.rzz(2* gamma[index_repetition], i, j)
quantum_circuit.barrier()
for i in range(0, number_of_qubits):
quantum_circuit.rz(2 * gamma[index_repetition], i)
quantum_circuit.barrier()
# mixer unitary
for index_qubit in range(0, number_of_qubits):
quantum_circuit.rxx(2 * beta[index_repetition], index_qubit,np.mod(index_qubit+1,number_of_qubits))
quantum_circuit.ryy(2 * beta[index_repetition], index_qubit,np.mod(index_qubit+1,number_of_qubits))
quantum_circuit.barrier()
# measure
quantum_circuit.measure_all()
return quantum_circuit
# Finally we write a function that executes the circuit on the chosen backend
def get_execute_circuit(graph, shots=512):
"""
Runs parametrized circuit
Args:
graph: networkx graph
"""
backend = Aer.get_backend('qasm_simulator')
backend.shots = shots
def execute_circuit(theta):
quantum_circuit = create_qaoa_circuit(graph, theta)
counts = backend.run(quantum_circuit, seed_simulator=10,
nshots=2 ^ 12).result().get_counts()
return compute_expectation(counts, graph)
return execute_circuit
|
https://github.com/magn5452/QiskitQaoa
|
magn5452
|
import numpy as np
from matplotlib import pyplot as plt
from qiskit import Aer
from qiskit.visualization import plot_histogram
from scipy.optimize import minimize
from VehicleRouting.standard.factories.MaxCutFactories import TwoConnectedMaxCutFactory
from VehicleRouting.standard.problems.MaxCutProblem import MaxCutProblem
from VehicleRouting.functions.functionsMaxCut import get_expectation, get_execute_circuit, create_qaoa_circuit
from VehicleRouting.standard.plotter.GraphPlotter import GraphPlotter
number_of_vertices = 4
problem_factory = TwoConnectedMaxCutFactory()
problem = MaxCutProblem(problem_factory)
plotter = GraphPlotter(problem)
plotter.plot_problem()
graph = problem.get_graph()
expectation = get_expectation(graph, p=1)
# Returns a function to be optimized
p = 4
expectation = get_execute_circuit(graph)
# Optimize
initial_parameter = np.ones(2 * p)
optimization_method = 'COBYLA'
optimization_object = minimize(expectation, initial_parameter, method=optimization_method)
print(optimization_object)
backend = Aer.get_backend('aer_simulator')
backend.shots = 2 ^ 12
# Create Circuit with Optimized Parameters
optimized_parameters = optimization_object.x
qc_res = create_qaoa_circuit(graph, optimized_parameters)
qc_res.draw(output="mpl")
counts = backend.run(qc_res, seed_simulator=10).result().get_counts()
print(counts)
plot_histogram(counts)
plt.show()
|
https://github.com/magn5452/QiskitQaoa
|
magn5452
|
import numpy as np
from matplotlib import pyplot as plt
from qiskit import QuantumCircuit, Aer, transpile, assemble
from qiskit.circuit import Gate
from qiskit.circuit import Parameter
from qiskit.extensions import UnitaryGate, HamiltonianGate
from qiskit.providers.aer import StatevectorSimulator
from qiskit.visualization import plot_histogram
from qiskit_nature.operators.second_quantization import SpinOp
from VehicleRouting.standard.concretization.CircuitPlotter import MPLCircuitPlotter
beta = Parameter('beta')
spinop = SpinOp([("++--", 1),("--++", 1)])
print(spinop.to_matrix())
gate = HamiltonianGate(spinop.to_matrix(), np.pi/2, label="Gate")
qc = QuantumCircuit(4)
qc.h(0)
qc.h(1)
qc.h(2)
qc.h(3)
qc.append(gate, [0,1,2,3])
backend = StatevectorSimulator(precision='double')
transpiled = transpile(qc, backend=backend)
transpiled.draw('mpl')
result = backend.run(transpiled).result()
counts = result.get_counts()
print(result)
print(counts)
plot_histogram(counts)
circuit_plotter = MPLCircuitPlotter()
circuit_plotter.plot(qc)
plt.show()
|
https://github.com/magn5452/QiskitQaoa
|
magn5452
|
from matplotlib import pyplot as plt
from qiskit import QuantumCircuit, Aer, assemble
from qiskit.extensions import HamiltonianGate
from qiskit.providers import aer
from qiskit.providers.aer import StatevectorSimulator
from qiskit.quantum_info import Operator
from qiskit.visualization import plot_histogram
from VehicleRouting.standard.concretization.CircuitPlotter import MPLCircuitPlotter
circuit = QuantumCircuit(4)
circuit.h(0)
circuit.h(1)
circuit.h(2)
circuit.h(3)
circuit.measure_all()
circuit_plotter = MPLCircuitPlotter()
circuit_plotter.plot(circuit)
backend = StatevectorSimulator(precision='single')
backend.shots = 2 ** 8
counts = backend.run(circuit).result().get_counts()
plt.show()
|
https://github.com/magn5452/QiskitQaoa
|
magn5452
|
import numpy as np
from matplotlib import pyplot as plt
from qiskit import QuantumCircuit
from qiskit.providers.aer import StatevectorSimulator
from qiskit.visualization import plot_histogram
from qiskit_nature.operators.second_quantization import SpinOp
from VehicleRouting.standard.concretization.CircuitPlotter import MPLCircuitPlotter
from VehicleRouting.standard.concretization.Qaoa import Qaoa
from VehicleRouting.standard.concretization.QaoaMinimizer import QaoaMinimizerImpl
from VehicleRouting.standard.factories.MaxCutFactories import TwoConnectedMaxCutFactory
from VehicleRouting.standard.factories.QaoaFactory import ExactMaxCutQaoaFactory
from VehicleRouting.standard.plotter.BarPlotter import BarPlotter
from VehicleRouting.standard.plotter.GraphPlotter import GraphPlotter
from VehicleRouting.standard.plotter.SurfacePlotter import SurfacePlotter
from VehicleRouting.standard.problems.MaxCutProblem import MaxCutProblem
# Problem
factory = TwoConnectedMaxCutFactory()
problem = MaxCutProblem(factory)
plotter = GraphPlotter(problem)
plotter.plot_problem()
# Qaoa
qaoa_factory = ExactMaxCutQaoaFactory(problem)
qaoa = Qaoa(qaoa_factory)
# Minimizer
qaoaMinimizer = QaoaMinimizerImpl(qaoa)
result, optimal_parameters, optimal_circuit = qaoaMinimizer.minimize()
print(optimal_parameters) #[1.14403197, 0.99879625]
# Plot Circuit
circuit_plotter = MPLCircuitPlotter()
circuit_plotter.plot(optimal_circuit)
# Simulate Optimized Parameters
result, counts, expectation = qaoa.simulate(optimal_parameters)
# Bar Plot
barPlotter = BarPlotter()
barPlotter.plot(counts)
# Find Surface Plot
plotter = SurfacePlotter()
plotter.plot(qaoa.get_execute_circuit())
plt.show()
|
https://github.com/magn5452/QiskitQaoa
|
magn5452
|
import matplotlib.pyplot as plt
import numpy as np
from VehicleRouting.standard.factories.VehicleRoutingProblemFactories import Experiment1VehicleRoutingProblemFactory
from VehicleRouting.standard.problems.VehicleRoutingProblem import VehicleRoutingProblem
from VehicleRouting.functions.functionsVehicleRouting import get_execute_circuit
from VehicleRouting.functions.functionsVehicleRouting import create_qaoa_circuit
from qiskit import Aer
from qiskit.visualization import plot_histogram
from scipy.optimize import minimize
# Setting Up Graph
from VehicleRouting.standard.plotter.GraphPlotter import GraphPlotter
from VehicleRouting.standard.concretization.GraphStrategy import SimpleExperimentProblemStrategy
problem_factory = Experiment1VehicleRoutingProblemFactory()
problem = VehicleRoutingProblem(problem_factory)
plotter = GraphPlotter(problem)
plotter.plot_problem()
graph = problem.get_graph()
# Returns a function to be optimized
p = 2
expectation = get_execute_circuit(graph)
# Optimize
initial_parameter = np.ones(2*p)
optimization_method = 'COBYLA'
optimization_object = minimize(expectation, initial_parameter, method=optimization_method)
print(optimization_object)
# Get a simulator
backend = Aer.get_backend('aer_simulator')
backend.shots = 2 ^ 12
# Create Circuit with Optimized Parameters
optimized_parameters = optimization_object.x
qc_res = create_qaoa_circuit(graph, optimized_parameters)
qc_res.draw(output="mpl")
# Run simulation with optimised parameters
counts = backend.run(qc_res, seed_simulator=10).result().get_counts()
print(counts)
# Plot Histogram
plot_histogram(counts)
plt.show()
|
https://github.com/magn5452/QiskitQaoa
|
magn5452
|
from qiskit import QuantumCircuit
from qiskit.algorithms import NumPyMinimumEigensolver
from qiskit_optimization.algorithms import MinimumEigenOptimizer
from VehicleRouting.framework.interfaces.MinimumEigenSolver import MinimumEigenSolver
class QAOAMinimumEigenSolver(MinimumEigenSolver):
def __init__(self, factory):
self.qaoa = factory.create_qaoa()
self.optimizer = MinimumEigenOptimizer(self.qaoa)
def solve(self, quadratic_program):
return self.optimizer.solve(quadratic_program)
def get_optimal_circuit(self) -> QuantumCircuit:
return self.qaoa.get_optimal_circuit()
def get_optimal_vector(self):
return self.qaoa.get_optimal_vector()
def get_optimal_cost(self):
return self.qaoa.get_optimal_cost()
def get_probabilities(self):
return self.qaoa.get_probabilities_for_counts()
def get_optimizer(self):
return self.optimizer
def get_qaoa(self):
return self.qaoa
class ExactMinimumEigenSolver(MinimumEigenSolver):
def __init__(self):
self.exact_minimum_eigen_solver = NumPyMinimumEigensolver()
self.optimizer = MinimumEigenOptimizer(self.exact_minimum_eigen_solver)
def solve(self, quadratic_program):
return self.optimizer.solve(quadratic_program)
def get_optimizer(self):
return self.optimizer
def get_exact_minimum_eigen_solver(self):
return self.exact_minimum_eigen_solver
|
https://github.com/magn5452/QiskitQaoa
|
magn5452
|
#------------------------------------------------------------------------------
# Qaoa.py
#
# Implementation of the Quantum Approximate Optimization Algorithm (QAOA) [1],[2]
# specifically tailored for solving the MaxCut problem on graphs [3].
# This class facilitates the creation of QAOA circuits with
# various types of mixer operators and allows execution on a quantum simulator
# backend provided by Qiskit.
#
# The `Qaoa` class provides methods to:
# - Initialize with QAOA parameters, graph instance, mixer type, and backend settings
# - Create cost operator and various mixer operators (x, xx, y, yy, xy)
# - Generate the complete QAOA circuit
#
# Initialization parameters include the number of QAOA layers, angles for the
# mixer and cost operators, and options for setting verbosity, measurement, and
# random seed. The class checks for consistency in the provided parameters and
# supports visualizing the graph and QAOA circuit.
#
# Refs.
# [1] https://arxiv.org/abs/1411.4028
# [2] https://learning.quantum.ibm.com/tutorial/quantum-approximate-optimization-algorithm
# [3] https://en.wikipedia.org/wiki/Maximum_cut
#
# © Leonardo Lavagna 2024
# @ NESYA https://github.com/NesyaLab
#------------------------------------------------------------------------------
import numpy as np
from matplotlib import pyplot as plt
from classes import Problems as P
from functions import qaoa_utilities as utils
from qiskit import QuantumCircuit
from qiskit_aer import Aer
from typing import List, Tuple
from networkx import Graph
from qiskit.circuit import ParameterVector
class Qaoa:
def __init__(self, p: int = 0, G: Graph = None, betas: List[float] = None, gammas: List[float] = None,
mixer: str = "x", backend = Aer.get_backend('qasm_simulator'), measure: bool = True,
seed: int = None, verbose: bool = True):
"""Initialize class QAOA.
Args:
p (int): Positive number of QAOA layers. The default is 0.
G (Graph): A graph created with the Problem class used as MaxCut problem instance. The default is None.
betas (float): Angles for the mixer operator.
gammas (float): Angles for the cost operator.
mixer (str): Type of mixer operator to be used. The default is "x".
backend (Qiskit backend): Qiskit backend to execute the code on a quantum simulator.
The default is Aer.get_backend('qasm_simulator').
measure (bool): If True measure the qaoa circuit. The default is True.
seed (int): Seed for a pseudo-random number generator. The default is None.
verbose (bool): If True enters in debugging mode. The default is True.
"""
# Setup
self.p = p
self.G = G
self.mixer = mixer
self.backend = backend
self.measure = measure
self.verbose = verbose
self.seed = seed
self.problems_class = P.Problems(p_type="custom", G=self.G)
if self.seed is not None:
np.random.seed(self.seed)
if self.G is None:
self.N = 0
self.w = [[]]
self.betas = []
self.gammas = []
if self.G is not None:
self.N = G.get_number_of_nodes()
self.w = G.get_adjacency_matrix()
if betas is None or gammas is None:
self.betas = utils.generate_parameters(n=self.p, k=1)
self.gammas = utils.generate_parameters(n=self.p, k=2)
if betas is not None and gammas is not None:
self.betas = betas
self.gammas = gammas
# Checking...
if self.problems_class.__class__.__name__ != self.G.__class__.__name__ and G is not None:
raise Exception("Invalid parameters. The graph G should be created with the Problems class.")
if (self.p == 0 and self.G is not None) or (self.p > 0 and G is None):
raise ValueError("If G is not the empty graph p should be a strictly positive integer, and viceversa.")
if len(self.betas) != p or len(self.gammas) != p or len(self.betas) != len(self.gammas):
raise ValueError("Invalid angles list. The length of betas and gammas should be equal to p.")
# Initializing...
if self.verbose is True:
print(" --------------------------- ")
print("| Intializing Qaoa class... |".upper())
print(" --------------------------- ")
print("-> Getting problem instance...".upper())
if self.G is not None:
self.G.get_draw()
plt.show()
if self.G is None:
print("\t * G = ø")
if self.betas is None and self.G is not None:
print("-> Beta angles not provided. Generating angles...".upper())
print(f"\t * betas = {self.betas}")
if self.gammas is None and self.G is not None:
print("-> Gamma angles not provided. Generating angles...".upper())
print(f"\t * gammas = {self.gammas}")
print("-> Getting the ansatz...".upper())
if self.G is not None:
print(self.get_circuit())
if self.G is None:
print("\t * Qaoa circuit = ø")
print("-> The Qaoa class was initialized with the following parameters.".upper())
print(f"\t * Number of layers: p = {self.p};")
if self.G is None:
print(f"\t * Graph: G = ø;")
if self.G is not None:
print(f"\t * Graph: G = {self.G.p_type};")
print("\t * Angles:")
print(f"\t\t - betas = {self.betas};")
print(f"\t\t - gammas = {self.gammas};")
print(f"\t * Mixer Hamiltonian type: '{self.mixer}';")
print(f"\t * Random seed: seed = {self.seed};")
print(f"\t * Measurement setting: measure = {self.measure}.")
def cost_operator(self, gamma: float) -> QuantumCircuit:
"""Create an instance of the cost operator with angle 'gamma'.
Args:
gamma (float): Angle for the cost operator.
Returns:
QuantumCircuit: Circuit representing the cost operator.
"""
qc = QuantumCircuit(self.N, self.N)
for i,j in self.G.get_edges():
qc.cx(i, j)
qc.rz(gamma, j)
qc.cx(i, j)
return qc
def x_mixer_operator(self, beta: float) -> QuantumCircuit:
"""Create an instance of the x-mixer operator with angle 'beta'.
Args:
beta (float): Angle for the mixer operator.
Returns:
QuantumCircuit: Circuit representing the mixer operator.
"""
qc = QuantumCircuit(self.N, self.N)
for v in self.G.get_nodes():
qc.rx(beta, v)
return qc
def xx_mixer_operator(self, beta: float) -> QuantumCircuit:
"""Create an instance of the xx-mixer operator with angle 'beta'.
Args:
beta (float): Angle for the mixer operator.
Returns:
QuantumCircuit: Circuit representing the mixer operator.
"""
qc = QuantumCircuit(self.N, self.N)
for i, j in self.G.get_edges():
if self.w[i, j] > 0:
qc.rxx(beta, i, j)
return qc
def y_mixer_operator(self, beta: float) -> QuantumCircuit:
"""Create an instance of the y-mixer operator with angle 'beta'.
Args:
beta (float): Angle for the mixer operator.
Returns:
QuantumCircuit: Circuit representing the mixer operator.
"""
qc = QuantumCircuit(self.N, self.N)
for v in self.G.get_nodes():
qc.ry(2 * beta, v)
return qc
def yy_mixer_operator(self, beta: float) -> QuantumCircuit:
"""Create an instance of the yy-mixer operator with angle 'beta'.
Args:
beta (float): Time-slice angle for the mixer operator.
Returns:
QuantumCircuit: Circuit representing the mixer operator.
"""
qc = QuantumCircuit(self.N, self.N)
for i, j in self.G.get_edges():
if self.w[i, j] > 0:
qc.ryy(beta / 2, i, j)
return qc
def xy_mixer_operator(self, phi: float, psi: float) -> QuantumCircuit:
"""Create an instance of the xy-mixer operator with angle 'beta'.
Args:
beta (float): Angle for the mixer operator.
Returns:
QuantumCircuit: Circuit representing the mixer operator.
"""
qc = QuantumCircuit(self.N, self.N)
# X_iX_j
for i, j in self.G.get_edges():
if self.w[i, j] > 0:
qc.rxx(phi / 2, i, j)
# Y_iY_j
for i, j in self.G.get_edges():
if self.w[i, j] > 0:
qc.ryy(psi / 2, i, j)
return qc
def get_circuit(self) -> QuantumCircuit:
"""Create an instance of the Qaoa circuit with given parameters.
Returns:
QuantumCircuit: Circuit representing the Qaoa.
"""
qc = QuantumCircuit(self.N, self.N)
params = ParameterVector("params", 2 * self.p)
betas = params[0 : self.p]
gammas = params[self.p : 2 * self.p]
qc.h(range(self.N))
qc.barrier(range(self.N))
for i in range(self.p):
qc = qc.compose(self.cost_operator(gammas[i]))
qc.barrier(range(self.N))
if self.mixer == "x":
qc = qc.compose(self.x_mixer_operator(betas[i]))
qc.barrier(range(self.N))
elif self.mixer == "xx":
qc = qc.compose(self.xx_mixer_operator(betas[i]))
qc.barrier(range(self.N))
elif self.mixer == "y":
qc = qc.compose(self.y_mixer_operator(betas[i]))
qc.barrier(range(self.N))
elif self.mixer == "yy":
qc = qc.compose(self.yy_mixer_operator(betas[i]))
qc.barrier(range(self.N))
elif self.mixer == "xy":
qc = qc.compose(self.xy_mixer_operator(betas[i],betas[i]))
qc.barrier(range(self.N))
qc.barrier(range(self.N))
if self.measure:
qc.measure(range(self.N), range(self.N))
return qc
|
https://github.com/magn5452/QiskitQaoa
|
magn5452
|
from qiskit import Aer
from qiskit.algorithms import QAOA
from qiskit.algorithms.optimizers import COBYLA
from qiskit.providers.aer import QasmSimulator, StatevectorSimulator
from VehicleRouting.framework.factory.QaoaMinimumEigenSolverFactory import QAOAMinimumEigenSolverFactory
class StandardQaoaMinimumEigenSolverFactory(QAOAMinimumEigenSolverFactory):
def create_qaoa(self):
precision = 12
classical_optimization_method = COBYLA()
#backend = StatevectorSimulator(precision='single')
backend = QasmSimulator()
return QAOA(optimizer=classical_optimization_method, reps=precision, quantum_instance=backend)
|
https://github.com/magn5452/QiskitQaoa
|
magn5452
|
from qiskit import Aer
from qiskit.providers.aer import noise, StatevectorSimulator
from VehicleRouting.framework.qaoa.BackendStrategy import BackendStrategy
class AerBackendStrategy(BackendStrategy):
def __init__(self):
pass
def get_backend(self):
backend = Aer.get_backend('aer_simulator')
backend.shots = 2^8
return backend
class StateVectorBackendStrategy(BackendStrategy):
def __init__(self):
pass
def get_backend(self):
backend = StatevectorSimulator(precision='double')
return backend
class NoisyBackendStrategy(BackendStrategy):
def __init__(self):
pass
def get_backend(self):
# Error probabilities
prob_1 = 0.9 # 1-qubit gate
prob_2 = 0.9 # 2-qubit gate
# Depolarizing quantum errors
error_1 = noise.depolarizing_error(prob_1, 1)
error_2 = noise.depolarizing_error(prob_2, 2)
# Add errors to noise model
noise_model = noise.NoiseModel()
noise_model.add_all_qubit_quantum_error(error_1, ['x', 'y', 'z', 'sx', 'h'])
noise_model.add_all_qubit_quantum_error(error_2, ['cx', 'cy', 'cz'])
backend = Aer.get_backend('aer_simulator', noise_model=noise_model)
backend.shots = 1
return backend
|
https://github.com/magn5452/QiskitQaoa
|
magn5452
|
from operator import xor
import numpy as np
from qiskit import QuantumCircuit
from qiskit.extensions import HamiltonianGate
from qiskit_nature.operators.second_quantization import SpinOp
from VehicleRouting.framework.qaoa.CircuitStrategy import InitialStrategy, MixerStrategy
from VehicleRouting.standard.qaoa.MixerStrategy import PartialSwapMixerStrategy, AdjacentSwapMixerStrategy
class NullInitialStrategy(InitialStrategy):
def __init__(self):
pass
def set_up_initial_state_circuit(self, quantum_circuit: QuantumCircuit):
pass
class HGateInitialStrategy(InitialStrategy):
def __init__(self):
pass
def set_up_initial_state_circuit(self, quantum_circuit: QuantumCircuit):
quantum_circuit.barrier()
for index_qubit in range(0, quantum_circuit.num_qubits):
quantum_circuit.h(index_qubit)
class OneHotSingleInitialStrategy(InitialStrategy):
def __init__(self):
pass
def set_up_initial_state_circuit(self, quantum_circuit: QuantumCircuit):
quantum_circuit.barrier()
initial_array = self.get_initial_array(quantum_circuit.num_qubits)
for index_qubit, value_qubit in enumerate(initial_array):
if value_qubit == 1:
quantum_circuit.x(index_qubit)
def get_initial_array(self, num_qubits):
initial_array = np.zeros(num_qubits)
num_vertices = int(np.round(np.sqrt(num_qubits)))
for index_qubit in range(0, num_qubits):
if np.mod(index_qubit, num_vertices + 1) == 0:
initial_array[index_qubit] = 1
return initial_array
class XGateInitialStrategy(InitialStrategy):
def __init__(self, initial_array):
self.initial_array = initial_array
def set_up_initial_state_circuit(self, quantum_circuit: QuantumCircuit):
quantum_circuit.barrier()
for index_qubit, value_qubit in enumerate(self.initial_array):
if value_qubit == 1:
quantum_circuit.x(index_qubit)
class PartialSwapInitialStrategy(InitialStrategy):
def __init__(self):
pass
def set_up_initial_state_circuit(self, quantum_circuit):
XGateInitialStrategy(initial_array=np.array([1, 0, 0, 0, 1, 0, 0, 0, 1])).set_up_initial_state_circuit(
quantum_circuit)
quantum_circuit.barrier()
n = 0
beta_3 = n * np.pi - np.arcsin(np.sqrt(1 / 3))
beta_2 = n * np.pi - np.arcsin(np.sqrt(1 / 2))
self.set_up_partial_swap_gate(beta_2, 1, 2, 1, 2, quantum_circuit)
self.set_up_partial_swap_gate(beta_3, 0, 1, 0, 1, quantum_circuit)
self.set_up_partial_swap_gate(beta_3, 0, 2, 0, 1, quantum_circuit)
self.set_up_partial_swap_gate(beta_2, 0, 2, 0, 2, quantum_circuit)
self.set_up_partial_swap_gate(beta_2, 0, 1, 0, 2, quantum_circuit)
def set_up_partial_swap_gate(self, beta, city_u, city_v, position_i, position_j, quantum_circuit):
num_vertices = int(np.round(np.sqrt(quantum_circuit.num_qubits)))
hamiltonian = SpinOp([("++--", 1), ("--++", 1)])
unitary_gate = HamiltonianGate(hamiltonian.to_matrix(), beta, label="(" + str(round(beta, 1)) + ")")
quantum_circuit.append(unitary_gate, [self.map(city_u, position_i, num_vertices),
self.map(city_v, position_j,
num_vertices),
self.map(city_u, position_j,
num_vertices),
self.map(city_v, position_i, num_vertices)])
def map(self, city: int, position: int, num_vertices: int):
mapping = num_vertices * np.mod(city, num_vertices) + np.mod(position, num_vertices)
return mapping
class CustomInitialStrategy(InitialStrategy):
def __init__(self):
pass
def set_up_initial_state_circuit(self, quantum_circuit: QuantumCircuit):
initializer = OneHotSingleInitialStrategy()
initializer.set_up_initial_state_circuit(quantum_circuit)
mixer = AdjacentSwapMixerStrategy()
mixer.set_up_mixer_circuit(np.pi / 2, quantum_circuit)
class AdjacentSwapInitialStrategy(InitialStrategy):
def __init__(self):
pass
def set_up_initial_state_circuit(self, quantum_circuit):
initializer = OneHotSingleInitialStrategy()
initializer.set_up_initial_state_circuit(quantum_circuit)
initial_array = initializer.get_initial_array(quantum_circuit.num_qubits)
quantum_circuit.barrier()
num_vertices = int(np.round(np.sqrt(quantum_circuit.num_qubits)))
hamiltonian = self.make_adjacent_swap_mixer_hamiltonian(num_vertices, initial_array)
beta = np.sqrt(3) / (3 ** 2) * np.pi # for n = 3 sqrt(3)/3^2
unitary_gate = HamiltonianGate(hamiltonian.to_matrix(), beta, label="(" + str(round(beta, 1)) + ")")
quantum_circuit.append(unitary_gate, range(quantum_circuit.num_qubits))
def make_adjacent_swap_mixer_hamiltonian(self, num_vertices, initial_array) -> SpinOp:
opr_list = []
for city_u in range(num_vertices):
for city_v in range(num_vertices):
for position_i in range(num_vertices):
for position_j in range(num_vertices):
if city_u < city_v and position_i < position_j:
if initial_array[self.map(city_u, position_i, num_vertices)] == 1 and initial_array[
self.map(city_v, position_j, num_vertices)] == 1:
string, string_hermitian = self.make_string_partial_mixer(city_u, city_v, position_i,
position_j, num_vertices)
print(string)
opr_list.append((string, 1))
opr_list.append((string_hermitian, 1))
return SpinOp(opr_list)
def make_string_partial_mixer(self, city_u, city_v, position_i, position_j, num_vertices):
string_list = []
string_hermitian_list = []
for i in range(num_vertices ** 2):
string_list.append("I")
string_hermitian_list.append("I")
string_list[self.map(city_u, position_i, num_vertices)] = "+"
string_list[self.map(city_v, position_j, num_vertices)] = "+"
string_list[self.map(city_u, position_j, num_vertices)] = "-"
string_list[self.map(city_v, position_i, num_vertices)] = "-"
string_hermitian_list[self.map(city_u, position_i, num_vertices)] = "-"
string_hermitian_list[self.map(city_v, position_j, num_vertices)] = "-"
string_hermitian_list[self.map(city_u, position_j, num_vertices)] = "+"
string_hermitian_list[self.map(city_v, position_i, num_vertices)] = "+"
new_string = "".join(string_list)
new_string_hermitian = "".join(string_hermitian_list)
return new_string, new_string_hermitian
def map(self, city: int, position: int, num_vertices: int):
mapping = num_vertices * np.mod(city, num_vertices) + np.mod(position, num_vertices)
return mapping
class Adjacent2SwapInitialStrategy(InitialStrategy):
def __init__(self):
pass
def set_up_initial_state_circuit(self, quantum_circuit):
initializer = OneHotSingleInitialStrategy()
initializer.set_up_initial_state_circuit(quantum_circuit)
initial_array = initializer.get_initial_array(quantum_circuit.num_qubits)
quantum_circuit.barrier()
num_vertices = int(np.round(np.sqrt(quantum_circuit.num_qubits)))
hamiltonian = self.make_adjacent_swap_mixer_hamiltonian(num_vertices, initial_array)
beta = np.sqrt(3) / (3 ** 2) * np.pi # for n = 3 sqrt(3)/3^2
unitary_gate = HamiltonianGate(hamiltonian.to_matrix(), beta, label="(" + str(round(beta, 1)) + ")")
quantum_circuit.append(unitary_gate, range(quantum_circuit.num_qubits))
def make_adjacent_swap_mixer_hamiltonian(self, num_vertices, initial_array) -> SpinOp:
opr_list = []
for city_u in range(num_vertices):
for city_v in range(num_vertices):
for position_i in range(num_vertices):
for position_j in range(num_vertices):
if city_u != city_v and position_i != position_j:
if initial_array[self.map(city_u, position_i, num_vertices)] == 1 and initial_array[
self.map(city_v, position_j, num_vertices)] == 1:
string, string_hermitian = self.make_string_partial_mixer(city_u, city_v, position_i,
position_j, num_vertices)
print(string)
opr_list.append((string, 1))
opr_list.append((string_hermitian, 1))
return SpinOp(opr_list)
def make_string_partial_mixer(self, city_u, city_v, position_i, position_j, num_vertices):
string_list = []
string_hermitian_list = []
for i in range(num_vertices ** 2):
string_list.append("I")
string_hermitian_list.append("I")
string_list[self.map(city_u, position_i, num_vertices)] = "+"
string_list[self.map(city_v, position_j, num_vertices)] = "+"
string_list[self.map(city_u, position_j, num_vertices)] = "-"
string_list[self.map(city_v, position_i, num_vertices)] = "-"
string_hermitian_list[self.map(city_u, position_i, num_vertices)] = "-"
string_hermitian_list[self.map(city_v, position_j, num_vertices)] = "-"
string_hermitian_list[self.map(city_u, position_j, num_vertices)] = "+"
string_hermitian_list[self.map(city_v, position_i, num_vertices)] = "+"
new_string = "".join(string_list)
new_string_hermitian = "".join(string_hermitian_list)
return new_string, new_string_hermitian
def map(self, city: int, position: int, num_vertices: int):
mapping = num_vertices * np.mod(city, num_vertices) + np.mod(position, num_vertices)
return mapping
|
https://github.com/lancecarter03/QiskitLearning
|
lancecarter03
|
from qiskit import *
%matplotlib inline
from qiskit.tools.visualization import plot_histogram
secretNumber = '111000'
circuit = QuantumCircuit(len(secretNumber)+1, len(secretNumber))
circuit.h(range(len(secretNumber)))
circuit.x(len(secretNumber))
circuit.h(len(secretNumber))
circuit.barrier()
for ii, yesno in enumerate(reversed(secretNumber)):
if yesno == '1':
circuit.cx(ii, len(secretNumber))
circuit.barrier()
circuit.h(range(len(secretNumber)))
circuit.barrier()
circuit.measure(range(len(secretNumber)),range(len(secretNumber)))
circuit.draw(output="mpl")
simulator = Aer.get_backend('qasm_simulator')
result = execute(circuit,backend = simulator, shots=1).result()
counts = result.get_counts()
print(counts)
|
https://github.com/lancecarter03/QiskitLearning
|
lancecarter03
|
import numpy as np
from qiskit import QuantumCircuit
|
https://github.com/lancecarter03/QiskitLearning
|
lancecarter03
|
from qiskit import *
from qiskit.tools.visualization import plot_histogram
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
circuit = QuantumCircuit(qr,cr)
circuit.decompose().draw(output="mpl", initial_state=True)
circuit.h(qr[0])
circuit.draw(output="mpl")
circuit.cx(qr[0],qr[1])
circuit.draw(output="mpl")
circuit.measure(qr,cr)
circuit.draw(output="mpl")
simulator = Aer.get_backend('qasm_simulator')
result = execute(circuit, backend = simulator).result()
plot_histogram(result.get_counts(circuit))
|
https://github.com/lancecarter03/QiskitLearning
|
lancecarter03
|
from qiskit import *
from qiskit.tools.visualization import plot_bloch_multivector
from qiskit.tools.visualization import plot_histogram
circuit = QuantumCircuit(1,1)
circuit.x(0)
simulator = Aer.get_backend('statevector_simulator')
result = execute(circuit, backend = simulator).result()
statevector = result.get_statevector()
print(statevector)
circuit.draw(output='mpl')
plot_bloch_multivector(statevector)
circuit.measure([0],[0])
backend = Aer.get_backend('qasm_simulator')
result = execute(circuit, backend = backend, shots=1024).result()
counts = result.get_counts()
plot_histogram(counts)
circuit = QuantumCircuit(1,1)
circuit.x(0)
simulator = Aer.get_backend('unitary_simulator')
result = execute(circuit, backend = simulator).result()
unitary = result.get_unitary()
print(unitary)
|
https://github.com/lancecarter03/QiskitLearning
|
lancecarter03
|
from qiskit import *
from qiskit.tools.visualization import plot_histogram
circuit = QuantumCircuit(1,1)
circuit.draw(output='mpl', initial_state=True)
circuit.measure(0,0)
simulator = Aer.get_backend('qasm_simulator')
result = execute(circuit, backend = simulator, shots =1024).result()
counts = result.get_counts()
plot_histogram(counts)
circuit.h(0)
circuit.z(0)
circuit.h(0)
circuit.measure(0,0)
circuit.draw(output='mpl', initial_state=True)
simulator = Aer.get_backend('qasm_simulator')
result = execute(circuit, backend = simulator, shots =1024).result()
counts = result.get_counts()
plot_histogram(counts)
|
https://github.com/lancecarter03/QiskitLearning
|
lancecarter03
|
import numpy as np
from qiskit import QuantumCircuit
from qiskit.providers.aer import QasmSimulator
from qiskit.visualization import plot_histogram
circuit = QuantumCircuit(2,2)
#Applies Hadamard gate to qubit 0
circuit.h(0)
#Entangles qubit 0 to 1
circuit.cx(0,1)
#When passing entire quantum and classical registers, Ith qubit
#measurement result stored in Ith classical bit
circuit.measure([0,1],[0,1])
circuit.draw()
import numpy as np
from qiskit import QuantumCircuit, transpile
from qiskit.providers.basicaer import QasmSimulatorPy
simulator = QasmSimulator()
compiled_circuit = transpile(circuit,simulator)
job = simulator.run(compiled_circuit,shots=1000)
result = job.result()
counts = result.get_counts(circuit)
print("\nTotal count for 00 and 11 are:",counts)
plot_histogram(counts)
|
https://github.com/lancecarter03/QiskitLearning
|
lancecarter03
|
from qiskit import *
from qiskit.tools.visualization import plot_histogram
circuit = QuantumCircuit(3,3)
circuit.draw(output="mpl")
circuit.x(0)
circuit.barrier()
circuit.draw(output="mpl")
circuit.h(1)
circuit.cx(1,2)
circuit.draw(output="mpl")
circuit.cx(0,1)
circuit.h(0)
circuit.draw(output="mpl")
circuit.barrier()
circuit.measure([0,1],[0,1])
circuit.draw(output="mpl")
circuit.barrier()
circuit.cx(1,2)
circuit.cz(0,2)
circuit.draw(output="mpl")
circuit.measure(2,2)
simulator = Aer.get_backend('qasm_simulator')
result = execute(circuit, backend = simulator, shots =1024).result()
counts = result.get_counts()
plot_histogram(counts)
|
https://github.com/lancecarter03/QiskitLearning
|
lancecarter03
|
import numpy as np
from qiskit import QuantumCircuit
from qiskit.providers.aer import QasmSimulator
from qiskit.visualization import plot_histogram
circuit = QuantumCircuit(2,2)
circuit.h(0)
circuit.cx(0,1)
circuit.measure([0,1],[0,1])
circuit.draw()
|
https://github.com/abbarreto/qiskit3
|
abbarreto
|
list_bin = []
for j in range(0,2**4):
b = "{:04b}".format(j)
list_bin.append(b)
print(list_bin)
list_int = []
for j in range(0,2**4):
list_int.append(int(list_bin[j],2))
print(list_int)
|
https://github.com/abbarreto/qiskit3
|
abbarreto
|
%run init.ipynb
c00,c01,c10,c11 = symbols('c_{00} c_{01} c_{10} c_{11}')
psiAB = Matrix([[c00],[c01],[c10],[c11]]); psiAB
rhoAB = psiAB*conjugate(psiAB.T); rhoAB
rhoA = ptraceB(2,2,rhoAB); rhoB = ptraceA(2,2,rhoAB)
rhoA, rhoB
pauli(3)*pauli(1)*pauli(3), pauli(3)*pauli(2)*pauli(3), comm(pauli(3),pauli(1)), comm(pauli(3),pauli(2))
%run init.ipynb
def pTraceL_num(dl, dr, rhoLR):
rhoR = np.zeros((dr, dr), dtype=complex)
for j in range(0, dr):
for k in range(j, dr):
for l in range(0, dl):
rhoR[j,k] += rhoLR[l*dr+j,l*dr+k]
if j != k:
rhoR[k,j] = np.conj(rhoR[j,k])
return rhoR
def pTraceR_num(dl, dr, rhoLR):
rhoL = np.zeros((dl, dl), dtype=complex)
for j in range(0, dl):
for k in range(j, dl):
for l in range(0, dr):
rhoL[j,k] += rhoLR[j*dr+l,k*dr+l]
if j != k:
rhoL[k,j] = np.conj(rhoL[j,k])
return rhoL
def coh_l1(rho):
d = rho.shape[0]; C = 0
for j in range(0,d-1):
for k in range(j+1,d):
C += np.abs(rho[j,k])
return 2*C
from numpy import linalg as LA
def Econc_(rho):
s2 = np.array([[0,-1j],[1j,0]])
R = rho@np.kron(s2,s2)@np.matrix.conjugate(rho)@np.kron(s2,s2)
w, v = LA.eig(R)
evm = max(abs(w[0]), abs(w[1]), abs(w[2]), abs(w[3]))
Ec = 2*math.sqrt(abs(evm)) - math.sqrt(abs(w[0])) - math.sqrt(abs(w[1]))\
- math.sqrt(abs(w[2])) - math.sqrt(abs(w[3]))
if Ec < 0.0:
Ec = 0.0
return Ec
import scipy.linalg.lapack as lapak
def Econc(rho):
s2 = np.array([[0,-1j],[1j,0]])
R = rho@np.kron(s2,s2)@np.matrix.conjugate(rho)@np.kron(s2,s2)
ev = lapak.zheevd(R)
evm = max(abs(ev[0][0]), abs(ev[0][1]), abs(ev[0][2]), abs(ev[0][3]))
Ec = 2*math.sqrt(abs(evm)) - math.sqrt(abs(ev[0][0])) - math.sqrt(abs(ev[0][1]))\
- math.sqrt(abs(ev[0][2])) - math.sqrt(abs(ev[0][3]))
if Ec < 0.0:
Ec = 0.0
return Ec
def concurrence_psi(rho):
rho_r = pTraceL_num(2,2,rho)
return math.sqrt(2*abs(1-np.matrix.trace(rho_r@rho_r)))
def predict_jb(rho):
return abs(rho[0,0]-rho[1,1])
import qiskit
from qiskit import *
nshots = 8192
IBMQ.load_account()
#provider= qiskit.IBMQ.get_provider(hub='ibm-q-research-2',group='federal-uni-sant-1',project='main')
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
device = provider.get_backend('ibmq_manila')
simulator = Aer.get_backend('qasm_simulator')
from qiskit.tools.monitor import job_monitor
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
q_exp = np.arange(0,1.1,0.1); N = len(q_exp)
th_xi = np.zeros(N); th_xi = 2*np.arccos(np.sqrt(1-q_exp))
th_eta = np.zeros(N); th_eta = 2*np.arccos(np.sqrt(q_exp))
E_sim_10 = np.zeros(N); C_sim_0 = np.zeros(N); P_sim_0 = np.zeros(N)
jobs_ids = []
for j in range(0,N):
qr = QuantumRegister(5); qc = QuantumCircuit(qr)
# prepara xi
qc.u(th_xi[j],0,0,qr[1])
qc.cx(qr[1],qr[2])
qc.h([qr[1],qr[2]])
# prepara eta
qc.u(th_eta[j],0,0,qr[3])
qc.cx(qr[3],qr[4])
qc.h([qr[3],qr[4]])
# tomografia
qstc = state_tomography_circuits(qc, [qr[1],qr[2]])
job_sim = qiskit.execute(qstc, backend = simulator, shots=nshots)
qstf_sim = StateTomographyFitter(job_sim.result(), qstc)
rho_10_sim = qstf_sim.fit(method='lstsq')
E_sim_10[j] = concurrence_psi(rho_10_sim)
rho_0_sim = pTraceL_num(2, 2, rho_10_sim)
C_sim_0[j] = coh_l1(rho_0_sim)
P_sim_0[j] = predict_jb(rho_0_sim)
qc.draw(output='mpl')
q_exp = np.arange(0,1.1,0.1); N = len(q_exp)
th_xi = np.zeros(N); th_xi = 2*np.arccos(np.sqrt(1-q_exp))
th_eta = np.zeros(N); th_eta = 2*np.arccos(np.sqrt(q_exp))
jobs_ids = []
for j in range(0,N):
qr = QuantumRegister(5); qc = QuantumCircuit(qr)
# prepara xi
qc.u(th_xi[j],0,0,qr[1])
qc.cx(qr[1],qr[2])
qc.h([qr[1],qr[2]])
# prepara eta
qc.u(th_eta[j],0,0,qr[3])
qc.cx(qr[3],qr[4])
qc.h([qr[3],qr[4]])
# tomografia
qstc = state_tomography_circuits(qc, [qr[1],qr[2]])
job_exp = qiskit.execute(qstc, backend = device, shots=nshots)
jobs_ids.append(job_exp.job_id())
print(job_exp.job_id())
job_monitor(job_exp)
print(jobs_ids)
f = open("jobs_ids_ES_pre_bbm.txt", "w")
f.write(str(jobs_ids))
f.close()
f = open("jobs_ids_ES_pre_bbm.txt","r")
#jobs_ids_list = f.read()
list_ids = f.read().replace("'","").replace(" ","").replace("[","").replace("]","").split(",")
f.close()
list_ids[0]
print(list_ids)
print(jobs_ids_list)
len_ids = len('6368049443e1f0708afdaf73')
print(len_ids)
list_ids = []
for j in range(0,N):
s = 0
if j > 0:
s = 2
print(jobs_ids_list[(j*(len_ids+2+s)+2):(j+1)*(len_ids+2)+j*s])
list_ids.append(jobs_ids_list[(j*(len_ids+2+s)+2):(j+1)*(len_ids+2)+j*s])
list_ids[0]
q_exp = np.arange(0,1.1,0.1); N = len(q_exp)
E_exp_10 = np.zeros(N); C_exp_0 = np.zeros(N); P_exp_0 = np.zeros(N)
for j in range(0,N):
job = device.retrieve_job(list_ids[j])
qstf_exp = StateTomographyFitter(job.result(), qstc)
rho_10_exp = qstf_exp.fit(method='lstsq');
E_exp_10[j] = Econc_(rho_10_exp)
print(E_exp_10[j])
rho_0_exp = pTraceL_num(2, 2, rho_10_exp)
C_exp_0[j] = coh_l1(rho_0_exp)
P_exp[j] = predict_jb(rho_0_exp)
import matplotlib
matplotlib.rcParams.update({'font.size':11}); plt.figure(figsize = (7,5), dpi = 100)
q = np.arange(0,1.01,0.01)
Ei2 = 4*q*(1-q)
Ci2 = (2*q-1)**2
Pi2 = np.zeros(len(q))
Pm = 1-2*q*(1-q)
plt.plot(q, Ei2, '-', label=r'$E_{conc}(\xi_{AC})^2$')
plt.plot(q, Ci2, '--', label=r'$C_{l_1}(\xi_C)^2$')
plt.plot(q, Pi2, '-.', label=r'$P(\xi_C)^2$')
plt.plot(q, Ei2+Ci2, ':', label=r'$E_{conc}(\xi_{AC})^{2}+C_{l_{1}}(\xi_{C})^{2}+P(\xi_C)^2$')
plt.plot(q_exp, E_sim_10**2, 'X', label=r'$E_{conc}(\xi_{AC})^2_{sim}$')
plt.plot(q_exp, C_sim_0**2, 'h', label=r'$C_{l_1}(\xi_C)^2_{sim}$')
plt.plot(q_exp, P_sim_0**2, '>', label=r'$P(\xi_C)^2_{sim}$')
plt.plot(q_exp, E_sim_10**2+C_sim_0**2+P_sim_0**2, '*', label=r'$E_{conc}(\xi_{AC})^{2}_{sim}+C_{l_{1}}(\xi_{C})^{2}_{sim}+P(\xi_C)^2_{sim}$')
plt.plot(q_exp, E_exp_10**2, 's', label=r'$E_{conc}(\xi_{AC})^2_{exp}$')
plt.plot(q_exp, C_exp_0**2, 'o', label=r'$C_{l_1}(\xi_C)^2_{exp}$')
plt.plot(q_exp, P_exp_0**2, 'v', label=r'$P(\xi_C)^2_{exp}$')
plt.plot(q_exp, E_exp_10**2+C_exp_0**2+P_exp_0**2, 'd', label=r'$E_{conc}(\xi_{AC})^{2}_{exp}+C_{l_{1}}(\xi_{C})^{2}_{exp}+P(\xi_C)^2_{exp}$')
plt.legend(bbox_to_anchor=(1.75, 1.0), loc='upper right')
plt.xlabel(r'$q$')
plt.show()
# error mitigation
qr = QuantumRegister(5); qubit_list = [1,2]
meas_calibs, state_labels = complete_meas_cal(qubit_list = qubit_list, qr = qr)
job = qiskit.execute(meas_calibs, backend = device, shots = nshots)
print(job.job_id())
job_monitor(job)
job = device.retrieve_job('636d895d04e46a1feb6227a9')
meas_fitter = CompleteMeasFitter(job.result(), state_labels)
q_exp = np.arange(0,1.1,0.1); N = len(q_exp)
for j in range(0,N):
job = device.retrieve_job(list_ids[j])
mitigated_results = meas_fitter.filter.apply(job.result())
qstf_exp = StateTomographyFitter(mitigated_results, qstc)
rho_10_exp = qstf_exp.fit(method='lstsq');
E_exp_10[j] = Econc_(rho_10_exp)
print(E_exp_10[j])
rho_0_exp = pTraceL_num(2, 2, rho_10_exp)
C_exp_0[j] = coh_l1(rho_0_exp)
P_exp[j] = predict_jb(rho_0_exp)
import matplotlib
matplotlib.rcParams.update({'font.size':11}); plt.figure(figsize = (7,5), dpi = 100)
q = np.arange(0,1.01,0.01)
Ei2 = 4*q*(1-q)
Ci2 = (2*q-1)**2
Pi2 = np.zeros(len(q))
Pm = 1-2*q*(1-q)
plt.plot(q, Ei2, '-', label=r'$E_{conc}(\xi_{AC})^2$')
plt.plot(q, Ci2, '--', label=r'$C_{l_1}(\xi_C)^2$')
plt.plot(q, Pi2, '-.', label=r'$P(\xi_C)^2$')
plt.plot(q, Ei2+Ci2, ':', label=r'$E_{conc}(\xi_{AC})^{2}+C_{l_{1}}(\xi_{C})^{2}+P(\xi_C)^2$')
plt.plot(q_exp, E_sim_10**2, 'X', label=r'$E_{conc}(\xi_{AC})^2_{sim}$')
plt.plot(q_exp, C_sim_0**2, 'h', label=r'$C_{l_1}(\xi_C)^2_{sim}$')
plt.plot(q_exp, P_sim_0**2, '>', label=r'$P(\xi_C)^2_{sim}$')
plt.plot(q_exp, E_sim_10**2+C_sim_0**2+P_sim_0**2, '*', label=r'$E_{conc}(\xi_{AC})^{2}_{sim}+C_{l_{1}}(\xi_{C})^{2}_{sim}+P(\xi_C)^2_{sim}$')
plt.plot(q_exp, E_exp_10**2, '^', label=r'$E_{conc}(\xi_{AC})^2_{exp}$')
plt.plot(q_exp, C_exp_0**2, 'o', label=r'$C_{l_1}(\xi_C)^2_{exp}$')
plt.plot(q_exp, P_exp_0**2, '.', label=r'$P(\xi_C)^2_{exp}$')
plt.plot(q_exp, E_exp_10**2+C_exp_0**2+P_exp_0**2, 'd', label=r'$E_{conc}(\xi_{AC})^{2}_{exp}+C_{l_{1}}(\xi_{C})^{2}_{exp}+P(\xi_C)^2_{exp}$')
plt.legend(bbox_to_anchor=(1.75, 1.0), loc='upper right')
plt.xlabel(r'$q$')
plt.savefig('fig_Eswap_pre_bbm.pdf')
plt.show()
qc.draw(output='mpl')
def pTrace_3_num(rho_abc, da, db, dc):
rho_ac = np.zeros(da*dc*da*dc, dtype=complex).reshape(da*dc,da*dc)
for j in range(0,da):
for l in range(0,dc):
cj = j*dc+l
ccj = j*db*dc+l
for m in range(0,da):
for o in range(0,dc):
ck = m*dc+o
cck = m*db*dc+o
for k in range(0,db):
rho_ac[cj,ck] = rho_ac[cj,ck] + rho_abc[ccj+k*dc,cck+k*dc]
return rho_ac
import numpy as np
import math
# projetores para a pos-seleção
I2 = np.array([[1,0],[0,1]], dtype=complex)
P00 = np.kron(np.kron(I2,np.array([[1,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],dtype=complex)), I2) # PhiP
P01 = np.kron(np.kron(I2,np.array([[0,0,0,0],[0,1,0,0],[0,0,0,0],[0,0,0,0]],dtype=complex)), I2) # PsiP
P10 = np.kron(np.kron(I2,np.array([[0,0,0,0],[0,0,0,0],[0,0,1,0],[0,0,0,0]],dtype=complex)), I2) # PhiM
P11 = np.kron(np.kron(I2,np.array([[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,1]],dtype=complex)), I2) # PsiM
#P00+P01+P10+P11
q_exp = np.arange(0,1.1,0.1); N = len(q_exp)
q_exp[0] = 0.03; q_exp[N-1] = 1-q_exp[0]
th_xi = np.zeros(N); th_xi = 2*np.arccos(np.sqrt(1-q_exp))
th_eta = np.zeros(N); th_eta = 2*np.arccos(np.sqrt(q_exp))
E_phiP_04_sim = np.zeros(N); E_psiM_04_sim = np.zeros(N)
E_psiP_04_sim = np.zeros(N); E_phiM_04_sim = np.zeros(N)
C2_sim = np.zeros(N)
for j in range(0,N):
qr = QuantumRegister(5); qc = QuantumCircuit(qr)
# prepara xi
qc.u(th_xi[j],0,0,qr[0])
qc.cx(qr[0],qr[1])
qc.h([qr[0],qr[1]])
# prepara eta
qc.u(th_eta[j],0,0,qr[3])
qc.cx(qr[3],qr[4])
qc.h([qr[3],qr[4]])
# BBM
qc.cx(qr[1],qr[3])
qc.h(qr[1])
# circuito para tomografia
qstc = state_tomography_circuits(qc, [qr[4],qr[3],qr[1],qr[0]])
# Simulacao
job_sim = qiskit.execute(qstc, backend = simulator, shots=nshots)
qstf_sim = StateTomographyFitter(job_sim.result(), qstc)
rho_4310_sim = qstf_sim.fit(method='lstsq')
# pos-selecao
rho_PhiP = P00@rho_4310_sim@P00
pr_phiP = np.real(np.trace(rho_PhiP))
rho_PhiP = (1/pr_phiP)*rho_PhiP
rho_PsiP = P01@rho_4310_sim@P01
pr_psiP = np.real(np.trace(rho_PsiP))
rho_PsiP = (1/pr_psiP)*rho_PsiP
rho_PhiM = P10@rho_4310_sim@P10
pr_phiM = np.real(np.trace(rho_PhiM))
rho_PhiM = (1/pr_phiM)*rho_PhiM
rho_PsiM = P11@rho_4310_sim@P11
pr_psiM = np.real(np.trace(rho_PsiM))
rho_PsiM = (1/pr_psiM)*rho_PsiM
# estados reduzidos
rho_PhiP_04 = pTrace_3_num(rho_PhiP,2,4,2)
rho_PsiP_04 = pTrace_3_num(rho_PsiP,2,4,2)
rho_PhiM_04 = pTrace_3_num(rho_PhiM,2,4,2)
rho_PsiM_04 = pTrace_3_num(rho_PsiM,2,4,2)
# emaranhamentos e probabilidades
E_phiP_04_sim[j] = Econc_(rho_PhiP_04)
E_phiM_04_sim[j] = Econc_(rho_PhiM_04)
E_psiP_04_sim[j] = Econc_(rho_PsiP_04)
E_psiM_04_sim[j] = Econc_(rho_PsiM_04)
C2_sim[j] = 1 - 2*(pr_phiP+pr_psiP)
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
device = provider.get_backend('ibmq_manila')
q_exp = np.arange(0,1.1,0.1); N = len(q_exp)
q_exp[0] = 0.03; q_exp[N-1] = 1-q_exp[0]
th_xi = np.zeros(N); th_xi = 2*np.arccos(np.sqrt(1-q_exp))
th_eta = np.zeros(N); th_eta = 2*np.arccos(np.sqrt(q_exp))
#jobs_ids2 = []
for j in range(N-1,N):
qr = QuantumRegister(5); qc = QuantumCircuit(qr)
# prepara xi
qc.u(th_xi[j],0,0,qr[1])
qc.cx(qr[1],qr[2])
qc.h([qr[1],qr[2]])
# prepara eta
qc.u(th_eta[j],0,0,qr[3])
qc.cx(qr[3],qr[4])
qc.h([qr[3],qr[4]])
# BBM
qc.cx(qr[2],qr[3])
qc.h(qr[2])
# circuito para tomografia
qstc = state_tomography_circuits(qc, [qr[4],qr[3],qr[2],qr[1]])
# Experimento
job_exp = qiskit.execute(qstc, backend = device, shots=nshots)
#jobs_ids2.append(job_exp.job_id())
print(job_exp.job_id())
job_monitor(job_exp)
jobs_ids2.append('636e2c8910cc1925ad755b77')
qc.draw(output='mpl')
f = open("jobs_ids_ES_post_bbm.txt", "w")
f.write(str(jobs_ids2))
f.close()
f = open("jobs_ids_ES_post_bbm.txt","r")
list_ids2 = f.read().replace("'","").replace(" ","").replace("[","").replace("]","").split(",")
f.close()
print(list_ids2)
q_exp = np.arange(0,1.1,0.1); N = len(q_exp)
q_exp[0] = 0.03; q_exp[N-1] = 1-q_exp[0]
E_phiP_04_exp = np.zeros(N); E_psiM_04_exp = np.zeros(N)
E_psiP_04_exp = np.zeros(N); E_phiM_04_exp = np.zeros(N)
C2_exp = np.zeros(N)
for j in range(0,N):
job = device.retrieve_job(list_ids2[j])
qstf_exp = StateTomographyFitter(job.result(), qstc)
rho_4310_exp = qstf_exp.fit(method='lstsq')
# pos-selecao
rho_PhiP = P00@rho_4310_exp@P00
pr_phiP = np.real(np.trace(rho_PhiP))
rho_PhiP = (1/pr_phiP)*rho_PhiP
rho_PsiP = P01@rho_4310_exp@P01
pr_psiP = np.real(np.trace(rho_PsiP))
rho_PsiP = (1/pr_psiP)*rho_PsiP
rho_PhiM = P10@rho_4310_exp@P10
pr_phiM = np.real(np.trace(rho_PhiM))
rho_PhiM = (1/pr_phiM)*rho_PhiM
rho_PsiM = P11@rho_4310_exp@P11
pr_psiM = np.real(np.trace(rho_PsiM))
rho_PsiM = (1/pr_psiM)*rho_PsiM
# estados reduzidos
rho_PhiP_04 = pTrace_3_num(rho_PhiP,2,4,2)
rho_PsiP_04 = pTrace_3_num(rho_PsiP,2,4,2)
rho_PhiM_04 = pTrace_3_num(rho_PhiM,2,4,2)
rho_PsiM_04 = pTrace_3_num(rho_PsiM,2,4,2)
# emaranhamentos e probabilidades
E_phiP_04_exp[j] = Econc_(rho_PhiP_04)
E_phiM_04_exp[j] = Econc_(rho_PhiM_04)
E_psiP_04_exp[j] = Econc_(rho_PsiP_04)
E_psiM_04_exp[j] = Econc_(rho_PsiM_04)
C2_exp[j] = 1 - 2*(pr_phiP+pr_psiP)
print(C2_exp[j])
import matplotlib
from matplotlib import pyplot as plt
matplotlib.rcParams.update({'font.size':11}); plt.figure(figsize = (6,4), dpi = 100)
q = np.arange(0,1.01,0.01)
Ep = np.ones(len(q)); Em = (2*q*(1-q))/(1-2*q+2*q**2); C2 = 1-4*q*(1-q)
plt.plot(q, Ep, '-', label=r'$E(\hat{\phi}_+)=E(\hat{\psi}_+)$')
plt.plot(q, Em, '--', label=r'$E(\hat{\phi}_-)=E(\hat{\psi}_-)$')
plt.plot(q, C2, '-.', label=r'$1-2(Pr(\hat{\phi}_+)+Pr(\hat{\psi}_+))$')
plt.plot(q_exp, E_phiP_04_sim, 'o', label=r'$E(\hat{\phi}_+)_{sim}$')
plt.plot(q_exp, E_phiM_04_sim, '*', label=r'$E(\hat{\phi}_-)_{sim}$')
#plt.plot(q_exp, E_psiP_04_sim, 'X', label=r'$E(\hat{\psi}_+)_{sim}$')
#plt.plot(q_exp, E_psiM_04_sim, '.', label=r'$E(\hat{\psi}_-)_{sim}$')
plt.plot(q_exp, C2_sim, 'X', label=r'$1-2(Pr(\hat{\phi}_+)_{sim}+Pr(\hat{\psi}_+)_{sim})$')
plt.plot(q_exp, E_phiP_04_exp, '<', label=r'$E(\hat{\phi}_+)_{exp}$')
plt.plot(q_exp, E_phiM_04_exp, '>', label=r'$E(\hat{\phi}_-)_{exp}$')
#plt.plot(q_exp, E_psiP_04_exp, '^', label=r'$E(\hat{\psi}_+)_{exp}$')
#plt.plot(q_exp, E_psiM_04_exp, '.', label=r'$E(\hat{\psi}_-)_{exp}$')
plt.plot(q_exp, C2_exp, '^', label=r'$1-2(Pr(\hat{\phi}_+)_{exp}+Pr(\hat{\psi}_+)_{exp})$')
plt.xlabel(r'$q$')
plt.legend(bbox_to_anchor=(1.8, 1.0), loc='upper right')
plt.show()
# error mitigation
qr = QuantumRegister(5)#; qc = QuantumCircuit(qr)
qubit_list = [1,2,3,4]
meas_calibs, state_labels = complete_meas_cal(qubit_list = qubit_list, qr = qr)
job = qiskit.execute(meas_calibs, backend = device, shots = nshots)
print(job.job_id())
job_monitor(job)
job = device.retrieve_job('636e3407fb0a57272187586a')
meas_fitter = CompleteMeasFitter(job.result(), state_labels)
q_exp = np.arange(0,1.1,0.1); N = len(q_exp)
q_exp[0] = 0.03; q_exp[N-1] = 1-q_exp[0]
E_phiP_04_exp = np.zeros(N); E_psiM_04_exp = np.zeros(N)
E_psiP_04_exp = np.zeros(N); E_phiM_04_exp = np.zeros(N)
C2_exp = np.zeros(N)
for j in range(0,N):
job = device.retrieve_job(list_ids2[j])
mitigated_results = meas_fitter.filter.apply(job.result()) # error mitigation
qstf_exp = StateTomographyFitter(mitigated_results, qstc) # error mitigation
rho_4310_exp = qstf_exp.fit(method='lstsq')
# pos-selecao
rho_PhiP = P00@rho_4310_exp@P00
pr_phiP = np.real(np.trace(rho_PhiP))
rho_PhiP = (1/pr_phiP)*rho_PhiP
rho_PsiP = P01@rho_4310_exp@P01
pr_psiP = np.real(np.trace(rho_PsiP))
rho_PsiP = (1/pr_psiP)*rho_PsiP
rho_PhiM = P10@rho_4310_exp@P10
pr_phiM = np.real(np.trace(rho_PhiM))
rho_PhiM = (1/pr_phiM)*rho_PhiM
rho_PsiM = P11@rho_4310_exp@P11
pr_psiM = np.real(np.trace(rho_PsiM))
rho_PsiM = (1/pr_psiM)*rho_PsiM
# estados reduzidos
rho_PhiP_04 = pTrace_3_num(rho_PhiP,2,4,2)
rho_PsiP_04 = pTrace_3_num(rho_PsiP,2,4,2)
rho_PhiM_04 = pTrace_3_num(rho_PhiM,2,4,2)
rho_PsiM_04 = pTrace_3_num(rho_PsiM,2,4,2)
# emaranhamentos e probabilidades
E_phiP_04_exp[j] = Econc_(rho_PhiP_04)
E_phiM_04_exp[j] = Econc_(rho_PhiM_04)
E_psiP_04_exp[j] = Econc_(rho_PsiP_04)
E_psiM_04_exp[j] = Econc_(rho_PsiM_04)
C2_exp[j] = 1 - 2*(pr_phiP+pr_psiP)
print(C2_exp[j])
import matplotlib
from matplotlib import pyplot as plt
matplotlib.rcParams.update({'font.size':11}); plt.figure(figsize = (6,4), dpi = 100)
q = np.arange(0,1.01,0.01)
Ep = np.ones(len(q)); Em = (2*q*(1-q))/(1-2*q+2*q**2); C2 = 1-4*q*(1-q)
plt.plot(q, Ep, '-', label=r'$E(\hat{\phi}_+)=E(\hat{\psi}_+)$')
plt.plot(q, Em, '--', label=r'$E(\hat{\phi}_-)=E(\hat{\psi}_-)$')
plt.plot(q, C2, '-.', label=r'$1-2(Pr(\hat{\phi}_+)+Pr(\hat{\psi}_+))$')
plt.plot(q_exp, E_phiP_04_sim, 'o', label=r'$E(\hat{\phi}_+)_{sim}$')
plt.plot(q_exp, E_phiM_04_sim, '*', label=r'$E(\hat{\phi}_-)_{sim}$')
#plt.plot(q_exp, E_psiP_04_sim, 'X', label=r'$E(\hat{\psi}_+)_{sim}$')
#plt.plot(q_exp, E_psiM_04_sim, '.', label=r'$E(\hat{\psi}_-)_{sim}$')
plt.plot(q_exp, C2_sim, 'X', label=r'$1-2(Pr(\hat{\phi}_+)_{sim}+Pr(\hat{\psi}_+)_{sim})$')
plt.plot(q_exp, E_phiP_04_exp, '<', label=r'$E(\hat{\phi}_+)_{exp}$')
plt.plot(q_exp, E_phiM_04_exp, '>', label=r'$E(\hat{\phi}_-)_{exp}$')
#plt.plot(q_exp, E_psiP_04_exp, '^', label=r'$E(\hat{\psi}_+)_{exp}$')
#plt.plot(q_exp, E_psiM_04_exp, '.', label=r'$E(\hat{\psi}_-)_{exp}$')
plt.plot(q_exp, C2_exp, '^', label=r'$1-2(Pr(\hat{\phi}_+)_{exp}+Pr(\hat{\psi}_+)_{exp})$')
plt.xlabel(r'$q$')
plt.legend(bbox_to_anchor=(1.8, 1.0), loc='upper right')
plt.savefig('fig_Eswap_post_bbm.pdf')
plt.show()
C = np.arange(0,1.1,0.1);
E_PhiP = (1-C**2)/(1+C**2)
E_PhiM = np.ones(len(C))
plt.plot(C, E_PhiP, '*'); plt.plot(C, E_PhiM, '.')
plt.show()
from qiskit import *
qr = QuantumRegister(4);
%run init.ipynb
p,q = symbols('p q')
ket_xi = Matrix([[sqrt(p)],[sqrt((1-p)/2)],[sqrt((1-p)/2)],[0]])
ket_eta = Matrix([[sqrt(q)],[sqrt((1-q)/2)],[sqrt((1-q)/2)],[0]])
ket_xi, ket_eta
rho_xi = ket_xi*ket_xi.T
rho_eta = ket_eta*ket_eta.T
rho_xi, rho_eta
def ptraceA(da, db, rho):
rhoB = zeros(db,db)
for j in range(0, db):
for k in range(0, db):
for l in range(0, da):
rhoB[j,k] += rho[l*db+j,l*db+k]
return rhoB
def ptraceB(da, db, rho):
rhoA = zeros(da,da)
for j in range(0, da):
for k in range(0, da):
for l in range(0, db):
rhoA[j,k] += rho[j*db+l,k*db+l]
return rhoA
rho_xi_A = ptraceB(2,2,rho_xi); rho_xi_C = ptraceA(2,2,rho_xi)
rho_xi_A, rho_xi_C
rho_eta_Cp = ptraceB(2,2,rho_eta); rho_eta_B = ptraceA(2,2,rho_eta)
rho_eta_Cp, rho_eta_B
c00,c01,c10,c11 = symbols('c_{00} c_{01} c_{10} c_{11}')
d00,d01,d10,d11 = symbols('d_{00} d_{01} d_{10} d_{11}')
def two_qb_basis():
zz = Matrix([[1],[0],[0],[0]])
zu = Matrix([[0],[1],[0],[0]])
uz = Matrix([[0],[0],[1],[0]])
uu = Matrix([[0],[0],[0],[1]])
return zz,zu,uz,uu
zz,zu,uz,uu = two_qb_basis(); zz,zu,uz,uu
def psi_p(c00,c01,c10,c11,d00,d01,d10,d11):
zz,zu,uz,uu = two_qb_basis()
psi = (c00*d00+c01*d10)*zz + (c00*d01+c01*d11)*zu + (c10*d00+c11*d10)*uz + (c10*d01+c11*d11)*uu
return psi/sqrt(2)
def psi_m(c00,c01,c10,c11,d00,d01,d10,d11):
zz,zu,uz,uu = two_qb_basis()
psi = (c00*d00-c01*d10)*zz + (c00*d01-c01*d11)*zu + (c10*d00-c11*d10)*uz + (c10*d01-c11*d11)*uu
return psi/sqrt(2)
def phi_p(c00,c01,c10,c11,d00,d01,d10,d11):
zz,zu,uz,uu = two_qb_basis()
psi = (c00*d10+c01*d00)*zz + (c00*d11+c01*d01)*zu + (c10*d10+c11*d00)*uz + (c10*d11+c11*d01)*uu
return psi/sqrt(2)
def phi_m(c00,c01,c10,c11,d00,d01,d10,d11):
zz,zu,uz,uu = two_qb_basis()
psi = (c00*d10-c01*d00)*zz + (c00*d11-c01*d01)*zu + (c10*d10-c11*d00)*uz + (c10*d11-c11*d01)*uu
return psi/sqrt(2)
c00 = sqrt(p); c01 = sqrt((1-p)/2); c10 = sqrt((1-p)/2); c11 = 0
d00 = sqrt(q); d01 = sqrt((1-q)/2); d10 = sqrt((1-q)/2); d11 = 0
psip = psi_p(c00,c01,c10,c11,d00,d01,d10,d11);
psim = psi_m(c00,c01,c10,c11,d00,d01,d10,d11)
phip = phi_p(c00,c01,c10,c11,d00,d01,d10,d11);
phim = phi_m(c00,c01,c10,c11,d00,d01,d10,d11)
simplify(psip), simplify(psim), simplify(phip), simplify(phim)
psip_norm2 = psip.T*psip; simplify(psip_norm2)
psim_norm2 = psim.T*psim; simplify(psim_norm2)
phip_norm2 = phip.T*phip; simplify(phip_norm2)
phim_norm2 = phim.T*phim; simplify(phim_norm2)
|
https://github.com/abbarreto/qiskit3
|
abbarreto
|
0.4*7.6
|
https://github.com/abbarreto/qiskit3
|
abbarreto
|
from qiskit_ibm_runtime import QiskitRuntimeService
# Save an IBM Quantum account.
QiskitRuntimeService.save_account(channel='ibm_quantum',
#channel='ibm_cloud',
token='17efde49764005e8eeb00dd065d44bc208778be72d44b475e508d20504818786f842988b0e506515c78debdd1b0c4b570717863db5e4f85569fb43c4c8626b8a',
overwrite=True)
service = QiskitRuntimeService(
channel='ibm_quantum',
instance='ibm-q/open/main'
#instance='ibm-q-research-2/federal-uni-sant-1/main'
)
program_inputs = {'iterations': 1}
options = {"backend_name": "ibmq_qasm_simulator"}
job = service.run(program_id="hello-world",
options=options,
inputs=program_inputs
)
#print(f"job id: {job.job_id()}")
result = job.result()
print(result)
backend = service.get_backend("ibmq_qasm_simulator")
from qiskit.circuit.random import random_circuit
from qiskit.quantum_info import SparsePauliOp
from qiskit.primitives import Estimator
from qiskit import QuantumCircuit
#circuit = random_circuit(2, 2, seed=1).decompose(reps=1)
circuit = QuantumCircuit(2)
circuit.x(0)
circuit.draw(output='mpl')
observable = SparsePauliOp("IZ") # ordem ...210
#options = {"backend_name": "ibmq_qasm_simulator"}
estimator = Estimator()#options=options)
job = estimator.run(circuit, observable)
result = job.result()
display(circuit.draw("mpl"))
print(f" > Observable: {observable.paulis}")
print(f" > Expectation value: {result.values[0]}")
print(f" > Metadata: {result.metadata[0]}")
import math
qc1 = QuantumCircuit(2); qc2 = QuantumCircuit(2)
qc1.h(1)
qc2.h(0); qc2.p(-math.pi/2, 0)
circuits = (
#random_circuit(2, 2, seed=0).decompose(reps=1),
#random_circuit(2, 2, seed=1).decompose(reps=1),
qc1, qc2
)
observables = (
SparsePauliOp("XZ"),
SparsePauliOp("IY"),
)
estimator = Estimator()
job = estimator.run(circuits, observables)
result = job.result()
[display(cir.draw("mpl")) for cir in circuits]
print(f" > Observables: {[obs.paulis for obs in observables]}")
print(f" > Expectation values: {result.values.tolist()}")
print(f" > Metadata: {result.metadata}")
circuits = (
random_circuit(2, 2, seed=0).decompose(reps=1),
random_circuit(2, 2, seed=1).decompose(reps=1),
)
observables = (
SparsePauliOp("XZ"),
SparsePauliOp("IY"),
)
estimator = Estimator()
job_0 = estimator.run(circuits[0], observables[0])
job_1 = estimator.run(circuits[1], observables[1])
result_0 = job_0.result()
result_1 = job_1.result()
[display(cir.draw("mpl")) for cir in circuits]
print(f" > Observables: {[obs.paulis for obs in observables]}")
print(f" > Expectation values [0]: {result_0.values.tolist()[0]}")
print(f" > Metadata [0]: {result_0.metadata[0]}")
print(f" > Expectation values [1]: {result_1.values.tolist()[0]}")
print(f" > Metadata [1]: {result_1.metadata[0]}")
from qiskit.circuit.library import RealAmplitudes
circuit = RealAmplitudes(num_qubits=2, reps=2).decompose(reps=1)
observable = SparsePauliOp("ZI")
parameter_values = [0, 1, 2, 3, 4, 5]
estimator = Estimator()
job = estimator.run(circuit, observable, parameter_values)
result = job.result()
display(circuit.draw("mpl"))
print(f" > Observable: {observable.paulis}")
print(f" > Parameter values: {parameter_values}")
print(f" > Expectation value: {result.values}")
print(f" > Metadata: {result.metadata[0]}")
circuit = RealAmplitudes(num_qubits=2, reps=1).decompose(reps=1)
display(circuit.draw("mpl"))
from qiskit.circuit.random import random_circuit
from qiskit.quantum_info import SparsePauliOp
from qiskit_ibm_runtime import QiskitRuntimeService, Session, Estimator, Options
circuit = random_circuit(2, 2, seed=1).decompose(reps=1)
observable = SparsePauliOp("IY")
options = Options()
options.optimization_level = 2
options.resilience_level = 2
service = QiskitRuntimeService()
with Session(service=service, backend="ibmq_qasm_simulator") as session:
estimator = Estimator(session=session, options=options)
job = estimator.run(circuit, observable)
result = job.result()
display(circuit.draw("mpl"))
print(f" > Observable: {observable.paulis}")
print(f" > Expectation value: {result.values[0]}")
print(f" > Metadata: {result.metadata[0]}")
from qiskit.circuit.random import random_circuit
from qiskit.quantum_info import SparsePauliOp
from qiskit_ibm_runtime import QiskitRuntimeService, Session, Estimator, Options
circuit = random_circuit(2, 2, seed=1).decompose(reps=1)
observable = SparsePauliOp("IY")
options = Options()
options.optimization_level = 2
options.resilience_level = 2
service = QiskitRuntimeService()
with Session(service=service, backend="ibmq_belem") as session:
estimator = Estimator(session=session, options=options)
job = estimator.run(circuit, observable)
result = job.result()
display(circuit.draw("mpl"))
print(f" > Observable: {observable.paulis}")
print(f" > Expectation value: {result.values[0]}")
print(f" > Metadata: {result.metadata[0]}")
from qiskit_ibm_runtime import Session, Options
circuit = random_circuit(2, 2, seed=1).decompose(reps=1)
observable = SparsePauliOp("IY")
options = Options()
options.optimization_level = 2
options.resilience_level = 2
service = QiskitRuntimeService()
backend = service.get_backend("ibmq_belem")
with Session(service=service, backend=backend):
estimator = Estimator()
job = estimator.run(circuit, observable)
result = job.result()
display(circuit.draw("mpl"))
print(f" > Observable: {observable.paulis}")
print(f" > Expectation value: {result.values[0]}")
print(f" > Metadata: {result.metadata[0]}")
from qiskit.circuit.random import random_circuit
from qiskit.primitives import Sampler
circuit = random_circuit(2, 2, seed=1).decompose(reps=1)
circuit.measure_all()
sampler = Sampler()
job = sampler.run(circuit)
result = job.result()
display(circuit.draw("mpl"))
print(f" > Quasi probability distribution: {result.quasi_dists[0]}")
#print(f" > Metadata: {result.metadata[0]}")
#print(result.quasi_dists,result.quasi_dists[0][1])
print(result.quasi_dists[0][0]+result.quasi_dists[0][1]+result.quasi_dists[0][2]+result.quasi_dists[0][3])
from qiskit.circuit.random import random_circuit
from qiskit.primitives import Sampler
circuits = (
random_circuit(2, 2, seed=0).decompose(reps=1),
random_circuit(2, 2, seed=1).decompose(reps=1),
)
[c.measure_all() for c in circuits]
sampler = Sampler()
job = sampler.run(circuits)
result = job.result()
[display(cir.draw("mpl")) for cir in circuits]
print(f" > Quasi probability distributions: {result.quasi_dists}")
#print(f" > Metadata: {result.metadata}")
from qiskit.circuit.library import RealAmplitudes
# RealAmplitudes is one way to generate a parametrized circuit
from qiskit.primitives import Sampler
circuit = RealAmplitudes(num_qubits=2, reps=2).decompose(reps=1)
circuit.measure_all()
parameter_values = [0, 1, 2, 3, 4, 5]
sampler = Sampler()
job = sampler.run(circuit, parameter_values)
result = job.result()
display(circuit.draw("mpl"))
print(f" > Parameter values: {parameter_values}")
print(f" > Quasi probability distribution: {result.quasi_dists[0]}")
print(f" > Metadata: {result.metadata[0]}")
from qiskit.circuit.random import random_circuit
from qiskit_ibm_runtime import QiskitRuntimeService, Session, Sampler, Options
backend = service.get_backend("ibmq_qasm_simulator")
circuit = random_circuit(2, 2, seed=2).decompose(reps=1)
circuit.measure_all()
options = Options()
options.optimization_level = 2
options.resilience_level = 0
service = QiskitRuntimeService()
with Session(service=service, backend=backend):
sampler = Sampler()
job = sampler.run(circuit)
result = job.result()
display(circuit.draw("mpl"))
print(f" > Quasi probability distribution: {result.quasi_dists[0]}")
print(f" > Metadata: {result.metadata[0]}")
from qiskit.circuit.random import random_circuit
from qiskit_ibm_runtime import QiskitRuntimeService, Session, Sampler, Options
backend = service.get_backend("ibmq_quito")
circuit = random_circuit(2, 2, seed=2).decompose(reps=1)
circuit.measure_all()
options = Options()
options.optimization_level = 2
options.resilience_level = 0
service = QiskitRuntimeService()
with Session(service=service, backend=backend):
sampler = Sampler()
job = sampler.run(circuit)
print(job.job_id())
result = job.result()
display(circuit.draw("mpl"))
print(f" > Quasi probability distribution: {result.quasi_dists[0]}")
print(f" > Metadata: {result.metadata[0]}")
|
https://github.com/abbarreto/qiskit3
|
abbarreto
|
%run init.ipynb
# tem algum problema com a funcao produto tensorial do sympy (implementar eu mesmo ...)
k000 = Matrix([1,0,0,0,0,0,0,0]); k001 = Matrix([0,1,0,0,0,0,0,0])
k010 = Matrix([0,0,1,0,0,0,0,0]); k011 = Matrix([0,0,0,1,0,0,0,0])
k100 = Matrix([0,0,0,0,1,0,0,0]); k101 = Matrix([0,0,0,0,0,1,0,0])
k110 = Matrix([0,0,0,0,0,0,1,0]); k111 = Matrix([0,0,0,0,0,0,0,1])
#k000,k001,k010,k011,k100,k101,k110,k111, k001*k001.T
p = symbols('p')
#p = 0
Psi0 = sqrt((4-3*p)/4)*k000 + sqrt(p/4)*(k101+k010+k111)
Psi1 = sqrt((4-3*p)/4)*k100 + sqrt(p/4)*(k001-k110-k011)
#Psi0.T, Psi1.T
r00,r01,r10,r11 = symbols('r_{00} r_{01} r_{10} r_{11}')
rhoA = Matrix([[r00,r01],[r10,r11]]); rhoA, rhoA[0,0]
#rhoA = Matrix([[2/3,1/3],[1/3,1/3]]); #rhoA, rhoA[0,0]
def rhoABt_s(rhoA,p):
Psi0 = sqrt((4-3*p)/4)*k000 + sqrt(p/4)*(k101+k010+k111)
Psi1 = sqrt((4-3*p)/4)*k100 + sqrt(p/4)*(k001-k110-k011)
return rhoA[0,0]*Psi0*Psi0.T + rhoA[0,1]*Psi0*Psi1.T + rhoA[1,0]*Psi1*Psi0.T + rhoA[1,1]*Psi1*Psi1.T
rhoABt_ = rhoABt_s(rhoA,p); rhoABt_
# não foi possivel diagonalizar com sympy
def ptraceB(da, db, rho):
rhoA = zeros(da,da)
for j in range(0, da):
for k in range(0, da):
for l in range(0, db):
rhoA[j,k] += rho[j*db+l,k*db+l]
return rhoA
rhoAt = ptraceB(2, 4, rhoABt_); simplify(rhoAt) # ok!
rhoA = Matrix([[2/3,1/3],[1/3,1/3]])
p = np.arange(0,1.1,0.1); N = len(p)
Cl1 = np.zeros(N); Pjb = np.zeros(N)
for j in range(0,N):
rhoABt_ = rhoABt_s(rhoA,p[j])
rhoA_ = ptraceB(2, 4, rhoABt_)
Cl1[j] = coh_l1_s(rhoA_)
Pjb[j] = predict_jb_s(rhoA_)
# calculo feito a partir de rhoAB_til
import matplotlib
matplotlib.rcParams.update({'font.size':12})
plt.figure(figsize = (6,4), dpi = 100)
plt.plot(p,Cl1,label=r'$C_{l_1}$')
plt.plot(p,Pjb,label=r'$P_{jb}$')
plt.xlabel(r'$p$')
plt.legend()
plt.show()
evv = rhoABt.eigenvects(); evv
def tp_vv_s(psi, csi): # tensor product, of vectors, symbolic
M = psi.shape[0]; N = csi.shape[0]
eta = zeros(M*N,1)
for j in range(0,M):
for k in range(0,N):
eta[j*N+k] = psi[j]*csi[k]
return eta
def cb(d,j): # estados da base computacional
v = zeros(d,1)
v[j] = 1
return v
cb(2,0)
def PhiABCt_s(rhoA,p):
rhoABt = rhoABt_s(rhoA,p)
eig = rhoABt.eigenvects()
d = rhoABt.shape[0]; Phi = zeros(d*d,1)
ne = 0; j = 0; l = -1
while ne < d:
mult = eig[j][1]; ne += mult
for k in range(0,mult):
l += 1
Phi += sqrt(abs(eig[j][0]))*tp_vv_s(eig[j][2][k],cb(d,l))
j += 1
for j in range(0,d*d):
if im(Phi[j]) < 10**-5:
Phi[j] = re(Phi[j])
return Phi
def coh_l1_s(rho):
d = rho.shape[0]; C = 0
for j in range(0,d-1):
for k in range(j+1,d):
C += abs(rho[j,k])
return 2*C
def predict_jb_s(rho):
return abs(rho[0,0]-rho[1,1])
def proj_s(psi): # simbolic projector
d = psi.shape[0]
proj = zeros(d,d)
for j in range(0,d):
for k in range(0,d):
proj[j,k] = psi[j]*conjugate(psi[k])
return proj
rhoA = Matrix([[2/3,1/3],[1/3,1/3]])
p = np.arange(0,1.1,0.1); N = len(p)
Cl1 = np.zeros(N); Pjb = np.zeros(N)
for j in range(0,N):
Phi = PhiABCt_s(rhoA,p[j]); PPhi = proj_s(Phi)#; print(PPhi)
rhoA_ = ptraceB(2, 2**5, PPhi)#; print(rhoA_[0,1])
Cl1[j] = coh_l1_s(rhoA_)
Pjb[j] = predict_jb_s(rhoA_)
# calculo feito a partir de PhiABC
import matplotlib
matplotlib.rcParams.update({'font.size':12})
plt.figure(figsize = (6,4), dpi = 100)
plt.plot(p,Cl1,label=r'$C_{l_1}$')
plt.plot(p,Pjb,label=r'$P_{jb}$')
plt.xlabel(r'$p$')
plt.legend()
plt.show()
def rho_AB_til(rhoA,p):
rhoAbc = np.zeros((2**3,2**3), dtype=complex)#; print(rhoAbc)
ket0 = np.array([[1],[0]]); ket1 = np.array([[0],[1]])#; print(ket0,ket1)
ket00 = np.kron(ket0,ket0); ket01 = np.kron(ket0,ket1); ket10 = np.kron(ket1,ket0)
ket11 = np.kron(ket1,ket1); #print(ket00,'',ket01,'',ket10,'',ket11)
ket000 = np.kron(ket0,ket00); ket100 = np.kron(ket1,ket00)
ket001 = np.kron(ket0,ket01); ket101 = np.kron(ket1,ket01)
ket010 = np.kron(ket0,ket10); ket110 = np.kron(ket1,ket10)
ket011 = np.kron(ket0,ket11); ket111 = np.kron(ket1,ket11)
Psi0 = math.sqrt((4-3*p)/4)*ket000 + math.sqrt(p/4)*(ket101+ket010+ket111)
Psi1 = math.sqrt((4-3*p)/4)*ket100 + math.sqrt(p/4)*(ket001-ket110-ket011)
rhoAbc = rhoA[0,0]*Psi0@Psi0.T + rhoA[0,1]*Psi0@Psi1.T\
+ rhoA[1,0]*Psi1@Psi0.T + rhoA[1,1]*Psi1@Psi1.T
return rhoAbc
def pTraceR_num(dl, dr, rhoLR):
rhoL = np.zeros((dl, dl), dtype=complex)
for j in range(0, dl):
for k in range(j, dl):
for l in range(0, dr):
rhoL[j,k] += rhoLR[j*dr+l,k*dr+l]
if j != k:
rhoL[k,j] = np.conj(rhoL[j,k])
return rhoL
rhoA = np.array([[2/3,1/3],[1/3,1/3]]); print(rhoA) # estado inicial
p = 0.
rhoAbc = rho_AB_til(rhoA,p)#; print(rhoAbc)
rhoA_ = pTraceR_num(2, 4, rhoAbc); print(rhoA_)
def coh_l1(rho):
d = rho.shape[0];
#d = rho.dims()[0]
C = 0
for j in range(0,d-1):
for k in range(j+1,d):
C += np.abs(rho[j,k])
return 2*C
def predict_jb(rho):
return abs(rho[0,0]-rho[1,1])
p = np.arange(0,1.1,0.1); #print(p)
N = len(p)#; print(N)
Cl1 = np.zeros(N); Pjb = np.zeros(N)
for j in range(0,N):
rhoAbc = rho_AB_til(rhoA,p[j])
rhoA_ = pTraceR_num(2, 4, rhoAbc)
Cl1[j] = coh_l1(rhoA_)
Pjb[j] = predict_jb(rhoA_)
# calculo feito a partir de rhoAB_til
import matplotlib
matplotlib.rcParams.update({'font.size':12})
plt.figure(figsize = (6,4), dpi = 100)
plt.plot(p,Cl1,label=r'$C_{l_1}$')
plt.plot(p,Pjb,label=r'$P_{jb}$')
plt.xlabel(r'$p$')
plt.legend()
plt.show()
from numpy import linalg
w, v = linalg.eig(rhoAbc)
print(v[0][:])
print(np.shape(v[:][0]))
ket0 = np.array([[1],[0]]); ket1 = np.array([[0],[1]])
ket00 = np.kron(ket0,ket0); ket01 = np.kron(ket0,ket1)
ket10 = np.kron(ket1,ket0); ket11 = np.kron(ket1,ket1)
ket000 = np.kron(ket0,ket00); ket100 = np.kron(ket1,ket00)
ket001 = np.kron(ket0,ket01); ket101 = np.kron(ket1,ket01)
ket010 = np.kron(ket0,ket10); ket110 = np.kron(ket1,ket10)
ket011 = np.kron(ket0,ket11); ket111 = np.kron(ket1,ket11)
p = np.arange(0,1.1,0.1)
N = len(p)
Cl1 = np.zeros(N); Pjb = np.zeros(N)
for j in range(0,N):
rhoAbc = rho_AB_til(rhoA,p[j])
w, v = linalg.eig(rhoAbc); w = np.abs(w)
PhiAbcdef = math.sqrt(w[0])*np.kron(v.T[0],ket000) + math.sqrt(w[1])*np.kron(v.T[1],ket001)\
+ math.sqrt(w[2])*np.kron(v.T[2],ket010) + math.sqrt(w[3])*np.kron(v.T[3],ket011)\
+ math.sqrt(w[4])*np.kron(v.T[4],ket100) + math.sqrt(w[5])*np.kron(v.T[5],ket101)\
+ math.sqrt(w[6])*np.kron(v.T[6],ket110) + math.sqrt(w[7])*np.kron(v.T[7],ket111)
rhoAbcdef = np.outer(PhiAbcdef,np.conj(PhiAbcdef))#; print(np.shape(rhoAbcdef))
rhoA_ = pTraceR_num(2, 2**5, rhoAbcdef); print(rhoA_)#; print(np.shape(rhoA_))
Cl1[j] = coh_l1(rhoA_)
Pjb[j] = predict_jb(rhoA_)
# calculo feito a partir da purificacao rhoAB_til
import matplotlib
matplotlib.rcParams.update({'font.size':12})
plt.figure(figsize = (6,4), dpi = 100)
plt.plot(p,Cl1,label=r'$C_{l_1}$')
plt.plot(p,Pjb,label=r'$P_{jb}$')
plt.xlabel(r'$p$')
plt.legend()
plt.show()
rho_A = Matrix([[2/3,1/3],[1/3,1/3]])
rho_A.eigenvects()
rho_A*Matrix([[0.85],[0.52]])/0.87, rho_A*Matrix([[-0.5257],[0.85]])/0.127
w, v = linalg.eig(rhoA) # os autovetores são as colunas de v
print(w, v, v.T[0], v.T[1], np.shape(v.T[1])) # nao pode usar
import qiskit
from qiskit import *
nshots = 8192
IBMQ.load_account()
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
device = provider.get_backend('ibmq_quito')
simulator = Aer.get_backend('qasm_simulator')
from qiskit.tools.monitor import job_monitor
from qiskit_experiments.library import StateTomography
r00 = 2/3; r01 = 1.33/3; r10 = 1.33/3; r11 = 1/3 # initial state
r = math.sqrt((r00-r11)**2 + abs(2*r01)**2) # raio de Bloch
th = math.acos((r00-r11)/r)
ph = math.acos(re(2*r01)/(r*sin(th))) # angulos de Bloch
r0 = (1+r)/2.; r1 = (1-r)/2. # autovetores
print(r, th, ph, r0, r1)
pt = np.arange(0,1.01,0.01) # for the theoretical results
Ct = (1-pt)*(2*1.33/3)
Pt = (1-pt)*(1/3)
p = np.arange(0,1.1,0.1)
d = len(p)
Csim = np.zeros(d); Psim = np.zeros(d)
for j in range(0,d):
pI = (4-3*p[j])/4; pX = p[j]/4; pZ = p[j]/4; pY = p[j]/4 # depolarizing
# sequencia: 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111
# = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Phi_ABCD = [math.sqrt(r0*pI)*math.cos(th/2),
math.sqrt(r0*pX)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r0*pZ)*math.cos(th/2),
-1j*math.sqrt(r0*pY)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r1*pI)*math.sin(th/2),
-math.sqrt(r1*pX)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r1*pZ)*math.sin(th/2),
1j*math.sqrt(r1*pY)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r0*pI)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r0*pX)*math.cos(th/2),
-math.sqrt(r0*pZ)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
1j*math.sqrt(r0*pY)*math.cos(th/2),
-math.sqrt(r1*pI)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r1*pX)*math.sin(th/2),
math.sqrt(r1*pZ)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
1j*math.sqrt(r1*pY)*math.sin(th/2)]
qr = QuantumRegister(4)
qc = QuantumCircuit(qr)
qc.initialize(Phi_ABCD, [qr[3],qr[2],qr[1],qr[0]])
job_sim = StateTomography(qc, measurement_qubits = [0])
data = job_sim.run(simulator, shots=nshots).block_for_results()
rho_sim = data.analysis_results(0).value
rho = rho_sim.to_operator().data
Csim[j] = coh_l1(rho)
Psim[j] = predict_jb(rho)
p = np.arange(0,1.1,0.1); d = len(p)
Cexp = np.zeros(d); Pexp = np.zeros(d)
for j in range(0,d):
pI = (4-3*p[j])/4; pX = p[j]/4; pZ = p[j]/4; pY = p[j]/4
Phi_ABCD = [math.sqrt(r0*pI)*math.cos(th/2),
math.sqrt(r0*pX)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r0*pZ)*math.cos(th/2),
-1j*math.sqrt(r0*pY)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r1*pI)*math.sin(th/2),
-math.sqrt(r1*pX)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r1*pZ)*math.sin(th/2),
1j*math.sqrt(r1*pY)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r0*pI)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r0*pX)*math.cos(th/2),
-math.sqrt(r0*pZ)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
1j*math.sqrt(r0*pY)*math.cos(th/2),
-math.sqrt(r1*pI)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r1*pX)*math.sin(th/2),
math.sqrt(r1*pZ)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
1j*math.sqrt(r1*pY)*math.sin(th/2)]
qr = QuantumRegister(4); qc = QuantumCircuit(qr)
qc.initialize(Phi_ABCD, [qr[3],qr[2],qr[1],qr[0]])
qcst = StateTomography(qc, measurement_qubits = [0])
data = qcst.run(device)
print(data.experiment_id)
rho = data.block_for_results().analysis_results(0).value
rhoM = rho.to_operator().data
Cexp[j] = coh_l1(rhoM)
Pexp[j] = predict_jb(rhoM)
print(Cexp,Pexp)
import matplotlib
matplotlib.rcParams.update({'font.size':12})
plt.figure(figsize = (6,4), dpi = 100)
plt.plot(pt,Ct,label=r'$C_{l_1}^{the}$')
plt.plot(pt,Pt,label=r'$P_{jb}^{the}$')
plt.plot(p,Csim,'*',label=r'$C_{l_1}^{sim}$')
plt.plot(p,Psim,'o',label=r'$P_{jb}^{sim}$')
plt.plot(p,Cexp,'^',label=r'$C_{l_1}^{exp}$')
plt.plot(p,Pexp,'+',label=r'$P_{jb}^{exp}$')
plt.xlabel(r'$p$')
plt.legend()
plt.show()
# para o chip quito, sem mitigacao de erro
# para o chip manila sem mitigacao de erro
|
https://github.com/abbarreto/qiskit3
|
abbarreto
|
pip install qiskit
pip install qiskit-ignis
import qiskit
qiskit.IBMQ.save_account('17efde49764005e8eeb00dd065d44bc208778be72d44b475e508d20504818786f842988b0e506515c78debdd1b0c4b570717863db5e4f85569fb43c4c8626b8a',
overwrite = True)
qiskit.IBMQ.load_account()
import numpy as np
import math
from qiskit import *
nshots = 8192
IBMQ.load_account()
#provider= qiskit.IBMQ.get_provider(hub='ibm-q-research-2',group='federal-uni-sant-1',project='main')
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
device = provider.get_backend('ibmq_quito')
simulator = Aer.get_backend('qasm_simulator')
from qiskit.tools.monitor import job_monitor
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
def coh_l1(rho):
d = rho.shape[0]; C = 0
for j in range(0,d-1):
for k in range(j+1,d):
C += np.abs(rho[j,k])
return 2*C
def predict_jb(rho):
return abs(rho[0,0]-rho[1,1])
r00 = 2/3; r01 = 1.33/3; r10 = 1.33/3; r11 = 1/3 # initial state
r = math.sqrt((r00-r11)**2 + abs(2*r01)**2) # raio de Bloch
th = math.acos((r00-r11)/r)
ph = math.acos(2*r01.real/(r*math.sin(th))) # angulos de Bloch
r0 = (1+r)/2.; r1 = (1-r)/2. # autovetores
print(r, th, ph, r0, r1)
# simulation
p = np.arange(0,1.1,0.1)
d = len(p)
Csim = np.zeros(d); Psim = np.zeros(d)
for j in range(0,d):
pI = (4-3*p[j])/4; pX = p[j]/4; pZ = p[j]/4; pY = p[j]/4 # depolarizing
# sequencia: 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111
# = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Phi_ABCD = [math.sqrt(r0*pI)*math.cos(th/2),
math.sqrt(r0*pX)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r0*pZ)*math.cos(th/2),
-1j*math.sqrt(r0*pY)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r1*pI)*math.sin(th/2),
-math.sqrt(r1*pX)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r1*pZ)*math.sin(th/2),
1j*math.sqrt(r1*pY)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r0*pI)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r0*pX)*math.cos(th/2),
-math.sqrt(r0*pZ)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
1j*math.sqrt(r0*pY)*math.cos(th/2),
-math.sqrt(r1*pI)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r1*pX)*math.sin(th/2),
math.sqrt(r1*pZ)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
1j*math.sqrt(r1*pY)*math.sin(th/2)]
qr = QuantumRegister(4)
qc = QuantumCircuit(qr)
qc.initialize(Phi_ABCD, [qr[0],qr[3],qr[2],qr[1]])
qstc = state_tomography_circuits(qc, [qr[1]])
job = qiskit.execute(qstc, backend = simulator, shots=nshots)
qstf = StateTomographyFitter(job.result(), qstc)
rho_sim = qstf.fit(method='lstsq')
Csim[j] = coh_l1(rho_sim)
Psim[j] = predict_jb(rho_sim)
# theoretical
pt = np.arange(0,1.01,0.01)
Ct = (1-pt)*(2*1.33/3)
Pt = (1-pt)*(1/3)
# experiment
p = np.arange(0,1.1,0.1); d = len(p)
Cexp = np.zeros(d); Pexp = np.zeros(d)
jobs_ids = []
for j in range(0,d):
pI = (4-3*p[j])/4; pX = p[j]/4; pZ = p[j]/4; pY = p[j]/4
Phi_ABCD = [math.sqrt(r0*pI)*math.cos(th/2),
math.sqrt(r0*pX)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r0*pZ)*math.cos(th/2),
-1j*math.sqrt(r0*pY)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r1*pI)*math.sin(th/2),
-math.sqrt(r1*pX)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r1*pZ)*math.sin(th/2),
1j*math.sqrt(r1*pY)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r0*pI)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r0*pX)*math.cos(th/2),
-math.sqrt(r0*pZ)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
1j*math.sqrt(r0*pY)*math.cos(th/2),
-math.sqrt(r1*pI)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r1*pX)*math.sin(th/2),
math.sqrt(r1*pZ)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
1j*math.sqrt(r1*pY)*math.sin(th/2)]
qr = QuantumRegister(4); qc = QuantumCircuit(qr)
qc.initialize(Phi_ABCD, [qr[0],qr[3],qr[2],qr[1]])
qstc = state_tomography_circuits(qc, [qr[1]])
job = qiskit.execute(qstc, backend = device, shots=nshots)
jobs_ids.append(job.job_id())
print(job.job_id())
job_monitor(job)
qstf = StateTomographyFitter(job.result(), qstc)
rho_exp = qstf.fit(method='lstsq')
Cexp[j] = coh_l1(rho_exp)
#Pexp[j] = predict_jb(rho_exp)
# sem mitigacao, chip quito, qr[1]
import matplotlib
from matplotlib import pyplot as plt
matplotlib.rcParams.update({'font.size':12})
plt.figure(figsize = (6,4), dpi = 100)
plt.plot(pt,Ct,label=r'$C_{l_1}^{the}$')
#plt.plot(pt,Pt,label=r'$P_{jb}^{the}$')
plt.plot(p,Csim,'*',label=r'$C_{l_1}^{sim}$')
#plt.plot(p,Psim,'o',label=r'$P_{jb}^{sim}$')
plt.plot(p,Cexp,'^',label=r'$C_{l_1}^{exp}$')
#plt.plot(p,Pexp,'+',label=r'$P_{jb}^{exp}$')
plt.xlabel(r'$p$')
plt.legend()
plt.show()
# sem mitigacao, chip belem
# sem mitigacao, chip manila
# sem mitigacao, chip quito, qr[0]
f = open("jobs_ids_CS_rho.txt", "w")
f.write(str(jobs_ids))
f.close()
f = open("jobs_ids_CS_rho.txt","r")
list_ids = f.read().replace("'","").replace(" ","").replace("[","").replace("]","").split(",")
f.close()
print(list_ids)
# error mitigation
qr = QuantumRegister(4); qubit_list = [1]
meas_calibs, state_labels = complete_meas_cal(qubit_list = qubit_list, qr = qr)
job = qiskit.execute(meas_calibs, backend = device, shots = nshots)
print(job.job_id())
job_monitor(job)
job = device.retrieve_job('63a124fa05888e2fcb99ab6e')
meas_fitter = CompleteMeasFitter(job.result(), state_labels)
p = np.arange(0,1.1,0.1); d = len(p)
Cexp = np.zeros(d); Pexp = np.zeros(d)
for j in range(0,d):
job = device.retrieve_job(list_ids[j])
mitigated_results = meas_fitter.filter.apply(job.result())
qstf_exp = StateTomographyFitter(mitigated_results, qstc)
rho_exp = qstf_exp.fit(method='lstsq')
Cexp[j] = coh_l1(rho_exp)
Pexp[j] = predict_jb(rho_exp)
# com mitigacao, chip quito, qr[1]
import matplotlib
from matplotlib import pyplot as plt
matplotlib.rcParams.update({'font.size':12})
plt.figure(figsize = (6,4), dpi = 100)
plt.plot(pt,Ct,label=r'$C_{l_1}^{the}$')#,color='green')
plt.plot(p,Csim,'o',label=r'$C_{l_1}^{sim}$')#,color='blue')
plt.plot(p,Cexp,'*',label=r'$C_{l_1}^{exp}$')#,color='orange')
#plt.plot(pt,Pt,label=r'$P_{jb}^{the}$')
#plt.plot(p,Psim,'o',label=r'$P_{jb}^{sim}$')
#plt.plot(p,Pexp,'+',label=r'$P_{jb}^{exp}$')
plt.xlabel(r'$p$')
plt.legend()
plt.savefig('fig_QCS_mixed.pdf')
plt.show()
# com mitigacao, chip belem
# com mitigacao, chip manila
# com mitigacao, chip quito, qr[0]
# com mitigacao, chip quito
# sem mitigacao, chip quito
|
https://github.com/abbarreto/qiskit3
|
abbarreto
|
%run init.ipynb
def pf(t,r):
f = (1-r**t)/(1-r) - t
return f
from mpl_toolkits import mplot3d
def pf_3d(th,ph):
import matplotlib
matplotlib.rcParams.update({'font.size':12});
#plt.figure(figsize = (6,4,4), dpi = 100)
x = np.linspace(0, 1, 20)
y = np.linspace(0, 1, 20)
X, Y = np.meshgrid(x, y)
Z = pf(X,Y)
fig = plt.figure();
ax = plt.axes(projection="3d")
ax.plot_wireframe(X, Y, Z, color='blue')
ax.set_xlabel(r'$\lambda$')
ax.set_ylabel(r'$t$'); ax.set_zlabel(r'$r$')
ax.view_init(th, ph)
fig.tight_layout()
plt.show()
interactive(pf_3d, th = (0,90,10), ph = (0,360,10))
import numpy as np
import math
from matplotlib import pyplot as plt
x = np.arange(0.1,5,0.1) # d tau/dt
y = np.log(np.sinh(x/2)/math.sinh(1/2)) #faz beta*hbat*omega/2 = 1
plt.plot(x,y)
plt.show()
x = np.arange(0,10,0.1) # x = hb*omega, kT=1
y1 = np.exp(-x) # dtau/dt = 1
y2 = np.exp(-0.5*x) # dtau/dt = 0.5
y3 = np.exp(-1.5*x) # dtau/dt = 1.5
plt.plot(x,y1,label='1')
plt.plot(x,y2,label='0.5')
plt.plot(x,y3,label='1.5')
plt.legend()
plt.show()
|
https://github.com/abbarreto/qiskit3
|
abbarreto
|
import sympy
from sympy import *
import numpy as np
from numpy import random
import math
import scipy
init_printing(use_unicode=True)
from matplotlib import pyplot as plt
%matplotlib inline
from sympy.physics.quantum.dagger import Dagger
from sympy.physics.quantum import TensorProduct as tp
from mpmath import factorial as fact
import io
import base64
#from IPython.core.display import display, HTML, clear_output
from IPython import *
from ipywidgets import interactive, interact, fixed, interact_manual, widgets
import csv
import importlib
import scipy.interpolate
from mpl_toolkits.mplot3d import Axes3D, proj3d
from itertools import product, combinations
from matplotlib.patches import FancyArrowPatch
from matplotlib import cm, colors
from sympy.functions.special.tensor_functions import KroneckerDelta
from scipy.linalg import polar, lapack
import mpmath
# constantes físicas
e = 1.60217662*10**-19 # C (carga elementar)
k = 8.9875517923*10**9 # Nm^2/C^2 (constante de Coulomb)
eps0 = 8.8541878128*10**-12 #F/m (permissividade do vácuo)
mu0 = 1.25663706212*10**-6 # N/A^2 (permeabilidade do vácuo)
h = 6.626069*10**-34 # Js (constante de Planck)
heV = h/e # em eV
hb = h/(2*math.pi) # hbar
hbeV = hb/e # em eV
c = 2.99792458*10**8 # m/s (velocidade da luz no vácuo)
G = 6.6742*10**-11 # Nm^2/kg^2 (constante gravitacional)
kB = 1.38065*10**-23 # J/K (constante de Boltzmann)
me = 9.109382*10**-31 # kg (massa do elétron)
mp = 1.6726219*10**-27 # kg (massa do próton)
mn = 1.67492749804*10**-27 # kg (massa do nêutron)
mT = 5.9722*10**24 # kg (massa da Terra)
mS = 1.98847*10**30 # kg (massa do Sol)
u = 1.660538921*10**-27 # kg (unidade de massa atômica)
dTS = 1.496*10**11 # m (distância Terra-Sol)
rT = 6.3781*10**6 # m (raio da Terra)
sSB = 5.670374419*10**-8 # W⋅m−2⋅K−4 (constante de Stefan-Boltzmann)
Ri = 10973734.848575922 # m^-1 (constante de Rydberg)
al = (k*e**2)/(hb*c) # ~1/137.035999084 (constante de estrutura fina)
a0=(hb**2)/(me*k*e**2) # ~ 0.52917710^-10 m (raio de Bohr)
ge = 2 # (fator giromagnetico do eletron)
gp = 5.58 # (fator giromagnetico do proton)
def id(n):
'''retorna a matriz identidade nxn'''
id = zeros(n,n)
for j in range(0,n):
id[j,j] = 1
return id
#id(2)
def pauli(j):
'''retorna as matrizes de Pauli'''
if j == 1:
return Matrix([[0,1],[1,0]])
elif j == 2:
return Matrix([[0,-1j],[1j,0]])
elif j == 3:
return Matrix([[1,0],[0,-1]])
#pauli(1), pauli(2), pauli(3)
def tr(A):
'''retorna o traço de uma matriz'''
d = A.shape[0]
tr = 0
for j in range(0,d):
tr += A[j,j]
return tr
#tr(pauli(1))
def comm(A,B):
'''retorna a função comutador'''
return A*B-B*A
#comm(pauli(1),pauli(2))
def acomm(A,B):
'''retorna a função anti-comutador'''
return A*B+B*A
#acomm(pauli(1),pauli(2))
def cb(n,j):
'''retorna um vetor da base padrão de C^n'''
vec = zeros(n,1)
vec[j] = 1
return vec
#cb(2,0)
def proj(psi):
'''retorna o projeto no vetor psi'''
d = psi.shape[0]
P = zeros(d,d)
for j in range(0,d):
for k in range(0,d):
P[j,k] = psi[j]*conjugate(psi[k])
return P
#proj(cb(2,0))
def bell(j,k):
if j == 0 and k == 0:
return (1/sqrt(2))*(tp(cb(2,0),cb(2,0))+tp(cb(2,1),cb(2,1)))
elif j == 0 and k == 1:
return (1/sqrt(2))*(tp(cb(2,0),cb(2,1))+tp(cb(2,1),cb(2,0)))
elif j == 1 and k == 0:
return (1/sqrt(2))*(tp(cb(2,0),cb(2,1))-tp(cb(2,1),cb(2,0)))
elif j == 1 and k == 1:
return (1/sqrt(2))*(tp(cb(2,0),cb(2,0))-tp(cb(2,1),cb(2,1)))
#bell(0,0), bell(0,1), bell(1,0), bell(1,1)
def inner_product(v,w):
d = len(v); ip = 0
for j in range(0,d):
ip += conjugate(v[j])*w[j]
return ip
#a,b,c,d = symbols("a b c d"); v = [b,a]; w = [c,d]; inner_product(v,w)
def norm(v):
d = len(v)
return sqrt(inner_product(v,v))
#v = [2,2]; norm(v)
def tp(x,y):
return tensorproduct(x,y)
A = tp(pauli(3),pauli(1)); A
|
https://github.com/abbarreto/qiskit3
|
abbarreto
|
list_bin = []
for j in range(0,2**4):
b = "{:04b}".format(j)
list_bin.append(b)
print(list_bin)
list_int = []
for j in range(0,2**4):
list_int.append(int(list_bin[j],2))
print(list_int)
|
https://github.com/abbarreto/qiskit3
|
abbarreto
|
%run init.ipynb
c00,c01,c10,c11 = symbols('c_{00} c_{01} c_{10} c_{11}')
psiAB = Matrix([[c00],[c01],[c10],[c11]]); psiAB
rhoAB = psiAB*conjugate(psiAB.T); rhoAB
rhoA = ptraceB(2,2,rhoAB); rhoB = ptraceA(2,2,rhoAB)
rhoA, rhoB
pauli(3)*pauli(1)*pauli(3), pauli(3)*pauli(2)*pauli(3), comm(pauli(3),pauli(1)), comm(pauli(3),pauli(2))
%run init.ipynb
def pTraceL_num(dl, dr, rhoLR):
rhoR = np.zeros((dr, dr), dtype=complex)
for j in range(0, dr):
for k in range(j, dr):
for l in range(0, dl):
rhoR[j,k] += rhoLR[l*dr+j,l*dr+k]
if j != k:
rhoR[k,j] = np.conj(rhoR[j,k])
return rhoR
def pTraceR_num(dl, dr, rhoLR):
rhoL = np.zeros((dl, dl), dtype=complex)
for j in range(0, dl):
for k in range(j, dl):
for l in range(0, dr):
rhoL[j,k] += rhoLR[j*dr+l,k*dr+l]
if j != k:
rhoL[k,j] = np.conj(rhoL[j,k])
return rhoL
def coh_l1(rho):
d = rho.shape[0]; C = 0
for j in range(0,d-1):
for k in range(j+1,d):
C += np.abs(rho[j,k])
return 2*C
from numpy import linalg as LA
def Econc_(rho):
s2 = np.array([[0,-1j],[1j,0]])
R = rho@np.kron(s2,s2)@np.matrix.conjugate(rho)@np.kron(s2,s2)
w, v = LA.eig(R)
evm = max(abs(w[0]), abs(w[1]), abs(w[2]), abs(w[3]))
Ec = 2*math.sqrt(abs(evm)) - math.sqrt(abs(w[0])) - math.sqrt(abs(w[1]))\
- math.sqrt(abs(w[2])) - math.sqrt(abs(w[3]))
if Ec < 0.0:
Ec = 0.0
return Ec
import scipy.linalg.lapack as lapak
def Econc(rho):
s2 = np.array([[0,-1j],[1j,0]])
R = rho@np.kron(s2,s2)@np.matrix.conjugate(rho)@np.kron(s2,s2)
ev = lapak.zheevd(R)
evm = max(abs(ev[0][0]), abs(ev[0][1]), abs(ev[0][2]), abs(ev[0][3]))
Ec = 2*math.sqrt(abs(evm)) - math.sqrt(abs(ev[0][0])) - math.sqrt(abs(ev[0][1]))\
- math.sqrt(abs(ev[0][2])) - math.sqrt(abs(ev[0][3]))
if Ec < 0.0:
Ec = 0.0
return Ec
def concurrence_psi(rho):
rho_r = pTraceL_num(2,2,rho)
return math.sqrt(2*abs(1-np.matrix.trace(rho_r@rho_r)))
def predict_jb(rho):
return abs(rho[0,0]-rho[1,1])
import qiskit
from qiskit import *
nshots = 8192
IBMQ.load_account()
#provider= qiskit.IBMQ.get_provider(hub='ibm-q-research-2',group='federal-uni-sant-1',project='main')
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
device = provider.get_backend('ibmq_manila')
simulator = Aer.get_backend('qasm_simulator')
from qiskit.tools.monitor import job_monitor
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
q_exp = np.arange(0,1.1,0.1); N = len(q_exp)
th_xi = np.zeros(N); th_xi = 2*np.arccos(np.sqrt(1-q_exp))
th_eta = np.zeros(N); th_eta = 2*np.arccos(np.sqrt(q_exp))
E_sim_10 = np.zeros(N); C_sim_0 = np.zeros(N); P_sim_0 = np.zeros(N)
jobs_ids = []
for j in range(0,N):
qr = QuantumRegister(5); qc = QuantumCircuit(qr)
# prepara xi
qc.u(th_xi[j],0,0,qr[1])
qc.cx(qr[1],qr[2])
qc.h([qr[1],qr[2]])
# prepara eta
qc.u(th_eta[j],0,0,qr[3])
qc.cx(qr[3],qr[4])
qc.h([qr[3],qr[4]])
# tomografia
qstc = state_tomography_circuits(qc, [qr[1],qr[2]])
job_sim = qiskit.execute(qstc, backend = simulator, shots=nshots)
qstf_sim = StateTomographyFitter(job_sim.result(), qstc)
rho_10_sim = qstf_sim.fit(method='lstsq')
E_sim_10[j] = concurrence_psi(rho_10_sim)
rho_0_sim = pTraceL_num(2, 2, rho_10_sim)
C_sim_0[j] = coh_l1(rho_0_sim)
P_sim_0[j] = predict_jb(rho_0_sim)
qc.draw(output='mpl')
q_exp = np.arange(0,1.1,0.1); N = len(q_exp)
th_xi = np.zeros(N); th_xi = 2*np.arccos(np.sqrt(1-q_exp))
th_eta = np.zeros(N); th_eta = 2*np.arccos(np.sqrt(q_exp))
jobs_ids = []
for j in range(0,N):
qr = QuantumRegister(5); qc = QuantumCircuit(qr)
# prepara xi
qc.u(th_xi[j],0,0,qr[1])
qc.cx(qr[1],qr[2])
qc.h([qr[1],qr[2]])
# prepara eta
qc.u(th_eta[j],0,0,qr[3])
qc.cx(qr[3],qr[4])
qc.h([qr[3],qr[4]])
# tomografia
qstc = state_tomography_circuits(qc, [qr[1],qr[2]])
job_exp = qiskit.execute(qstc, backend = device, shots=nshots)
jobs_ids.append(job_exp.job_id())
print(job_exp.job_id())
job_monitor(job_exp)
print(jobs_ids)
f = open("jobs_ids_ES_pre_bbm.txt", "w")
f.write(str(jobs_ids))
f.close()
f = open("jobs_ids_ES_pre_bbm.txt","r")
#jobs_ids_list = f.read()
list_ids = f.read().replace("'","").replace(" ","").replace("[","").replace("]","").split(",")
f.close()
list_ids[0]
print(list_ids)
print(jobs_ids_list)
len_ids = len('6368049443e1f0708afdaf73')
print(len_ids)
list_ids = []
for j in range(0,N):
s = 0
if j > 0:
s = 2
print(jobs_ids_list[(j*(len_ids+2+s)+2):(j+1)*(len_ids+2)+j*s])
list_ids.append(jobs_ids_list[(j*(len_ids+2+s)+2):(j+1)*(len_ids+2)+j*s])
list_ids[0]
q_exp = np.arange(0,1.1,0.1); N = len(q_exp)
E_exp_10 = np.zeros(N); C_exp_0 = np.zeros(N); P_exp_0 = np.zeros(N)
for j in range(0,N):
job = device.retrieve_job(list_ids[j])
qstf_exp = StateTomographyFitter(job.result(), qstc)
rho_10_exp = qstf_exp.fit(method='lstsq');
E_exp_10[j] = Econc_(rho_10_exp)
print(E_exp_10[j])
rho_0_exp = pTraceL_num(2, 2, rho_10_exp)
C_exp_0[j] = coh_l1(rho_0_exp)
P_exp[j] = predict_jb(rho_0_exp)
import matplotlib
matplotlib.rcParams.update({'font.size':11}); plt.figure(figsize = (7,5), dpi = 100)
q = np.arange(0,1.01,0.01)
Ei2 = 4*q*(1-q)
Ci2 = (2*q-1)**2
Pi2 = np.zeros(len(q))
Pm = 1-2*q*(1-q)
plt.plot(q, Ei2, '-', label=r'$E_{conc}(\xi_{AC})^2$')
plt.plot(q, Ci2, '--', label=r'$C_{l_1}(\xi_C)^2$')
plt.plot(q, Pi2, '-.', label=r'$P(\xi_C)^2$')
plt.plot(q, Ei2+Ci2, ':', label=r'$E_{conc}(\xi_{AC})^{2}+C_{l_{1}}(\xi_{C})^{2}+P(\xi_C)^2$')
plt.plot(q_exp, E_sim_10**2, 'X', label=r'$E_{conc}(\xi_{AC})^2_{sim}$')
plt.plot(q_exp, C_sim_0**2, 'h', label=r'$C_{l_1}(\xi_C)^2_{sim}$')
plt.plot(q_exp, P_sim_0**2, '>', label=r'$P(\xi_C)^2_{sim}$')
plt.plot(q_exp, E_sim_10**2+C_sim_0**2+P_sim_0**2, '*', label=r'$E_{conc}(\xi_{AC})^{2}_{sim}+C_{l_{1}}(\xi_{C})^{2}_{sim}+P(\xi_C)^2_{sim}$')
plt.plot(q_exp, E_exp_10**2, 's', label=r'$E_{conc}(\xi_{AC})^2_{exp}$')
plt.plot(q_exp, C_exp_0**2, 'o', label=r'$C_{l_1}(\xi_C)^2_{exp}$')
plt.plot(q_exp, P_exp_0**2, 'v', label=r'$P(\xi_C)^2_{exp}$')
plt.plot(q_exp, E_exp_10**2+C_exp_0**2+P_exp_0**2, 'd', label=r'$E_{conc}(\xi_{AC})^{2}_{exp}+C_{l_{1}}(\xi_{C})^{2}_{exp}+P(\xi_C)^2_{exp}$')
plt.legend(bbox_to_anchor=(1.75, 1.0), loc='upper right')
plt.xlabel(r'$q$')
plt.show()
# error mitigation
qr = QuantumRegister(5); qubit_list = [1,2]
meas_calibs, state_labels = complete_meas_cal(qubit_list = qubit_list, qr = qr)
job = qiskit.execute(meas_calibs, backend = device, shots = nshots)
print(job.job_id())
job_monitor(job)
job = device.retrieve_job('636d895d04e46a1feb6227a9')
meas_fitter = CompleteMeasFitter(job.result(), state_labels)
q_exp = np.arange(0,1.1,0.1); N = len(q_exp)
for j in range(0,N):
job = device.retrieve_job(list_ids[j])
mitigated_results = meas_fitter.filter.apply(job.result())
qstf_exp = StateTomographyFitter(mitigated_results, qstc)
rho_10_exp = qstf_exp.fit(method='lstsq');
E_exp_10[j] = Econc_(rho_10_exp)
print(E_exp_10[j])
rho_0_exp = pTraceL_num(2, 2, rho_10_exp)
C_exp_0[j] = coh_l1(rho_0_exp)
P_exp[j] = predict_jb(rho_0_exp)
import matplotlib
matplotlib.rcParams.update({'font.size':11}); plt.figure(figsize = (7,5), dpi = 100)
q = np.arange(0,1.01,0.01)
Ei2 = 4*q*(1-q)
Ci2 = (2*q-1)**2
Pi2 = np.zeros(len(q))
Pm = 1-2*q*(1-q)
plt.plot(q, Ei2, '-', label=r'$E_{conc}(\xi_{AC})^2$')
plt.plot(q, Ci2, '--', label=r'$C_{l_1}(\xi_C)^2$')
plt.plot(q, Pi2, '-.', label=r'$P(\xi_C)^2$')
plt.plot(q, Ei2+Ci2, ':', label=r'$E_{conc}(\xi_{AC})^{2}+C_{l_{1}}(\xi_{C})^{2}+P(\xi_C)^2$')
plt.plot(q_exp, E_sim_10**2, 'X', label=r'$E_{conc}(\xi_{AC})^2_{sim}$')
plt.plot(q_exp, C_sim_0**2, 'h', label=r'$C_{l_1}(\xi_C)^2_{sim}$')
plt.plot(q_exp, P_sim_0**2, '>', label=r'$P(\xi_C)^2_{sim}$')
plt.plot(q_exp, E_sim_10**2+C_sim_0**2+P_sim_0**2, '*', label=r'$E_{conc}(\xi_{AC})^{2}_{sim}+C_{l_{1}}(\xi_{C})^{2}_{sim}+P(\xi_C)^2_{sim}$')
plt.plot(q_exp, E_exp_10**2, '^', label=r'$E_{conc}(\xi_{AC})^2_{exp}$')
plt.plot(q_exp, C_exp_0**2, 'o', label=r'$C_{l_1}(\xi_C)^2_{exp}$')
plt.plot(q_exp, P_exp_0**2, '.', label=r'$P(\xi_C)^2_{exp}$')
plt.plot(q_exp, E_exp_10**2+C_exp_0**2+P_exp_0**2, 'd', label=r'$E_{conc}(\xi_{AC})^{2}_{exp}+C_{l_{1}}(\xi_{C})^{2}_{exp}+P(\xi_C)^2_{exp}$')
plt.legend(bbox_to_anchor=(1.75, 1.0), loc='upper right')
plt.xlabel(r'$q$')
plt.savefig('fig_Eswap_pre_bbm.pdf')
plt.show()
qc.draw(output='mpl')
def pTrace_3_num(rho_abc, da, db, dc):
rho_ac = np.zeros(da*dc*da*dc, dtype=complex).reshape(da*dc,da*dc)
for j in range(0,da):
for l in range(0,dc):
cj = j*dc+l
ccj = j*db*dc+l
for m in range(0,da):
for o in range(0,dc):
ck = m*dc+o
cck = m*db*dc+o
for k in range(0,db):
rho_ac[cj,ck] = rho_ac[cj,ck] + rho_abc[ccj+k*dc,cck+k*dc]
return rho_ac
import numpy as np
import math
# projetores para a pos-seleção
I2 = np.array([[1,0],[0,1]], dtype=complex)
P00 = np.kron(np.kron(I2,np.array([[1,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],dtype=complex)), I2) # PhiP
P01 = np.kron(np.kron(I2,np.array([[0,0,0,0],[0,1,0,0],[0,0,0,0],[0,0,0,0]],dtype=complex)), I2) # PsiP
P10 = np.kron(np.kron(I2,np.array([[0,0,0,0],[0,0,0,0],[0,0,1,0],[0,0,0,0]],dtype=complex)), I2) # PhiM
P11 = np.kron(np.kron(I2,np.array([[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,1]],dtype=complex)), I2) # PsiM
#P00+P01+P10+P11
q_exp = np.arange(0,1.1,0.1); N = len(q_exp)
q_exp[0] = 0.03; q_exp[N-1] = 1-q_exp[0]
th_xi = np.zeros(N); th_xi = 2*np.arccos(np.sqrt(1-q_exp))
th_eta = np.zeros(N); th_eta = 2*np.arccos(np.sqrt(q_exp))
E_phiP_04_sim = np.zeros(N); E_psiM_04_sim = np.zeros(N)
E_psiP_04_sim = np.zeros(N); E_phiM_04_sim = np.zeros(N)
C2_sim = np.zeros(N)
for j in range(0,N):
qr = QuantumRegister(5); qc = QuantumCircuit(qr)
# prepara xi
qc.u(th_xi[j],0,0,qr[0])
qc.cx(qr[0],qr[1])
qc.h([qr[0],qr[1]])
# prepara eta
qc.u(th_eta[j],0,0,qr[3])
qc.cx(qr[3],qr[4])
qc.h([qr[3],qr[4]])
# BBM
qc.cx(qr[1],qr[3])
qc.h(qr[1])
# circuito para tomografia
qstc = state_tomography_circuits(qc, [qr[4],qr[3],qr[1],qr[0]])
# Simulacao
job_sim = qiskit.execute(qstc, backend = simulator, shots=nshots)
qstf_sim = StateTomographyFitter(job_sim.result(), qstc)
rho_4310_sim = qstf_sim.fit(method='lstsq')
# pos-selecao
rho_PhiP = P00@rho_4310_sim@P00
pr_phiP = np.real(np.trace(rho_PhiP))
rho_PhiP = (1/pr_phiP)*rho_PhiP
rho_PsiP = P01@rho_4310_sim@P01
pr_psiP = np.real(np.trace(rho_PsiP))
rho_PsiP = (1/pr_psiP)*rho_PsiP
rho_PhiM = P10@rho_4310_sim@P10
pr_phiM = np.real(np.trace(rho_PhiM))
rho_PhiM = (1/pr_phiM)*rho_PhiM
rho_PsiM = P11@rho_4310_sim@P11
pr_psiM = np.real(np.trace(rho_PsiM))
rho_PsiM = (1/pr_psiM)*rho_PsiM
# estados reduzidos
rho_PhiP_04 = pTrace_3_num(rho_PhiP,2,4,2)
rho_PsiP_04 = pTrace_3_num(rho_PsiP,2,4,2)
rho_PhiM_04 = pTrace_3_num(rho_PhiM,2,4,2)
rho_PsiM_04 = pTrace_3_num(rho_PsiM,2,4,2)
# emaranhamentos e probabilidades
E_phiP_04_sim[j] = Econc_(rho_PhiP_04)
E_phiM_04_sim[j] = Econc_(rho_PhiM_04)
E_psiP_04_sim[j] = Econc_(rho_PsiP_04)
E_psiM_04_sim[j] = Econc_(rho_PsiM_04)
C2_sim[j] = 1 - 2*(pr_phiP+pr_psiP)
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
device = provider.get_backend('ibmq_manila')
q_exp = np.arange(0,1.1,0.1); N = len(q_exp)
q_exp[0] = 0.03; q_exp[N-1] = 1-q_exp[0]
th_xi = np.zeros(N); th_xi = 2*np.arccos(np.sqrt(1-q_exp))
th_eta = np.zeros(N); th_eta = 2*np.arccos(np.sqrt(q_exp))
#jobs_ids2 = []
for j in range(N-1,N):
qr = QuantumRegister(5); qc = QuantumCircuit(qr)
# prepara xi
qc.u(th_xi[j],0,0,qr[1])
qc.cx(qr[1],qr[2])
qc.h([qr[1],qr[2]])
# prepara eta
qc.u(th_eta[j],0,0,qr[3])
qc.cx(qr[3],qr[4])
qc.h([qr[3],qr[4]])
# BBM
qc.cx(qr[2],qr[3])
qc.h(qr[2])
# circuito para tomografia
qstc = state_tomography_circuits(qc, [qr[4],qr[3],qr[2],qr[1]])
# Experimento
job_exp = qiskit.execute(qstc, backend = device, shots=nshots)
#jobs_ids2.append(job_exp.job_id())
print(job_exp.job_id())
job_monitor(job_exp)
jobs_ids2.append('636e2c8910cc1925ad755b77')
qc.draw(output='mpl')
f = open("jobs_ids_ES_post_bbm.txt", "w")
f.write(str(jobs_ids2))
f.close()
f = open("jobs_ids_ES_post_bbm.txt","r")
list_ids2 = f.read().replace("'","").replace(" ","").replace("[","").replace("]","").split(",")
f.close()
print(list_ids2)
q_exp = np.arange(0,1.1,0.1); N = len(q_exp)
q_exp[0] = 0.03; q_exp[N-1] = 1-q_exp[0]
E_phiP_04_exp = np.zeros(N); E_psiM_04_exp = np.zeros(N)
E_psiP_04_exp = np.zeros(N); E_phiM_04_exp = np.zeros(N)
C2_exp = np.zeros(N)
for j in range(0,N):
job = device.retrieve_job(list_ids2[j])
qstf_exp = StateTomographyFitter(job.result(), qstc)
rho_4310_exp = qstf_exp.fit(method='lstsq')
# pos-selecao
rho_PhiP = P00@rho_4310_exp@P00
pr_phiP = np.real(np.trace(rho_PhiP))
rho_PhiP = (1/pr_phiP)*rho_PhiP
rho_PsiP = P01@rho_4310_exp@P01
pr_psiP = np.real(np.trace(rho_PsiP))
rho_PsiP = (1/pr_psiP)*rho_PsiP
rho_PhiM = P10@rho_4310_exp@P10
pr_phiM = np.real(np.trace(rho_PhiM))
rho_PhiM = (1/pr_phiM)*rho_PhiM
rho_PsiM = P11@rho_4310_exp@P11
pr_psiM = np.real(np.trace(rho_PsiM))
rho_PsiM = (1/pr_psiM)*rho_PsiM
# estados reduzidos
rho_PhiP_04 = pTrace_3_num(rho_PhiP,2,4,2)
rho_PsiP_04 = pTrace_3_num(rho_PsiP,2,4,2)
rho_PhiM_04 = pTrace_3_num(rho_PhiM,2,4,2)
rho_PsiM_04 = pTrace_3_num(rho_PsiM,2,4,2)
# emaranhamentos e probabilidades
E_phiP_04_exp[j] = Econc_(rho_PhiP_04)
E_phiM_04_exp[j] = Econc_(rho_PhiM_04)
E_psiP_04_exp[j] = Econc_(rho_PsiP_04)
E_psiM_04_exp[j] = Econc_(rho_PsiM_04)
C2_exp[j] = 1 - 2*(pr_phiP+pr_psiP)
print(C2_exp[j])
import matplotlib
from matplotlib import pyplot as plt
matplotlib.rcParams.update({'font.size':11}); plt.figure(figsize = (6,4), dpi = 100)
q = np.arange(0,1.01,0.01)
Ep = np.ones(len(q)); Em = (2*q*(1-q))/(1-2*q+2*q**2); C2 = 1-4*q*(1-q)
plt.plot(q, Ep, '-', label=r'$E(\hat{\phi}_+)=E(\hat{\psi}_+)$')
plt.plot(q, Em, '--', label=r'$E(\hat{\phi}_-)=E(\hat{\psi}_-)$')
plt.plot(q, C2, '-.', label=r'$1-2(Pr(\hat{\phi}_+)+Pr(\hat{\psi}_+))$')
plt.plot(q_exp, E_phiP_04_sim, 'o', label=r'$E(\hat{\phi}_+)_{sim}$')
plt.plot(q_exp, E_phiM_04_sim, '*', label=r'$E(\hat{\phi}_-)_{sim}$')
#plt.plot(q_exp, E_psiP_04_sim, 'X', label=r'$E(\hat{\psi}_+)_{sim}$')
#plt.plot(q_exp, E_psiM_04_sim, '.', label=r'$E(\hat{\psi}_-)_{sim}$')
plt.plot(q_exp, C2_sim, 'X', label=r'$1-2(Pr(\hat{\phi}_+)_{sim}+Pr(\hat{\psi}_+)_{sim})$')
plt.plot(q_exp, E_phiP_04_exp, '<', label=r'$E(\hat{\phi}_+)_{exp}$')
plt.plot(q_exp, E_phiM_04_exp, '>', label=r'$E(\hat{\phi}_-)_{exp}$')
#plt.plot(q_exp, E_psiP_04_exp, '^', label=r'$E(\hat{\psi}_+)_{exp}$')
#plt.plot(q_exp, E_psiM_04_exp, '.', label=r'$E(\hat{\psi}_-)_{exp}$')
plt.plot(q_exp, C2_exp, '^', label=r'$1-2(Pr(\hat{\phi}_+)_{exp}+Pr(\hat{\psi}_+)_{exp})$')
plt.xlabel(r'$q$')
plt.legend(bbox_to_anchor=(1.8, 1.0), loc='upper right')
plt.show()
# error mitigation
qr = QuantumRegister(5)#; qc = QuantumCircuit(qr)
qubit_list = [1,2,3,4]
meas_calibs, state_labels = complete_meas_cal(qubit_list = qubit_list, qr = qr)
job = qiskit.execute(meas_calibs, backend = device, shots = nshots)
print(job.job_id())
job_monitor(job)
job = device.retrieve_job('636e3407fb0a57272187586a')
meas_fitter = CompleteMeasFitter(job.result(), state_labels)
q_exp = np.arange(0,1.1,0.1); N = len(q_exp)
q_exp[0] = 0.03; q_exp[N-1] = 1-q_exp[0]
E_phiP_04_exp = np.zeros(N); E_psiM_04_exp = np.zeros(N)
E_psiP_04_exp = np.zeros(N); E_phiM_04_exp = np.zeros(N)
C2_exp = np.zeros(N)
for j in range(0,N):
job = device.retrieve_job(list_ids2[j])
mitigated_results = meas_fitter.filter.apply(job.result()) # error mitigation
qstf_exp = StateTomographyFitter(mitigated_results, qstc) # error mitigation
rho_4310_exp = qstf_exp.fit(method='lstsq')
# pos-selecao
rho_PhiP = P00@rho_4310_exp@P00
pr_phiP = np.real(np.trace(rho_PhiP))
rho_PhiP = (1/pr_phiP)*rho_PhiP
rho_PsiP = P01@rho_4310_exp@P01
pr_psiP = np.real(np.trace(rho_PsiP))
rho_PsiP = (1/pr_psiP)*rho_PsiP
rho_PhiM = P10@rho_4310_exp@P10
pr_phiM = np.real(np.trace(rho_PhiM))
rho_PhiM = (1/pr_phiM)*rho_PhiM
rho_PsiM = P11@rho_4310_exp@P11
pr_psiM = np.real(np.trace(rho_PsiM))
rho_PsiM = (1/pr_psiM)*rho_PsiM
# estados reduzidos
rho_PhiP_04 = pTrace_3_num(rho_PhiP,2,4,2)
rho_PsiP_04 = pTrace_3_num(rho_PsiP,2,4,2)
rho_PhiM_04 = pTrace_3_num(rho_PhiM,2,4,2)
rho_PsiM_04 = pTrace_3_num(rho_PsiM,2,4,2)
# emaranhamentos e probabilidades
E_phiP_04_exp[j] = Econc_(rho_PhiP_04)
E_phiM_04_exp[j] = Econc_(rho_PhiM_04)
E_psiP_04_exp[j] = Econc_(rho_PsiP_04)
E_psiM_04_exp[j] = Econc_(rho_PsiM_04)
C2_exp[j] = 1 - 2*(pr_phiP+pr_psiP)
print(C2_exp[j])
import matplotlib
from matplotlib import pyplot as plt
matplotlib.rcParams.update({'font.size':11}); plt.figure(figsize = (6,4), dpi = 100)
q = np.arange(0,1.01,0.01)
Ep = np.ones(len(q)); Em = (2*q*(1-q))/(1-2*q+2*q**2); C2 = 1-4*q*(1-q)
plt.plot(q, Ep, '-', label=r'$E(\hat{\phi}_+)=E(\hat{\psi}_+)$')
plt.plot(q, Em, '--', label=r'$E(\hat{\phi}_-)=E(\hat{\psi}_-)$')
plt.plot(q, C2, '-.', label=r'$1-2(Pr(\hat{\phi}_+)+Pr(\hat{\psi}_+))$')
plt.plot(q_exp, E_phiP_04_sim, 'o', label=r'$E(\hat{\phi}_+)_{sim}$')
plt.plot(q_exp, E_phiM_04_sim, '*', label=r'$E(\hat{\phi}_-)_{sim}$')
#plt.plot(q_exp, E_psiP_04_sim, 'X', label=r'$E(\hat{\psi}_+)_{sim}$')
#plt.plot(q_exp, E_psiM_04_sim, '.', label=r'$E(\hat{\psi}_-)_{sim}$')
plt.plot(q_exp, C2_sim, 'X', label=r'$1-2(Pr(\hat{\phi}_+)_{sim}+Pr(\hat{\psi}_+)_{sim})$')
plt.plot(q_exp, E_phiP_04_exp, '<', label=r'$E(\hat{\phi}_+)_{exp}$')
plt.plot(q_exp, E_phiM_04_exp, '>', label=r'$E(\hat{\phi}_-)_{exp}$')
#plt.plot(q_exp, E_psiP_04_exp, '^', label=r'$E(\hat{\psi}_+)_{exp}$')
#plt.plot(q_exp, E_psiM_04_exp, '.', label=r'$E(\hat{\psi}_-)_{exp}$')
plt.plot(q_exp, C2_exp, '^', label=r'$1-2(Pr(\hat{\phi}_+)_{exp}+Pr(\hat{\psi}_+)_{exp})$')
plt.xlabel(r'$q$')
plt.legend(bbox_to_anchor=(1.8, 1.0), loc='upper right')
plt.savefig('fig_Eswap_post_bbm.pdf')
plt.show()
C = np.arange(0,1.1,0.1);
E_PhiP = (1-C**2)/(1+C**2)
E_PhiM = np.ones(len(C))
plt.plot(C, E_PhiP, '*'); plt.plot(C, E_PhiM, '.')
plt.show()
from qiskit import *
qr = QuantumRegister(4);
%run init.ipynb
p,q = symbols('p q')
ket_xi = Matrix([[sqrt(p)],[sqrt((1-p)/2)],[sqrt((1-p)/2)],[0]])
ket_eta = Matrix([[sqrt(q)],[sqrt((1-q)/2)],[sqrt((1-q)/2)],[0]])
ket_xi, ket_eta
rho_xi = ket_xi*ket_xi.T
rho_eta = ket_eta*ket_eta.T
rho_xi, rho_eta
def ptraceA(da, db, rho):
rhoB = zeros(db,db)
for j in range(0, db):
for k in range(0, db):
for l in range(0, da):
rhoB[j,k] += rho[l*db+j,l*db+k]
return rhoB
def ptraceB(da, db, rho):
rhoA = zeros(da,da)
for j in range(0, da):
for k in range(0, da):
for l in range(0, db):
rhoA[j,k] += rho[j*db+l,k*db+l]
return rhoA
rho_xi_A = ptraceB(2,2,rho_xi); rho_xi_C = ptraceA(2,2,rho_xi)
rho_xi_A, rho_xi_C
rho_eta_Cp = ptraceB(2,2,rho_eta); rho_eta_B = ptraceA(2,2,rho_eta)
rho_eta_Cp, rho_eta_B
c00,c01,c10,c11 = symbols('c_{00} c_{01} c_{10} c_{11}')
d00,d01,d10,d11 = symbols('d_{00} d_{01} d_{10} d_{11}')
def two_qb_basis():
zz = Matrix([[1],[0],[0],[0]])
zu = Matrix([[0],[1],[0],[0]])
uz = Matrix([[0],[0],[1],[0]])
uu = Matrix([[0],[0],[0],[1]])
return zz,zu,uz,uu
zz,zu,uz,uu = two_qb_basis(); zz,zu,uz,uu
def psi_p(c00,c01,c10,c11,d00,d01,d10,d11):
zz,zu,uz,uu = two_qb_basis()
psi = (c00*d00+c01*d10)*zz + (c00*d01+c01*d11)*zu + (c10*d00+c11*d10)*uz + (c10*d01+c11*d11)*uu
return psi/sqrt(2)
def psi_m(c00,c01,c10,c11,d00,d01,d10,d11):
zz,zu,uz,uu = two_qb_basis()
psi = (c00*d00-c01*d10)*zz + (c00*d01-c01*d11)*zu + (c10*d00-c11*d10)*uz + (c10*d01-c11*d11)*uu
return psi/sqrt(2)
def phi_p(c00,c01,c10,c11,d00,d01,d10,d11):
zz,zu,uz,uu = two_qb_basis()
psi = (c00*d10+c01*d00)*zz + (c00*d11+c01*d01)*zu + (c10*d10+c11*d00)*uz + (c10*d11+c11*d01)*uu
return psi/sqrt(2)
def phi_m(c00,c01,c10,c11,d00,d01,d10,d11):
zz,zu,uz,uu = two_qb_basis()
psi = (c00*d10-c01*d00)*zz + (c00*d11-c01*d01)*zu + (c10*d10-c11*d00)*uz + (c10*d11-c11*d01)*uu
return psi/sqrt(2)
c00 = sqrt(p); c01 = sqrt((1-p)/2); c10 = sqrt((1-p)/2); c11 = 0
d00 = sqrt(q); d01 = sqrt((1-q)/2); d10 = sqrt((1-q)/2); d11 = 0
psip = psi_p(c00,c01,c10,c11,d00,d01,d10,d11);
psim = psi_m(c00,c01,c10,c11,d00,d01,d10,d11)
phip = phi_p(c00,c01,c10,c11,d00,d01,d10,d11);
phim = phi_m(c00,c01,c10,c11,d00,d01,d10,d11)
simplify(psip), simplify(psim), simplify(phip), simplify(phim)
psip_norm2 = psip.T*psip; simplify(psip_norm2)
psim_norm2 = psim.T*psim; simplify(psim_norm2)
phip_norm2 = phip.T*phip; simplify(phip_norm2)
phim_norm2 = phim.T*phim; simplify(phim_norm2)
|
https://github.com/abbarreto/qiskit3
|
abbarreto
|
0.4*7.6
|
https://github.com/abbarreto/qiskit3
|
abbarreto
|
from qiskit_ibm_runtime import QiskitRuntimeService
# Save an IBM Quantum account.
QiskitRuntimeService.save_account(channel='ibm_quantum',
#channel='ibm_cloud',
token='17efde49764005e8eeb00dd065d44bc208778be72d44b475e508d20504818786f842988b0e506515c78debdd1b0c4b570717863db5e4f85569fb43c4c8626b8a',
overwrite=True)
service = QiskitRuntimeService(
channel='ibm_quantum',
instance='ibm-q/open/main'
#instance='ibm-q-research-2/federal-uni-sant-1/main'
)
program_inputs = {'iterations': 1}
options = {"backend_name": "ibmq_qasm_simulator"}
job = service.run(program_id="hello-world",
options=options,
inputs=program_inputs
)
#print(f"job id: {job.job_id()}")
result = job.result()
print(result)
backend = service.get_backend("ibmq_qasm_simulator")
from qiskit.circuit.random import random_circuit
from qiskit.quantum_info import SparsePauliOp
from qiskit.primitives import Estimator
from qiskit import QuantumCircuit
#circuit = random_circuit(2, 2, seed=1).decompose(reps=1)
circuit = QuantumCircuit(2)
circuit.x(0)
circuit.draw(output='mpl')
observable = SparsePauliOp("IZ") # ordem ...210
#options = {"backend_name": "ibmq_qasm_simulator"}
estimator = Estimator()#options=options)
job = estimator.run(circuit, observable)
result = job.result()
display(circuit.draw("mpl"))
print(f" > Observable: {observable.paulis}")
print(f" > Expectation value: {result.values[0]}")
print(f" > Metadata: {result.metadata[0]}")
import math
qc1 = QuantumCircuit(2); qc2 = QuantumCircuit(2)
qc1.h(1)
qc2.h(0); qc2.p(-math.pi/2, 0)
circuits = (
#random_circuit(2, 2, seed=0).decompose(reps=1),
#random_circuit(2, 2, seed=1).decompose(reps=1),
qc1, qc2
)
observables = (
SparsePauliOp("XZ"),
SparsePauliOp("IY"),
)
estimator = Estimator()
job = estimator.run(circuits, observables)
result = job.result()
[display(cir.draw("mpl")) for cir in circuits]
print(f" > Observables: {[obs.paulis for obs in observables]}")
print(f" > Expectation values: {result.values.tolist()}")
print(f" > Metadata: {result.metadata}")
circuits = (
random_circuit(2, 2, seed=0).decompose(reps=1),
random_circuit(2, 2, seed=1).decompose(reps=1),
)
observables = (
SparsePauliOp("XZ"),
SparsePauliOp("IY"),
)
estimator = Estimator()
job_0 = estimator.run(circuits[0], observables[0])
job_1 = estimator.run(circuits[1], observables[1])
result_0 = job_0.result()
result_1 = job_1.result()
[display(cir.draw("mpl")) for cir in circuits]
print(f" > Observables: {[obs.paulis for obs in observables]}")
print(f" > Expectation values [0]: {result_0.values.tolist()[0]}")
print(f" > Metadata [0]: {result_0.metadata[0]}")
print(f" > Expectation values [1]: {result_1.values.tolist()[0]}")
print(f" > Metadata [1]: {result_1.metadata[0]}")
from qiskit.circuit.library import RealAmplitudes
circuit = RealAmplitudes(num_qubits=2, reps=2).decompose(reps=1)
observable = SparsePauliOp("ZI")
parameter_values = [0, 1, 2, 3, 4, 5]
estimator = Estimator()
job = estimator.run(circuit, observable, parameter_values)
result = job.result()
display(circuit.draw("mpl"))
print(f" > Observable: {observable.paulis}")
print(f" > Parameter values: {parameter_values}")
print(f" > Expectation value: {result.values}")
print(f" > Metadata: {result.metadata[0]}")
circuit = RealAmplitudes(num_qubits=2, reps=1).decompose(reps=1)
display(circuit.draw("mpl"))
from qiskit.circuit.random import random_circuit
from qiskit.quantum_info import SparsePauliOp
from qiskit_ibm_runtime import QiskitRuntimeService, Session, Estimator, Options
circuit = random_circuit(2, 2, seed=1).decompose(reps=1)
observable = SparsePauliOp("IY")
options = Options()
options.optimization_level = 2
options.resilience_level = 2
service = QiskitRuntimeService()
with Session(service=service, backend="ibmq_qasm_simulator") as session:
estimator = Estimator(session=session, options=options)
job = estimator.run(circuit, observable)
result = job.result()
display(circuit.draw("mpl"))
print(f" > Observable: {observable.paulis}")
print(f" > Expectation value: {result.values[0]}")
print(f" > Metadata: {result.metadata[0]}")
from qiskit.circuit.random import random_circuit
from qiskit.quantum_info import SparsePauliOp
from qiskit_ibm_runtime import QiskitRuntimeService, Session, Estimator, Options
circuit = random_circuit(2, 2, seed=1).decompose(reps=1)
observable = SparsePauliOp("IY")
options = Options()
options.optimization_level = 2
options.resilience_level = 2
service = QiskitRuntimeService()
with Session(service=service, backend="ibmq_belem") as session:
estimator = Estimator(session=session, options=options)
job = estimator.run(circuit, observable)
result = job.result()
display(circuit.draw("mpl"))
print(f" > Observable: {observable.paulis}")
print(f" > Expectation value: {result.values[0]}")
print(f" > Metadata: {result.metadata[0]}")
from qiskit_ibm_runtime import Session, Options
circuit = random_circuit(2, 2, seed=1).decompose(reps=1)
observable = SparsePauliOp("IY")
options = Options()
options.optimization_level = 2
options.resilience_level = 2
service = QiskitRuntimeService()
backend = service.get_backend("ibmq_belem")
with Session(service=service, backend=backend):
estimator = Estimator()
job = estimator.run(circuit, observable)
result = job.result()
display(circuit.draw("mpl"))
print(f" > Observable: {observable.paulis}")
print(f" > Expectation value: {result.values[0]}")
print(f" > Metadata: {result.metadata[0]}")
from qiskit.circuit.random import random_circuit
from qiskit.primitives import Sampler
circuit = random_circuit(2, 2, seed=1).decompose(reps=1)
circuit.measure_all()
sampler = Sampler()
job = sampler.run(circuit)
result = job.result()
display(circuit.draw("mpl"))
print(f" > Quasi probability distribution: {result.quasi_dists[0]}")
#print(f" > Metadata: {result.metadata[0]}")
#print(result.quasi_dists,result.quasi_dists[0][1])
print(result.quasi_dists[0][0]+result.quasi_dists[0][1]+result.quasi_dists[0][2]+result.quasi_dists[0][3])
from qiskit.circuit.random import random_circuit
from qiskit.primitives import Sampler
circuits = (
random_circuit(2, 2, seed=0).decompose(reps=1),
random_circuit(2, 2, seed=1).decompose(reps=1),
)
[c.measure_all() for c in circuits]
sampler = Sampler()
job = sampler.run(circuits)
result = job.result()
[display(cir.draw("mpl")) for cir in circuits]
print(f" > Quasi probability distributions: {result.quasi_dists}")
#print(f" > Metadata: {result.metadata}")
from qiskit.circuit.library import RealAmplitudes
# RealAmplitudes is one way to generate a parametrized circuit
from qiskit.primitives import Sampler
circuit = RealAmplitudes(num_qubits=2, reps=2).decompose(reps=1)
circuit.measure_all()
parameter_values = [0, 1, 2, 3, 4, 5]
sampler = Sampler()
job = sampler.run(circuit, parameter_values)
result = job.result()
display(circuit.draw("mpl"))
print(f" > Parameter values: {parameter_values}")
print(f" > Quasi probability distribution: {result.quasi_dists[0]}")
print(f" > Metadata: {result.metadata[0]}")
from qiskit.circuit.random import random_circuit
from qiskit_ibm_runtime import QiskitRuntimeService, Session, Sampler, Options
backend = service.get_backend("ibmq_qasm_simulator")
circuit = random_circuit(2, 2, seed=2).decompose(reps=1)
circuit.measure_all()
options = Options()
options.optimization_level = 2
options.resilience_level = 0
service = QiskitRuntimeService()
with Session(service=service, backend=backend):
sampler = Sampler()
job = sampler.run(circuit)
result = job.result()
display(circuit.draw("mpl"))
print(f" > Quasi probability distribution: {result.quasi_dists[0]}")
print(f" > Metadata: {result.metadata[0]}")
from qiskit.circuit.random import random_circuit
from qiskit_ibm_runtime import QiskitRuntimeService, Session, Sampler, Options
backend = service.get_backend("ibmq_quito")
circuit = random_circuit(2, 2, seed=2).decompose(reps=1)
circuit.measure_all()
options = Options()
options.optimization_level = 2
options.resilience_level = 0
service = QiskitRuntimeService()
with Session(service=service, backend=backend):
sampler = Sampler()
job = sampler.run(circuit)
print(job.job_id())
result = job.result()
display(circuit.draw("mpl"))
print(f" > Quasi probability distribution: {result.quasi_dists[0]}")
print(f" > Metadata: {result.metadata[0]}")
|
https://github.com/abbarreto/qiskit3
|
abbarreto
|
%run init.ipynb
# tem algum problema com a funcao produto tensorial do sympy (implementar eu mesmo ...)
k000 = Matrix([1,0,0,0,0,0,0,0]); k001 = Matrix([0,1,0,0,0,0,0,0])
k010 = Matrix([0,0,1,0,0,0,0,0]); k011 = Matrix([0,0,0,1,0,0,0,0])
k100 = Matrix([0,0,0,0,1,0,0,0]); k101 = Matrix([0,0,0,0,0,1,0,0])
k110 = Matrix([0,0,0,0,0,0,1,0]); k111 = Matrix([0,0,0,0,0,0,0,1])
#k000,k001,k010,k011,k100,k101,k110,k111, k001*k001.T
p = symbols('p')
#p = 0
Psi0 = sqrt((4-3*p)/4)*k000 + sqrt(p/4)*(k101+k010+k111)
Psi1 = sqrt((4-3*p)/4)*k100 + sqrt(p/4)*(k001-k110-k011)
#Psi0.T, Psi1.T
r00,r01,r10,r11 = symbols('r_{00} r_{01} r_{10} r_{11}')
rhoA = Matrix([[r00,r01],[r10,r11]]); rhoA, rhoA[0,0]
#rhoA = Matrix([[2/3,1/3],[1/3,1/3]]); #rhoA, rhoA[0,0]
def rhoABt_s(rhoA,p):
Psi0 = sqrt((4-3*p)/4)*k000 + sqrt(p/4)*(k101+k010+k111)
Psi1 = sqrt((4-3*p)/4)*k100 + sqrt(p/4)*(k001-k110-k011)
return rhoA[0,0]*Psi0*Psi0.T + rhoA[0,1]*Psi0*Psi1.T + rhoA[1,0]*Psi1*Psi0.T + rhoA[1,1]*Psi1*Psi1.T
rhoABt_ = rhoABt_s(rhoA,p); rhoABt_
# não foi possivel diagonalizar com sympy
def ptraceB(da, db, rho):
rhoA = zeros(da,da)
for j in range(0, da):
for k in range(0, da):
for l in range(0, db):
rhoA[j,k] += rho[j*db+l,k*db+l]
return rhoA
rhoAt = ptraceB(2, 4, rhoABt_); simplify(rhoAt) # ok!
rhoA = Matrix([[2/3,1/3],[1/3,1/3]])
p = np.arange(0,1.1,0.1); N = len(p)
Cl1 = np.zeros(N); Pjb = np.zeros(N)
for j in range(0,N):
rhoABt_ = rhoABt_s(rhoA,p[j])
rhoA_ = ptraceB(2, 4, rhoABt_)
Cl1[j] = coh_l1_s(rhoA_)
Pjb[j] = predict_jb_s(rhoA_)
# calculo feito a partir de rhoAB_til
import matplotlib
matplotlib.rcParams.update({'font.size':12})
plt.figure(figsize = (6,4), dpi = 100)
plt.plot(p,Cl1,label=r'$C_{l_1}$')
plt.plot(p,Pjb,label=r'$P_{jb}$')
plt.xlabel(r'$p$')
plt.legend()
plt.show()
evv = rhoABt.eigenvects(); evv
def tp_vv_s(psi, csi): # tensor product, of vectors, symbolic
M = psi.shape[0]; N = csi.shape[0]
eta = zeros(M*N,1)
for j in range(0,M):
for k in range(0,N):
eta[j*N+k] = psi[j]*csi[k]
return eta
def cb(d,j): # estados da base computacional
v = zeros(d,1)
v[j] = 1
return v
cb(2,0)
def PhiABCt_s(rhoA,p):
rhoABt = rhoABt_s(rhoA,p)
eig = rhoABt.eigenvects()
d = rhoABt.shape[0]; Phi = zeros(d*d,1)
ne = 0; j = 0; l = -1
while ne < d:
mult = eig[j][1]; ne += mult
for k in range(0,mult):
l += 1
Phi += sqrt(abs(eig[j][0]))*tp_vv_s(eig[j][2][k],cb(d,l))
j += 1
for j in range(0,d*d):
if im(Phi[j]) < 10**-5:
Phi[j] = re(Phi[j])
return Phi
def coh_l1_s(rho):
d = rho.shape[0]; C = 0
for j in range(0,d-1):
for k in range(j+1,d):
C += abs(rho[j,k])
return 2*C
def predict_jb_s(rho):
return abs(rho[0,0]-rho[1,1])
def proj_s(psi): # simbolic projector
d = psi.shape[0]
proj = zeros(d,d)
for j in range(0,d):
for k in range(0,d):
proj[j,k] = psi[j]*conjugate(psi[k])
return proj
rhoA = Matrix([[2/3,1/3],[1/3,1/3]])
p = np.arange(0,1.1,0.1); N = len(p)
Cl1 = np.zeros(N); Pjb = np.zeros(N)
for j in range(0,N):
Phi = PhiABCt_s(rhoA,p[j]); PPhi = proj_s(Phi)#; print(PPhi)
rhoA_ = ptraceB(2, 2**5, PPhi)#; print(rhoA_[0,1])
Cl1[j] = coh_l1_s(rhoA_)
Pjb[j] = predict_jb_s(rhoA_)
# calculo feito a partir de PhiABC
import matplotlib
matplotlib.rcParams.update({'font.size':12})
plt.figure(figsize = (6,4), dpi = 100)
plt.plot(p,Cl1,label=r'$C_{l_1}$')
plt.plot(p,Pjb,label=r'$P_{jb}$')
plt.xlabel(r'$p$')
plt.legend()
plt.show()
def rho_AB_til(rhoA,p):
rhoAbc = np.zeros((2**3,2**3), dtype=complex)#; print(rhoAbc)
ket0 = np.array([[1],[0]]); ket1 = np.array([[0],[1]])#; print(ket0,ket1)
ket00 = np.kron(ket0,ket0); ket01 = np.kron(ket0,ket1); ket10 = np.kron(ket1,ket0)
ket11 = np.kron(ket1,ket1); #print(ket00,'',ket01,'',ket10,'',ket11)
ket000 = np.kron(ket0,ket00); ket100 = np.kron(ket1,ket00)
ket001 = np.kron(ket0,ket01); ket101 = np.kron(ket1,ket01)
ket010 = np.kron(ket0,ket10); ket110 = np.kron(ket1,ket10)
ket011 = np.kron(ket0,ket11); ket111 = np.kron(ket1,ket11)
Psi0 = math.sqrt((4-3*p)/4)*ket000 + math.sqrt(p/4)*(ket101+ket010+ket111)
Psi1 = math.sqrt((4-3*p)/4)*ket100 + math.sqrt(p/4)*(ket001-ket110-ket011)
rhoAbc = rhoA[0,0]*Psi0@Psi0.T + rhoA[0,1]*Psi0@Psi1.T\
+ rhoA[1,0]*Psi1@Psi0.T + rhoA[1,1]*Psi1@Psi1.T
return rhoAbc
def pTraceR_num(dl, dr, rhoLR):
rhoL = np.zeros((dl, dl), dtype=complex)
for j in range(0, dl):
for k in range(j, dl):
for l in range(0, dr):
rhoL[j,k] += rhoLR[j*dr+l,k*dr+l]
if j != k:
rhoL[k,j] = np.conj(rhoL[j,k])
return rhoL
rhoA = np.array([[2/3,1/3],[1/3,1/3]]); print(rhoA) # estado inicial
p = 0.
rhoAbc = rho_AB_til(rhoA,p)#; print(rhoAbc)
rhoA_ = pTraceR_num(2, 4, rhoAbc); print(rhoA_)
def coh_l1(rho):
d = rho.shape[0];
#d = rho.dims()[0]
C = 0
for j in range(0,d-1):
for k in range(j+1,d):
C += np.abs(rho[j,k])
return 2*C
def predict_jb(rho):
return abs(rho[0,0]-rho[1,1])
p = np.arange(0,1.1,0.1); #print(p)
N = len(p)#; print(N)
Cl1 = np.zeros(N); Pjb = np.zeros(N)
for j in range(0,N):
rhoAbc = rho_AB_til(rhoA,p[j])
rhoA_ = pTraceR_num(2, 4, rhoAbc)
Cl1[j] = coh_l1(rhoA_)
Pjb[j] = predict_jb(rhoA_)
# calculo feito a partir de rhoAB_til
import matplotlib
matplotlib.rcParams.update({'font.size':12})
plt.figure(figsize = (6,4), dpi = 100)
plt.plot(p,Cl1,label=r'$C_{l_1}$')
plt.plot(p,Pjb,label=r'$P_{jb}$')
plt.xlabel(r'$p$')
plt.legend()
plt.show()
from numpy import linalg
w, v = linalg.eig(rhoAbc)
print(v[0][:])
print(np.shape(v[:][0]))
ket0 = np.array([[1],[0]]); ket1 = np.array([[0],[1]])
ket00 = np.kron(ket0,ket0); ket01 = np.kron(ket0,ket1)
ket10 = np.kron(ket1,ket0); ket11 = np.kron(ket1,ket1)
ket000 = np.kron(ket0,ket00); ket100 = np.kron(ket1,ket00)
ket001 = np.kron(ket0,ket01); ket101 = np.kron(ket1,ket01)
ket010 = np.kron(ket0,ket10); ket110 = np.kron(ket1,ket10)
ket011 = np.kron(ket0,ket11); ket111 = np.kron(ket1,ket11)
p = np.arange(0,1.1,0.1)
N = len(p)
Cl1 = np.zeros(N); Pjb = np.zeros(N)
for j in range(0,N):
rhoAbc = rho_AB_til(rhoA,p[j])
w, v = linalg.eig(rhoAbc); w = np.abs(w)
PhiAbcdef = math.sqrt(w[0])*np.kron(v.T[0],ket000) + math.sqrt(w[1])*np.kron(v.T[1],ket001)\
+ math.sqrt(w[2])*np.kron(v.T[2],ket010) + math.sqrt(w[3])*np.kron(v.T[3],ket011)\
+ math.sqrt(w[4])*np.kron(v.T[4],ket100) + math.sqrt(w[5])*np.kron(v.T[5],ket101)\
+ math.sqrt(w[6])*np.kron(v.T[6],ket110) + math.sqrt(w[7])*np.kron(v.T[7],ket111)
rhoAbcdef = np.outer(PhiAbcdef,np.conj(PhiAbcdef))#; print(np.shape(rhoAbcdef))
rhoA_ = pTraceR_num(2, 2**5, rhoAbcdef); print(rhoA_)#; print(np.shape(rhoA_))
Cl1[j] = coh_l1(rhoA_)
Pjb[j] = predict_jb(rhoA_)
# calculo feito a partir da purificacao rhoAB_til
import matplotlib
matplotlib.rcParams.update({'font.size':12})
plt.figure(figsize = (6,4), dpi = 100)
plt.plot(p,Cl1,label=r'$C_{l_1}$')
plt.plot(p,Pjb,label=r'$P_{jb}$')
plt.xlabel(r'$p$')
plt.legend()
plt.show()
rho_A = Matrix([[2/3,1/3],[1/3,1/3]])
rho_A.eigenvects()
rho_A*Matrix([[0.85],[0.52]])/0.87, rho_A*Matrix([[-0.5257],[0.85]])/0.127
w, v = linalg.eig(rhoA) # os autovetores são as colunas de v
print(w, v, v.T[0], v.T[1], np.shape(v.T[1])) # nao pode usar
import qiskit
from qiskit import *
nshots = 8192
IBMQ.load_account()
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
device = provider.get_backend('ibmq_quito')
simulator = Aer.get_backend('qasm_simulator')
from qiskit.tools.monitor import job_monitor
from qiskit_experiments.library import StateTomography
r00 = 2/3; r01 = 1.33/3; r10 = 1.33/3; r11 = 1/3 # initial state
r = math.sqrt((r00-r11)**2 + abs(2*r01)**2) # raio de Bloch
th = math.acos((r00-r11)/r)
ph = math.acos(re(2*r01)/(r*sin(th))) # angulos de Bloch
r0 = (1+r)/2.; r1 = (1-r)/2. # autovetores
print(r, th, ph, r0, r1)
pt = np.arange(0,1.01,0.01) # for the theoretical results
Ct = (1-pt)*(2*1.33/3)
Pt = (1-pt)*(1/3)
p = np.arange(0,1.1,0.1)
d = len(p)
Csim = np.zeros(d); Psim = np.zeros(d)
for j in range(0,d):
pI = (4-3*p[j])/4; pX = p[j]/4; pZ = p[j]/4; pY = p[j]/4 # depolarizing
# sequencia: 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111
# = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Phi_ABCD = [math.sqrt(r0*pI)*math.cos(th/2),
math.sqrt(r0*pX)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r0*pZ)*math.cos(th/2),
-1j*math.sqrt(r0*pY)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r1*pI)*math.sin(th/2),
-math.sqrt(r1*pX)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r1*pZ)*math.sin(th/2),
1j*math.sqrt(r1*pY)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r0*pI)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r0*pX)*math.cos(th/2),
-math.sqrt(r0*pZ)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
1j*math.sqrt(r0*pY)*math.cos(th/2),
-math.sqrt(r1*pI)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r1*pX)*math.sin(th/2),
math.sqrt(r1*pZ)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
1j*math.sqrt(r1*pY)*math.sin(th/2)]
qr = QuantumRegister(4)
qc = QuantumCircuit(qr)
qc.initialize(Phi_ABCD, [qr[3],qr[2],qr[1],qr[0]])
job_sim = StateTomography(qc, measurement_qubits = [0])
data = job_sim.run(simulator, shots=nshots).block_for_results()
rho_sim = data.analysis_results(0).value
rho = rho_sim.to_operator().data
Csim[j] = coh_l1(rho)
Psim[j] = predict_jb(rho)
p = np.arange(0,1.1,0.1); d = len(p)
Cexp = np.zeros(d); Pexp = np.zeros(d)
for j in range(0,d):
pI = (4-3*p[j])/4; pX = p[j]/4; pZ = p[j]/4; pY = p[j]/4
Phi_ABCD = [math.sqrt(r0*pI)*math.cos(th/2),
math.sqrt(r0*pX)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r0*pZ)*math.cos(th/2),
-1j*math.sqrt(r0*pY)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r1*pI)*math.sin(th/2),
-math.sqrt(r1*pX)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r1*pZ)*math.sin(th/2),
1j*math.sqrt(r1*pY)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r0*pI)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r0*pX)*math.cos(th/2),
-math.sqrt(r0*pZ)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
1j*math.sqrt(r0*pY)*math.cos(th/2),
-math.sqrt(r1*pI)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r1*pX)*math.sin(th/2),
math.sqrt(r1*pZ)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
1j*math.sqrt(r1*pY)*math.sin(th/2)]
qr = QuantumRegister(4); qc = QuantumCircuit(qr)
qc.initialize(Phi_ABCD, [qr[3],qr[2],qr[1],qr[0]])
qcst = StateTomography(qc, measurement_qubits = [0])
data = qcst.run(device)
print(data.experiment_id)
rho = data.block_for_results().analysis_results(0).value
rhoM = rho.to_operator().data
Cexp[j] = coh_l1(rhoM)
Pexp[j] = predict_jb(rhoM)
print(Cexp,Pexp)
import matplotlib
matplotlib.rcParams.update({'font.size':12})
plt.figure(figsize = (6,4), dpi = 100)
plt.plot(pt,Ct,label=r'$C_{l_1}^{the}$')
plt.plot(pt,Pt,label=r'$P_{jb}^{the}$')
plt.plot(p,Csim,'*',label=r'$C_{l_1}^{sim}$')
plt.plot(p,Psim,'o',label=r'$P_{jb}^{sim}$')
plt.plot(p,Cexp,'^',label=r'$C_{l_1}^{exp}$')
plt.plot(p,Pexp,'+',label=r'$P_{jb}^{exp}$')
plt.xlabel(r'$p$')
plt.legend()
plt.show()
# para o chip quito, sem mitigacao de erro
# para o chip manila sem mitigacao de erro
|
https://github.com/abbarreto/qiskit3
|
abbarreto
|
pip install qiskit
pip install qiskit-ignis
import qiskit
qiskit.IBMQ.save_account('17efde49764005e8eeb00dd065d44bc208778be72d44b475e508d20504818786f842988b0e506515c78debdd1b0c4b570717863db5e4f85569fb43c4c8626b8a',
overwrite = True)
qiskit.IBMQ.load_account()
import numpy as np
import math
from qiskit import *
nshots = 8192
IBMQ.load_account()
#provider= qiskit.IBMQ.get_provider(hub='ibm-q-research-2',group='federal-uni-sant-1',project='main')
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
device = provider.get_backend('ibmq_quito')
simulator = Aer.get_backend('qasm_simulator')
from qiskit.tools.monitor import job_monitor
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
def coh_l1(rho):
d = rho.shape[0]; C = 0
for j in range(0,d-1):
for k in range(j+1,d):
C += np.abs(rho[j,k])
return 2*C
def predict_jb(rho):
return abs(rho[0,0]-rho[1,1])
r00 = 2/3; r01 = 1.33/3; r10 = 1.33/3; r11 = 1/3 # initial state
r = math.sqrt((r00-r11)**2 + abs(2*r01)**2) # raio de Bloch
th = math.acos((r00-r11)/r)
ph = math.acos(2*r01.real/(r*math.sin(th))) # angulos de Bloch
r0 = (1+r)/2.; r1 = (1-r)/2. # autovetores
print(r, th, ph, r0, r1)
# simulation
p = np.arange(0,1.1,0.1)
d = len(p)
Csim = np.zeros(d); Psim = np.zeros(d)
for j in range(0,d):
pI = (4-3*p[j])/4; pX = p[j]/4; pZ = p[j]/4; pY = p[j]/4 # depolarizing
# sequencia: 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111
# = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Phi_ABCD = [math.sqrt(r0*pI)*math.cos(th/2),
math.sqrt(r0*pX)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r0*pZ)*math.cos(th/2),
-1j*math.sqrt(r0*pY)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r1*pI)*math.sin(th/2),
-math.sqrt(r1*pX)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r1*pZ)*math.sin(th/2),
1j*math.sqrt(r1*pY)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r0*pI)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r0*pX)*math.cos(th/2),
-math.sqrt(r0*pZ)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
1j*math.sqrt(r0*pY)*math.cos(th/2),
-math.sqrt(r1*pI)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r1*pX)*math.sin(th/2),
math.sqrt(r1*pZ)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
1j*math.sqrt(r1*pY)*math.sin(th/2)]
qr = QuantumRegister(4)
qc = QuantumCircuit(qr)
qc.initialize(Phi_ABCD, [qr[0],qr[3],qr[2],qr[1]])
qstc = state_tomography_circuits(qc, [qr[1]])
job = qiskit.execute(qstc, backend = simulator, shots=nshots)
qstf = StateTomographyFitter(job.result(), qstc)
rho_sim = qstf.fit(method='lstsq')
Csim[j] = coh_l1(rho_sim)
Psim[j] = predict_jb(rho_sim)
# theoretical
pt = np.arange(0,1.01,0.01)
Ct = (1-pt)*(2*1.33/3)
Pt = (1-pt)*(1/3)
# experiment
p = np.arange(0,1.1,0.1); d = len(p)
Cexp = np.zeros(d); Pexp = np.zeros(d)
jobs_ids = []
for j in range(0,d):
pI = (4-3*p[j])/4; pX = p[j]/4; pZ = p[j]/4; pY = p[j]/4
Phi_ABCD = [math.sqrt(r0*pI)*math.cos(th/2),
math.sqrt(r0*pX)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r0*pZ)*math.cos(th/2),
-1j*math.sqrt(r0*pY)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r1*pI)*math.sin(th/2),
-math.sqrt(r1*pX)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r1*pZ)*math.sin(th/2),
1j*math.sqrt(r1*pY)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r0*pI)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r0*pX)*math.cos(th/2),
-math.sqrt(r0*pZ)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
1j*math.sqrt(r0*pY)*math.cos(th/2),
-math.sqrt(r1*pI)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r1*pX)*math.sin(th/2),
math.sqrt(r1*pZ)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
1j*math.sqrt(r1*pY)*math.sin(th/2)]
qr = QuantumRegister(4); qc = QuantumCircuit(qr)
qc.initialize(Phi_ABCD, [qr[0],qr[3],qr[2],qr[1]])
qstc = state_tomography_circuits(qc, [qr[1]])
job = qiskit.execute(qstc, backend = device, shots=nshots)
jobs_ids.append(job.job_id())
print(job.job_id())
job_monitor(job)
qstf = StateTomographyFitter(job.result(), qstc)
rho_exp = qstf.fit(method='lstsq')
Cexp[j] = coh_l1(rho_exp)
#Pexp[j] = predict_jb(rho_exp)
# sem mitigacao, chip quito, qr[1]
import matplotlib
from matplotlib import pyplot as plt
matplotlib.rcParams.update({'font.size':12})
plt.figure(figsize = (6,4), dpi = 100)
plt.plot(pt,Ct,label=r'$C_{l_1}^{the}$')
#plt.plot(pt,Pt,label=r'$P_{jb}^{the}$')
plt.plot(p,Csim,'*',label=r'$C_{l_1}^{sim}$')
#plt.plot(p,Psim,'o',label=r'$P_{jb}^{sim}$')
plt.plot(p,Cexp,'^',label=r'$C_{l_1}^{exp}$')
#plt.plot(p,Pexp,'+',label=r'$P_{jb}^{exp}$')
plt.xlabel(r'$p$')
plt.legend()
plt.show()
# sem mitigacao, chip belem
# sem mitigacao, chip manila
# sem mitigacao, chip quito, qr[0]
f = open("jobs_ids_CS_rho.txt", "w")
f.write(str(jobs_ids))
f.close()
f = open("jobs_ids_CS_rho.txt","r")
list_ids = f.read().replace("'","").replace(" ","").replace("[","").replace("]","").split(",")
f.close()
print(list_ids)
# error mitigation
qr = QuantumRegister(4); qubit_list = [1]
meas_calibs, state_labels = complete_meas_cal(qubit_list = qubit_list, qr = qr)
job = qiskit.execute(meas_calibs, backend = device, shots = nshots)
print(job.job_id())
job_monitor(job)
job = device.retrieve_job('63a124fa05888e2fcb99ab6e')
meas_fitter = CompleteMeasFitter(job.result(), state_labels)
p = np.arange(0,1.1,0.1); d = len(p)
Cexp = np.zeros(d); Pexp = np.zeros(d)
for j in range(0,d):
job = device.retrieve_job(list_ids[j])
mitigated_results = meas_fitter.filter.apply(job.result())
qstf_exp = StateTomographyFitter(mitigated_results, qstc)
rho_exp = qstf_exp.fit(method='lstsq')
Cexp[j] = coh_l1(rho_exp)
Pexp[j] = predict_jb(rho_exp)
# com mitigacao, chip quito, qr[1]
import matplotlib
from matplotlib import pyplot as plt
matplotlib.rcParams.update({'font.size':12})
plt.figure(figsize = (6,4), dpi = 100)
plt.plot(pt,Ct,label=r'$C_{l_1}^{the}$')#,color='green')
plt.plot(p,Csim,'o',label=r'$C_{l_1}^{sim}$')#,color='blue')
plt.plot(p,Cexp,'*',label=r'$C_{l_1}^{exp}$')#,color='orange')
#plt.plot(pt,Pt,label=r'$P_{jb}^{the}$')
#plt.plot(p,Psim,'o',label=r'$P_{jb}^{sim}$')
#plt.plot(p,Pexp,'+',label=r'$P_{jb}^{exp}$')
plt.xlabel(r'$p$')
plt.legend()
plt.savefig('fig_QCS_mixed.pdf')
plt.show()
# com mitigacao, chip belem
# com mitigacao, chip manila
# com mitigacao, chip quito, qr[0]
# com mitigacao, chip quito
# sem mitigacao, chip quito
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.