repo
stringclasses 885
values | file
stringclasses 741
values | content
stringlengths 4
215k
|
|---|---|---|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.visualization.timeline import draw as timeline_draw
from qiskit import QuantumCircuit, transpile
from qiskit.providers.fake_provider import FakeBoeblingen
backend = FakeBoeblingen()
ghz = QuantumCircuit(5)
ghz.h(0)
ghz.cx(0,range(1,5))
circ = transpile(ghz, backend, scheduling_method="asap")
timeline_draw(circ)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_nature.units import DistanceUnit
from qiskit_nature.second_q.drivers import PySCFDriver
driver = PySCFDriver(
atom="H 0 0 0; H 0 0 0.735",
basis="sto3g",
charge=0,
spin=0,
unit=DistanceUnit.ANGSTROM,
)
es_problem = driver.run()
from qiskit_nature.second_q.mappers import JordanWignerMapper
mapper = JordanWignerMapper()
from qiskit.algorithms.eigensolvers import NumPyEigensolver
numpy_solver = NumPyEigensolver(filter_criterion=es_problem.get_default_filter_criterion())
from qiskit.algorithms.minimum_eigensolvers import VQE
from qiskit.algorithms.optimizers import SLSQP
from qiskit.primitives import Estimator
from qiskit_nature.second_q.algorithms import GroundStateEigensolver, QEOM
from qiskit_nature.second_q.circuit.library import HartreeFock, UCCSD
ansatz = UCCSD(
es_problem.num_spatial_orbitals,
es_problem.num_particles,
mapper,
initial_state=HartreeFock(
es_problem.num_spatial_orbitals,
es_problem.num_particles,
mapper,
),
)
estimator = Estimator()
# This first part sets the ground state solver
# see more about this part in the ground state calculation tutorial
solver = VQE(estimator, ansatz, SLSQP())
solver.initial_point = [0.0] * ansatz.num_parameters
gse = GroundStateEigensolver(mapper, solver)
# The qEOM algorithm is simply instantiated with the chosen ground state solver and Estimator primitive
qeom_excited_states_solver = QEOM(gse, estimator, "sd")
from qiskit_nature.second_q.algorithms import ExcitedStatesEigensolver
numpy_excited_states_solver = ExcitedStatesEigensolver(mapper, numpy_solver)
numpy_results = numpy_excited_states_solver.solve(es_problem)
qeom_results = qeom_excited_states_solver.solve(es_problem)
print(numpy_results)
print("\n\n")
print(qeom_results)
import numpy as np
def filter_criterion(eigenstate, eigenvalue, aux_values):
return np.isclose(aux_values["ParticleNumber"][0], 2.0)
new_numpy_solver = NumPyEigensolver(filter_criterion=filter_criterion)
new_numpy_excited_states_solver = ExcitedStatesEigensolver(mapper, new_numpy_solver)
new_numpy_results = new_numpy_excited_states_solver.solve(es_problem)
print(new_numpy_results)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_nature.units import DistanceUnit
from qiskit_nature.second_q.drivers import PySCFDriver
driver = PySCFDriver(
atom="H 0 0 0; H 0 0 0.735",
basis="sto3g",
charge=0,
spin=0,
unit=DistanceUnit.ANGSTROM,
)
es_problem = driver.run()
from qiskit_nature.second_q.mappers import JordanWignerMapper
mapper = JordanWignerMapper()
from qiskit.algorithms.eigensolvers import NumPyEigensolver
numpy_solver = NumPyEigensolver(filter_criterion=es_problem.get_default_filter_criterion())
from qiskit.algorithms.minimum_eigensolvers import VQE
from qiskit.algorithms.optimizers import SLSQP
from qiskit.primitives import Estimator
from qiskit_nature.second_q.algorithms import GroundStateEigensolver, QEOM
from qiskit_nature.second_q.circuit.library import HartreeFock, UCCSD
ansatz = UCCSD(
es_problem.num_spatial_orbitals,
es_problem.num_particles,
mapper,
initial_state=HartreeFock(
es_problem.num_spatial_orbitals,
es_problem.num_particles,
mapper,
),
)
estimator = Estimator()
# This first part sets the ground state solver
# see more about this part in the ground state calculation tutorial
solver = VQE(estimator, ansatz, SLSQP())
solver.initial_point = [0.0] * ansatz.num_parameters
gse = GroundStateEigensolver(mapper, solver)
# The qEOM algorithm is simply instantiated with the chosen ground state solver and Estimator primitive
qeom_excited_states_solver = QEOM(gse, estimator, "sd")
from qiskit_nature.second_q.algorithms import ExcitedStatesEigensolver
numpy_excited_states_solver = ExcitedStatesEigensolver(mapper, numpy_solver)
numpy_results = numpy_excited_states_solver.solve(es_problem)
qeom_results = qeom_excited_states_solver.solve(es_problem)
print(numpy_results)
print("\n\n")
print(qeom_results)
import numpy as np
def filter_criterion(eigenstate, eigenvalue, aux_values):
return np.isclose(aux_values["ParticleNumber"][0], 2.0)
new_numpy_solver = NumPyEigensolver(filter_criterion=filter_criterion)
new_numpy_excited_states_solver = ExcitedStatesEigensolver(mapper, new_numpy_solver)
new_numpy_results = new_numpy_excited_states_solver.solve(es_problem)
print(new_numpy_results)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-pocket-guide
|
qiskit-community
|
from qiskit.opflow.state_fns import StateFn
statefn = StateFn('10100')
print(statefn)
from qiskit import QuantumCircuit
qc = QuantumCircuit(3)
qc.h(0)
qc.cx(0, 1)
qc.cx(1, 2)
statefn = StateFn(qc)
print(statefn)
import numpy as np
statefn = StateFn([1, 0, 0, 1] / np.sqrt(2))
print(statefn)
from qiskit.opflow.state_fns import StateFn
from qiskit.opflow import One, Zero
statefn_a = StateFn('100', is_measurement=True)
print('statefn_a:', statefn_a, statefn_a.is_measurement)
statefn_b = ~(One ^ Zero ^ Zero)
print('statefn_b:', statefn_b, statefn_b.is_measurement)
|
https://github.com/apcarrik/qiskit-dev
|
apcarrik
|
import sys
# !conda install --yes --prefix {sys.prefix} numpy
# !conda install --yes --prefix {sys.prefix} qiskit
# !conda install --yes --prefix {sys.prefix} matplotlib
# !{sys.executable} -m pip install pyppeteer
import numpy as np
from qiskit import *
from matplotlib import pyplot
from math import pi
thetas = [i*pi/10 for i in range(0,11)]
shots = 100
import matplotlib.pyplot as plt
import numpy as np
def plot_results(counts_arr):
zeros_count = [count[0] for count in counts_arr] #+ [sum([count[0] for count in counts_arr])/len(counts_arr)]
ones_count = [count[1] for count in counts_arr] #+ [sum([count[1] for count in counts_arr])/len(counts_arr)]
ones_pct = [count/shots for count in ones_count]
fig, ax = plt.subplots()
labels = [f'{i}/10*pi' for i in range(len(thetas))] #+ ['Average']
x = np.arange(len(labels))
width=0.35
# c1 = ax.bar(x - width/2, zeros_count, width, label='Output = 0')
c2 = ax.bar(x + width/2, ones_pct, width, label='Output = 1')
ax.set_ylabel('Output 1 Average')
ax.set_xlabel('Theta')
ax.set_title('Output 1 Averages vs. Theta')
ax.set_xticks(x)
ax.set_xticklabels(labels)
ax.legend()
# ax.bar_label(c1, padding=3)
ax.bar_label(c2, padding=3)
fig.set_size_inches(12, 9)
plt.show()
counts_arr = [ [] for i in range(len(thetas)) ]
for i, theta in enumerate(thetas):
# Build circuit
qc = QuantumCircuit(1,1)
qc.h(0)
qc.rz(theta,0)
qc.h(0)
qc.measure(0,0)
if i==0:
qc.draw('mpl')
pyplot.show()
# Simulate circuit using Aer's qasm_simulator
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = backend_sim.run(transpile(qc, backend_sim), shots=shots)
result_sim = job_sim.result()
counts = result_sim.get_counts(qc)
# collect counts of simulation output
counts_arr[i].append( counts['0'] if '0' in counts else 0 )
counts_arr[i].append( counts['1'] if '1' in counts else 0 )
print(f'theta={i}/10*pi\tcounts: {counts}\tavg: {counts_arr[i][1]/shots*100:.1f}%')
plot_results(counts_arr)
counts_arr = [ [] for i in range(len(thetas)) ]
for i, theta in enumerate(thetas):
# Build circuit
qc = QuantumCircuit(1,1)
qc.h(0)
qc.rz(theta/2,0)
qc.x(0)
qc.rz(theta/2,0)
qc.x(0)
qc.h(0)
qc.measure(0,0)
if i==0:
qc.draw('mpl')
pyplot.show()
# Simulate circuit using Aer's qasm_simulator
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = backend_sim.run(transpile(qc, backend_sim), shots=shots)
result_sim = job_sim.result()
counts = result_sim.get_counts(qc)
# collect counts of simulation output
counts_arr[i].append( counts['0'] if '0' in counts else 0 )
counts_arr[i].append( counts['1'] if '1' in counts else 0 )
print(f'theta={i}/10*pi\tcounts: {counts}\tavg: {counts_arr[i][1]/shots:.2f}%')
plot_results(counts_arr)
deltas = [0.1, 0.2]
for delta in deltas:
counts_arr = [ [] for i in range(len(thetas)) ]
print(f"\n-----\nDelta: {delta}")
for i, theta in enumerate(thetas):
# Build circuit
qc = QuantumCircuit(1,1)
qc.h(0)
qc.rz(theta/2+delta,0)
qc.x(0)
qc.rz(theta/2-delta,0)
qc.x(0)
qc.h(0)
qc.measure(0,0)
if i==0:
qc.draw('mpl')
pyplot.show()
# Simulate circuit using Aer's qasm_simulator
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = backend_sim.run(transpile(qc, backend_sim), shots=shots)
result_sim = job_sim.result()
counts = result_sim.get_counts(qc)
# collect counts of simulation output
counts_arr[i].append( counts['0'] if '0' in counts else 0 )
counts_arr[i].append( counts['1'] if '1' in counts else 0 )
print(f'theta={i}/10*pi\tcounts: {counts}\tavg: {counts_arr[i][1]/shots:.2f}%')
plot_results(counts_arr)
from qiskit.quantum_info import Operator
from qiskit.extensions import HamiltonianGate
from qiskit.opflow import I, X, Y, Z
counts_arr = [ [] for i in range(len(thetas)) ]
for i, theta in enumerate(thetas):
# Define operator in exponent
op = X + Y + Z
# Define coefficient in exponent
c = (theta/4)/2*((1/3)**(1/2))
# Create HamiltonianGate, which is defined as exp(-i*op*c)
V_gate = HamiltonianGate(op, c)
# Define circuit
qc = QuantumCircuit(1,1)
qc.append(V_gate, [0])
qc.x(0)
qc.append(V_gate, [0])
qc.x(0)
qc.append(V_gate, [0])
qc.x(0)
qc.append(V_gate, [0])
qc.x(0)
qc.measure(0,0)
# Draw circuit once
if i==0:
qc.draw('mpl')
pyplot.show()
# Simulate circuit using Aer's qasm_simulator
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = backend_sim.run(transpile(qc, backend_sim), shots=shots)
result_sim = job_sim.result()
counts = result_sim.get_counts(qc)
# collect counts of simulation output
counts_arr[i].append( counts['0'] if '0' in counts else 0 )
counts_arr[i].append( counts['1'] if '1' in counts else 0 )
print(f'theta={i}/10*pi\tcounts: {counts}\tavg: {counts_arr[i][1]/shots:.2f}%')
plot_results(counts_arr)
counts_arr = [ [] for i in range(len(thetas)) ]
for i, theta in enumerate(thetas):
# Define operator in exponent
op = X + Y + Z
# Define coefficient in exponent
c = (theta/4)/2*((1/3)**(1/2))
# Create HamiltonianGate, which is defined as exp(-i*op*c)
V_gate = HamiltonianGate(op, c)
# Define circuit
qc = QuantumCircuit(1,1)
qc.append(V_gate, [0])
qc.x(0)
qc.append(V_gate, [0])
qc.y(0)
qc.append(V_gate, [0])
qc.x(0)
qc.append(V_gate, [0])
qc.y(0)
qc.measure(0,0)
# Draw circuit once
if i==0:
qc.draw('mpl')
pyplot.show()
# Simulate circuit using Aer's qasm_simulator
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = backend_sim.run(transpile(qc, backend_sim), shots=shots)
result_sim = job_sim.result()
counts = result_sim.get_counts(qc)
# collect counts of simulation output
counts_arr[i].append( counts['0'] if '0' in counts else 0 )
counts_arr[i].append( counts['1'] if '1' in counts else 0 )
print(f'theta={i}/10*pi\tcounts: {counts}\tavg: {counts_arr[i][1]/shots:.2f}%')
plot_results(counts_arr)
|
https://github.com/jdanielescanez/quantum-solver
|
jdanielescanez
|
from qiskit import QuantumCircuit
from math import log2
class QSCircuit(QuantumCircuit):
def __init__(self, size):
self.size = size
super().__init__(size, size)
def not1(self, a):
self.x(a)
def not2(self, a, result):
self.reset(result)
self.cx(a, result)
self.x(result)
def or3(self, a, b, result):
self.reset(result)
self.x([a, b])
self.ccx(a, b, result)
self.x([a, b, result])
def or_list(self, indexes, result, aux):
self.reset(result)
for a in indexes:
self.or3(a, result, aux)
self.reset(result)
self.xor2(aux, result)
def and3(self, a, b, result):
self.reset(result)
self.ccx(a, b, result)
def and_list(self, indexes, result, aux):
self.reset(result)
self.not1(result)
for a in indexes:
self.and3(a, result, aux)
self.reset(result)
self.xor2(aux, result)
def nand3(self, a, b, result):
self.and3(a, b, result)
self.not1(result)
# copy the source to the destiny if conditional
def copy_if(self, conditional, source, destiny):
for i in range(len(source)):
self.and3(conditional, source[i], destiny[i])
def xor2(self, a, result):
self.cx(a, result)
def xor3(self, a, b, result):
self.reset(result)
self.cx(b, result)
self.cx(a, result)
def swap2(self, a, b):
self.swap(a, b)
def shift_left(self, indexes):
indexes.sort()
self.swap(indexes[:-1], indexes[1:])
def shift_right(self, indexes):
indexes.sort(reverse=True)
self.swap(indexes[:-1], indexes[1:])
def reset1(self, a):
self.reset(a)
def set1(self, a):
self.reset(a)
self.x(a)
def set_bin_reg(self, values, indexes):
self.set_reg(values[::-1], indexes)
def set_reg(self, values, indexes):
for i, value in enumerate(values):
if value == '1':
self.set1(indexes[i])
else:
self.reset1(indexes[i])
# output in indexes2
def full_add_regs(self, indexes1, indexes2, carry, auxs):
a_xor_b, a_prod_b, aux = auxs
self.reset1(carry)
for a, b in zip(indexes1, indexes2):
self.reset1([a_xor_b, a_prod_b, aux])
# a_xor_b = a xor b
self.xor3(a, b, a_xor_b)
# a_prod_b = a * b
self.and3(a, b, a_prod_b)
# aux = carry_in * (a xor b)
self.and3(carry, a_xor_b, aux)
# output = a xor b xor carry_in
self.xor3(a_xor_b, carry, b)
# carry_out = (a * b) + (carry_in * (a xor b))
self.or3(a_prod_b, aux, carry)
# output in indexes2
def half_add_regs(self, indexes1, indexes2, carries):
self.reset1(carries)
for a, b, c in zip(indexes1, indexes2, carries):
self.and3(a, b, c) # c = ab
self.xor2(a, b) # b = b xor a
self.swap2(b, c) # b = ab; c = a xor b
def encoder(self, inputs, outputs, aux):
n = len(inputs)
m = int(log2(n))
assert(m == len(outputs))
relative_indexes = [[inputs[num] for num in range(2 ** m) if (num >> i) & 1 == 1] for i in range(m)]
for i in range(m):
self.or_list(relative_indexes[i], outputs[i], aux)
def decoder(self, inputs, outputs, flipped_inputs, aux):
n = len(inputs)
m = int(2 ** n)
assert(m == len(outputs))
self.xor2(inputs, flipped_inputs)
self.not1(flipped_inputs)
for i in range(m):
tag = format(i, '0' + str(n) + 'b')[::-1]
relative_inputs = [flipped_inputs[j] if x == '0' else inputs[j] for j, x in enumerate(tag)]
self.and_list(relative_inputs, outputs[i], aux)
''' Modify inputs to its pruduct by its code '''
def multiplexer(self, inputs, selectors, flipped_selectors, output, aux):
n = len(inputs)
m = int(log2(n))
assert(m == len(selectors))
self.xor2(selectors, flipped_selectors)
self.not1(flipped_selectors)
for i in range(n):
tag = format(i, '0' + str(m) + 'b')[::-1]
relative_selectors = [flipped_selectors[j] if x == '0' else selectors[j] for j, x in enumerate(tag)]
self.and_list([inputs[i]] + relative_selectors, output, aux)
self.swap(inputs[i], output)
self.or_list(inputs, output, aux)
|
https://github.com/Aman-Agrawal01/Quantum-Computing-Qiskit-Tutorial
|
Aman-Agrawal01
|
from qiskit import *
from qiskit.tools.visualization import plot_histogram
%matplotlib inline
qr1 = QuantumRegister(size=2,name='numbers')
qr2 = QuantumRegister(size=1,name='answer-bit')
qr3 = QuantumRegister(size=1,name='carry-bit')
cr1 = ClassicalRegister(size=1,name='answer-cbit')
cr2 = ClassicalRegister(size=1,name='carry-cbit')
circuit = QuantumCircuit(qr1,qr2,qr3,cr1,cr2)
circuit.x(qr1)
circuit.barrier()
circuit.draw(output='mpl')
circuit.cx(control_qubit=qr1[0],target_qubit=qr2)
circuit.cx(control_qubit=qr1[1],target_qubit=qr2)
circuit.draw(output='mpl')
circuit.ccx(control_qubit1=qr1[0],control_qubit2=qr1[1],target_qubit=qr3)
circuit.barrier()
circuit.draw(output='mpl')
circuit.measure(qr2,cr1)
circuit.measure(qr3,cr2)
circuit.draw(output='mpl')
simulator = Aer.get_backend('qasm_simulator')
result = execute(circuit,backend=simulator).result()
plot_histogram(result.get_counts())
|
https://github.com/aryashah2k/Quantum-Computing-Collection-Of-Resources
|
aryashah2k
|
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer
q = QuantumRegister(2, "q")
c = ClassicalRegister(2, "c")
qc = QuantumCircuit(q,c)
qc.x(q[1])
qc.cx(q[1],q[0])
# Returning control qubit to the initial state
qc.x(q[1])
job = execute(qc,Aer.get_backend('unitary_simulator'), shots = 1)
U=job.result().get_unitary(qc,decimals=3)
print("CNOT(0) = ")
for row in U:
s = ""
for value in row:
s = s + str(round(value.real,2)) + " "
print(s)
qc.draw(output="mpl", reverse_bits=True)
#
# your solution is here
#
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer
q = QuantumRegister(3,"q")
c = ClassicalRegister(3,"c")
qc = QuantumCircuit(q,c)
qc.x(q[2])
qc.x(q[1])
qc.ccx(q[2],q[1],q[0])
qc.x(q[2])
qc.x(q[1])
job = execute(qc,Aer.get_backend('unitary_simulator'), shots = 1)
U=job.result().get_unitary(qc,decimals=3)
print("CCNOT(00) = ")
for row in U:
s = ""
for value in row:
s = s + str(round(value.real,2)) + " "
print(s)
qc.draw(output="mpl",reverse_bits=True)
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer
q = QuantumRegister(3,"q")
c = ClassicalRegister(3,"c")
qc = QuantumCircuit(q,c)
qc.x(q[2])
qc.ccx(q[2],q[1],q[0])
qc.x(q[2])
job = execute(qc,Aer.get_backend('unitary_simulator'), shots = 1)
U=job.result().get_unitary(qc,decimals=3)
print("CCNOT(01) = ")
for row in U:
s = ""
for value in row:
s = s + str(round(value.real,2)) + " "
print(s)
qc.draw(output="mpl",reverse_bits=True)
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer
q = QuantumRegister(3,"q")
c = ClassicalRegister(3,"c")
qc = QuantumCircuit(q,c)
qc.x(q[1])
qc.ccx(q[2],q[1],q[0])
qc.x(q[1])
job = execute(qc,Aer.get_backend('unitary_simulator'), shots = 1)
U=job.result().get_unitary(qc,decimals=3)
print("CCNOT(10) = ")
for row in U:
s = ""
for value in row:
s = s + str(round(value.real,2)) + " "
print(s)
qc.draw(output="mpl",reverse_bits=True)
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer
qaux = QuantumRegister(1,"qaux")
q = QuantumRegister(4,"q")
c = ClassicalRegister(4,"c")
qc = QuantumCircuit(q,qaux,c)
# step 1: set qaux to |1> if both q3 and q2 are in |1>
qc.ccx(q[3],q[2],qaux[0])
# step 2: apply NOT gate to q0 if both qaux and q1 are in |1>
qc.ccx(qaux[0],q[1],q[0])
# step 3: set qaux to |0> if both q3 and q2 are in |1> by reversing the affect of step 1
qc.ccx(q[3],q[2],qaux[0])
qc.draw(output="mpl",reverse_bits=True)
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer
all_inputs=[]
for q3 in ['0','1']:
for q2 in ['0','1']:
for q1 in ['0','1']:
for q0 in ['0','1']:
all_inputs.append(q3+q2+q1+q0)
# print(all_inputs)
print("input --> output")
for the_input in all_inputs:
# create the circuit
qaux = QuantumRegister(1,"qaux")
q = QuantumRegister(4,"q")
c = ClassicalRegister(4,"c")
qc = QuantumCircuit(q,qaux,c)
# set the initial value of the circuit w.r.t. the input
if the_input[0] =='1': qc.x(q[3])
if the_input[1] =='1': qc.x(q[2])
if the_input[2] =='1': qc.x(q[1])
if the_input[3] =='1': qc.x(q[0])
# implement the CCNOT gates
qc.ccx(q[3],q[2],qaux[0])
qc.ccx(qaux[0],q[1],q[0])
qc.ccx(q[3],q[2],qaux[0])
# measure the main quantum register
qc.measure(q,c)
# execute the circuit
job = execute(qc,Aer.get_backend('qasm_simulator'),shots=1)
counts = job.result().get_counts(qc)
for key in counts: the_output = key
printed_str = the_input[0:3]+" "+the_input[3]+" --> "+the_output[0:3]+" "+the_output[3]
if (the_input!=the_output): printed_str = printed_str + " the output is different than the input"
print(printed_str)
#
# your solution is here
#
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer
qaux = QuantumRegister(2,"qaux")
q = QuantumRegister(5,"q")
c = ClassicalRegister(5,"c")
qc = QuantumCircuit(q,qaux,c)
qc.ccx(q[4],q[3],qaux[1])
qc.ccx(q[2],q[1],qaux[0])
qc.ccx(qaux[1],qaux[0],q[0])
qc.ccx(q[4],q[3],qaux[1])
qc.ccx(q[2],q[1],qaux[0])
qc.draw(output="mpl",reverse_bits=True)
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer
all_inputs=[]
for q4 in ['0','1']:
for q3 in ['0','1']:
for q2 in ['0','1']:
for q1 in ['0','1']:
for q0 in ['0','1']:
all_inputs.append(q4+q3+q2+q1+q0)
#print(all_inputs)
print("input --> output")
for the_input in all_inputs:
# create the circuit
qaux = QuantumRegister(2,"qaux")
q = QuantumRegister(5,"q")
c = ClassicalRegister(5,"c")
qc = QuantumCircuit(q,qaux,c)
# set the initial value of the circuit w.r.t. the input
if the_input[0] =='1': qc.x(q[4])
if the_input[1] =='1': qc.x(q[3])
if the_input[2] =='1': qc.x(q[2])
if the_input[3] =='1': qc.x(q[1])
if the_input[4] =='1': qc.x(q[0])
# implement the CCNOT gates
qc.ccx(q[4],q[3],qaux[1])
qc.ccx(q[2],q[1],qaux[0])
qc.ccx(qaux[1],qaux[0],q[0])
qc.ccx(q[4],q[3],qaux[1])
qc.ccx(q[2],q[1],qaux[0])
# measure the main quantum register
qc.measure(q,c)
# execute the circuit
job = execute(qc,Aer.get_backend('qasm_simulator'),shots=1)
counts = job.result().get_counts(qc)
for key in counts: the_output = key
printed_str = the_input[0:4]+" "+the_input[4]+" --> "+the_output[0:4]+" "+the_output[4]
if (the_input!=the_output): printed_str = printed_str + " the output is different than the input"
print(printed_str)
#
# your solution is here
#
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer
qaux = QuantumRegister(2,"qaux")
q = QuantumRegister(5,"q")
c = ClassicalRegister(5,"c")
qc = QuantumCircuit(q,qaux,c)
qc.x(q[3])
qc.x(q[1])
qc.ccx(q[4],q[3],qaux[1])
qc.ccx(q[2],q[1],qaux[0])
qc.ccx(qaux[1],qaux[0],q[0])
qc.ccx(q[4],q[3],qaux[1])
qc.ccx(q[2],q[1],qaux[0])
qc.x(q[3])
qc.x(q[1])
qc.draw(output="mpl",reverse_bits=True)
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer
all_inputs=[]
for q4 in ['0','1']:
for q3 in ['0','1']:
for q2 in ['0','1']:
for q1 in ['0','1']:
for q0 in ['0','1']:
all_inputs.append(q4+q3+q2+q1+q0)
#print(all_inputs)
print("input --> output")
for the_input in all_inputs:
# create the circuit
qaux = QuantumRegister(2,"qaux")
q = QuantumRegister(5,"q")
c = ClassicalRegister(5,"c")
qc = QuantumCircuit(q,qaux,c)
# set the initial value of the circuit w.r.t. the input
if the_input[0] =='1': qc.x(q[4])
if the_input[1] =='1': qc.x(q[3])
if the_input[2] =='1': qc.x(q[2])
if the_input[3] =='1': qc.x(q[1])
if the_input[4] =='1': qc.x(q[0])
# implement the CCNOT gates
qc.x(q[3])
qc.x(q[1])
qc.ccx(q[4],q[3],qaux[1])
qc.ccx(q[2],q[1],qaux[0])
qc.ccx(qaux[1],qaux[0],q[0])
qc.ccx(q[4],q[3],qaux[1])
qc.ccx(q[2],q[1],qaux[0])
qc.x(q[3])
qc.x(q[1])
# measure the main quantum register
qc.measure(q,c)
# execute the circuit
job = execute(qc,Aer.get_backend('qasm_simulator'),shots=1)
counts = job.result().get_counts(qc)
for key in counts: the_output = key
printed_str = the_input[0:4]+" "+the_input[4]+" --> "+the_output[0:4]+" "+the_output[4]
if (the_input!=the_output): printed_str = printed_str + " the output is different than the input"
print(printed_str)
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer
all_inputs=[]
for q4 in ['0','1']:
for q3 in ['0','1']:
for q2 in ['0','1']:
for q1 in ['0','1']:
for q0 in ['0','1']:
all_inputs.append(q4+q3+q2+q1+q0)
#print(all_inputs)
def c4not(control_state='1111'):
#
# drawing the circuit
#
print("Control state is",control_state)
print("Drawing the circuit:")
qaux = QuantumRegister(2,"qaux")
q = QuantumRegister(5,"q")
c = ClassicalRegister(5,"c")
qc = QuantumCircuit(q,qaux,c)
for b in range(4):
if control_state[b] == '0':
qc.x(q[4-b])
qc.ccx(q[4],q[3],qaux[1])
qc.ccx(q[2],q[1],qaux[0])
qc.ccx(qaux[1],qaux[0],q[0])
qc.ccx(q[4],q[3],qaux[1])
qc.ccx(q[2],q[1],qaux[0])
for b in range(4):
if control_state[b] == '0':
qc.x(q[4-b])
display(qc.draw(output="mpl",reverse_bits=True))
#
# executing the operator on all possible inputs
#
print("Control state is",control_state)
print("input --> output")
for the_input in all_inputs:
# create the circuit
qaux = QuantumRegister(2,"qaux")
q = QuantumRegister(5,"q")
c = ClassicalRegister(5,"c")
qc = QuantumCircuit(q,qaux,c)
# set the initial value of the circuit w.r.t. the input
if the_input[0] =='1': qc.x(q[4])
if the_input[1] =='1': qc.x(q[3])
if the_input[2] =='1': qc.x(q[2])
if the_input[3] =='1': qc.x(q[1])
if the_input[4] =='1': qc.x(q[0])
# implement the CCNOT gates
for b in range(4):
if control_state[b] == '0':
qc.x(q[4-b])
qc.ccx(q[4],q[3],qaux[1])
qc.ccx(q[2],q[1],qaux[0])
qc.ccx(qaux[1],qaux[0],q[0])
qc.ccx(q[4],q[3],qaux[1])
qc.ccx(q[2],q[1],qaux[0])
for b in range(4):
if control_state[b] == '0':
qc.x(q[4-b])
# measure the main quantum register
qc.measure(q,c)
# execute the circuit
job = execute(qc,Aer.get_backend('qasm_simulator'),shots=1)
counts = job.result().get_counts(qc)
for key in counts: the_output = key
printed_str = the_input[0:4]+" "+the_input[4]+" --> "+the_output[0:4]+" "+the_output[4]
if (the_input!=the_output): printed_str = printed_str + " the output is different than the input"
print(printed_str)
# try different values
#c4not()
#c4not('1001')
c4not('0011')
#c4not('1101')
#c4not('0000')
|
https://github.com/Ilan-Bondarevsky/qiskit_algorithm
|
Ilan-Bondarevsky
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# 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=too-many-function-args, unexpected-keyword-arg
"""THIS FILE IS DEPRECATED AND WILL BE REMOVED IN RELEASE 0.9.
"""
import warnings
from qiskit.converters import dag_to_circuit, circuit_to_dag
from qiskit.transpiler import CouplingMap
from qiskit import compiler
from qiskit.transpiler.preset_passmanagers import (default_pass_manager_simulator,
default_pass_manager)
def transpile(circuits, backend=None, basis_gates=None, coupling_map=None,
initial_layout=None, seed_mapper=None, pass_manager=None):
"""transpile one or more circuits.
Args:
circuits (QuantumCircuit or list[QuantumCircuit]): circuits to compile
backend (BaseBackend): a backend to compile for
basis_gates (list[str]): list of basis gate names supported by the
target. Default: ['u1','u2','u3','cx','id']
coupling_map (list): coupling map (perhaps custom) to target in mapping
initial_layout (Layout or dict or list):
Initial position of virtual qubits on physical qubits. The final
layout is not guaranteed to be the same, as the transpiler may permute
qubits through swaps or other means.
seed_mapper (int): random seed for the swap_mapper
pass_manager (PassManager): a pass_manager for the transpiler stages
Returns:
QuantumCircuit or list[QuantumCircuit]: transpiled circuit(s).
Raises:
TranspilerError: in case of bad inputs to transpiler or errors in passes
"""
warnings.warn("qiskit.transpiler.transpile() has been deprecated and will be "
"removed in the 0.9 release. Use qiskit.compiler.transpile() instead.",
DeprecationWarning)
return compiler.transpile(circuits=circuits, backend=backend,
basis_gates=basis_gates, coupling_map=coupling_map,
initial_layout=initial_layout, seed_transpiler=seed_mapper,
pass_manager=pass_manager)
def transpile_dag(dag, basis_gates=None, coupling_map=None,
initial_layout=None, seed_mapper=None, pass_manager=None):
"""Deprecated - Use qiskit.compiler.transpile for transpiling from
circuits to circuits.
Transform a dag circuit into another dag circuit
(transpile), through consecutive passes on the dag.
Args:
dag (DAGCircuit): dag circuit to transform via transpilation
basis_gates (list[str]): list of basis gate names supported by the
target. Default: ['u1','u2','u3','cx','id']
coupling_map (list): A graph of coupling::
[
[control0(int), target0(int)],
[control1(int), target1(int)],
]
eg. [[0, 2], [1, 2], [1, 3], [3, 4]}
initial_layout (Layout or None): A layout object
seed_mapper (int): random seed_mapper for the swap mapper
pass_manager (PassManager): pass manager instance for the transpilation process
If None, a default set of passes are run.
Otherwise, the passes defined in it will run.
If contains no passes in it, no dag transformations occur.
Returns:
DAGCircuit: transformed dag
"""
warnings.warn("transpile_dag has been deprecated and will be removed in the "
"0.9 release. Circuits can be transpiled directly to other "
"circuits with the transpile function.", DeprecationWarning)
if basis_gates is None:
basis_gates = ['u1', 'u2', 'u3', 'cx', 'id']
if pass_manager is None:
# default set of passes
# if a coupling map is given compile to the map
if coupling_map:
pass_manager = default_pass_manager(basis_gates,
CouplingMap(coupling_map),
initial_layout,
seed_transpiler=seed_mapper)
else:
pass_manager = default_pass_manager_simulator(basis_gates)
# run the passes specified by the pass manager
# TODO return the property set too. See #1086
name = dag.name
circuit = dag_to_circuit(dag)
circuit = pass_manager.run(circuit)
dag = circuit_to_dag(circuit)
dag.name = name
return dag
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
# You can show the phase of each state and use
# degrees instead of radians
from qiskit.quantum_info import DensityMatrix
import numpy as np
from qiskit import QuantumCircuit
from qiskit.visualization import plot_state_qsphere
qc = QuantumCircuit(2)
qc.h([0, 1])
qc.cz(0,1)
qc.ry(np.pi/3, 0)
qc.rx(np.pi/5, 1)
qc.z(1)
matrix = DensityMatrix(qc)
plot_state_qsphere(matrix,
show_state_phases = True, use_degrees = True)
|
https://github.com/Alice-Bob-SW/emulation-examples
|
Alice-Bob-SW
|
from qiskit_alice_bob_provider import AliceBobLocalProvider
from qiskit_aer import AerSimulator
import tempfile
from qiskit import transpile, execute, QuantumCircuit
from qiskit.circuit import Qubit, Clbit
from qiskit.circuit.library.phase_oracle import PhaseOracle
from qiskit_algorithms import AmplificationProblem
from qiskit_algorithms import Grover
from qiskit.primitives import BackendSampler
from qiskit.tools.visualization import plot_histogram
import numpy as np
from tqdm.notebook import tqdm
from matplotlib import pyplot as plt
provider = AliceBobLocalProvider()
provider.backends()
backend = provider.get_backend('EMU:40Q:LOGICAL_TARGET')
input_3sat_instance = """
c example DIMACS-CNF 3-SAT
p cnf 3 5
-1 -2 -3 0
1 -2 3 0
1 2 -3 0
1 -2 -3 0
-1 2 3 0
"""
with tempfile.NamedTemporaryFile(mode='w+t', delete=True) as fp:
fp.write(input_3sat_instance)
fp.flush()
oracle = PhaseOracle.from_dimacs_file(fp.name)
oracle.draw('mpl')
transpile(oracle, backend).draw('mpl')
problem = AmplificationProblem(oracle, is_good_state=oracle.evaluate_bitstring)
sampler = BackendSampler(backend, options={'shots': 100_000})
grover = Grover(sampler=sampler)
result = grover.amplify(problem)
sampler.circuits[0].draw('mpl')
sampler.circuits[0].decompose().decompose().draw('mpl')
sampler.transpiled_circuits[0].draw('mpl')
plot_histogram(result.circuit_results[0])
degraded_backend = provider.get_backend('EMU:15Q:LOGICAL_EARLY', average_nb_photons=4, distance=5)
problem = AmplificationProblem(oracle, is_good_state=oracle.evaluate_bitstring)
sampler = BackendSampler(degraded_backend, options={'shots': 100_000})
grover = Grover(sampler=sampler)
result = grover.amplify(problem)
plot_histogram(result.circuit_results[0])
|
https://github.com/farhad-abdi/InSilicoQ
|
farhad-abdi
|
#importing packages
import numpy as np
import matplotlib.pyplot as plt
import torch
from torch.autograd import Function
from torchvision import datasets, transforms
import torch.optim as optim
import torch.nn as nn
import torch.nn.functional as F
import qiskit
from qiskit import transpile, assemble
from qiskit.visualization import *
#######################
#IMPLEMENTING QUANTUM CLASS: 1 trainable parameter
#Hadamard gate (superposition) + Rotation_Y (trainable parameter) + Measure_Z. Returning the expectation value over n_shots
class QuantumCircuit:
"""
This class provides an interface to interact with our Quantum Circuit
"""
def __init__(self, n_qubits, backend, shots):
#-----Circuit definition
self._circuit = qiskit.QuantumCircuit(n_qubits)
self.theta = qiskit.circuit.Parameter('theta')
all_qubits = [i for i in range (n_qubits)]#qubits vector
self._circuit.h(all_qubits)#over all the qubits
self._circuit.barrier()
self._circuit.ry(self.theta, all_qubits)
self._circuit.measure_all()
#-----
self.backend = backend
self.shots = shots
def run(self, thetas):
#acting on a simulator
t_qc = transpile(self._circuit,
self.backend)#matching the features of a quantum device
qobj = assemble(t_qc,
shots = self.shots,
parameter_binds = [{self.theta: theta} for theta in thetas])#assembling features (circuit, sampling, parameter list)
job = self.backend.run(qobj)#running on the simulator
result = job.result().get_counts() #counts for each values: |0> or |1>. DIVERSO DA LINK
counts = np.array(list(result.values()))
states = np.array(list(result.keys())).astype(float)
# Compute probability for each state
probabilities = counts / self.shots
# Get state expectation
expectation = np.sum(states * probabilities)
return np.array([expectation])
#testing the implementation
simulator = qiskit.Aer.get_backend('qasm_simulator')
n_qubits = 1
circuit = QuantumCircuit(n_qubits, simulator, 100)
print(circuit._circuit)
#circuit._circuit.draw(output='mpl')#to print as a pyplot figure (new library needed)
exp = circuit.run([np.pi])
print('Expected value for rotation pi: {}'.format(exp[0]))
#######################
#CREATING A QUANTUM CLASSICAL CLASS
#extending autograd functions for a quantum layer(forward and backward)
class HybridFunction(Function):
"""Hybrid quantum-classical function definition"""
@staticmethod
def forward(ctx, input, quantum_circuit, shift):
"""Forward pass computation"""
ctx.shift = shift
ctx.quantum_circuit = quantum_circuit
# context variable (it may take multiple values and return them related to the context). Used to keep track for backpropagation
expectation_z = ctx.quantum_circuit.run(input[0].tolist()) #evaluating model with trainable parameter
result = torch.tensor([expectation_z])
ctx.save_for_backward(input, result) #saves a given tensor for a future call to backward (trainable parameter and the result obtained)
return result
@staticmethod
def backward(ctx, grad_output): #grad_output os previous gradient
"""Backward computation"""
input, expectation =ctx.saved_tensors #evaluated in forward
input_list = np.array(input.tolist())
#shifting parameters
shift_right = input_list + np.ones(input_list.shape) * ctx.shift
shift_left = input_list - np.ones(input_list.shape) * ctx.shift
gradients=[]
for i in range(len(input_list)):
#evaluating model after shift
expectation_right = ctx.quantum_circuit.run(shift_right[i])
expectation_left = ctx.quantum_circuit.run(shift_left[i])
#evaluating gradient with finite difference formula
gradient = torch.tensor([expectation_right]) - torch.tensor([expectation_left])
gradients.append(gradient)
gradients = np.array([gradients]).T
return torch.tensor([gradients]).float() * grad_output.float(), None, None
#returns the chain of previous gradient and evaluated gradient
class Hybrid(nn.Module):
"""Hybrid quantum-cassical layer definition"""
def __init__(self, n_qubits ,backend, shots, shift):
super(Hybrid, self).__init__()
self.quantum_circuit = QuantumCircuit(n_qubits, backend, shots)
self.shift = shift #parameter shift
def forward(self, input):
return HybridFunction.apply(input, self.quantum_circuit, self.shift) #calling forward and backward
##################3
#DATA LOADING
#training data
n_samples=100
X_train=datasets.MNIST(root='./data', train=True, download=True, transform=transforms.Compose([transforms.ToTensor()]))
#keeping only labels 0 and 1
idx=np.append(np.where(X_train.targets == 0)[0][:n_samples], np.where(X_train.targets == 1)[0][:n_samples])
X_train.data = X_train.data[idx] #tensor values
X_train.targets = X_train.targets[idx]#tensor labels
#making batches (dim = 1). Ir returns an iterable(pytorch tensor)
train_loader = torch.utils.data.DataLoader(X_train, batch_size=1, shuffle=True)
data_iter = iter(train_loader)#making the iterable an iterator, an object with the next method that can be used in a for cycle
#showing samples
n_samples_show = 6
fig, axes = plt.subplots(nrows=1, ncols=int(n_samples_show), figsize=(10, 3))
#subolot returns the figure and axis that are indipendent as default
while n_samples_show > 0:
images, targets = data_iter.__next__()
axes[int(n_samples_show) - 1].imshow(images[0].numpy().squeeze(), cmap='gray')#squeeze removes unuseful dim(1). Converting into a numpy vector
axes[int(n_samples_show) - 1].set_xticks([])
axes[int(n_samples_show) - 1].set_yticks([])
axes[int(n_samples_show) - 1].set_title("Labeled: {}".format(targets.item()))
n_samples_show -= 1
#validation data
n_samples = 50
X_test = datasets.MNIST(root='./data', train=False, download=True,
transform=transforms.Compose([transforms.ToTensor()]))
idx = np.append(np.where(X_test.targets == 0)[0][:n_samples],
np.where(X_test.targets == 1)[0][:n_samples])
X_test.data = X_test.data[idx]
X_test.targets = X_test.targets[idx]
test_loader = torch.utils.data.DataLoader(X_test, batch_size=1, shuffle=True)
#########################
#CREATING THE NN
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 6, kernel_size=5) #input = gray scale
self.conv2 = nn.Conv2d(6, 16, kernel_size=5)
self.dropout = nn.Dropout2d() #deactivating randomly some neurons to avoid overfitting
self.fc1 = nn.Linear(256, 64) #input dimension: CH(16) x Matrix_dim (4x4)
self.fc2 = nn.Linear(64,1)
self.hybrid = Hybrid(n_qubits, qiskit.Aer.get_backend('qasm_simulator'), 100, np.pi/2 )
def forward(self, x):
x = F.max_pool2d(F.relu(self.conv1(x)),2)
x = F.max_pool2d(F.relu(self.conv2(x)),2)
x = self.dropout(x)
x = x.view(1,-1) #reshaping tensor
x = F.relu(self.fc1(x))
x = self.fc2(x)
x = self.hybrid(x) #calling the forward method
return torch.cat((x, 1-x),-1)#returning probabilities
#######################
#TRAINING AND TESTING
#function to train the nn
def training_loop (n_epochs, optimizer, model, loss_fn, train_loader):
loss_values = []
for epoch in range(0, n_epochs, +1):
total_loss = []
for batch_idx, (data, target) in enumerate(train_loader):
optimizer.zero_grad()#getting rid of previous gradients
output = model(data)#forward pass
loss = loss_fn(output, target)
loss.backward()
optimizer.step()#updating parameters
total_loss.append(loss.item())#item transforms into a number
loss_values.append(sum(total_loss)/len(total_loss))#obtainign the average loss
print('Training [{:.0f}%] Loss: {:.4f}'.format(100*(epoch+1)/n_epochs, loss_values[-1]))
return loss_values
#defining a function to test our net
def validate(model, test_loader, loss_function, n_test, axes):
correct = 0
total_loss = []
count = 0
with torch.no_grad(): # disabling the gradient as we don't want to update parameters
for batch_idx, (data, target) in enumerate(test_loader):
output = model(data) #evaluating the model on test data
# evaluating the accuracy of our model
pred = output.argmax(dim=1,
keepdim=True) # we are interested in the max value of probability
correct += pred.eq(target.view_as(pred)).sum().item() # checking if it matches with label
#evluating loss function
loss = loss_function(output, target)
total_loss.append(loss.item())
#printing the resut as images
if count >= n_test:
continue
else:
axes[count].imshow(data[0].numpy().squeeze(), cmap='gray')
axes[count].set_xticks([])
axes[count].set_yticks([])
axes[count].set_title('Predicted {}'.format(pred.item()))
count += 1
print('Performance on test data: \n\tLoss: {:.4f}\n\tAccuracy: {:.1f}%'
.format(sum(total_loss)/len(total_loss),(correct / len(test_loader))*100))
#Training the NN
#we can use any optimiser, learning rate and cost/loss function to train over multiple epochs
model = Net()
params = list(model.parameters())
learning_rate = 0.001
optimizer = optim.Adam(params, learning_rate)
loss_func = nn.NLLLoss()
epochs = 20
loss_list = []
model.train() #training the module in training mode(specifying the intention to the layers). Used for dropout or batchnorm
loss_list = (training_loop(epochs, optimizer, model, loss_func, train_loader))
#plotting the training graph
plt.figure(num=2)
plt.plot(loss_list)
plt.title('Hybrid NN Training convergence')
plt.xlabel('Training Iterations')
plt.ylabel('Neg Log Likelihood Loss')
###########################
#TESTING THE NN
n_test_show = 6
fig, axes = plt.subplots(nrows=1, ncols=n_test_show, figsize=(10, 3))
model.eval()
validate(model, test_loader, loss_func, n_test_show, axes)
plt.show()
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import numpy as np
import copy
# Problem modelling imports
from docplex.mp.model import Model
# Qiskit imports
from qiskit.algorithms.minimum_eigensolvers import QAOA, NumPyMinimumEigensolver
from qiskit.algorithms.optimizers import COBYLA
from qiskit.primitives import Sampler
from qiskit.utils.algorithm_globals import algorithm_globals
from qiskit_optimization.algorithms import MinimumEigenOptimizer, CplexOptimizer
from qiskit_optimization import QuadraticProgram
from qiskit_optimization.problems.variable import VarType
from qiskit_optimization.converters.quadratic_program_to_qubo import QuadraticProgramToQubo
from qiskit_optimization.translators import from_docplex_mp
def create_problem(mu: np.array, sigma: np.array, total: int = 3) -> QuadraticProgram:
"""Solve the quadratic program using docplex."""
mdl = Model()
x = [mdl.binary_var("x%s" % i) for i in range(len(sigma))]
objective = mdl.sum([mu[i] * x[i] for i in range(len(mu))])
objective -= 2 * mdl.sum(
[sigma[i, j] * x[i] * x[j] for i in range(len(mu)) for j in range(len(mu))]
)
mdl.maximize(objective)
cost = mdl.sum(x)
mdl.add_constraint(cost == total)
qp = from_docplex_mp(mdl)
return qp
def relax_problem(problem) -> QuadraticProgram:
"""Change all variables to continuous."""
relaxed_problem = copy.deepcopy(problem)
for variable in relaxed_problem.variables:
variable.vartype = VarType.CONTINUOUS
return relaxed_problem
mu = np.array([3.418, 2.0913, 6.2415, 4.4436, 10.892, 3.4051])
sigma = np.array(
[
[1.07978412, 0.00768914, 0.11227606, -0.06842969, -0.01016793, -0.00839765],
[0.00768914, 0.10922887, -0.03043424, -0.0020045, 0.00670929, 0.0147937],
[0.11227606, -0.03043424, 0.985353, 0.02307313, -0.05249785, 0.00904119],
[-0.06842969, -0.0020045, 0.02307313, 0.6043817, 0.03740115, -0.00945322],
[-0.01016793, 0.00670929, -0.05249785, 0.03740115, 0.79839634, 0.07616951],
[-0.00839765, 0.0147937, 0.00904119, -0.00945322, 0.07616951, 1.08464544],
]
)
qubo = create_problem(mu, sigma)
print(qubo.prettyprint())
result = CplexOptimizer().solve(qubo)
print(result.prettyprint())
qp = relax_problem(QuadraticProgramToQubo().convert(qubo))
print(qp.prettyprint())
sol = CplexOptimizer().solve(qp)
print(sol.prettyprint())
c_stars = sol.samples[0].x
print(c_stars)
algorithm_globals.random_seed = 12345
qaoa_mes = QAOA(sampler=Sampler(), optimizer=COBYLA(), initial_point=[0.0, 1.0])
exact_mes = NumPyMinimumEigensolver()
qaoa = MinimumEigenOptimizer(qaoa_mes)
qaoa_result = qaoa.solve(qubo)
print(qaoa_result.prettyprint())
from qiskit import QuantumCircuit
thetas = [2 * np.arcsin(np.sqrt(c_star)) for c_star in c_stars]
init_qc = QuantumCircuit(len(sigma))
for idx, theta in enumerate(thetas):
init_qc.ry(theta, idx)
init_qc.draw(output="mpl")
from qiskit.circuit import Parameter
beta = Parameter("Ξ²")
ws_mixer = QuantumCircuit(len(sigma))
for idx, theta in enumerate(thetas):
ws_mixer.ry(-theta, idx)
ws_mixer.rz(-2 * beta, idx)
ws_mixer.ry(theta, idx)
ws_mixer.draw(output="mpl")
ws_qaoa_mes = QAOA(
sampler=Sampler(),
optimizer=COBYLA(),
initial_state=init_qc,
mixer=ws_mixer,
initial_point=[0.0, 1.0],
)
ws_qaoa = MinimumEigenOptimizer(ws_qaoa_mes)
ws_qaoa_result = ws_qaoa.solve(qubo)
print(ws_qaoa_result.prettyprint())
def format_qaoa_samples(samples, max_len: int = 10):
qaoa_res = []
for s in samples:
if sum(s.x) == 3:
qaoa_res.append(("".join([str(int(_)) for _ in s.x]), s.fval, s.probability))
res = sorted(qaoa_res, key=lambda x: -x[1])[0:max_len]
return [(_[0] + f": value: {_[1]:.3f}, probability: {1e2*_[2]:.1f}%") for _ in res]
format_qaoa_samples(qaoa_result.samples)
format_qaoa_samples(ws_qaoa_result.samples)
from qiskit_optimization.algorithms import WarmStartQAOAOptimizer
qaoa_mes = QAOA(sampler=Sampler(), optimizer=COBYLA(), initial_point=[0.0, 1.0])
ws_qaoa = WarmStartQAOAOptimizer(
pre_solver=CplexOptimizer(), relax_for_pre_solver=True, qaoa=qaoa_mes, epsilon=0.0
)
ws_result = ws_qaoa.solve(qubo)
print(ws_result.prettyprint())
format_qaoa_samples(ws_result.samples)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.tools.visualization import circuit_drawer
q = QuantumRegister(1)
c = ClassicalRegister(1)
qc = QuantumCircuit(q, c)
qc.h(q)
qc.measure(q, c)
circuit_drawer(qc, output='mpl', style={'backgroundcolor': '#EEEEEE'})
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
#In case you don't have qiskit, install it now
%pip install qiskit --quiet
#Installing/upgrading pylatexenc seems to have fixed my mpl issue
#If you try this and it doesn't work, try also restarting the runtime/kernel
%pip install pylatexenc --quiet
!pip install -Uqq ipdb
!pip install qiskit_optimization
import networkx as nx
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import BasicAer
from qiskit.compiler import transpile
from qiskit.quantum_info.operators import Operator, Pauli
from qiskit.quantum_info import process_fidelity
from qiskit.extensions.hamiltonian_gate import HamiltonianGate
from qiskit.extensions import RXGate, XGate, CXGate
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, Aer, execute
import numpy as np
from qiskit.visualization import plot_histogram
import ipdb
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
#quadratic optimization
from qiskit_optimization import QuadraticProgram
from qiskit_optimization.converters import QuadraticProgramToQubo
%pdb on
# def ApplyCost(qc, gamma):
# Ix = np.array([[1,0],[0,1]])
# Zx= np.array([[1,0],[0,-1]])
# Xx = np.array([[0,1],[1,0]])
# Temp = (Ix-Zx)/2
# T = Operator(Temp)
# I = Operator(Ix)
# Z = Operator(Zx)
# X = Operator(Xx)
# FinalOp=-2*(T^I^T)-(I^T^T)-(T^I^I)+2*(I^T^I)-3*(I^I^T)
# ham = HamiltonianGate(FinalOp,gamma)
# qc.append(ham,[0,1,2])
task = QuadraticProgram(name = 'QUBO on QC')
task.binary_var(name = 'x')
task.binary_var(name = 'y')
task.binary_var(name = 'z')
task.minimize(linear = {"x":-1,"y":2,"z":-3}, quadratic = {("x", "z"): -2, ("y", "z"): -1})
qubo = QuadraticProgramToQubo().convert(task) #convert to QUBO
operator, offset = qubo.to_ising()
print(operator)
# ham = HamiltonianGate(operator,0)
# print(ham)
Ix = np.array([[1,0],[0,1]])
Zx= np.array([[1,0],[0,-1]])
Xx = np.array([[0,1],[1,0]])
Temp = (Ix-Zx)/2
T = Operator(Temp)
I = Operator(Ix)
Z = Operator(Zx)
X = Operator(Xx)
FinalOp=-2*(T^I^T)-(I^T^T)-(T^I^I)+2*(I^T^I)-3*(I^I^T)
ham = HamiltonianGate(FinalOp,0)
print(ham)
#define PYBIND11_DETAILED_ERROR_MESSAGES
def compute_expectation(counts):
"""
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():
x = int(bitstring[2])
y = int(bitstring[1])
z = int(bitstring[0])
obj = -2*x*z-y*z-x+2*y-3*z
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_circ(theta):
"""
Creates a parametrized qaoa circuit
Args:
G: networkx graph
theta: list
unitary parameters
Returns:
qc: qiskit circuit
"""
nqubits = 3
n,m=3,3
p = len(theta)//2 # number of alternating unitaries
qc = QuantumCircuit(nqubits,nqubits)
Ix = np.array([[1,0],[0,1]])
Zx= np.array([[1,0],[0,-1]])
Xx = np.array([[0,1],[1,0]])
Temp = (Ix-Zx)/2
T = Operator(Temp)
I = Operator(Ix)
Z = Operator(Zx)
X = Operator(Xx)
FinalOp=-2*(Z^I^Z)-(I^Z^Z)-(Z^I^I)+2*(I^Z^I)-3*(I^I^Z)
beta = theta[:p]
gamma = theta[p:]
# initial_state
for i in range(0, nqubits):
qc.h(i)
for irep in range(0, p):
#ipdb.set_trace(context=6)
# problem unitary
# for pair in list(G.edges()):
# qc.rzz(2 * gamma[irep], pair[0], pair[1])
#ApplyCost(qc,2*0)
ham = HamiltonianGate(operator,2 * gamma[irep])
qc.append(ham,[0,1,2])
# mixer unitary
for i in range(0, nqubits):
qc.rx(2 * beta[irep], i)
qc.measure(qc.qubits[:n],qc.clbits[:m])
return qc
# Finally we write a function that executes the circuit on the chosen backend
def get_expectation(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_circ(theta)
# ipdb.set_trace(context=6)
counts = {}
job = execute(qc, backend, shots=1024)
result = job.result()
counts=result.get_counts(qc)
return compute_expectation(counts)
return execute_circ
from scipy.optimize import minimize
expectation = get_expectation()
res = minimize(expectation, [1, 1], method='COBYLA')
expectation = get_expectation()
res = minimize(expectation, res.x, method='COBYLA')
res
from qiskit.visualization import plot_histogram
backend = Aer.get_backend('aer_simulator')
backend.shots = 512
qc_res = create_qaoa_circ(res.x)
backend = Aer.get_backend('qasm_simulator')
job = execute(qc_res, backend, shots=1024)
result = job.result()
counts=result.get_counts(qc_res)
plot_histogram(counts)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
# Necessary imports
import numpy as np
import matplotlib.pyplot as plt
from torch import Tensor
from torch.nn import Linear, CrossEntropyLoss, MSELoss
from torch.optim import LBFGS
from qiskit import QuantumCircuit
from qiskit.utils import algorithm_globals
from qiskit.circuit import Parameter
from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap
from qiskit_machine_learning.neural_networks import SamplerQNN, EstimatorQNN
from qiskit_machine_learning.connectors import TorchConnector
# Set seed for random generators
algorithm_globals.random_seed = 42
# Generate random dataset
# Select dataset dimension (num_inputs) and size (num_samples)
num_inputs = 2
num_samples = 20
# Generate random input coordinates (X) and binary labels (y)
X = 2 * algorithm_globals.random.random([num_samples, num_inputs]) - 1
y01 = 1 * (np.sum(X, axis=1) >= 0) # in { 0, 1}, y01 will be used for SamplerQNN example
y = 2 * y01 - 1 # in {-1, +1}, y will be used for EstimatorQNN example
# Convert to torch Tensors
X_ = Tensor(X)
y01_ = Tensor(y01).reshape(len(y)).long()
y_ = Tensor(y).reshape(len(y), 1)
# Plot dataset
for x, y_target in zip(X, y):
if y_target == 1:
plt.plot(x[0], x[1], "bo")
else:
plt.plot(x[0], x[1], "go")
plt.plot([-1, 1], [1, -1], "--", color="black")
plt.show()
# Set up a circuit
feature_map = ZZFeatureMap(num_inputs)
ansatz = RealAmplitudes(num_inputs)
qc = QuantumCircuit(num_inputs)
qc.compose(feature_map, inplace=True)
qc.compose(ansatz, inplace=True)
qc.draw("mpl")
# Setup QNN
qnn1 = EstimatorQNN(
circuit=qc, input_params=feature_map.parameters, weight_params=ansatz.parameters
)
# Set up PyTorch module
# Note: If we don't explicitly declare the initial weights
# they are chosen uniformly at random from [-1, 1].
initial_weights = 0.1 * (2 * algorithm_globals.random.random(qnn1.num_weights) - 1)
model1 = TorchConnector(qnn1, initial_weights=initial_weights)
print("Initial weights: ", initial_weights)
# Test with a single input
model1(X_[0, :])
# Define optimizer and loss
optimizer = LBFGS(model1.parameters())
f_loss = MSELoss(reduction="sum")
# Start training
model1.train() # set model to training mode
# Note from (https://pytorch.org/docs/stable/optim.html):
# Some optimization algorithms such as LBFGS need to
# reevaluate the function multiple times, so you have to
# pass in a closure that allows them to recompute your model.
# The closure should clear the gradients, compute the loss,
# and return it.
def closure():
optimizer.zero_grad() # Initialize/clear gradients
loss = f_loss(model1(X_), y_) # Evaluate loss function
loss.backward() # Backward pass
print(loss.item()) # Print loss
return loss
# Run optimizer step4
optimizer.step(closure)
# Evaluate model and compute accuracy
y_predict = []
for x, y_target in zip(X, y):
output = model1(Tensor(x))
y_predict += [np.sign(output.detach().numpy())[0]]
print("Accuracy:", sum(y_predict == y) / len(y))
# Plot results
# red == wrongly classified
for x, y_target, y_p in zip(X, y, y_predict):
if y_target == 1:
plt.plot(x[0], x[1], "bo")
else:
plt.plot(x[0], x[1], "go")
if y_target != y_p:
plt.scatter(x[0], x[1], s=200, facecolors="none", edgecolors="r", linewidths=2)
plt.plot([-1, 1], [1, -1], "--", color="black")
plt.show()
# Define feature map and ansatz
feature_map = ZZFeatureMap(num_inputs)
ansatz = RealAmplitudes(num_inputs, entanglement="linear", reps=1)
# Define quantum circuit of num_qubits = input dim
# Append feature map and ansatz
qc = QuantumCircuit(num_inputs)
qc.compose(feature_map, inplace=True)
qc.compose(ansatz, inplace=True)
# Define SamplerQNN and initial setup
parity = lambda x: "{:b}".format(x).count("1") % 2 # optional interpret function
output_shape = 2 # parity = 0, 1
qnn2 = SamplerQNN(
circuit=qc,
input_params=feature_map.parameters,
weight_params=ansatz.parameters,
interpret=parity,
output_shape=output_shape,
)
# Set up PyTorch module
# Reminder: If we don't explicitly declare the initial weights
# they are chosen uniformly at random from [-1, 1].
initial_weights = 0.1 * (2 * algorithm_globals.random.random(qnn2.num_weights) - 1)
print("Initial weights: ", initial_weights)
model2 = TorchConnector(qnn2, initial_weights)
# Define model, optimizer, and loss
optimizer = LBFGS(model2.parameters())
f_loss = CrossEntropyLoss() # Our output will be in the [0,1] range
# Start training
model2.train()
# Define LBFGS closure method (explained in previous section)
def closure():
optimizer.zero_grad(set_to_none=True) # Initialize gradient
loss = f_loss(model2(X_), y01_) # Calculate loss
loss.backward() # Backward pass
print(loss.item()) # Print loss
return loss
# Run optimizer (LBFGS requires closure)
optimizer.step(closure);
# Evaluate model and compute accuracy
y_predict = []
for x in X:
output = model2(Tensor(x))
y_predict += [np.argmax(output.detach().numpy())]
print("Accuracy:", sum(y_predict == y01) / len(y01))
# plot results
# red == wrongly classified
for x, y_target, y_ in zip(X, y01, y_predict):
if y_target == 1:
plt.plot(x[0], x[1], "bo")
else:
plt.plot(x[0], x[1], "go")
if y_target != y_:
plt.scatter(x[0], x[1], s=200, facecolors="none", edgecolors="r", linewidths=2)
plt.plot([-1, 1], [1, -1], "--", color="black")
plt.show()
# Generate random dataset
num_samples = 20
eps = 0.2
lb, ub = -np.pi, np.pi
f = lambda x: np.sin(x)
X = (ub - lb) * algorithm_globals.random.random([num_samples, 1]) + lb
y = f(X) + eps * (2 * algorithm_globals.random.random([num_samples, 1]) - 1)
plt.plot(np.linspace(lb, ub), f(np.linspace(lb, ub)), "r--")
plt.plot(X, y, "bo")
plt.show()
# Construct simple feature map
param_x = Parameter("x")
feature_map = QuantumCircuit(1, name="fm")
feature_map.ry(param_x, 0)
# Construct simple feature map
param_y = Parameter("y")
ansatz = QuantumCircuit(1, name="vf")
ansatz.ry(param_y, 0)
qc = QuantumCircuit(1)
qc.compose(feature_map, inplace=True)
qc.compose(ansatz, inplace=True)
# Construct QNN
qnn3 = EstimatorQNN(circuit=qc, input_params=[param_x], weight_params=[param_y])
# Set up PyTorch module
# Reminder: If we don't explicitly declare the initial weights
# they are chosen uniformly at random from [-1, 1].
initial_weights = 0.1 * (2 * algorithm_globals.random.random(qnn3.num_weights) - 1)
model3 = TorchConnector(qnn3, initial_weights)
# Define optimizer and loss function
optimizer = LBFGS(model3.parameters())
f_loss = MSELoss(reduction="sum")
# Start training
model3.train() # set model to training mode
# Define objective function
def closure():
optimizer.zero_grad(set_to_none=True) # Initialize gradient
loss = f_loss(model3(Tensor(X)), Tensor(y)) # Compute batch loss
loss.backward() # Backward pass
print(loss.item()) # Print loss
return loss
# Run optimizer
optimizer.step(closure)
# Plot target function
plt.plot(np.linspace(lb, ub), f(np.linspace(lb, ub)), "r--")
# Plot data
plt.plot(X, y, "bo")
# Plot fitted line
y_ = []
for x in np.linspace(lb, ub):
output = model3(Tensor([x]))
y_ += [output.detach().numpy()[0]]
plt.plot(np.linspace(lb, ub), y_, "g-")
plt.show()
# Additional torch-related imports
import torch
from torch import cat, no_grad, manual_seed
from torch.utils.data import DataLoader
from torchvision import datasets, transforms
import torch.optim as optim
from torch.nn import (
Module,
Conv2d,
Linear,
Dropout2d,
NLLLoss,
MaxPool2d,
Flatten,
Sequential,
ReLU,
)
import torch.nn.functional as F
# Train Dataset
# -------------
# Set train shuffle seed (for reproducibility)
manual_seed(42)
batch_size = 1
n_samples = 100 # We will concentrate on the first 100 samples
# Use pre-defined torchvision function to load MNIST train data
X_train = datasets.MNIST(
root="./data", train=True, download=True, transform=transforms.Compose([transforms.ToTensor()])
)
# Filter out labels (originally 0-9), leaving only labels 0 and 1
idx = np.append(
np.where(X_train.targets == 0)[0][:n_samples], np.where(X_train.targets == 1)[0][:n_samples]
)
X_train.data = X_train.data[idx]
X_train.targets = X_train.targets[idx]
# Define torch dataloader with filtered data
train_loader = DataLoader(X_train, batch_size=batch_size, shuffle=True)
n_samples_show = 6
data_iter = iter(train_loader)
fig, axes = plt.subplots(nrows=1, ncols=n_samples_show, figsize=(10, 3))
while n_samples_show > 0:
images, targets = data_iter.__next__()
axes[n_samples_show - 1].imshow(images[0, 0].numpy().squeeze(), cmap="gray")
axes[n_samples_show - 1].set_xticks([])
axes[n_samples_show - 1].set_yticks([])
axes[n_samples_show - 1].set_title("Labeled: {}".format(targets[0].item()))
n_samples_show -= 1
# Test Dataset
# -------------
# Set test shuffle seed (for reproducibility)
# manual_seed(5)
n_samples = 50
# Use pre-defined torchvision function to load MNIST test data
X_test = datasets.MNIST(
root="./data", train=False, download=True, transform=transforms.Compose([transforms.ToTensor()])
)
# Filter out labels (originally 0-9), leaving only labels 0 and 1
idx = np.append(
np.where(X_test.targets == 0)[0][:n_samples], np.where(X_test.targets == 1)[0][:n_samples]
)
X_test.data = X_test.data[idx]
X_test.targets = X_test.targets[idx]
# Define torch dataloader with filtered data
test_loader = DataLoader(X_test, batch_size=batch_size, shuffle=True)
# Define and create QNN
def create_qnn():
feature_map = ZZFeatureMap(2)
ansatz = RealAmplitudes(2, reps=1)
qc = QuantumCircuit(2)
qc.compose(feature_map, inplace=True)
qc.compose(ansatz, inplace=True)
# REMEMBER TO SET input_gradients=True FOR ENABLING HYBRID GRADIENT BACKPROP
qnn = EstimatorQNN(
circuit=qc,
input_params=feature_map.parameters,
weight_params=ansatz.parameters,
input_gradients=True,
)
return qnn
qnn4 = create_qnn()
# Define torch NN module
class Net(Module):
def __init__(self, qnn):
super().__init__()
self.conv1 = Conv2d(1, 2, kernel_size=5)
self.conv2 = Conv2d(2, 16, kernel_size=5)
self.dropout = Dropout2d()
self.fc1 = Linear(256, 64)
self.fc2 = Linear(64, 2) # 2-dimensional input to QNN
self.qnn = TorchConnector(qnn) # Apply torch connector, weights chosen
# uniformly at random from interval [-1,1].
self.fc3 = Linear(1, 1) # 1-dimensional output from QNN
def forward(self, x):
x = F.relu(self.conv1(x))
x = F.max_pool2d(x, 2)
x = F.relu(self.conv2(x))
x = F.max_pool2d(x, 2)
x = self.dropout(x)
x = x.view(x.shape[0], -1)
x = F.relu(self.fc1(x))
x = self.fc2(x)
x = self.qnn(x) # apply QNN
x = self.fc3(x)
return cat((x, 1 - x), -1)
model4 = Net(qnn4)
# Define model, optimizer, and loss function
optimizer = optim.Adam(model4.parameters(), lr=0.001)
loss_func = NLLLoss()
# Start training
epochs = 10 # Set number of epochs
loss_list = [] # Store loss history
model4.train() # Set model to training mode
for epoch in range(epochs):
total_loss = []
for batch_idx, (data, target) in enumerate(train_loader):
optimizer.zero_grad(set_to_none=True) # Initialize gradient
output = model4(data) # Forward pass
loss = loss_func(output, target) # Calculate loss
loss.backward() # Backward pass
optimizer.step() # Optimize weights
total_loss.append(loss.item()) # Store loss
loss_list.append(sum(total_loss) / len(total_loss))
print("Training [{:.0f}%]\tLoss: {:.4f}".format(100.0 * (epoch + 1) / epochs, loss_list[-1]))
# Plot loss convergence
plt.plot(loss_list)
plt.title("Hybrid NN Training Convergence")
plt.xlabel("Training Iterations")
plt.ylabel("Neg. Log Likelihood Loss")
plt.show()
torch.save(model4.state_dict(), "model4.pt")
qnn5 = create_qnn()
model5 = Net(qnn5)
model5.load_state_dict(torch.load("model4.pt"))
model5.eval() # set model to evaluation mode
with no_grad():
correct = 0
for batch_idx, (data, target) in enumerate(test_loader):
output = model5(data)
if len(output.shape) == 1:
output = output.reshape(1, *output.shape)
pred = output.argmax(dim=1, keepdim=True)
correct += pred.eq(target.view_as(pred)).sum().item()
loss = loss_func(output, target)
total_loss.append(loss.item())
print(
"Performance on test data:\n\tLoss: {:.4f}\n\tAccuracy: {:.1f}%".format(
sum(total_loss) / len(total_loss), correct / len(test_loader) / batch_size * 100
)
)
# Plot predicted labels
n_samples_show = 6
count = 0
fig, axes = plt.subplots(nrows=1, ncols=n_samples_show, figsize=(10, 3))
model5.eval()
with no_grad():
for batch_idx, (data, target) in enumerate(test_loader):
if count == n_samples_show:
break
output = model5(data[0:1])
if len(output.shape) == 1:
output = output.reshape(1, *output.shape)
pred = output.argmax(dim=1, keepdim=True)
axes[count].imshow(data[0].numpy().squeeze(), cmap="gray")
axes[count].set_xticks([])
axes[count].set_yticks([])
axes[count].set_title("Predicted {}".format(pred.item()))
count += 1
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qBraid/qBraid
|
qBraid
|
# Copyright (C) 2024 qBraid
#
# This file is part of the qBraid-SDK
#
# The qBraid-SDK is free software released under the GNU General Public License v3
# or later. You can redistribute and/or modify it under the terms of the GPL v3.
# See the LICENSE file in the project root or <https://www.gnu.org/licenses/gpl-3.0.html>.
#
# THERE IS NO WARRANTY for the qBraid-SDK, as per Section 15 of the GPL v3.
"""
Module defining Qiskit conversion extras.
"""
import warnings
from typing import TYPE_CHECKING
from qbraid_core._import import LazyLoader
from qbraid.transpiler.annotations import requires_extras
qiskit_braket_provider = LazyLoader("qiskit_braket_provider", globals(), "qiskit_braket_provider")
qiskit_qir = LazyLoader("qiskit_qir", globals(), "qiskit_qir")
if TYPE_CHECKING:
import braket.circuits
import pyqir
import qiskit.circuit
@requires_extras("qiskit_braket_provider")
def qiskit_to_braket(
circuit: "qiskit.circuit.QuantumCircuit", **kwargs
) -> "braket.circuits.Circuit":
"""Return a Braket quantum circuit from a Qiskit quantum circuit.
Args:
circuit (QuantumCircuit): Qiskit quantum circuit
basis_gates (Optional[Iterable[str]]): The gateset to transpile to.
If `None`, the transpiler will use all gates defined in the Braket SDK.
Default: `None`.
verbatim (bool): Whether to translate the circuit without any modification, in other
words without transpiling it. Default: False.
Returns:
Circuit: Braket circuit
"""
with warnings.catch_warnings():
warnings.simplefilter("ignore", UserWarning)
return qiskit_braket_provider.providers.adapter.to_braket(circuit, **kwargs)
@requires_extras("qiskit_qir")
def qiskit_to_pyqir(circuit: "qiskit.circuit.QuantumCircuit") -> "pyqir.Module":
"""Return a PyQIR module from a Qiskit quantum circuit.
Args:
circuit (QuantumCircuit): Qiskit quantum circuit
Returns:
Module: PyQIR module
"""
return qiskit_qir.to_qir_module(circuit)
|
https://github.com/madmen2/QASM
|
madmen2
|
#Quantum gates basics
from qiskit import *
from qiskit.tools.visualization import plot_bloch_multivector
from qiskit.tools.visualization import plot_histogram
import matplotlib
circuit = QuantumCircuit(1,1) #one qubit one classical bit (one operation )
circuit.x(0)
simulator = Aer.get_backend('statevector_simulator') #describes the quantum state of the qbit
result = execute(circuit, backend= simulator).result()
statevector= result.get_statevector()
print(statevector)
circuit.draw(output='mpl')
#plotting bloch vector
plot_bloch_multivector(statevector)
circuit.measure([0],[0])
simulator= Aer.get_backend('qasm_simulator')
result = execute(circuit, backend= simulator, shots=1023).result()
plot_histogram(result.get_counts(circuit))
#displaying results in matrices
circuit = QuantumCircuit(1,1)
circuit.x(0)
simulator = Aer.get_backend('unitary_simulator') #unitary simulator for matrix representation
result = execute(circuit,backend=simulator).result()
unitary= result.get_unitary()
print(unitary)
|
https://github.com/JouziP/MQITE
|
JouziP
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Oct 13 14:39:39 2022
@author: pejmanjouzdani
"""
import numpy as np
import pandas as pd
from qiskit import QuantumCircuit, transpile
from qiskit import Aer
# from Amplitude.AmplitudeFunctions.getAmplitudes import getAmplitudes
# from Amplitude.AmplitudeFunctions.getIndexsFromExecute import getIndexsFromExecute
from Amplitude.amplitude import AmplitudeClass as Amplitude
def computeAmplFromShots(circ, shots, j_ref, backend = 'qasm_simulator'):
pass
'''
'''
#### FIRST ATTEMPT
df_count = Amplitude.getIndexsFromExecute(circ, shots, backend)
try:
m1 = df_count['n_j'][j_ref]/shots #df_count[0].sum()
# print('------------ RESOLVED AT {shots} SHOTS; FIRST ATTEMPT ---------')
except KeyError :
print('WARNING: FIRST CIRCUIT RUN FAILED !')
print('j_ref is not oobserved in the bitstrings... running the circuit with increased shots')
print(f"Increasing shots from {shots} to {10 * shots}")
print()
#### SECOND ATTEMPT -> INCREASE THE SHOTS
df_count = Amplitude.getIndexsFromExecute(circ, 10*shots, backend)
try:
m1 = df_count['n_j'][j_ref]/shots #df_count[0].sum()
print('------------ RESOLVED AT {10*shots} SHOTS; SECOND ATTEMPT ---------')
except KeyError:
print('WARNING: SECOND CIRCUIT RUN FAILED !')
print('j_ref is not oobserved in the bitstrings in the SECOND circuit run...')
print(f"Increasing shots from {10 * shots} to {100*shots}")
print()
#### THIRD ATTEMPT --> INCREASE SHOTS
df_count = Amplitude.getIndexsFromExecute(circ, 100*shots, backend)
try:
m1 = df_count['n_j'][j_ref]/shots #df_count[0].sum()
print('------------ RESOLVED AT {100*shots} SHOTS; THIRD ATTEMPT ---------')
except:
print('WARNING: THIRD CIRCUIT RUN FAILED !')
print('j_ref is not oobserved in the bitstrings in the THIRD circuit run...')
print(f"Increasing shots from {100 * shots} to {1000 * shots}")
print()
#### FORTH ATTEMPT --> INCREASE SHOTS
df_count = Amplitude.getIndexsFromExecute(circ, 1000*shots, backend)
try:
m1 = df_count['n_j'][j_ref]/shots #df_count[0].sum()
print('------------ RESOLVED AT {1000*shots} SHOTS; FORTH ATTEMPT ---------')
except KeyError:
raise
return m1
if __name__=='__main__':
'''
Testing the function:
create a circ_UQU circuit
'''
from qiskit import QuantumCircuit
from Amplitude.amplitude import AmplitudeClass as Amplitude
from BasicFunctions.functions import getBinary, getState
from MultiQubitGate.functions import multiqubit
################################################################
################################################################
##################### FOR TEST #######################
################################################################
################################################################
################################################################
################################################################
################################################################
def getRandomU(nspins, num_layers=10):
circ = QuantumCircuit(nspins)
for l in range(num_layers):
for i in range(nspins):
##############
q=np.random.randint(nspins)
g=np.random.randint(1, 4)
p=np.random.uniform(-1,1)
if g==1:
circ.rx(p,q)
if g==2:
circ.ry(p,q)
if g==2:
circ.rz(p,q)
##############
q=np.random.randint(nspins-1)
circ.cnot(q, q+1)
return circ
################################################################
################################################################
def getRandomQ(nspins):
Q = np.random.randint(0,2, size=nspins)
return Q
################################################################
################################################################
def getCircUQU(circ, Q):
circ_uhu=QuantumCircuit.copy(circ)
for (q,o) in enumerate(Q):
if o==0:
pass
if o==1:
circ_uhu.x(q)
if o==2:
circ_uhu.y(q)
if o==3:
circ_uhu.z(q)
circ_uhu=circ_uhu.compose(QuantumCircuit.copy(circ).inverse())
return circ_uhu
################################################################
################################################################
seed = 1211
np.random.seed(seed)
################################################################
################################################################
nspins = 2 # >=2
num_layers =2
num_itr =1
machine_precision = 10
shots = 1000000
eta = 100
significant_figures = 3#np.log10(np.sqrt(shots)).astype(int)
circ_U = getRandomU(nspins, num_layers)
Q = getRandomQ(nspins)
circ_UQU = getCircUQU(circ_U, Q)
print(Q)
|
https://github.com/MonitSharma/Qiskit-Summer-School-and-Quantum-Challenges
|
MonitSharma
|
# please create a 3 qubit GHZ circuit
# please create a 2 qubit ch gate with only cx and ry gate
# Enter your prompt here - Delete this line
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import math
from qiskit import pulse
from qiskit.providers.fake_provider import FakeOpenPulse3Q
# TODO: This example should use a real mock backend.
backend = FakeOpenPulse3Q()
d2 = pulse.DriveChannel(2)
with pulse.build(backend) as bell_prep:
pulse.u2(0, math.pi, 0)
pulse.cx(0, 1)
with pulse.build(backend) as decoupled_bell_prep_and_measure:
# We call our bell state preparation schedule constructed above.
with pulse.align_right():
pulse.call(bell_prep)
pulse.play(pulse.Constant(bell_prep.duration, 0.02), d2)
pulse.barrier(0, 1, 2)
registers = pulse.measure_all()
decoupled_bell_prep_and_measure.draw()
|
https://github.com/Spintronic6889/Introduction-of-Quantum-walk-its-application-on-search-and-decision-making
|
Spintronic6889
|
!python --version
!pip install qiskit
!pip install pylatexenc
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer
from qiskit.visualization import plot_histogram
import matplotlib.pyplot as plt
from qiskit.visualization import plot_state_city
%matplotlib inline
import matplotlib as mpl
from random import randrange
import numpy as np
import networkx as nx
import random
import math
from qiskit.tools.monitor import job_monitor
from random import randrange
pose=[]
for i in range(400):
pose.append([])
#print(pose)
#pose[-1]=1
#print(pose[-1])
pose[0]=200
for k in range(200):
rand = randrange(0,2)
if rand==0:
#print(rand)
pose[k+1]=pose[k]+1
if rand==1:
pose[k+1]=pose[k]-1
#print(pose)
yc=[]
for e in range(400):
yc.append([])
for q in range(400):
yc[q]=0
for h in range(400):
if pose[h]==q:
yc[q]=yc[q]+1
#print((yc))
#print(len(yc))
xc = np.arange(0, 400, 1)
plt.plot(yc)
plt.xlim(150, 250)
class quantom_walk:
def __init__(self):
self.__n=2
self.__steps=1
self.__theta=0
self.__phi=0
self.__qtype=1
self.__shot=5000
def main_qw(self,n,steps,qtype,theta,phi):
self.__qpos = QuantumRegister(n,'qpos')
self.__qcoin = QuantumRegister(1,'qcoin')
self.__cpos = ClassicalRegister(n,'cr')
self.__QC = QuantumCircuit(self.__qpos, self.__qcoin)
if qtype==2: self.__QC.x(self.__qcoin[0])
if qtype==3: self.__QC.u(theta, phi, 0, self.__qcoin[0])
for i in range(steps):
self.__QC.h(self.__qcoin[0])
self.__QC.barrier()
for i in range(n):
self.__QC.mct([self.__qcoin[0]]+self.__qpos[i+1:], self.__qpos[i], None, mode='noancilla')
self.__QC.barrier()
self.__QC.x(self.__qcoin[0])
for i in range(n):
if i+1 < n: self.__QC.x(self.__qpos[i+1:])
self.__QC.mct([self.__qcoin[0]]+self.__qpos[i+1:], self.__qpos[i], None, mode='noancilla')
if i+1 < n: self.__QC.x(self.__qpos[i+1:])
self.__QC.barrier()
a=n/2
p=math.floor(a)
for k in range(n):
if(k<p):
self.__QC.swap(self.__qpos[n-1-k],self.__qpos[k])
def displayh(self):
display(self.__QC.draw(output="mpl"))
def histagramh(self,shot):
self.__QC.measure_all()
job = execute(self.__QC,Aer.get_backend('aer_simulator'),shots=5000)
counts = job.result().get_counts(self.__QC)
return counts
def spacevectorh(self):
backend = Aer.get_backend('statevector_simulator')
job = execute(self.__QC, backend)
result = job.result()
outputstate = result.get_statevector(self.__QC, decimals=3)
print(outputstate)
def plotcityh(self):
backend = Aer.get_backend('statevector_simulator')
job = execute(self.__QC, backend)
result = job.result()
outputstate = result.get_statevector(self.__QC, decimals=3)
from qiskit.visualization import plot_state_city
plot_state_city(outputstate)
return outputstate
def unitaryh(self):
backend = Aer.get_backend('unitary_simulator')
job = execute(self.__QC, backend)
result = job.result()
yy=result.get_unitary(self.__QC, decimals=3)
print(yy)
def IBMQh(self):
from qiskit import IBMQ
IBMQ.save_account('d1441affe8622903745ae099f50bce72c21036f85b14600d18195c977b9efcdee621dd4a981b92d8028c03c4dc1860c82d70f501d345023471402f4f8dad0181',overwrite=True)
provider = IBMQ.load_account()
device = provider.get_backend('ibmq_quito') #we use ibmq_16_melbourne quantum device
job = execute(self.__QC, backend = device) #we pass our circuit and backend as usual
from qiskit.tools.monitor import job_monitor
job_monitor(job) #to see our status in queue
result = job.result()
counts= result.get_counts(self.__QC)
return counts
def instructionset(self):
print(self.__QC.qasm())
qw = quantom_walk()
qw.main_qw(4,4,1,1.5,4)
#qw.instructionset()
#qw.displayh()
#plot_histogram(qw.histagramh(3000), figsize=(20, 5), color=None, number_to_keep=None, sort='asc', target_string=None, legend=None, bar_labels=True, title=None, ax=None)
#qw.histagramh(3000)
#qw.spacevectorh()
#qw.unitaryh()
#qw.plotcityh()
#plot_state_city(qw.plotcityh(), figsize=(20, 10))
#plot_histogram(qw.IBMQh(), figsize=(5, 2), color=None, number_to_keep=None, sort='asc', target_string=None, legend=None, bar_labels=True, title=None, ax=None, filename=None)
#qw.IBMQh()
qw = quantom_walk()
qw.main_qw(2,2,1,1.5,4)
qw.displayh()
qw.main_qw(6,25,1,1.5,4)
plot_histogram(qw.histagramh(3000), figsize=(20, 5), color=None, number_to_keep=None, sort='asc', target_string=None, legend=None, bar_labels=True, title=None, ax=None)
qw.main_qw(3,4,1,1.5,4)
qw.spacevectorh()
qw.main_qw(3,15,1,1.5,4)
plot_state_city(qw.plotcityh(), figsize=(20, 10))
qw.main_qw(2,3,1,1.5,4)
qw.unitaryh()
qw.main_qw(3,2,1,1.5,4)
qw.instructionset()
qw.main_qw(2,1,1,1.5,4)
plot_histogram(qw.IBMQh(), figsize=(5, 2), color=None, number_to_keep=None, sort='asc', target_string=None, legend=None, bar_labels=True, title=None, ax=None, filename=None)
#hadamrad...qtype=1
qw = quantom_walk()
qw.main_qw(3,32,1,0,0)
plot_histogram(qw.histagramh(3000), figsize=(20, 5), color=None, number_to_keep=None, sort='asc', target_string=None, legend=None, bar_labels=True, title=None, ax=None)
#optimized ugate applied...qtype=3
qw = quantom_walk()
qw.main_qw(3,32,3,1.57,1.57)
plot_histogram(qw.histagramh(3000), figsize=(20, 5), color=None, number_to_keep=None, sort='asc', target_string=None, legend=None, bar_labels=True, title=None, ax=None)
|
https://github.com/PavanCyborg/Quantum-Algorithms-Benchmarking
|
PavanCyborg
|
from qiskit.circuit.library import QuantumVolume as QuantumVolumeCircuit
from qiskit.quantum_info import Statevector
qv_circuit = QuantumVolumeCircuit(4)
qv_circuit.decompose().draw()
def get_heavy_outputs(counts):
"""Extract heavy outputs from counts dict.
Args:
counts (dict): Output of `.get_counts()`
Returns:
list: All states with measurement probability greater
than the mean.
"""
# sort the keys of `counts` by value of counts.get(key)
sorted_counts = sorted(counts.keys(), key=counts.get)
# discard results with probability < median
heavy_outputs = sorted_counts[len(sorted_counts)//2:]
return heavy_outputs
def check_threshold(nheavies, ncircuits, nshots):
"""Evaluate adjusted threshold inequality for quantum volume.
Args:
nheavies (int): Total number of heavy outputs measured from device
ncircuits (int): Number of different square circuits run on device
nshots (int): Number of shots per circuit
Returns:
Bool:
True if heavy output probability is > 2/3 with 97% certainty,
otherwise False
"""
from numpy import sqrt
numerator = nheavies - 2*sqrt(nheavies*(nshots-(nheavies/ncircuits)))
return bool(numerator/(ncircuits*nshots) > 2/3)
from qiskit import transpile
from qiskit.visualization import plot_histogram
def test_qv(device, nqubits, ncircuits, nshots):
"""Try to achieve 2**nqubits quantum volume on device.
Args:
device (qiskit.providers.Backend): Device to test.
nqubits (int): Number of qubits to use for test.
ncircuits (int): Number of different circuits to run on the device.
nshots (int): Number of shots per circuit.
Returns:
Bool
True if device passes test, otherwise False.
"""
def get_ideal_probabilities(circuit):
"""Simulates circuit behaviour on a device with no errors."""
state_vector = Statevector.from_instruction(
circuit.remove_final_measurements(inplace=False)
)
#print(state_vector.probabilities_dict())
return state_vector.probabilities_dict()
def get_real_counts(circuit, backend, shots):
"""Runs circuit on device and returns counts dict."""
t_circuit = transpile(circuit, backend)
job = backend.run(t_circuit,
shots=shots,
memory=True)
#print(job.result().get_counts())
return job.result().get_counts()
# generate set of random circuits
qv_circuits = [
QuantumVolumeCircuit(nqubits) for c in range(ncircuits)
]
nheavies = 0 # number of measured heavy outputs
for circuit in qv_circuits:
# simulate circuit
ideal_heavy_outputs = get_heavy_outputs(
get_ideal_probabilities(circuit)
)
# run circuit on device
circuit.measure_all()
real_counts = get_real_counts(circuit, device, nshots)
# record whether device result is in the heavy outputs
for output, count in real_counts.items():
if output in ideal_heavy_outputs:
nheavies += count
# do statistical check to see if device passes test
is_pass = check_threshold(nheavies, ncircuits, nshots)
# calculate percentage of measurements that are heavy outputs
percent_heavy_outputs = nheavies*100/(ncircuits * nshots)
print(f"Quantum Volume: {2**nqubits}\n"
f"Percentage Heavy Outputs: {percent_heavy_outputs:.1f}%\n"
f"Passed?: {is_pass}\n")
return is_pass
from qiskit.providers.fake_provider import FakeSantiago
santiago = FakeSantiago()
test_qv(santiago, 5, ncircuits=150, nshots=50)
|
https://github.com/indian-institute-of-science-qc/qiskit-aakash
|
indian-institute-of-science-qc
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# 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.
"""Test the decompose pass"""
from numpy import pi
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.transpiler.passes import Decompose
from qiskit.converters import circuit_to_dag
from qiskit.circuit.library import HGate, CCXGate, U2Gate
from qiskit.quantum_info.operators import Operator
from qiskit.test import QiskitTestCase
class TestDecompose(QiskitTestCase):
"""Tests the decompose pass."""
def setUp(self):
super().setUp()
# example complex circuit
# ββββββββββ ββββββββββββββββββββ
# q2_0: β€0 ββββββββββββββ βββ€ H ββ€0 β
# β β β ββββββ circuit-57 β
# q2_1: β€1 gate1 ββββββββββββββ ββββββββ€1 β
# β βββββββββββ β βββββββββββββββ
# q2_2: β€2 ββ€0 ββββ ββββββββββββββββββββββ
# βββββββββββ β β
# q2_3: βββββββββββ€1 gate2 ββββ ββββββββββββββββββββββ
# β ββββ΄ββ
# q2_4: βββββββββββ€2 ββ€ X βββββββββββββββββββββ
# βββββββββββββββ
circ1 = QuantumCircuit(3)
circ1.h(0)
circ1.t(1)
circ1.x(2)
my_gate = circ1.to_gate(label="gate1")
circ2 = QuantumCircuit(3)
circ2.h(0)
circ2.cx(0, 1)
circ2.x(2)
my_gate2 = circ2.to_gate(label="gate2")
circ3 = QuantumCircuit(2)
circ3.x(0)
q_bits = QuantumRegister(5)
qc = QuantumCircuit(q_bits)
qc.append(my_gate, q_bits[:3])
qc.append(my_gate2, q_bits[2:])
qc.mct(q_bits[:4], q_bits[4])
qc.h(0)
qc.append(circ3, [0, 1])
self.complex_circuit = qc
def test_basic(self):
"""Test decompose a single H into u2."""
qr = QuantumRegister(1, "qr")
circuit = QuantumCircuit(qr)
circuit.h(qr[0])
dag = circuit_to_dag(circuit)
pass_ = Decompose(HGate)
after_dag = pass_.run(dag)
op_nodes = after_dag.op_nodes()
self.assertEqual(len(op_nodes), 1)
self.assertEqual(op_nodes[0].name, "u2")
def test_decompose_none(self):
"""Test decompose a single H into u2."""
qr = QuantumRegister(1, "qr")
circuit = QuantumCircuit(qr)
circuit.h(qr[0])
dag = circuit_to_dag(circuit)
pass_ = Decompose()
after_dag = pass_.run(dag)
op_nodes = after_dag.op_nodes()
self.assertEqual(len(op_nodes), 1)
self.assertEqual(op_nodes[0].name, "u2")
def test_decompose_only_h(self):
"""Test to decompose a single H, without the rest"""
qr = QuantumRegister(2, "qr")
circuit = QuantumCircuit(qr)
circuit.h(qr[0])
circuit.cx(qr[0], qr[1])
dag = circuit_to_dag(circuit)
pass_ = Decompose(HGate)
after_dag = pass_.run(dag)
op_nodes = after_dag.op_nodes()
self.assertEqual(len(op_nodes), 2)
for node in op_nodes:
self.assertIn(node.name, ["cx", "u2"])
def test_decompose_toffoli(self):
"""Test decompose CCX."""
qr1 = QuantumRegister(2, "qr1")
qr2 = QuantumRegister(1, "qr2")
circuit = QuantumCircuit(qr1, qr2)
circuit.ccx(qr1[0], qr1[1], qr2[0])
dag = circuit_to_dag(circuit)
pass_ = Decompose(CCXGate)
after_dag = pass_.run(dag)
op_nodes = after_dag.op_nodes()
self.assertEqual(len(op_nodes), 15)
for node in op_nodes:
self.assertIn(node.name, ["h", "t", "tdg", "cx"])
def test_decompose_conditional(self):
"""Test decompose a 1-qubit gates with a conditional."""
qr = QuantumRegister(1, "qr")
cr = ClassicalRegister(1, "cr")
circuit = QuantumCircuit(qr, cr)
circuit.h(qr).c_if(cr, 1)
circuit.x(qr).c_if(cr, 1)
dag = circuit_to_dag(circuit)
pass_ = Decompose(HGate)
after_dag = pass_.run(dag)
ref_circuit = QuantumCircuit(qr, cr)
ref_circuit.append(U2Gate(0, pi), [qr[0]]).c_if(cr, 1)
ref_circuit.x(qr).c_if(cr, 1)
ref_dag = circuit_to_dag(ref_circuit)
self.assertEqual(after_dag, ref_dag)
def test_decompose_oversized_instruction(self):
"""Test decompose on a single-op gate that doesn't use all qubits."""
# ref: https://github.com/Qiskit/qiskit-terra/issues/3440
qc1 = QuantumCircuit(2)
qc1.x(0)
gate = qc1.to_gate()
qc2 = QuantumCircuit(2)
qc2.append(gate, [0, 1])
output = qc2.decompose()
self.assertEqual(qc1, output)
def test_decomposition_preserves_qregs_order(self):
"""Test decomposing a gate preserves it's definition registers order"""
qr = QuantumRegister(2, "qr1")
qc1 = QuantumCircuit(qr)
qc1.cx(1, 0)
gate = qc1.to_gate()
qr2 = QuantumRegister(2, "qr2")
qc2 = QuantumCircuit(qr2)
qc2.append(gate, qr2)
expected = QuantumCircuit(qr2)
expected.cx(1, 0)
self.assertEqual(qc2.decompose(), expected)
def test_decompose_global_phase_1q(self):
"""Test decomposition of circuit with global phase"""
qc1 = QuantumCircuit(1)
qc1.rz(0.1, 0)
qc1.ry(0.5, 0)
qc1.global_phase += pi / 4
qcd = qc1.decompose()
self.assertEqual(Operator(qc1), Operator(qcd))
def test_decompose_global_phase_2q(self):
"""Test decomposition of circuit with global phase"""
qc1 = QuantumCircuit(2, global_phase=pi / 4)
qc1.rz(0.1, 0)
qc1.rxx(0.2, 0, 1)
qcd = qc1.decompose()
self.assertEqual(Operator(qc1), Operator(qcd))
def test_decompose_global_phase_1q_composite(self):
"""Test decomposition of circuit with global phase in a composite gate."""
circ = QuantumCircuit(1, global_phase=pi / 2)
circ.x(0)
circ.h(0)
v = circ.to_gate()
qc1 = QuantumCircuit(1)
qc1.append(v, [0])
qcd = qc1.decompose()
self.assertEqual(Operator(qc1), Operator(qcd))
def test_decompose_only_h_gate(self):
"""Test decomposition parameters so that only a certain gate is decomposed."""
circ = QuantumCircuit(2, 1)
circ.h(0)
circ.cz(0, 1)
decom_circ = circ.decompose(["h"])
dag = circuit_to_dag(decom_circ)
self.assertEqual(len(dag.op_nodes()), 2)
self.assertEqual(dag.op_nodes()[0].name, "u2")
self.assertEqual(dag.op_nodes()[1].name, "cz")
def test_decompose_only_given_label(self):
"""Test decomposition parameters so that only a given label is decomposed."""
decom_circ = self.complex_circuit.decompose(["gate2"])
dag = circuit_to_dag(decom_circ)
self.assertEqual(len(dag.op_nodes()), 7)
self.assertEqual(dag.op_nodes()[0].op.label, "gate1")
self.assertEqual(dag.op_nodes()[1].name, "h")
self.assertEqual(dag.op_nodes()[2].name, "cx")
self.assertEqual(dag.op_nodes()[3].name, "x")
self.assertEqual(dag.op_nodes()[4].name, "mcx")
self.assertEqual(dag.op_nodes()[5].name, "h")
self.assertRegex(dag.op_nodes()[6].name, "circuit-")
def test_decompose_only_given_name(self):
"""Test decomposition parameters so that only given name is decomposed."""
decom_circ = self.complex_circuit.decompose(["mcx"])
dag = circuit_to_dag(decom_circ)
self.assertEqual(len(dag.op_nodes()), 13)
self.assertEqual(dag.op_nodes()[0].op.label, "gate1")
self.assertEqual(dag.op_nodes()[1].op.label, "gate2")
self.assertEqual(dag.op_nodes()[2].name, "h")
self.assertEqual(dag.op_nodes()[3].name, "cu1")
self.assertEqual(dag.op_nodes()[4].name, "rcccx")
self.assertEqual(dag.op_nodes()[5].name, "h")
self.assertEqual(dag.op_nodes()[6].name, "h")
self.assertEqual(dag.op_nodes()[7].name, "cu1")
self.assertEqual(dag.op_nodes()[8].name, "rcccx_dg")
self.assertEqual(dag.op_nodes()[9].name, "h")
self.assertEqual(dag.op_nodes()[10].name, "c3sx")
self.assertEqual(dag.op_nodes()[11].name, "h")
self.assertRegex(dag.op_nodes()[12].name, "circuit-")
def test_decompose_mixture_of_names_and_labels(self):
"""Test decomposition parameters so that mixture of names and labels is decomposed"""
decom_circ = self.complex_circuit.decompose(["mcx", "gate2"])
dag = circuit_to_dag(decom_circ)
self.assertEqual(len(dag.op_nodes()), 15)
self.assertEqual(dag.op_nodes()[0].op.label, "gate1")
self.assertEqual(dag.op_nodes()[1].name, "h")
self.assertEqual(dag.op_nodes()[2].name, "cx")
self.assertEqual(dag.op_nodes()[3].name, "x")
self.assertEqual(dag.op_nodes()[4].name, "h")
self.assertEqual(dag.op_nodes()[5].name, "cu1")
self.assertEqual(dag.op_nodes()[6].name, "rcccx")
self.assertEqual(dag.op_nodes()[7].name, "h")
self.assertEqual(dag.op_nodes()[8].name, "h")
self.assertEqual(dag.op_nodes()[9].name, "cu1")
self.assertEqual(dag.op_nodes()[10].name, "rcccx_dg")
self.assertEqual(dag.op_nodes()[11].name, "h")
self.assertEqual(dag.op_nodes()[12].name, "c3sx")
self.assertEqual(dag.op_nodes()[13].name, "h")
self.assertRegex(dag.op_nodes()[14].name, "circuit-")
def test_decompose_name_wildcards(self):
"""Test decomposition parameters so that name wildcards is decomposed"""
decom_circ = self.complex_circuit.decompose(["circuit-*"])
dag = circuit_to_dag(decom_circ)
self.assertEqual(len(dag.op_nodes()), 9)
self.assertEqual(dag.op_nodes()[0].name, "h")
self.assertEqual(dag.op_nodes()[1].name, "t")
self.assertEqual(dag.op_nodes()[2].name, "x")
self.assertEqual(dag.op_nodes()[3].name, "h")
self.assertRegex(dag.op_nodes()[4].name, "cx")
self.assertEqual(dag.op_nodes()[5].name, "x")
self.assertEqual(dag.op_nodes()[6].name, "mcx")
self.assertEqual(dag.op_nodes()[7].name, "h")
self.assertEqual(dag.op_nodes()[8].name, "x")
def test_decompose_label_wildcards(self):
"""Test decomposition parameters so that label wildcards is decomposed"""
decom_circ = self.complex_circuit.decompose(["gate*"])
dag = circuit_to_dag(decom_circ)
self.assertEqual(len(dag.op_nodes()), 9)
self.assertEqual(dag.op_nodes()[0].name, "h")
self.assertEqual(dag.op_nodes()[1].name, "t")
self.assertEqual(dag.op_nodes()[2].name, "x")
self.assertEqual(dag.op_nodes()[3].name, "h")
self.assertEqual(dag.op_nodes()[4].name, "cx")
self.assertEqual(dag.op_nodes()[5].name, "x")
self.assertEqual(dag.op_nodes()[6].name, "mcx")
self.assertEqual(dag.op_nodes()[7].name, "h")
self.assertRegex(dag.op_nodes()[8].name, "circuit-")
def test_decompose_empty_gate(self):
"""Test a gate where the definition is an empty circuit is decomposed."""
empty = QuantumCircuit(1)
circuit = QuantumCircuit(1)
circuit.append(empty.to_gate(), [0])
decomposed = circuit.decompose()
self.assertEqual(len(decomposed.data), 0)
def test_decompose_reps(self):
"""Test decompose reps function is decomposed correctly"""
decom_circ = self.complex_circuit.decompose(reps=2)
decomposed = self.complex_circuit.decompose().decompose()
self.assertEqual(decom_circ, decomposed)
def test_decompose_single_qubit_clbit(self):
"""Test the decomposition of a block with a single qubit and clbit works.
Regression test of Qiskit/qiskit-terra#8591.
"""
block = QuantumCircuit(1, 1)
block.h(0)
circuit = QuantumCircuit(1, 1)
circuit.append(block, [0], [0])
decomposed = circuit.decompose()
self.assertEqual(decomposed, block)
|
https://github.com/Axect/QuantumAlgorithms
|
Axect
|
import numpy as np
from numpy import pi
# importing Qiskit
from qiskit import QuantumCircuit, transpile, assemble, Aer
from qiskit.visualization import plot_histogram, plot_bloch_multivector
qc = QuantumCircuit(3)
qc.h(2)
qc.cp(pi/2, 1, 2)
qc.cp(pi/4, 0, 2)
qc.h(1)
qc.cp(pi/2, 0, 1)
qc.h(0)
qc.swap(0, 2)
qc.draw()
def qft_rotations(circuit, n):
if n == 0:
return circuit
n -= 1
circuit.h(n)
for qubit in range(n):
circuit.cp(pi/2**(n-qubit), qubit, n)
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_rotations(circuit, n)
swap_registers(circuit, n)
return circuit
qc = QuantumCircuit(4)
qft(qc,4)
qc.draw()
# Create the circuit
qc = QuantumCircuit(3)
# Encode the state 5 (101 in binary)
qc.x(0)
qc.x(2)
qc.draw()
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)
qft(qc, 3)
qc.draw()
qc.save_statevector()
statevector = sim.run(qc).result().get_statevector()
plot_bloch_multivector(statevector)
|
https://github.com/carstenblank/dc-qiskit-stochastics
|
carstenblank
|
# Copyright 2018-2022 Carsten Blank
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import logging
from datetime import datetime
from typing import List, Union, Optional, Callable
import numpy as np
import qiskit
import scipy
from qiskit.circuit import Parameter
from qiskit.providers.ibmq import IBMQBackend
from qiskit.transpiler import PassManager
from scipy import sparse
from dc_quantum_scheduling import PreparedExperiment
from . import get_default_pass_manager
from .dsp_common import apply_level, apply_initial, x_measurement, y_measurement
from .dsp_independent import index_independent_prep
from .dsp_util import create_qobj, extract_evaluations
from .qiskit_util import qasm_simulator
LOG = logging.getLogger(__name__)
class DiscreteStochasticProcess(object):
realizations: np.array
probabilities: np.array
initial_value: float
def __init__(self, initial_value: float, probabilities: np.ndarray, realizations: np.ndarray):
self.initial_value = initial_value
self.probabilities = probabilities
self.realizations = realizations
@staticmethod
def _get_circuit_name(scaling: float) -> str:
return f'dsp_simulation({scaling})'
@staticmethod
def _get_circuit_name_cos(scaling: float) -> str:
return f'{DiscreteStochasticProcess._get_circuit_name(scaling)}_cosine'
@staticmethod
def _get_circuit_name_sin(scaling: float) -> str:
return f'{DiscreteStochasticProcess._get_circuit_name(scaling)}_sine'
def _proposition_one_circuit(self, scaling: Parameter, level_func=None, index_state_prep=None, with_barrier=False, **kwargs):
# per default we use the standard Moettoennen level function
level_func = apply_level if level_func is None else level_func
# per default we use the independent index state preparation (also Moettoennen)
index_state_prep = index_independent_prep if index_state_prep is None else index_state_prep
LOG.debug(f"Data: initial value={self.initial_value}, "
f"probabilities={list(self.probabilities)}, realizations={list(self.realizations)},"
f"applied function={level_func.__name__}.")
qc = qiskit.QuantumCircuit()
LOG.debug(f"Initializing with {self.initial_value} and scaling {scaling}.")
init_qc = apply_initial(self.initial_value, scaling)
qc.extend(init_qc)
if with_barrier:
qc.barrier()
for level, (p, r) in enumerate(zip(self.probabilities, self.realizations)):
LOG.debug(f"Adding level {level}: {p} with {r} and scaling {scaling}.")
qc_index = index_state_prep(level, p, **kwargs)
qc_level_l = level_func(level, r, scaling, **kwargs)
qc.extend(qc_index)
if with_barrier:
qc.barrier()
qc.extend(qc_level_l)
if with_barrier:
qc.barrier()
return qc
def expval_cos_circuit(self, scaling: Parameter, level_func=None, index_state_prep=None, **kwargs):
LOG.info(f'Cosine Circuit generation with scaling {scaling} and level_func={level_func}')
qc = self._proposition_one_circuit(scaling, level_func, index_state_prep, **kwargs)
qc.extend(x_measurement())
qc.name = f'{qc.name}_cosine'
LOG.debug(f"Circuit:\n{qc.draw(output='text', fold=-1)}")
return qc
def expval_sin_circuit(self, scaling: Parameter, level_func=None, index_state_prep=None, **kwargs):
LOG.info(f'Sine Circuit generation with scaling {scaling} and level_func={level_func}')
qc = self._proposition_one_circuit(scaling, level_func, index_state_prep, **kwargs)
qc.extend(y_measurement())
qc.name = f'{qc.name}_sine'
LOG.debug(f"Circuit:\n{qc.draw(output='text', fold=-1)}")
return qc
def characteristic_function(self, evaluations: Union[List[float], np.ndarray, scipy.sparse.dok_matrix],
external_id: Optional[str] = None, level_func=None, pm: Optional[PassManager] = None,
transpiler_target_backend: Optional[Callable[[], IBMQBackend]] = None,
other_arguments: dict = None) -> PreparedExperiment:
other_arguments = {} if other_arguments is None else other_arguments
backend = transpiler_target_backend() if transpiler_target_backend is not None else qasm_simulator()
if external_id is None:
tags = other_arguments.get('tags', [])
external_id = datetime.now().strftime('%Y%m%d-%H%M%S') + f"-{type(self).__name__}-{'-'.join(tags)}"
scaling_v: Parameter = Parameter('v')
qc_cos_param: qiskit.QuantumCircuit = self.expval_cos_circuit(scaling_v, level_func, **other_arguments)
qc_sin_param: qiskit.QuantumCircuit = self.expval_sin_circuit(scaling_v, level_func, **other_arguments)
pre_pm = None
if pm is None:
LOG.info('No PassManager given, trying to attain one.')
pre_pm, pm = get_default_pass_manager(
transpiler_target_backend=backend,
other_arguments=other_arguments
)
qobj_list = create_qobj(qc_cos_param, qc_sin_param, scaling_v, evaluations=evaluations,
pass_manager=pm, pre_pass_manager=pre_pm, qobj_id=external_id,
other_arguments=other_arguments,
transpiler_target_backend=backend)
prepared_experiment = PreparedExperiment(
external_id=external_id,
tags=other_arguments.get('tags', []),
arguments=evaluations,
parameters={
'initial_value': self.initial_value,
'probabilities': self.probabilities,
'realizations': self.realizations,
'pass_manager': pm.passes(),
'qc_cos': qc_cos_param,
'qc_sin': qc_sin_param,
**other_arguments
},
qobj_list=qobj_list,
callback=extract_evaluations,
transpiler_backend=backend
)
return prepared_experiment
|
https://github.com/DmitriiNabok/QuantumKitchenSinks
|
DmitriiNabok
|
import time, sys
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split, GridSearchCV, KFold
from sklearn import metrics
from sklearn.linear_model import LogisticRegression
from sklearn.svm import LinearSVR, SVR
# Qiskit
from qiskit import Aer
from qiskit.utils import QuantumInstance, algorithm_globals
from qiskit.circuit import QuantumCircuit, ParameterVector
# sys.path.append('/Users/nabok/Work/Notebooks/qml/git/quantum-kitchen-sinks')
from qks.QuantumKitchenSinks import QuantumKitchenSinks
from qks.ProjectedQuantumKitchenSinks import ProjectedQuantumKitchenSinks
seed = 12345
np.random.seed(seed)
plt.style.use('classic')
plt.rcParams['font.size'] = 20
plt.rcParams['axes.linewidth'] = 2
plt.rcParams['axes.grid'] = True
plt.rcParams['legend.fontsize'] = 16
def compute_score(y_true, y_pred):
return {
"R2": f"{metrics.r2_score(y_true, y_pred):.3f}",
"MSE": f"{metrics.mean_squared_error(y_true, y_pred):.3f}",
"MAE": f"{metrics.median_absolute_error(y_true, y_pred):.3f}",
}
def scores(model, X_train, y_train, X_test, y_test, qks=None):
if qks is None:
y_pred = model.predict(X_train)
else:
X_emb = qks.embedding(X_train)
y_pred = model.predict(X_emb)
train_scores = compute_score(y_train, y_pred)
if qks is None:
y_pred = model.predict(X_test)
else:
X_emb = qks.embedding(X_test)
y_pred = model.predict(X_emb)
test_scores = compute_score(y_test, y_pred)
print()
print(f"R2 scores (train, test): {train_scores['R2']} {test_scores['R2']}")
print(f"MSE scores (train, test): {train_scores['MSE']} {test_scores['MSE']}")
print(f"MAE scores (train, test): {train_scores['MAE']} {test_scores['MAE']}")
print()
def plot_model(model, qks=None):
plt.figure(figsize=(8, 6), facecolor='w')
plt.scatter(X, y, c="k", s=20, label="data", zorder=1, edgecolors=(0, 0, 0))
plt.scatter(X_train, y_train, c="r", s=40, marker="s", label="train")
plt.scatter(X_test, y_test, c="b", s=50, marker="^", label="test")
if qks is None:
y_plot = model.predict(X_plot)
else:
X_emb = qks.embedding(X_plot)
y_plot = model.predict(X_emb)
plt.plot(
X_plot,
y_plot,
c="g",
lw=4,
label="SVR",
)
plt.xlabel("data")
plt.ylabel("target")
_ = plt.legend()
rng = np.random.RandomState(42)
X = 2*np.pi * rng.rand(100, 1)
y = np.sin(X).ravel()
# Add noise to targets
y[::5] += 3 * (0.5 - rng.rand(X.shape[0] // 5))
X_plot = np.linspace(0, 2*np.pi, 100)[:, None]
train_size = 20
test_size = 10
X_train, X_test, y_train, y_test = train_test_split(
X, y,
train_size=train_size, test_size=test_size,
random_state=100
)
plt.figure(figsize=(8, 6), facecolor='w')
plt.scatter(X, y, c="k", s=20, label="data", zorder=1, edgecolors=(0, 0, 0))
plt.scatter(X_train, y_train, c="r", s=40, marker="s", label="train")
plt.scatter(X_test, y_test, c="b", s=50, marker="^", label="test")
plt.legend()
plt.show()
svr = GridSearchCV(
SVR(kernel="rbf"),
param_grid={"C": [1, 20, 40, 60, 80, 100, 120, 140, 160, 180, 200], "gamma": np.logspace(-2, 1, 100)},
scoring='r2',
n_jobs=1,
cv=KFold(n_splits=2, shuffle=True, random_state=seed),
)
svr.fit(X_train, y_train)
print(f"Best SVR with params: {svr.best_params_} and R2 score: {svr.best_score_:.3f}")
scores(svr, X_train, y_train, X_test, y_test)
plot_model(svr)
t0 = time.perf_counter()
n_features = len(X[0])
n_qubits = 1
n_layers = 1
n_params = n_qubits
theta = ParameterVector('ΞΈ', length=n_params)
fm = QuantumCircuit(n_qubits)
j = 0
for r in range(n_layers):
for i in range(n_qubits):
fm.ry(theta[j%n_features], i); j += 1
for i in range(n_qubits-1):
fm.cx(i, (i+1)%n_qubits)
print(fm.draw(fold=120, plot_barriers=False))
#############################################################
# QKS
#############################################################
algorithm_globals.random_seed = seed
backend = QuantumInstance(
# Aer.get_backend("qasm_simulator"), shots=1024, seed_simulator=seed, seed_transpiler=seed,
Aer.get_backend("statevector_simulator"), seed_simulator=seed, seed_transpiler=seed,
)
n_episodes = 40
stddev = 0.5
qks = QuantumKitchenSinks(
n_features, fm,
n_episodes=n_episodes, stddev=stddev, sampling='normal',
backend=backend, seed=seed,
)
emb_tr = qks.embedding(X_train)
# print('emb_tr.shape: ', emb_tr.shape)
svr = SVR(kernel='linear', C=100.0)
svr.fit(emb_tr, y_train)
scores(svr, X_train, y_train, X_test, y_test, qks=qks)
plot_model(svr, qks=qks)
t1 = time.perf_counter()
print( 'Timing info:', time.strftime("%Hh%Mm%Ss", time.gmtime(t1-t0)) )
t0 = time.perf_counter()
n_features = len(X[0])
n_qubits = 1
n_layers = 1
n_params = n_qubits
theta = ParameterVector('ΞΈ', length=n_params)
fm = QuantumCircuit(n_qubits)
j = 0
for r in range(n_layers):
for i in range(n_qubits):
fm.ry(theta[j%n_features], i); j += 1
for i in range(n_qubits-1):
fm.cx(i, (i+1)%n_qubits)
print(fm.draw(fold=120, plot_barriers=False))
#############################################################
# QKS
#############################################################
algorithm_globals.random_seed = seed
backend = QuantumInstance(
# Aer.get_backend("qasm_simulator"), shots=1024, seed_simulator=seed, seed_transpiler=seed,
Aer.get_backend("statevector_simulator"), seed_simulator=seed, seed_transpiler=seed,
)
n_episodes = 10
stddev = 0.5
qks = ProjectedQuantumKitchenSinks(
n_features, fm, projection='z',
n_episodes=n_episodes, stddev=stddev, sampling='normal',
seed=seed, backend=backend, method='statevector'
)
emb_tr = qks.embedding(X_train)
# print('emb_tr.shape: ', emb_tr.shape)
svr = SVR(kernel='linear', C=100.0)
svr.fit(emb_tr, y_train)
scores(svr, X_train, y_train, X_test, y_test, qks=qks)
plot_model(svr, qks=qks)
t1 = time.perf_counter()
print( 'Timing info:', time.strftime("%Hh%Mm%Ss", time.gmtime(t1-t0)) )
t0 = time.perf_counter()
n_features = len(X[0])
n_qubits = 2
n_layers = 2
n_params = n_qubits
theta = ParameterVector('ΞΈ', length=n_params)
fm = QuantumCircuit(n_qubits)
j = 0
for r in range(n_layers):
for i in range(n_qubits):
fm.ry(theta[j%n_features], i); j += 1
for i in range(n_qubits):
fm.cx(i, (i+1)%n_qubits)
print(fm.draw(fold=120, plot_barriers=False))
#############################################################
# QKS
#############################################################
algorithm_globals.random_seed = seed
backend = QuantumInstance(
# Aer.get_backend("qasm_simulator"), shots=1024, seed_simulator=seed, seed_transpiler=seed,
Aer.get_backend("statevector_simulator"), seed_simulator=seed, seed_transpiler=seed,
)
n_episodes = 40
stddev = 0.5
qks = QuantumKitchenSinks(
n_features, fm,
n_episodes=n_episodes, stddev=stddev, sampling='normal',
backend=backend, seed=seed,
)
emb_tr = qks.embedding(X_train)
# print('emb_tr.shape: ', emb_tr.shape)
svr = SVR(kernel='linear', C=100.0)
svr.fit(emb_tr, y_train)
scores(svr, X_train, y_train, X_test, y_test, qks=qks)
plot_model(svr, qks=qks)
t1 = time.perf_counter()
print( 'Timing info:', time.strftime("%Hh%Mm%Ss", time.gmtime(t1-t0)) )
t0 = time.perf_counter()
n_features = len(X[0])
n_qubits = 2
n_layers = 1
n_params = n_qubits
theta = ParameterVector('ΞΈ', length=n_params)
fm = QuantumCircuit(n_qubits)
j = 0
for r in range(n_layers):
for i in range(n_qubits):
fm.ry(theta[j%n_features], i); j += 1
for i in range(n_qubits-1):
fm.cx(i, (i+1)%n_qubits)
print(fm.draw(fold=120, plot_barriers=False))
#############################################################
# QKS
#############################################################
algorithm_globals.random_seed = seed
backend = QuantumInstance(
# Aer.get_backend("qasm_simulator"), shots=1024, seed_simulator=seed, seed_transpiler=seed,
Aer.get_backend("statevector_simulator"), seed_simulator=seed, seed_transpiler=seed,
)
n_episodes = 10
stddev = 0.5
qks = ProjectedQuantumKitchenSinks(
n_features, fm, projection='z',
n_episodes=n_episodes, stddev=stddev, sampling='normal',
seed=seed, backend=backend, method='statevector'
)
emb_tr = qks.embedding(X_train)
# print('emb_tr.shape: ', emb_tr.shape)
svr = SVR(kernel='linear', C=100.0)
svr.fit(emb_tr, y_train)
scores(svr, X_train, y_train, X_test, y_test, qks=qks)
plot_model(svr, qks=qks)
t1 = time.perf_counter()
print( 'Timing info:', time.strftime("%Hh%Mm%Ss", time.gmtime(t1-t0)) )
|
https://github.com/mrvee-qC-bee/SCQC23
|
mrvee-qC-bee
|
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from qiskit.circuit import Parameter
import numpy as np
# Define a variable theta to be a parameter with name 'theta'
theta = Parameter('theta')
# Initialize a quantum circuit with one qubit
quantum_circuit = QuantumCircuit(1)
# Add a parametrized RX rotation on the qubit
quantum_circuit.rx(theta, 0)
quantum_circuit.draw(output="mpl")
# Set the value of the parameter
theta_value = np.pi
# Bind the value to the parametrized circuit
qc = quantum_circuit.bind_parameters({theta: theta_value})
# Add a measurement gate to the circuit before we run it
qc.measure_all()
qc.draw(output="mpl")
# Running on a simulator
from qiskit_aer import AerSimulator
sim = AerSimulator()
job = sim.run(qc) # shots = 1024 is the default
result = job.result()
counts = result.get_counts()
counts
# running on a quantum device
from qiskit import transpile
from qiskit_ibm_provider import IBMProvider, least_busy
provider = IBMProvider(instance='ibm-q/open/main')
# get the least-busy backend
real_backend = least_busy(provider.backends(filters=lambda b: b.configuration().n_qubits >= 1 and
not b.configuration().simulator and b.status().operational==True))
print(f"The best backend is: ", real_backend.name)
# transpilation
circuit_transpiled = transpile(qc, real_backend)
# submit the job
job = real_backend.run(circuit_transpiled, shots = 1024)
# Monitoring our job
from qiskit_ibm_provider.job import job_monitor
print(f"Job ID: {job.job_id()}")
job_monitor(job)
results = job.result()
counts = results.get_counts()
counts
from qiskit import QuantumCircuit
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
bell.measure_all()
bell.draw()
from qiskit.primitives import Sampler
sampler = Sampler(options={"shots": 100})
job = sampler.run(bell) # uses local simulator under the hood
result = job.result()
print(result)
# quasi-distribution:
dist = result.quasi_dists[0].binary_probabilities()
print(f"Quasi-distribution is: ", dist)
plot_histogram(dist)
quantum_circuit.measure_all()
quantum_circuit.draw()
#notice that theta is an unbound parameter
thetas = [0, np.pi/4, np.pi/3, np.pi/2, 2*np.pi/3, 3*np.pi/4, np.pi]
indv_thetas = [[ph] for ph in thetas] #[[0], [np.pi/4], [np.pi/3], [np.pi/2], [2*np.pi/3], [3*np.pi/4], [np.pi]]
job = sampler.run([quantum_circuit]*len(indv_thetas), parameter_values=indv_thetas) # uses local simulator under the hood
result = job.result()
quasi_dists = result.quasi_dists
quasi_dists
# Get the prob values for each of the states
prob_values_0 = [dist.get(0, 0) for dist in result.quasi_dists]
prob_values_1 = [dist.get(1, 0) for dist in result.quasi_dists]
import matplotlib.pyplot as plt
plt.plot(thetas, prob_values_0, 'o', label='zero state')
plt.plot(thetas, prob_values_1, 'o', label='one state')
plt.xlabel('Theta')
plt.ylabel('Probability')
plt.legend();
from qiskit_ibm_runtime import QiskitRuntimeService, Session, Sampler
from qiskit import QuantumCircuit
# QiskitRuntimeService.save_account(channel='ibm_quantum', token='my_token', overwrite=True) #uncomment if you need to save your account again
service = QiskitRuntimeService(
channel='ibm_quantum',
instance='ibm-q/open/main',
)
print(service.backends())
real_backend = service.least_busy(min_num_qubits=2, simulator=False, operational=True)
print(f"The best backend is {real_backend.name}")
# backend = service.get_backend('ibmq_qasm_simulator') # simulator
# can also use noisy simulators
# Execute both example circuits
with Session(service=service, backend=real_backend) as session:
sampler = Sampler(session=session)
# now we can run multiple jobs but only queue once
job = sampler.run([bell], [[]])
samples_bell = job.result().quasi_dists[0]
job = sampler.run([quantum_circuit]*len(indv_thetas), parameter_values=indv_thetas)
samples_param = job.result().quasi_dists
samples_bell.binary_probabilities()
samples_param
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/shesha-raghunathan/DATE2019-qiskit-tutorial
|
shesha-raghunathan
|
from IPython.display import HTML
HTML('''<script>
code_show=true;
function code_toggle() {
if (code_show){
$('div.input').hide();
} else {
$('div.input').show();
}
code_show = !code_show
}
$( document ).ready(code_toggle);
</script>
<form action="javascript:code_toggle()"><input type="submit" value="Click here to toggle on/off the raw code for QISKit exercises."></form>''')
from qiskit import *
# Quantum program setup
Q_program = QuantumProgram()
# Creating registers
q = Q_program.create_quantum_register('q', 5)
c0 = Q_program.create_classical_register('c0', 1)
c1 = Q_program.create_classical_register('c1', 1)
c2 = Q_program.create_classical_register('c2', 1)
# Creates the quantum circuit
bit_flip = Q_program.create_circuit('bit_flip', [q], [c0,c1,c2])
# Prepares qubit in the desired initial state
bit_flip.h(q[0])
# Encodes the qubit in a three-qubit entangled state
bit_flip.cx(q[0], q[1])
bit_flip.cx(q[0], q[2])
# Bit-flip error on the second qubit
bit_flip.x(q[1])
# Adds additional two qubits for error-correction
bit_flip.cx(q[0], q[3])
bit_flip.cx(q[1], q[3])
bit_flip.cx(q[0], q[4])
bit_flip.cx(q[2], q[4])
# Measure the two additional qubits
bit_flip.measure(q[3], c0[0])
bit_flip.measure(q[4], c1[0])
# Do error correction
bit_flip.x(q[1]).c_if(c0, 1)
bit_flip.x(q[2]).c_if(c1, 1)
# Decodes the qubit from the three-qubit entangled state
bit_flip.cx(q[0], q[1])
bit_flip.cx(q[0], q[2])
# Check the state of the initial qubit
bit_flip.measure(q[0], c2[0])
# Shows gates of the circuit
circuits = ['bit_flip']
print(Q_program.get_qasms(circuits)[0])
# Parameters for execution on simulator
backend = 'local_qasm_simulator'
shots = 1024 # the number of shots in the experiment
# Run the algorithm
result = Q_program.execute(circuits, backend=backend, shots=shots)
#Shows the results obtained from the quantum algorithm
counts = result.get_counts('bit_flip')
print('\nThe measured outcomes of the circuits are:', counts)
from qiskit import *
# Quantum program setup
Q_program = QuantumProgram()
# Creating registers
q = Q_program.create_quantum_register('q', 5)
c0 = Q_program.create_classical_register('c0', 1)
c1 = Q_program.create_classical_register('c1', 1)
c2 = Q_program.create_classical_register('c2', 1)
# Creates the quantum circuit
bit_flip = Q_program.create_circuit('bit_flip', [q], [c0,c1,c2])
# Prepares qubit in the desired initial state
bit_flip.h(q[0])
# Encodes the qubit in a three-qubit entangled state
bit_flip.cx(q[0], q[1])
bit_flip.cx(q[0], q[2])
# Go to Hadamard basis
bit_flip.h(q[0])
bit_flip.h(q[1])
bit_flip.h(q[2])
# Phase error on the second qubit
bit_flip.z(q[1])
# Converts phase error in bit-flip error
bit_flip.h(q[0])
bit_flip.h(q[1])
bit_flip.h(q[2])
# Adds additional two qubits for error-correction
bit_flip.cx(q[0], q[3])
bit_flip.cx(q[1], q[3])
bit_flip.cx(q[0], q[4])
bit_flip.cx(q[2], q[4])
# Measure the two additional qubits
bit_flip.measure(q[3], c0[0])
bit_flip.measure(q[4], c1[0])
# Do error correction
bit_flip.x(q[1]).c_if(c0, 1)
bit_flip.x(q[2]).c_if(c1, 1)
# Decodes the qubit from the three-qubit entangled state
bit_flip.cx(q[0], q[1])
bit_flip.cx(q[0], q[2])
# Check the state of the initial qubit
bit_flip.measure(q[0], c2[0])
# Shows gates of the circuit
circuits = ['bit_flip']
print(Q_program.get_qasms(circuits)[0])
# Parameters for execution on simulator
backend = 'local_qasm_simulator'
shots = 1024 # the number of shots in the experiment
# Run the algorithm
result = Q_program.execute(circuits, backend=backend, shots=shots)
#Shows the results obtained from the quantum algorithm
counts = result.get_counts('bit_flip')
print('\nThe measured outcomes of the circuits are:', counts)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.circuit.random import random_circuit
circuit = random_circuit(2, 2, seed=0).decompose(reps=1)
display(circuit.draw("mpl"))
from qiskit.quantum_info import SparsePauliOp
observable = SparsePauliOp("XZ")
print(f">>> Observable: {observable.paulis}")
from qiskit.primitives import Estimator
estimator = Estimator()
job = estimator.run(circuit, observable)
print(f">>> Job ID: {job.job_id()}")
print(f">>> Job Status: {job.status()}")
result = job.result()
print(f">>> {result}")
print(f" > Expectation value: {result.values[0]}")
circuit = random_circuit(2, 2, seed=1).decompose(reps=1)
observable = SparsePauliOp("IY")
job = estimator.run(circuit, observable)
result = job.result()
display(circuit.draw("mpl"))
print(f">>> Observable: {observable.paulis}")
print(f">>> Expectation value: {result.values[0]}")
circuits = (
random_circuit(2, 2, seed=0).decompose(reps=1),
random_circuit(2, 2, seed=1).decompose(reps=1),
)
observables = (
SparsePauliOp("XZ"),
SparsePauliOp("IY"),
)
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()}")
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]
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[0]}")
from qiskit_ibm_runtime import QiskitRuntimeService
service = QiskitRuntimeService(channel="ibm_quantum")
backend = service.backend("ibmq_qasm_simulator")
from qiskit.circuit.random import random_circuit
from qiskit.quantum_info import SparsePauliOp
circuit = random_circuit(2, 2, seed=0).decompose(reps=1)
display(circuit.draw("mpl"))
observable = SparsePauliOp("XZ")
print(f">>> Observable: {observable.paulis}")
from qiskit_ibm_runtime import Estimator
estimator = Estimator(session=backend)
job = estimator.run(circuit, observable)
print(f">>> Job ID: {job.job_id()}")
print(f">>> Job Status: {job.status()}")
result = job.result()
print(f">>> {result}")
print(f" > Expectation value: {result.values[0]}")
print(f" > Metadata: {result.metadata[0]}")
from qiskit_ibm_runtime import Options
options = Options(optimization_level=3, environment={"log_level": "INFO"})
from qiskit_ibm_runtime import Options
options = Options()
options.resilience_level = 1
options.execution.shots = 2048
estimator = Estimator(session=backend, options=options)
result = estimator.run(circuit, observable).result()
print(f">>> Metadata: {result.metadata[0]}")
estimator = Estimator(session=backend, options=options)
result = estimator.run(circuit, observable, shots=1024).result()
print(f">>> Metadata: {result.metadata[0]}")
from qiskit_ibm_runtime import Options
# optimization_level=3 adds dynamical decoupling
# resilience_level=1 adds readout error mitigation
options = Options(optimization_level=3, resilience_level=1)
estimator = Estimator(session=backend, options=options)
result = estimator.run(circuit, observable).result()
print(f">>> Expectation value: {result.values[0]}")
print(f">>> Metadata: {result.metadata[0]}")
from qiskit_ibm_runtime import Session, Estimator
with Session(backend=backend, max_time="1h"):
estimator = Estimator()
result = estimator.run(circuit, observable).result()
print(f">>> Expectation value from the first run: {result.values[0]}")
result = estimator.run(circuit, observable).result()
print(f">>> Expectation value from the second run: {result.values[0]}")
from qiskit.circuit.random import random_circuit
sampler_circuit = random_circuit(2, 2, seed=0).decompose(reps=1)
sampler_circuit.measure_all()
display(circuit.draw("mpl"))
from qiskit_ibm_runtime import Session, Sampler, Estimator
with Session(backend=backend):
sampler = Sampler()
estimator = Estimator()
result = sampler.run(sampler_circuit).result()
print(f">>> Quasi Distribution from the sampler job: {result.quasi_dists[0]}")
result = estimator.run(circuit, observable).result()
print(f">>> Expectation value from the estimator job: {result.values[0]}")
from qiskit_ibm_runtime import Session, Sampler, Estimator
with Session(backend=backend):
sampler = Sampler()
estimator = Estimator()
sampler_job = sampler.run(sampler_circuit)
estimator_job = estimator.run(circuit, observable)
print(f">>> Quasi Distribution from the sampler job: {sampler_job.result().quasi_dists[0]}")
print(f">>> Expectation value from the estimator job: {estimator_job.result().values[0]}")
from qiskit_ibm_runtime import QiskitRuntimeService, Session, Sampler, Estimator, Options
# 1. Initialize account
service = QiskitRuntimeService(channel="ibm_quantum")
# 2. Specify options, such as enabling error mitigation
options = Options(resilience_level=1)
# 3. Select a backend.
backend = service.backend("ibmq_qasm_simulator")
# 4. Create a session
with Session(backend=backend):
# 5. Create primitive instances
sampler = Sampler(options=options)
estimator = Estimator(options=options)
# 6. Submit jobs
sampler_job = sampler.run(sampler_circuit)
estimator_job = estimator.run(circuit, observable)
# 7. Get results
print(f">>> Quasi Distribution from the sampler job: {sampler_job.result().quasi_dists[0]}")
print(f">>> Expectation value from the estimator job: {estimator_job.result().values[0]}")
import qiskit_ibm_runtime
qiskit_ibm_runtime.version.get_version_info()
from qiskit.tools.jupyter import *
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.utils import algorithm_globals
algorithm_globals.random_seed = 123456
from sklearn.datasets import make_blobs
features, labels = make_blobs(
n_samples=20,
centers=2,
center_box=(-1, 1),
cluster_std=0.1,
random_state=algorithm_globals.random_seed,
)
from qiskit import BasicAer
from qiskit.utils import QuantumInstance
sv_qi = QuantumInstance(
BasicAer.get_backend("statevector_simulator"),
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
)
from qiskit.circuit.library import ZZFeatureMap
from qiskit_machine_learning.kernels import QuantumKernel
feature_map = ZZFeatureMap(2)
previous_kernel = QuantumKernel(feature_map=feature_map, quantum_instance=sv_qi)
from qiskit_machine_learning.algorithms import QSVC
qsvc = QSVC(quantum_kernel=previous_kernel)
qsvc.fit(features, labels)
qsvc.score(features, labels)
from qiskit.algorithms.state_fidelities import ComputeUncompute
from qiskit.primitives import Sampler
fidelity = ComputeUncompute(sampler=Sampler())
from qiskit_machine_learning.kernels import FidelityQuantumKernel
feature_map = ZZFeatureMap(2)
new_kernel = FidelityQuantumKernel(feature_map=feature_map, fidelity=fidelity)
from qiskit_machine_learning.algorithms import QSVC
qsvc = QSVC(quantum_kernel=new_kernel)
qsvc.fit(features, labels)
qsvc.score(features, labels)
from qiskit import QuantumCircuit
from qiskit.circuit.library import RealAmplitudes
num_inputs = 2
feature_map = ZZFeatureMap(num_inputs)
ansatz = RealAmplitudes(num_inputs, reps=1)
circuit = QuantumCircuit(num_inputs)
circuit.compose(feature_map, inplace=True)
circuit.compose(ansatz, inplace=True)
def parity(x):
return "{:b}".format(x).count("1") % 2
initial_point = algorithm_globals.random.random(ansatz.num_parameters)
from qiskit_machine_learning.neural_networks import CircuitQNN
circuit_qnn = CircuitQNN(
circuit=circuit,
input_params=feature_map.parameters,
weight_params=ansatz.parameters,
interpret=parity,
output_shape=2,
quantum_instance=sv_qi,
)
from qiskit.algorithms.optimizers import COBYLA
from qiskit_machine_learning.algorithms import NeuralNetworkClassifier
classifier = NeuralNetworkClassifier(
neural_network=circuit_qnn,
loss="cross_entropy",
one_hot=True,
optimizer=COBYLA(maxiter=40),
initial_point=initial_point,
)
classifier.fit(features, labels)
classifier.score(features, labels)
from qiskit.primitives import Sampler
sampler = Sampler()
from qiskit_machine_learning.neural_networks import SamplerQNN
sampler_qnn = SamplerQNN(
circuit=circuit,
input_params=feature_map.parameters,
weight_params=ansatz.parameters,
interpret=parity,
output_shape=2,
sampler=sampler,
)
classifier = NeuralNetworkClassifier(
neural_network=sampler_qnn,
loss="cross_entropy",
one_hot=True,
optimizer=COBYLA(maxiter=40),
initial_point=initial_point,
)
classifier.fit(features, labels)
classifier.score(features, labels)
import numpy as np
num_samples = 20
eps = 0.2
lb, ub = -np.pi, np.pi
features = (ub - lb) * np.random.rand(num_samples, 1) + lb
labels = np.sin(features[:, 0]) + eps * (2 * np.random.rand(num_samples) - 1)
from qiskit.circuit import Parameter
num_inputs = 1
feature_map = QuantumCircuit(1)
feature_map.ry(Parameter("input"), 0)
ansatz = QuantumCircuit(1)
ansatz.ry(Parameter("weight"), 0)
circuit = QuantumCircuit(num_inputs)
circuit.compose(feature_map, inplace=True)
circuit.compose(ansatz, inplace=True)
initial_point = algorithm_globals.random.random(ansatz.num_parameters)
from qiskit.opflow import PauliSumOp, StateFn
from qiskit_machine_learning.neural_networks import OpflowQNN
observable = PauliSumOp.from_list([("Z", 1)])
operator = StateFn(observable, is_measurement=True) @ StateFn(circuit)
opflow_qnn = OpflowQNN(
operator=operator,
input_params=feature_map.parameters,
weight_params=ansatz.parameters,
quantum_instance=sv_qi,
)
from qiskit.algorithms.optimizers import L_BFGS_B
from qiskit_machine_learning.algorithms import NeuralNetworkRegressor
regressor = NeuralNetworkRegressor(
neural_network=opflow_qnn,
optimizer=L_BFGS_B(maxiter=5),
initial_point=initial_point,
)
regressor.fit(features, labels)
regressor.score(features, labels)
from qiskit.primitives import Estimator
estimator = Estimator()
from qiskit_machine_learning.neural_networks import EstimatorQNN
estimator_qnn = EstimatorQNN(
circuit=circuit,
input_params=feature_map.parameters,
weight_params=ansatz.parameters,
estimator=estimator,
)
from qiskit.algorithms.optimizers import L_BFGS_B
from qiskit_machine_learning.algorithms import VQR
regressor = NeuralNetworkRegressor(
neural_network=estimator_qnn,
optimizer=L_BFGS_B(maxiter=5),
initial_point=initial_point,
)
regressor.fit(features, labels)
regressor.score(features, labels)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import numpy as np
from qiskit import pulse
d0 = pulse.DriveChannel(0)
x90 = pulse.Gaussian(10, 0.1, 3)
x180 = pulse.Gaussian(10, 0.2, 3)
def udd10_pos(j):
return np.sin(np.pi*j/(2*10 + 2))**2
with pulse.build() as udd_sched:
pulse.play(x90, d0)
with pulse.align_func(duration=300, func=udd10_pos):
for _ in range(10):
pulse.play(x180, d0)
pulse.play(x90, d0)
udd_sched.draw()
|
https://github.com/DSamuel1/QiskitProjects
|
DSamuel1
|
import numpy as np
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile, Aer, IBMQ
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from ibm_quantum_widgets import *
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
from qiskit import *
def dj(n, case, bstring):
qc = QuantumCircuit(n+1, n)
qc.x(n)
for i in range(n+1):
qc.h(i)
oracle(qc, n, case, bstring)
for i in range(n):
qc.h(i)
qc.measure(i,i)
return qc
def oracle(qc, n, case, bstring):
#let case 1 be f(x)=0, case 2 is f(x)=1, case 3 is f(x)=x, case 4 is f(x)=!x
if(case == 2):
qc.x(n)
elif(case == 3):
for i in range(n):
if bstring[i] == '1':
qc.x(i)
qc.cx(i,n)
if bstring[i] == '1':
qc.x(i)
elif(case == 4):
for i in range(n):
if bstring[i]=='1':
qc.x(i)
qc.cx(i, n)
if bstring[i]=='1':
qc.x(i)
qc.x(n)
circ = dj(3, 3, "101")
circ.draw('mpl')
backend = Aer.get_backend('qasm_simulator')
job = execute(circ, backend, shots = 1024)
counts = job.result().get_counts()
plot_histogram(counts)
|
https://github.com/yatharth0610/Quantum-Algorithms-qiskit-
|
yatharth0610
|
%matplotlib inline
# Importing standard Qiskit libraries
import random
from qiskit import *
from qiskit.tools.jupyter import *
from qiskit.visualization import *
#Get the library to check the answers
%pip install -I git+https://github.com/mnp-club/MnP_QC_Workshop.git
from mnp_qc_workshop_2020.bb84 import *
# Configuring account
provider = IBMQ.load_account()
backend = provider.get_backend('ibmq_qasm_simulator') # with this simulator it wouldn't work \
# Initial setup
random.seed(64) # do not change this seed, otherwise you will get a different key
# This is your 'random' bit string that determines your bases
numqubits = 16
bob_bases = str('{0:016b}'.format(random.getrandbits(numqubits)))
def bb84():
print('Bob\'s bases:', bob_bases)
# Now Alice will send her bits one by one...
all_qubit_circuits = []
for qubit_index in range(numqubits):
# This is Alice creating the qubit
thisqubit_circuit = alice_prepare_qubit(qubit_index)
# This is Bob finishing the protocol below
bob_measure_qubit(bob_bases, qubit_index, thisqubit_circuit)
# We collect all these circuits and put them in an array
all_qubit_circuits.append(thisqubit_circuit)
# Now execute all the circuits for each qubit
results = execute(all_qubit_circuits, backend=backend, shots=1).result()
# And combine the results
bits = ''
for qubit_index in range(numqubits):
bits += [measurement for measurement in results.get_counts(qubit_index)][0]
return bits
# Here is your task
def bob_measure_qubit(bob_bases, qubit_index, qubit_circuit):
if bob_bases[qubit_index] == '1':
qubit_circuit.h(0)
qubit_circuit.measure(0,0)
bits = bb84()
print('Bob\'s bits: ', bits)
check_bits(bits)
alice_bases = '0100000101011100' # Alice's bases bits
key = ''
for i in range(16):
if (alice_bases[i] == bob_bases[i]):
key += bits[i]
print(key)
check_key(key)
message = get_message()# encrypted message
decrypted = ''
for i in range(43):
for j in range(8):
decrypted += str((int(message[8*i+j]) + int(key[j]))%2)
print(decrypted)
check_decrypted(decrypted)
decrypted_to_string_ASCII = ''
for i in range(43):
for i in range(43):
decrypted_to_string_ASCII += chr(int(decrypted[8*i:8*(i+1)], 2))
check_message(decrypted_to_string_ASCII)
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
### removed x gate ###
pass
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/soultanis/Quantum-Database-Search
|
soultanis
|
circuit = None
oracle_simple = None
execute = None
Aer = None
IBMQ = None
least_busy = None
def _import_modules():
print("Importing modules")
global circuit, oracle_simple, execute, least_busy
import circuit
import oracle_simple
from qiskit import execute
from qiskit.backends.ibmq import least_busy
# To be used from REPL
def build_and_infos(n, x_stars, real=False, online=False, backend_name=None):
_import_modules()
oracles = []
for i in range(len(x_stars)):
oracles.append(oracle_simple.OracleSimple(n, x_stars[i]))
gc, n_qubits = circuit.get_circuit(n, oracles)
if real:
online = True
backend, max_credits, shots = get_appropriate_backend(
n_qubits, real, online, backend_name)
res = get_compiled_circuit_infos(gc, backend, max_credits, shots)
return res
# To be used from REPL
def build_and_run(n, x_stars, real=False, online=False, backend_name=None):
"""
This just build the grover circuit for the specific n and x_star
and run them on the selected backend.
It may be convenient to use in an interactive shell for quick testing.
"""
_import_modules()
oracles = []
for i in range(len(x_stars)):
oracles.append(oracle_simple.OracleSimple(n, x_stars[i]))
gc, n_qubits = circuit.get_circuit(n, oracles)
if real:
online = True
backend, max_credits, shots = get_appropriate_backend(
n_qubits, real, online, backend_name)
return run_grover_algorithm(gc, backend, max_credits, shots)
def get_appropriate_backend(n, real, online, backend_name):
# Online, real or simuator?
if (not online):
global Aer
from qiskit import Aer
max_credits = 10
shots = 4098
print("Local simulator backend")
backend = Aer.get_backend('qasm_simulator')
# list of online devices: ibmq_qasm_simulator, ibmqx2, ibmqx4, ibmqx5, ibmq_16_melbourne
else:
global IBMQ
from qiskit import IBMQ
print("Online {0} backend".format("real" if real else "simulator"))
max_credits = 3
shots = 4098
import Qconfig
IBMQ.load_accounts()
if (backend_name is not None):
backend = IBMQ.get_backend(backend_name)
else:
large_enough_devices = IBMQ.backends(
filters=lambda x: x.configuration()['n_qubits'] >= n and x.configuration()[
'simulator'] == (not real)
)
backend = least_busy(large_enough_devices)
print("Backend name is {0}; max_credits = {1}, shots = {2}".format(
backend, max_credits, shots))
return backend, max_credits, shots
def get_compiled_circuit_infos(qc, backend, max_credits, shots):
result = {}
print("Getting infos ... ")
backend_coupling = backend.configuration()['coupling_map']
from qiskit import compile
grover_compiled = compile(
qc, backend=backend, coupling_map=backend_coupling, shots=shots)
grover_compiled_qasm = grover_compiled.experiments[
0].header.compiled_circuit_qasm
result['n_gates'] = len(grover_compiled_qasm.split("\n")) - 4
return result
def run_grover_algorithm(qc, backend, max_credits, shots):
"""
Run the grover algorithm, i.e. the quantum circuit qc.
:param qc: The (qiskit) quantum circuit
:param real: False (default) to run the circuit on a simulator backend, True to run on a real backend
:param backend_name: None (default) to run the circuit on the default backend (local qasm for simulation, least busy IBMQ device for a real backend); otherwise, it should contain the name of the backend you want to use.
:returns: Result of the computations, i.e. the dictionary of result counts for an execution.
:rtype: dict
"""
_import_modules()
pending_jobs = backend.status()['pending_jobs']
print("Backend has {0} pending jobs".format(pending_jobs))
print("Compiling ... ")
job = execute(qc, backend, shots=shots, max_credits=max_credits)
print("Job id is {0}".format(job.job_id()))
print(
"At this point, if any error occurs, you can always retrieve the job results using the backend name and the job id using the utils/retrieve_job_results.py script"
)
if pending_jobs > 1:
s = input(
"Do you want to wait for the job to go up in the queue list or exit the program(q)? If you exit now you can still retrieve the job results later on using the backend name and the job id w/ the utils/retrieve_job_results.py script"
)
if (s == "q"):
print(
"WARNING: Take note of backend name and job id to retrieve the job"
)
from sys import exit
exit()
result = job.result()
return result.get_counts(qc)
def get_max_key_value(counts):
mx = max(counts.keys(), key=(lambda key: counts[key]))
total = sum(counts.values())
confidence = counts[mx] / total
return mx, confidence
def main():
import argparse
parser = argparse.ArgumentParser(description="Grover algorithm")
parser.add_argument(
'n',
metavar='n',
type=int,
help='the number of bits used to store the oracle data.')
parser.add_argument(
'x_stars',
metavar='x_star',
type=int,
nargs='+',
help='the number(s) for which the oracle returns 1, in the range [0..2**n-1].'
)
parser.add_argument(
'-r',
'--real',
action='store_true',
help='Invoke the real device (implies -o). Default is simulator.')
parser.add_argument(
'-o',
'--online',
action='store_true',
help='Use the online IBMQ devices. Default is local (simulator). This option is automatically set when we want to use a real device (see -r).'
)
parser.add_argument(
'-i',
'--infos',
action='store_true',
help='Print only infos on the circuit built for the specific backend (such as the number of gates) without executing it.'
)
parser.add_argument(
'-b',
'--backend_name',
help="The name of the backend. It makes sense only for online ibmq devices and it's useless otherwise. If not specified, the program automatically choose the least busy ibmq backend."
)
parser.add_argument(
'--img_dir',
help='If you want to store the image of the circuit, you need to specify the directory.'
)
parser.add_argument(
'--plot',
action='store_true',
help='Plot the histogram of the results. Default is false')
args = parser.parse_args()
n = args.n
x_stars = args.x_stars
print("n: {0}, x_stars: {1}".format(n, x_stars))
real = args.real
online = True if real else args.online
infos = args.infos
backend_name = args.backend_name
img_dir = args.img_dir
plot = args.plot
print("real: {0}, online: {1}, infos: {2}, backend_name: {3}".format(
real, online, infos, backend_name))
_import_modules()
oracles = []
for i in range(len(x_stars)):
oracles.append(oracle_simple.OracleSimple(n, x_stars[i]))
gc, n_qubits = circuit.get_circuit(n, oracles)
if (img_dir is not None):
from qiskit.tools.visualization import circuit_drawer
circuit_drawer(
gc, filename=img_dir + "grover_{0}_{1}.png".format(n, x_stars[0]))
backend, max_credits, shots = get_appropriate_backend(
n_qubits, real, online, backend_name)
if (infos):
res = get_compiled_circuit_infos(gc, backend, max_credits, shots)
for k, v in res.items():
print("{0} --> {1}".format(k, v))
else: # execute
counts = run_grover_algorithm(gc, backend, max_credits, shots)
print(counts)
max, confidence = get_max_key_value(counts)
print("Max value: {0}, confidence {1}".format(max, confidence))
if (plot):
from qiskit.tools.visualization import plot_histogram
plot_histogram(counts)
print("END")
# Assumption: if run from console we're inside src/.. dir
if __name__ == "__main__":
main()
|
https://github.com/sanori/quantum-docker
|
sanori
|
import qsharp
qsharp.__version__
from NamespaceQFT import Perform3qubitQFT
Perform3qubitQFT.simulate()
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
from qiskit.algorithms import IterativeAmplitudeEstimation, EstimationProblem
from qiskit.circuit.library import LinearAmplitudeFunction
from qiskit_aer.primitives import Sampler
from qiskit_finance.circuit.library import LogNormalDistribution
# number of qubits to represent the uncertainty
num_uncertainty_qubits = 3
# parameters for considered random distribution
S = 2.0 # initial spot price
vol = 0.4 # volatility of 40%
r = 0.05 # annual interest rate of 4%
T = 40 / 365 # 40 days to maturity
# resulting parameters for log-normal distribution
mu = (r - 0.5 * vol**2) * T + np.log(S)
sigma = vol * np.sqrt(T)
mean = np.exp(mu + sigma**2 / 2)
variance = (np.exp(sigma**2) - 1) * np.exp(2 * mu + sigma**2)
stddev = np.sqrt(variance)
# lowest and highest value considered for the spot price; in between, an equidistant discretization is considered.
low = np.maximum(0, mean - 3 * stddev)
high = mean + 3 * stddev
# construct A operator for QAE for the payoff function by
# composing the uncertainty model and the objective
uncertainty_model = LogNormalDistribution(
num_uncertainty_qubits, mu=mu, sigma=sigma**2, bounds=(low, high)
)
# plot probability distribution
x = uncertainty_model.values
y = uncertainty_model.probabilities
plt.bar(x, y, width=0.2)
plt.xticks(x, size=15, rotation=90)
plt.yticks(size=15)
plt.grid()
plt.xlabel("Spot Price at Maturity $S_T$ (\$)", size=15)
plt.ylabel("Probability ($\%$)", size=15)
plt.show()
# set the strike price (should be within the low and the high value of the uncertainty)
strike_price = 2.126
# set the approximation scaling for the payoff function
rescaling_factor = 0.25
# setup piecewise linear objective fcuntion
breakpoints = [low, strike_price]
slopes = [-1, 0]
offsets = [strike_price - low, 0]
f_min = 0
f_max = strike_price - low
european_put_objective = LinearAmplitudeFunction(
num_uncertainty_qubits,
slopes,
offsets,
domain=(low, high),
image=(f_min, f_max),
breakpoints=breakpoints,
rescaling_factor=rescaling_factor,
)
# construct A operator for QAE for the payoff function by
# composing the uncertainty model and the objective
european_put = european_put_objective.compose(uncertainty_model, front=True)
# plot exact payoff function (evaluated on the grid of the uncertainty model)
x = uncertainty_model.values
y = np.maximum(0, strike_price - x)
plt.plot(x, y, "ro-")
plt.grid()
plt.title("Payoff Function", size=15)
plt.xlabel("Spot Price", size=15)
plt.ylabel("Payoff", size=15)
plt.xticks(x, size=15, rotation=90)
plt.yticks(size=15)
plt.show()
# evaluate exact expected value (normalized to the [0, 1] interval)
exact_value = np.dot(uncertainty_model.probabilities, y)
exact_delta = -sum(uncertainty_model.probabilities[x <= strike_price])
print("exact expected value:\t%.4f" % exact_value)
print("exact delta value: \t%.4f" % exact_delta)
# set target precision and confidence level
epsilon = 0.01
alpha = 0.05
problem = EstimationProblem(
state_preparation=european_put,
objective_qubits=[num_uncertainty_qubits],
post_processing=european_put_objective.post_processing,
)
# construct amplitude estimation
ae = IterativeAmplitudeEstimation(
epsilon_target=epsilon, alpha=alpha, sampler=Sampler(run_options={"shots": 100})
)
result = ae.estimate(problem)
conf_int = np.array(result.confidence_interval_processed)
print("Exact value: \t%.4f" % exact_value)
print("Estimated value: \t%.4f" % (result.estimation_processed))
print("Confidence interval:\t[%.4f, %.4f]" % tuple(conf_int))
# setup piecewise linear objective fcuntion
breakpoints = [low, strike_price]
slopes = [0, 0]
offsets = [1, 0]
f_min = 0
f_max = 1
european_put_delta_objective = LinearAmplitudeFunction(
num_uncertainty_qubits,
slopes,
offsets,
domain=(low, high),
image=(f_min, f_max),
breakpoints=breakpoints,
)
# construct circuit for payoff function
european_put_delta = european_put_delta_objective.compose(uncertainty_model, front=True)
# set target precision and confidence level
epsilon = 0.01
alpha = 0.05
problem = EstimationProblem(
state_preparation=european_put_delta, objective_qubits=[num_uncertainty_qubits]
)
# construct amplitude estimation
ae_delta = IterativeAmplitudeEstimation(
epsilon_target=epsilon, alpha=alpha, sampler=Sampler(run_options={"shots": 100})
)
result_delta = ae_delta.estimate(problem)
conf_int = -np.array(result_delta.confidence_interval)[::-1]
print("Exact delta: \t%.4f" % exact_delta)
print("Esimated value: \t%.4f" % -result_delta.estimation)
print("Confidence interval: \t[%.4f, %.4f]" % tuple(conf_int))
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/Tojarieh97/VQE
|
Tojarieh97
|
from qiskit.circuit.library.standard_gates import RXGate, RZGate, CXGate, CZGate
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
def get_thetas_circuit(thetas, D2):
qr = QuantumRegister(4, name="qubit")
qc = QuantumCircuit(qr)
for d in range(D2):
qc.append(RXGate(thetas[0]), [qr[0]])
qc.append(RXGate(thetas[1]), [qr[1]])
qc.append(RXGate(thetas[2]), [qr[2]])
qc.append(RXGate(thetas[3]), [qr[3]])
qc.append(RZGate(thetas[4]), [qr[0]])
qc.append(RZGate(thetas[5]), [qr[1]])
qc.append(RZGate(thetas[6]), [qr[2]])
qc.append(RZGate(thetas[7]), [qr[3]])
qc.append(CZGate(), [qr[0], qr[1]])
qc.append(CZGate(), [qr[1], qr[2]])
qc.append(CZGate(), [qr[2], qr[3]])
qc.barrier(qr)
qc.append(RXGate(thetas[0]), [qr[0]])
qc.append(RXGate(thetas[1]), [qr[1]])
qc.append(RXGate(thetas[2]), [qr[2]])
qc.append(RXGate(thetas[3]), [qr[3]])
qc.append(RZGate(thetas[4]), [qr[0]])
qc.append(RZGate(thetas[5]), [qr[1]])
qc.append(RZGate(thetas[6]), [qr[2]])
qc.append(RZGate(thetas[7]), [qr[3]])
return qc
def get_phis_circuit(phis, D1):
qr = QuantumRegister(4, name="qubit")
qc = QuantumCircuit(qr)
for d in range(D1):
qc.append(RXGate(phis[0]), [qr[2]])
qc.append(RXGate(phis[1]), [qr[3]])
qc.append(RZGate(phis[2]), [qr[2]])
qc.append(RZGate(phis[3]), [qr[3]])
qc.append(CZGate(), [qr[2], qr[3]])
qc.barrier(qr)
return qc
def get_full_variational_quantum_circuit(thetas, phis, D1, D2):
thetas_quantum_circuit = get_thetas_circuit(thetas, D2)
phis_quantum_circuit = get_phis_circuit(phis, D1)
variational_quantum_circuit = phis_quantum_circuit.compose(thetas_quantum_circuit)
return variational_quantum_circuit
import numpy as np
thetas = np.random.uniform(low=0, high=2*np.pi, size=8)
phis = np.random.uniform(low=0, high=2*np.pi, size=4)
D1 = 2
D2 = 6
qc1 = get_thetas_circuit(thetas,D2)
print(qc1.draw())
qc2 = get_phis_circuit(phis,D1)
print(qc2.draw())
print(get_full_variational_quantum_circuit(thetas, phis, D1, D2))
|
https://github.com/PabloMartinezAngerosa/QAOA-uniform-convergence
|
PabloMartinezAngerosa
|
from tsp_qaoa import test_solution
from qiskit.visualization import plot_histogram
import networkx as nx
import numpy as np
import json
import csv
# Array of JSON Objects
header = ['instance','p','distance', 'mean']
length_p = 3
length_instances = 2
with open('qaoa_multiple_p_distance.csv', 'w', encoding='UTF8') as f:
writer = csv.writer(f)
# write the header
writer.writerow(header)
instance_index = 0
for instance in range(length_instances):
instance_index += 1
first_p = False
UNIFORM_CONVERGENCE_P = []
UNIFORM_CONVERGENCE_SAMPLE = []
for p in range(length_p):
p = p+1
if first_p == False:
print("Vuelve a llamar a test_solution")
job_2, G, UNIFORM_CONVERGENCE_SAMPLE = test_solution(p=p)
first_p = True
else:
job_2, G, UNIFORM_CONVERGENCE_SAMPLE = test_solution(grafo=G, p=p)
# Sort the JSON data based on the value of the brand key
UNIFORM_CONVERGENCE_SAMPLE.sort(key=lambda x: x["mean"])
convergence_min = UNIFORM_CONVERGENCE_SAMPLE[0]
UNIFORM_CONVERGENCE_P.append({
"mean":convergence_min["mean"],
"probabilities": convergence_min["probabilities"]
})
cauchy_function_nk = UNIFORM_CONVERGENCE_P[len(UNIFORM_CONVERGENCE_P) - 1]
p_index = 0
for p_state in UNIFORM_CONVERGENCE_P:
p_index += 1
print(p_index)
mean = p_state["mean"]
print(p_state)
print(mean)
distance_p_cauchy_function_nk = np.max(np.abs(cauchy_function_nk["probabilities"] - p_state["probabilities"]))
writer.writerow([instance_index, p_index, distance_p_cauchy_function_nk, mean])
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
from qiskit import *
def Hxxx():
H = tp(tp(pauli(1),pauli(1)),id(2)) + tp(id(2),tp(pauli(1),pauli(1)))\
+ tp(tp(pauli(2),pauli(2)),id(2)) + tp(id(2),tp(pauli(2),pauli(2)))\
+ tp(tp(pauli(3),pauli(3)),id(2)) + tp(id(2),tp(pauli(3),pauli(3)))
return H
H = Hxxx(); H
#eig
#eig = H.eigenvects(); eig[0], eig[0][0], eig[0][2][0]
def mat_exp(A):
d = A.shape[0]; eig = A.eigenvects(); Aexp = zeros(d,d); ne = 0; j = 0; lk = 0
while ne < d:
mult = eig[j][1]; ne += mult
for k in range(0,mult):
Proj = proj(eig[j][2][k]); Aexp += exp(eig[j][0])*(Proj/trace(Proj))
j += 1
return Aexp
simplify(mat_exp(pauli(1)))
def UHxxx(t):
H = Hxxx()
return mat_exp(-1j*t*H)
U = UHxxx(0); U
psi0 = tp(tp(cb(2,1),cb(2,1)),cb(2,0)); #psi0
dt = 0.05; t = np.arange(0, 2*pi+dt, dt); d = len(t); F = np.zeros(d); psit = psi0
for j in range(0, d):
U = UHxxx(t[j]); psit = U*psi0
ip = inner_product(psi0, psit); F[j] = ip*conjugate(ip)
#print(t[j], F[j])
plt.figure(figsize = (6,4), dpi = 100)
plt.plot(t, F); plt.xlabel(r'$t$'); plt.ylabel(r'$F$'); plt.grid(); plt.show()
t = symbols('t'); U = UHxxx(t); psit = U*psi0; simplify(psit)
tp(tp(cb(2,0),cb(2,0)), cb(2,0)).T, tp(tp(cb(2,0),cb(2,0)), cb(2,1)).T, tp(tp(cb(2,0),cb(2,1)), cb(2,0)).T,\
tp(tp(cb(2,1),cb(2,0)), cb(2,0)).T, tp(tp(cb(2,0),cb(2,1)), cb(2,1)).T, tp(tp(cb(2,1),cb(2,0)), cb(2,1)).T,\
tp(tp(cb(2,1),cb(2,1)), cb(2,0)).T, tp(tp(cb(2,1),cb(2,1)), cb(2,1)).T
1/3, 1/6
H12 = tp(tp(pauli(1),pauli(1)),id(2)) + tp(tp(pauli(2),pauli(2)),id(2)) + tp(tp(pauli(3),pauli(3)),id(2))
H23 = tp(id(2),tp(pauli(1),pauli(1))) + tp(id(2),tp(pauli(2),pauli(2))) + tp(id(2),tp(pauli(3),pauli(3)))
dH = comm(H12,H23); dH, dH.norm()
H1 = tp(tp(pauli(1),pauli(1)),id(2)) + tp(id(2),tp(pauli(1),pauli(1))) + tp(id(2),tp(pauli(3),pauli(3)))
H2 = tp(tp(pauli(2),pauli(2)),id(2)) + tp(id(2),tp(pauli(2),pauli(2))) + tp(tp(pauli(3),pauli(3)),id(2))
dH = comm(H1,H2); dH, dH.norm()
comm(tp(pauli(1),pauli(1)),tp(pauli(2),pauli(2)))
XX = tp(pauli(1), pauli(1)); YY = tp(pauli(2), pauli(2)); ZZ = tp(pauli(3), pauli(3)); XX, YY, ZZ
XX.eigenvects(), YY.eigenvects()#, ZZ.eigenvects()
def Hxxx12():
H = tp(pauli(1),pauli(1)) + tp(pauli(2),pauli(2)) + tp(pauli(3),pauli(3))
return tp(H,id(2))
def Hxxx23():
H = tp(pauli(1),pauli(1)) + tp(pauli(2),pauli(2)) + tp(pauli(3),pauli(3))
return tp(id(2),H)
def UHxxx12(t):
H = Hxxx12()
return mat_exp(-1j*t*H)
def UHxxx23(t):
H = Hxxx23()
return mat_exp(-1j*t*H)
dt = 0.05; t = np.arange(0, 2*pi+dt, dt); d = len(t)
F1 = np.zeros(d); F2 = np.zeros(d); F3 = np.zeros(d); F4 = np.zeros(d); F5 = np.zeros(d)
psit1 = psi0; psit2 = psi0; psit3 = psi0; psit4 = psi0; psit5 = psi0
for j in range(0, d):
U12 = UHxxx12(t[j]); U23 = UHxxx23(t[j]); U1 = U12*U23; psit1 = U1*psi0
ip = inner_product(psi0,psit1); F1[j] = ip*conjugate(ip)
#U12 = UHxxx12(t[j]/2); U23 = UHxxx23(t[j]/2); U2 = U12*U23*U12*U23; psit2 = U2*psi0
#ip = inner_product(psi0,psit2); F2[j] = ip*conjugate(ip)
#U12 = UHxxx12(t[j]/3); U23 = UHxxx23(t[j]/3); U3 = U12*U23*U12*U23*U12*U23; psit3 = U3*psi0
#ip = inner_product(psi0,psit3); F3[j] = ip*conjugate(ip)
#U12 = UHxxx12(t[j]/4); U23 = UHxxx23(t[j]/4); U4 = U12*U23*U12*U23*U12*U23*U12*U23; psit4 = U4*psi0
#ip = inner_product(psi0,psit4); F4[j] = ip*conjugate(ip)
#U12 = UHxxx12(t[j]/5); U23 = UHxxx23(t[j]/5); U5 = U12*U23*U12*U23*U12*U23*U12*U23*U12*U23; psit5 = U5*psi0
#ip = inner_product(psi0,psit5); F5[j] = ip*conjugate(ip)
plt.figure(figsize = (6,3), dpi = 100)
plt.plot(t, F, '^', label = r'$F$'); plt.plot(t, F1, '--', label = r'$F_{1}$')
#plt.plot(t, F2, '-.', label = r'$F_{2}$'); plt.plot(t, F3, ':', label = r'$F_{3}$')
#plt.plot(t, F4, '.', label = r'$F_{4}$'); plt.plot(t, F5, '*', label = r'$F_{5}$')
plt.xlabel(r'$t$'); plt.legend(bbox_to_anchor=(1.05, 1.0), loc='upper left')
plt.grid(); plt.show()
# esse cΓ‘lculo "simbΓ³lico" demora muito. Melhor usar o numpy!
# matrizes de Pauli
I = np.array([[1,0],[0,1]]); #print(I)
X = np.array([[0,1],[1,0]]); #print(X)
Y = np.array([[0,-1j],[1j,0]]);# print(Y)
Z = np.array([[1,0],[0,-1]]); #print(Z)
def Hxxx_num():
H = np.kron(np.kron(X,X),I) + np.kron(I,np.kron(X,X))\
+ np.kron(np.kron(Y,Y),I) + np.kron(I,np.kron(Y,Y))\
+ np.kron(np.kron(Z,Z),I) + np.kron(I,np.kron(Z,Z))
return H
H = Hxxx_num(); print(H.real)
# para calcular a função de matriz (teve problemas de pequenas oscilaçáes)
def proj_num(psi):
#return np.outer(psi, np.ndarray.conjugate(psi))
d = len(psi); proj = np.zeros((d, d), dtype = complex)
for j in range(0, d):
for k in range(0, d):
proj[j,k] = psi[j]*np.conj(psi[k])
return proj
proj_num(np.array([[1],[1j]]))
import cmath
#from math import e
# para calcular a função de matriz (teve problemas de pequenas oscilaçáes)
def mat_exp_num(A):
d = A.shape[0]; Aexp = np.zeros((d,d), dtype = complex);
eva, eve = np.linalg.eig(A);
# eva, eve = scipy.linalg.eig(A)
for j in range(0, d):
Aexp += cmath.exp(eva[j])*proj_num(eve[:,j])
#Aexp += e**(eva[j])*proj_num(eve[:,j])
return Aexp
mat_exp_num(Y)
def UHxxx_num(t):
H = Hxxx_num()
#return mat_exp_num(-1j*t*H)
return scipy.linalg.expm(-1j*t*H) # resolveu o problema das pequenas flutuaçáes
U = UHxxx_num(0*math.pi); U.real
def ip_num(a, b):
d = len(a); ip = 0
for j in range(0, d):
ip += np.conj(a[j])*b[j]
return ip
a = np.array([[1],[1j]]); b = np.array([[1],[1j]]); ip_num(a, b)
ket0 = np.array([[1],[0]]); ket1 = np.array([[0],[1]]); #ket0, ket1
dt = 0.05; t = np.arange(0, math.pi+dt, dt); d = len(t); F = np.zeros(d); psit = np.zeros(d, dtype = complex)
psi0_ = np.zeros(d, dtype = complex); psi0_ = np.kron(ket1, np.kron(ket1, ket0)); #psi0
for j in range(0, d):
U = UHxxx_num(t[j]); psit = np.dot(U, psi0_)
#ip = ip_num(psi0_, psit); F[j] = np.abs(ip)**2
F[j] = qiskit.quantum_info.state_fidelity(psi0_, psit)
plt.figure(figsize = (6,4), dpi = 100)
plt.plot(t, F); plt.xlabel(r'$t$'); plt.ylabel(r'$F$'); plt.grid(); plt.show()
H2 = np.kron(X, X) + np.kron(Y, Y) + np.kron(Z, Z)
def UHxxx12_num(t):
H = np.kron(H2, I)
return scipy.linalg.expm(-1j*t*H)
def UHxxx23_num(t):
H = np.kron(I, H2)
return scipy.linalg.expm(-1j*t*H)
dt = 0.05; t = np.arange(0, math.pi+dt, dt); d = len(t)
#F = np.zeros(d);
F1 = np.zeros(d); F2 = np.zeros(d); F3 = np.zeros(d); F4 = np.zeros(d); F5 = np.zeros(d)
F6 = np.zeros(d); F7 = np.zeros(d); F8 = np.zeros(d); F9 = np.zeros(d); F10 = np.zeros(d); F11 = np.zeros(d)
#psi0_ = np.zeros(d, dtype = complex);
psi0_ = np.kron(ket1, np.kron(ket1, ket0))
for j in range(0, d):
U12 = UHxxx12_num(t[j]); U23 = UHxxx23_num(t[j])
B = np.dot(U12, U23); U1 = np.linalg.matrix_power(B, 1); psit1 = np.dot(U1, psi0_)
#ip = ip_num(psi0_, psit1); F1[j] = np.abs(ip)**2
F1[j] = qiskit.quantum_info.state_fidelity(psi0_, psit1)
U12 = UHxxx12_num(t[j]/2); U23 = UHxxx23_num(t[j]/2)
B = np.dot(U12, U23); U2 = np.linalg.matrix_power(B, 2); psit2 = np.dot(U2, psi0_)
#ip = ip_num(psi0_, psit2); F2[j] = np.abs(ip)**2
F2[j] = qiskit.quantum_info.state_fidelity(psi0_, psit2)
U12 = UHxxx12_num(t[j]/3); U23 = UHxxx23_num(t[j]/3)
B = np.dot(U12, U23); U3 = np.linalg.matrix_power(B, 3); psit3 = np.dot(U3, psi0_)
#ip = ip_num(psi0_, psit3); F3[j] = np.abs(ip)**2
F3[j] = qiskit.quantum_info.state_fidelity(psi0_, psit3)
U12 = UHxxx12_num(t[j]/4); U23 = UHxxx23_num(t[j]/4)
B = np.dot(U12, U23); U4 = np.linalg.matrix_power(B, 4); psit4 = np.dot(U4, psi0_)
#ip = ip_num(psi0_, psit4); F4[j] = np.abs(ip)**2
F4[j] = qiskit.quantum_info.state_fidelity(psi0_, psit4)
U12 = UHxxx12_num(t[j]/5); U23 = UHxxx23_num(t[j]/5)
B = np.dot(U12, U23); U5 = np.linalg.matrix_power(B, 5); psit5 = np.dot(U5, psi0_)
#ip = ip_num(psi0_, psit5); F5[j] = np.abs(ip)**2
F5[j] = qiskit.quantum_info.state_fidelity(psi0_, psit5)
U12 = UHxxx12_num(t[j]/6); U23 = UHxxx23_num(t[j]/6)
B = np.dot(U12, U23); U6 = np.linalg.matrix_power(B, 6); psit6 = np.dot(U6, psi0_)
#ip = ip_num(psi0_, psit6); F6[j] = np.abs(ip)**2
F6[j] = qiskit.quantum_info.state_fidelity(psi0_, psit6)
U12 = UHxxx12_num(t[j]/7); U23 = UHxxx23_num(t[j]/7)
B = np.dot(U12, U23); U7 = np.linalg.matrix_power(B, 7); psit7 = np.dot(U7, psi0_)
#ip = ip_num(psi0_, psit7); F7[j] = np.abs(ip)**2
F7[j] = qiskit.quantum_info.state_fidelity(psi0_, psit7)
U12 = UHxxx12_num(t[j]/8); U23 = UHxxx23_num(t[j]/8)
B = np.dot(U12, U23); U8 = np.linalg.matrix_power(B, 8); psit8 = np.dot(U8, psi0_)
#ip = ip_num(psi0_, psit8); F8[j] = np.abs(ip)**2
F8[j] = qiskit.quantum_info.state_fidelity(psi0_, psit8)
U12 = UHxxx12_num(t[j]/9); U23 = UHxxx23_num(t[j]/9)
B = np.dot(U12, U23); U9 = np.linalg.matrix_power(B, 9); psit9 = np.dot(U9, psi0_)
#ip = ip_num(psi0_, psit9); F9[j] = np.abs(ip)**2
F9[j] = qiskit.quantum_info.state_fidelity(psi0_, psit9)
U12 = UHxxx12_num(t[j]/10); U23 = UHxxx23_num(t[j]/10)
B = np.dot(U12, U23); U10 = np.linalg.matrix_power(B, 10); psit10 = np.dot(U10, psi0_)
#ip = ip_num(psi0_, psit10); F10[j] = np.abs(ip)**2
F10[j] = qiskit.quantum_info.state_fidelity(psi0_, psit10)
U12 = UHxxx12_num(t[j]/11); U23 = UHxxx23_num(t[j]/11)
B = np.dot(U12, U23); U11 = np.linalg.matrix_power(B, 11); psit11 = np.dot(U11, psi0_)
#ip = ip_num(psi0_, psit11); F11[j] = np.abs(ip)**2
F11[j] = qiskit.quantum_info.state_fidelity(psi0_, psit11)
if j == d-1:
print('F5 = ', F5[j], ', F6 = ', F6[j])
plt.figure(figsize = (8,5), dpi = 100)
plt.plot(t, F, '^', label = r'$F$');
plt.plot(t, F1, '-.', label = r'$F_{1}$')
plt.plot(t, F2, '', label = r'$F_{2}$'); plt.plot(t, F3, '-.', label = r'$F_{3}$')
plt.plot(t, F4, '', label = r'$F_{4}$'); plt.plot(t, F5, '-.', label = r'$F_{5}$')
plt.plot(t, F6, '', label = r'$F_{6}$'); plt.plot(t, F7, '-.', label = r'$F_{7}$')
plt.plot(t, F8, '', label = r'$F_{8}$'); plt.plot(t, F9, '-.', label = r'$F_{9}$')
plt.plot(t, F10, '*', label = r'$F_{10}$'); plt.plot(t, F11, 'o', label = r'$F_{11}$')
plt.xlabel(r'$t$'); plt.legend(bbox_to_anchor=(1.05, 1.0), loc='upper left')
plt.grid(); plt.show()
def qc_ezz(t):
qc = QuantumCircuit(2, name = 'e^(-itZZ)')
qc.cx(0, 1); qc.rz(2*t, 1); qc.cx(0, 1)
return qc
qc_ezz_ = qc_ezz(math.pi); qc_ezz_.draw(output='mpl')
def qc_exx(t):
qc = QuantumCircuit(2, name = 'e^(-itXX)')
qc.h([0,1]); qc.cx(0, 1); qc.rz(2*t, 1); qc.cx(0, 1); qc.h([0,1])
#qc.h([0,1]); qc_ezz_ = qc_ezz(t); qc.append(qc_ezz_, [0, 1]); qc.h([0,1])
return qc
qc_exx_ = qc_exx(math.pi); qc_exx_.draw(output='mpl')
#qc_exx_.decompose().draw(output='mpl')
def qc_eyy(t):
qc = QuantumCircuit(2, name = 'e^(-itYY)')
qc.sdg([0,1]); qc.h([0,1]); qc.cx(0, 1); qc.rz(2*t, 1); qc.cx(0, 1); qc.h([0,1]); qc.s([0,1])
#qc.sdg([0,1]); qc_exx_ = qc_exx(t); qc.append(qc_exx_, [0, 1]); qc.s([0,1])
return qc
qc_eyy_ = qc_eyy(math.pi); qc_eyy_.draw(output='mpl')
#qc_eyy_.decompose().draw(output='mpl')
def qc_Bj(t):
qc = QuantumCircuit(3, name = 'B_j')
qc_ezz_ = qc_ezz(t); qc_eyy_ = qc_eyy(t); qc_exx_ = qc_exx(t)
qc.append(qc_ezz_, [1, 2]); qc.append(qc_eyy_, [1, 2]); qc.append(qc_exx_, [1, 2])
qc.append(qc_ezz_, [0, 1]); qc.append(qc_eyy_, [0, 1]); qc.append(qc_exx_, [0, 1])
return qc
qc_Bj_ = qc_Bj(math.pi/2); qc_Bj_.draw(output='mpl')
qc_Bj_.decompose().draw(output='mpl')
def F_psi_rho_num(psi, rho):
d = rho.shape[0]; F = 0
for j in range(0, d):
for k in range(0, d):
F += np.conj(psi[j])*rho[j,k]*psi[k]
return F.real
psi = [1/math.sqrt(2),1j/math.sqrt(2)]; rho = 0.5*np.array([[1,-1j],[1j,1]])
F = F_psi_rho_num(psi, rho); print(F) # ok!
nshots = 8192
qiskit.IBMQ.load_account()
#provider = IBMQ.get_provider(hub='ibm-q-community', group='ibmquantumawards', project='open-science-22')
#device = provider.get_backend('ibmq_jakarta')
provider = qiskit.IBMQ.get_provider(hub = 'ibm-q-research-2', group = 'federal-uni-sant-1', project = 'main')
device = provider.get_backend('ibmq_bogota')
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.tools.monitor import backend_overview, backend_monitor
backend_overview()
def qc_psi0():
qc = QuantumCircuit(3, name = 'psi0')
qc.x([0,1])
return qc
qc_psi0_ = qc_psi0(); qc_psi0_.draw(output = 'mpl')
psi0_ = np.kron(ket1, np.kron(ket1, ket0));
psi0__ = np.kron(ket0, np.kron(ket1, ket1)) # para calcular a fidelidade com o estado da tomografia
psi0_.T, psi0__.T
nshots = 500
dt = 0.2; t = np.arange(0, math.pi+dt, dt); d = len(t)
F_teo = np.zeros(d); F_sim = np.zeros(d); F_exp = np.zeros(d)
for j in range(0, d):fidelity
# teΓ³rico
U12 = UHxxx12_num(t[j]/2); U23 = UHxxx23_num(t[j]/2)
B = np.dot(U12, U23); U = np.linalg.matrix_power(B, 2); psit = np.dot(U, psi0_)
F_teo[j] = qiskit.quantum_info.state_fidelity(psi0_, psit)
# circuito quΓ’ntico
qc = QuantumCircuit(3)
qc_psi0_ = qc_psi0(); qc.append(qc_psi0_, [0, 1, 2])
qc_Bj_ = qc_Bj(t[j]/2); qc.append(qc_Bj_, [0, 1, 2]); qc.append(qc_Bj_, [0, 1, 2]) # 2 passos de Trotter
qstc = state_tomography_circuits(qc, [0, 1, 2])
# simulação
job = qiskit.execute(qstc, backend = simulator, shots = nshots)
qstf = StateTomographyFitter(job.result(), qstc)
rho = qstf.fit(method = 'lstsq')
F_sim[j] = qiskit.quantum_info.state_fidelity(psi0__, rho)
# experimento
jobE = qiskit.execute(qstc, backend = device, shots = nshots)
print(jobE.job_id()); job_monitor(jobE)
qstfE = StateTomographyFitter(jobE.result(), qstc)
rhoE = qstfE.fit(method = 'lstsq')
F_exp[j] = qiskit.quantum_info.state_fidelity(psi0__, rhoE)
qc.draw(output = 'mpl')
plt.figure(figsize = (8,5), dpi = 100)
plt.plot(t, F_teo, '-.', label = r'$F_{teo}$'); plt.plot(t, F_sim, '-.', label = r'$F_{sim}$')
plt.plot(t, F_exp, '-.', label = r'$F_{exp}$')
plt.xlabel(r'$t$'); plt.legend(bbox_to_anchor=(1.05, 1.0), loc='upper left')
plt.grid(); plt.show()
device = provider.get_backend('ibmq_jakarta')
jakarta_info = backend_monitor(device); print(jakarta_info)
nshots = 500
t = math.pi
for j in range(0, 7): # muda o No. de passos de Trotter
# teΓ³rico
U12 = UHxxx12_num(t/(j+1)); U23 = UHxxx23_num(t/(j+1))
B = np.dot(U12, U23); U = np.linalg.matrix_power(B, j+1); psit = np.dot(U, psi0_)
F_teo = qiskit.quantum_info.state_fidelity(psi0_, psit)
# circuit q
qc = QuantumCircuit(3)
qc_psi0_ = qc_psi0(); qc.append(qc_psi0_, [0, 1, 2])
qc_Bj_ = qc_Bj(t/(j+1))
for k in range(0, j+1):
qc.append(qc_Bj_, [0, 1, 2])
qstc = state_tomography_circuits(qc, [0, 1, 2])
# simulação
job = qiskit.execute(qstc, backend = simulator, shots = nshots)
qstf = StateTomographyFitter(job.result(), qstc)
rho = qstf.fit(method = 'lstsq')
F_sim = qiskit.quantum_info.state_fidelity(psi0__, rho)
# experimento
jobE = qiskit.execute(qstc, backend = device, shots = nshots)
print(jobE.job_id()); job_monitor(jobE)
qstfE = StateTomographyFitter(jobE.result(), qstc)
rhoE = qstfE.fit(method = 'lstsq')
F_exp = qiskit.quantum_info.state_fidelity(psi0__, rhoE)
print('No. passos=', j+1, ',F_teo=', F_teo, ',F_sim=', F_sim, ',F_exp=', F_exp)
qc.draw(output = 'mpl')
nshots = 500;
Npt = 7 # NΓΊmero de passos de Trotter
ph = 2*math.pi # Òngulo para a transformação de simetria
t = math.pi
for j in range(0, Npt): # muda o No. de passos de Trotter
# teΓ³rico
U12 = UHxxx12_num(t/(j+1)); U23 = UHxxx23_num(t/(j+1))
B = np.dot(U12, U23); U = np.linalg.matrix_power(B, j+1); psit = np.dot(U, psi0_)
F_teo = qiskit.quantum_info.state_fidelity(psi0_, psit)
# circuit q
qc = QuantumCircuit(3)
qc_psi0_ = qc_psi0(); qc.append(qc_psi0_, [0, 1, 2]) # estado inicial
qc_Bj_ = qc_Bj(t/(j+1))
for k in range(0, j+1):
qc.rz(ph/(j+1), [0, 1, 2]) # transformação de simetria
qc.append(qc_Bj_, [0, 1, 2])
qc.rz(-ph, [0, 1, 2]) # revertendo a transformação de simetria
if j == 1:
qc.draw(output = 'mpl')
qstc = state_tomography_circuits(qc, [0, 1, 2])
# simulação
job = qiskit.execute(qstc, backend = simulator, shots = nshots)
qstf = StateTomographyFitter(job.result(), qstc)
rho = qstf.fit(method = 'lstsq')
F_sim = qiskit.quantum_info.state_fidelity(psi0__, rho)
# experimento
jobE = qiskit.execute(qstc, backend = device, shots = nshots)
print(jobE.job_id()); job_monitor(jobE)
qstfE = StateTomographyFitter(jobE.result(), qstc)
rhoE = qstfE.fit(method = 'lstsq')
F_exp = qiskit.quantum_info.state_fidelity(psi0__, rhoE)
print('No. passos=', j+1, ',F_teo=', F_teo, ',F_sim=', F_sim, ',F_exp=', F_exp)
qc.draw(output = 'mpl')
nshots = 1000;
Npt = 7 # NΓΊmero de passos de Trotter
ph = 2*math.pi # Òngulo para a transformação de simetria RZ
th = math.pi # Òngulo para a transformação de simetria RX
t = math.pi
for j in range(0, Npt): # muda o No. de passos de Trotter
# teΓ³rico
U12 = UHxxx12_num(t/(j+1)); U23 = UHxxx23_num(t/(j+1))
B = np.dot(U12, U23); U = np.linalg.matrix_power(B, j+1); psit = np.dot(U, psi0_)
F_teo = qiskit.quantum_info.state_fidelity(psi0_, psit)
# circuit q
qc = QuantumCircuit(3)
qc_psi0_ = qc_psi0(); qc.append(qc_psi0_, [0, 1, 2]) # estado inicial
qc_Bj_ = qc_Bj(t/(j+1))
for k in range(0, j+1):
qc.rx(th/(j+1), [0, 1, 2]) # transformação de simetria RX
qc.rz(ph/(j+1), [0, 1, 2]) # transformação de simetria RZ
qc.append(qc_Bj_, [0, 1, 2])
qc.rz(-ph, [0, 1, 2]) # revertendo a transformação de simetria RZ
qc.rx(-th, [0, 1, 2]) # revertendo a transformação de simetria RX
if j == 1:
qc.draw(output = 'mpl')
qstc = state_tomography_circuits(qc, [0, 1, 2])
# simulação
job = qiskit.execute(qstc, backend = simulator, shots = nshots)
qstf = StateTomographyFitter(job.result(), qstc)
rho = qstf.fit(method = 'lstsq')
F_sim = qiskit.quantum_info.state_fidelity(psi0__, rho)
# experimento
jobE = qiskit.execute(qstc, backend = device, shots = nshots)
print(jobE.job_id()); job_monitor(jobE)
qstfE = StateTomographyFitter(jobE.result(), qstc)
rhoE = qstfE.fit(method = 'lstsq')
F_exp = qiskit.quantum_info.state_fidelity(psi0__, rhoE)
print('No. passos=', j+1, ',F_teo=', F_teo, ',F_sim=', F_sim, ',F_exp=', F_exp)
qc.draw(output = 'mpl')
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# 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.
"""Test hardcoded decomposition rules and matrix definitions for standard gates."""
import inspect
import numpy as np
from ddt import ddt, data, idata, unpack
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.quantum_info import Operator
from qiskit.test import QiskitTestCase
from qiskit.circuit import ParameterVector, Gate, ControlledGate
from qiskit.circuit.library import standard_gates
from qiskit.circuit.library import (
HGate,
CHGate,
IGate,
RGate,
RXGate,
CRXGate,
RYGate,
CRYGate,
RZGate,
CRZGate,
SGate,
SdgGate,
CSwapGate,
TGate,
TdgGate,
U1Gate,
CU1Gate,
U2Gate,
U3Gate,
CU3Gate,
XGate,
CXGate,
ECRGate,
CCXGate,
YGate,
CYGate,
ZGate,
CZGate,
RYYGate,
PhaseGate,
CPhaseGate,
UGate,
CUGate,
SXGate,
SXdgGate,
CSXGate,
RVGate,
XXMinusYYGate,
)
from qiskit.circuit.library.standard_gates.equivalence_library import (
StandardEquivalenceLibrary as std_eqlib,
)
from .gate_utils import _get_free_params
class TestGateDefinitions(QiskitTestCase):
"""Test the decomposition of a gate in terms of other gates
yields the equivalent matrix as the hardcoded matrix definition
up to a global phase."""
def test_ch_definition(self): # TODO: expand this to all gates
"""Test ch gate matrix and definition."""
circ = QuantumCircuit(2)
circ.ch(0, 1)
decomposed_circ = circ.decompose()
self.assertTrue(Operator(circ).equiv(Operator(decomposed_circ)))
def test_ccx_definition(self):
"""Test ccx gate matrix and definition."""
circ = QuantumCircuit(3)
circ.ccx(0, 1, 2)
decomposed_circ = circ.decompose()
self.assertTrue(Operator(circ).equiv(Operator(decomposed_circ)))
def test_crz_definition(self):
"""Test crz gate matrix and definition."""
circ = QuantumCircuit(2)
circ.crz(1, 0, 1)
decomposed_circ = circ.decompose()
self.assertTrue(Operator(circ).equiv(Operator(decomposed_circ)))
def test_cry_definition(self):
"""Test cry gate matrix and definition."""
circ = QuantumCircuit(2)
circ.cry(1, 0, 1)
decomposed_circ = circ.decompose()
self.assertTrue(Operator(circ).equiv(Operator(decomposed_circ)))
def test_crx_definition(self):
"""Test crx gate matrix and definition."""
circ = QuantumCircuit(2)
circ.crx(1, 0, 1)
decomposed_circ = circ.decompose()
self.assertTrue(Operator(circ).equiv(Operator(decomposed_circ)))
def test_cswap_definition(self):
"""Test cswap gate matrix and definition."""
circ = QuantumCircuit(3)
circ.cswap(0, 1, 2)
decomposed_circ = circ.decompose()
self.assertTrue(Operator(circ).equiv(Operator(decomposed_circ)))
def test_cu1_definition(self):
"""Test cu1 gate matrix and definition."""
circ = QuantumCircuit(2)
circ.append(CU1Gate(1), [0, 1])
decomposed_circ = circ.decompose()
self.assertTrue(Operator(circ).equiv(Operator(decomposed_circ)))
def test_cu3_definition(self):
"""Test cu3 gate matrix and definition."""
circ = QuantumCircuit(2)
circ.append(CU3Gate(1, 1, 1), [0, 1])
decomposed_circ = circ.decompose()
self.assertTrue(Operator(circ).equiv(Operator(decomposed_circ)))
def test_cx_definition(self):
"""Test cx gate matrix and definition."""
circ = QuantumCircuit(2)
circ.cx(0, 1)
decomposed_circ = circ.decompose()
self.assertTrue(Operator(circ).equiv(Operator(decomposed_circ)))
def test_ecr_definition(self):
"""Test ecr gate matrix and definition."""
circ = QuantumCircuit(2)
circ.ecr(0, 1)
decomposed_circ = circ.decompose()
self.assertTrue(Operator(circ).equiv(Operator(decomposed_circ)))
def test_rv_definition(self):
"""Test R(v) gate to_matrix and definition."""
qreg = QuantumRegister(1)
circ = QuantumCircuit(qreg)
vec = np.array([0.1, 0.2, 0.3], dtype=float)
circ.rv(*vec, 0)
decomposed_circ = circ.decompose()
self.assertTrue(Operator(circ).equiv(Operator(decomposed_circ)))
def test_rv_r_equiv(self):
"""Test R(v) gate is equivalent to R gate."""
theta = np.pi / 5
phi = np.pi / 3
rgate = RGate(theta, phi)
axis = np.array([np.cos(phi), np.sin(phi), 0]) # RGate axis
rotvec = theta * axis
rv = RVGate(*rotvec)
rg_matrix = rgate.to_matrix()
rv_matrix = rv.to_matrix()
np.testing.assert_array_max_ulp(rg_matrix.real, rv_matrix.real, 4)
np.testing.assert_array_max_ulp(rg_matrix.imag, rv_matrix.imag, 4)
def test_rv_zero(self):
"""Test R(v) gate with zero vector returns identity"""
rv = RVGate(0, 0, 0)
self.assertTrue(np.array_equal(rv.to_matrix(), np.array([[1, 0], [0, 1]])))
def test_xx_minus_yy_definition(self):
"""Test XX-YY gate decomposition."""
theta, beta = np.random.uniform(-10, 10, size=2)
gate = XXMinusYYGate(theta, beta)
circuit = QuantumCircuit(2)
circuit.append(gate, [0, 1])
decomposed_circuit = circuit.decompose()
self.assertTrue(len(decomposed_circuit) > len(circuit))
self.assertTrue(Operator(circuit).equiv(Operator(decomposed_circuit), atol=1e-7))
@ddt
class TestStandardGates(QiskitTestCase):
"""Standard Extension Test."""
@unpack
@data(
*inspect.getmembers(
standard_gates,
predicate=lambda value: (inspect.isclass(value) and issubclass(value, Gate)),
)
)
def test_definition_parameters(self, class_name, gate_class):
"""Verify definitions from standard library include correct parameters."""
free_params = _get_free_params(gate_class)
n_params = len(free_params)
param_vector = ParameterVector("th", n_params)
if class_name in ("MCPhaseGate", "MCU1Gate"):
param_vector = param_vector[:-1]
gate = gate_class(*param_vector, num_ctrl_qubits=2)
elif class_name in ("MCXGate", "MCXGrayCode", "MCXRecursive", "MCXVChain"):
num_ctrl_qubits = 2
param_vector = param_vector[:-1]
gate = gate_class(num_ctrl_qubits, *param_vector)
elif class_name == "MSGate":
num_qubits = 2
param_vector = param_vector[:-1]
gate = gate_class(num_qubits, *param_vector)
else:
gate = gate_class(*param_vector)
if gate.definition is not None:
self.assertEqual(gate.definition.parameters, set(param_vector))
@unpack
@data(
*inspect.getmembers(
standard_gates,
predicate=lambda value: (inspect.isclass(value) and issubclass(value, Gate)),
)
)
def test_inverse(self, class_name, gate_class):
"""Verify self-inverse pair yield identity for all standard gates."""
free_params = _get_free_params(gate_class)
n_params = len(free_params)
float_vector = [0.1 + 0.1 * i for i in range(n_params)]
if class_name in ("MCPhaseGate", "MCU1Gate"):
float_vector = float_vector[:-1]
gate = gate_class(*float_vector, num_ctrl_qubits=2)
elif class_name in ("MCXGate", "MCXGrayCode", "MCXRecursive", "MCXVChain"):
num_ctrl_qubits = 3
float_vector = float_vector[:-1]
gate = gate_class(num_ctrl_qubits, *float_vector)
elif class_name == "PauliGate":
pauli_string = "IXYZ"
gate = gate_class(pauli_string)
else:
gate = gate_class(*float_vector)
from qiskit.quantum_info.operators.predicates import is_identity_matrix
self.assertTrue(is_identity_matrix(Operator(gate).dot(gate.inverse()).data))
if gate.definition is not None:
self.assertTrue(is_identity_matrix(Operator(gate).dot(gate.definition.inverse()).data))
self.assertTrue(is_identity_matrix(Operator(gate).dot(gate.inverse().definition).data))
@ddt
class TestGateEquivalenceEqual(QiskitTestCase):
"""Test the decomposition of a gate in terms of other gates
yields the same matrix as the hardcoded matrix definition."""
class_list = Gate.__subclasses__() + ControlledGate.__subclasses__()
exclude = {
"ControlledGate",
"DiagonalGate",
"UCGate",
"MCGupDiag",
"MCU1Gate",
"UnitaryGate",
"HamiltonianGate",
"MCPhaseGate",
"UCPauliRotGate",
"SingleQubitUnitary",
"MCXGate",
"VariadicZeroParamGate",
"ClassicalFunction",
"ClassicalElement",
"StatePreparation",
"LinearFunction",
"PermutationGate",
"Commuting2qBlock",
"PauliEvolutionGate",
"_U0Gate",
"_DefinedGate",
}
# Amazingly, Python's scoping rules for class bodies means that this is the closest we can get
# to a "natural" comprehension or functional iterable definition:
# https://docs.python.org/3/reference/executionmodel.html#resolution-of-names
@idata(filter(lambda x, exclude=exclude: x.__name__ not in exclude, class_list))
def test_equivalence_phase(self, gate_class):
"""Test that the equivalent circuits from the equivalency_library
have equal matrix representations"""
n_params = len(_get_free_params(gate_class))
params = [0.1 * i for i in range(1, n_params + 1)]
if gate_class.__name__ == "RXXGate":
params = [np.pi / 2]
if gate_class.__name__ in ["MSGate"]:
params[0] = 2
if gate_class.__name__ in ["PauliGate"]:
params = ["IXYZ"]
if gate_class.__name__ in ["BooleanExpression"]:
params = ["x | y"]
gate = gate_class(*params)
equiv_lib_list = std_eqlib.get_entry(gate)
for ieq, equivalency in enumerate(equiv_lib_list):
with self.subTest(msg=gate.name + "_" + str(ieq)):
op1 = Operator(gate)
op2 = Operator(equivalency)
self.assertEqual(op1, op2)
@ddt
class TestStandardEquivalenceLibrary(QiskitTestCase):
"""Standard Extension Test."""
@data(
HGate,
CHGate,
IGate,
RGate,
RXGate,
CRXGate,
RYGate,
CRYGate,
RZGate,
CRZGate,
SGate,
SdgGate,
CSwapGate,
TGate,
TdgGate,
U1Gate,
CU1Gate,
U2Gate,
U3Gate,
CU3Gate,
XGate,
CXGate,
ECRGate,
CCXGate,
YGate,
CYGate,
ZGate,
CZGate,
RYYGate,
PhaseGate,
CPhaseGate,
UGate,
CUGate,
SXGate,
SXdgGate,
CSXGate,
)
def test_definition_parameters(self, gate_class):
"""Verify decompositions from standard equivalence library match definitions."""
n_params = len(_get_free_params(gate_class))
param_vector = ParameterVector("th", n_params)
float_vector = [0.1 * i for i in range(n_params)]
param_gate = gate_class(*param_vector)
float_gate = gate_class(*float_vector)
param_entry = std_eqlib.get_entry(param_gate)
float_entry = std_eqlib.get_entry(float_gate)
if not param_gate.definition or not param_gate.definition.data:
return
self.assertGreaterEqual(len(param_entry), 1)
self.assertGreaterEqual(len(float_entry), 1)
param_qc = QuantumCircuit(param_gate.num_qubits)
float_qc = QuantumCircuit(float_gate.num_qubits)
param_qc.append(param_gate, param_qc.qregs[0])
float_qc.append(float_gate, float_qc.qregs[0])
self.assertTrue(any(equiv == param_qc.decompose() for equiv in param_entry))
self.assertTrue(any(equiv == float_qc.decompose() for equiv in float_entry))
|
https://github.com/jwalaQ/my-qiskit-textbook-solutions
|
jwalaQ
|
n = 275
print("Answer = " + bin(n)[2:])
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.tools.visualization import circuit_drawer
q = QuantumRegister(1)
c = ClassicalRegister(1)
qc = QuantumCircuit(q, c)
qc.h(q)
qc.measure(q, c)
circuit_drawer(qc, output='mpl', style={'backgroundcolor': '#EEEEEE'})
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import random
from qiskit.quantum_info import Statevector
secret = random.randint(0,7) # the owner is randomly picked
secret_string = format(secret, '03b') # format the owner in 3-bit string
oracle = Statevector.from_label(secret_string) # let the oracle know the owner
from qiskit.algorithms import AmplificationProblem
problem = AmplificationProblem(oracle, is_good_state=secret_string)
from qiskit.algorithms import Grover
grover_circuits = []
for iteration in range(1,3):
grover = Grover(iterations=iteration)
circuit = grover.construct_circuit(problem)
circuit.measure_all()
grover_circuits.append(circuit)
# Grover's circuit with 1 iteration
grover_circuits[0].draw()
# Grover's circuit with 2 iterations
grover_circuits[1].draw()
from qiskit_ibm_runtime import QiskitRuntimeService
service = QiskitRuntimeService()
backend = "ibmq_qasm_simulator" # use the simulator
from qiskit_ibm_runtime import Sampler, Session
with Session(service=service, backend=backend):
sampler = Sampler()
job = sampler.run(circuits=grover_circuits, shots=1000)
result = job.result()
print(result)
from qiskit.tools.visualization import plot_histogram
# Extract bit string with highest probability from results as the answer
result_dict = result.quasi_dists[1].binary_probabilities()
answer = max(result_dict, key=result_dict.get)
print(f"As you can see, the quantum computer returned '{answer}' as the answer with highest probability.\n"
"And the results with 2 iterations have higher probability than the results with 1 iteration."
)
# Plot the results
plot_histogram(result.quasi_dists, legend=['1 iteration', '2 iterations'])
# Print the results and the correct answer.
print(f"Quantum answer: {answer}")
print(f"Correct answer: {secret_string}")
print('Success!' if answer == secret_string else 'Failure!')
import qiskit_ibm_runtime
qiskit_ibm_runtime.version.get_version_info()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
cos(-2*pi/3), sin(-2*pi/3), cos(-4*pi/3), sin(-4*pi/3), cos(-8*pi/3), sin(-8*pi/3)
|
https://github.com/Pitt-JonesLab/clonk_transpilation
|
Pitt-JonesLab
|
from typing import Optional
from qiskit.circuit.gate import Gate
from qiskit.circuit.parameterexpression import ParameterValueType
import numpy as np
class RiSwapGate(Gate):
r"""RiSWAP gate.
**Circuit Symbol:**
.. parsed-literal::
q_0: ββ¨β
R(alpha)
q_1: ββ¨β
"""
def __init__(self, alpha: ParameterValueType, label: Optional[str] = None):
"""Create new iSwap gate."""
super().__init__("riswap", 2, [alpha], label=label)
def __array__(self, dtype=None):
"""Return a numpy.array for the RiSWAP gate."""
alpha = self.params[0]
return np.array(
[
[1, 0, 0, 0],
[0, np.cos(np.pi * alpha / 2), 1j * np.sin(np.pi * alpha / 2), 0],
[0, 1j * np.sin(np.pi * alpha / 2), np.cos(np.pi * alpha / 2), 0],
[0, 0, 0, 1],
],
dtype=dtype,
)
# from Qiskits two_qubit_decomp #FIXME moving functions around still this won't need to be copied once SQiSwap inside of that same pass
import cmath
from qiskit.quantum_info.synthesis.two_qubit_decompose import *
import scipy.linalg as la
_ipx = np.array([[0, 1j], [1j, 0]], dtype=complex)
_ipy = np.array([[0, 1], [-1, 0]], dtype=complex)
_ipz = np.array([[1j, 0], [0, -1j]], dtype=complex)
_id = np.array([[1, 0], [0, 1]], dtype=complex)
def KAKDecomp(unitary_matrix, *, fidelity=(1.0 - 1.0e-9)):
"""Perform the Weyl chamber decomposition, and optionally choose a specialized subclass.
The flip into the Weyl Chamber is described in B. Kraus and J. I. Cirac, Phys. Rev. A 63,
062309 (2001).
FIXME: There's a cleaner-seeming method based on choosing branch cuts carefully, in Andrew
M. Childs, Henry L. Haselgrove, and Michael A. Nielsen, Phys. Rev. A 68, 052311, but I
wasn't able to get that to work.
The overall decomposition scheme is taken from Drury and Love, arXiv:0806.4015 [quant-ph].
"""
pi = np.pi
pi2 = np.pi / 2
pi4 = np.pi / 4
# Make U be in SU(4)
U = np.array(unitary_matrix, dtype=complex, copy=True)
detU = la.det(U)
U *= detU ** (-0.25)
global_phase = cmath.phase(detU) / 4
Up = transform_to_magic_basis(U, reverse=True)
M2 = Up.T.dot(Up)
# M2 is a symmetric complex matrix. We need to decompose it as M2 = P D P^T where
# P β SO(4), D is diagonal with unit-magnitude elements.
#
# We can't use raw `eig` directly because it isn't guaranteed to give us real or othogonal
# eigenvectors. Instead, since `M2` is complex-symmetric,
# M2 = A + iB
# for real-symmetric `A` and `B`, and as
# M2^+ @ M2 = A^2 + B^2 + i [A, B] = 1
# we must have `A` and `B` commute, and consequently they are simultaneously diagonalizable.
# Mixing them together _should_ account for any degeneracy problems, but it's not
# guaranteed, so we repeat it a little bit. The fixed seed is to make failures
# deterministic; the value is not important.
state = np.random.default_rng(2020)
for _ in range(100): # FIXME: this randomized algorithm is horrendous
M2real = state.normal() * M2.real + state.normal() * M2.imag
_, P = np.linalg.eigh(M2real)
D = P.T.dot(M2).dot(P).diagonal()
if np.allclose(P.dot(np.diag(D)).dot(P.T), M2, rtol=0, atol=1.0e-13):
break
else:
raise ValueError
d = -np.angle(D) / 2
d[3] = -d[0] - d[1] - d[2]
cs = np.mod((d[:3] + d[3]) / 2, 2 * np.pi)
# Reorder the eigenvalues to get in the Weyl chamber
cstemp = np.mod(cs, pi2)
np.minimum(cstemp, pi2 - cstemp, cstemp)
order = np.argsort(cstemp)[[1, 2, 0]]
cs = cs[order]
d[:3] = d[order]
P[:, :3] = P[:, order]
# Fix the sign of P to be in SO(4)
if np.real(la.det(P)) < 0:
P[:, -1] = -P[:, -1]
# Find K1, K2 so that U = K1.A.K2, with K being product of single-qubit unitaries
K1 = transform_to_magic_basis(Up @ P @ np.diag(np.exp(1j * d)))
K2 = transform_to_magic_basis(P.T)
K1l, K1r, phase_l = decompose_two_qubit_product_gate(K1)
K2l, K2r, phase_r = decompose_two_qubit_product_gate(K2)
global_phase += phase_l + phase_r
K1l = K1l.copy()
# Flip into Weyl chamber
if cs[0] > pi2:
cs[0] -= 3 * pi2
K1l = K1l.dot(_ipy)
K1r = K1r.dot(_ipy)
global_phase += pi2
if cs[1] > pi2:
cs[1] -= 3 * pi2
K1l = K1l.dot(_ipx)
K1r = K1r.dot(_ipx)
global_phase += pi2
conjs = 0
if cs[0] > pi4:
cs[0] = pi2 - cs[0]
K1l = K1l.dot(_ipy)
K2r = _ipy.dot(K2r)
conjs += 1
global_phase -= pi2
if cs[1] > pi4:
cs[1] = pi2 - cs[1]
K1l = K1l.dot(_ipx)
K2r = _ipx.dot(K2r)
conjs += 1
global_phase += pi2
if conjs == 1:
global_phase -= pi
if cs[2] > pi2:
cs[2] -= 3 * pi2
K1l = K1l.dot(_ipz)
K1r = K1r.dot(_ipz)
global_phase += pi2
if conjs == 1:
global_phase -= pi
if conjs == 1:
cs[2] = pi2 - cs[2]
K1l = K1l.dot(_ipz)
K2r = _ipz.dot(K2r)
global_phase += pi2
if cs[2] > pi4:
cs[2] -= pi2
K1l = K1l.dot(_ipz)
K1r = K1r.dot(_ipz)
global_phase -= pi2
a, b, c = cs[1], cs[0], cs[2]
return global_phase, (a, b, c), K1l, K1r, K2l, K2r
# Reference: https://arxiv.org/pdf/2105.06074.pdf
from qiskit.circuit.library import RZGate, RXGate, RYGate, IGate
from qiskit.extensions.unitary import UnitaryGate
from qiskit import QuantumCircuit
from qiskit.quantum_info import Operator
# from clonk.utils.riswap_gates.riswap import RiSwapGate
def decomp(U):
"""Decompose U into single qubit gates and the SQiSW gates"""
qc = QuantumCircuit(2)
_, (x, y, z), A1, A2, B1, B2 = KAKDecomp(U)
if np.abs(z) <= x - y:
C1, C2 = interleavingSingleQubitRotations(x, y, z)
V = RiSwapGate(0.5).to_matrix() @ np.kron(C1, C2) @ RiSwapGate(0.5).to_matrix()
_, (x, y, z), D1, D2, E1, E2 = KAKDecomp(V)
qc.append(UnitaryGate(np.matrix(E1).H @ B1), [1])
qc.append(UnitaryGate(np.matrix(E2).H @ B2), [0])
qc.append(RiSwapGate(0.5), [0, 1])
qc.append(UnitaryGate(C1), [1])
qc.append(UnitaryGate(C2), [0])
qc.append(RiSwapGate(0.5), [0, 1])
qc.append(UnitaryGate(A1 @ np.matrix(D1).H), [1])
qc.append(UnitaryGate(A2 @ np.matrix(D2).H), [0])
else:
(x, y, z), F1, F2, G1, G2, H1, H2 = canonicalize(x, y, z)
C1, C2 = interleavingSingleQubitRotations(x, y, z)
V = RiSwapGate(0.5).to_matrix() @ np.kron(C1, C2) @ RiSwapGate(0.5).to_matrix()
_, (x, y, z), D1, D2, E1, E2 = KAKDecomp(V)
qc.append(UnitaryGate(H1 @ B1), [1])
qc.append(UnitaryGate(H2 @ B2), [0])
qc.append(RiSwapGate(0.5), [0, 1])
qc.append(UnitaryGate(np.matrix(E1).H @ G1), [1])
qc.append(UnitaryGate(np.matrix(E2).H @ G2), [0])
qc.append(RiSwapGate(0.5), [0, 1])
qc.append(UnitaryGate(C1), [1])
qc.append(UnitaryGate(C2), [0])
qc.append(RiSwapGate(0.5), [0, 1])
qc.append(UnitaryGate(A1 @ F1 @ np.matrix(D1).H), [1])
qc.append(UnitaryGate(A2 @ F2 @ np.matrix(D2).H), [0])
return qc
def interleavingSingleQubitRotations(x, y, z):
"""Output the single qubit rotations given the interaction coefficients (x,y,z) \in W' when sandiwched by two SQiSW gates"""
C = np.sin(x + y - z) * np.sin(x - y + z) * np.sin(-x - y - z) * np.sin(-x + y + z)
alpha = np.arccos(np.cos(2 * x) - np.cos(2 * y) + np.cos(2 * z) + 2 * np.sqrt(C))
beta = np.arccos(np.cos(2 * x) - np.cos(2 * y) + np.cos(2 * z) - 2 * np.sqrt(C))
_num = 4 * (np.cos(x) ** 2) * (np.cos(z) ** 2) * (np.cos(y) ** 2)
_den = _num + np.cos(2 * x) + np.cos(2 * y) * np.cos(2 * z)
gamma = np.arccos(np.sign(z) * np.sqrt(_num / _den))
return (
RZGate(gamma).to_matrix()
@ RXGate(alpha).to_matrix()
@ RZGate(gamma).to_matrix(),
RXGate(beta).to_matrix(),
)
def canonicalize(x, y, z):
"""Decompose an arbitrary gate into one SQISW and one L(x,y',z) where (x',y',z') \in W' and output the coefficients (x',y',z') and the interleaving single qubit rotations"""
A1 = IGate().to_matrix()
A2 = IGate().to_matrix()
B1 = RYGate(-np.pi / 2).to_matrix()
B2 = RYGate(np.pi / 2).to_matrix()
C1 = RYGate(np.pi / 2).to_matrix()
C2 = RYGate(-np.pi / 2).to_matrix()
s = np.sign(z)
z = np.abs(z)
if x > np.pi / 8:
y = y - np.pi / 8
z = z - np.pi / 8
B1 = RZGate(np.pi / 2).to_matrix() @ B1
B2 = RZGate(-np.pi / 2).to_matrix() @ B2
C1 = C1 @ RZGate(-np.pi / 2).to_matrix()
C2 = C2 @ RZGate(np.pi / 2).to_matrix()
else:
x = x + np.pi / 8
z = z - np.pi / 8
if np.abs(y) < np.abs(z):
# XXX typo in alibaba here (?)
z = -z
A1 = RXGate(np.pi / 2).to_matrix()
A2 = RXGate(-np.pi / 2).to_matrix()
B1 = RXGate(-np.pi / 2).to_matrix() @ B1
B2 = RXGate(np.pi / 2).to_matrix() @ B2
if s < 0:
z = -z
A1 = RZGate(np.pi).to_matrix() @ A1 @ RZGate(np.pi).to_matrix()
B1 = RZGate(np.pi).to_matrix() @ B1 @ RZGate(np.pi).to_matrix()
C1 = RZGate(np.pi).to_matrix() @ C1 @ RZGate(np.pi).to_matrix()
return (x, y, z), A1, A2, B1, B2, C1, C2
# qc = QuantumCircuit(2)
# qc.swap(0,1)
# new_qc = decomp(Operator(qc).data)
# Operator(new_qc).equiv(qc)
new_qc.decompose().draw(output="mpl")
from qiskit.transpiler import PassManager
pm = PassManager()
from qiskit.transpiler.passes import (
BasisTranslator,
UnrollCustomDefinitions,
Optimize1qGates,
Optimize1qGatesDecomposition,
Optimize1qGatesSimpleCommutation,
)
from qiskit.transpiler import PassManager
from qiskit.circuit.equivalence_library import StandardEquivalenceLibrary as _sel
from elim_small_ import ElimSmallRZ
pass_ = [
UnrollCustomDefinitions(_sel, ["u3", "riswap"]),
Optimize1qGatesDecomposition(basis=["rz", "sx", "riswap"]),
Optimize1qGatesDecomposition(basis=["rz", "sx", "x", "riswap"]),
]
pm = PassManager(pass_)
new_circ = pm.run(new_qc)
new_circ.draw(output="mpl")
Operator(new_circ).equiv(CXGate())
import sys
sys.path.append("../..")
# qc.draw(output='mpl')
from qiskit import transpile
b = transpile(qc, basis_gates=basis)
b.draw(output="mpl")
from qiskit.circuit.library.basis_change import QFT
from qiskit import QuantumCircuit
qc = QuantumCircuit(2)
qc = QFT(4).decompose()
# qc.cz(0,1)
from clonk.utils.riswap_gates.riswap import RiSwapGate
from qiskit.circuit.library.standard_gates import CXGate
basis = ["u3", "cx"]
basis_gate = CXGate()
# basis = ["u3", "riswap"]
# basis_gate = RiSwapGate(0.5)
from clonk.utils.riswap_gates.equivalence_library import (
SessionEquivalenceLibrary as _sel,
)
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import (
Collect2qBlocks,
ConsolidateBlocks,
ResourceEstimation,
)
from clonk.utils.transpiler_passes.weyl_decompose import RootiSwapWeylDecomposition
pm = PassManager()
# pm.append(BasisTranslator(equivalence_library=_sel, target_basis=basis))
pm.append(Collect2qBlocks())
pm.append(ConsolidateBlocks(kak_basis_gate=basis_gate, force_consolidate=True))
pm.append(RootiSwapWeylDecomposition(basis_gate=basis_gate))
pm.append(ResourceEstimation())
a = pm.run(qc)
print(pm.property_set["count_ops"])
a.draw(output="mpl")
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_nature.second_q.problems import BaseProblem
dummy_hamiltonian = None
base_problem = BaseProblem(dummy_hamiltonian)
print(base_problem.properties)
from qiskit_nature.second_q.properties import AngularMomentum
print("AngularMomentum is in problem.properties:", AngularMomentum in base_problem.properties)
print("Adding AngularMomentum to problem.properties...")
base_problem.properties.add(AngularMomentum(2))
print("AngularMomentum is in problem.properties:", AngularMomentum in base_problem.properties)
print("Discarding AngularMomentum from problem.properties...")
base_problem.properties.discard(AngularMomentum)
print("AngularMomentum is in problem.properties:", AngularMomentum in base_problem.properties)
from qiskit_nature.second_q.drivers import PySCFDriver
es_problem = PySCFDriver().run()
print(es_problem.properties.particle_number)
print(es_problem.properties.angular_momentum)
print(es_problem.properties.magnetization)
print(es_problem.properties.electronic_dipole_moment)
print(es_problem.properties.electronic_density)
from qiskit_nature.second_q.properties import ElectronicDensity
density = ElectronicDensity.from_orbital_occupation(
es_problem.orbital_occupations,
es_problem.orbital_occupations_b,
)
es_problem.properties.electronic_density = density
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2023.
#
# 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.
"""Tests for SparsePauliOp class."""
import itertools as it
import unittest
from test import combine
import numpy as np
from ddt import ddt
from qiskit import QiskitError
from qiskit.circuit import ParameterExpression, Parameter, ParameterVector
from qiskit.circuit.parametertable import ParameterView
from qiskit.quantum_info.operators import Operator, Pauli, PauliList, PauliTable, SparsePauliOp
from qiskit.test import QiskitTestCase
def pauli_mat(label):
"""Return Pauli matrix from a Pauli label"""
mat = np.eye(1, dtype=complex)
for i in label:
if i == "I":
mat = np.kron(mat, np.eye(2, dtype=complex))
elif i == "X":
mat = np.kron(mat, np.array([[0, 1], [1, 0]], dtype=complex))
elif i == "Y":
mat = np.kron(mat, np.array([[0, -1j], [1j, 0]], dtype=complex))
elif i == "Z":
mat = np.kron(mat, np.array([[1, 0], [0, -1]], dtype=complex))
else:
raise QiskitError(f"Invalid Pauli string {i}")
return mat
class TestSparsePauliOpInit(QiskitTestCase):
"""Tests for SparsePauliOp initialization."""
def test_pauli_table_init(self):
"""Test PauliTable initialization."""
labels = ["I", "X", "Y", "Z"]
table = PauliTable.from_labels(labels)
paulis = PauliList(labels)
with self.subTest(msg="no coeffs"):
spp_op = SparsePauliOp(table)
np.testing.assert_array_equal(spp_op.coeffs, np.ones(len(labels)))
self.assertEqual(spp_op.paulis, paulis)
with self.subTest(msg="no coeffs"):
coeffs = [1, 2, 3, 4]
spp_op = SparsePauliOp(table, coeffs)
np.testing.assert_array_equal(spp_op.coeffs, coeffs)
self.assertEqual(spp_op.paulis, paulis)
def test_str_init(self):
"""Test str initialization."""
for label in ["IZ", "XI", "YX", "ZZ"]:
pauli_list = PauliList(label)
spp_op = SparsePauliOp(label)
self.assertEqual(spp_op.paulis, pauli_list)
np.testing.assert_array_equal(spp_op.coeffs, [1])
def test_pauli_list_init(self):
"""Test PauliList initialization."""
labels = ["I", "X", "Y", "-Z", "iZ", "-iX"]
paulis = PauliList(labels)
with self.subTest(msg="no coeffs"):
spp_op = SparsePauliOp(paulis)
np.testing.assert_array_equal(spp_op.coeffs, [1, 1, 1, -1, 1j, -1j])
paulis.phase = 0
self.assertEqual(spp_op.paulis, paulis)
paulis = PauliList(labels)
with self.subTest(msg="with coeffs"):
coeffs = [1, 2, 3, 4, 5, 6]
spp_op = SparsePauliOp(paulis, coeffs)
np.testing.assert_array_equal(spp_op.coeffs, [1, 2, 3, -4, 5j, -6j])
paulis.phase = 0
self.assertEqual(spp_op.paulis, paulis)
paulis = PauliList(labels)
with self.subTest(msg="with Parameterized coeffs"):
params = ParameterVector("params", 6)
coeffs = np.array(params)
spp_op = SparsePauliOp(paulis, coeffs)
target = coeffs.copy()
target[3] *= -1
target[4] *= 1j
target[5] *= -1j
np.testing.assert_array_equal(spp_op.coeffs, target)
paulis.phase = 0
self.assertEqual(spp_op.paulis, paulis)
def test_sparse_pauli_op_init(self):
"""Test SparsePauliOp initialization."""
labels = ["I", "X", "Y", "-Z", "iZ", "-iX"]
with self.subTest(msg="make SparsePauliOp from SparsePauliOp"):
op = SparsePauliOp(labels)
ref_op = op.copy()
spp_op = SparsePauliOp(op)
self.assertEqual(spp_op, ref_op)
np.testing.assert_array_equal(ref_op.paulis.phase, np.zeros(ref_op.size))
np.testing.assert_array_equal(spp_op.paulis.phase, np.zeros(spp_op.size))
# make sure the changes of `op` do not propagate through to `spp_op`
op.paulis.z[:] = False
op.coeffs *= 2
self.assertNotEqual(spp_op, op)
self.assertEqual(spp_op, ref_op)
with self.subTest(msg="make SparsePauliOp from SparsePauliOp and ndarray"):
op = SparsePauliOp(labels)
coeffs = np.array([1, 2, 3, 4, 5, 6])
spp_op = SparsePauliOp(op, coeffs)
ref_op = SparsePauliOp(op.paulis.copy(), coeffs.copy())
self.assertEqual(spp_op, ref_op)
np.testing.assert_array_equal(ref_op.paulis.phase, np.zeros(ref_op.size))
np.testing.assert_array_equal(spp_op.paulis.phase, np.zeros(spp_op.size))
# make sure the changes of `op` and `coeffs` do not propagate through to `spp_op`
op.paulis.z[:] = False
coeffs *= 2
self.assertNotEqual(spp_op, op)
self.assertEqual(spp_op, ref_op)
with self.subTest(msg="make SparsePauliOp from PauliList"):
paulis = PauliList(labels)
spp_op = SparsePauliOp(paulis)
ref_op = SparsePauliOp(labels)
self.assertEqual(spp_op, ref_op)
np.testing.assert_array_equal(ref_op.paulis.phase, np.zeros(ref_op.size))
np.testing.assert_array_equal(spp_op.paulis.phase, np.zeros(spp_op.size))
# make sure the change of `paulis` does not propagate through to `spp_op`
paulis.z[:] = False
self.assertEqual(spp_op, ref_op)
with self.subTest(msg="make SparsePauliOp from PauliList and ndarray"):
paulis = PauliList(labels)
coeffs = np.array([1, 2, 3, 4, 5, 6])
spp_op = SparsePauliOp(paulis, coeffs)
ref_op = SparsePauliOp(labels, coeffs.copy())
self.assertEqual(spp_op, ref_op)
np.testing.assert_array_equal(ref_op.paulis.phase, np.zeros(ref_op.size))
np.testing.assert_array_equal(spp_op.paulis.phase, np.zeros(spp_op.size))
# make sure the changes of `paulis` and `coeffs` do not propagate through to `spp_op`
paulis.z[:] = False
coeffs[:] = 0
self.assertEqual(spp_op, ref_op)
class TestSparsePauliOpConversions(QiskitTestCase):
"""Tests SparsePauliOp representation conversions."""
def test_from_operator(self):
"""Test from_operator methods."""
for tup in it.product(["I", "X", "Y", "Z"], repeat=2):
label = "".join(tup)
with self.subTest(msg=label):
spp_op = SparsePauliOp.from_operator(Operator(pauli_mat(label)))
np.testing.assert_array_equal(spp_op.coeffs, [1])
self.assertEqual(spp_op.paulis, PauliList(label))
def test_from_list(self):
"""Test from_list method."""
labels = ["XXZ", "IXI", "YZZ", "III"]
coeffs = [3.0, 5.5, -1j, 23.3333]
spp_op = SparsePauliOp.from_list(zip(labels, coeffs))
np.testing.assert_array_equal(spp_op.coeffs, coeffs)
self.assertEqual(spp_op.paulis, PauliList(labels))
def test_from_list_parameters(self):
"""Test from_list method with parameters."""
labels = ["XXZ", "IXI", "YZZ", "III"]
coeffs = ParameterVector("a", 4)
spp_op = SparsePauliOp.from_list(zip(labels, coeffs), dtype=object)
np.testing.assert_array_equal(spp_op.coeffs, coeffs)
self.assertEqual(spp_op.paulis, PauliList(labels))
def test_from_index_list(self):
"""Test from_list method specifying the Paulis via indices."""
expected_labels = ["XXZ", "IXI", "YIZ", "III"]
paulis = ["XXZ", "X", "YZ", ""]
indices = [[2, 1, 0], [1], [2, 0], []]
coeffs = [3.0, 5.5, -1j, 23.3333]
spp_op = SparsePauliOp.from_sparse_list(zip(paulis, indices, coeffs), num_qubits=3)
np.testing.assert_array_equal(spp_op.coeffs, coeffs)
self.assertEqual(spp_op.paulis, PauliList(expected_labels))
def test_from_index_list_parameters(self):
"""Test from_list method specifying the Paulis via indices with paramteres."""
expected_labels = ["XXZ", "IXI", "YIZ", "III"]
paulis = ["XXZ", "X", "YZ", ""]
indices = [[2, 1, 0], [1], [2, 0], []]
coeffs = ParameterVector("a", 4)
spp_op = SparsePauliOp.from_sparse_list(
zip(paulis, indices, coeffs), num_qubits=3, dtype=object
)
np.testing.assert_array_equal(spp_op.coeffs, coeffs)
self.assertEqual(spp_op.paulis, PauliList(expected_labels))
def test_from_index_list_endianness(self):
"""Test the construction from index list has the right endianness."""
spp_op = SparsePauliOp.from_sparse_list([("ZX", [1, 4], 1)], num_qubits=5)
expected = Pauli("XIIZI")
self.assertEqual(spp_op.paulis[0], expected)
def test_from_index_list_raises(self):
"""Test from_list via Pauli + indices raises correctly, if number of qubits invalid."""
with self.assertRaises(QiskitError):
_ = SparsePauliOp.from_sparse_list([("Z", [2], 1)], 1)
def test_from_index_list_same_index(self):
"""Test from_list via Pauli + number of qubits raises correctly, if indices duplicate."""
with self.assertRaises(QiskitError):
_ = SparsePauliOp.from_sparse_list([("ZZ", [0, 0], 1)], 2)
with self.assertRaises(QiskitError):
_ = SparsePauliOp.from_sparse_list([("ZI", [0, 0], 1)], 2)
with self.assertRaises(QiskitError):
_ = SparsePauliOp.from_sparse_list([("IZ", [0, 0], 1)], 2)
def test_from_zip(self):
"""Test from_list method for zipped input."""
labels = ["XXZ", "IXI", "YZZ", "III"]
coeffs = [3.0, 5.5, -1j, 23.3333]
spp_op = SparsePauliOp.from_list(zip(labels, coeffs))
np.testing.assert_array_equal(spp_op.coeffs, coeffs)
self.assertEqual(spp_op.paulis, PauliList(labels))
def test_to_matrix(self):
"""Test to_matrix method."""
labels = ["XI", "YZ", "YY", "ZZ"]
coeffs = [-3, 4.4j, 0.2 - 0.1j, 66.12]
spp_op = SparsePauliOp(labels, coeffs)
target = np.zeros((4, 4), dtype=complex)
for coeff, label in zip(coeffs, labels):
target += coeff * pauli_mat(label)
np.testing.assert_array_equal(spp_op.to_matrix(), target)
np.testing.assert_array_equal(spp_op.to_matrix(sparse=True).toarray(), target)
def test_to_matrix_large(self):
"""Test to_matrix method with a large number of qubits."""
reps = 5
labels = ["XI" * reps, "YZ" * reps, "YY" * reps, "ZZ" * reps]
coeffs = [-3, 4.4j, 0.2 - 0.1j, 66.12]
spp_op = SparsePauliOp(labels, coeffs)
size = 1 << 2 * reps
target = np.zeros((size, size), dtype=complex)
for coeff, label in zip(coeffs, labels):
target += coeff * pauli_mat(label)
np.testing.assert_array_equal(spp_op.to_matrix(), target)
np.testing.assert_array_equal(spp_op.to_matrix(sparse=True).toarray(), target)
def test_to_matrix_parameters(self):
"""Test to_matrix method for parameterized SparsePauliOp."""
labels = ["XI", "YZ", "YY", "ZZ"]
coeffs = np.array(ParameterVector("a", 4))
spp_op = SparsePauliOp(labels, coeffs)
target = np.zeros((4, 4), dtype=object)
for coeff, label in zip(coeffs, labels):
target += coeff * pauli_mat(label)
np.testing.assert_array_equal(spp_op.to_matrix(), target)
def test_to_operator(self):
"""Test to_operator method."""
labels = ["XI", "YZ", "YY", "ZZ"]
coeffs = [-3, 4.4j, 0.2 - 0.1j, 66.12]
spp_op = SparsePauliOp(labels, coeffs)
target = Operator(np.zeros((4, 4), dtype=complex))
for coeff, label in zip(coeffs, labels):
target = target + Operator(coeff * pauli_mat(label))
self.assertEqual(spp_op.to_operator(), target)
def test_to_list(self):
"""Test to_operator method."""
labels = ["XI", "YZ", "YY", "ZZ"]
coeffs = [-3, 4.4j, 0.2 - 0.1j, 66.12]
op = SparsePauliOp(labels, coeffs)
target = list(zip(labels, coeffs))
self.assertEqual(op.to_list(), target)
def test_to_list_parameters(self):
"""Test to_operator method with paramters."""
labels = ["XI", "YZ", "YY", "ZZ"]
coeffs = np.array(ParameterVector("a", 4))
op = SparsePauliOp(labels, coeffs)
target = list(zip(labels, coeffs))
self.assertEqual(op.to_list(), target)
class TestSparsePauliOpIteration(QiskitTestCase):
"""Tests for SparsePauliOp iterators class."""
def test_enumerate(self):
"""Test enumerate with SparsePauliOp."""
labels = ["III", "IXI", "IYY", "YIZ", "XYZ", "III"]
coeffs = np.array([1, 2, 3, 4, 5, 6])
op = SparsePauliOp(labels, coeffs)
for idx, i in enumerate(op):
self.assertEqual(i, SparsePauliOp(labels[idx], coeffs[[idx]]))
def test_enumerate_parameters(self):
"""Test enumerate with SparsePauliOp with parameters."""
labels = ["III", "IXI", "IYY", "YIZ", "XYZ", "III"]
coeffs = np.array(ParameterVector("a", 6))
op = SparsePauliOp(labels, coeffs)
for idx, i in enumerate(op):
self.assertEqual(i, SparsePauliOp(labels[idx], coeffs[[idx]]))
def test_iter(self):
"""Test iter with SparsePauliOp."""
labels = ["III", "IXI", "IYY", "YIZ", "XYZ", "III"]
coeffs = np.array([1, 2, 3, 4, 5, 6])
op = SparsePauliOp(labels, coeffs)
for idx, i in enumerate(iter(op)):
self.assertEqual(i, SparsePauliOp(labels[idx], coeffs[[idx]]))
def test_iter_parameters(self):
"""Test iter with SparsePauliOp with parameters."""
labels = ["III", "IXI", "IYY", "YIZ", "XYZ", "III"]
coeffs = np.array(ParameterVector("a", 6))
op = SparsePauliOp(labels, coeffs)
for idx, i in enumerate(iter(op)):
self.assertEqual(i, SparsePauliOp(labels[idx], coeffs[[idx]]))
def test_label_iter(self):
"""Test SparsePauliOp label_iter method."""
labels = ["III", "IXI", "IYY", "YIZ", "XYZ", "III"]
coeffs = np.array([1, 2, 3, 4, 5, 6])
op = SparsePauliOp(labels, coeffs)
for idx, i in enumerate(op.label_iter()):
self.assertEqual(i, (labels[idx], coeffs[idx]))
def test_label_iter_parameters(self):
"""Test SparsePauliOp label_iter method with parameters."""
labels = ["III", "IXI", "IYY", "YIZ", "XYZ", "III"]
coeffs = np.array(ParameterVector("a", 6))
op = SparsePauliOp(labels, coeffs)
for idx, i in enumerate(op.label_iter()):
self.assertEqual(i, (labels[idx], coeffs[idx]))
def test_matrix_iter(self):
"""Test SparsePauliOp dense matrix_iter method."""
labels = ["III", "IXI", "IYY", "YIZ", "XYZ", "III"]
coeffs = np.array([1, 2, 3, 4, 5, 6])
op = SparsePauliOp(labels, coeffs)
for idx, i in enumerate(op.matrix_iter()):
np.testing.assert_array_equal(i, coeffs[idx] * pauli_mat(labels[idx]))
def test_matrix_iter_parameters(self):
"""Test SparsePauliOp dense matrix_iter method. with parameters"""
labels = ["III", "IXI", "IYY", "YIZ", "XYZ", "III"]
coeffs = np.array(ParameterVector("a", 6))
op = SparsePauliOp(labels, coeffs)
for idx, i in enumerate(op.matrix_iter()):
np.testing.assert_array_equal(i, coeffs[idx] * pauli_mat(labels[idx]))
def test_matrix_iter_sparse(self):
"""Test SparsePauliOp sparse matrix_iter method."""
labels = ["III", "IXI", "IYY", "YIZ", "XYZ", "III"]
coeffs = np.array([1, 2, 3, 4, 5, 6])
op = SparsePauliOp(labels, coeffs)
for idx, i in enumerate(op.matrix_iter(sparse=True)):
np.testing.assert_array_equal(i.toarray(), coeffs[idx] * pauli_mat(labels[idx]))
def bind_parameters_to_one(array):
"""Bind parameters to one. The purpose of using this method is to bind some value and
use ``assert_allclose``, since it is impossible to verify equivalence in the case of
numerical errors with parameters existing.
"""
def bind_one(a):
parameters = a.parameters
return complex(a.bind(dict(zip(parameters, [1] * len(parameters)))))
return np.vectorize(bind_one, otypes=[complex])(array)
@ddt
class TestSparsePauliOpMethods(QiskitTestCase):
"""Tests for SparsePauliOp operator methods."""
RNG = np.random.default_rng(1994)
def setUp(self):
super().setUp()
self.parameter_names = (f"param_{x}" for x in it.count())
def random_spp_op(self, num_qubits, num_terms, use_parameters=False):
"""Generate a pseudo-random SparsePauliOp"""
if use_parameters:
coeffs = np.array(ParameterVector(next(self.parameter_names), num_terms))
else:
coeffs = self.RNG.uniform(-1, 1, size=num_terms) + 1j * self.RNG.uniform(
-1, 1, size=num_terms
)
labels = [
"".join(self.RNG.choice(["I", "X", "Y", "Z"], size=num_qubits))
for _ in range(num_terms)
]
return SparsePauliOp(labels, coeffs)
@combine(num_qubits=[1, 2, 3, 4], use_parameters=[True, False])
def test_conjugate(self, num_qubits, use_parameters):
"""Test conjugate method for {num_qubits}-qubits."""
spp_op = self.random_spp_op(num_qubits, 2**num_qubits, use_parameters)
target = spp_op.to_matrix().conjugate()
op = spp_op.conjugate()
value = op.to_matrix()
np.testing.assert_array_equal(value, target)
np.testing.assert_array_equal(op.paulis.phase, np.zeros(op.size))
@combine(num_qubits=[1, 2, 3, 4], use_parameters=[True, False])
def test_transpose(self, num_qubits, use_parameters):
"""Test transpose method for {num_qubits}-qubits."""
spp_op = self.random_spp_op(num_qubits, 2**num_qubits, use_parameters)
target = spp_op.to_matrix().transpose()
op = spp_op.transpose()
value = op.to_matrix()
np.testing.assert_array_equal(value, target)
np.testing.assert_array_equal(op.paulis.phase, np.zeros(op.size))
@combine(num_qubits=[1, 2, 3, 4], use_parameters=[True, False])
def test_adjoint(self, num_qubits, use_parameters):
"""Test adjoint method for {num_qubits}-qubits."""
spp_op = self.random_spp_op(num_qubits, 2**num_qubits, use_parameters)
target = spp_op.to_matrix().transpose().conjugate()
op = spp_op.adjoint()
value = op.to_matrix()
np.testing.assert_array_equal(value, target)
np.testing.assert_array_equal(op.paulis.phase, np.zeros(op.size))
@combine(num_qubits=[1, 2, 3, 4], use_parameters=[True, False])
def test_compose(self, num_qubits, use_parameters):
"""Test {num_qubits}-qubit compose methods."""
spp_op1 = self.random_spp_op(num_qubits, 2**num_qubits, use_parameters)
spp_op2 = self.random_spp_op(num_qubits, 2**num_qubits, use_parameters)
target = spp_op2.to_matrix() @ spp_op1.to_matrix()
op = spp_op1.compose(spp_op2)
value = op.to_matrix()
if use_parameters:
value = bind_parameters_to_one(value)
target = bind_parameters_to_one(target)
np.testing.assert_allclose(value, target, atol=1e-8)
np.testing.assert_array_equal(op.paulis.phase, np.zeros(op.size))
op = spp_op1 & spp_op2
value = op.to_matrix()
if use_parameters:
value = bind_parameters_to_one(value)
np.testing.assert_allclose(value, target, atol=1e-8)
np.testing.assert_array_equal(op.paulis.phase, np.zeros(op.size))
@combine(num_qubits=[1, 2, 3, 4], use_parameters=[True, False])
def test_dot(self, num_qubits, use_parameters):
"""Test {num_qubits}-qubit dot methods."""
spp_op1 = self.random_spp_op(num_qubits, 2**num_qubits, use_parameters)
spp_op2 = self.random_spp_op(num_qubits, 2**num_qubits, use_parameters)
target = spp_op1.to_matrix() @ spp_op2.to_matrix()
op = spp_op1.dot(spp_op2)
value = op.to_matrix()
if use_parameters:
value = bind_parameters_to_one(value)
target = bind_parameters_to_one(target)
np.testing.assert_allclose(value, target, atol=1e-8)
np.testing.assert_array_equal(op.paulis.phase, np.zeros(op.size))
op = spp_op1 @ spp_op2
value = op.to_matrix()
if use_parameters:
value = bind_parameters_to_one(value)
np.testing.assert_allclose(value, target, atol=1e-8)
np.testing.assert_array_equal(op.paulis.phase, np.zeros(op.size))
@combine(num_qubits=[1, 2, 3])
def test_qargs_compose(self, num_qubits):
"""Test 3-qubit compose method with {num_qubits}-qubit qargs."""
spp_op1 = self.random_spp_op(3, 2**3)
spp_op2 = self.random_spp_op(num_qubits, 2**num_qubits)
qargs = self.RNG.choice(3, size=num_qubits, replace=False).tolist()
target = Operator(spp_op1).compose(Operator(spp_op2), qargs=qargs)
op = spp_op1.compose(spp_op2, qargs=qargs)
value = op.to_operator()
self.assertEqual(value, target)
np.testing.assert_array_equal(op.paulis.phase, np.zeros(op.size))
op = spp_op1 & spp_op2(qargs)
value = op.to_operator()
self.assertEqual(value, target)
np.testing.assert_array_equal(op.paulis.phase, np.zeros(op.size))
@combine(num_qubits=[1, 2, 3])
def test_qargs_dot(self, num_qubits):
"""Test 3-qubit dot method with {num_qubits}-qubit qargs."""
spp_op1 = self.random_spp_op(3, 2**3)
spp_op2 = self.random_spp_op(num_qubits, 2**num_qubits)
qargs = self.RNG.choice(3, size=num_qubits, replace=False).tolist()
target = Operator(spp_op1).dot(Operator(spp_op2), qargs=qargs)
op = spp_op1.dot(spp_op2, qargs=qargs)
value = op.to_operator()
self.assertEqual(value, target)
np.testing.assert_array_equal(op.paulis.phase, np.zeros(op.size))
@combine(num_qubits1=[1, 2, 3], num_qubits2=[1, 2, 3], use_parameters=[True, False])
def test_tensor(self, num_qubits1, num_qubits2, use_parameters):
"""Test tensor method for {num_qubits1} and {num_qubits2} qubits."""
spp_op1 = self.random_spp_op(num_qubits1, 2**num_qubits1, use_parameters)
spp_op2 = self.random_spp_op(num_qubits2, 2**num_qubits2, use_parameters)
target = np.kron(spp_op1.to_matrix(), spp_op2.to_matrix())
op = spp_op1.tensor(spp_op2)
value = op.to_matrix()
if use_parameters:
value = bind_parameters_to_one(value)
target = bind_parameters_to_one(target)
np.testing.assert_allclose(value, target, atol=1e-8)
np.testing.assert_array_equal(op.paulis.phase, np.zeros(op.size))
@combine(num_qubits1=[1, 2, 3], num_qubits2=[1, 2, 3], use_parameters=[True, False])
def test_expand(self, num_qubits1, num_qubits2, use_parameters):
"""Test expand method for {num_qubits1} and {num_qubits2} qubits."""
spp_op1 = self.random_spp_op(num_qubits1, 2**num_qubits1, use_parameters)
spp_op2 = self.random_spp_op(num_qubits2, 2**num_qubits2, use_parameters)
target = np.kron(spp_op2.to_matrix(), spp_op1.to_matrix())
op = spp_op1.expand(spp_op2)
value = op.to_matrix()
if use_parameters:
value = bind_parameters_to_one(value)
target = bind_parameters_to_one(target)
np.testing.assert_allclose(value, target, atol=1e-8)
np.testing.assert_array_equal(op.paulis.phase, np.zeros(op.size))
@combine(num_qubits=[1, 2, 3, 4], use_parameters=[True, False])
def test_add(self, num_qubits, use_parameters):
"""Test + method for {num_qubits} qubits."""
spp_op1 = self.random_spp_op(num_qubits, 2**num_qubits, use_parameters)
spp_op2 = self.random_spp_op(num_qubits, 2**num_qubits, use_parameters)
target = spp_op1.to_matrix() + spp_op2.to_matrix()
op = spp_op1 + spp_op2
value = op.to_matrix()
if use_parameters:
value = bind_parameters_to_one(value)
target = bind_parameters_to_one(target)
np.testing.assert_allclose(value, target, atol=1e-8)
np.testing.assert_array_equal(op.paulis.phase, np.zeros(op.size))
@combine(num_qubits=[1, 2, 3, 4], use_parameters=[True, False])
def test_sub(self, num_qubits, use_parameters):
"""Test + method for {num_qubits} qubits."""
spp_op1 = self.random_spp_op(num_qubits, 2**num_qubits, use_parameters)
spp_op2 = self.random_spp_op(num_qubits, 2**num_qubits, use_parameters)
target = spp_op1.to_matrix() - spp_op2.to_matrix()
op = spp_op1 - spp_op2
value = op.to_matrix()
if use_parameters:
value = bind_parameters_to_one(value)
target = bind_parameters_to_one(target)
np.testing.assert_allclose(value, target, atol=1e-8)
np.testing.assert_array_equal(op.paulis.phase, np.zeros(op.size))
@combine(num_qubits=[1, 2, 3])
def test_add_qargs(self, num_qubits):
"""Test + method for 3 qubits with {num_qubits} qubit qargs."""
spp_op1 = self.random_spp_op(3, 2**3)
spp_op2 = self.random_spp_op(num_qubits, 2**num_qubits)
qargs = self.RNG.choice(3, size=num_qubits, replace=False).tolist()
target = Operator(spp_op1) + Operator(spp_op2)(qargs)
op = spp_op1 + spp_op2(qargs)
value = op.to_operator()
self.assertEqual(value, target)
np.testing.assert_array_equal(op.paulis.phase, np.zeros(op.size))
@combine(num_qubits=[1, 2, 3])
def test_sub_qargs(self, num_qubits):
"""Test - method for 3 qubits with {num_qubits} qubit qargs."""
spp_op1 = self.random_spp_op(3, 2**3)
spp_op2 = self.random_spp_op(num_qubits, 2**num_qubits)
qargs = self.RNG.choice(3, size=num_qubits, replace=False).tolist()
target = Operator(spp_op1) - Operator(spp_op2)(qargs)
op = spp_op1 - spp_op2(qargs)
value = op.to_operator()
self.assertEqual(value, target)
np.testing.assert_array_equal(op.paulis.phase, np.zeros(op.size))
@combine(
num_qubits=[1, 2, 3],
value=[
0,
1,
1j,
-3 + 4.4j,
np.int64(2),
Parameter("x"),
0 * Parameter("x"),
(-2 + 1.7j) * Parameter("x"),
],
param=[None, "a"],
)
def test_mul(self, num_qubits, value, param):
"""Test * method for {num_qubits} qubits and value {value}."""
spp_op = self.random_spp_op(num_qubits, 2**num_qubits, param)
target = value * spp_op.to_matrix()
op = value * spp_op
value_mat = op.to_matrix()
has_parameters = isinstance(value, ParameterExpression) or param is not None
if value != 0 and has_parameters:
value_mat = bind_parameters_to_one(value_mat)
target = bind_parameters_to_one(target)
if value == 0:
np.testing.assert_array_equal(value_mat, target.astype(complex))
else:
np.testing.assert_allclose(value_mat, target, atol=1e-8)
np.testing.assert_array_equal(op.paulis.phase, np.zeros(op.size))
target = spp_op.to_matrix() * value
op = spp_op * value
value_mat = op.to_matrix()
if value != 0 and has_parameters:
value_mat = bind_parameters_to_one(value_mat)
target = bind_parameters_to_one(target)
if value == 0:
np.testing.assert_array_equal(value_mat, target.astype(complex))
else:
np.testing.assert_allclose(value_mat, target, atol=1e-8)
np.testing.assert_array_equal(op.paulis.phase, np.zeros(op.size))
@combine(num_qubits=[1, 2, 3], value=[1, 1j, -3 + 4.4j], param=[None, "a"])
def test_div(self, num_qubits, value, param):
"""Test / method for {num_qubits} qubits and value {value}."""
spp_op = self.random_spp_op(num_qubits, 2**num_qubits, param)
target = spp_op.to_matrix() / value
op = spp_op / value
value_mat = op.to_matrix()
if param is not None:
value_mat = bind_parameters_to_one(value_mat)
target = bind_parameters_to_one(target)
np.testing.assert_allclose(value_mat, target, atol=1e-8)
np.testing.assert_array_equal(op.paulis.phase, np.zeros(op.size))
def test_simplify(self):
"""Test simplify method"""
coeffs = [3 + 1j, -3 - 1j, 0, 4, -5, 2.2, -1.1j]
labels = ["IXI", "IXI", "ZZZ", "III", "III", "XXX", "XXX"]
spp_op = SparsePauliOp.from_list(zip(labels, coeffs))
simplified_op = spp_op.simplify()
target_coeffs = [-1, 2.2 - 1.1j]
target_labels = ["III", "XXX"]
target_op = SparsePauliOp.from_list(zip(target_labels, target_coeffs))
self.assertEqual(simplified_op, target_op)
np.testing.assert_array_equal(simplified_op.paulis.phase, np.zeros(simplified_op.size))
@combine(num_qubits=[1, 2, 3, 4], num_adds=[0, 1, 2, 3])
def test_simplify2(self, num_qubits, num_adds):
"""Test simplify method for {num_qubits} qubits with {num_adds} `add` calls."""
spp_op = self.random_spp_op(num_qubits, 2**num_qubits)
for _ in range(num_adds):
spp_op += spp_op
simplified_op = spp_op.simplify()
value = Operator(simplified_op)
target = Operator(spp_op)
self.assertEqual(value, target)
np.testing.assert_array_equal(spp_op.paulis.phase, np.zeros(spp_op.size))
np.testing.assert_array_equal(simplified_op.paulis.phase, np.zeros(simplified_op.size))
@combine(num_qubits=[1, 2, 3, 4])
def test_simplify_zero(self, num_qubits):
"""Test simplify method for {num_qubits} qubits with zero operators."""
spp_op = self.random_spp_op(num_qubits, 2**num_qubits)
zero_op = spp_op - spp_op
simplified_op = zero_op.simplify()
value = Operator(simplified_op)
target = Operator(zero_op)
self.assertEqual(value, target)
np.testing.assert_array_equal(simplified_op.coeffs, [0])
np.testing.assert_array_equal(zero_op.paulis.phase, np.zeros(zero_op.size))
np.testing.assert_array_equal(simplified_op.paulis.phase, np.zeros(simplified_op.size))
def test_simplify_parameters(self):
"""Test simplify methods for parameterized SparsePauliOp."""
a = Parameter("a")
coeffs = np.array([a, -a, 0, a, a, a, 2 * a])
labels = ["IXI", "IXI", "ZZZ", "III", "III", "XXX", "XXX"]
spp_op = SparsePauliOp(labels, coeffs)
simplified_op = spp_op.simplify()
target_coeffs = np.array([2 * a, 3 * a])
target_labels = ["III", "XXX"]
target_op = SparsePauliOp(target_labels, target_coeffs)
self.assertEqual(simplified_op, target_op)
np.testing.assert_array_equal(simplified_op.paulis.phase, np.zeros(simplified_op.size))
def test_sort(self):
"""Test sort method."""
with self.assertRaises(QiskitError):
target = SparsePauliOp([], [])
with self.subTest(msg="1 qubit real number"):
target = SparsePauliOp(
["I", "I", "I", "I"], [-3.0 + 0.0j, 1.0 + 0.0j, 2.0 + 0.0j, 4.0 + 0.0j]
)
value = SparsePauliOp(["I", "I", "I", "I"], [1, 2, -3, 4]).sort()
self.assertEqual(target, value)
with self.subTest(msg="1 qubit complex"):
target = SparsePauliOp(
["I", "I", "I", "I"], [-1.0 + 0.0j, 0.0 - 1.0j, 0.0 + 1.0j, 1.0 + 0.0j]
)
value = SparsePauliOp(
["I", "I", "I", "I"], [1.0 + 0.0j, 0.0 + 1.0j, 0.0 - 1.0j, -1.0 + 0.0j]
).sort()
self.assertEqual(target, value)
with self.subTest(msg="1 qubit Pauli I, X, Y, Z"):
target = SparsePauliOp(
["I", "X", "Y", "Z"], [-1.0 + 2.0j, 1.0 + 0.0j, 2.0 + 0.0j, 3.0 - 4.0j]
)
value = SparsePauliOp(
["Y", "X", "Z", "I"], [2.0 + 0.0j, 1.0 + 0.0j, 3.0 - 4.0j, -1.0 + 2.0j]
).sort()
self.assertEqual(target, value)
with self.subTest(msg="1 qubit weight order"):
target = SparsePauliOp(
["I", "X", "Y", "Z"], [-1.0 + 2.0j, 1.0 + 0.0j, 2.0 + 0.0j, 3.0 - 4.0j]
)
value = SparsePauliOp(
["Y", "X", "Z", "I"], [2.0 + 0.0j, 1.0 + 0.0j, 3.0 - 4.0j, -1.0 + 2.0j]
).sort(weight=True)
self.assertEqual(target, value)
with self.subTest(msg="1 qubit multi Pauli"):
target = SparsePauliOp(
["I", "I", "I", "I", "X", "X", "Y", "Z"],
[
-1.0 + 2.0j,
1.0 + 0.0j,
2.0 + 0.0j,
3.0 - 4.0j,
-1.0 + 4.0j,
-1.0 + 5.0j,
-1.0 + 3.0j,
-1.0 + 2.0j,
],
)
value = SparsePauliOp(
["I", "I", "I", "I", "X", "Z", "Y", "X"],
[
2.0 + 0.0j,
1.0 + 0.0j,
3.0 - 4.0j,
-1.0 + 2.0j,
-1.0 + 5.0j,
-1.0 + 2.0j,
-1.0 + 3.0j,
-1.0 + 4.0j,
],
).sort()
self.assertEqual(target, value)
with self.subTest(msg="2 qubit standard order"):
target = SparsePauliOp(
["II", "XI", "XX", "XX", "XX", "XY", "XZ", "YI"],
[
4.0 + 0.0j,
7.0 + 0.0j,
2.0 + 1.0j,
2.0 + 2.0j,
3.0 + 0.0j,
6.0 + 0.0j,
5.0 + 0.0j,
3.0 + 0.0j,
],
)
value = SparsePauliOp(
["XX", "XX", "XX", "YI", "II", "XZ", "XY", "XI"],
[
2.0 + 1.0j,
2.0 + 2.0j,
3.0 + 0.0j,
3.0 + 0.0j,
4.0 + 0.0j,
5.0 + 0.0j,
6.0 + 0.0j,
7.0 + 0.0j,
],
).sort()
self.assertEqual(target, value)
with self.subTest(msg="2 qubit weight order"):
target = SparsePauliOp(
["II", "XI", "YI", "XX", "XX", "XX", "XY", "XZ"],
[
4.0 + 0.0j,
7.0 + 0.0j,
3.0 + 0.0j,
2.0 + 1.0j,
2.0 + 2.0j,
3.0 + 0.0j,
6.0 + 0.0j,
5.0 + 0.0j,
],
)
value = SparsePauliOp(
["XX", "XX", "XX", "YI", "II", "XZ", "XY", "XI"],
[
2.0 + 1.0j,
2.0 + 2.0j,
3.0 + 0.0j,
3.0 + 0.0j,
4.0 + 0.0j,
5.0 + 0.0j,
6.0 + 0.0j,
7.0 + 0.0j,
],
).sort(weight=True)
self.assertEqual(target, value)
def test_chop(self):
"""Test chop, which individually truncates real and imaginary parts of the coeffs."""
eps = 1e-10
op = SparsePauliOp(
["XYZ", "ZII", "ZII", "YZY"], coeffs=[eps + 1j * eps, 1 + 1j * eps, eps + 1j, 1 + 1j]
)
simplified = op.chop(tol=eps)
expected_coeffs = [1, 1j, 1 + 1j]
expected_paulis = ["ZII", "ZII", "YZY"]
self.assertListEqual(simplified.coeffs.tolist(), expected_coeffs)
self.assertListEqual(simplified.paulis.to_labels(), expected_paulis)
def test_chop_all(self):
"""Test that chop returns an identity operator with coeff 0 if all coeffs are chopped."""
eps = 1e-10
op = SparsePauliOp(["X", "Z"], coeffs=[eps, eps])
simplified = op.chop(tol=eps)
expected = SparsePauliOp(["I"], coeffs=[0.0])
self.assertEqual(simplified, expected)
@combine(num_qubits=[1, 2, 3, 4], num_ops=[1, 2, 3, 4], param=[None, "a"])
def test_sum(self, num_qubits, num_ops, param):
"""Test sum method for {num_qubits} qubits with {num_ops} operators."""
ops = [
self.random_spp_op(
num_qubits, 2**num_qubits, param if param is None else f"{param}_{i}"
)
for i in range(num_ops)
]
sum_op = SparsePauliOp.sum(ops)
value = sum_op.to_matrix()
target_operator = sum((op.to_matrix() for op in ops[1:]), ops[0].to_matrix())
if param is not None:
value = bind_parameters_to_one(value)
target_operator = bind_parameters_to_one(target_operator)
np.testing.assert_allclose(value, target_operator, atol=1e-8)
target_spp_op = sum((op for op in ops[1:]), ops[0])
self.assertEqual(sum_op, target_spp_op)
np.testing.assert_array_equal(sum_op.paulis.phase, np.zeros(sum_op.size))
def test_sum_error(self):
"""Test sum method with invalid cases."""
with self.assertRaises(QiskitError):
SparsePauliOp.sum([])
with self.assertRaises(QiskitError):
ops = [self.random_spp_op(num_qubits, 2**num_qubits) for num_qubits in [1, 2]]
SparsePauliOp.sum(ops)
with self.assertRaises(QiskitError):
SparsePauliOp.sum([1, 2])
@combine(num_qubits=[1, 2, 3, 4], use_parameters=[True, False])
def test_eq(self, num_qubits, use_parameters):
"""Test __eq__ method for {num_qubits} qubits."""
spp_op1 = self.random_spp_op(num_qubits, 2**num_qubits, use_parameters)
spp_op2 = self.random_spp_op(num_qubits, 2**num_qubits, use_parameters)
spp_op3 = self.random_spp_op(num_qubits, 2**num_qubits, use_parameters)
zero = spp_op3 - spp_op3
self.assertEqual(spp_op1, spp_op1)
self.assertEqual(spp_op2, spp_op2)
self.assertNotEqual(spp_op1, spp_op1 + zero)
self.assertNotEqual(spp_op2, spp_op2 + zero)
if spp_op1 != spp_op2:
self.assertNotEqual(spp_op1 + spp_op2, spp_op2 + spp_op1)
@combine(num_qubits=[1, 2, 3, 4])
def test_equiv(self, num_qubits):
"""Test equiv method for {num_qubits} qubits."""
spp_op1 = self.random_spp_op(num_qubits, 2**num_qubits)
spp_op2 = self.random_spp_op(num_qubits, 2**num_qubits)
spp_op3 = self.random_spp_op(num_qubits, 2**num_qubits)
spp_op4 = self.random_spp_op(num_qubits, 2**num_qubits)
zero = spp_op3 - spp_op3
zero2 = spp_op4 - spp_op4
self.assertTrue(spp_op1.equiv(spp_op1))
self.assertTrue(spp_op1.equiv(spp_op1 + zero))
self.assertTrue(spp_op2.equiv(spp_op2))
self.assertTrue(spp_op2.equiv(spp_op2 + zero))
self.assertTrue(zero.equiv(zero2))
self.assertTrue((zero + zero2).equiv(zero2 + zero))
self.assertTrue((zero2 + zero).equiv(zero + zero2))
self.assertTrue((spp_op1 + spp_op2).equiv(spp_op2 + spp_op1))
self.assertTrue((spp_op2 + spp_op1).equiv(spp_op1 + spp_op2))
self.assertTrue((spp_op1 - spp_op1).equiv(spp_op2 - spp_op2))
self.assertTrue((2 * spp_op1).equiv(spp_op1 + spp_op1))
self.assertTrue((2 * spp_op2).equiv(spp_op2 + spp_op2))
if not spp_op1.equiv(zero):
self.assertFalse(spp_op1.equiv(spp_op1 + spp_op1))
if not spp_op2.equiv(zero):
self.assertFalse(spp_op2.equiv(spp_op2 + spp_op2))
def test_equiv_atol(self):
"""Test equiv method with atol."""
op1 = SparsePauliOp.from_list([("X", 1), ("Y", 2)])
op2 = op1 + 1e-7 * SparsePauliOp.from_list([("I", 1)])
self.assertFalse(op1.equiv(op2))
self.assertTrue(op1.equiv(op2, atol=1e-7))
def test_eq_equiv(self):
"""Test __eq__ and equiv methods with some specific cases."""
with self.subTest("shuffled"):
spp_op1 = SparsePauliOp.from_list([("X", 1), ("Y", 2)])
spp_op2 = SparsePauliOp.from_list([("Y", 2), ("X", 1)])
self.assertNotEqual(spp_op1, spp_op2)
self.assertTrue(spp_op1.equiv(spp_op2))
with self.subTest("w/ zero"):
spp_op1 = SparsePauliOp.from_list([("X", 1), ("Y", 1)])
spp_op2 = SparsePauliOp.from_list([("X", 1), ("Y", 1), ("Z", 0)])
self.assertNotEqual(spp_op1, spp_op2)
self.assertTrue(spp_op1.equiv(spp_op2))
@combine(parameterized=[True, False], qubit_wise=[True, False])
def test_group_commuting(self, parameterized, qubit_wise):
"""Test general grouping commuting operators"""
def commutes(left: Pauli, right: Pauli, qubit_wise: bool) -> bool:
if len(left) != len(right):
return False
if not qubit_wise:
return left.commutes(right)
else:
# qubit-wise commuting check
vec_l = left.z + 2 * left.x
vec_r = right.z + 2 * right.x
qubit_wise_comparison = (vec_l * vec_r) * (vec_l - vec_r)
return np.all(qubit_wise_comparison == 0)
input_labels = ["IX", "IY", "IZ", "XX", "YY", "ZZ", "XY", "YX", "ZX", "ZY", "XZ", "YZ"]
np.random.shuffle(input_labels)
if parameterized:
coeffs = np.array(ParameterVector("a", len(input_labels)))
else:
coeffs = np.random.random(len(input_labels)) + np.random.random(len(input_labels)) * 1j
sparse_pauli_list = SparsePauliOp(input_labels, coeffs)
groups = sparse_pauli_list.group_commuting(qubit_wise)
# checking that every input Pauli in sparse_pauli_list is in a group in the ouput
output_labels = [pauli.to_label() for group in groups for pauli in group.paulis]
self.assertListEqual(sorted(output_labels), sorted(input_labels))
# checking that every coeffs are grouped according to sparse_pauli_list group
paulis_coeff_dict = dict(
sum([list(zip(group.paulis.to_labels(), group.coeffs)) for group in groups], [])
)
self.assertDictEqual(dict(zip(input_labels, coeffs)), paulis_coeff_dict)
# Within each group, every operator commutes with every other operator.
for group in groups:
self.assertTrue(
all(
commutes(pauli1, pauli2, qubit_wise)
for pauli1, pauli2 in it.combinations(group.paulis, 2)
)
)
# For every pair of groups, at least one element from one group does not commute with
# at least one element of the other.
for group1, group2 in it.combinations(groups, 2):
self.assertFalse(
all(
commutes(group1_pauli, group2_pauli, qubit_wise)
for group1_pauli, group2_pauli in it.product(group1.paulis, group2.paulis)
)
)
def test_dot_real(self):
"""Test dot for real coefficiets."""
x = SparsePauliOp("X", np.array([1]))
y = SparsePauliOp("Y", np.array([1]))
iz = SparsePauliOp("Z", 1j)
self.assertEqual(x.dot(y), iz)
def test_get_parameters(self):
"""Test getting the parameters."""
x, y = Parameter("x"), Parameter("y")
op = SparsePauliOp(["X", "Y", "Z"], coeffs=[1, x, x * y])
with self.subTest(msg="all parameters"):
self.assertEqual(ParameterView([x, y]), op.parameters)
op.assign_parameters({y: 2}, inplace=True)
with self.subTest(msg="after partial binding"):
self.assertEqual(ParameterView([x]), op.parameters)
def test_assign_parameters(self):
"""Test assign parameters."""
x, y = Parameter("x"), Parameter("y")
op = SparsePauliOp(["X", "Y", "Z"], coeffs=[1, x, x * y])
# partial binding inplace
op.assign_parameters({y: 2}, inplace=True)
with self.subTest(msg="partial binding"):
self.assertListEqual(op.coeffs.tolist(), [1, x, 2 * x])
# bind via array
bound = op.assign_parameters([3])
with self.subTest(msg="fully bound"):
self.assertTrue(np.allclose(bound.coeffs.astype(complex), [1, 3, 6]))
def test_paulis_setter_rejects_bad_inputs(self):
"""Test that the setter for `paulis` rejects different-sized inputs."""
op = SparsePauliOp(["XY", "ZX"], coeffs=[1, 1j])
with self.assertRaisesRegex(ValueError, "incorrect number of qubits"):
op.paulis = PauliList([Pauli("X"), Pauli("Y")])
with self.assertRaisesRegex(ValueError, "incorrect number of operators"):
op.paulis = PauliList([Pauli("XY"), Pauli("ZX"), Pauli("YZ")])
if __name__ == "__main__":
unittest.main()
|
https://github.com/bayesian-randomized-benchmarking/qiskit-advocates-bayes-RB
|
bayesian-randomized-benchmarking
|
import numpy as np
import copy
from qiskit_experiments.library import StandardRB, InterleavedRB
from qiskit_experiments.framework import ParallelExperiment
from qiskit_experiments.library.randomized_benchmarking import RBUtils
import qiskit.circuit.library as circuits
# for retrieving gate calibration
from datetime import datetime
import qiskit.providers.aer.noise.device as dv
# import the bayesian packages
import pymc3 as pm
import arviz as az
import unif_bayesian_fitter as bf
simulation = True # make your choice here
if simulation:
from qiskit.providers.aer import AerSimulator
from qiskit.test.mock import FakeParis
backend = AerSimulator.from_backend(FakeParis())
else:
from qiskit import IBMQ
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
backend = provider.get_backend('ibmq_lima') # type here hardware backend
# for WIP
import importlib
importlib.reload(bf)
lengths = np.arange(1, 2500, 250)
num_samples = 10
seed = 1010
qubits = [0]
# Run an RB experiment on qubit 0
exp1 = StandardRB(qubits, lengths, num_samples=num_samples, seed=seed)
expdata1 = exp1.run(backend).block_for_results()
results1 = expdata1.analysis_results()
# View result data
display(expdata1.figure(0))
for result in results1:
print(result)
popt = expdata1.analysis_results()[0].value.value
pcov = expdata1.analysis_results()[0].extra['covariance_mat']
epc_est_fm = expdata1.analysis_results()[2].value.value
epc_est_fm_err = expdata1.analysis_results()[2].value.stderr
EPG_dic = {}
for i in range(3,6):
EPG_key = expdata1.analysis_results()[i].name
EPG_dic[EPG_key] = expdata1.analysis_results()[i].value.value
nQ = len(qubits)
scale = (2 ** nQ - 1) / 2 ** nQ
interleaved_gate =''
# get count data
Y = bf.get_GSP_counts(expdata1._data, len(lengths),range(num_samples))
expdata1._data[1]
experiment_type = expdata1._data[0]['metadata']['experiment_type']
physical_qubits = expdata1._data[0]['metadata']['physical_qubits']
shots = expdata1._data[0]['shots']
#build model
pooled_model = bf.build_bayesian_model(model_type="pooled",Y=Y,
shots=shots,m_gates=lengths,
popt = popt,
pcov = pcov)
pm.model_to_graphviz(pooled_model)
trace_p = bf.get_trace(pooled_model, target_accept = 0.95)
# backend's recorded EPG
print(RBUtils.get_error_dict_from_backend(backend, qubits))
bf.RB_bayesian_results(pooled_model, trace_p, lengths,
epc_est_fm,
epc_est_fm_err,
experiment_type,
scale,
num_samples, Y, shots, physical_qubits, interleaved_gate, backend,
EPG_dic = EPG_dic,
routine = 'build_bayesian_model')
#build model
hierarchical_model = bf.build_bayesian_model(model_type="h_sigma",Y=Y,
shots=shots,m_gates=lengths,
popt = popt,
pcov = pcov,
sigma_theta=0.001,sigma_theta_l=0.0005,sigma_theta_u=0.0015)
pm.model_to_graphviz(hierarchical_model)
trace_h = bf.get_trace(hierarchical_model, target_accept = 0.99)
# backend's recorded EPG
print(RBUtils.get_error_dict_from_backend(backend, qubits))
bf.RB_bayesian_results(hierarchical_model, trace_h, lengths,
epc_est_fm, epc_est_fm_err, experiment_type, scale,
num_samples, Y, shots, physical_qubits, interleaved_gate, backend,
EPG_dic = EPG_dic, routine = 'build_bayesian_model')
# describe RB experiment
interleaved_gate =''
physical_qubits = qubits = (1,4)
nQ = len(qubits)
scale = (2 ** nQ - 1) / 2 ** nQ # defined for the 2-qubit run
lengths = np.arange(1, 200, 30)
lengths_1_qubit = np.arange(1, 2500, 250)
num_samples = 10
seed = 1010
# Run a 1-qubit RB expriment on each qubit to determine the error-per-gate of 1-qubit gates
expdata_1q = {}
epg_1q = []
for qubit in qubits:
exp = StandardRB([qubit], lengths_1_qubit, num_samples=num_samples, seed=seed)
expdata = exp.run(backend).block_for_results()
expdata_1q[qubit] = expdata
epg_1q += expdata.analysis_results()
# Run an RB experiment on qubits 1, 4
exp2 = StandardRB(qubits, lengths, num_samples=num_samples, seed=seed)
# Use the EPG data of the 1-qubit runs to ensure correct 2-qubit EPG computation
exp2.set_analysis_options(epg_1_qubit=epg_1q)
# Run the 2-qubit experiment
expdata2 = exp2.run(backend).block_for_results()
# View result data
results2 = expdata2.analysis_results()
# View result data
display(expdata2.figure(0))
for result in results2:
print(result)
# Compare the computed EPG of the cx gate with the backend's recorded cx gate error:
expected_epg = RBUtils.get_error_dict_from_backend(backend, qubits)[(qubits, 'cx')]
exp2_epg = expdata2.analysis_results("EPG_cx").value
print("Backend's reported EPG of the cx gate:", expected_epg)
print("Experiment computed EPG of the cx gate:", exp2_epg)
popt = expdata2.analysis_results()[0].value.value
pcov = expdata2.analysis_results()[0].extra['covariance_mat']
epc_est_fm = expdata2.analysis_results()[2].value.value
epc_est_fm_err = expdata2.analysis_results()[2].value.stderr
EPG_dic = {}
EPG_key = 'cx' #expdata2.analysis_results()[3].name
EPG_dic[EPG_key] = expdata2.analysis_results()[3].value.value
nQ = len(qubits)
scale = (2 ** nQ - 1) / 2 ** nQ
desired_gate ='cx'
t = None # enter t in datetime format if necessary
e_list = dv.gate_error_values(backend.properties()) # use properties(datetime=t) if t is defined
epc_calib = np.nan
for tuple_e in e_list:
if tuple_e[0] == 'cx' and tuple_e[1] == physical_qubits:
epc_calib = tuple_e[2]
print('EPC calibration: {0:.6f}'.format(epc_calib))
# get count data
Y = bf.get_GSP_counts(expdata2._data, len(lengths),range(num_samples))
experiment_type = expdata2._data[0]['metadata']['experiment_type']
physical_qubits = expdata2._data[0]['metadata']['physical_qubits']
shots = expdata2._data[0]['shots']
#build model
S2QBp_model = bf.build_bayesian_model(model_type="pooled",Y=Y,
shots=shots,m_gates=lengths,
popt = popt,
pcov = pcov)
pm.model_to_graphviz(S2QBp_model)
trace_p2 = bf.get_trace(S2QBp_model, target_accept = 0.95)
bf.RB_bayesian_results(S2QBp_model, trace_p2, lengths,
epc_est_fm,
epc_est_fm_err,
experiment_type,
scale,
num_samples, Y, shots, physical_qubits, interleaved_gate, backend,
EPG_dic = EPG_dic,
routine = 'build_bayesian_model')
#build model
S2QBh_model = bf.build_bayesian_model(model_type="h_sigma",Y=Y,shots=shots,m_gates=lengths,
popt = popt,
pcov = pcov,
sigma_theta=0.001,sigma_theta_l=0.0005,sigma_theta_u=0.0015)
pm.model_to_graphviz(S2QBh_model)
trace_h2 = bf.get_trace(S2QBh_model)
bf.RB_bayesian_results(S2QBh_model, trace_h2, lengths,
epc_est_fm,
epc_est_fm_err,
experiment_type,
scale,
num_samples, Y, shots, physical_qubits, interleaved_gate, backend,
EPG_dic = EPG_dic,
routine = 'build_bayesian_model')
# describe RB experiment
interleaved_gate = "x"
qubits = [0]
interleaved_circuit = circuits.XGate()
lengths = np.arange(1, 2500, 250)
num_samples = 10
seed = 1010
# Run an interleaved RB experiment
int_exp1 = InterleavedRB(interleaved_circuit, qubits,
lengths, num_samples=num_samples, seed=seed)
# Run
int_expdata1 = int_exp1.run(backend).block_for_results()
int_results1 = int_expdata1.analysis_results()
# View result data
display(int_expdata1.figure(0))
for result in int_results1:
print(result)
popt = int_expdata1.analysis_results()[0].value.value
pcov = int_expdata1.analysis_results()[0].extra['covariance_mat']
popt[2] = popt[1]/popt[2] # replace alpha_C by p_tilde
# WIP rigorously the covariance matrix could be modified too if used
epc_est_fm = int_expdata1.analysis_results()[3].value.value
epc_est_fm_err = int_expdata1.analysis_results()[3].value.stderr
nQ = len(qubits)
scale = (2 ** nQ - 1) / 2 ** nQ
interleaved_gate ='x'
# get count data
Y1 = bf.get_GSP_counts(int_expdata1._data, len(lengths),
range(0,2*num_samples-1,2))
Y2 = bf.get_GSP_counts(int_expdata1._data, len(lengths),
range(1,2*num_samples,2))
int_expdata1._data[1]
experiment_type = int_expdata1._data[0]['metadata']['experiment_type']
physical_qubits = int_expdata1._data[0]['metadata']['physical_qubits']
shots = int_expdata1._data[0]['shots']
Y=np.vstack((Y1,Y2))
RvsI = np.vstack((np.ones_like(Y1),np.zeros_like(Y2)))
IvsR = np.vstack((np.zeros_like(Y1),np.ones_like(Y2)))
tilde1 = bf.build_bayesian_model("tilde",Y=Y,shots=shots,
m_gates=lengths,
popt = popt,
pcov = pcov,
RvsI=RvsI,IvsR=IvsR)
pm.model_to_graphviz(tilde1)
trace_t = bf.get_trace(tilde1)
t = None # enter t in datetime format if necessary
e_list = dv.gate_error_values(backend.properties()) # use properties(datetime=t) if t is defined
epc_calib = np.nan
for tuple_e in e_list:
if tuple_e[0] == interleaved_gate and tuple_e[1] == qubits:
epc_calib = np.nan = tuple_e[2]
print('EPC calibration: {0:.6f}'.format(epc_calib))
# example of interpolated EPC_cal for hardware experiments
# EPC0 + (t_exp - tO) * (EPC1 - EPC0) / (t1 - t0)
# code here:
# epc_calib = 2.307E-4 + (23.6-7)*(2.193E-4 - 2.307E-4)/24
bf.RB_bayesian_results(tilde1, trace_t, lengths,
epc_est_fm, epc_est_fm_err, experiment_type, scale,
num_samples, Y, shots, physical_qubits, interleaved_gate, backend,
epc_calib = epc_calib, Y1 = Y1, Y2 = Y2,
routine = 'build_bayesian_model')
import importlib
importlib.reload(bf)
Y=np.hstack((Y1,Y2))
RvsI_h = np.ravel(np.vstack((np.ones_like(lengths),np.zeros_like(lengths))))
IvsR_h = np.ravel(np.vstack((np.zeros_like(lengths),np.ones_like(lengths))))
tilde2 = bf.build_bayesian_model("h_tilde",Y=Y,shots=shots, m_gates=lengths,
popt = popt,
pcov = pcov,
RvsI = RvsI_h, IvsR = IvsR_h,
sigma_theta=0.001,sigma_theta_l=0.0005,sigma_theta_u=0.0015)
pm.model_to_graphviz(tilde2)
trace_t3 = bf.get_trace(tilde2, target_accept = .95)
bf.RB_bayesian_results(tilde2, trace_t3, lengths,
epc_est_fm, epc_est_fm_err, experiment_type, scale,
num_samples, Y, shots, physical_qubits, interleaved_gate, backend,
epc_calib = epc_calib, Y1 = Y1, Y2 = Y2,
routine = 'build_bayesian_model')
# describe RB experiment
interleaved_gate = "cx"
physical_qubits = qubits = [1,4]
interleaved_circuit = circuits.CXGate()
lengths = np.arange(1, 200, 30)
num_samples = 10
seed = 1010
t = None # enter t in datetime format if necessary
e_list = dv.gate_error_values(backend.properties()) # use properties(datetime=t) if t is defined
epc_calib = np.nan
for tuple_e in e_list:
if tuple_e[0] == interleaved_gate and tuple_e[1] == physical_qubits:
epc_calib = np.nan = tuple_e[2]
print('EPC calibration: {0:.6f}'.format(epc_calib))
# Run an interleaved RB experiment
int_exp2 = InterleavedRB(interleaved_circuit, qubits,
lengths, num_samples=num_samples, seed=seed)
# Run
int_expdata2 = int_exp2.run(backend).block_for_results()
int_results2 = int_expdata2.analysis_results()
# View result data
display(int_expdata2.figure(0))
for result in int_results2:
print(result)
popt = int_expdata2.analysis_results()[0].value.value
pcov = int_expdata2.analysis_results()[0].extra['covariance_mat']
popt[2] = popt[1]/popt[2] # replace alpha_C by p_tilde
# WIP rigorously the covariance matrix could be modified too if used
epc_est_fm = int_expdata2.analysis_results()[3].value.value
epc_est_fm_err = int_expdata2.analysis_results()[3].value.stderr
nQ = len(qubits)
scale = (2 ** nQ - 1) / 2 ** nQ
interleaved_gate ='cx'
# get count data
Y1 = bf.get_GSP_counts(int_expdata2._data, len(lengths),
range(0,2*num_samples-1,2))
Y2 = bf.get_GSP_counts(int_expdata2._data, len(lengths),
range(1,2*num_samples,2))
int_expdata2._data[1]
experiment_type = int_expdata2._data[0]['metadata']['experiment_type']
physical_qubits = int_expdata2._data[0]['metadata']['physical_qubits']
shots = int_expdata2._data[0]['shots']
# example of interpolated EPC_cal for hardware experiments
# EPC0 + (t_exp - tO) * (EPC1 - EPC0) / (t1 - t0)
# code here:
# epc_calib = 2.307E-4 + (23.6-7)*(2.193E-4 - 2.307E-4)/24
Y = np.vstack((Y1,Y2))
RvsI = np.vstack((np.ones_like(Y1),np.zeros_like(Y2)))
IvsR = np.vstack((np.zeros_like(Y1),np.ones_like(Y2)))
tilde3 = bf.build_bayesian_model("tilde",Y=Y,shots=shots, m_gates=lengths,
popt = popt,
pcov = pcov,
RvsI=RvsI,IvsR=IvsR)
pm.model_to_graphviz(tilde3)
trace_t3 = bf.get_trace(tilde3)
bf.RB_bayesian_results(tilde3, trace_t3, lengths,
epc_est_fm, epc_est_fm_err, experiment_type, scale,
num_samples, Y, shots, physical_qubits, interleaved_gate, backend,
epc_calib = epc_calib, Y1 = Y1, Y2 = Y2,
routine = 'build_bayesian_model')
import importlib
importlib.reload(bf)
# use 2m length array
RvsI_h = np.ravel(np.vstack((np.ones_like(lengths),np.zeros_like(lengths))))
IvsR_h = np.ravel(np.vstack((np.zeros_like(lengths),np.ones_like(lengths))))
tilde4 = bf.build_bayesian_model("h_tilde",Y=np.hstack((Y1,Y2)),
shots=shots, m_gates=lengths,
popt = popt,
pcov = pcov,
RvsI = RvsI_h, IvsR = IvsR_h,
sigma_theta=0.005,sigma_theta_l=0.001,sigma_theta_u=0.05)
pm.model_to_graphviz(tilde4)
trace_t4 = bf.get_trace(tilde4, target_accept = .99)
bf.RB_bayesian_results(tilde4, trace_t4, lengths,
epc_est_fm, epc_est_fm_err, experiment_type, scale,
num_samples, Y, shots, physical_qubits, interleaved_gate, backend,
epc_calib = epc_calib, Y1 = Y1, Y2 = Y2,
routine = 'build_bayesian_model')
|
https://github.com/AllenGabrielMarchen/HHL_implementation
|
AllenGabrielMarchen
|
#measurement.py
from qiskit import QuantumCircuit, transpile, assemble
from qiskit.visualization import plot_histogram
def measurement(qc,n_l,n_b,CU,backend,shots):
t = transpile(qc, backend)
qobj = assemble(t, shots=shots)
results = backend.run(qobj).result()
answer = results.get_counts()
plot_histogram(answer, title="Output Histogram").savefig('./outputs/output_histogram.png',facecolor='#eeeeee')
return answer
|
https://github.com/apcarrik/qiskit-dev
|
apcarrik
|
import pylab
import numpy as np
from qiskit import Aer
from qiskit.utils import QuantumInstance
from qiskit.tools.visualization import plot_histogram
from qiskit.algorithms import Grover, AmplificationProblem
from qiskit.circuit.library.phase_oracle import PhaseOracle
### Finding Solutions to 3-SAT Problems
input_3sat_instance = '''
c example DIMACS-CNF 3-SAT
p cnf 3 5
-1 -2 -3 0
1 -2 3 0
1 2 -3 0
1 -2 -3 0
-1 2 3 0
''' # example problem has 3 solutions: (1 -2 3), (-1 -2 -3), (1 2 -3)
# Create corresponding oracle for Grover search using PhaseOracle (supports DIMACS-CNF format strings)
import os
import tempfile
from qiskit.exceptions import MissingOptionalLibraryError
fp = tempfile.NamedTemporaryFile(mode='w+t', delete=False)
fp.write(input_3sat_instance)
file_name = fp.name
fp.close()
oracle = None
try:
oracle = PhaseOracle.from_dimacs_file(file_name)
except MissingOptionalLibraryError as ex:
print(ex)
finally:
os.remove(file_name)
# create Grover instance using oracle
problem = None
if oracle is not None:
problem = AmplificationProblem(oracle, is_good_state=oracle.evaluate_bitstring)
# configure backend & run Grover instance to obtain result
backend = Aer.get_backend('aer_simulator')
quantum_instance = QuantumInstance(backend, shots=1024)
grover = Grover(quantum_instance=quantum_instance)
result = None
if problem is not None:
result = grover.amplify(problem)
print(result.assignment)
plot_histogram(result.circuit_results[0]).show()
### Boolean Logical Expressions
# Construct oracle using arbitrary Boolean logic expression
expression = '(w ^ x) & ~(y ^ z) & (x & y & z)'
try:
oracle = PhaseOracle(expression)
problem = AmplificationProblem(oracle, is_good_state=oracle.evaluate_bitstring)
grover = Grover(quantum_instance=QuantumInstance(Aer.get_backend('aer_simulator'),
shots=1024))
result = grover.amplify(problem)
plot_histogram(result.circuit_results[0]).show()
except MissingOptionalLibraryError as ex:
print(ex)
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 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.
"""Tests for PTM quantum channel representation class."""
import copy
import unittest
import numpy as np
from numpy.testing import assert_allclose
from qiskit import QiskitError
from qiskit.quantum_info.states import DensityMatrix
from qiskit.quantum_info.operators.channel import PTM
from .channel_test_case import ChannelTestCase
class TestPTM(ChannelTestCase):
"""Tests for PTM channel representation."""
def test_init(self):
"""Test initialization"""
mat4 = np.eye(4) / 2.0
chan = PTM(mat4)
assert_allclose(chan.data, mat4)
self.assertEqual(chan.dim, (2, 2))
self.assertEqual(chan.num_qubits, 1)
mat16 = np.eye(16) / 4
chan = PTM(mat16)
assert_allclose(chan.data, mat16)
self.assertEqual(chan.dim, (4, 4))
self.assertEqual(chan.num_qubits, 2)
# Wrong input or output dims should raise exception
self.assertRaises(QiskitError, PTM, mat16, input_dims=2, output_dims=4)
# Non multi-qubit dimensions should raise exception
self.assertRaises(QiskitError, PTM, np.eye(6) / 2, input_dims=3, output_dims=2)
def test_circuit_init(self):
"""Test initialization from a circuit."""
circuit, target = self.simple_circuit_no_measure()
op = PTM(circuit)
target = PTM(target)
self.assertEqual(op, target)
def test_circuit_init_except(self):
"""Test initialization from circuit with measure raises exception."""
circuit = self.simple_circuit_with_measure()
self.assertRaises(QiskitError, PTM, circuit)
def test_equal(self):
"""Test __eq__ method"""
mat = self.rand_matrix(4, 4, real=True)
self.assertEqual(PTM(mat), PTM(mat))
def test_copy(self):
"""Test copy method"""
mat = np.eye(4)
with self.subTest("Deep copy"):
orig = PTM(mat)
cpy = orig.copy()
cpy._data[0, 0] = 0.0
self.assertFalse(cpy == orig)
with self.subTest("Shallow copy"):
orig = PTM(mat)
clone = copy.copy(orig)
clone._data[0, 0] = 0.0
self.assertTrue(clone == orig)
def test_clone(self):
"""Test clone method"""
mat = np.eye(4)
orig = PTM(mat)
clone = copy.copy(orig)
clone._data[0, 0] = 0.0
self.assertTrue(clone == orig)
def test_is_cptp(self):
"""Test is_cptp method."""
self.assertTrue(PTM(self.depol_ptm(0.25)).is_cptp())
# Non-CPTP should return false
self.assertFalse(PTM(1.25 * self.ptmI - 0.25 * self.depol_ptm(1)).is_cptp())
def test_compose_except(self):
"""Test compose different dimension exception"""
self.assertRaises(QiskitError, PTM(np.eye(4)).compose, PTM(np.eye(16)))
self.assertRaises(QiskitError, PTM(np.eye(4)).compose, 2)
def test_compose(self):
"""Test compose method."""
# Random input test state
rho = DensityMatrix(self.rand_rho(2))
# UnitaryChannel evolution
chan1 = PTM(self.ptmX)
chan2 = PTM(self.ptmY)
chan = chan1.compose(chan2)
rho_targ = rho.evolve(PTM(self.ptmZ))
self.assertEqual(rho.evolve(chan), rho_targ)
# 50% depolarizing channel
chan1 = PTM(self.depol_ptm(0.5))
chan = chan1.compose(chan1)
rho_targ = rho.evolve(PTM(self.depol_ptm(0.75)))
self.assertEqual(rho.evolve(chan), rho_targ)
# Compose random
ptm1 = self.rand_matrix(4, 4, real=True)
ptm2 = self.rand_matrix(4, 4, real=True)
chan1 = PTM(ptm1, input_dims=2, output_dims=2)
chan2 = PTM(ptm2, input_dims=2, output_dims=2)
rho_targ = rho.evolve(chan1).evolve(chan2)
chan = chan1.compose(chan2)
self.assertEqual(chan.dim, (2, 2))
self.assertEqual(rho.evolve(chan), rho_targ)
chan = chan1 & chan2
self.assertEqual(chan.dim, (2, 2))
self.assertEqual(rho.evolve(chan), rho_targ)
def test_dot(self):
"""Test dot method."""
# Random input test state
rho = DensityMatrix(self.rand_rho(2))
# UnitaryChannel evolution
chan1 = PTM(self.ptmX)
chan2 = PTM(self.ptmY)
rho_targ = rho.evolve(PTM(self.ptmZ))
self.assertEqual(rho.evolve(chan2.dot(chan1)), rho_targ)
self.assertEqual(rho.evolve(chan2 @ chan1), rho_targ)
# Compose random
ptm1 = self.rand_matrix(4, 4, real=True)
ptm2 = self.rand_matrix(4, 4, real=True)
chan1 = PTM(ptm1, input_dims=2, output_dims=2)
chan2 = PTM(ptm2, input_dims=2, output_dims=2)
rho_targ = rho.evolve(chan1).evolve(chan2)
self.assertEqual(rho.evolve(chan2.dot(chan1)), rho_targ)
self.assertEqual(rho.evolve(chan2 @ chan1), rho_targ)
def test_compose_front(self):
"""Test deprecated front compose method."""
# Random input test state
rho = DensityMatrix(self.rand_rho(2))
# UnitaryChannel evolution
chan1 = PTM(self.ptmX)
chan2 = PTM(self.ptmY)
chan = chan2.compose(chan1, front=True)
rho_targ = rho.evolve(PTM(self.ptmZ))
self.assertEqual(rho.evolve(chan), rho_targ)
# Compose random
ptm1 = self.rand_matrix(4, 4, real=True)
ptm2 = self.rand_matrix(4, 4, real=True)
chan1 = PTM(ptm1, input_dims=2, output_dims=2)
chan2 = PTM(ptm2, input_dims=2, output_dims=2)
rho_targ = rho.evolve(chan1).evolve(chan2)
chan = chan2.compose(chan1, front=True)
self.assertEqual(chan.dim, (2, 2))
self.assertEqual(rho.evolve(chan), rho_targ)
def test_expand(self):
"""Test expand method."""
rho0, rho1 = np.diag([1, 0]), np.diag([0, 1])
rho_init = DensityMatrix(np.kron(rho0, rho0))
chan1 = PTM(self.ptmI)
chan2 = PTM(self.ptmX)
# X \otimes I
chan = chan1.expand(chan2)
rho_targ = DensityMatrix(np.kron(rho1, rho0))
self.assertEqual(chan.dim, (4, 4))
self.assertEqual(rho_init.evolve(chan), rho_targ)
# I \otimes X
chan = chan2.expand(chan1)
rho_targ = DensityMatrix(np.kron(rho0, rho1))
self.assertEqual(chan.dim, (4, 4))
self.assertEqual(rho_init.evolve(chan), rho_targ)
# Completely depolarizing
chan_dep = PTM(self.depol_ptm(1))
chan = chan_dep.expand(chan_dep)
rho_targ = DensityMatrix(np.diag([1, 1, 1, 1]) / 4)
self.assertEqual(chan.dim, (4, 4))
self.assertEqual(rho_init.evolve(chan), rho_targ)
def test_tensor(self):
"""Test tensor method."""
rho0, rho1 = np.diag([1, 0]), np.diag([0, 1])
rho_init = DensityMatrix(np.kron(rho0, rho0))
chan1 = PTM(self.ptmI)
chan2 = PTM(self.ptmX)
# X \otimes I
chan = chan2.tensor(chan1)
rho_targ = DensityMatrix(np.kron(rho1, rho0))
self.assertEqual(chan.dim, (4, 4))
self.assertEqual(rho_init.evolve(chan), rho_targ)
# I \otimes X
chan = chan1.tensor(chan2)
rho_targ = DensityMatrix(np.kron(rho0, rho1))
self.assertEqual(chan.dim, (4, 4))
self.assertEqual(rho_init.evolve(chan), rho_targ)
# Completely depolarizing
chan_dep = PTM(self.depol_ptm(1))
chan = chan_dep.tensor(chan_dep)
rho_targ = DensityMatrix(np.diag([1, 1, 1, 1]) / 4)
self.assertEqual(chan.dim, (4, 4))
self.assertEqual(rho_init.evolve(chan), rho_targ)
def test_power(self):
"""Test power method."""
# 10% depolarizing channel
p_id = 0.9
depol = PTM(self.depol_ptm(1 - p_id))
# Compose 3 times
p_id3 = p_id**3
chan3 = depol.power(3)
targ3 = PTM(self.depol_ptm(1 - p_id3))
self.assertEqual(chan3, targ3)
def test_add(self):
"""Test add method."""
mat1 = 0.5 * self.ptmI
mat2 = 0.5 * self.depol_ptm(1)
chan1 = PTM(mat1)
chan2 = PTM(mat2)
targ = PTM(mat1 + mat2)
self.assertEqual(chan1._add(chan2), targ)
self.assertEqual(chan1 + chan2, targ)
targ = PTM(mat1 - mat2)
self.assertEqual(chan1 - chan2, targ)
def test_add_qargs(self):
"""Test add method with qargs."""
mat = self.rand_matrix(8**2, 8**2)
mat0 = self.rand_matrix(4, 4)
mat1 = self.rand_matrix(4, 4)
op = PTM(mat)
op0 = PTM(mat0)
op1 = PTM(mat1)
op01 = op1.tensor(op0)
eye = PTM(self.ptmI)
with self.subTest(msg="qargs=[0]"):
value = op + op0([0])
target = op + eye.tensor(eye).tensor(op0)
self.assertEqual(value, target)
with self.subTest(msg="qargs=[1]"):
value = op + op0([1])
target = op + eye.tensor(op0).tensor(eye)
self.assertEqual(value, target)
with self.subTest(msg="qargs=[2]"):
value = op + op0([2])
target = op + op0.tensor(eye).tensor(eye)
self.assertEqual(value, target)
with self.subTest(msg="qargs=[0, 1]"):
value = op + op01([0, 1])
target = op + eye.tensor(op1).tensor(op0)
self.assertEqual(value, target)
with self.subTest(msg="qargs=[1, 0]"):
value = op + op01([1, 0])
target = op + eye.tensor(op0).tensor(op1)
self.assertEqual(value, target)
with self.subTest(msg="qargs=[0, 2]"):
value = op + op01([0, 2])
target = op + op1.tensor(eye).tensor(op0)
self.assertEqual(value, target)
with self.subTest(msg="qargs=[2, 0]"):
value = op + op01([2, 0])
target = op + op0.tensor(eye).tensor(op1)
self.assertEqual(value, target)
def test_sub_qargs(self):
"""Test subtract method with qargs."""
mat = self.rand_matrix(8**2, 8**2)
mat0 = self.rand_matrix(4, 4)
mat1 = self.rand_matrix(4, 4)
op = PTM(mat)
op0 = PTM(mat0)
op1 = PTM(mat1)
op01 = op1.tensor(op0)
eye = PTM(self.ptmI)
with self.subTest(msg="qargs=[0]"):
value = op - op0([0])
target = op - eye.tensor(eye).tensor(op0)
self.assertEqual(value, target)
with self.subTest(msg="qargs=[1]"):
value = op - op0([1])
target = op - eye.tensor(op0).tensor(eye)
self.assertEqual(value, target)
with self.subTest(msg="qargs=[2]"):
value = op - op0([2])
target = op - op0.tensor(eye).tensor(eye)
self.assertEqual(value, target)
with self.subTest(msg="qargs=[0, 1]"):
value = op - op01([0, 1])
target = op - eye.tensor(op1).tensor(op0)
self.assertEqual(value, target)
with self.subTest(msg="qargs=[1, 0]"):
value = op - op01([1, 0])
target = op - eye.tensor(op0).tensor(op1)
self.assertEqual(value, target)
with self.subTest(msg="qargs=[0, 2]"):
value = op - op01([0, 2])
target = op - op1.tensor(eye).tensor(op0)
self.assertEqual(value, target)
with self.subTest(msg="qargs=[2, 0]"):
value = op - op01([2, 0])
target = op - op0.tensor(eye).tensor(op1)
self.assertEqual(value, target)
def test_add_except(self):
"""Test add method raises exceptions."""
chan1 = PTM(self.ptmI)
chan2 = PTM(np.eye(16))
self.assertRaises(QiskitError, chan1._add, chan2)
self.assertRaises(QiskitError, chan1._add, 5)
def test_multiply(self):
"""Test multiply method."""
chan = PTM(self.ptmI)
val = 0.5
targ = PTM(val * self.ptmI)
self.assertEqual(chan._multiply(val), targ)
self.assertEqual(val * chan, targ)
targ = PTM(self.ptmI * val)
self.assertEqual(chan * val, targ)
def test_multiply_except(self):
"""Test multiply method raises exceptions."""
chan = PTM(self.ptmI)
self.assertRaises(QiskitError, chan._multiply, "s")
self.assertRaises(QiskitError, chan.__rmul__, "s")
self.assertRaises(QiskitError, chan._multiply, chan)
self.assertRaises(QiskitError, chan.__rmul__, chan)
def test_negate(self):
"""Test negate method"""
chan = PTM(self.ptmI)
targ = PTM(-self.ptmI)
self.assertEqual(-chan, targ)
if __name__ == "__main__":
unittest.main()
|
https://github.com/Qottmann/Quantum-anomaly-detection
|
Qottmann
|
import sys
sys.path.insert(1, '..') # sets the import path to the parent folder
import time
import itertools
import numpy as np
import qiskit
from qiskit import *
from qiskit.quantum_info import Statevector
from qiskit.algorithms.optimizers import COBYLA, L_BFGS_B, SPSA
from qiskit.opflow.state_fns import StateFn, CircuitStateFn
from qiskit.providers.aer import StatevectorSimulator, AerSimulator
from qiskit.opflow import CircuitSampler
from qiskit.ignis.mitigation.measurement import CompleteMeasFitter # you will need to pip install qiskit-ignis
from qiskit.ignis.mitigation.measurement import complete_meas_cal
import matplotlib.pyplot as plt
from matplotlib.ticker import MaxNLocator
from matplotlib.colors import BoundaryNorm
cmap = plt.get_cmap("plasma") #'viridis'
from modules.utils import *
from qae import *
import datetime
from tenpy.networks.mps import MPS
from tenpy.models.hubbard import BoseHubbardChain
from tenpy.algorithms import dmrg
from tenpy.linalg import np_conserved
def DMRG_EBH(L, V, t_list, chi_max=30, bc_MPS='infinite'):
model_params = dict(n_max=1, filling=0.5, bc_MPS=bc_MPS, t=t_list,
L=L, V=V, mu=0, conserve='N')
M = BoseHubbardChain(model_params)
vector=[]
for i in range(M.lat.N_sites):
if i%2:
vector.append(1)
else:
vector.append(0)
psi = MPS.from_product_state(M.lat.mps_sites(), vector, bc=M.lat.bc_MPS)
dmrg_params = {
'mixer': True,
'trunc_params': {
'chi_max': chi_max,
},
'max_E_err': 1.e-16,
#'verbose': 0
}
info = dmrg.run(psi, M, dmrg_params)
return info['E'], psi
print(qiskit.__version__, np.__version__)
#IBMQ.load_account() # this then automatically loads your saved account
#provider = IBMQ.get_provider(hub='ibm-q-research')
#device = provider.backend.ibmq_rome # 6 bogota ; 4 rome
### Real device execution:
#backend = device
### Simulation with noise profile from real device
#backend = qiskit.providers.aer.AerSimulator.from_backend(device)
### Simulation without noise
backend = qiskit.providers.aer.AerSimulator(method="matrix_product_state")
#backend = StatevectorSimulator()
### Preliminaries
L = 10
num_trash = 2
anti = 1 # 1 for ferromagnetic Ising model, -1 for antiferromagnet
filename = "data/QAEAnsatz_scaling_MPS"
V = 1
deltat=1
chi = 2**3
print("bond dimension : ", chi)
t_list = np.ones(L-1)
for i in range(len(t_list)):
t_list[i] -= deltat*(-1)**i
E0, psi0 = DMRG_EBH(L, V, t_list, chi_max=chi, bc_MPS='finite')
thetas = np.random.rand(num_trash*(L+1))
QAE_circ = QAEAnsatz(num_qubits = L, num_trash_qubits= num_trash, trash_qubits_idxs = list(range(num_trash)), measure_trash=False).assign_parameters(thetas)
QAE_circ.save_matrix_product_state(label="my_mps")
result = backend.run(QAE_circ).result()
#result.data(0)["my_mps"]
[(_[0].shape, _[1].shape) for _ in result.data(0)["my_mps"][0]]
[_.shape for _ in result.data(0)["my_mps"][1]]
# G is only the local tensor (not multiplied by any singular values) - see https://tenpy.readthedocs.io/en/latest/reference/tenpy.networks.mps.html
A_list = [psi0.get_B(i, form="G").to_ndarray().transpose([1,0,2]) for i in range(L)]
for i,A in enumerate(A_list):
A_list[i] = (A[0], A[1])
[(_[0].shape, _[1].shape) for _ in A_list]
S_list = [psi0.get_SR(i) for i in range(L-1)] # skip trivial last bond; hast to be of size L-1
state = (A_list, S_list)
initcirc = QuantumCircuit(QuantumRegister(L,"q")) #,ClassicalRegister(num_trash, 'c')
initcirc.set_matrix_product_state(state)
initcirc.draw()
plt.plot(psi0.expectation_value("N"))
i=0
qi = qiskit.utils.QuantumInstance(backend=backend, # , seed_simulator=seed, seed_transpiler=seed
shots = 1000,
#coupling_map=coupling_map,
#noise_model=noise_model, # comment out on real device execution
#measurement_error_mitigation_cls= CompleteMeasFitter,
#cals_matrix_refresh_period=30 #How often to refresh the calibration matrix in measurement mitigation. in minutes
)
QZ = np.zeros(L)
for i in range(L):
meas_outcome = ~StateFn(QNKron(L,Z,I,i)) @ StateFn(initcirc)
QZ[i] = CircuitSampler(qi).convert(meas_outcome).eval()
plt.plot(QZ)
|
https://github.com/carstenblank/dc-qiskit-qml
|
carstenblank
|
import qiskit
from qiskit_aer.backends.aerbackend import AerBackend
from dc_qiskit_qml.encoding_maps import NormedAmplitudeEncoding
from dc_qiskit_qml.distance_based.hadamard import QmlHadamardNeighborClassifier
from dc_qiskit_qml.distance_based.hadamard.state import QmlGenericStateCircuitBuilder
from dc_qiskit_qml.distance_based.hadamard.state.sparsevector import MottonenStatePreparation
initial_state_builder = QmlGenericStateCircuitBuilder(MottonenStatePreparation())
execution_backend: AerBackend = qiskit.Aer.get_backend('qasm_simulator')
qml = QmlHadamardNeighborClassifier(backend=execution_backend,
shots=8192,
classifier_circuit_factory=initial_state_builder,
encoding_map=NormedAmplitudeEncoding())
from sklearn.preprocessing import StandardScaler, Normalizer
from sklearn.pipeline import Pipeline
from sklearn.datasets import load_wine
X, y = load_wine(return_X_y=True)
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.10, random_state=42)
pipeline = Pipeline([
('scaler', StandardScaler()),
('l2norm', Normalizer(norm='l2', copy=True)),
('qml', qml)
])
pipeline.fit(X_train, y_train)
prediction = pipeline.predict(X_test)
prediction
"Test Accuracy: {}".format(
sum([1 if p == t else 0 for p, t in zip(prediction, y_test)])/len(prediction)
)
prediction_train = pipeline.predict(X_train)
"Train Accuracy: {}".format(
sum([1 if p == t else 0 for p, t in zip(prediction_train, y_train)])/len(prediction_train)
)
import matplotlib.pyplot as plt
colors = ['red', 'blue', 'green', 'orange']
plt.scatter(
pipeline.transform(X_train[:,0]), pipeline.transform(X_train[:,1]),
color=[colors[yy] for yy in y_train],
marker='.', s=50)
plt.show()
plt.scatter(
pipeline.transform(X_test[:,0]), pipeline.transform(X_test[:,1]),
color=[colors[yy] for yy in prediction],
marker='.', s=50)
plt.show()
plt.scatter(
pipeline.transform(X_test[:,0]), pipeline.transform(X_test[:,1]),
color=[colors[yy] for yy in y_test],
marker='.', s=20)
plt.show()
_X_train = pipeline.transform(X_train)
_X_test = pipeline.transform(X_test)
for i in range(len(_X_test)):
p_acc_theory = QmlHadamardNeighborClassifier.p_acc_theory(X_train, y_train, X_test[i])
print(f"{qml.last_predict_p_acc[i]:.4f} ~~ {p_acc_theory:.4f}")
for i in range(len(X_test)):
p_label_theory = QmlHadamardNeighborClassifier.p_label_theory(X_train, y_train, X_test[i], prediction[i])
print(f"{qml.last_predict_probability[i]:.4f} ~~ {p_label_theory:.4f}")
print(qml._last_predict_circuits[0].qasm())
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, transpile, schedule
from qiskit.visualization.timeline import draw, IQXSimple
from qiskit.providers.fake_provider import FakeBoeblingen
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0,1)
qc = transpile(qc, FakeBoeblingen(), scheduling_method='alap', layout_method='trivial')
draw(qc, style=IQXSimple())
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_nature.second_q.drivers import PySCFDriver
driver = PySCFDriver(
atom="H 0 0 0; H 0 0 0.72" # Two Hydrogen atoms, 0.72 Angstrom apart
)
molecule = driver.run()
from qiskit_nature.second_q.mappers import QubitConverter, ParityMapper
qubit_converter = QubitConverter(ParityMapper())
hamiltonian = qubit_converter.convert(molecule.second_q_ops()[0])
from qiskit.algorithms.minimum_eigensolvers import NumPyMinimumEigensolver
sol = NumPyMinimumEigensolver().compute_minimum_eigenvalue(hamiltonian)
real_solution = molecule.interpret(sol)
real_solution.groundenergy
from qiskit_ibm_runtime import QiskitRuntimeService, Estimator, Session, Options
service = QiskitRuntimeService()
backend = "ibmq_qasm_simulator"
from qiskit.algorithms.minimum_eigensolvers import VQE
# Use RealAmplitudes circuit to create trial states
from qiskit.circuit.library import RealAmplitudes
ansatz = RealAmplitudes(num_qubits=2, reps=2)
# Search for better states using SPSA algorithm
from qiskit.algorithms.optimizers import SPSA
optimizer = SPSA(150)
# Set a starting point for reproduceability
import numpy as np
np.random.seed(6)
initial_point = np.random.uniform(-np.pi, np.pi, 12)
# Create an object to store intermediate results
from dataclasses import dataclass
@dataclass
class VQELog:
values: list
parameters: list
def update(self, count, parameters, mean, _metadata):
self.values.append(mean)
self.parameters.append(parameters)
print(f"Running circuit {count} of ~350", end="\r", flush=True)
log = VQELog([],[])
# Main calculation
with Session(service=service, backend=backend) as session:
options = Options()
options.optimization_level = 3
vqe = VQE(Estimator(session=session, options=options),
ansatz, optimizer, callback=log.update, initial_point=initial_point)
result = vqe.compute_minimum_eigenvalue(hamiltonian)
print("Experiment complete.".ljust(30))
print(f"Raw result: {result.optimal_value}")
if 'simulator' not in backend:
# Run once with ZNE error mitigation
options.resilience_level = 2
vqe = VQE(Estimator(session=session, options=options),
ansatz, SPSA(1), initial_point=result.optimal_point)
result = vqe.compute_minimum_eigenvalue(hamiltonian)
print(f"Mitigated result: {result.optimal_value}")
import matplotlib.pyplot as plt
plt.rcParams["font.size"] = 14
# Plot energy and reference value
plt.figure(figsize=(12, 6))
plt.plot(log.values, label="Estimator VQE")
plt.axhline(y=real_solution.groundenergy, color="tab:red", ls="--", label="Target")
plt.legend(loc="best")
plt.xlabel("Iteration")
plt.ylabel("Energy [H]")
plt.title("VQE energy")
plt.show()
import qiskit_ibm_runtime
qiskit_ibm_runtime.version.get_version_info()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
# You can choose different colors for the real and imaginary parts of the density matrix.
from qiskit import QuantumCircuit
from qiskit.quantum_info import DensityMatrix
from qiskit.visualization import plot_state_city
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
state = DensityMatrix(qc)
plot_state_city(state, color=['midnightblue', 'crimson'], title="New State City")
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
top = QuantumCircuit(1)
top.x(0);
bottom = QuantumCircuit(2)
bottom.cry(0.2, 0, 1);
tensored = bottom.tensor(top)
tensored.draw('mpl')
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
qc.draw('mpl')
|
https://github.com/matheusmtta/Quantum-Computing
|
matheusmtta
|
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
from qiskit import *
from qiskit.providers.ibmq import least_busy
from qiskit.tools.visualization import plot_histogram
from IPython.display import display, Math, Latex
def Increment(size):
U = QuantumCircuit(size)
control = [x for x in range(size-1)]
for k in range(size-1):
U.mcx(control, control[-1]+1)
control.pop()
U.x(0)
U = U.to_gate()
U.name = '--->'
ctl_U = U.control()
return ctl_U
def Decrement(size):
U = QuantumCircuit(size)
control = [x for x in range(size-1)]
for k in range(size-1):
U.x(control)
U.mcx(control, control[-1]+1)
U.x(control)
control.pop()
U.x(0)
U = U.to_gate()
U.name = '<---'
ctl_U = U.control()
return ctl_U
n = 2
steps = 2
graph = QuantumRegister(n+1)
mes = ClassicalRegister(n)
mcq = QuantumCircuit(graph, mes)
#define U(t)
for i in range(steps):
mcq.h(n)
mcq.append(Increment(n), [n]+list(range(0, n)))
mcq.x(n)
mcq.append(Decrement(n), [n]+list(range(0, n)))
mcq.x(n)
mcq.measure(range(n), range(n))
#mcq = transpile(mcq, basis_gates=['cx','u3'],optimization_level=3)
mcq.draw('mpl')
backend = BasicAer.get_backend('qasm_simulator')
atp = 1024
res = execute(mcq, backend=backend, shots=atp).result()
ans = res.get_counts()
plot_histogram(ans)
IBMQ.load_account()
provider = IBMQ.get_provider(group='open', project='main')
backend = provider.get_backend('ibmq_16_melbourne')
job = execute(mcq, backend=backend)
ans_quantum = job.result().get_counts()
legend = ['QASM','ibmq_16_melbourne']
plot_histogram([ans,ans_quantum], legend=legend)
|
https://github.com/qclib/qclib
|
qclib
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 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.
"""
Arbitrary unitary circuit instruction.
"""
import numpy
from qiskit.circuit import Gate, ControlledGate
from qiskit.circuit import QuantumCircuit
from qiskit.circuit import QuantumRegister, Qubit
from qiskit.circuit.exceptions import CircuitError
from qiskit.circuit._utils import _compute_control_matrix
from qiskit.circuit.library.standard_gates import UGate
from qiskit.extensions.quantum_initializer import isometry
from qiskit.quantum_info.operators.predicates import matrix_equal
from qiskit.quantum_info.operators.predicates import is_unitary_matrix
from qiskit.quantum_info.synthesis.one_qubit_decompose import OneQubitEulerDecomposer
from qiskit.quantum_info.synthesis.two_qubit_decompose import two_qubit_cnot_decompose
from qiskit.extensions.exceptions import ExtensionError
_DECOMPOSER1Q = OneQubitEulerDecomposer("U")
class UnitaryGate(Gate):
"""Class quantum gates specified by a unitary matrix.
Example:
We can create a unitary gate from a unitary matrix then add it to a
quantum circuit. The matrix can also be directly applied to the quantum
circuit, see :meth:`.QuantumCircuit.unitary`.
.. code-block:: python
from qiskit import QuantumCircuit
from qiskit.extensions import UnitaryGate
matrix = [[0, 0, 0, 1],
[0, 0, 1, 0],
[1, 0, 0, 0],
[0, 1, 0, 0]]
gate = UnitaryGate(matrix)
circuit = QuantumCircuit(2)
circuit.append(gate, [0, 1])
"""
def __init__(self, data, label=None):
"""Create a gate from a numeric unitary matrix.
Args:
data (matrix or Operator): unitary operator.
label (str): unitary name for backend [Default: None].
Raises:
ExtensionError: if input data is not an N-qubit unitary operator.
"""
if hasattr(data, "to_matrix"):
# If input is Gate subclass or some other class object that has
# a to_matrix method this will call that method.
data = data.to_matrix()
elif hasattr(data, "to_operator"):
# If input is a BaseOperator subclass this attempts to convert
# the object to an Operator so that we can extract the underlying
# numpy matrix from `Operator.data`.
data = data.to_operator().data
# Convert to numpy array in case not already an array
data = numpy.array(data, dtype=complex)
# Check input is unitary
if not is_unitary_matrix(data):
raise ExtensionError("Input matrix is not unitary.")
# Check input is N-qubit matrix
input_dim, output_dim = data.shape
num_qubits = int(numpy.log2(input_dim))
if input_dim != output_dim or 2**num_qubits != input_dim:
raise ExtensionError("Input matrix is not an N-qubit operator.")
# Store instruction params
super().__init__("unitary", num_qubits, [data], label=label)
def __eq__(self, other):
if not isinstance(other, UnitaryGate):
return False
if self.label != other.label:
return False
# Should we match unitaries as equal if they are equal
# up to global phase?
return matrix_equal(self.params[0], other.params[0], ignore_phase=True)
def __array__(self, dtype=None):
"""Return matrix for the unitary."""
# pylint: disable=unused-argument
return self.params[0]
def inverse(self):
"""Return the adjoint of the unitary."""
return self.adjoint()
def conjugate(self):
"""Return the conjugate of the unitary."""
return UnitaryGate(numpy.conj(self.to_matrix()))
def adjoint(self):
"""Return the adjoint of the unitary."""
return self.transpose().conjugate()
def transpose(self):
"""Return the transpose of the unitary."""
return UnitaryGate(numpy.transpose(self.to_matrix()))
def _define(self):
"""Calculate a subcircuit that implements this unitary."""
if self.num_qubits == 1:
q = QuantumRegister(1, "q")
qc = QuantumCircuit(q, name=self.name)
theta, phi, lam, global_phase = _DECOMPOSER1Q.angles_and_phase(self.to_matrix())
qc._append(UGate(theta, phi, lam), [q[0]], [])
qc.global_phase = global_phase
self.definition = qc
elif self.num_qubits == 2:
self.definition = two_qubit_cnot_decompose(self.to_matrix())
else:
from qiskit.quantum_info.synthesis.qsd import ( # pylint: disable=cyclic-import
qs_decomposition,
)
self.definition = qs_decomposition(self.to_matrix())
def control(self, num_ctrl_qubits=1, label=None, ctrl_state=None):
"""Return controlled version of gate
Args:
num_ctrl_qubits (int): number of controls to add to gate (default=1)
label (str): optional gate label
ctrl_state (int or str or None): The control state in decimal or as a
bit string (e.g. '1011'). If None, use 2**num_ctrl_qubits-1.
Returns:
UnitaryGate: controlled version of gate.
Raises:
QiskitError: Invalid ctrl_state.
ExtensionError: Non-unitary controlled unitary.
"""
mat = self.to_matrix()
cmat = _compute_control_matrix(mat, num_ctrl_qubits, ctrl_state=None)
iso = isometry.Isometry(cmat, 0, 0)
return ControlledGate(
"c-unitary",
num_qubits=self.num_qubits + num_ctrl_qubits,
params=[mat],
label=label,
num_ctrl_qubits=num_ctrl_qubits,
definition=iso.definition,
ctrl_state=ctrl_state,
base_gate=self.copy(),
)
def _qasm2_decomposition(self):
"""Return an unparameterized version of ourselves, so the OQ2 exporter doesn't choke on the
non-standard things in our `params` field."""
out = self.definition.to_gate()
out.name = self.name
return out
def validate_parameter(self, parameter):
"""Unitary gate parameter has to be an ndarray."""
if isinstance(parameter, numpy.ndarray):
return parameter
else:
raise CircuitError(f"invalid param type {type(parameter)} in gate {self.name}")
def unitary(self, obj, qubits, label=None):
"""Apply unitary gate specified by ``obj`` to ``qubits``.
Args:
obj (matrix or Operator): unitary operator.
qubits (Union[int, Tuple[int]]): The circuit qubits to apply the
transformation to.
label (str): unitary name for backend [Default: None].
Returns:
QuantumCircuit: The quantum circuit.
Raises:
ExtensionError: if input data is not an N-qubit unitary operator.
Example:
Apply a gate specified by a unitary matrix to a quantum circuit
.. code-block:: python
from qiskit import QuantumCircuit
matrix = [[0, 0, 0, 1],
[0, 0, 1, 0],
[1, 0, 0, 0],
[0, 1, 0, 0]]
circuit = QuantumCircuit(2)
circuit.unitary(matrix, [0, 1])
"""
gate = UnitaryGate(obj, label=label)
if isinstance(qubits, QuantumRegister):
qubits = qubits[:]
# for single qubit unitary gate, allow an 'int' or a 'list of ints' as qubits.
if gate.num_qubits == 1:
if isinstance(qubits, (int, Qubit)) or len(qubits) > 1:
qubits = [qubits]
return self.append(gate, qubits, [])
QuantumCircuit.unitary = unitary
|
https://github.com/xtophe388/QISKIT
|
xtophe388
|
# Import the QuantumProgram and our configuration
import math
from pprint import pprint
from qiskit import QuantumProgram
import Qconfig
qp = QuantumProgram()
# quantum register for the first circuit
q1 = qp.create_quantum_register('q1', 4)
c1 = qp.create_classical_register('c1', 4)
# quantum register for the second circuit
q2 = qp.create_quantum_register('q2', 2)
c2 = qp.create_classical_register('c2', 2)
# making the first circuits
qc1 = qp.create_circuit('GHZ', [q1], [c1])
qc2 = qp.create_circuit('superposition', [q2], [c2])
qc1.h(q1[0])
qc1.cx(q1[0], q1[1])
qc1.cx(q1[1], q1[2])
qc1.cx(q1[2], q1[3])
for i in range(4):
qc1.measure(q1[i], c1[i])
# making the second circuits
qc2.h(q2)
for i in range(2):
qc2.measure(q2[i], c2[i])
# printing the circuits
print(qp.get_qasm('GHZ'))
print(qp.get_qasm('superposition'))
qobj = qp.compile(['GHZ','superposition'], backend='local_qasm_simulator')
qp.get_execution_list(qobj)
qp.get_execution_list(qobj, verbose=True)
qp.get_compiled_configuration(qobj, 'GHZ', )
print(qp.get_compiled_qasm(qobj, 'GHZ'))
# Coupling map
coupling_map = {0: [1, 2, 3]}
# Place the qubits on a triangle in the bow-tie
initial_layout={("q1", 0): ("q", 0), ("q1", 1): ("q", 1), ("q1", 2): ("q", 2), ("q1", 3): ("q", 3)}
qobj = qp.compile(['GHZ'], backend='local_qasm_simulator', coupling_map=coupling_map, initial_layout=initial_layout)
print(qp.get_compiled_qasm(qobj,'GHZ'))
# Define methods for making QFT circuits
def input_state(circ, q, n):
"""n-qubit input state for QFT that produces output 1."""
for j in range(n):
circ.h(q[j])
circ.u1(math.pi/float(2**(j)), q[j]).inverse()
def qft(circ, q, n):
"""n-qubit QFT on q in circ."""
for j in range(n):
for k in range(j):
circ.cu1(math.pi/float(2**(j-k)), q[j], q[k])
circ.h(q[j])
qp = QuantumProgram()
q = qp.create_quantum_register("q", 3)
c = qp.create_classical_register("c", 3)
qft3 = qp.create_circuit("qft3", [q], [c])
input_state(qft3, q, 3)
qft(qft3, q, 3)
for i in range(3):
qft3.measure(q[i], c[i])
print(qft3.qasm())
result = qp.execute(["qft3"], backend="local_qasm_simulator", shots=1024)
result.get_counts("qft3")
print(result.get_ran_qasm("qft3"))
# Coupling map for ibmqx2 "bowtie"
coupling_map = {0: [1, 2],
1: [2],
2: [],
3: [2, 4],
4: [2]}
# Place the qubits on a triangle in the bow-tie
initial_layout={("q", 0): ("q", 2), ("q", 1): ("q", 3), ("q", 2): ("q", 4)}
result2 = qp.execute(["qft3"], backend="local_qasm_simulator", coupling_map=coupling_map, initial_layout=initial_layout)
result2.get_counts("qft3")
print(result2.get_ran_qasm("qft3"))
# Place the qubits on a linear segment of the ibmqx3
coupling_map = {0: [1], 1: [2], 2: [3], 3: [14], 4: [3, 5], 6: [7, 11], 7: [10], 8: [7], 9: [8, 10], 11: [10], 12: [5, 11, 13], 13: [4, 14], 15: [0, 14]}
initial_layout={("q", 0): ("q", 0), ("q", 1): ("q", 1), ("q", 2): ("q", 2)}
result3 = qp.execute(["qft3"], backend="local_qasm_simulator", coupling_map=coupling_map, initial_layout=initial_layout)
result3.get_counts("qft3")
print(result3.get_ran_qasm("qft3"))
|
https://github.com/PabloMartinezAngerosa/QAOA-uniform-convergence
|
PabloMartinezAngerosa
|
from thirdParty.classical import rand_graph, classical, bitstring_to_path, calc_cost
from utils import mapeo_grafo
import qiskit
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt
from collections import defaultdict
from operator import itemgetter
from scipy.optimize import minimize
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, assemble
from qiskit.quantum_info import Statevector
from qiskit.aqua.algorithms import NumPyEigensolver
from qiskit.quantum_info import Pauli
from qiskit.aqua.operators import op_converter
from qiskit.aqua.operators import WeightedPauliOperator
from qiskit.visualization import plot_histogram
from qiskit.providers.aer.extensions.snapshot_statevector import *
import json
import csv
# Gloabal _lambda variable
_LAMBDA = 10
_SHOTS = 10000
_UNIFORM_CONVERGENCE_SAMPLE = []
# returns the bit index for an alpha and j
def bit(i_city, l_time, num_cities):
return i_city * num_cities + l_time
# e^(cZZ)
def append_zz_term(qc, q_i, q_j, gamma, constant_term):
qc.cx(q_i, q_j)
qc.rz(2*gamma*constant_term,q_j)
qc.cx(q_i, q_j)
# e^(cZ)
def append_z_term(qc, q_i, gamma, constant_term):
qc.rz(2*gamma*constant_term, q_i)
# e^(cX)
def append_x_term(qc,qi,beta):
qc.rx(-2*beta, qi)
def get_not_edge_in(G):
N = G.number_of_nodes()
not_edge = []
for i in range(N):
for j in range(N):
if i != j:
buffer_tupla = (i,j)
in_edges = False
for edge_i, edge_j in G.edges():
if ( buffer_tupla == (edge_i, edge_j) or buffer_tupla == (edge_j, edge_i)):
in_edges = True
if in_edges == False:
not_edge.append((i, j))
return not_edge
def get_classical_simplified_z_term(G, _lambda):
# recorrer la formula Z con datos grafo se va guardando en diccionario que acumula si coinciden los terminos
N = G.number_of_nodes()
E = G.edges()
# z term #
z_classic_term = [0] * N**2
# first term
for l in range(N):
for i in range(N):
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += -1 * _lambda
# second term
for l in range(N):
for j in range(N):
for i in range(N):
if i < j:
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 2
# z_jl
z_jl_index = bit(j, l, N)
z_classic_term[z_jl_index] += _lambda / 2
# third term
for i in range(N):
for l in range(N):
for j in range(N):
if l < j:
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 2
# z_ij
z_ij_index = bit(i, j, N)
z_classic_term[z_ij_index] += _lambda / 2
# fourth term
not_edge = get_not_edge_in(G) # include order tuples ej = (1,0), (0,1)
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 4
# z_j(l+1)
l_plus = (l+1) % N
z_jlplus_index = bit(j, l_plus, N)
z_classic_term[z_jlplus_index] += _lambda / 4
# fifthy term
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# z_il
z_il_index = bit(edge_i, l, N)
z_classic_term[z_il_index] += weight_ij / 4
# z_jlplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_j, l_plus, N)
z_classic_term[z_jlplus_index] += weight_ij / 4
# add order term because G.edges() do not include order tuples #
# z_i'l
z_il_index = bit(edge_j, l, N)
z_classic_term[z_il_index] += weight_ji / 4
# z_j'lplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_i, l_plus, N)
z_classic_term[z_jlplus_index] += weight_ji / 4
return z_classic_term
def get_classical_simplified_zz_term(G, _lambda):
# recorrer la formula Z con datos grafo se va guardando en diccionario que acumula si coinciden los terminos
N = G.number_of_nodes()
E = G.edges()
# zz term #
zz_classic_term = [[0] * N**2 for i in range(N**2) ]
# first term
for l in range(N):
for j in range(N):
for i in range(N):
if i < j:
# z_il
z_il_index = bit(i, l, N)
# z_jl
z_jl_index = bit(j, l, N)
zz_classic_term[z_il_index][z_jl_index] += _lambda / 2
# second term
for i in range(N):
for l in range(N):
for j in range(N):
if l < j:
# z_il
z_il_index = bit(i, l, N)
# z_ij
z_ij_index = bit(i, j, N)
zz_classic_term[z_il_index][z_ij_index] += _lambda / 2
# third term
not_edge = get_not_edge_in(G)
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# z_il
z_il_index = bit(i, l, N)
# z_j(l+1)
l_plus = (l+1) % N
z_jlplus_index = bit(j, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += _lambda / 4
# fourth term
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# z_il
z_il_index = bit(edge_i, l, N)
# z_jlplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_j, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += weight_ij / 4
# add order term because G.edges() do not include order tuples #
# z_i'l
z_il_index = bit(edge_j, l, N)
# z_j'lplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_i, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += weight_ji / 4
return zz_classic_term
def get_classical_simplified_hamiltonian(G, _lambda):
# z term #
z_classic_term = get_classical_simplified_z_term(G, _lambda)
# zz term #
zz_classic_term = get_classical_simplified_zz_term(G, _lambda)
return z_classic_term, zz_classic_term
def get_cost_circuit(G, gamma, _lambda):
N = G.number_of_nodes()
N_square = N**2
qc = QuantumCircuit(N_square,N_square)
z_classic_term, zz_classic_term = get_classical_simplified_hamiltonian(G, _lambda)
# z term
for i in range(N_square):
if z_classic_term[i] != 0:
append_z_term(qc, i, gamma, z_classic_term[i])
# zz term
for i in range(N_square):
for j in range(N_square):
if zz_classic_term[i][j] != 0:
append_zz_term(qc, i, j, gamma, zz_classic_term[i][j])
return qc
def get_mixer_operator(G,beta):
N = G.number_of_nodes()
qc = QuantumCircuit(N**2,N**2)
for n in range(N**2):
append_x_term(qc, n, beta)
return qc
def invert_counts(counts):
return {k[::-1] :v for k,v in counts.items()}
def get_QAOA_circuit(G, beta, gamma, _lambda):
assert(len(beta)==len(gamma))
N = G.number_of_nodes()
qc = QuantumCircuit(N**2,N**2)
# init min mix state
qc.h(range(N**2))
p = len(beta)
for i in range(p):
qc = qc.compose(get_cost_circuit(G, gamma[i], _lambda))
qc = qc.compose(get_mixer_operator(G, beta[i]))
qc.barrier(range(N**2))
qc.snapshot_statevector("final_state")
qc.measure(range(N**2),range(N**2))
return qc
def tsp_obj(x, G):
# obtenemos el valor evaluado en f(x_1, x_2,... x_n)
z_classic_term, zz_classic_term = get_classical_simplified_hamiltonian(G, _LAMBDA)
cost = 0
# z term
for index in range(len(x)):
z = (int(x[index]) * 2 ) -1
cost += z_classic_term[index] * z
## zz term
for i in range(len(x)):
z_1 = (int(x[i]) * 2 ) -1
for j in range(len(x)):
z_2 = (int(x[j]) * 2 ) -1
cost += zz_classic_term[i][j] * z_1 * z_1
return cost
# Sample expectation value
def compute_tsp_energy(counts, G):
energy = 0
get_counts = 0
total_counts = 0
for meas, meas_count in counts.items():
obj_for_meas = tsp_obj(meas, G)
energy += obj_for_meas*meas_count
total_counts += meas_count
return energy/total_counts
# Sample expectation value
def compute_tsp_energy_2(counts, G):
energy = 0
get_counts = 0
total_counts = 0
for meas, meas_count in counts.items():
obj_for_meas = tsp_obj_2(meas, G, _LAMBDA)
energy += obj_for_meas*meas_count
total_counts += meas_count
mean = energy/total_counts
return mean
def tsp_obj_2(x, G,_lambda):
# obtenemos el valor evaluado en f(x_1, x_2,... x_n)
not_edge = get_not_edge_in(G)
N = G.number_of_nodes()
tsp_cost=0
#Distancia
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# x_il
x_il_index = bit(edge_i, l, N)
# x_jlplus
l_plus = (l+1) % N
x_jlplus_index = bit(edge_j, l_plus, N)
tsp_cost+= int(x[x_il_index]) * int(x[x_jlplus_index]) * weight_ij
# add order term because G.edges() do not include order tuples #
# x_i'l
x_il_index = bit(edge_j, l, N)
# x_j'lplus
x_jlplus_index = bit(edge_i, l_plus, N)
tsp_cost += int(x[x_il_index]) * int(x[x_jlplus_index]) * weight_ji
#Constraint 1
for l in range(N):
penal1 = 1
for i in range(N):
x_il_index = bit(i, l, N)
penal1 -= int(x[x_il_index])
tsp_cost += _lambda * penal1**2
#Contstraint 2
for i in range(N):
penal2 = 1
for l in range(N):
x_il_index = bit(i, l, N)
penal2 -= int(x[x_il_index])
tsp_cost += _lambda*penal2**2
#Constraint 3
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# x_il
x_il_index = bit(i, l, N)
# x_j(l+1)
l_plus = (l+1) % N
x_jlplus_index = bit(j, l_plus, N)
tsp_cost += int(x[x_il_index]) * int(x[x_jlplus_index]) * _lambda
return tsp_cost
def get_black_box_objective(G,p):
backend = Aer.get_backend('qasm_simulator')
def f(theta):
beta = theta[:p]
gamma = theta[p:]
_lambda = _LAMBDA # get global _lambda
qc = get_QAOA_circuit(G, beta, gamma, _LAMBDA)
counts = execute(qc, backend, seed_simulator=10, shots=_SHOTS).result().get_counts()
return compute_tsp_energy(invert_counts(counts),G)
return f
def get_black_box_objective_2(G,p):
backend = Aer.get_backend('qasm_simulator')
sim = Aer.get_backend('aer_simulator')
def f(theta):
beta = theta[:p]
gamma = theta[p:]
#print(beta)
_lambda = _LAMBDA # get global _lambda
qc = get_QAOA_circuit(G, beta, gamma, _LAMBDA)
#print(beta)
result = execute(qc, backend, seed_simulator=10, shots=_SHOTS).result()
final_state_vector = result.data()["snapshots"]["statevector"]["final_state"][0]
state_vector = Statevector(final_state_vector)
probabilities = state_vector.probabilities()
# expected value
#print("prob-dict")
#print(state_vector.probabilities_dict())
probabilities_states = invert_counts(state_vector.probabilities_dict())
expected_value = 0
for state,probability in probabilities_states.items():
# get cost from state
cost = tsp_obj_2(state, G, _LAMBDA)
expected_value += cost*probability
#print(probabilities)
counts = result.get_counts()
#qc.save_statevector() # Tell simulator to save statevector
#qobj = assemble(qc) # Create a Qobj from the circuit for the simulator to run
#state_vector = sim.run(qobj).result().get_statevector()
#state_vector = Statevector(state_vector)
#probabilities = state_vector.probabilities()
mean = compute_tsp_energy_2(invert_counts(counts),G)
global _UNIFORM_CONVERGENCE_SAMPLE
_UNIFORM_CONVERGENCE_SAMPLE.append({
"beta" : beta,
"gamma" : gamma,
"counts" : counts,
"mean" : mean,
"probabilities" : probabilities,
"expected_value" : expected_value
})
return mean
return f
def compute_tsp_min_energy_2(counts, G):
energy = 0
get_counts = 0
total_counts = 0
min = 1000000000000000000000
index = 0
min_meas = ""
for meas, meas_count in counts.items():
index = index + 1
obj_for_meas = tsp_obj_2(meas, G, _LAMBDA)
if obj_for_meas < min:
min = obj_for_meas
min_meas = meas
return index, min, min_meas
def compute_tsp_min_energy_1(counts, G):
energy = 0
get_counts = 0
total_counts = 0
min = 1000000000000000000000
index = 0
min_meas = ""
for meas, meas_count in counts.items():
index = index + 1
obj_for_meas = tsp_obj(meas, G)
if obj_for_meas < min:
min = obj_for_meas
min_meas = meas
return index, min, min_meas
def test_counts_2(counts, G):
mean_energy2 = compute_tsp_energy_2(invert_counts(counts),G)
cantidad, min, min_meas = compute_tsp_min_energy_2(invert_counts(counts),G)
print("*************************")
print("En el algoritmo 2 (Marina) el valor esperado como resultado es " + str(mean_energy2))
print("El valor minimo de todos los evaluados es " + str(min) + " se evaluaron un total de " + str(cantidad))
print("El vector minimo es " + min_meas)
def test_counts_1(counts, G):
mean_energy1 = compute_tsp_energy(invert_counts(counts),G)
cantidad, min, min_meas = compute_tsp_min_energy_1(invert_counts(counts),G)
print("*************************")
print("En el algoritmo 1 (Pablo) el valor esperado como resultado es " + str(mean_energy1))
print("El valor minimo de todos los evaluados es " + str(min) + " se evaluaron un total de " + str(cantidad))
print("El vector minimo es " + min_meas)
def test_solution(grafo=None, p=7):
global _UNIFORM_CONVERGENCE_SAMPLE
_UNIFORM_CONVERGENCE_SAMPLE = []
if grafo == None:
cantidad_ciudades = 2
pesos, conexiones = None, None
mejor_camino = None
while not mejor_camino:
pesos, conexiones = rand_graph(cantidad_ciudades)
mejor_costo, mejor_camino = classical(pesos, conexiones, loop=False)
G = mapeo_grafo(conexiones, pesos)
print(mejor_costo)
print(mejor_camino)
print(G.edges())
print(G.nodes())
else:
G = grafo
# beta [0,pi], gamma [0, 2pi]
# create bounds for beta [0,pi]
bounds = []
intial_random = []
for i in range(p):
bounds.append((0, np.pi))
intial_random.append(np.random.uniform(0,np.pi))
# create bounds for gamma [0,2*pi]
for i in range(p):
bounds.append((0, np.pi * 2))
intial_random.append(np.random.uniform(0,2*np.pi))
init_point = np.array(intial_random)
# Pablo Solutions
#obj = get_black_box_objective(G,p)
#res_sample_1 = minimize(obj, init_point,method="COBYLA",options={"maxiter":2500,"disp":True})
#print(res_sample_1)
# Marina Solutions
obj = get_black_box_objective_2(G,p)
res_sample_2 = minimize(obj, init_point, method="COBYLA", options={"maxiter":2500,"disp":True})
print(res_sample_2)
#theta_1 = res_sample_1.x
theta_2 = res_sample_2.x
#beta = theta_1[:p]
#gamma = theta_1[p:]
#_lambda = _LAMBDA # get global _lambda
#qc = get_QAOA_circuit(G, beta, gamma, _LAMBDA)
#backend = Aer.get_backend('qasm_simulator')
#job_1 = execute(qc, backend, shots=_SHOTS)
#resutls_1 = job_1.result().get_counts()
#test_counts_1(resutls_1, G)
beta = theta_2[:p]
gamma = theta_2[p:]
_lambda = _LAMBDA # get global _lambda
qc = get_QAOA_circuit(G, beta, gamma, _LAMBDA)
backend = Aer.get_backend('qasm_simulator')
job_2 = execute(qc, backend, shots=_SHOTS)
resutls_2 = job_2.result().get_counts()
test_counts_2(resutls_2, G)
#print( _UNIFORM_CONVERGENCE_SAMPLE)
return job_2, G, _UNIFORM_CONVERGENCE_SAMPLE
def create_multiple_p_mismo_grafo():
header = ['p', 'state', 'probability', 'mean']
length_p = 10
with open('qaoa_multiple_p.csv', 'w', encoding='UTF8') as f:
writer = csv.writer(f)
# write the header
writer.writerow(header)
first_p = False
UNIFORM_CONVERGENCE_SAMPLE = []
for p in range(length_p):
p = p+1
if first_p == False:
job_2, G, UNIFORM_CONVERGENCE_SAMPLE = test_solution(p=p)
first_p = True
else:
job_2, G, UNIFORM_CONVERGENCE_SAMPLE = test_solution(grafo=G, p=p)
# Sort the JSON data based on the value of the brand key
UNIFORM_CONVERGENCE_SAMPLE.sort(key=lambda x: x["mean"])
mean = UNIFORM_CONVERGENCE_SAMPLE[0]["mean"]
print(mean)
state = 0
for probability in UNIFORM_CONVERGENCE_SAMPLE[0]["probabilities"]:
state += 1
writer.writerow([p,state, probability,mean])
def create_multiple_p_mismo_grafo_multiples_instanncias():
header = ['instance','p','distance', 'mean']
length_p = 4
length_instances = 10
with open('qaoa_multiple_p_distance.csv', 'w', encoding='UTF8') as f:
writer = csv.writer(f)
# write the header
writer.writerow(header)
instance_index = 0
for instance in range(length_instances):
instance_index += 1
first_p = False
UNIFORM_CONVERGENCE_P = []
UNIFORM_CONVERGENCE_SAMPLE = []
for p in range(length_p):
p = p+1
print("p es igual " + str(p))
if first_p == False:
print("Vuelve a llamar a test_solution")
job_2, G, UNIFORM_CONVERGENCE_SAMPLE = test_solution(p=p)
first_p = True
else:
job_2, G, UNIFORM_CONVERGENCE_SAMPLE = test_solution(grafo=G, p=p)
# Sort the JSON data based on the value of the brand key
UNIFORM_CONVERGENCE_SAMPLE.sort(key=lambda x: x["expected_value"])
convergence_min = UNIFORM_CONVERGENCE_SAMPLE[0]
UNIFORM_CONVERGENCE_P.append({
"mean":convergence_min["expected_value"],
"probabilities": convergence_min["probabilities"]
})
print("expected value min con p =" + str(p) + " : " + str(convergence_min["expected_value"]))
cauchy_function_nk = UNIFORM_CONVERGENCE_P[len(UNIFORM_CONVERGENCE_P) - 1]
p_index = 0
for p_state in UNIFORM_CONVERGENCE_P:
p_index += 1
print(p_index)
mean = p_state["mean"]
#print(p_state)
print("expected value min")
print(mean)
distance_p_cauchy_function_nk = np.max(np.abs(cauchy_function_nk["probabilities"] - p_state["probabilities"]))
writer.writerow([instance_index, p_index, distance_p_cauchy_function_nk, mean])
if __name__ == '__main__':
#create_multiple_p_mismo_grafo()
create_multiple_p_mismo_grafo_multiples_instanncias()
def defult_init():
cantidad_ciudades = 2
pesos, conexiones = None, None
mejor_camino = None
while not mejor_camino:
pesos, conexiones = rand_graph(cantidad_ciudades)
mejor_costo, mejor_camino = classical(pesos, conexiones, loop=False)
G = mapeo_grafo(conexiones, pesos)
print(mejor_costo)
print(mejor_camino)
print(G.edges())
print(G.nodes())
print("labels")
labels = nx.get_edge_attributes(G,'weight')
#z_term, zz_term = get_classical_simplified_hamiltonian(G, 1)
#print("z term")
#print(z_term)
#print("*****************")
#print("zz term")
#print(zz_term)
#print(get_QAOA_circuit(G, beta = [2,3], gamma = [4,5], _lambda = 1))
p = 5
obj = get_black_box_objective(G,p)
init_point = np.array([0.8,2.2,0.83,2.15,0.37,2.4,6.1,2.2,3.8,6.1])
#res_sample = minimize(obj, init_point,method="COBYLA",options={"maxiter":2500,"disp":True})
#print(res_sample)
# Marina Solutions
obj = get_black_box_objective_2(G,p)
res_sample = minimize(obj, init_point,method="COBYLA",options={"maxiter":2500,"disp":True})
print(res_sample)
theta_2 = [0.72685401, 2.15678239, 0.86389827, 2.19403121, 0.26916675, 2.19832144, 7.06651453, 3.20333137, 3.81301611, 6.08893568]
theta_1 = [0.90644898, 2.15994212, 1.8609325 , 2.14042604, 1.49126214, 2.4127999, 6.10529434, 2.18238732, 3.84056674, 6.07097744]
beta = theta_1[:p]
gamma = theta_1[p:]
_lambda = _LAMBDA # get global _lambda
qc = get_QAOA_circuit(G, beta, gamma, _LAMBDA)
backend = Aer.get_backend('qasm_simulator')
job = execute(qc, backend)
print(plot_histogram(job.result().get_counts(), color='midnightblue', title="New Histogram"))
beta = theta_2[:p]
gamma = theta_2[p:]
_lambda = _LAMBDA # get global _lambda
qc = get_QAOA_circuit(G, beta, gamma, _LAMBDA)
backend = Aer.get_backend('qasm_simulator')
job = execute(qc, backend)
print(plot_histogram(job.result().get_counts(), color='midnightblue', title="New Histogram"))
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_nature.second_q.drivers import GaussianForcesDriver
# if you ran Gaussian elsewhere and already have the output file
driver = GaussianForcesDriver(logfile="aux_files/CO2_freq_B3LYP_631g.log")
# if you want to run the Gaussian job from Qiskit
# driver = GaussianForcesDriver(
# ['#p B3LYP/6-31g Freq=(Anharm) Int=Ultrafine SCF=VeryTight',
# '',
# 'CO2 geometry optimization B3LYP/6-31g',
# '',
# '0 1',
# 'C -0.848629 2.067624 0.160992',
# 'O 0.098816 2.655801 -0.159738',
# 'O -1.796073 1.479446 0.481721',
# '',
# ''
from qiskit_nature.second_q.problems import HarmonicBasis
basis = HarmonicBasis([2, 2, 2, 2])
from qiskit_nature.second_q.problems import VibrationalStructureProblem
from qiskit_nature.second_q.mappers import DirectMapper
vibrational_problem = driver.run(basis=basis)
vibrational_problem.hamiltonian.truncation_order = 2
main_op, aux_ops = vibrational_problem.second_q_ops()
print(main_op)
qubit_mapper = DirectMapper()
qubit_op = qubit_mapper.map(main_op)
print(qubit_op)
basis = HarmonicBasis([3, 3, 3, 3])
vibrational_problem = driver.run(basis=basis)
vibrational_problem.hamiltonian.truncation_order = 2
main_op, aux_ops = vibrational_problem.second_q_ops()
qubit_mapper = DirectMapper()
qubit_op = qubit_mapper.map(main_op)
print(qubit_op)
# for simplicity, we will use the smaller basis again
vibrational_problem = driver.run(basis=HarmonicBasis([2, 2, 2, 2]))
vibrational_problem.hamiltonian.truncation_order = 2
from qiskit.algorithms.minimum_eigensolvers import NumPyMinimumEigensolver
from qiskit_nature.second_q.algorithms import GroundStateEigensolver
solver = GroundStateEigensolver(
qubit_mapper,
NumPyMinimumEigensolver(filter_criterion=vibrational_problem.get_default_filter_criterion()),
)
result = solver.solve(vibrational_problem)
print(result)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/SaashaJoshi/IBM-Qiskit-Summer-School-2020
|
SaashaJoshi
|
# 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/jcylim/QiskitProject
|
jcylim
|
from qiskit import ClassicalRegister, QuantumRegister
from qiskit import QuantumCircuit, execute
from qiskit.tools.visualization import plot_histogram, circuit_drawer
q = QuantumRegister(2)
c = ClassicalRegister(2)
#quantum circuit is used to perform operations on qubits
qc = QuantumCircuit(q, c)
#hadamard gate (ususally used to create superposition)
qc.h(q[0])
#controllled not gate
qc.cx(q[0], q[1])
#measures the qubits
qc.measure(q, c)
#run simulation (default backend: "local_qasm_simulator")
job_sim = execute(qc, "local_qasm_simulator")
#Simulation Results
sim_result = job_sim.result()
#qubit probability results
print(sim_result.get_counts(qc))
#visualize simulation results in histogram
plot_histogram(sim_result.get_counts(qc))
|
https://github.com/2lambda123/Qiskit-qiskit
|
2lambda123
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# 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=invalid-name,no-name-in-module,ungrouped-imports
"""A circuit library widget module"""
import ipywidgets as wid
from IPython.display import display
from qiskit import QuantumCircuit
from qiskit.utils import optionals as _optionals
from qiskit.utils.deprecation import deprecate_func
@_optionals.HAS_MATPLOTLIB.require_in_call
def _generate_circuit_library_visualization(circuit: QuantumCircuit):
import matplotlib.pyplot as plt
circuit = circuit.decompose()
ops = circuit.count_ops()
num_nl = circuit.num_nonlocal_gates()
_fig, (ax0, ax1) = plt.subplots(2, 1)
circuit.draw("mpl", ax=ax0)
ax1.axis("off")
ax1.grid(visible=None)
ax1.table(
[[circuit.name], [circuit.width()], [circuit.depth()], [sum(ops.values())], [num_nl]],
rowLabels=["Circuit Name", "Width", "Depth", "Total Gates", "Non-local Gates"],
)
plt.tight_layout()
plt.show()
@deprecate_func(
since="0.25.0",
additional_msg="This is unused by Qiskit, and no replacement will be publicly provided.",
)
def circuit_data_table(circuit: QuantumCircuit) -> wid.HTML:
"""Create a HTML table widget for a given quantum circuit.
Args:
circuit: Input quantum circuit.
Returns:
Output widget.
"""
circuit = circuit.decompose()
ops = circuit.count_ops()
num_nl = circuit.num_nonlocal_gates()
html = "<table>"
html += """<style>
table {
font-family: "IBM Plex Sans", Arial, Helvetica, sans-serif;
border-collapse: collapse;
width: 100%;
border-left: 2px solid #212121;
}
th {
text-align: left;
padding: 5px 5px 5px 5px;
width: 100%;
background-color: #988AFC;
color: #fff;
font-size: 14px;
border-left: 2px solid #988AFC;
}
td {
text-align: left;
padding: 5px 5px 5px 5px;
width: 100%;
font-size: 12px;
font-weight: medium;
}
tr:nth-child(even) {background-color: #f6f6f6;}
</style>"""
html += f"<tr><th>{circuit.name}</th><th></tr>"
html += f"<tr><td>Width</td><td>{circuit.width()}</td></tr>"
html += f"<tr><td>Depth</td><td>{circuit.depth()}</td></tr>"
html += f"<tr><td>Total Gates</td><td>{sum(ops.values())}</td></tr>"
html += f"<tr><td>Non-local Gates</td><td>{num_nl}</td></tr>"
html += "</table>"
out_wid = wid.HTML(html)
return out_wid
head_style = (
"font-family: IBM Plex Sans, Arial, Helvetica, sans-serif;"
" font-size: 20px; font-weight: medium;"
)
property_label = wid.HTML(
f"<p style='{head_style}'>Circuit Properties</p>",
layout=wid.Layout(margin="0px 0px 10px 0px"),
)
@deprecate_func(
since="0.25.0",
additional_msg="This is unused by Qiskit, and no replacement will be publicly provided.",
)
def properties_widget(circuit: QuantumCircuit) -> wid.VBox:
"""Create a HTML table widget with header for a given quantum circuit.
Args:
circuit: Input quantum circuit.
Returns:
Output widget.
"""
properties = wid.VBox(
children=[property_label, circuit_data_table(circuit)],
layout=wid.Layout(width="40%", height="auto"),
)
return properties
@_optionals.HAS_PYGMENTS.require_in_call
@deprecate_func(
since="0.25.0",
additional_msg="This is unused by Qiskit, and no replacement will be publicly provided.",
)
def qasm_widget(circuit: QuantumCircuit) -> wid.VBox:
"""Generate a QASM widget with header for a quantum circuit.
Args:
circuit: Input quantum circuit.
Returns:
Output widget.
"""
import pygments
from pygments.formatters import HtmlFormatter
from qiskit.qasm.pygments import QasmHTMLStyle, OpenQASMLexer
qasm_code = circuit.qasm()
code = pygments.highlight(qasm_code, OpenQASMLexer(), HtmlFormatter())
html_style = HtmlFormatter(style=QasmHTMLStyle).get_style_defs(".highlight")
code_style = (
"""
<style>
.highlight
{
font-family: monospace;
font-size: 14px;
line-height: 1.7em;
}
.highlight .err { color: #000000; background-color: #FFFFFF }
%s
</style>
"""
% html_style
)
out = wid.HTML(
code_style + code,
layout=wid.Layout(max_height="500px", height="auto", overflow="scroll scroll"),
)
out_label = wid.HTML(
f"<p style='{head_style}'>OpenQASM</p>",
layout=wid.Layout(margin="0px 0px 10px 0px"),
)
qasm = wid.VBox(
children=[out_label, out],
layout=wid.Layout(
height="auto", max_height="500px", width="60%", margin="0px 0px 0px 20px"
),
)
qasm._code_length = len(qasm_code.split("\n"))
return qasm
@deprecate_func(
since="0.25.0",
additional_msg="This is unused by Qiskit, and no replacement will be publicly provided.",
)
def circuit_diagram_widget() -> wid.Box:
"""Create a circuit diagram widget.
Returns:
Output widget.
"""
# The max circuit height corresponds to a 20Q circuit with flat
# classical register.
top_out = wid.Output(
layout=wid.Layout(
width="100%",
height="auto",
max_height="1000px",
overflow="hidden scroll",
)
)
top = wid.Box(children=[top_out], layout=wid.Layout(width="100%", height="auto"))
return top
@deprecate_func(
since="0.25.0",
additional_msg="This is unused by Qiskit, and no replacement will be publicly provided.",
)
def circuit_library_widget(circuit: QuantumCircuit) -> None:
"""Create a circuit library widget.
Args:
circuit: Input quantum circuit.
"""
qasm_wid = qasm_widget(circuit)
sep_length = str(min(20 * qasm_wid._code_length, 495))
# The separator widget
sep = wid.HTML(
f"<div style='border-left: 3px solid #212121;height: {sep_length}px;'></div>",
layout=wid.Layout(height="auto", max_height="495px", margin="40px 0px 0px 20px"),
)
bottom = wid.HBox(
children=[properties_widget(circuit), sep, qasm_widget(circuit)],
layout=wid.Layout(max_height="550px", height="auto"),
)
top = circuit_diagram_widget()
with top.children[0]:
display(circuit.decompose().draw(output="mpl"))
display(wid.VBox(children=[top, bottom], layout=wid.Layout(width="100%", height="auto")))
|
https://github.com/Chibikuri/qwopt
|
Chibikuri
|
# This cell is added by sphinx-gallery
# It can be customized to whatever you like
%matplotlib inline
import pennylane as qml
import numpy as np
import tensorflow as tf
dev = qml.device('cirq.simulator', wires=4)
def real(angles, **kwargs):
qml.RY(0.27740551, wires=0)
qml.PauliX(wires =0)
qml.CRY(0.20273270, wires=[0, 1])
qml.PauliX(wires =0)
qml.CRY(np.pi/2, wires=[0, 1])
qml.CRY(np.pi/2, wires=[0, 2])
qml.PauliX(wires =0)
qml.CRY(1.42492, wires=[0, 2])
qml.PauliX(wires =0)
def generator(w, **kwargs):
qml.Hadamard(wires=0)
# qml.Hadamard(wires=1)
qml.RX(w[0], wires=0)
qml.RX(w[1], wires=1)
qml.RX(w[2], wires=2)
qml.RY(w[3], wires=0)
qml.RY(w[4], wires=1)
qml.RY(w[5], wires=2)
qml.RZ(w[6], wires=0)
qml.RZ(w[7], wires=1)
qml.RZ(w[8], wires=2)
qml.CNOT(wires=[0, 1])
qml.CNOT(wires=[1, 2])
qml.RX(w[9], wires=0)
qml.RY(w[10], wires=0)
qml.RZ(w[11], wires=0)
qml.RX(w[12], wires=1)
qml.RY(w[13], wires=1)
qml.RZ(w[14], wires=1)
def discriminator(w):
qml.Hadamard(wires=1)
qml.RX(w[0], wires=1)
qml.RX(w[1], wires=2)
qml.RX(w[2], wires=3)
qml.RY(w[3], wires=1)
qml.RY(w[4], wires=2)
qml.RY(w[5], wires=3)
qml.RZ(w[6], wires=1)
qml.RZ(w[7], wires=2)
qml.RZ(w[8], wires=3)
qml.CNOT(wires=[1, 2])
qml.CNOT(wires=[2, 3])
qml.RX(w[9], wires=2)
qml.RY(w[10], wires=2)
qml.RZ(w[11], wires=2)
qml.RX(w[12], wires=3)
qml.RY(w[13], wires=3)
qml.RZ(w[14], wires=3)
@qml.qnode(dev, interface="tf")
def real_disc_circuit(phi, theta, omega, disc_weights):
real([phi, theta, omega])
discriminator(disc_weights)
return qml.expval(qml.PauliZ(3))
@qml.qnode(dev, interface="tf")
def gen_disc_circuit(gen_weights, disc_weights):
generator(gen_weights)
discriminator(disc_weights)
return qml.expval(qml.PauliZ(3))
def prob_real_true(disc_weights):
true_disc_output = real_disc_circuit(phi, theta, omega, disc_weights)
# convert to probability
prob_real_true = (true_disc_output + 1) / 2
return prob_real_true
def prob_fake_true(gen_weights, disc_weights):
fake_disc_output = gen_disc_circuit(gen_weights, disc_weights)
# convert to probability
prob_fake_true = (fake_disc_output + 1) / 2
return prob_fake_true
def disc_cost(disc_weights):
cost = prob_fake_true(gen_weights, disc_weights) - prob_real_true(disc_weights)
return cost
def gen_cost(gen_weights):
return -prob_fake_true(gen_weights, disc_weights)
phi = np.pi / 6
theta = np.pi / 2
omega = np.pi / 7
np.random.seed(0)
eps = 1e-2
init_gen_weights = np.array([np.pi] + [0] * 14) + \
np.random.normal(scale=eps, size=(15,))
init_disc_weights = np.random.normal(size=(15,))
gen_weights = tf.Variable(init_gen_weights)
disc_weights = tf.Variable(init_disc_weights)
print(gen_weights)
opt = tf.keras.optimizers.SGD(0.4)
cost = lambda: disc_cost(disc_weights)
for step in range(100):
opt.minimize(cost, disc_weights)
if step % 5 == 0:
cost_val = cost().numpy()
print("Step {}: cost = {}".format(step, cost_val))
print("Prob(real classified as real): ", prob_real_true(disc_weights).numpy())
print("Prob(fake classified as real): ", prob_fake_true(gen_weights, disc_weights).numpy())
cost = lambda: gen_cost(gen_weights)
for step in range(100):
opt.minimize(cost, gen_weights)
if step % 5 == 0:
cost_val = cost().numpy()
print("Step {}: cost = {}".format(step, cost_val))
print("Prob(fake classified as real): ", prob_fake_true(gen_weights, disc_weights).numpy())
print("Discriminator cost: ", disc_cost(disc_weights).numpy())
obs = [qml.PauliX(0), qml.PauliY(0), qml.PauliZ(0)]
bloch_vector_real = qml.map(real, obs, dev, interface="tf")
bloch_vector_generator = qml.map(generator, obs, dev, interface="tf")
print("Real Bloch vector: {}".format(bloch_vector_real([phi, theta, omega])))
print("Generator Bloch vector: {}".format(bloch_vector_generator(gen_weights)))
print(gen_weights)
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer
w = gen_weights.numpy()
q = QuantumRegister(3)
c = ClassicalRegister(3)
qc = QuantumCircuit(q, c)
qc.h(q[0])
qc.rx(w[0], q[0])
qc.rx(w[1], q[1])
qc.rx(w[2], q[2])
qc.ry(w[3], q[0])
qc.ry(w[4], q[1])
qc.ry(w[5], q[2])
qc.rz(w[6], q[0])
qc.rz(w[7], q[1])
qc.rz(w[8], q[2])
qc.cx(q[0], q[1])
qc.cx(q[1], q[2])
qc.rx(w[9], q[0])
qc.ry(w[10], q[0])
qc.rz(w[11], q[0])
qc.rx(w[12], q[1])
qc.ry(w[13], q[1])
qc.rz(w[14], q[1])
job = execute(qc, backend=Aer.get_backend("statevector_simulator"))
vec = job.result().get_statevector()
for i in vec:
print(i)
|
https://github.com/albertnieto/mucomcu04
|
albertnieto
|
%%capture
%pip install qiskit
%pip install qiskit_ibm_provider
%pip install qiskit-aer
# Importing standard Qiskit libraries
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, QuantumCircuit, transpile, Aer
from qiskit_ibm_provider import IBMProvider
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from qiskit.circuit.library import C3XGate
# Importing matplotlib
import matplotlib.pyplot as plt
# Importing Numpy, Cmath and math
import numpy as np
import os, math, cmath
from numpy import pi
# Other imports
from IPython.display import display, Math, Latex
# Specify the path to your env file
env_file_path = 'config.env'
# Load environment variables from the file
os.environ.update(line.strip().split('=', 1) for line in open(env_file_path) if '=' in line and not line.startswith('#'))
# Load IBM Provider API KEY
IBMP_API_KEY = os.environ.get('IBMP_API_KEY')
# Loading your IBM Quantum account(s)
IBMProvider.save_account(IBMP_API_KEY, overwrite=True)
# Run the quantum circuit on a statevector simulator backend
backend = Aer.get_backend('statevector_simulator')
qc_b1 = QuantumCircuit(2, 2)
qc_b1.h(0)
qc_b1.cx(0, 1)
qc_b1.draw(output='mpl', style="iqp")
sv = backend.run(qc_b1).result().get_statevector()
sv.draw(output='latex', prefix = "|\Phi^+\\rangle = ")
qc_b2 = QuantumCircuit(2, 2)
qc_b2.x(0)
qc_b2.h(0)
qc_b2.cx(0, 1)
qc_b2.draw(output='mpl', style="iqp")
sv = backend.run(qc_b2).result().get_statevector()
sv.draw(output='latex', prefix = "|\Phi^-\\rangle = ")
qc_b2 = QuantumCircuit(2, 2)
qc_b2.h(0)
qc_b2.cx(0, 1)
qc_b2.z(0)
qc_b2.draw(output='mpl', style="iqp")
sv = backend.run(qc_b2).result().get_statevector()
sv.draw(output='latex', prefix = "|\Phi^-\\rangle = ")
qc_b3 = QuantumCircuit(2, 2)
qc_b3.x(1)
qc_b3.h(0)
qc_b3.cx(0, 1)
qc_b3.draw(output='mpl', style="iqp")
sv = backend.run(qc_b3).result().get_statevector()
sv.draw(output='latex', prefix = "|\Psi^+\\rangle = ")
qc_b3 = QuantumCircuit(2, 2)
qc_b3.h(0)
qc_b3.cx(0, 1)
qc_b3.x(0)
qc_b3.draw(output='mpl', style="iqp")
sv = backend.run(qc_b3).result().get_statevector()
sv.draw(output='latex', prefix = "|\Psi^+\\rangle = ")
qc_b4 = QuantumCircuit(2, 2)
qc_b4.x(0)
qc_b4.h(0)
qc_b4.x(1)
qc_b4.cx(0, 1)
qc_b4.draw(output='mpl', style="iqp")
sv = backend.run(qc_b4).result().get_statevector()
sv.draw(output='latex', prefix = "|\Psi^-\\rangle = ")
qc_b4 = QuantumCircuit(2, 2)
qc_b4.h(0)
qc_b4.cx(0, 1)
qc_b4.x(0)
qc_b4.z(1)
qc_b4.draw(output='mpl', style="iqp")
sv = backend.run(qc_b4).result().get_statevector()
sv.draw(output='latex', prefix = "|\Psi^-\\rangle = ")
def sv_latex_from_qc(qc, backend):
sv = backend.run(qc).result().get_statevector()
return sv.draw(output='latex')
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(0)
sv_latex_from_qc(qc_ej2, backend)
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(1)
sv_latex_from_qc(qc_ej2, backend)
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(0)
qc_ej2.x(1)
sv_latex_from_qc(qc_ej2, backend)
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(2)
sv_latex_from_qc(qc_ej2, backend)
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(0)
qc_ej2.x(2)
sv_latex_from_qc(qc_ej2, backend)
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(0)
qc_ej2.x(2)
sv_latex_from_qc(qc_ej2, backend)
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(0)
qc_ej2.x(1)
qc_ej2.x(2)
sv_latex_from_qc(qc_ej2, backend)
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(3)
sv_latex_from_qc(qc_ej2, backend)
def circuit_adder (num):
if num<1 or num>8:
raise ValueError("Out of range") ## El enunciado limita el sumador a los valores entre 1 y 8. Quitar esta restricciΓ³n serΓa directo.
# DefiniciΓ³n del circuito base que vamos a construir
qreg_q = QuantumRegister(4, 'q')
creg_c = ClassicalRegister(1, 'c')
circuit = QuantumCircuit(qreg_q, creg_c)
qbit_position = 0
for element in reversed(np.binary_repr(num)):
if (element=='1'):
circuit.barrier()
match qbit_position:
case 0: # +1
circuit.append(C3XGate(), [qreg_q[0], qreg_q[1], qreg_q[2], qreg_q[3]])
circuit.ccx(qreg_q[0], qreg_q[1], qreg_q[2])
circuit.cx(qreg_q[0], qreg_q[1])
circuit.x(qreg_q[0])
case 1: # +2
circuit.ccx(qreg_q[1], qreg_q[2], qreg_q[3])
circuit.cx(qreg_q[1], qreg_q[2])
circuit.x(qreg_q[1])
case 2: # +4
circuit.cx(qreg_q[2], qreg_q[3])
circuit.x(qreg_q[2])
case 3: # +8
circuit.x(qreg_q[3])
qbit_position+=1
return circuit
add_3 = circuit_adder(3)
add_3.draw(output='mpl', style="iqp")
qc_test_2 = QuantumCircuit(4, 4)
qc_test_2.x(1)
qc_test_2_plus_3 = qc_test_2.compose(add_3)
qc_test_2_plus_3.draw(output='mpl', style="iqp")
sv_latex_from_qc(qc_test_2_plus_3, backend)
qc_test_7 = QuantumCircuit(4, 4)
qc_test_7.x(0)
qc_test_7.x(1)
qc_test_7.x(2)
qc_test_7_plus_8 = qc_test_7.compose(circuit_adder(8))
sv_latex_from_qc(qc_test_7_plus_8, backend)
#qc_test_7_plus_8.draw()
theta = 6.544985
phi = 2.338741
lmbda = 0
alice_1 = 0
alice_2 = 1
bob_1 = 2
qr_alice = QuantumRegister(2, 'Alice')
qr_bob = QuantumRegister(1, 'Bob')
cr = ClassicalRegister(3, 'c')
qc_ej3 = QuantumCircuit(qr_alice, qr_bob, cr)
qc_ej3.barrier(label='1')
qc_ej3.u(theta, phi, lmbda, alice_1);
qc_ej3.barrier(label='2')
qc_ej3.h(alice_2)
qc_ej3.cx(alice_2, bob_1);
qc_ej3.barrier(label='3')
qc_ej3.cx(alice_1, alice_2)
qc_ej3.h(alice_1);
qc_ej3.barrier(label='4')
qc_ej3.measure([alice_1, alice_2], [alice_1, alice_2]);
qc_ej3.barrier(label='5')
qc_ej3.x(bob_1).c_if(alice_2, 1)
qc_ej3.z(bob_1).c_if(alice_1, 1)
qc_ej3.measure(bob_1, bob_1);
qc_ej3.draw(output='mpl', style="iqp")
result = backend.run(qc_ej3, shots=1024).result()
counts = result.get_counts()
plot_histogram(counts)
sv_0 = np.array([1, 0])
sv_1 = np.array([0, 1])
def find_symbolic_representation(value, symbolic_constants={1/np.sqrt(2): '1/β2'}, tolerance=1e-10):
"""
Check if the given numerical value corresponds to a symbolic constant within a specified tolerance.
Parameters:
- value (float): The numerical value to check.
- symbolic_constants (dict): A dictionary mapping numerical values to their symbolic representations.
Defaults to {1/np.sqrt(2): '1/β2'}.
- tolerance (float): Tolerance for comparing values with symbolic constants. Defaults to 1e-10.
Returns:
str or float: If a match is found, returns the symbolic representation as a string
(prefixed with '-' if the value is negative); otherwise, returns the original value.
"""
for constant, symbol in symbolic_constants.items():
if np.isclose(abs(value), constant, atol=tolerance):
return symbol if value >= 0 else '-' + symbol
return value
def array_to_dirac_notation(array, tolerance=1e-10):
"""
Convert a complex-valued array representing a quantum state in superposition
to Dirac notation.
Parameters:
- array (numpy.ndarray): The complex-valued array representing
the quantum state in superposition.
- tolerance (float): Tolerance for considering amplitudes as negligible.
Returns:
str: The Dirac notation representation of the quantum state.
"""
# Ensure the statevector is normalized
array = array / np.linalg.norm(array)
# Get the number of qubits
num_qubits = int(np.log2(len(array)))
# Find indices where amplitude is not negligible
non_zero_indices = np.where(np.abs(array) > tolerance)[0]
# Generate Dirac notation terms
terms = [
(find_symbolic_representation(array[i]), format(i, f"0{num_qubits}b"))
for i in non_zero_indices
]
# Format Dirac notation
dirac_notation = " + ".join([f"{amplitude}|{binary_rep}β©" for amplitude, binary_rep in terms])
return dirac_notation
def array_to_matrix_representation(array):
"""
Convert a one-dimensional array to a column matrix representation.
Parameters:
- array (numpy.ndarray): The one-dimensional array to be converted.
Returns:
numpy.ndarray: The column matrix representation of the input array.
"""
# Replace symbolic constants with their representations
matrix_representation = np.array([find_symbolic_representation(value) or value for value in array])
# Return the column matrix representation
return matrix_representation.reshape((len(matrix_representation), 1))
def array_to_dirac_and_matrix_latex(array):
"""
Generate LaTeX code for displaying both the matrix representation and Dirac notation
of a quantum state.
Parameters:
- array (numpy.ndarray): The complex-valued array representing the quantum state.
Returns:
Latex: A Latex object containing LaTeX code for displaying both representations.
"""
matrix_representation = array_to_matrix_representation(array)
latex = "Matrix representation\n\\begin{bmatrix}\n" + \
"\\\\\n".join(map(str, matrix_representation.flatten())) + \
"\n\\end{bmatrix}\n"
latex += f'Dirac Notation:\n{array_to_dirac_notation(array)}'
return Latex(latex)
sv_b1 = np.kron(sv_0, sv_0)
array_to_dirac_and_matrix_latex(sv_b1)
sv_b1 = (np.kron(sv_0, sv_0) + np.kron(sv_0, sv_1)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b1)
sv_b1 = (np.kron(sv_0, sv_0) + np.kron(sv_1, sv_1)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b1)
sv_b2 = np.kron(sv_0, sv_0)
array_to_dirac_and_matrix_latex(sv_b2)
sv_b2 = (np.kron(sv_0, sv_0) + np.kron(sv_0, sv_1)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b2)
sv_b2 = (np.kron(sv_0, sv_0) + np.kron(sv_1, sv_1)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b2)
sv_b2 = (np.kron(sv_0, sv_0) - np.kron(sv_1, sv_1)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b2)
sv_b3 = np.kron(sv_0, sv_0)
array_to_dirac_and_matrix_latex(sv_b3)
sv_b3 = np.kron(sv_0, sv_1)
array_to_dirac_and_matrix_latex(sv_b3)
sv_b3 = (np.kron(sv_0, sv_0) - np.kron(sv_0, sv_1)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b3)
sv_b3 = (np.kron(sv_0, sv_1) - np.kron(sv_1, sv_0)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b3)
sv_b3 = (np.kron(sv_0, sv_1) + np.kron(sv_1, sv_0)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b3)
sv_b4 = np.kron(sv_0, sv_0)
array_to_dirac_and_matrix_latex(sv_b4)
sv_b4 = np.kron(sv_0, sv_1)
array_to_dirac_and_matrix_latex(sv_b4)
sv_b4 = (np.kron(sv_0, sv_0) - np.kron(sv_0, sv_1)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b4)
sv_b4 = (np.kron(sv_0, sv_1) - np.kron(sv_1, sv_0)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b4)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_nature.problems.second_quantization.lattice.lattices import LineLattice
from qiskit_nature.problems.second_quantization.lattice.models import FermiHubbardModel
line = LineLattice(2)
fermi = FermiHubbardModel.uniform_parameters(line, 2.0, 4.0, 3.0)
print(fermi.second_q_ops()) # Note: the trailing `s`
from qiskit_nature.second_q.hamiltonians.lattices import LineLattice
from qiskit_nature.second_q.hamiltonians import FermiHubbardModel
line = LineLattice(2)
fermi = FermiHubbardModel(line.uniform_parameters(2.0, 4.0), 3.0)
print(fermi.second_q_op()) # Note: NO trailing `s`
import numpy as np
from qiskit_nature.problems.second_quantization.lattice.models import FermiHubbardModel
interaction = np.array([[4.0, 2.0], [2.0, 4.0]])
fermi = FermiHubbardModel.from_parameters(interaction, 3.0)
print(fermi.second_q_ops()) # Note: the trailing `s`
import numpy as np
from qiskit_nature.second_q.hamiltonians.lattices import Lattice
from qiskit_nature.second_q.hamiltonians import FermiHubbardModel
interaction = np.array([[4.0, 2.0], [2.0, 4.0]])
lattice = Lattice.from_adjacency_matrix(interaction)
fermi = FermiHubbardModel(lattice, 3.0)
print(fermi.second_q_op()) # Note: NO trailing `s`
from qiskit_nature.problems.second_quantization.lattice.lattices import LineLattice
from qiskit_nature.problems.second_quantization.lattice.models import IsingModel
line = LineLattice(2)
ising = IsingModel.uniform_parameters(line, 2.0, 4.0)
print(ising.second_q_ops()) # Note: the trailing `s`
from qiskit_nature.second_q.hamiltonians.lattices import LineLattice
from qiskit_nature.second_q.hamiltonians import IsingModel
line = LineLattice(2)
ising = IsingModel(line.uniform_parameters(2.0, 4.0))
print(ising.second_q_op()) # Note: NO trailing `s`
import numpy as np
from qiskit_nature.problems.second_quantization.lattice.models import IsingModel
interaction = np.array([[4.0, 2.0], [2.0, 4.0]])
ising = IsingModel.from_parameters(interaction)
print(ising.second_q_ops()) # Note: the trailing `s`
import numpy as np
from qiskit_nature.second_q.hamiltonians.lattices import Lattice
from qiskit_nature.second_q.hamiltonians import IsingModel
interaction = np.array([[4.0, 2.0], [2.0, 4.0]])
lattice = Lattice.from_adjacency_matrix(interaction)
ising = IsingModel(lattice)
print(ising.second_q_op()) # Note: NO trailing `s`
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import numpy as np
from qiskit import QuantumCircuit
from qiskit.providers.fake_provider import FakeVigoV2
backend = FakeVigoV2()
qc = QuantumCircuit(2, 1)
qc.h(0)
qc.x(1)
qc.cp(np.pi/4, 0, 1)
qc.h(0)
qc.measure([0], [0])
qc.draw(output='mpl')
|
https://github.com/QPong/qpong-livestream
|
QPong
|
import pygame
import qiskit
from . import globals
class Computer:
def __init__(self):
pass
def update(self):
pass
class ClassicalComputer(Computer):
def __init__(self, paddle):
self.paddle = paddle
self.score = 0
self.speed = 3
def update(self, ball):
if self.paddle.rect.centery - ball.rect.centery > 0:
self.paddle.rect.y -= self.speed
else:
self.paddle.rect.y += self.speed
if pygame.sprite.collide_mask(ball, self.paddle):
ball.bounce()
class QuantumComputer(Computer):
def __init__(self, quantum_paddles, circuit_grid) -> None:
self.paddles = quantum_paddles.paddles
self.score = 0
self.circuit_grid = circuit_grid
self.measured_state = 0
self.last_measurement_time = pygame.time.get_ticks() - globals.MEASUREMENT_COOLDOWN_TIME
def update(self, ball):
current_time = pygame.time.get_ticks()
# trigger measurement when the ball is close to quantum paddles
if 88 < ball.rect.x / globals.WIDTH_UNIT < 92:
if current_time - self.last_measurement_time > globals.MEASUREMENT_COOLDOWN_TIME:
self.update_after_measurement()
self.last_measurement_time = pygame.time.get_ticks()
else:
self.update_before_measurement()
if pygame.sprite.collide_mask(ball, self.paddles[self.measured_state]):
ball.bounce()
def update_before_measurement(self):
simulator = qiskit.BasicAer.get_backend("statevector_simulator")
circuit = self.circuit_grid.model.compute_circuit()
transpiled_circuit = qiskit.transpile(circuit, simulator)
statevector = simulator.run(transpiled_circuit, shots=100).result().get_statevector()
for basis_state, amplitude in enumerate(statevector):
self.paddles[basis_state].image.set_alpha(abs(amplitude)**2*255)
def update_after_measurement(self):
simulator = qiskit.BasicAer.get_backend("qasm_simulator")
circuit = self.circuit_grid.model.compute_circuit()
circuit.measure_all()
transpiled_circuit = qiskit.transpile(circuit, simulator)
counts = simulator.run(transpiled_circuit, shots=1).result().get_counts()
self.measured_state = int(list(counts.keys())[0], 2)
for paddle in self.paddles:
paddle.image.set_alpha(0)
self.paddles[self.measured_state].image.set_alpha(255)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.utils import algorithm_globals
from qiskit.algorithms.minimum_eigensolvers import QAOA, NumPyMinimumEigensolver
from qiskit.algorithms.optimizers import COBYLA
from qiskit.primitives import Sampler
from qiskit_optimization.algorithms import (
MinimumEigenOptimizer,
RecursiveMinimumEigenOptimizer,
SolutionSample,
OptimizationResultStatus,
)
from qiskit_optimization import QuadraticProgram
from qiskit.visualization import plot_histogram
from typing import List, Tuple
import numpy as np
# create a QUBO
qubo = QuadraticProgram()
qubo.binary_var("x")
qubo.binary_var("y")
qubo.binary_var("z")
qubo.minimize(linear=[1, -2, 3], quadratic={("x", "y"): 1, ("x", "z"): -1, ("y", "z"): 2})
print(qubo.prettyprint())
op, offset = qubo.to_ising()
print("offset: {}".format(offset))
print("operator:")
print(op)
qp = QuadraticProgram()
qp.from_ising(op, offset, linear=True)
print(qp.prettyprint())
algorithm_globals.random_seed = 10598
qaoa_mes = QAOA(sampler=Sampler(), optimizer=COBYLA(), initial_point=[0.0, 0.0])
exact_mes = NumPyMinimumEigensolver()
qaoa = MinimumEigenOptimizer(qaoa_mes) # using QAOA
exact = MinimumEigenOptimizer(exact_mes) # using the exact classical numpy minimum eigen solver
exact_result = exact.solve(qubo)
print(exact_result.prettyprint())
qaoa_result = qaoa.solve(qubo)
print(qaoa_result.prettyprint())
print("variable order:", [var.name for var in qaoa_result.variables])
for s in qaoa_result.samples:
print(s)
def get_filtered_samples(
samples: List[SolutionSample],
threshold: float = 0,
allowed_status: Tuple[OptimizationResultStatus] = (OptimizationResultStatus.SUCCESS,),
):
res = []
for s in samples:
if s.status in allowed_status and s.probability > threshold:
res.append(s)
return res
filtered_samples = get_filtered_samples(
qaoa_result.samples, threshold=0.005, allowed_status=(OptimizationResultStatus.SUCCESS,)
)
for s in filtered_samples:
print(s)
fvals = [s.fval for s in qaoa_result.samples]
probabilities = [s.probability for s in qaoa_result.samples]
np.mean(fvals)
np.std(fvals)
samples_for_plot = {
" ".join(f"{qaoa_result.variables[i].name}={int(v)}" for i, v in enumerate(s.x)): s.probability
for s in filtered_samples
}
samples_for_plot
plot_histogram(samples_for_plot)
rqaoa = RecursiveMinimumEigenOptimizer(qaoa, min_num_vars=1, min_num_vars_optimizer=exact)
rqaoa_result = rqaoa.solve(qubo)
print(rqaoa_result.prettyprint())
filtered_samples = get_filtered_samples(
rqaoa_result.samples, threshold=0.005, allowed_status=(OptimizationResultStatus.SUCCESS,)
)
samples_for_plot = {
" ".join(f"{rqaoa_result.variables[i].name}={int(v)}" for i, v in enumerate(s.x)): s.probability
for s in filtered_samples
}
samples_for_plot
plot_histogram(samples_for_plot)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/sarthag/Quantum-Algos-using-Qiskit
|
sarthag
|
# initialization
import numpy as np
# importing Qiskit
from qiskit import IBMQ, BasicAer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, execute, Aer
from qiskit.tools.jupyter import *
provider = IBMQ.load_account()
# import basic plot tools
from qiskit.visualization import plot_histogram
def initialize(circuit, n, m):
circuit.h(range(n)) # Hadamard transform on measurment register
circuit.x(n+m-1) # X gate on last qubit
def c_amod15(a, x):
if a not in [2,7,8,11,13]:
raise ValueError("'a' must be 2,7,8,11 or 13") # remember that a needs to be co-prime with N
unitary = QuantumCircuit(4)
for iteration in range(x):
# bitwise arithmetic to represent modular exponentiation function
if a in [2,13]:
unitary.swap(0,1)
unitary.swap(1,2)
unitary.swap(2,3)
if a in [7,8]:
unitary.swap(2,3)
unitary.swap(1,2)
unitary.swap(0,1)
if a == 11:
unitary.swap(1,3)
unitary.swap(0,2)
if a in [7,11,13]:
for q in range(4):
unitary.x(q)
unitary = unitary.to_gate()
unitary.name = "%i^%i mod 15" % (a, x)
# But we need to make it a controlled operation for phase kickback
c_unitary = unitary.control()
return c_unitary
def modular_exponentiation(circuit, n, m, a):
for exp in range(n):
exponent = 2**exp
circuit.append(a_x_mod15(a, exponent), [exp] + list(range(n, n+m)))
from qiskit.circuit.library import QFT
def apply_iqft(circuit, measurement_qubits):
circuit.append(QFT( len(measurement_qubits), do_swaps=False).inverse(), measurement_qubits)
def shor_algo(n, m, a):
# set up the circuit
circ = QuantumCircuit(n+m, n)
# initialize the registers
initialize(circ, n, m)
circ.barrier()
# map modular exponentiation problem onto qubits
modular_exponentiation(circ, n, m, a)
circ.barrier()
# apply inverse QFT -- expose period
apply_iqft(circ, range(n))
# measure the measurement register
circ.measure(range(n), range(n))
return circ
n = 4; m = 4; a = 11
mycircuit = shor_algo(n, m, a)
mycircuit.draw('mpl')
simulator = Aer.get_backend('qasm_simulator')
counts = execute(mycircuit, backend=simulator, shots=1024).result().get_counts(mycircuit)
plot_histogram(counts)
for measured_value in counts:
print(f"Measured {int(measured_value[::-1], 2)}")
from math import gcd
from math import sqrt
from itertools import count, islice
for measured_value in counts:
measured_value_decimal = int(measured_value[::-1], 2)
print(f"Measured {measured_value_decimal}")
if measured_value_decimal % 2 != 0:
print("Failed. Measured value is not an even number")
continue
x = int((a ** (measured_value_decimal/2)) % 15)
if (x + 1) % 15 == 0:
print("Failed. x + 1 = 0 (mod N) where x = a^(r/2) (mod N)")
continue
guesses = gcd(x + 1, 15), gcd(x - 1, 15)
print(guesses)
def is_prime(n):
return n > 1 and all(n % i for i in islice(count(2), int(sqrt(n)-1)))
if is_prime(guesses[0]) and is_prime(guesses[1]):
print(f"**The prime factors are {guesses[0]} and {guesses[1]}**")
|
https://github.com/acfilok96/Quantum-Computation
|
acfilok96
|
import qiskit
print(qiskit.__version__)
from qiskit_machine_learning.datasets import ad_hoc_data
adhoc_dimension = 2
train_features, train_labels, test_features, test_labels, adhoc_total = ad_hoc_data(training_size = 20, test_size = 5,
n = adhoc_dimension, gap=0.3,
plot_data =False, one_hot=False,
include_sample_total=True)
import numpy
print(numpy.array(adhoc_total).shape)
print("train data shape: ", train_features.shape,"\ttrain labels shape: ", train_labels.shape)
print("test data shape: ", test_features.shape,"\ttest labels shape: ", test_labels.shape)
print('train data:\n',train_features[:5])
print('\ntrain label:\n',train_labels[:5])
# plot_adhoc_dataset(train_features, train_labels, test_features, test_labels, adhoc_total)
from qiskit import Aer
from qiskit.utils import QuantumInstance
seed=20
quantum_instance = QuantumInstance(Aer.get_backend("qasm_simulator"), shots=1024,
seed_simulator=seed, seed_transpiler=seed)
from qiskit.circuit.library import ZFeatureMap
from qiskit_machine_learning.kernels import QuantumKernel
z_feature_map = ZFeatureMap(feature_dimension=adhoc_dimension, reps=2)
z_kernel = QuantumKernel(feature_map = z_feature_map, quantum_instance=quantum_instance)
# z_feature_map.draw(output='mpl', scale=2)
z_feature_map.decompose().draw(output='mpl', scale=2)
from sklearn.svm import SVC
svc = SVC(kernel=z_kernel.evaluate)
svc.fit(train_features, train_labels)
score = svc.score(test_features, test_labels)
print('Callable kernel with ZFeatureMap classification test score: ', score)
prediction = svc.predict(test_features)
print(prediction)
from qiskit.circuit.library import ZZFeatureMap
zz_feature_map = ZZFeatureMap(feature_dimension=adhoc_dimension, reps=2, entanglement='linear')
zz_kernel = QuantumKernel(feature_map = zz_feature_map, quantum_instance=quantum_instance)
zz_feature_map.decompose().draw(output='mpl', scale=2)
from sklearn.svm import SVC
svc = SVC(kernel=zz_kernel.evaluate)
svc.fit(train_features, train_labels)
score = svc.score(test_features, test_labels)
print('Callable kernel with ZZFeatureMap classification test score: ', score)
prediction = svc.predict(test_features)
print(prediction)
from qiskit_machine_learning.algorithms import QSVC
qsvc = QSVC()
qsvc.quantum_kernel.quantum_instance = quantum_instance
qsvc.fit(train_features, train_labels)
score = qsvc.score(test_features, test_labels)
print('QSVC classification test score: ', score)
prediction = qsvc.predict(test_features)
print(prediction)
from qiskit.circuit.library import ZFeatureMap
from qiskit_machine_learning.kernels import QuantumKernel
# here feature_dimension = 2 and reps = 1
adhoc_dimension = 2
z_feature_map = ZFeatureMap(feature_dimension=adhoc_dimension, reps=1)
z_kernel = QuantumKernel(feature_map = z_feature_map, quantum_instance=quantum_instance)
z_feature_map.decompose().draw(output='mpl', scale=2)
from qiskit.circuit.library import ZFeatureMap
from qiskit_machine_learning.kernels import QuantumKernel
# here feature_dimension = 2 and reps = 2
adhoc_dimension = 2
z_feature_map = ZFeatureMap(feature_dimension=adhoc_dimension, reps=2)
z_kernel = QuantumKernel(feature_map = z_feature_map, quantum_instance=quantum_instance)
z_feature_map.decompose().draw(output='mpl', scale=2)
from qiskit.circuit.library import ZFeatureMap
from qiskit_machine_learning.kernels import QuantumKernel
# here feature_dimension = 3 and reps = 4
adhoc_dimension = 3
z_feature_map = ZFeatureMap(feature_dimension=adhoc_dimension, reps=4)
z_kernel = QuantumKernel(feature_map = z_feature_map, quantum_instance=quantum_instance)
z_feature_map.decompose().draw(output='mpl', scale=2)
# same happens for ZZFeatureMap
from qiskit.circuit.library import ZZFeatureMap
adhoc_dimension=2
zz_feature_map = ZZFeatureMap(feature_dimension=adhoc_dimension, reps=1, entanglement='linear')
zz_kernel = QuantumKernel(feature_map = zz_feature_map, quantum_instance=quantum_instance)
zz_feature_map.decompose().draw(output='mpl', scale=2)
# same happens for ZZFeatureMap
from qiskit.circuit.library import ZZFeatureMap
adhoc_dimension=2
zz_feature_map = ZZFeatureMap(feature_dimension=adhoc_dimension, reps=2, entanglement='linear')
zz_kernel = QuantumKernel(feature_map = zz_feature_map, quantum_instance=quantum_instance)
zz_feature_map.decompose().draw(output='mpl', scale=2)
# same happens for ZZFeatureMap
from qiskit.circuit.library import ZZFeatureMap
adhoc_dimension=3
zz_feature_map = ZZFeatureMap(feature_dimension=adhoc_dimension, reps=1, entanglement='linear')
zz_kernel = QuantumKernel(feature_map = zz_feature_map, quantum_instance=quantum_instance)
zz_feature_map.decompose().draw(output='mpl', scale=2)
# same happens for ZZFeatureMap
from qiskit.circuit.library import ZZFeatureMap
adhoc_dimension=3
zz_feature_map = ZZFeatureMap(feature_dimension=adhoc_dimension, reps=2, entanglement='linear')
zz_kernel = QuantumKernel(feature_map = zz_feature_map, quantum_instance=quantum_instance)
zz_feature_map.decompose().draw(output='mpl', scale=2)
|
https://github.com/bayesian-randomized-benchmarking/qiskit-advocates-bayes-RB
|
bayesian-randomized-benchmarking
|
import numpy as np
import time
from qiskit_experiments.library import StandardRB, InterleavedRB
from qiskit_experiments.framework import ParallelExperiment
from qiskit_experiments.library.randomized_benchmarking import RBUtils
import qiskit.circuit.library as circuits
# for retrieving gate Reference
from datetime import datetime
import qiskit.providers.aer.noise.device as dv
# import the bayesian packages
import pymc3 as pm
import arviz as az
import qiskit_bayesian_fitter as bf
simulation = True # make your choice here
if simulation:
from qiskit.providers.aer import AerSimulator
from qiskit.test.mock import FakeParis
backend = AerSimulator.from_backend(FakeParis())
else:
from qiskit import IBMQ
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
backend = provider.get_backend('ibmq_bogota') # type here hardware backend
# describe RB experiment (accept 1-qubit or 2-qubit interleaved gate)
is_1_qubit = True
if is_1_qubit:
interleaved_gate = "x"
interleaved_circuit = circuits.XGate()
qubits = [0]
lengths = np.arange(1, 2500, 250)
testval_s = 0.001
upper_s = 0.004
lower_s = 0.0005
alpha_Gamma = 10
beta_Gamma = 10000
else:
interleaved_gate = "cx"
interleaved_circuit = circuits.CXGate()
qubits = [1,4]
lengths = np.arange(1, 200, 15)
testval_s = 0.0025
upper_s = 0.005
lower_s = 0.0005
alpha_Gamma = 5
beta_Gamma = 2000
num_samples = 10
seed = 194606
# get the backend's referencevalue
t = None # enter t in datetime format if necessary
# use properties(datetime=t) if t is defined
e_list = dv.gate_error_values(backend.properties())
epc_calib = np.nan
for tuple_e in e_list:
if tuple_e[0] == interleaved_gate and tuple_e[1] == qubits:
epc_calib = tuple_e[2]
print('EPC reference: {0:1.4e}'.format(epc_calib))
#prepare circuits
int_exp = InterleavedRB(interleaved_circuit, qubits,
lengths, num_samples=num_samples, seed=seed)
#run
print("start experiments",time.strftime('%d/%m/%Y %H:%M:%S'))
int_expdata = int_exp.run(backend).block_for_results()
print(" end experiments",time.strftime('%d/%m/%Y %H:%M:%S'))
experiment_type = int_expdata._data[0]['metadata']['experiment_type']
physical_qubits = int_expdata._data[0]['metadata']['physical_qubits']
shots = int_expdata._data[0]['shots']
nQ = len(qubits)
scale = (2 ** nQ - 1) / 2 ** nQ
m_len = len(lengths)
# get count data and other values from int_expdata
Y = bf.get_GSP_counts(int_expdata._data, 2*m_len,
range(num_samples))
# get RvsI_h and IvsR_h
RvsI_h = np.ones(2*m_len)
for i_data in range(2*m_len):
if int_expdata._data[i_data]['metadata']['interleaved']:
RvsI_h[i_data] = 0.
IvsR_h = (RvsI_h + 1.) %2
X0 = np.tile(lengths,2)
X = np.vstack((X0,RvsI_h,IvsR_h))
y_mean = np.mean(Y, axis = 0)/shots
sigma_y = np.std(Y, axis = 0)/shots
model = "hierarchical model"
# priors for unknown model parameters
T_priors = int_expdata.analysis_results()[0].value.value
print(T_priors)
h_model = bf.create_model(T_priors, X, Y, shots, scale,
testval_s = testval_s, upper_s = upper_s, lower_s = lower_s,
s_prior = "Gamma", alpha_Gamma = alpha_Gamma, beta_Gamma = beta_Gamma)
# model graph
pm.model_to_graphviz(h_model)
# sample
with h_model:
trace_h = pm.sample(draws = 4000, tune= 1000, target_accept=.99,
return_inferencedata=True)
with h_model:
az.plot_trace(trace_h);
with h_model:
az.plot_posterior(trace_h, var_names = ["Tying_Parameters","Ο_Beta","EPC"], round_to = 4, figsize = [16, 8]);
# look at the posterior values of the hyperparameters:
with h_model:
# (hdi_prob=.94 is default)
azt_summary = az.summary(trace_h, round_to=12,
var_names = ["Tying_Parameters","Ο_Beta","EPC"],
kind="stats")
azt_summary
# for comparison
# bayesian
epc_est_a = azt_summary['mean']['EPC']
epc_est_a_err = azt_summary['sd']['EPC']
# frequentist
epc_est_fm = int_expdata.analysis_results()[3].value.value
epc_est_fm_err = int_expdata.analysis_results()[3].value.stderr
epc_title = experiment_type +', ' + interleaved_gate \
+ " qubit(s):" + str(physical_qubits)\
+', backend: '+ backend.name() + "\n Bayesian "+model
bf.plot_epc(h_model, trace_h, epc_calib, epc_est_a,
epc_est_a_err, epc_est_fm, epc_est_fm_err, epc_title)
# compare LSF and SMC
print("Model: Frequentist Bayesian Reference")
print("__________________________________________________________")
print("EPC {0:1.3e} {1:1.3e} {2:1.3e}"
.format(epc_est_fm,epc_est_a,epc_calib ))
print("Β± sd Β± {0:1.3e} Β± {1:1.3e} "
.format(epc_est_fm_err, epc_est_a_err))
def calc_chisquare(ydata, sigma, ycalc):
r = ydata - ycalc
chisq = np.sum((r / sigma) ** 2)
return chisq
# GSP plot
# perform reduced ΟΒ² value calculation for Bayes hierarchical
mean_h = trace_h.posterior.mean(dim=['chain', 'draw'])
theta_stacked = mean_h.ΞΈ.values
NDF_h = m_len*2 - 4 - 1 # (-1 is for Ο_Beta)
chisq_h = calc_chisquare(y_mean, sigma_y, theta_stacked)/NDF_h
#box:
texto = " alpha = {0:7.4f} Β± {1:1.4e}"\
.format(azt_summary['mean']['Tying_Parameters[1]'],
azt_summary['sd']['Tying_Parameters[1]']) + "\n"
texto +=" alpha_c = {0:7.4f} Β± {1:1.4e}"\
.format(azt_summary['mean']['Tying_Parameters[2]'],
azt_summary['sd']['Tying_Parameters[2]']) + "\n"
texto +=" EPC = {0:7.4f} Β± {1:1.4e}"\
.format(azt_summary['mean']['EPC'],
azt_summary['sd']['EPC']) + "\n"
texto +=" Fit ΟΒ² = {0:7.4f} "\
.format(chisq_h)
# obtain data for plot
bounds_rmk, y1, y1_min, y1_max, y2, y2_min, y2_max, Y1, Y2 = \
bf.prepare_two_curves_GSP_plot(h_model, trace_h, X, Y, HDI = False)
# title
title = experiment_type +', ' + interleaved_gate\
+ str(physical_qubits)\
+', backend: '+backend.name()+\
"\n Bayesian "+model+" "+ bounds_rmk
# plot
bf.gsp_plot(scale, lengths, num_samples, shots, texto, title,
y1, y1_min, y1_max, y2, y2_min, y2_max, Y1, Y2,
first_curve = "Standard", second_curve = "Interleaved")
# View result for frequentist model
display(int_expdata.figure(0))
|
https://github.com/matteoacrossi/oqs-jupyterbook
|
matteoacrossi
|
# Imports
import numpy as np
import matplotlib.pyplot as plt
from datetime import datetime
import json
import copy
# Main qiskit imports
from qiskit import QuantumRegister, ClassicalRegister
from qiskit import QuantumCircuit, execute, Aer, IBMQ
# Error mitigation
from qiskit.ignis.mitigation.measurement import (complete_meas_cal,
CompleteMeasFitter,
MeasurementFilter)
# Utility functions
from qiskit.tools.jupyter import *
from qiskit.tools.monitor import job_monitor
from qiskit.providers.jobstatus import JobStatus
# We use ibmq_vigo
IBMQ.load_account()
backend = IBMQ.get_provider(hub='ibm-q', group='open', project='main').get_backend('ibmq_quito')
# Local simulator and vector simulator
simulator = Aer.get_backend('qasm_simulator')
def c1(R,t):
"""Returns the coherence factor in the amplitude damping channel
Args:
R (float): value of R = \gamma_0/\lambda
t (float): value of the time variable
Returns:
A float number
"""
if R < 0.5:
c1 = np.exp(- t / 2.0) * (np.cosh(t * np.sqrt(1.0 - 2.0 * R) / 2.0) + 1.0 / np.sqrt(1.0 - 2.0 * R) * np.sinh(t * np.sqrt(1.0 - 2.0 * R) / 2.0))
else:
c1 = np.exp(- t / 2.0) * (np.cos(t * np.sqrt(2.0 * R - 1.0) / 2.0) + 1.0 / np.sqrt(2.0 * R - 1.0) * np.sin(t * np.sqrt(2.0 * R - 1.0) / 2.0))
return c1
def amplitude_damping_channel(q, c, sys, env, R, t):
"""Returns a QuantumCircuit implementing the amplitude damping channel on the system qubit
Args:
q (QuantumRegister): the register to use for the circuit
c (ClassicalRegister): the register to use for the measurement of the system qubit
sys (int): index for the system qubit
env (int): index for the environment qubit
R (float): value of R = \gamma_0/\lambda
t (float): value of the time variable
Returns:
A QuantumCircuit object
"""
ad = QuantumCircuit(q, c)
# Rotation angle
theta = np.arccos(c1(R, t))
# Channel (notice the extra factor of 2 due to the definition
# of the unitary gate in qiskit)
ad.cu(2.0 * theta, 0.0, 0.0, 0.0, q[sys], q[env])
ad.cx(q[env], q[sys])
# Masurement in the computational basis
ad.measure(q[sys], c[0])
return ad
# We choose to add the initial condition elsewhere
def initial_state(q, sys):
"""Returns a QuantumCircuit implementing the initial condition for the amplitude damping channel
Args:
q (QuantumRegister): the register to use for the circuit
sys (int): index for the system qubit
Returns:
A QuantumCircuit object
"""
# Create circuit
ic = QuantumCircuit(q)
# System in |1>
ic.x(q[sys])
return ic
SHOTS = 8192
# The values for R and corresponding times
R_values = [0.2, 100.0, 200.0, 400.0]
npoints = 30
t_values = {}
for R in R_values:
t_values[R] = np.linspace(0.0, 6.0 * np.pi / np.sqrt(abs(2.0 * R - 1.0)), npoints)
# We create the quantum circuits
q = QuantumRegister(5, name="q")
c = ClassicalRegister(1, name="c")
## Indices of the system and environment qubits
sys = 1
env = 2
## For values of R and thirty values of t for each
circuits = {}
for R in R_values:
circuits[R] = []
for t in t_values[R]:
circuits[R].append(initial_state(q, sys)
+ amplitude_damping_channel(q, c, sys, env, R, t))
circuits[0.2][1].draw(output='mpl')
# Execute the circuits on the local simulator
jobs_sim = {}
for R in R_values:
jobs_sim[R] = execute(circuits[R], backend = simulator, shots = SHOTS)
# Analyse the outcomes
populations_sim = {}
for R in R_values:
populations_sim[R] = []
current_job_res = jobs_sim[R].result()
for i in range(npoints):
counts = current_job_res.get_counts(i)
if '1' in counts:
sm = counts['1']/float(SHOTS)
populations_sim[R].append(sm)
# Plot the results
fig_idx = 221
plt.figure(figsize=(10,12))
for R in R_values:
plt.subplot(fig_idx)
plt.plot(t_values[R], populations_sim[R], label=f"R = {R}")
plt.xlabel('t')
plt.ylabel('Population')
plt.legend()
fig_idx += 1
plt.grid()
# Calibration circuits
cal_circuits, state_labels = complete_meas_cal([sys], q, c)
# Run the calibration job
calibration_job = execute(cal_circuits, backend, shots=SHOTS)
# Run the circuits and save the jobs
jobs = {}
for R in R_values:
jobs[R] = execute(circuits[R], backend = backend, shots = SHOTS)
# Use the calibration job to implement the error mitigation
meas_fitter = CompleteMeasFitter(calibration_job.result(), state_labels)
meas_filter = meas_fitter.filter
# Analyse the outcomes
populations = {}
for R in jobs:
populations[R] = []
current_job_res = jobs[R].result()
for i in range(npoints):
counts = meas_filter.apply(current_job_res).get_counts(i)
if '1' in counts:
sm = counts['1']/float(SHOTS)
populations[R].append(sm)
# Plot the results
fig_idx = 221
plt.figure(figsize=(10,12))
for R in R_values:
plt.subplot(fig_idx)
plt.plot(t_values[R], populations[R], label='Experiment')
plt.plot(t_values[R], populations_sim[R], label='Simulation')
plt.xlabel('t')
plt.ylabel('Population')
fig_idx += 1
plt.grid()
plt.legend();
def amplitude_damping_channel_witness(q, c, sys, env, anc, observable, R, t):
"""Returns a QuantumCircuit implementing the amplitude damping channel on the system qubit with non-Markovianity witness
Args:
q (QuantumRegister): the register to use for the circuit
c (ClassicalRegister): the register to use for the measurement of the system and ancilla qubits
sys (int): index for the system qubit
env (int): index for the environment qubit
anc (int): index for the ancillary qubit
observable (str): the observable to be measured
R (float): value of R = \gamma_0/\lambda
t (float): value of the time variable
Returns:
A QuantumCircuit object
"""
ad = QuantumCircuit(q, c)
# Rotation angle
theta = 2.0 * np.arccos(c1(R, t))
# Channel
ad.cu3(theta, 0.0, 0.0, q[sys], q[env])
ad.cx(q[env], q[sys])
# Masurement of the corresponding observable
if observable == 'xx':
ad.h(sys)
ad.h(anc)
elif observable == 'yy':
ad.sdg(sys)
ad.h(sys)
ad.sdg(anc)
ad.h(anc)
ad.measure(sys,c[0])
ad.measure(anc,c[1])
return ad
# We set the initial entangled state separately
def initial_state_witness(q, sys, anc):
"""Returns a QuantumCircuit implementing the initial condition for the amplitude damping channel with non-Markovianity witness
Args:
q (QuantumRegister): the register to use for the circuit
sys (int): index for the system qubit
anc (int): index for the ancilla qubit
Returns:
A QuantumCircuit object
"""
# Create circuit
ic = QuantumCircuit(q)
# System and ancilla in |\psi^+>
ic.h(q[sys])
ic.cx(q[sys], q[anc])
return ic
SHOTS = 8192
# The values for R and corresponding times,
# as well as the observables needed for the witness
observables = ['xx', 'yy', 'zz']
R_values = [0.2, 100.0]
npoints = 30
t_values = {}
for R in R_values:
t_values[R] = np.linspace(0.0, 6.0 * np.pi / np.sqrt(abs(2.0 * R - 1.0)), npoints)
# We create the quantum circuits
q = QuantumRegister(5, name="q")
c = ClassicalRegister(2, name="c")
## Indices of the system, environment and ancillary qubits
sys = 1
env = 2
anc = 3
## Two values of R and thirty values of t for each
## The witness requires measuring three observables per point
circuits = {}
for R in R_values:
circuits[R] = {}
for observable in observables:
circuits[R][observable] = []
for t in t_values[R]:
circuits[R][observable].append(initial_state_witness(q, sys, anc)
+amplitude_damping_channel_witness(q, c, sys, env, anc, observable, R, t))
circuits[0.2]['yy'][1].draw(output='mpl')
# Execute the circuits on the local simulator
jobs_sim = {}
for R in R_values:
jobs_sim[R] = {}
for observable in observables:
jobs_sim[R][observable] = execute(circuits[R][observable], backend = simulator, shots = SHOTS)
# Analyse the outcomes
## Compute expected values
expected_sim = {}
for R in R_values:
expected_sim[R] = {}
for observable in observables:
expected_sim[R][observable] = []
current_job_res = jobs_sim[R][observable].result()
for i in range(npoints):
counts = current_job_res.get_counts(i)
expc = 0.0
for outcome in counts:
if outcome[0] == outcome[1]:
expc += counts[outcome]/float(SHOTS)
else:
expc -= counts[outcome]/float(SHOTS)
expected_sim[R][observable].append(expc)
## Compute witness
witness_sim = {}
for R in R_values:
witness_sim[R] = []
for i in range(npoints):
w = 0.25*(1.0+expected_sim[R]['xx'][i]-expected_sim[R]['yy'][i]+expected_sim[R]['zz'][i])
witness_sim[R].append(w)
# Plot the results
fig_idx = 221
plt.figure(figsize=(10,12))
for R in R_values:
plt.subplot(fig_idx)
plt.plot(t_values[R], witness_sim[R])
plt.xlabel('t')
plt.ylabel('Population')
fig_idx += 1
plt.grid()
# Calibration circuits
cal_circuits, state_labels = complete_meas_cal([sys, anc], q, c)
# Run the calibration job
calibration_job = execute(cal_circuits, backend, shots=SHOTS)
# Run the circuits and save the jobs
jobs = {}
for R in R_values:
jobs[R] = {}
for observable in observables:
jobs[R][observable] = execute(circuits[R][observable], backend = backend, shots = SHOTS)
# Use the calibration job to implement the error mitigation
meas_fitter = CompleteMeasFitter(calibration_job.result(), state_labels)
meas_filter = meas_fitter.filter
# Analyse the outcomes
## Compute expected values
expected = {}
for R in R_values:
expected[R] = {}
for observable in observables:
expected[R][observable] = []
current_job_res = jobs[R][observable].result()
mitigated_res = meas_filter.apply(current_job_res)
for i in range(npoints):
counts = mitigated_res.get_counts(i)
expc = 0.0
for outcome in counts:
if outcome[0] == outcome[1]:
expc += counts[outcome]/float(SHOTS)
else:
expc -= counts[outcome]/float(SHOTS)
expected[R][observable].append(expc)
## Compute witness
witness = {}
for R in R_values:
witness[R] = []
for i in range(npoints):
w = 0.25*(1.0+expected[R]['xx'][i]-expected[R]['yy'][i]+expected[R]['zz'][i])
witness[R].append(w)
# Plot the results
fig_idx = 221
plt.figure(figsize=(10,12))
for R in R_values:
plt.subplot(fig_idx)
plt.plot(t_values[R], witness[R], label='Experiment')
plt.plot(t_values[R], witness_sim[R], label='Simulation')
plt.xlabel('t')
plt.ylabel('Witness')
fig_idx += 1
plt.grid()
plt.legend();
|
https://github.com/jatin-47/QGSS-2021
|
jatin-47
|
from qiskit.circuit.library import RealAmplitudes
ansatz = RealAmplitudes(num_qubits=2, reps=1, entanglement='linear')
ansatz.draw('mpl', style='iqx')
from qiskit.opflow import Z, I
hamiltonian = Z ^ Z
from qiskit.opflow import StateFn
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(ansatz)
import numpy as np
point = np.random.random(ansatz.num_parameters)
index = 2
from qiskit import Aer
from qiskit.utils import QuantumInstance
backend = Aer.get_backend('qasm_simulator')
q_instance = QuantumInstance(backend, shots = 8192, seed_simulator = 2718, seed_transpiler = 2718)
from qiskit.circuit import QuantumCircuit
from qiskit.opflow import Z, X
H = X ^ X
U = QuantumCircuit(2)
U.h(0)
U.cx(0, 1)
# YOUR CODE HERE
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(U)
matmult_result =expectation.eval()
from qc_grader import grade_lab4_ex1
# Note that the grading function is expecting a complex number
grade_lab4_ex1(matmult_result)
from qiskit.opflow import CircuitSampler, PauliExpectation
sampler = CircuitSampler(q_instance)
# YOUR CODE HERE
sampler = CircuitSampler(q_instance) # q_instance is the QuantumInstance from the beginning of the notebook
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(U)
in_pauli_basis = PauliExpectation().convert(expectation)
shots_result = sampler.convert(in_pauli_basis).eval()
from qc_grader import grade_lab4_ex2
# Note that the grading function is expecting a complex number
grade_lab4_ex2(shots_result)
from qiskit.opflow import PauliExpectation, CircuitSampler
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(ansatz)
in_pauli_basis = PauliExpectation().convert(expectation)
sampler = CircuitSampler(q_instance)
def evaluate_expectation(x):
value_dict = dict(zip(ansatz.parameters, x))
result = sampler.convert(in_pauli_basis, params=value_dict).eval()
return np.real(result)
eps = 0.2
e_i = np.identity(point.size)[:, index] # identity vector with a 1 at index ``index``, otherwise 0
plus = point + eps * e_i
minus = point - eps * e_i
finite_difference = (evaluate_expectation(plus) - evaluate_expectation(minus)) / (2 * eps)
print(finite_difference)
from qiskit.opflow import Gradient
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(ansatz)
shifter = Gradient('fin_diff', analytic=False, epsilon=eps)
grad = shifter.convert(expectation, params=ansatz.parameters[index])
print(grad)
value_dict = dict(zip(ansatz.parameters, point))
sampler.convert(grad, value_dict).eval().real
eps = np.pi / 2
e_i = np.identity(point.size)[:, index] # identity vector with a 1 at index ``index``, otherwise 0
plus = point + eps * e_i
minus = point - eps * e_i
finite_difference = (evaluate_expectation(plus) - evaluate_expectation(minus)) / 2
print(finite_difference)
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(ansatz)
shifter = Gradient() # parameter-shift rule is the default
grad = shifter.convert(expectation, params=ansatz.parameters[index])
sampler.convert(grad, value_dict).eval().real
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(ansatz)
shifter = Gradient('lin_comb') # parameter-shift rule is the default
grad = shifter.convert(expectation, params=ansatz.parameters[index])
sampler.convert(grad, value_dict).eval().real
# initial_point = np.random.random(ansatz.num_parameters)
initial_point = np.array([0.43253681, 0.09507794, 0.42805949, 0.34210341])
expectation = StateFn(hamiltonian, is_measurement=True).compose(StateFn(ansatz))
gradient = Gradient().convert(expectation)
gradient_in_pauli_basis = PauliExpectation().convert(gradient)
sampler = CircuitSampler(q_instance)
def evaluate_gradient(x):
value_dict = dict(zip(ansatz.parameters, x))
result = sampler.convert(gradient_in_pauli_basis, params=value_dict).eval() # add parameters in here!
return np.real(result)
# Note: The GradientDescent class will be released with Qiskit 0.28.0 and can then be imported as:
# from qiskit.algorithms.optimizers import GradientDescent
from qc_grader.gradient_descent import GradientDescent
gd_loss = []
def gd_callback(nfevs, x, fx, stepsize):
gd_loss.append(fx)
gd = GradientDescent(maxiter=300, learning_rate=0.01, callback=gd_callback)
x_opt, fx_opt, nfevs = gd.optimize(initial_point.size, # number of parameters
evaluate_expectation, # function to minimize
gradient_function=evaluate_gradient, # function to evaluate the gradient
initial_point=initial_point) # initial point
import matplotlib
import matplotlib.pyplot as plt
matplotlib.rcParams['font.size'] = 14
plt.figure(figsize=(12, 6))
plt.plot(gd_loss, label='vanilla gradient descent')
plt.axhline(-1, ls='--', c='tab:red', label='target')
plt.ylabel('loss')
plt.xlabel('iterations')
plt.legend();
from qiskit.opflow import NaturalGradient
expectation = StateFn(hamiltonian, is_measurement=True).compose(StateFn(ansatz))
natural_gradient = NaturalGradient(regularization='ridge').convert(expectation)
natural_gradient_in_pauli_basis = PauliExpectation().convert(natural_gradient)
sampler = CircuitSampler(q_instance, caching="all")
def evaluate_natural_gradient(x):
value_dict = dict(zip(ansatz.parameters, x))
result = sampler.convert(natural_gradient, params=value_dict).eval()
return np.real(result)
print('Vanilla gradient:', evaluate_gradient(initial_point))
print('Natural gradient:', evaluate_natural_gradient(initial_point))
qng_loss = []
def qng_callback(nfevs, x, fx, stepsize):
qng_loss.append(fx)
qng = GradientDescent(maxiter=300, learning_rate=0.01, callback=qng_callback)
x_opt, fx_opt, nfevs = qng.optimize(initial_point.size,
evaluate_expectation,
gradient_function=evaluate_natural_gradient,
initial_point=initial_point)
def plot_loss():
plt.figure(figsize=(12, 6))
plt.plot(gd_loss, 'tab:blue', label='vanilla gradient descent')
plt.plot(qng_loss, 'tab:green', label='quantum natural gradient')
plt.axhline(-1, c='tab:red', ls='--', label='target')
plt.ylabel('loss')
plt.xlabel('iterations')
plt.legend()
plot_loss()
from qc_grader.spsa import SPSA
spsa_loss = []
def spsa_callback(nfev, x, fx, stepsize, accepted):
spsa_loss.append(fx)
spsa = SPSA(maxiter=300, learning_rate=0.01, perturbation=0.01, callback=spsa_callback)
x_opt, fx_opt, nfevs = spsa.optimize(initial_point.size,
evaluate_expectation,
initial_point=initial_point)
def plot_loss():
plt.figure(figsize=(12, 6))
plt.plot(gd_loss, 'tab:blue', label='vanilla gradient descent')
plt.plot(qng_loss, 'tab:green', label='quantum natural gradient')
plt.plot(spsa_loss, 'tab:blue', ls='--', label='SPSA')
plt.axhline(-1, c='tab:red', ls='--', label='target')
plt.ylabel('loss')
plt.xlabel('iterations')
plt.legend()
plot_loss()
# Note: The QNSPSA class will be released with Qiskit 0.28.0 and can then be imported as:
# from qiskit.algorithms.optimizers import QNSPSA
from qc_grader.qnspsa import QNSPSA
qnspsa_loss = []
def qnspsa_callback(nfev, x, fx, stepsize, accepted):
qnspsa_loss.append(fx)
fidelity = QNSPSA.get_fidelity(ansatz, q_instance, expectation=PauliExpectation())
qnspsa = QNSPSA(fidelity, maxiter=300, learning_rate=0.01, perturbation=0.01, callback=qnspsa_callback)
x_opt, fx_opt, nfevs = qnspsa.optimize(initial_point.size,
evaluate_expectation,
initial_point=initial_point)
def plot_loss():
plt.figure(figsize=(12, 6))
plt.plot(gd_loss, 'tab:blue', label='vanilla gradient descent')
plt.plot(qng_loss, 'tab:green', label='quantum natural gradient')
plt.plot(spsa_loss, 'tab:blue', ls='--', label='SPSA')
plt.plot(qnspsa_loss, 'tab:green', ls='--', label='QN-SPSA')
plt.axhline(-1, c='tab:red', ls='--', label='target')
plt.ylabel('loss')
plt.xlabel('iterations')
plt.legend()
plot_loss()
autospsa_loss = []
def autospsa_callback(nfev, x, fx, stepsize, accepted):
autospsa_loss.append(fx)
autospsa = SPSA(maxiter=300, learning_rate=None, perturbation=None, callback=autospsa_callback)
x_opt, fx_opt, nfevs = autospsa.optimize(initial_point.size,
evaluate_expectation,
initial_point=initial_point)
def plot_loss():
plt.figure(figsize=(12, 6))
plt.plot(gd_loss, 'tab:blue', label='vanilla gradient descent')
plt.plot(qng_loss, 'tab:green', label='quantum natural gradient')
plt.plot(spsa_loss, 'tab:blue', ls='--', label='SPSA')
plt.plot(qnspsa_loss, 'tab:green', ls='--', label='QN-SPSA')
plt.plot(autospsa_loss, 'tab:red', label='Powerlaw SPSA')
plt.axhline(-1, c='tab:red', ls='--', label='target')
plt.ylabel('loss')
plt.xlabel('iterations')
plt.legend()
plot_loss()
H_tfi = -(Z^Z^I)-(I^Z^Z)-(X^I^I)-(I^X^I)-(I^I^X)
from qc_grader import grade_lab4_ex3
# Note that the grading function is expecting a Hamiltonian
grade_lab4_ex3(H_tfi)
from qiskit.circuit.library import EfficientSU2
efficient_su2 = EfficientSU2(3, entanglement="linear", reps=2)
tfi_sampler = CircuitSampler(q_instance)
def evaluate_tfi(parameters):
exp = StateFn(H_tfi, is_measurement=True).compose(StateFn(efficient_su2))
value_dict = dict(zip(efficient_su2.parameters, parameters))
result = tfi_sampler.convert(PauliExpectation().convert(exp), params=value_dict).eval()
return np.real(result)
# target energy
tfi_target = -3.4939592074349326
# initial point for reproducibility
tfi_init = np.array([0.95667807, 0.06192812, 0.47615196, 0.83809827, 0.89022282,
0.27140831, 0.9540853 , 0.41374024, 0.92595507, 0.76150126,
0.8701938 , 0.05096063, 0.25476016, 0.71807858, 0.85661325,
0.48311132, 0.43623886, 0.6371297 ])
tfi_result = SPSA(maxiter=300, learning_rate=None, perturbation=None)
tfi_result = tfi_result.optimize(tfi_init.size, evaluate_tfi, initial_point=tfi_init)
tfi_minimum = tfi_result[1]
print("Error:", np.abs(tfi_result[1] - tfi_target))
from qc_grader import grade_lab4_ex4
# Note that the grading function is expecting a floating point number
grade_lab4_ex4(tfi_minimum)
from qiskit_machine_learning.datasets import ad_hoc_data
training_features, training_labels, test_features, test_labels = ad_hoc_data(
training_size=20, test_size=10, n=2, one_hot=False, gap=0.5
)
# the training labels are in {0, 1} but we'll use {-1, 1} as class labels!
training_labels = 2 * training_labels - 1
test_labels = 2 * test_labels - 1
def plot_sampled_data():
from matplotlib.patches import Patch
from matplotlib.lines import Line2D
import matplotlib.pyplot as plt
plt.figure(figsize=(12,6))
for feature, label in zip(training_features, training_labels):
marker = 'o'
color = 'tab:green' if label == -1 else 'tab:blue'
plt.scatter(feature[0], feature[1], marker=marker, s=100, color=color)
for feature, label in zip(test_features, test_labels):
marker = 's'
plt.scatter(feature[0], feature[1], marker=marker, s=100, facecolor='none', edgecolor='k')
legend_elements = [
Line2D([0], [0], marker='o', c='w', mfc='tab:green', label='A', ms=15),
Line2D([0], [0], marker='o', c='w', mfc='tab:blue', label='B', ms=15),
Line2D([0], [0], marker='s', c='w', mfc='none', mec='k', label='test features', ms=10)
]
plt.legend(handles=legend_elements, bbox_to_anchor=(1, 0.6))
plt.title('Training & test data')
plt.xlabel('$x$')
plt.ylabel('$y$')
plot_sampled_data()
from qiskit.circuit.library import ZZFeatureMap
dim = 2
feature_map = ZZFeatureMap(dim, reps=1) # let's keep it simple!
feature_map.draw('mpl', style='iqx')
ansatz = RealAmplitudes(num_qubits=dim, entanglement='linear', reps=1) # also simple here!
ansatz.draw('mpl', style='iqx')
circuit = feature_map.compose(ansatz)
circuit.draw('mpl', style='iqx')
hamiltonian = Z ^ Z # global Z operators
gd_qnn_loss = []
def gd_qnn_callback(*args):
gd_qnn_loss.append(args[2])
gd = GradientDescent(maxiter=100, learning_rate=0.01, callback=gd_qnn_callback)
from qiskit_machine_learning.neural_networks import OpflowQNN
qnn_expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(circuit)
qnn = OpflowQNN(qnn_expectation,
input_params=list(feature_map.parameters),
weight_params=list(ansatz.parameters),
exp_val=PauliExpectation(),
gradient=Gradient(), # <-- Parameter-Shift gradients
quantum_instance=q_instance)
from qiskit_machine_learning.algorithms import NeuralNetworkClassifier
#initial_point = np.array([0.2, 0.1, 0.3, 0.4])
classifier = NeuralNetworkClassifier(qnn, optimizer=gd)
classifier.fit(training_features, training_labels);
predicted = classifier.predict(test_features)
def plot_predicted():
from matplotlib.lines import Line2D
plt.figure(figsize=(12, 6))
for feature, label in zip(training_features, training_labels):
marker = 'o'
color = 'tab:green' if label == -1 else 'tab:blue'
plt.scatter(feature[0], feature[1], marker=marker, s=100, color=color)
for feature, label, pred in zip(test_features, test_labels, predicted):
marker = 's'
color = 'tab:green' if pred == -1 else 'tab:blue'
if label != pred: # mark wrongly classified
plt.scatter(feature[0], feature[1], marker='o', s=500, linewidths=2.5,
facecolor='none', edgecolor='tab:red')
plt.scatter(feature[0], feature[1], marker=marker, s=100, color=color)
legend_elements = [
Line2D([0], [0], marker='o', c='w', mfc='tab:green', label='A', ms=15),
Line2D([0], [0], marker='o', c='w', mfc='tab:blue', label='B', ms=15),
Line2D([0], [0], marker='s', c='w', mfc='tab:green', label='predict A', ms=10),
Line2D([0], [0], marker='s', c='w', mfc='tab:blue', label='predict B', ms=10),
Line2D([0], [0], marker='o', c='w', mfc='none', mec='tab:red', label='wrongly classified', mew=2, ms=15)
]
plt.legend(handles=legend_elements, bbox_to_anchor=(1, 0.7))
plt.title('Training & test data')
plt.xlabel('$x$')
plt.ylabel('$y$')
plot_predicted()
qng_qnn_loss = []
def qng_qnn_callback(*args):
qng_qnn_loss.append(args[2])
gd = GradientDescent(maxiter=100, learning_rate=0.01, callback=qng_qnn_callback)
qnn = OpflowQNN(qnn_expectation,
input_params=list(feature_map.parameters),
weight_params=list(ansatz.parameters),
gradient=NaturalGradient(regularization='ridge'), # <-- using Natural Gradients!
quantum_instance=q_instance)
classifier = NeuralNetworkClassifier(qnn, optimizer=gd)#, initial_point=initial_point)
classifier.fit(training_features, training_labels);
def plot_losses():
plt.figure(figsize=(12, 6))
plt.plot(gd_qnn_loss, 'tab:blue', marker='o', label='vanilla gradients')
plt.plot(qng_qnn_loss, 'tab:green', marker='o', label='natural gradients')
plt.xlabel('iterations')
plt.ylabel('loss')
plt.legend(loc='best')
plot_losses()
from qiskit.opflow import I
def sample_gradients(num_qubits, reps, local=False):
"""Sample the gradient of our model for ``num_qubits`` qubits and ``reps`` repetitions.
We sample 100 times for random parameters and compute the gradient of the first RY rotation gate.
"""
index = num_qubits - 1
# you can also exchange this for a local operator and observe the same!
if local:
operator = Z ^ Z ^ (I ^ (num_qubits - 2))
else:
operator = Z ^ num_qubits
# real amplitudes ansatz
ansatz = RealAmplitudes(num_qubits, entanglement='linear', reps=reps)
# construct Gradient we want to evaluate for different values
expectation = StateFn(operator, is_measurement=True).compose(StateFn(ansatz))
grad = Gradient().convert(expectation, params=ansatz.parameters[index])
# evaluate for 100 different, random parameter values
num_points = 100
grads = []
for _ in range(num_points):
# points are uniformly chosen from [0, pi]
point = np.random.uniform(0, np.pi, ansatz.num_parameters)
value_dict = dict(zip(ansatz.parameters, point))
grads.append(sampler.convert(grad, value_dict).eval())
return grads
num_qubits = list(range(2, 13))
reps = num_qubits # number of layers = numbers of qubits
gradients = [sample_gradients(n, r) for n, r in zip(num_qubits, reps)]
fit = np.polyfit(num_qubits, np.log(np.var(gradients, axis=1)), deg=1)
x = np.linspace(num_qubits[0], num_qubits[-1], 200)
plt.figure(figsize=(12, 6))
plt.semilogy(num_qubits, np.var(gradients, axis=1), 'o-', label='measured variance')
plt.semilogy(x, np.exp(fit[0] * x + fit[1]), 'r--', label=f'exponential fit w/ {fit[0]:.2f}')
plt.xlabel('number of qubits')
plt.ylabel(r'$\mathrm{Var}[\partial_{\theta 1} \langle E(\theta) \rangle]$')
plt.legend(loc='best');
from qiskit.opflow import NaturalGradient
def sample_natural_gradients(num_qubits, reps):
index = num_qubits - 1
operator = Z ^ num_qubits
ansatz = RealAmplitudes(num_qubits, entanglement='linear', reps=reps)
expectation = StateFn(operator, is_measurement=True).compose(StateFn(ansatz))
grad = # TODO: ``grad`` should be the natural gradient for the parameter at index ``index``.
# Hint: Check the ``sample_gradients`` function, this one is almost the same.
grad = NaturalGradient().convert(expectation, params=ansatz.parameters[index])
num_points = 100
grads = []
for _ in range(num_points):
point = np.random.uniform(0, np.pi, ansatz.num_parameters)
value_dict = dict(zip(ansatz.parameters, point))
grads.append(sampler.convert(grad, value_dict).eval())
return grads
num_qubits = list(range(2, 13))
reps = num_qubits # number of layers = numbers of qubits
natural_gradients = [sample_natural_gradients(n, r) for n, r in zip(num_qubits, reps)]
fit = np.polyfit(num_qubits, np.log(np.var(natural_gradients, axis=1)), deg=1)
x = np.linspace(num_qubits[0], num_qubits[-1], 200)
plt.figure(figsize=(12, 6))
plt.semilogy(num_qubits, np.var(gradients, axis=1), 'o-', label='vanilla gradients')
plt.semilogy(num_qubits, np.var(natural_gradients, axis=1), 's-', label='natural gradients')
plt.semilogy(x, np.exp(fit[0] * x + fit[1]), 'r--', label=f'exponential fit w/ {float(fit[0]):.2f}')
plt.xlabel('number of qubits')
plt.ylabel(r'$\mathrm{Var}[\partial_{\theta 1} \langle E(\theta) \rangle]$')
plt.legend(loc='best');
num_qubits = list(range(2, 13))
fixed_depth_global_gradients = [sample_gradients(n, 1) for n in num_qubits]
fit = np.polyfit(num_qubits, np.log(np.var(fixed_depth_global_gradients, axis=1)), deg=1)
x = np.linspace(num_qubits[0], num_qubits[-1], 200)
plt.figure(figsize=(12, 6))
plt.semilogy(num_qubits, np.var(gradients, axis=1), 'o-', label='global cost, linear depth')
plt.semilogy(num_qubits, np.var(fixed_depth_global_gradients, axis=1), 'o-', label='global cost, constant depth')
plt.semilogy(x, np.exp(fit[0] * x + fit[1]), 'r--', label=f'exponential fit w/ {fit[0]:.2f}')
plt.xlabel('number of qubits')
plt.ylabel(r'$\mathrm{Var}[\partial_{\theta 1} \langle E(\theta) \rangle]$')
plt.legend(loc='best');
num_qubits = list(range(2, 13))
linear_depth_local_gradients = [sample_gradients(n, n, local=True) for n in num_qubits]
fit = np.polyfit(num_qubits, np.log(np.var(linear_depth_local_gradients, axis=1)), deg=1)
x = np.linspace(num_qubits[0], num_qubits[-1], 200)
plt.figure(figsize=(12, 6))
plt.semilogy(num_qubits, np.var(gradients, axis=1), 'o-', label='global cost, linear depth')
plt.semilogy(num_qubits, np.var(fixed_depth_global_gradients, axis=1), 'o-', label='global cost, constant depth')
plt.semilogy(num_qubits, np.var(linear_depth_local_gradients, axis=1), 'o-', label='local cost, linear depth')
plt.semilogy(x, np.exp(fit[0] * x + fit[1]), 'r--', label=f'exponential fit w/ {fit[0]:.2f}')
plt.xlabel('number of qubits')
plt.ylabel(r'$\mathrm{Var}[\partial_{\theta 1} \langle E(\theta) \rangle]$')
plt.legend(loc='best');
num_qubits = list(range(2, 13))
fixed_depth_local_gradients = [sample_gradients(n, 1, local=True) for n in num_qubits]
fit = np.polyfit(num_qubits, np.log(np.var(fixed_depth_local_gradients, axis=1)), deg=1)
x = np.linspace(num_qubits[0], num_qubits[-1], 200)
plt.figure(figsize=(12, 6))
plt.semilogy(num_qubits, np.var(gradients, axis=1), 'o-', label='global cost, linear depth')
plt.semilogy(num_qubits, np.var(fixed_depth_global_gradients, axis=1), 'o-', label='global cost, constant depth')
plt.semilogy(num_qubits, np.var(linear_depth_local_gradients, axis=1), 'o-', label='local cost, linear depth')
plt.semilogy(num_qubits, np.var(fixed_depth_local_gradients, axis=1), 'o-', label='local cost, constant depth')
plt.semilogy(x, np.exp(fit[0] * x + fit[1]), 'r--', label=f'exponential fit w/ {fit[0]:.2f}')
plt.xlabel('number of qubits')
plt.ylabel(r'$\mathrm{Var}[\partial_{\theta 1} \langle E(\theta) \rangle]$')
plt.legend(loc='best');
num_qubits = 6
operator = Z ^ Z ^ (I ^ (num_qubits - 4))
def minimize(circuit, optimizer):
initial_point = np.random.random(circuit.num_parameters)
exp = StateFn(operator, is_measurement=True) @ StateFn(circuit)
grad = Gradient().convert(exp)
# pauli basis
exp = PauliExpectation().convert(exp)
grad = PauliExpectation().convert(grad)
sampler = CircuitSampler(q_instance, caching="all")
def loss(x):
values_dict = dict(zip(circuit.parameters, x))
return np.real(sampler.convert(exp, values_dict).eval())
def gradient(x):
values_dict = dict(zip(circuit.parameters, x))
return np.real(sampler.convert(grad, values_dict).eval())
return optimizer.optimize(circuit.num_parameters, loss, gradient, initial_point=initial_point)
circuit = RealAmplitudes(4, reps=1, entanglement='linear')
circuit.draw('mpl', style='iqx')
circuit.reps = 5
circuit.draw('mpl', style='iqx')
def layerwise_training(ansatz, max_num_layers, optimizer):
optimal_parameters = []
fopt = None
for reps in range(1, max_num_layers):
ansatz.reps = reps
# bind already optimized parameters
values_dict = dict(zip(ansatz.parameters, optimal_parameters))
partially_bound = ansatz.bind_parameters(values_dict)
xopt, fopt, _ = minimize(partially_bound, optimizer)
print('Circuit depth:', ansatz.depth(), 'best value:', fopt)
optimal_parameters += list(xopt)
return fopt, optimal_parameters
ansatz = RealAmplitudes(4, entanglement='linear')
optimizer = GradientDescent(maxiter=50)
np.random.seed(12)
fopt, optimal_parameters = layerwise_training(ansatz, 4, optimizer)
|
https://github.com/DarkStarQuantumLab/Qauntum-trading-a-disturbance-in-the-force-of-supply-and-demand
|
DarkStarQuantumLab
|
!python3 -m pip install -q qiskit
!python3 -m pip install -q qiskit_ibm_runtime
!python3 -m pip install qiskit-aer
import numpy as np
import pandas as pd
from qiskit import IBMQ, BasicAer, Aer
from qiskit_ibm_runtime import QiskitRuntimeService, Session, Options, Sampler, Estimator
from qiskit.circuit.quantumcircuit import QuantumCircuit
from qiskit.quantum_info.operators import Operator
from qiskit.extensions.unitary import UnitaryGate
from qiskit.execute_function import execute
from typing import Dict, Optional
from sympy import Matrix
from sympy.physics.quantum import TensorProduct
num_players = 2
# define the payoff matrices. Assume, the 1st matrix is Alice's payoff, the secomd matrix is Bob's payoff
payoff_matrix =[[[3, 0],
[5, 1]],
[[3, 5],
[0, 1]]]
# calculating payoffs
def get_payoff(counts):
"""
Calculate the reward for the players after the game ends.
"""
payoff_bob = []
payoff_alice = []
for strategy, prob in counts.items():
strategy_bob = int(strategy[1])
strategy_alice = int(strategy[0])
payoff_bob.append(prob * payoff_matrix[0][strategy_alice][strategy_bob])
payoff_alice.append(prob * payoff_matrix[0][strategy_bob][strategy_alice])
return sum(payoff_alice), sum(payoff_bob)
# define the simulator
simulator = Aer.get_backend('statevector_simulator')
def build_qcir_two_by_two_parameters(theta1, phi1, theta2, phi2):
alice = np.array([
[np.exp(1.0j*phi1)*np.cos(theta1), np.sin(theta1)],
[-np.sin(theta1), np.exp(-1.0j*phi1)*np.cos(theta1)]])
bob = np.array([
[np.exp(1.0j*phi2)*np.cos(theta2), np.sin(theta2)],
[-np.sin(theta2), np.exp(-1.0j*phi2)*np.cos(theta2)]])
qc = QuantumCircuit(num_players)
J = 1/np.sqrt(2)*np.array([[1.0, 0.0, 0.0, 1.0j],
[0.0, 1.0, 1.0j, 0.0],
[0.0, 1.0j, 1.0, 0.0],
[1.0j, 0.0, 0.0, 1.0]]).astype(complex)
J_unitary = UnitaryGate(Operator(J))
qc.append(J_unitary, [0,1])
qc.barrier()
unitary_alice = UnitaryGate(Operator(alice))
unitary_bob = UnitaryGate(Operator(bob))
qc.append(unitary_alice, [0])
qc.append(unitary_bob, [1])
qc.barrier()
Jdagger_unitary = UnitaryGate(Operator(J.conj().T))
qc.append(Jdagger_unitary, [0,1])
return qc
space_size = 4
actions_list = []
"quantum games theta and phi ranges"
for theta1 in np.linspace(0, np.pi/2, space_size):
for phi1 in np.linspace(0, np.pi/2, space_size):
actions_list.append((theta1,phi1))
def epsilon_Greedy_Policy_2x2(eps, playerName):
p = np.random.random()
if p < eps:
index = np.random.choice(len(actions_list))
action_chosen = actions_list[index]
else:
if(playerName == "Alice"):
index = np.argmax(Q_Alice)
action_chosen = actions_list[index]
elif(playerName == "Bob"):
index = np.argmax(Q_Bob)
action_chosen = actions_list[index]
return (action_chosen[0],action_chosen[1], index)
epsilonArray = []
payoffPercentage3_3 = []
eps = np.arange(0.0, 0.1, 0.01)
for e in eps:
count = 0
for k in range(100):
Q_Alice = [0]*len(actions_list)
Q_Bob = [0]*len(actions_list)
T = 20 #assuming t = 100
alice_reward = [0]*len(actions_list)
bob_reward = [0]*len(actions_list)
# Initialize parameters
#gamma = 0.5 # Discount factor
alpha = 0.9 # Learning rate
#epsilon = 0.04
for t in range(T):
theta1, phi1, action_index_Alice = epsilon_Greedy_Policy_2x2(e,"Alice")
theta2, phi2, action_index_Bob = epsilon_Greedy_Policy_2x2(e, "Bob")
qc = build_qcir_two_by_two_parameters(theta1, phi1, theta2, phi2)
results = execute(qc, simulator, shots=1024).result().get_counts()
payoff_alice, payoff_bob = get_payoff(results)
alice_reward[action_index_Alice] = payoff_alice
bob_reward[action_index_Bob] = payoff_bob
Q_Alice[action_index_Alice] = Q_Alice[action_index_Alice] + alpha * (alice_reward[action_index_Alice]-(Q_Alice[action_index_Alice]))
Q_Bob[action_index_Bob] = Q_Bob[action_index_Bob] + alpha * (bob_reward[action_index_Bob]-(Q_Bob[action_index_Bob]))
#Q_Alice[action_index_Alice] = Q_Alice[action_index_Alice] + alpha * (alice_reward[action_index_Alice] + (gamma*max(Q_Alice)) -(Q_Alice[action_index_Alice]))
#Q_Bob[action_index_Bob] = Q_Bob[action_index_Bob] + alpha * (bob_reward[action_index_Bob] + (gamma*max(Q_Bob)) - (Q_Bob[action_index_Bob]))
for i in range(len(Q_Alice)):
if(Q_Alice[i] == 3 and Q_Bob[i] ==3):
count+=1
epsilonArray.append(e)
payoffPercentage3_3.append(count)
print(epsilonArray)
print(payoffPercentage3_3)
import matplotlib.pyplot as plt
x = epsilonArray
y = payoffPercentage3_3
plt.scatter(x, y)
plt.show()
|
https://github.com/joemoorhouse/quantum-mc
|
joemoorhouse
|
import sys, os
import numpy as np
import scipy
from scipy.stats import norm
sys.path.append("../../../quantum-mc") # see os.getcwd()
import matplotlib.pyplot as plt
import quantum_mc.calibration.fitting as ft
import quantum_mc.calibration.time_series as ts
import matplotlib.dates as mdates
from matplotlib.ticker import (MultipleLocator, FormatStrFormatter,
AutoMinorLocator)
# AAPL, MSFT, SPX
ticker = "MSFT"
data = ts.get_data(ticker)
((cdf_x, cdf_y), sigma) = ft.get_cdf_data(ticker)
(x, y) = ft.get_fit_data(ticker, norm_to_rel = False)
pl = ft.fit_piecewise_linear(x, y)
pc = ft.fit_piecewise_cubic(x, y)
xf = np.linspace(-3, 3, 100)
cm = 1 / 2.54
years = mdates.YearLocator() # every year
months = mdates.MonthLocator() # every month
years_fmt = mdates.DateFormatter('%Y')
fig = plt.figure(figsize=(8*cm,6*cm))
ax = fig.add_axes([0.2, 0.19, 0.77, 0.77])
#fig, ax = plt.subplots(nrows=1, figsize=(8*cm, 6*cm))
fig.set_facecolor('w')
ax.plot(data.index, data["Close"], linewidth=0.5)
ax.set_xlabel('Time (years)')
ax.set_ylabel('Closing price')
# format the ticks
ax.xaxis.set_major_locator(years)
ax.xaxis.set_major_formatter(years_fmt)
ax.xaxis.set_minor_locator(months)
fig.savefig('hist_series.pdf', format='pdf', facecolor=fig.get_facecolor(), transparent=True)
fig = plt.figure(figsize=(8*cm,6*cm))
ax = fig.add_axes([0.2, 0.19, 0.77, 0.77])
fig.set_facecolor('w')
ax.plot(cdf_x, cdf_y, label="Empirical")
ax.plot(cdf_x, norm.cdf(cdf_x), '--', label="Normal")
ax.set_xlim(-5, 4)
ax.xaxis.set_major_locator(MultipleLocator(1))
ax.yaxis.set_major_locator(MultipleLocator(0.2))
ax.set_xlabel('Return ($\sigma$)')
ax.set_ylabel('Cumulative probability')
ax.legend()
fig.savefig('hist_cdf_linear.pdf', format='pdf', facecolor=fig.get_facecolor(), transparent=True)
fig = plt.figure(figsize=(8*cm,6*cm))
ax = fig.add_axes([0.2, 0.19, 0.77, 0.77])
fig.set_facecolor('w')
ax.plot(cdf_x, cdf_y, label="Empirical")
ax.plot(cdf_x, norm.cdf(cdf_x), '--', label="Normal")
ax.set_xlim(-5, 4)
ax.set_ylim(0.005, 1.0)
ax.set_yscale("log")
ax.xaxis.set_major_locator(MultipleLocator(1))
#ax.yaxis.set_major_locator(MultipleLocator(0.2))
ax.set_xlabel('Return ($\sigma$)')
ax.set_ylabel('Cumulative probability')
ax.legend()
fig.savefig('hist_cdf_log.pdf', format='pdf', facecolor=fig.get_facecolor(), transparent=True)
cm = 1 / 2.54
fig = plt.figure(figsize=(8*cm,6*cm))
ax = fig.add_axes([0.2, 0.19, 0.77, 0.77])
fig.set_facecolor('w')
ax.plot(x, y, "o", markersize = 2, label="Observed")
ax.set_xlabel('Normal return ($\sigma$)')
ax.set_ylabel('Empirical return ($\sigma$)')
ax.xaxis.set_major_locator(MultipleLocator(1))
ax.yaxis.set_major_locator(MultipleLocator(2))
fig.savefig('hist_scatter.pdf', format='pdf', facecolor=fig.get_facecolor(), transparent=True)
cm = 1 / 2.54
fig = plt.figure(figsize=(8*cm,6*cm))
ax = fig.add_axes([0.2, 0.19, 0.77, 0.77])
fig.set_facecolor('w')
ax.plot(x, y, "o", markersize = 2, label="Observed")
ax.plot(xf, pl(xf), label="Fitted", color = "green")
ax.set_xlabel('Normal return ($\sigma$)')
ax.set_ylabel('Empirical return ($\sigma$)')
ax.xaxis.set_major_locator(MultipleLocator(1))
ax.yaxis.set_major_locator(MultipleLocator(2))
ax.legend()
fig.savefig('hist_scatter_fitted.pdf', formt='pdf', facecolor=fig.get_facecolor(), transparent=True)
cm = 1 / 2.54
fig = plt.figure(figsize=(8*cm,6*cm))
ax = fig.add_axes([0.2, 0.19, 0.77, 0.77])
fig.set_facecolor('w')
ax.plot(x, y, "o", markersize = 2, label="Observed")
ax.plot(xf, pc(xf), label="Fitted", color = "green")
ax.set_xlabel('Normal return ($\sigma$)')
ax.set_ylabel('Empirical return ($\sigma$)')
ax.xaxis.set_major_locator(MultipleLocator(1))
ax.yaxis.set_major_locator(MultipleLocator(2))
ax.legend()
fig.savefig('hist_scatter_spline_fitted.pdf', format='pdf', facecolor=fig.get_facecolor(), transparent=True)
fig = plt.figure(figsize=(8*cm,6*cm))
ax = fig.add_axes([0.2, 0.19, 0.77, 0.77])
fig.set_facecolor('w')
ax.plot(cdf_x, cdf_y, label="Empirical")
ax.plot(cdf_x, norm.cdf(cdf_x), '--', label="Normal")
ax.plot(pc(xf), norm.cdf(xf), ':', label="Fitted") # plot the fitted
ax.set_xlim(-5, 4)
ax.set_ylim(0.005, 1.0)
ax.set_yscale("log")
ax.xaxis.set_major_locator(MultipleLocator(1))
#ax.yaxis.set_major_locator(MultipleLocator(0.2))
ax.set_xlabel('Return ($\sigma$)')
ax.set_ylabel('Cumulative probability')
ax.legend()
fig.savefig('hist_cdf_fitted_log.pdf', formt='pdf', facecolor=fig.get_facecolor(), transparent=True)
lookup = scipy.interpolate.interp1d(norm.cdf(cdf_x), cdf_x)
print(lookup(0.01))
lookup = scipy.interpolate.interp1d(cdf_y, cdf_x)
print(lookup(0.01))
lookup = scipy.interpolate.interp1d(norm.cdf(xf), pc(xf))
print(lookup(0.01))
rets = ts.returns(ticker) # 10 day log returns
rets = rets - np.mean(rets)
# normalize returns into units of (maximum-likelihood-estimated) standard deviations
sig = np.std(rets)
rets = rets / sig
# create discretised version
import scipy
cdf_fn = scipy.interpolate.interp1d(pc(xf), norm.cdf(xf))
def pdf_fn(x):
return (cdf_fn(x + 1e-9) - cdf_fn(x - 1e-9)) / 2e-9
xf2 = np.linspace(-4.8, 3.4, 100)
#plt.plot(xf2, cdf_fn(xf2))
fig = plt.figure(figsize=(8*cm,6*cm))
ax = fig.add_axes([0.2, 0.19, 0.77, 0.77])
fig.set_facecolor('w')
plt.plot(xf2, pdf_fn(xf2), label = "Fitted")
ax.hist(rets, density = True, bins = 100, label = "Empirical")
ax.set_xlim(-6, 4)
ax.set_xlabel('Return ($\sigma$)')
ax.set_ylabel('Probability density')
ax.legend()
fig.savefig('hist_pdf_spline_fitted.pdf', format='pdf', facecolor=fig.get_facecolor(), transparent=True)
from qiskit import execute, Aer, QuantumCircuit, QuantumRegister, ClassicalRegister, AncillaRegister
from qiskit.aqua.algorithms import IterativeAmplitudeEstimation
from qiskit.circuit.library import NormalDistribution, LogNormalDistribution, LinearAmplitudeFunction, IntegerComparator, WeightedAdder
from qiskit.visualization import plot_histogram
from quantum_mc.probability_distributions.gaussian_copula import GaussianCopula
rho = ts.correl(ts.returns("AAPL"), ts.returns("MSFT"))
mu = [0, 0]
sigma = [[1, rho], [rho, 1]]
num_qubits = [4, 4]
bounds = [(-3.4, 3.4), (-3.4, 3.4)]
def F(x):
return cdf_fn(x)
#return norm.cdf(x)
def f(x):
return pdf_fn(x)
#return norm.pdf(x)
cdfs = [F, F]
pdfs = [f, f]
pdf_circ = GaussianCopula(num_qubits, cdfs, sigma=sigma, bounds=bounds, pdfs = pdfs)
#pdf_circ = NormalDistribution(num_qubits, mu=mu, sigma=sigma, bounds=bounds)
qr_state1 = QuantumRegister(4, 'state1')
qr_state2 = QuantumRegister(4, 'state2')
state_out = ClassicalRegister(4, 'state_out')
circ = QuantumCircuit(qr_state1, qr_state2, state_out)
circ.append(pdf_circ, qr_state1[:] + qr_state2[:])
circ.measure(qr_state1, state_out)
circ.draw()
pdf_circ._probabilities
pdf_circ._values
pdf_circ._values[0]
comb = list(zip(pdf_circ._values, pdf_circ._probabilities))
print(comb[0])
values = sorted(set(map(lambda x:x[0], pdf_circ._values)))
#newlist = [sum([y[0] for y in values if y[1]==x]) for x in values]
print(values)
probs = [sum([y[1] for y in comb if y[0][0]==x]) for x in values]
print(probs)
#plt.plot(values, probs)
fig = plt.figure(figsize=(2*8*cm,8*cm))
ax = fig.add_axes([0.2, 0.19, 0.77, 0.77])
fig.set_facecolor('w')
rects = ax.bar(values, probs, width = 0.3)
ax.set_ylim(0, 0.3)
ax.set_xlabel('Return ($\sigma$)')
ax.set_ylabel('Probability')
labels = [r"$ | " + "{:04b}".format(i) + r" \rangle $" for i in range(len(values))]
ax.bar_label(rects, padding=4, labels = labels, rotation=60)
fig.savefig('hist_state.pdf', format='pdf', facecolor=fig.get_facecolor(), transparent=True)
#plt.plot(xf2, pdf_fn(xf2), label = "Fitted")
#fig = plt.figure(figsize=(8*cm,6*cm))
counts = execute(circ, Aer.get_backend('qasm_simulator', shots = 10000)).result().get_counts()
#plot_histogram(counts, figsize=(9,5))
fig = plt.figure(figsize=(2*8*cm,8*cm))
ax = fig.add_axes([0.2, 0.19, 0.77, 0.77])
fig.set_facecolor('w')
cnts = [counts.get(('{0:0%sb}' % 4).format(i), 0) for i, v in enumerate(values)]
cnts = np.array(cnts)
cnts = cnts / sum(cnts)
rects = ax.bar(values, cnts, width = 0.3)
ax.set_ylim(0, 0.3)
ax.set_xlabel('Return ($\sigma$)')
ax.set_ylabel('Probability')
labels = [r"$ | " + "{:04b}".format(i) + r" \rangle $" for i in range(len(values))]
ax.bar_label(rects, padding=4, labels = labels, rotation=60)
fig.savefig('hist_state_simulated.pdf', format='pdf', facecolor=fig.get_facecolor(), transparent=True)
shots=1000
#sim_statevector = Aer.get_backend('statevector_simulator')
job = execute(circ, Aer.get_backend('statevector_simulator'))
result = job.result()
outputstate = result.get_statevector(circ, decimals=3)
from qiskit.visualization import plot_state_city
plot_state_city(outputstate)
plt.plot(np.linspace(-4, 4, 100), np.exp(np.linspace(-4, 4, 100) * sigma) - 1)
Aer.backends()
|
https://github.com/aryashah2k/Quantum-Computing-Collection-Of-Resources
|
aryashah2k
|
#
# your code is here
#
# all portions are stored in a list
all_portions = [7,5,4,2,6,1];
# calculate the total portions
total_portion = 0
for i in range(6):
total_portion = total_portion + all_portions[i]
print("total is",total_portion)
# find the weight of one portion
one_portion = 1/total_portion
print("the weight of one portion is",one_portion)
print() # print an empty line
# now we can calculate the probabilities of getting 1,2,3,4,5, or 6
for i in range(6):
print("the probability of getting",(i+1),"is",(one_portion*all_portions[i]))
#
# your solution is here
#
# we randomly create a probabilistic state
#
# we should be careful about two things:
# 1. a probability value must be between 0 and 1
# 2. the total probability must be 1
#
# we use a list of size 4
# initial values are zeros
my_state = [0,0,0,0]
normalization_factor = 0 # this will be the summation of four values
# we pick for random values between 0 and 100
from random import randrange
while normalization_factor==0: # the normalization factor cannot be zero
for i in range(4):
my_state[i] = randrange(101) # pick a random value between 0 and (101-1)
normalization_factor += my_state[i]
print("the random values before the normalization",my_state)
# normalize each value
for i in range(4): my_state[i] = my_state[i]/normalization_factor
print("the random values after the normalization",my_state)
# find their summation
sum = 0
for i in range(4): sum += my_state[i]
print("the summation is",sum)
#
# your solution is here
#
|
https://github.com/swe-train/qiskit__qiskit
|
swe-train
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2021.
#
# 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.
"""Remove all barriers in a circuit"""
from qiskit.dagcircuit import DAGCircuit
from qiskit.transpiler.basepasses import TransformationPass
from qiskit.transpiler.passes.utils import control_flow
class RemoveBarriers(TransformationPass):
"""Return a circuit with any barrier removed.
This transformation is not semantics preserving.
Example:
.. plot::
:include-source:
from qiskit import QuantumCircuit
from qiskit.transpiler.passes import RemoveBarriers
circuit = QuantumCircuit(1)
circuit.x(0)
circuit.barrier()
circuit.h(0)
circuit = RemoveBarriers()(circuit)
circuit.draw('mpl')
"""
@control_flow.trivial_recurse
def run(self, dag: DAGCircuit) -> DAGCircuit:
"""Run the RemoveBarriers pass on `dag`."""
dag.remove_all_ops_named("barrier")
return dag
|
https://github.com/sarthag/Quantum-Algos-using-Qiskit
|
sarthag
|
# initialization
import numpy as np
import matplotlib
# importing Qiskit
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ, BasicAer, assemble, transpile
from qiskit.quantum_info import Statevector
# import basic plot tools
from qiskit.visualization import plot_bloch_multivector,plot_bloch_vector, plot_histogram
style = {'backgroundcolor': 'lightyellow'} # Style of the circuits
# set the length of the n-bit input string.
n = 3
# set the length of the n-bit input string.
n = 3
const_oracle = QuantumCircuit(n+1)
output = np.random.randint(2)
if output == 1:
const_oracle.x(n)
const_oracle.draw(output='mpl', style=style)
balanced_oracle = QuantumCircuit(n+1)
b_str = "101"
balanced_oracle = QuantumCircuit(n+1)
b_str = "101"
# Place X-gates
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
balanced_oracle.x(qubit)
balanced_oracle.draw(output='mpl', style=style)
balanced_oracle = QuantumCircuit(n+1)
b_str = "101"
# Place X-gates
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
balanced_oracle.x(qubit)
# Use barrier as divider
balanced_oracle.barrier()
# Controlled-NOT gates
for qubit in range(n):
balanced_oracle.cx(qubit, n)
balanced_oracle.barrier()
balanced_oracle.draw(output='mpl', style=style)
balanced_oracle = QuantumCircuit(n+1)
b_str = "101"
# Place X-gates
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
balanced_oracle.x(qubit)
# Use barrier as divider
balanced_oracle.barrier()
# Controlled-NOT gates
for qubit in range(n):
balanced_oracle.cx(qubit, n)
balanced_oracle.barrier()
# Place X-gates
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
balanced_oracle.x(qubit)
# Show oracle
balanced_oracle.draw(output='mpl', style=style)
dj_circuit = QuantumCircuit(n+1, n)
# Apply H-gates
for qubit in range(n):
dj_circuit.h(qubit)
# Put qubit in state |->
dj_circuit.x(n)
dj_circuit.h(n)
dj_circuit.draw(output='mpl', style=style)
dj_circuit = QuantumCircuit(n+1, n)
# Apply H-gates
for qubit in range(n):
dj_circuit.h(qubit)
# Put qubit in state |->
dj_circuit.x(n)
dj_circuit.h(n)
# Add oracle
dj_circuit += balanced_oracle
dj_circuit.draw(output='mpl', style=style)
dj_circuit = QuantumCircuit(n+1, n)
# Apply H-gates
for qubit in range(n):
dj_circuit.h(qubit)
# Put qubit in state |->
dj_circuit.x(n)
dj_circuit.h(n)
# Add oracle
dj_circuit += balanced_oracle
# Repeat H-gates
for qubit in range(n):
dj_circuit.h(qubit)
dj_circuit.barrier()
# Measure
for i in range(n):
dj_circuit.measure(i, i)
# Display circuit
dj_circuit.draw(output='mpl', style=style)
# use local simulator
aer_sim = Aer.get_backend('aer_simulator')
qobj = assemble(dj_circuit, aer_sim)
results = aer_sim.run(qobj).result()
answer = results.get_counts()
plot_histogram(answer)
def dj_oracle(case, n):
# We need to make a QuantumCircuit object to return
# This circuit has n+1 qubits: the size of the input,
# plus one output qubit
oracle_qc = QuantumCircuit(n+1)
# First, let's deal with the case in which oracle is balanced
if case == "balanced":
# First generate a random number that tells us which CNOTs to
# wrap in X-gates:
b = np.random.randint(1,2**n)
print(b)
print(str(n))
b=7
# Next, format 'b' as a binary string of length 'n', padded with zeros:
b_str = format(b, '0'+str(n)+'b')
print(b_str)
# Next, we place the first X-gates. Each digit in our binary string
# corresponds to a qubit, if the digit is 0, we do nothing, if it's 1
# we apply an X-gate to that qubit:
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
oracle_qc.x(qubit)
# Do the controlled-NOT gates for each qubit, using the output qubit
# as the target:
for qubit in range(n):
oracle_qc.cx(qubit, n)
# Next, place the final X-gates
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
oracle_qc.x(qubit)
# Case in which oracle is constant
if case == "constant":
# First decide what the fixed output of the oracle will be
# (either always 0 or always 1)
output = np.random.randint(2)
if output == 1:
oracle_qc.x(n)
oracle_gate = oracle_qc.to_gate()
oracle_gate.name = "Oracle" # To show when we display the circuit
return oracle_gate
def dj_algorithm(oracle, n):
dj_circuit = QuantumCircuit(n+1, n)
# Set up the output qubit:
dj_circuit.x(n)
dj_circuit.h(n)
# And set up the input register:
for qubit in range(n):
dj_circuit.h(qubit)
# Let's append the oracle gate to our circuit:
dj_circuit.append(oracle, range(n+1))
# Finally, perform the H-gates again and measure:
for qubit in range(n):
dj_circuit.h(qubit)
for i in range(n):
dj_circuit.measure(i, i)
return dj_circuit
n = 4
oracle_gate = dj_oracle('balanced', n)
dj_circuit = dj_algorithm(oracle_gate, n)
dj_circuit.draw(output='mpl', style=style)
transpiled_dj_circuit = transpile(dj_circuit, aer_sim)
qobj = assemble(transpiled_dj_circuit)
results = aer_sim.run(qobj).result()
answer = results.get_counts()
plot_histogram(answer)
|
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/shesha-raghunathan/DATE2019-qiskit-tutorial
|
shesha-raghunathan
|
import numpy as np
from scipy.linalg import expm
from qiskit import BasicAer
from qiskit import execute as q_execute
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.quantum_info import state_fidelity
from qiskit.aqua.operators import MatrixOperator, op_converter
from qiskit.aqua.components.initial_states import Custom
num_qubits = 2
evo_time = 1
temp = np.random.random((2 ** num_qubits, 2 ** num_qubits))
h1 = temp + temp.T
qubitOp = MatrixOperator(matrix=h1)
state_in = Custom(num_qubits, state='random')
state_in_vec = state_in.construct_circuit('vector')
groundtruth = expm(-1.j * h1 * evo_time) @ state_in_vec
print('The directly computed groundtruth evolution result state is\n{}.'.format(groundtruth))
groundtruth_evolution = qubitOp.evolve(state_in_vec, evo_time, num_time_slices=0)
print('The groundtruth evolution result as computed by the Dynamics algorithm is\n{}.'.format(groundtruth_evolution))
np.testing.assert_allclose(groundtruth_evolution, groundtruth)
qubit_op = op_converter.to_weighted_pauli_operator(qubitOp)
quantum_registers = QuantumRegister(qubit_op.num_qubits)
circuit = state_in.construct_circuit('circuit', quantum_registers)
circuit += qubit_op.evolve(
None, evo_time, num_time_slices=1,
quantum_registers=quantum_registers,
expansion_mode='suzuki',
expansion_order=3
)
circuit.draw(output='mpl')
backend = BasicAer.get_backend('statevector_simulator')
job = q_execute(circuit, backend)
circuit_execution_result = np.asarray(job.result().get_statevector(circuit))
print('The evolution result state from executing the Dynamics circuit is\n{}.'.format(circuit_execution_result))
print('Fidelity between the groundtruth and the circuit result states is {}.'.format(
state_fidelity(groundtruth, circuit_execution_result)
))
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# -*- 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/swe-bench/Qiskit__qiskit
|
swe-bench
|
# -*- 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/apcarrik/qiskit-dev
|
apcarrik
|
import math
import numpy as np
from qiskit import Aer
from qiskit.utils import QuantumInstance
from qiskit.algorithms import Shor
N = 15
backend = Aer.get_backend('aer_simulator')
quantum_instance = QuantumInstance(backend, shots=1024)
shor = Shor(quantum_instance=quantum_instance)
result = shor.factor(N)
print(f"The list of factors of {N} as computed by Shor's algorithm is {result.factors[0]}.")
print(f"Copmuted of qubits for circuit: {4 * math.ceil(math.log(N,2)) + 2}")
print(f"Actual number of qubits of circuit: {shor.construct_circuit(N).num_qubits}")
|
https://github.com/jvscursulim/qamp_fall22_project
|
jvscursulim
|
import numpy as np
import matplotlib.pyplot as plt
import imageio.v2 as imageio
from qiskit import execute, transpile
from qiskit.circuit import ClassicalRegister, QuantumCircuit, QuantumRegister
from qiskit.providers.aer.backends import AerSimulator
from qiskit.visualization import plot_histogram
from qiskit.quantum_info import DensityMatrix, state_fidelity, partial_trace
from skimage import data
from skimage.color import rgb2gray
from skimage.transform import resize
from neqr import NEQR
image_neqr = NEQR()
shots = 8192
backend = AerSimulator()
astronaut = data.astronaut()
astronaut.shape
plt.imshow(astronaut)
plt.show()
gray_astro = rgb2gray(astronaut)
plt.imshow(gray_astro, cmap="gray")
plt.show()
resized_gray_astro = resize(gray_astro, (2,2))
plt.imshow(resized_gray_astro, cmap="gray")
qubits_idx = QuantumRegister(size=2, name="qubits_idx")
intensity = QuantumRegister(size=8, name="intensity")
bits_idx = ClassicalRegister(size=2, name="bits_idx")
bits_intensity = ClassicalRegister(size=8, name="bits_intensity")
qc = QuantumCircuit(intensity, qubits_idx, bits_intensity, bits_idx)
qc.draw(output="mpl")
qc.h(qubit=qubits_idx)
qc.barrier()
qc.draw(output="mpl")
pixel_pos_intensity = []
for row in resized_gray_astro:
for item in row:
pixel_pos_intensity.append(int(np.round(255*item)))
bin_list = [bin(num)[2:] for num in pixel_pos_intensity]
for idx, bnum in enumerate(bin_list):
if idx == 0:
qc.x(qubit=qubits_idx)
for pos, item in enumerate(bnum[::-1]):
if item == "1":
qc.mct(control_qubits=qubits_idx, target_qubit=intensity[pos])
qc.x(qubit=qubits_idx)
qc.barrier()
elif idx == 1:
qc.x(qubit=qubits_idx[1])
for pos, item in enumerate(bnum[::-1]):
if item == "1":
qc.mct(control_qubits=qubits_idx, target_qubit=intensity[pos])
qc.x(qubit=qubits_idx[1])
qc.barrier()
elif idx == 2:
qc.x(qubit=qubits_idx[0])
for pos, item in enumerate(bnum[::-1]):
if item == "1":
qc.mct(control_qubits=qubits_idx, target_qubit=intensity[pos])
qc.x(qubit=qubits_idx[0])
qc.barrier()
else:
for pos, item in enumerate(bnum[::-1]):
if item == "1":
qc.mct(control_qubits=qubits_idx, target_qubit=intensity[pos])
qc.barrier()
qc.draw(output="mpl")
qc.measure(qubit=intensity, cbit=bits_intensity)
qc.barrier()
qc.measure(qubit=qubits_idx, cbit=bits_idx)
qc.draw(output="mpl")
print("Circuit dimensions")
print(f"Circuit depth: {qc.depth()}")
print(f"Circuit size: {qc.size()}")
print(f"Circuit operations: {qc.count_ops()}")
transpiled_qc = transpile(circuits=qc, basis_gates=["id", "x", "sx", "cx", "rz"])
transpiled_qc.draw(output="mpl")
print("Circuit dimensions")
print(f"Circuit depth: {transpiled_qc.depth()}")
print(f"Circuit size: {transpiled_qc.size()}")
print(f"Circuit operations: {transpiled_qc.count_ops()}")
qcircuit = image_neqr.image_quantum_circuit(image=resized_gray_astro, measurements=True)
qcircuit.draw(output="mpl")
print("Circuit dimensions")
print(f"Circuit depth: {qcircuit.depth()}")
print(f"Circuit size: {qcircuit.size()}")
print(f"Circuit operations: {qcircuit.count_ops()}")
counts = execute(experiments=qcircuit, backend=backend, shots=shots).result().get_counts()
plot_histogram(counts)
resized_gray_astro_33 = resize(gray_astro, (3,3))
plt.imshow(resized_gray_astro_33, cmap="gray")
qcircuit = image_neqr.image_quantum_circuit(image=resized_gray_astro_33, measurements=True)
qcircuit.draw(output="mpl")
print("Circuit dimensions")
print(f"Circuit depth: {qcircuit.depth()}")
print(f"Circuit size: {qcircuit.size()}")
print(f"Circuit operations: {qcircuit.count_ops()}")
counts = execute(experiments=qcircuit, backend=backend, shots=shots).result().get_counts()
keys_list = [key for key, _ in sorted(counts.items())][:9]
processed_counts = {key: counts[key] for key in keys_list}
plot_histogram(processed_counts)
test_matrix = np.array([[0,0,0],[0,1,0],[0,1,0],[0,0,0]])
plt.imshow(test_matrix, cmap="gray")
qcircuit = image_neqr.image_quantum_circuit(image=test_matrix, measurements=True)
qcircuit.draw(output="mpl")
print("Circuit dimensions")
print(f"Circuit depth: {qcircuit.depth()}")
print(f"Circuit size: {qcircuit.size()}")
print(f"Circuit operations: {qcircuit.count_ops()}")
counts = execute(experiments=qcircuit, backend=backend, shots=shots).result().get_counts()
plot_histogram(counts)
test_matrix = np.array([[0,1,0]])
plt.imshow(test_matrix, cmap="gray")
qcircuit = image_neqr.image_quantum_circuit(image=test_matrix, measurements=True)
qcircuit.draw(output="mpl")
print("Circuit dimensions")
print(f"Circuit depth: {qcircuit.depth()}")
print(f"Circuit size: {qcircuit.size()}")
print(f"Circuit operations: {qcircuit.count_ops()}")
counts = execute(experiments=qcircuit, backend=backend, shots=shots).result().get_counts()
keys_list = [key for key, _ in sorted(counts.items())][:3]
processed_counts = {key: counts[key] for key in keys_list}
plot_histogram(processed_counts)
test_image = np.array([[0,0],[0,0]])
plt.imshow(test_image, cmap="gray")
qc = image_neqr.image_quantum_circuit(image=test_image)
qc.draw(output="mpl")
dm = DensityMatrix(data=qc)
dm
dm_reduced = partial_trace(state=dm, qargs=[8,9])
dm_reduced
state_fidelity(dm_reduced, dm_reduced)
test_image2 = np.array([[1,1],[1,1]])
plt.imshow(test_image2, cmap="gray")
qc2 = image_neqr.image_quantum_circuit(image=test_image2)
qc2.draw(output="mpl")
dm2 = DensityMatrix(data=qc2)
dm2
dm_reduced2 = partial_trace(state=dm2, qargs=[8,9])
dm_reduced2
state_fidelity(dm_reduced, dm_reduced2)
resized_rgb_astro = resize(astronaut, (2,2))
plt.imshow(resized_rgb_astro)
qc = image_neqr.image_quantum_circuit(image=resized_rgb_astro, measurements=True)
qc.draw(output="mpl")
print("Circuit dimensions")
print(f"Circuit depth: {qc.depth()}")
print(f"Circuit size: {qc.size()}")
print(f"Circuit operations: {qc.count_ops()}")
counts = execute(experiments=qc, backend=backend, shots=shots).result().get_counts()
keys_list = [key for key, _ in sorted(counts.items())][:12]
processed_counts = {key: counts[key] for key in keys_list}
plot_histogram(processed_counts)
|
https://github.com/hephaex/Quantum-Computing-Awesome-List
|
hephaex
|
# Importing everything
from qiskit import *
from qiskit.visualization import plot_histogram
# For Jupyter Notebooks, change the settings to get nicer images
%config InlineBackend.figure_format = 'svg'
def create_bell_pair(qc, a, b):
qc.h(a)
qc.cx(a, b)
def encode_message(qc, qubit, message):
if message == "00":
pass
elif message == "01":
qc.z(qubit)
elif message == "10":
qc.x(qubit)
elif message == "11":
qc.z(qubit)
qz.x(qubit)
else:
print("Enter Valid message please")
def decode_message(qc, a, b):
qc.cx(a, b)
qc.h(a)
# Create the quantum circuit with 2 qubits
qc = QuantumCircuit(2)
# First, Eve creates the entangled pair between Alice and Bob
create_bell_pair(qc, 0, 1)
qc.barrier() # This adds a barrier to our circuit. A barrier
# separates the gates in our diagram and makes it
# clear which part of the circuit is which
# At this point, qubit 0 goes to Alice and qubit 1 goes to Bob
# Next, Alice encodes her message onto qubit 0. In this case,
# we want to send the message '10'. You can try changing this
# value and see how it affects the circuit
message = "10"
encode_message(qc, 0, message)
qc.barrier()
# Alice then sends her qubit to Bob.
# After recieving qubit 0, Bob applies the recovery protocol:
decode_message(qc, 0, 1)
# Finally, Bob measures his qubits to read Alice's message
qc.measure_all()
# Draw our output
qc.draw(output = "mpl")
backend = Aer.get_backend('qasm_simulator')
job_sim = execute(qc, backend, shots=1024)
sim_result = job_sim.result()
measurement_result = sim_result.get_counts(qc)
print(measurement_result)
plot_histogram(measurement_result)
from qiskit import IBMQ
from qiskit.providers.ibmq import least_busy
shots = 256
# Load local account information
IBMQ.load_account()
# Get the least busy backend
provider = IBMQ.get_provider(hub='ibm-q')
backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 2
and not x.configuration().simulator
and x.status().operational==True))
print("least busy backend: ", backend)
# Run our circuit
job = execute(qc, backend=backend, shots=shots)
from qiskit.tools.monitor import job_monitor
job_monitor(job)
result = job.result()
plot_histogram(result.get_counts(qc))
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.dagcircuit import DAGCircuit
from qiskit.converters import circuit_to_dag
from qiskit.visualization import dag_drawer
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)
dag = circuit_to_dag(circ)
dag_drawer(dag)
|
https://github.com/BOBO1997/osp_solutions
|
BOBO1997
|
import numpy as np
import matplotlib.pyplot as plt
import itertools
from pprint import pprint
# plt.rcParams.update({'font.size': 16}) # enlarge matplotlib fonts
import time
import datetime
# Import qubit states Zero (|0>) and One (|1>), and Pauli operators (X, Y, Z)
from qiskit.opflow import Zero, One, I, X, Y, Z
from qiskit import QuantumCircuit, QuantumRegister, IBMQ, execute, transpile, Aer
from qiskit.tools.monitor import job_monitor
from qiskit.circuit import Parameter
from qiskit.transpiler.passes import RemoveBarriers
# Import QREM package
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
from qiskit.ignis.mitigation import expectation_value
# Import mitiq for zne
import mitiq
# Import state tomography modules
from qiskit.ignis.verification.tomography import state_tomography_circuits
from qiskit.quantum_info import state_fidelity
import sys
import importlib
sys.path.append("./")
import circuit_utils, zne_utils, tomography_utils, sgs_algorithm
importlib.reload(circuit_utils)
importlib.reload(zne_utils)
importlib.reload(tomography_utils)
importlib.reload(sgs_algorithm)
from circuit_utils import *
from zne_utils import *
from tomography_utils import *
from sgs_algorithm import *
# Combine subcircuits into a single multiqubit gate representing a single trotter step
num_qubits = 3
# The final time of the state evolution
target_time = np.pi
# Parameterize variable t to be evaluated at t=pi later
dt = Parameter('t')
# Convert custom quantum circuit into a gate
trot_gate = trotter_gate(dt)
# initial layout
initial_layout = [5,3,1]
# Number of trotter steps
num_steps = 100
print("trotter step: ", num_steps)
scale_factors = [1.0, 2.0, 3.0, 4.0, 5.0]
# Initialize quantum circuit for 3 qubits
qr = QuantumRegister(num_qubits, name="q")
qc = QuantumCircuit(qr)
# Prepare initial state (remember we are only evolving 3 of the 7 qubits on jakarta qubits (q_5, q_3, q_1) corresponding to the state |110>)
make_initial_state(qc, "110") # DO NOT MODIFY (|q_5,q_3,q_1> = |110>)
subspace_encoder_init110(qc, targets=[0, 1, 2]) # encode
trotterize(qc, trot_gate, num_steps, targets=[1, 2]) # Simulate time evolution under H_heis3 Hamiltonian
subspace_decoder(qc, targets=[0,1,2]) # decode
# Evaluate simulation at target_time (t=pi) meaning each trotter step evolves pi/trotter_steps in time
t1 = time.perf_counter()
qc = qc.bind_parameters({dt: target_time / num_steps})
t2 = time.perf_counter()
print("created qc,", t2 - t1, "s")
# Generate state tomography circuits to evaluate fidelity of simulation
t1 = time.perf_counter()
st_qcs = state_tomography_circuits(qc, [0, 1, 2][::-1]) #! state tomography requires === BIG ENDIAN ===
t2 = time.perf_counter()
print("created st_qcs (length:", len(st_qcs), "),", t2 - t1, "s")
# remove barriers
t1 = time.perf_counter()
st_qcs = [RemoveBarriers()(qc) for qc in st_qcs]
t2 = time.perf_counter()
print("removed barriers from st_qcs,", t2 - t1, "s")
# optimize circuit
t1 = time.perf_counter()
t3_st_qcs = transpile(st_qcs, optimization_level=3, basis_gates=["sx", "cx", "rz"])
t2 = time.perf_counter()
print("created t3_st_qcs (length:", len(t3_st_qcs), "),", t2 - t1, "s")
t3_st_qcs[0].draw("mpl")
# zne wrapping
t1 = time.perf_counter()
zne_qcs = zne_wrapper(t3_st_qcs, scale_factors=scale_factors)
t2 = time.perf_counter()
print("created zne_qcs (length:", len(zne_qcs), "),", t2 - t1, "s")
t1 = time.perf_counter()
zne_qcs = transpile(zne_qcs, optimization_level=0, basis_gates=["sx", "cx", "rz"])
t2 = time.perf_counter()
print("decomposed zne_qcs into basis gates (length:", len(zne_qcs), "),", t2 - t1, "s")
t1 = time.perf_counter()
t3_zne_qcs = transpile(zne_qcs, optimization_level=3, basis_gates=["sx", "cx", "rz"])
t2 = time.perf_counter()
print("optimized zne_qcs -> create t3_zne_qcs (length:", len(t3_zne_qcs), "),", t2 - t1, "s")
t1 = time.perf_counter()
t3_zne_qcs = transpile(t3_zne_qcs, optimization_level=0, basis_gates=["sx", "cx", "rz"], initial_layout=initial_layout)
t2 = time.perf_counter()
print("fit the t3_zne_qcs to the initial layoit (length:", len(t3_zne_qcs), "),", t2 - t1, "s")
t3_zne_qcs[-3].draw("mpl")
from qiskit.test.mock import FakeJakarta
backend = FakeJakarta()
# backend = Aer.get_backend("qasm_simulator")
# IBMQ.load_account()
# provider = IBMQ.get_provider(hub='ibm-q-utokyo', group='internal', project='hirashi-jst')
# provider = IBMQ.get_provider(hub='ibm-q-community', group='ibmquantumawards', project='open-science-22')
# print("provider:", provider)
# backend = provider.get_backend("ibmq_jakarta")
shots = 1 << 13
reps = 1 # unused
# Number of trotter steps
print("trotter step: ", num_steps)
# execute: reps = 1
job = execute(t3_zne_qcs, backend, shots=shots) # ζ―εγγ§γγ―: γγγ‘γγγ¨ε€γγοΌ
print('Job ID', job.job_id())
# QREM
qr = QuantumRegister(num_qubits)
meas_calibs, state_labels = complete_meas_cal(qr=qr, circlabel='mcal')
cal_job = execute(meas_calibs, backend=backend, shots=shots, optimization_level=3, initial_layout = initial_layout)
print('Job ID', cal_job.job_id())
cal_results = cal_job.result()
meas_fitter = CompleteMeasFitter(cal_results, state_labels, circlabel='mcal')
mit_results = meas_fitter.filter.apply(job.result())
zne_expvals = zne_decoder(num_qubits, mit_results)
target_state = (One^One^Zero).to_matrix() # DO NOT CHANGE!!!
rho = expvals_to_valid_rho(num_qubits, zne_expvals)
fidelity = state_fidelity(rho, target_state)
print(fidelity)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.algorithms.optimizers import SLSQP
from qiskit.circuit.library import TwoLocal
num_qubits = 2
ansatz = TwoLocal(num_qubits, "ry", "cz")
optimizer = SLSQP(maxiter=1000)
ansatz.decompose().draw("mpl", style="iqx")
from qiskit.primitives import Estimator
estimator = Estimator()
from qiskit.algorithms.minimum_eigensolvers import VQE
vqe = VQE(estimator, ansatz, optimizer)
from qiskit.quantum_info import SparsePauliOp
H2_op = SparsePauliOp.from_list([
("II", -1.052373245772859),
("IZ", 0.39793742484318045),
("ZI", -0.39793742484318045),
("ZZ", -0.01128010425623538),
("XX", 0.18093119978423156)
])
result = vqe.compute_minimum_eigenvalue(H2_op)
print(result)
from qiskit.algorithms.optimizers import SPSA
estimator = Estimator(options={"shots": 1000})
vqe.estimator = estimator
vqe.optimizer = SPSA(maxiter=100)
result = vqe.compute_minimum_eigenvalue(operator=H2_op)
print(result)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/community.qiskit.org
|
qiskit-community
|
from qiskit import *
qc = QuantumCircuit()
qr = QuantumRegister(2,'qreg')
qc.add_register( qr )
qc.qregs
qc.draw(output='mpl')
qc.h()
qc.h( qr[0] )
qc.cx( qr[0], qr[1] );
qc.draw(output='mpl')
vector_sim = Aer.get_backend('statevector_simulator')
Aer.backends()
job = execute( qc, vector_sim )
ket = job.result().get_statevector()
for amplitude in ket:
print(amplitude)
new_qc = QuantumCircuit( qr )
new_qc.initialize( ket, qr )
new_qc.draw(output='mpl')
cr = ClassicalRegister(2,'creg')
qc.add_register(cr)
qc.measure(qr[0],cr[0])
qc.measure(qr[1],cr[1])
qc.draw(output='mpl')
emulator = Aer.get_backend('qasm_simulator')
job = execute( qc, emulator, shots=8192 )
hist = job.result().get_counts()
print(hist)
from qiskit.tools.visualization import plot_histogram
plot_histogram( hist )
job = execute( qc, emulator, shots=10, memory=True )
samples = job.result().get_memory()
print(samples)
qubit = QuantumRegister(8)
bit = ClassicalRegister(8)
circuit = QuantumCircuit(qubit,bit)
circuit.x(qubit[7])
circuit.measure(qubit,bit) # this is a way to do all the qc.measure(qr8[j],cr8[j]) at once
execute( circuit, emulator, shots=8192 ).result().get_counts()
qc = QuantumCircuit(3)
qc.h(1)
qc.draw(output='mpl')
qc = QuantumCircuit(2,1)
qc.h(0)
qc.cx(0,1)
qc.measure(1,0)
qc.draw(output='mpl')
sub_circuit = QuantumCircuit(3, name='toggle_cx')
sub_circuit.cx(0,1)
sub_circuit.cx(1,2)
sub_circuit.cx(0,1)
sub_circuit.cx(1,2)
sub_circuit.draw(output='mpl')
toggle_cx = sub_circuit.to_instruction()
qr = QuantumRegister(4)
new_qc = QuantumCircuit(qr)
new_qc.append(toggle_cx, [qr[1],qr[2],qr[3]])
new_qc.draw(output='mpl')
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
provider.backends()
for backend in provider.backends():
print( backend.status() )
real_device = provider.get_backend('ibmq_16_melbourne')
properties = real_device.properties()
coupling_map = real_device.configuration().coupling_map
from qiskit.providers.aer import noise
noise_model = noise.device.basic_device_noise_model(properties)
qc = QuantumCircuit(2,2)
qc.x(1)
qc.measure(0,0)
qc.measure(1,1)
job = execute(qc, emulator, shots=1024, noise_model=noise_model,
coupling_map=coupling_map,
basis_gates=noise_model.basis_gates)
job.result().get_counts()
|
https://github.com/QuSTaR/kaleidoscope
|
QuSTaR
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 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.
# pylint: disable=invalid-name
"""Interactive error map for IBM Quantum Experience devices."""
import math
from typing import Tuple, Union
import numpy as np
from plotly.subplots import make_subplots
import plotly.graph_objects as go
import matplotlib as mpl
from qiskit.providers.ibmq.ibmqbackend import IBMQBackend
from .plotly_wrapper import PlotlyWidget, PlotlyFigure
from ..device_layouts import DEVICE_LAYOUTS
from ..colormaps import (HELIX_LIGHT, HELIX_LIGHT_CMAP,
HELIX_DARK, HELIX_DARK_CMAP)
from ..exceptions import VisualizationValueError, VisualizationTypeError
def iplot_error_map(
backend: IBMQBackend,
figsize: Tuple[int] = (800, 500),
show_title: bool = True,
remove_badcal_edges: bool = True,
background_color: str = 'white',
as_widget: bool = False
) -> Union[PlotlyFigure, PlotlyWidget]:
"""Plot the error map of a device.
Args:
backend: Plot the error map for this backend.
figsize: Figure size in pixels.
show_title: Whether to show figure title.
remove_badcal_edges: Whether to remove bad CX gate calibration data.
background_color: Background color, either 'white' or 'black'.
as_widget: ``True`` if the figure is to be returned as a ``PlotlyWidget``.
Otherwise the figure is to be returned as a ``PlotlyFigure``.
Returns:
The error map figure.
Raises:
VisualizationValueError: If an invalid input is received.
VisualizationTypeError: If the specified `backend` is a simulator.
Example:
.. jupyter-execute::
:hide-code:
:hide-output:
from qiskit.test.ibmq_mock import mock_get_backend
mock_get_backend('FakeVigo')
.. jupyter-execute::
from qiskit import IBMQ
from qiskit.providers.ibmq.visualization import iplot_error_map
IBMQ.load_account()
provider = IBMQ.get_provider(group='open', project='main')
backend = provider.get_backend('ibmq_vigo')
iplot_error_map(backend, as_widget=True)
"""
meas_text_color = '#000000'
if background_color == 'white':
color_map = HELIX_LIGHT_CMAP
text_color = '#000000'
plotly_cmap = HELIX_LIGHT
elif background_color == 'black':
color_map = HELIX_DARK_CMAP
text_color = '#FFFFFF'
plotly_cmap = HELIX_DARK
else:
raise VisualizationValueError(
'"{}" is not a valid background_color selection.'.format(background_color))
if backend.configuration().simulator:
raise VisualizationTypeError('Requires a device backend, not a simulator.')
config = backend.configuration()
n_qubits = config.n_qubits
cmap = config.coupling_map
if n_qubits in DEVICE_LAYOUTS.keys():
grid_data = DEVICE_LAYOUTS[n_qubits]
else:
fig = go.Figure()
fig.update_layout(showlegend=False,
plot_bgcolor=background_color,
paper_bgcolor=background_color,
width=figsize[0], height=figsize[1],
margin=dict(t=60, l=0, r=0, b=0)
)
out = PlotlyWidget(fig)
return out
props = backend.properties().to_dict()
t1s = []
t2s = []
for qubit_props in props['qubits']:
count = 0
for item in qubit_props:
if item['name'] == 'T1':
t1s.append(item['value'])
count += 1
elif item['name'] == 'T2':
t2s.append(item['value'])
count += 1
if count == 2:
break
# U2 error rates
single_gate_errors = [0]*n_qubits
for gate in props['gates']:
if gate['gate'] == 'u2':
_qubit = gate['qubits'][0]
single_gate_errors[_qubit] = gate['parameters'][0]['value']
# Convert to percent
single_gate_errors = 100 * np.asarray(single_gate_errors)
avg_1q_err = np.mean(single_gate_errors)
max_1q_err = max(single_gate_errors)
single_norm = mpl.colors.Normalize(
vmin=min(single_gate_errors), vmax=max_1q_err)
q_colors = [mpl.colors.rgb2hex(color_map(single_norm(err))) for err in single_gate_errors]
line_colors = []
cx_idx = []
if n_qubits > 1 and cmap:
cx_errors = []
for cmap_qubits in cmap:
for gate in props['gates']:
if gate['qubits'] == cmap_qubits:
cx_errors.append(gate['parameters'][0]['value'])
break
else:
continue
# Convert to percent
cx_errors = 100 * np.asarray(cx_errors)
# remove bad cx edges
if remove_badcal_edges:
cx_idx = np.where(cx_errors != 100.0)[0]
else:
cx_idx = np.arange(len(cx_errors))
avg_cx_err = np.mean(cx_errors[cx_idx])
for err in cx_errors:
if err != 100.0 or not remove_badcal_edges:
cx_norm = mpl.colors.Normalize(
vmin=min(cx_errors[cx_idx]), vmax=max(cx_errors[cx_idx]))
line_colors.append(mpl.colors.rgb2hex(color_map(cx_norm(err))))
else:
line_colors.append("#ff0000")
# Measurement errors
read_err = []
for qubit in range(n_qubits):
for item in props['qubits'][qubit]:
if item['name'] == 'readout_error':
read_err.append(item['value'])
read_err = 100 * np.asarray(read_err)
avg_read_err = np.mean(read_err)
max_read_err = np.max(read_err)
if n_qubits < 10:
num_left = n_qubits
num_right = 0
else:
num_left = math.ceil(n_qubits / 2)
num_right = n_qubits - num_left
x_max = max([d[1] for d in grid_data])
y_max = max([d[0] for d in grid_data])
max_dim = max(x_max, y_max)
qubit_size = 32
font_size = 14
offset = 0
if cmap:
if y_max / max_dim < 0.33:
qubit_size = 24
font_size = 10
offset = 1
if n_qubits > 5:
right_meas_title = "Readout Error (%)"
else:
right_meas_title = None
if cmap and cx_idx.size > 0:
cx_title = "CNOT Error Rate [Avg. {}%]".format(np.round(avg_cx_err, 3))
else:
cx_title = None
fig = make_subplots(rows=2, cols=11, row_heights=[0.95, 0.05],
vertical_spacing=0.15,
specs=[[{"colspan": 2}, None, {"colspan": 6},
None, None, None,
None, None, {"colspan": 2},
None, None],
[{"colspan": 4}, None, None,
None, None, None,
{"colspan": 4}, None, None,
None, None]],
subplot_titles=("Readout Error (%)", None, right_meas_title,
"Hadamard Error Rate [Avg. {}%]".format(
np.round(avg_1q_err, 3)),
cx_title)
)
# Add lines for couplings
if cmap and n_qubits > 1 and cx_idx.size > 0:
for ind, edge in enumerate(cmap):
is_symmetric = False
if edge[::-1] in cmap:
is_symmetric = True
y_start = grid_data[edge[0]][0] + offset
x_start = grid_data[edge[0]][1]
y_end = grid_data[edge[1]][0] + offset
x_end = grid_data[edge[1]][1]
if is_symmetric:
if y_start == y_end:
x_end = (x_end - x_start) / 2 + x_start
x_mid = x_end
y_mid = y_start
elif x_start == x_end:
y_end = (y_end - y_start) / 2 + y_start
x_mid = x_start
y_mid = y_end
else:
x_end = (x_end - x_start) / 2 + x_start
y_end = (y_end - y_start) / 2 + y_start
x_mid = x_end
y_mid = y_end
else:
if y_start == y_end:
x_mid = (x_end - x_start) / 2 + x_start
y_mid = y_end
elif x_start == x_end:
x_mid = x_end
y_mid = (y_end - y_start) / 2 + y_start
else:
x_mid = (x_end - x_start) / 2 + x_start
y_mid = (y_end - y_start) / 2 + y_start
fig.add_trace(
go.Scatter(x=[x_start, x_mid, x_end],
y=[-y_start, -y_mid, -y_end],
mode="lines",
line=dict(width=6,
color=line_colors[ind]),
hoverinfo='text',
hovertext='CX<sub>err</sub>{B}_{A} = {err} %'.format(
A=edge[0], B=edge[1], err=np.round(cx_errors[ind], 3))
),
row=1, col=3)
# Add the qubits themselves
qubit_text = []
qubit_str = "<b>Qubit {}</b><br>H<sub>err</sub> = {} %"
qubit_str += "<br>T1 = {} \u03BCs<br>T2 = {} \u03BCs"
for kk in range(n_qubits):
qubit_text.append(qubit_str.format(kk,
np.round(single_gate_errors[kk], 3),
np.round(t1s[kk], 2),
np.round(t2s[kk], 2)))
if n_qubits > 20:
qubit_size = 23
font_size = 11
if n_qubits > 50:
qubit_size = 20
font_size = 9
qtext_color = []
for ii in range(n_qubits):
if background_color == 'black':
if single_gate_errors[ii] > 0.8*max_1q_err:
qtext_color.append('black')
else:
qtext_color.append('white')
else:
qtext_color.append('white')
fig.add_trace(go.Scatter(
x=[d[1] for d in grid_data],
y=[-d[0]-offset for d in grid_data],
mode="markers+text",
marker=go.scatter.Marker(size=qubit_size,
color=q_colors,
opacity=1),
text=[str(ii) for ii in range(n_qubits)],
textposition="middle center",
textfont=dict(size=font_size, color=qtext_color),
hoverinfo="text",
hovertext=qubit_text), row=1, col=3)
fig.update_xaxes(row=1, col=3, visible=False)
_range = None
if offset:
_range = [-3.5, 0.5]
fig.update_yaxes(row=1,
col=3,
visible=False,
range=_range)
# H error rate colorbar
min_1q_err = min(single_gate_errors)
max_1q_err = max(single_gate_errors)
if n_qubits > 1:
fig.add_trace(go.Heatmap(z=[np.linspace(min_1q_err,
max_1q_err, 100),
np.linspace(min_1q_err,
max_1q_err, 100)],
colorscale=plotly_cmap,
showscale=False,
hoverinfo='none'), row=2, col=1)
fig.update_yaxes(row=2,
col=1,
visible=False)
fig.update_xaxes(row=2,
col=1,
tickvals=[0, 49, 99],
ticktext=[np.round(min_1q_err, 3),
np.round((max_1q_err-min_1q_err)/2+min_1q_err, 3),
np.round(max_1q_err, 3)])
# CX error rate colorbar
if cmap and n_qubits > 1 and cx_idx.size > 0:
min_cx_err = min(cx_errors)
max_cx_err = max(cx_errors)
if min_cx_err == max_cx_err:
min_cx_err = 0 # Force more than 1 color.
fig.add_trace(go.Heatmap(z=[np.linspace(min_cx_err,
max_cx_err, 100),
np.linspace(min_cx_err,
max_cx_err, 100)],
colorscale=plotly_cmap,
showscale=False,
hoverinfo='none'), row=2, col=7)
fig.update_yaxes(row=2, col=7, visible=False)
min_cx_idx_err = min(cx_errors[cx_idx])
max_cx_idx_err = max(cx_errors[cx_idx])
fig.update_xaxes(row=2, col=7,
tickvals=[0, 49, 99],
ticktext=[np.round(min_cx_idx_err, 3),
np.round((max_cx_idx_err-min_cx_idx_err)/2+min_cx_idx_err, 3),
np.round(max_cx_idx_err, 3)])
hover_text = "<b>Qubit {}</b><br>M<sub>err</sub> = {} %"
# Add the left side meas errors
for kk in range(num_left-1, -1, -1):
fig.add_trace(go.Bar(x=[read_err[kk]], y=[kk],
orientation='h',
marker=dict(color='#eedccb'),
hoverinfo="text",
hoverlabel=dict(font=dict(color=meas_text_color)),
hovertext=[hover_text.format(kk,
np.round(read_err[kk], 3)
)]
),
row=1, col=1)
fig.add_trace(go.Scatter(x=[avg_read_err, avg_read_err],
y=[-0.25, num_left-1+0.25],
mode='lines',
hoverinfo='none',
line=dict(color=text_color,
width=2,
dash='dot')), row=1, col=1)
fig.update_yaxes(row=1, col=1,
tickvals=list(range(num_left)),
autorange="reversed")
fig.update_xaxes(row=1, col=1,
range=[0, 1.1*max_read_err],
tickvals=[0, np.round(avg_read_err, 2),
np.round(max_read_err, 2)],
showline=True, linewidth=1, linecolor=text_color,
tickcolor=text_color,
ticks="outside",
showgrid=False,
zeroline=False)
# Add the right side meas errors, if any
if num_right:
for kk in range(n_qubits-1, num_left-1, -1):
fig.add_trace(go.Bar(x=[-read_err[kk]],
y=[kk],
orientation='h',
marker=dict(color='#eedccb'),
hoverinfo="text",
hoverlabel=dict(font=dict(color=meas_text_color)),
hovertext=[hover_text.format(kk,
np.round(read_err[kk], 3))]
),
row=1, col=9)
fig.add_trace(go.Scatter(x=[-avg_read_err, -avg_read_err],
y=[num_left-0.25, n_qubits-1+0.25],
mode='lines',
hoverinfo='none',
line=dict(color=text_color,
width=2,
dash='dot')
), row=1, col=9)
fig.update_yaxes(row=1,
col=9,
tickvals=list(range(n_qubits-1, num_left-1, -1)),
side='right',
autorange="reversed",
)
fig.update_xaxes(row=1,
col=9,
range=[-1.1*max_read_err, 0],
tickvals=[0, -np.round(avg_read_err, 2), -np.round(max_read_err, 2)],
ticktext=[0, np.round(avg_read_err, 2), np.round(max_read_err, 2)],
showline=True, linewidth=1, linecolor=text_color,
tickcolor=text_color,
ticks="outside",
showgrid=False,
zeroline=False)
# Makes the subplot titles smaller than the 16pt default
for ann in fig['layout']['annotations']:
ann['font'] = dict(size=13)
title_text = "{} Error Map".format(backend.name()) if show_title else ''
fig.update_layout(showlegend=False,
plot_bgcolor=background_color,
paper_bgcolor=background_color,
width=figsize[0], height=figsize[1],
title=dict(text=title_text, x=0.452),
title_font_size=20,
font=dict(color=text_color),
margin=dict(t=60, l=0, r=40, b=0)
)
if as_widget:
return PlotlyWidget(fig)
return PlotlyFigure(fig)
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2022, 2023.
#
# 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.
# =============================================================================
"""Test QFI."""
import unittest
from ddt import ddt, data
import numpy as np
from qiskit import QuantumCircuit
from qiskit_algorithms.gradients import LinCombQGT, ReverseQGT, QFI, DerivativeType
from qiskit.circuit import Parameter
from qiskit.circuit.parametervector import ParameterVector
from qiskit.primitives import Estimator
from qiskit.test import QiskitTestCase
@ddt
class TestQFI(QiskitTestCase):
"""Test QFI"""
def setUp(self):
super().setUp()
self.estimator = Estimator()
self.lcu_qgt = LinCombQGT(self.estimator, derivative_type=DerivativeType.REAL)
self.reverse_qgt = ReverseQGT(derivative_type=DerivativeType.REAL)
def test_qfi(self):
"""Test if the quantum fisher information calculation is correct for a simple test case.
QFI = [[1, 0], [0, 1]] - [[0, 0], [0, cos^2(a)]]
"""
# create the circuit
a, b = Parameter("a"), Parameter("b")
qc = QuantumCircuit(1)
qc.h(0)
qc.rz(a, 0)
qc.rx(b, 0)
param_list = [[np.pi / 4, 0.1], [np.pi, 0.1], [np.pi / 2, 0.1]]
correct_values = [[[1, 0], [0, 0.5]], [[1, 0], [0, 0]], [[1, 0], [0, 1]]]
qfi = QFI(self.lcu_qgt)
for i, param in enumerate(param_list):
qfis = qfi.run([qc], [param]).result().qfis
np.testing.assert_allclose(qfis[0], correct_values[i], atol=1e-3)
def test_qfi_phase_fix(self):
"""Test the phase-fix argument in the QFI calculation"""
# create the circuit
a, b = Parameter("a"), Parameter("b")
qc = QuantumCircuit(1)
qc.h(0)
qc.rz(a, 0)
qc.rx(b, 0)
param = [np.pi / 4, 0.1]
# test for different values
correct_values = [[1, 0], [0, 1]]
qgt = LinCombQGT(self.estimator, phase_fix=False)
qfi = QFI(qgt)
qfis = qfi.run([qc], [param]).result().qfis
np.testing.assert_allclose(qfis[0], correct_values, atol=1e-3)
@data("lcu", "reverse")
def test_qfi_maxcut(self, qgt_kind):
"""Test the QFI for a simple MaxCut problem.
This is interesting because it contains the same parameters in different gates.
"""
# create maxcut circuit for the hamiltonian
# H = (I ^ I ^ Z ^ Z) + (I ^ Z ^ I ^ Z) + (Z ^ I ^ I ^ Z) + (I ^ Z ^ Z ^ I)
x = ParameterVector("x", 2)
ansatz = QuantumCircuit(4)
# initial hadamard layer
ansatz.h(ansatz.qubits)
# e^{iZZ} layers
def expiz(qubit0, qubit1):
ansatz.cx(qubit0, qubit1)
ansatz.rz(2 * x[0], qubit1)
ansatz.cx(qubit0, qubit1)
expiz(2, 1)
expiz(3, 0)
expiz(2, 0)
expiz(1, 0)
# mixer layer with RX gates
for i in range(ansatz.num_qubits):
ansatz.rx(2 * x[1], i)
reference = np.array([[16.0, -5.551], [-5.551, 18.497]])
param = [0.4, 0.69]
qgt = self.lcu_qgt if qgt_kind == "lcu" else self.reverse_qgt
qfi = QFI(qgt)
qfi_result = qfi.run([ansatz], [param]).result().qfis
np.testing.assert_array_almost_equal(qfi_result[0], reference, decimal=3)
def test_options(self):
"""Test QFI's options"""
a = Parameter("a")
qc = QuantumCircuit(1)
qc.rx(a, 0)
qgt = LinCombQGT(estimator=self.estimator, options={"shots": 100})
with self.subTest("QGT"):
qfi = QFI(qgt=qgt)
options = qfi.options
result = qfi.run([qc], [[1]]).result()
self.assertEqual(result.options.get("shots"), 100)
self.assertEqual(options.get("shots"), 100)
with self.subTest("QFI init"):
qfi = QFI(qgt=qgt, options={"shots": 200})
result = qfi.run([qc], [[1]]).result()
options = qfi.options
self.assertEqual(result.options.get("shots"), 200)
self.assertEqual(options.get("shots"), 200)
with self.subTest("QFI update"):
qfi = QFI(qgt, options={"shots": 200})
qfi.update_default_options(shots=100)
options = qfi.options
result = qfi.run([qc], [[1]]).result()
self.assertEqual(result.options.get("shots"), 100)
self.assertEqual(options.get("shots"), 100)
with self.subTest("QFI run"):
qfi = QFI(qgt=qgt, options={"shots": 200})
result = qfi.run([qc], [[0]], shots=300).result()
options = qfi.options
self.assertEqual(result.options.get("shots"), 300)
self.assertEqual(options.get("shots"), 200)
if __name__ == "__main__":
unittest.main()
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
from uuid import uuid4
from qiskit import QuantumCircuit
from QiskitPBT.stats.measurement_configuration import MeasurementConfiguration
from QiskitPBT.utils import HashableQuantumCircuit
class ExecutionOptimizer:
def __init__(self) -> None:
self.measurement_info_for_unique_circuits: dict[HashableQuantumCircuit, list[tuple[str, HashableQuantumCircuit]]] = {}
self.unoptimized_measurement_info: dict[HashableQuantumCircuit, list[tuple[str, dict[int, QuantumCircuit]]]] = {}
def add_measurement_configuration(self, measurement_config: MeasurementConfiguration) -> None:
base_circuits = measurement_config.get_measured_circuits()
for circuit in base_circuits:
if circuit in self.unoptimized_measurement_info:
self._ensure_unique_measurement_specifications_insertion(circuit, measurement_config.get_measurements_for_circuit(circuit))
else:
self.unoptimized_measurement_info[circuit] = measurement_config.get_measurements_for_circuit(circuit)
# we probably dont need this as this would get optimized later on with circuits, but its probably cheaper like this then with circuit comparisons
def _ensure_unique_measurement_specifications_insertion(self, circuit: HashableQuantumCircuit, measurement_specifications: list[tuple[str, dict[int, QuantumCircuit]]]):
for measurement_id, qubits_measurements in measurement_specifications:
unique = True
# we assume the circuit is in the dict as its only called in context of self.add_measurement_configuration
for stored_measurement_id, stored_qubits_measurements in self.unoptimized_measurement_info[circuit]:
if measurement_id == stored_measurement_id and qubits_measurements == stored_qubits_measurements:
unique = False
break
if unique:
self.unoptimized_measurement_info[circuit].append((measurement_id, stored_qubits_measurements))
def _optimize(self) -> list[HashableQuantumCircuit]:
"""TODO (write this properly):
2. this optimize has to do squashing / optimizing twice:
1. get unique base circuits (and a list of all identical circuit objects for each unique circuit)
2. generate some best effort measurement circuits from measurement config (non overlapping qubit sets go together)
3. once again optimize the resulting circuits (and keep a list of all identical circuit objects)
4. probably flatten/generate a list of really unique circuits to original base circuits and their measurement info
"""
# get unique base circuits:
base_circuits = self.unoptimized_measurement_info.keys()
unique_base_circuits = []
# since we hash by reference, keep track of all duplicated circuits to feed back in get_measurement_info
unique_circuits_to_all: dict[HashableQuantumCircuit, list[HashableQuantumCircuit]] = {}
for circuit in base_circuits:
try:
inserted_circuit_idx = unique_base_circuits.index(circuit)
unique_circuits_to_all[unique_base_circuits[inserted_circuit_idx]].append(circuit)
except ValueError:
unique_base_circuits.append(circuit)
unique_circuits_to_all[circuit] = [circuit]
# generate full circuits, we greedily add measurements to a circuit until we cannot add any more
full_circuits: dict[HashableQuantumCircuit, list[tuple[str, HashableQuantumCircuit]]] = {}
for unique_circuit in unique_base_circuits:
full_circuits.update(self._get_full_circuits(unique_circuit, unique_circuits_to_all[unique_circuit]))
# remove duplicates
full_unique_circuits = []
for full_circuit in full_circuits.keys():
try:
circ_idx = full_unique_circuits.index(full_circuit)
self.measurement_info_for_unique_circuits[full_unique_circuits[circ_idx]].extend(full_circuits[full_circuit])
except ValueError:
full_unique_circuits.append(full_circuit)
self.measurement_info_for_unique_circuits[full_circuit] = full_circuits[full_circuit]
return full_unique_circuits
def _get_full_circuits(self, unique_circuit: HashableQuantumCircuit, duplicate_circuits: HashableQuantumCircuit) -> dict[HashableQuantumCircuit, list[tuple[str, HashableQuantumCircuit]]]:
all_measurement_specifications = []
for circuit in duplicate_circuits:
for measurement_id, qubit_spec in self.unoptimized_measurement_info[circuit]:
all_measurement_specifications.append((measurement_id, qubit_spec, circuit))
measurement_specification_inserted = [False for _ in all_measurement_specifications]
full_circuits: dict[HashableQuantumCircuit, list[tuple[str, HashableQuantumCircuit]]] = {}
while True:
qc = unique_circuit.copy()
qc.reset_hash()
inserted_qubits = {}
measurement_specifications_in_circuit = []
if False not in measurement_specification_inserted:
return full_circuits
for i in range(len(all_measurement_specifications)):
if measurement_specification_inserted[i]:
continue
measurement_id, qubit_measurement_map, original_circuit = all_measurement_specifications[i]
overlapping_qubits = set(inserted_qubits.keys()).intersection(qubit_measurement_map.keys())
should_append_circuit = True
for qubit in overlapping_qubits:
if inserted_qubits[qubit] != qubit_measurement_map[qubit]:
should_append_circuit = False
break
if not should_append_circuit:
continue
else:
measurement_specifications_in_circuit.append((measurement_id, original_circuit))
measurement_specification_inserted[i] = True
for qubit, measurement in qubit_measurement_map.items():
if qubit not in inserted_qubits:
qc.compose(measurement, (qubit,), (qubit,), inplace=True)
inserted_qubits.update(qubit_measurement_map)
full_circuits[qc] = measurement_specifications_in_circuit
def get_circuits_to_execute(self) -> list[QuantumCircuit]:
"""
Returns:
list[QuantumCircuit]: list of unique circuits to be executed based on all measurement configs added to optimizer so far
"""
return [self._get_executable_circuit(circuit) for circuit in self._optimize()]
def get_measurement_info(self, circuit: QuantumCircuit) -> list[tuple[str, HashableQuantumCircuit]]:
"""
Args:
circuit (QuantumCircuit): one of circuits returned by get_circuits_to_execute
Returns:
list[tuple[str, HashableQuantumCircuit]]: list of tuples (measurement_id, original circuit)
- data from measurement configuration provided to the optimizer
"""
return self.measurement_info_for_unique_circuits[self._get_hashable_circuit(circuit)]
def _get_hashable_circuit(self, circuit: QuantumCircuit) -> HashableQuantumCircuit:
circ = circuit.copy()
circ.__class__ = HashableQuantumCircuit
return circ
def _get_executable_circuit(self, circuit: HashableQuantumCircuit) -> QuantumCircuit:
circ = circuit.copy()
circ.__class__ = QuantumCircuit
return circ
|
https://github.com/swe-train/qiskit__qiskit
|
swe-train
|
# 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.
"""
This module contains utility functions for circuits.
"""
import math
import numpy
from qiskit import _numpy_compat
from qiskit.exceptions import QiskitError
from qiskit.circuit.exceptions import CircuitError
from .parametervector import ParameterVectorElement
def sort_parameters(parameters):
"""Sort an iterable of :class:`.Parameter` instances into a canonical order, respecting the
ordering relationships between elements of :class:`.ParameterVector`\\ s."""
def key(parameter):
if isinstance(parameter, ParameterVectorElement):
return (parameter.vector.name, parameter.index)
return (parameter.name,)
return sorted(parameters, key=key)
def _compute_control_matrix(base_mat, num_ctrl_qubits, ctrl_state=None):
r"""
Compute the controlled version of the input matrix with qiskit ordering.
This function computes the controlled unitary with :math:`n` control qubits
and :math:`m` target qubits,
.. math::
V_n^j(U_{2^m}) = (U_{2^m} \otimes |j\rangle\!\langle j|) +
(I_{2^m} \otimes (I_{2^n} - |j\rangle\!\langle j|)).
where :math:`|j\rangle \in \mathcal{H}^{2^n}` is the control state.
Args:
base_mat (ndarray): unitary to be controlled
num_ctrl_qubits (int): number of controls for new unitary
ctrl_state (int or str or None): The control state in decimal or as
a bitstring (e.g. '111'). If None, use 2**num_ctrl_qubits-1.
Returns:
ndarray: controlled version of base matrix.
Raises:
QiskitError: unrecognized mode or invalid ctrl_state
"""
num_target = int(math.log2(base_mat.shape[0]))
ctrl_dim = 2**num_ctrl_qubits
ctrl_grnd = numpy.repeat([[1], [0]], [1, ctrl_dim - 1])
if ctrl_state is None:
ctrl_state = ctrl_dim - 1
elif isinstance(ctrl_state, str):
ctrl_state = int(ctrl_state, 2)
if isinstance(ctrl_state, int):
if not 0 <= ctrl_state < ctrl_dim:
raise QiskitError("Invalid control state value specified.")
else:
raise QiskitError("Invalid control state type specified.")
ctrl_proj = numpy.diag(numpy.roll(ctrl_grnd, ctrl_state))
full_mat = numpy.kron(numpy.eye(2**num_target), numpy.eye(ctrl_dim) - ctrl_proj) + numpy.kron(
base_mat, ctrl_proj
)
return full_mat
def _ctrl_state_to_int(ctrl_state, num_ctrl_qubits):
"""Convert ctrl_state to int.
Args:
ctrl_state (None, str, int): ctrl_state. If None, set to 2**num_ctrl_qubits-1.
If str, convert to int. If int, pass.
num_ctrl_qubits (int): The number of control qubits.
Return:
int: ctrl_state
Raises:
CircuitError: invalid ctrl_state
"""
ctrl_state_std = None
if isinstance(ctrl_state, str):
try:
assert len(ctrl_state) == num_ctrl_qubits
ctrl_state = int(ctrl_state, 2)
except ValueError as ex:
raise CircuitError("invalid control bit string: " + ctrl_state) from ex
except AssertionError as ex:
raise CircuitError("invalid control bit string: length != num_ctrl_qubits") from ex
if isinstance(ctrl_state, int):
if 0 <= ctrl_state < 2**num_ctrl_qubits:
ctrl_state_std = ctrl_state
else:
raise CircuitError("invalid control state specification")
elif ctrl_state is None:
ctrl_state_std = 2**num_ctrl_qubits - 1
else:
raise CircuitError(f"invalid control state specification: {repr(ctrl_state)}")
return ctrl_state_std
def with_gate_array(base_array):
"""Class decorator that adds an ``__array__`` method to a :class:`.Gate` instance that returns a
singleton nonwritable view onto the complex matrix described by ``base_array``."""
nonwritable = numpy.array(base_array, dtype=numpy.complex128)
nonwritable.setflags(write=False)
def __array__(_self, dtype=None, copy=_numpy_compat.COPY_ONLY_IF_NEEDED):
dtype = nonwritable.dtype if dtype is None else dtype
return numpy.array(nonwritable, dtype=dtype, copy=copy)
def decorator(cls):
if hasattr(cls, "__array__"):
raise RuntimeError("Refusing to decorate a class that already has '__array__' defined.")
cls.__array__ = __array__
return cls
return decorator
def with_controlled_gate_array(base_array, num_ctrl_qubits, cached_states=None):
"""Class decorator that adds an ``__array__`` method to a :class:`.ControlledGate` instance that
returns singleton nonwritable views onto a relevant precomputed complex matrix for the given
control state.
If ``cached_states`` is not given, then all possible control states are precomputed. If it is
given, it should be an iterable of integers, and only these control states will be cached."""
base = numpy.asarray(base_array, dtype=numpy.complex128)
def matrix_for_control_state(state):
out = numpy.asarray(
_compute_control_matrix(base, num_ctrl_qubits, state),
dtype=numpy.complex128,
)
out.setflags(write=False)
return out
if cached_states is None:
nonwritables = [matrix_for_control_state(state) for state in range(2**num_ctrl_qubits)]
def __array__(self, dtype=None, copy=_numpy_compat.COPY_ONLY_IF_NEEDED):
arr = nonwritables[self.ctrl_state]
dtype = arr.dtype if dtype is None else dtype
return numpy.array(arr, dtype=dtype, copy=copy)
else:
nonwritables = {state: matrix_for_control_state(state) for state in cached_states}
def __array__(self, dtype=None, copy=_numpy_compat.COPY_ONLY_IF_NEEDED):
if (arr := nonwritables.get(self.ctrl_state)) is not None:
dtype = arr.dtype if dtype is None else dtype
return numpy.array(arr, dtype=dtype, copy=copy)
if copy is False and copy is not _numpy_compat.COPY_ONLY_IF_NEEDED:
raise ValueError("could not produce matrix without calculation")
return numpy.asarray(
_compute_control_matrix(base, num_ctrl_qubits, self.ctrl_state), dtype=dtype
)
def decorator(cls):
if hasattr(cls, "__array__"):
raise RuntimeError("Refusing to decorate a class that already has '__array__' defined.")
cls.__array__ = __array__
return cls
return decorator
|
https://github.com/indian-institute-of-science-qc/qiskit-aakash
|
indian-institute-of-science-qc
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# 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.
"""Test the TrivialLayout pass"""
import unittest
from qiskit import ClassicalRegister, QuantumRegister, QuantumCircuit
from qiskit.transpiler import CouplingMap
from qiskit.transpiler.passes import TrivialLayout
from qiskit.transpiler.target import Target
from qiskit.circuit.library import CXGate
from qiskit.transpiler import TranspilerError
from qiskit.converters import circuit_to_dag
from qiskit.test import QiskitTestCase
from qiskit.providers.fake_provider import FakeTenerife, FakeRueschlikon
class TestTrivialLayout(QiskitTestCase):
"""Tests the TrivialLayout pass"""
def setUp(self):
super().setUp()
self.cmap5 = FakeTenerife().configuration().coupling_map
self.cmap16 = FakeRueschlikon().configuration().coupling_map
def test_3q_circuit_5q_coupling(self):
"""Test finds trivial layout for 3q circuit on 5q device."""
qr = QuantumRegister(3, "q")
circuit = QuantumCircuit(qr)
circuit.cx(qr[1], qr[0])
circuit.cx(qr[0], qr[2])
circuit.cx(qr[1], qr[2])
dag = circuit_to_dag(circuit)
pass_ = TrivialLayout(CouplingMap(self.cmap5))
pass_.run(dag)
layout = pass_.property_set["layout"]
for i in range(3):
self.assertEqual(layout[qr[i]], i)
def test_3q_circuit_5q_coupling_with_target(self):
"""Test finds trivial layout for 3q circuit on 5q device."""
qr = QuantumRegister(3, "q")
circuit = QuantumCircuit(qr)
circuit.cx(qr[1], qr[0])
circuit.cx(qr[0], qr[2])
circuit.cx(qr[1], qr[2])
dag = circuit_to_dag(circuit)
target = Target()
target.add_instruction(CXGate(), {tuple(edge): None for edge in self.cmap5})
pass_ = TrivialLayout(target)
pass_.run(dag)
layout = pass_.property_set["layout"]
for i in range(3):
self.assertEqual(layout[qr[i]], i)
def test_9q_circuit_16q_coupling(self):
"""Test finds trivial layout for 9q circuit with 2 registers on 16q device."""
qr0 = QuantumRegister(4, "q0")
qr1 = QuantumRegister(5, "q1")
cr = ClassicalRegister(2, "c")
circuit = QuantumCircuit(qr0, qr1, cr)
circuit.cx(qr0[1], qr0[2])
circuit.cx(qr0[0], qr1[3])
circuit.cx(qr1[4], qr0[2])
circuit.measure(qr1[1], cr[0])
circuit.measure(qr0[2], cr[1])
dag = circuit_to_dag(circuit)
pass_ = TrivialLayout(CouplingMap(self.cmap16))
pass_.run(dag)
layout = pass_.property_set["layout"]
for i in range(4):
self.assertEqual(layout[qr0[i]], i)
for i in range(5):
self.assertEqual(layout[qr1[i]], i + 4)
def test_raises_wider_circuit(self):
"""Test error is raised if the circuit is wider than coupling map."""
qr0 = QuantumRegister(3, "q0")
qr1 = QuantumRegister(3, "q1")
circuit = QuantumCircuit(qr0, qr1)
circuit.cx(qr0, qr1)
dag = circuit_to_dag(circuit)
with self.assertRaises(TranspilerError):
pass_ = TrivialLayout(CouplingMap(self.cmap5))
pass_.run(dag)
if __name__ == "__main__":
unittest.main()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.