repo
stringclasses 900
values | file
stringclasses 754
values | content
stringlengths 4
215k
|
|---|---|---|
https://github.com/arthurfaria/QC_basic_agorithms_qiskit
|
arthurfaria
|
###### Import Libraries
import numpy as np
from qiskit import Aer
from qiskit_nature.drivers import UnitsType, Molecule
from qiskit_nature.drivers.second_quantization import (
ElectronicStructureDriverType,
ElectronicStructureMoleculeDriver,
)
from qiskit_nature.problems.second_quantization import ElectronicStructureProblem
from qiskit_nature.converters.second_quantization import QubitConverter
from qiskit_nature.mappers.second_quantization import JordanWignerMapper
import time
molecule = Molecule(
geometry=[["H", [0.0, 0.0, 0.0]], ["F", [0.0, 0.0, 0.9554]]], charge=0, multiplicity=1
)
print(molecule.geometry)
###### Define the electronic structure driver
driver = ElectronicStructureMoleculeDriver(
molecule, basis="sto3g", driver_type=ElectronicStructureDriverType.PYSCF,
)
# define the electronic structure problem as a function of the driver
es_problem = ElectronicStructureProblem(driver)
# build the second quantized Hamiltonian of the molecule
second_q_op = es_problem.second_q_ops()
# print the Hamiltonian, no. of spin orbitals or qubits, and the no. of paticles
print('\n',"The second quantized form of the electronic Hamiltonian is" , second_q_op[0])
print('\n',"The no. of spin orbitals is", es_problem.num_spin_orbitals)
print('\n', "The total no. of electrons is", es_problem.num_particles)
qubit_converter = QubitConverter(JordanWignerMapper())
%%time
from qiskit.algorithms import NumPyMinimumEigensolver
from qiskit_nature.algorithms import GroundStateEigensolver
##############################
# Provide your code here
numpy_solver = NumPyMinimumEigensolver()
numpy_ground_state_solver = GroundStateEigensolver(qubit_converter=qubit_converter, solver=numpy_solver)
numpy_results = numpy_ground_state_solver.solve(problem=es_problem)
##############################
exact_energy = np.real(numpy_results.electronic_energies + numpy_results.nuclear_repulsion_energy)[0]
print(f"Exact electronic energy: {exact_energy:.6f} Hartree\n")
print(numpy_results)
%%time
from qiskit.utils import QuantumInstance
from qiskit_nature.algorithms import VQEUCCFactory
#backend
backend=Aer.get_backend("aer_simulator_statevector")
# Select the simulator to run the calculation
quantum_instance = QuantumInstance(backend=backend)
# define the VQE simulator
vqe_solver = VQEUCCFactory(quantum_instance)
%%time
from qiskit_nature.algorithms import GroundStateEigensolver
# do the calculation
calc = GroundStateEigensolver(qubit_converter, vqe_solver)
# save the result
res = calc.solve(es_problem)
# print the result
print(res)
from qiskit.algorithms.optimizers import COBYLA
from qiskit_nature.drivers.second_quantization import PySCFDriver
driver_reduced = PySCFDriver(atom='H 0.0, 0.0, 0.0; F 0.0, 0.0, 0.9554',
unit=UnitsType.ANGSTROM, charge=0, spin=0, basis='STO3G')
es_problem = ElectronicStructureProblem(driver_reduced)
properties = driver_reduced.run()
from qiskit_nature.circuit.library import HartreeFock
from qiskit.circuit.library import EfficientSU2
from qiskit_nature.properties.second_quantization.electronic import ParticleNumber
particle_number = properties.get_property(ParticleNumber)
init_state = HartreeFock(num_spin_orbitals=particle_number.num_spin_orbitals,
num_particles=particle_number.num_particles,
qubit_converter=qubit_converter)
init_state.barrier()
##############################
ansatz = EfficientSU2(num_qubits=particle_number.num_spin_orbitals,
reps=1,
entanglement='linear',
initial_state=init_state,
insert_barriers=True)
##############################
ansatz.decompose().draw('mpl')
from qiskit.providers.aer import StatevectorSimulator
from qiskit.algorithms.optimizers import L_BFGS_B
from qiskit.algorithms import VQE
##############################
# Provide your code here
backend1 = StatevectorSimulator()
optimizer = L_BFGS_B(maxfun=400)
##############################
from qiskit_nature.algorithms import VQEUCCFactory, GroundStateEigensolver
from jupyterplot import ProgressPlot
error_threshold = 10 # mHartree
np.random.seed(5) # fix seed for reproducibility
initial_point = np.random.random(ansatz.num_parameters)
from qiskit.providers.aer import StatevectorSimulator
from qiskit.algorithms.optimizers import L_BFGS_B
from qiskit.algorithms import VQE
##############################
# Provide your code here
backend1 = StatevectorSimulator()
optimizer = L_BFGS_B(maxfun=400)
##############################
from qiskit_nature.algorithms import VQEUCCFactory, GroundStateEigensolver
from jupyterplot import ProgressPlot
error_threshold = 10 # mHartree
np.random.seed(5) # fix seed for reproducibility
initial_point = np.random.random(ansatz.num_parameters)
%%time
# for live plotting
pp = ProgressPlot(plot_names=['Energy'],
line_names=['Runtime VQE', f'Target + {error_threshold}mH', 'Target'])
intermediate_info = {
'nfev': [],
'parameters': [],
'energy': [],
'stddev': []
}
def callback(nfev, parameters, energy, stddev):
intermediate_info['nfev'].append(nfev)
intermediate_info['parameters'].append(parameters)
intermediate_info['energy'].append(energy)
intermediate_info['stddev'].append(stddev)
pp.update([[energy, exact_energy+error_threshold/1000, exact_energy]])
##############################
# Provide your code here
vqe = VQE(ansatz=ansatz,
optimizer=optimizer,
quantum_instance=backend1,
callback=callback,
initial_point=initial_point)
vqe_ground_state_solver = GroundStateEigensolver(qubit_converter=qubit_converter, solver=vqe)
vqe_results = vqe_ground_state_solver.solve(problem=es_problem)
##############################
print(vqe_results)
error = (vqe_results.computed_energies[0] - exact_energy) * 1000 # mHartree
print(f'Error is: {error:.3f} Hartree')
%%time
WITHOUT__ActiveSpace = ElectronicStructureProblem(driver_reduced)
second_q_ops = WITHOUT__ActiveSpace.second_q_ops()
main_op = second_q_ops[0]
# particle_number = problem.molecule_data_transformed
# num_particles = (particle_number.num_alpha, particle_numbaer.num_beta)
# num_spin_orbitals = particle_number.num_molecular_orbitals*2
molecule = driver.run()
simulation = QuantumInstance(backend=backend)
mapper = JordanWignerMapper()
qubit_converter = QubitConverter(mapper=mapper, two_qubit_reduction=True)
qubit_op = qubit_converter.convert(main_op, num_particles=2)
%%time
shots=10
begin = time.time()
VQE = VQEUCCFactory(simulation, optimizer=COBYLA(maxiter=shots))
calculation = GroundStateEigensolver(qubit_converter, VQE)
result0 = calculation.solve(WITHOUT__ActiveSpace)
end = time.time()
print(f"Total runtime of the program is {end - begin}")
np.real(result0.electronic_energies + result0.nuclear_repulsion_energy)[0]
# from qiskit_nature.transformers import ActiveSpaceTransformer
from qiskit_nature.transformers.second_quantization.electronic import ActiveSpaceTransformer
transformer = ActiveSpaceTransformer(2, 2, [4,5])
%%time
WITH_ActiveSpace = ElectronicStructureProblem(driver_reduced, transformers=[transformer])
second_q_ops = WITH_ActiveSpace.second_q_ops()
main_op = second_q_ops[0]
# particle_number = problem.molecule_data_transformed
# num_particles = (particle_number.num_alpha, particle_number.num_beta)
# num_spin_orbitals = particle_number.num_molecular_orbitals*2
molecule = driver.run()
simulation = QuantumInstance(backend=backend)
mapper = JordanWignerMapper()
qubit_converter = QubitConverter(mapper=mapper, two_qubit_reduction=True)
qubit_op = qubit_converter.convert(main_op, num_particles=2)
shots=10
simulation = QuantumInstance(backend=backend)
begin = time.time()
VQE = VQEUCCFactory(simulation, optimizer=COBYLA(maxiter=shots))
calculation = GroundStateEigensolver(qubit_converter, VQE)
result1 = calculation.solve(WITH_ActiveSpace)
end = time.time()
print(f"Total runtime of the program is {end - begin}")
np.real(result1.electronic_energies + result1.nuclear_repulsion_energy)[0]
|
https://github.com/draentropia/Qiskit_PyLadiesBCN
|
draentropia
|
from qiskit import QuantumCircuit, assemble, Aer
from qiskit.visualization import plot_histogram
# create quantum circuit
qc = QuantumCircuit(1) # 1 quantum register, 1 classical register
qc.x(0) # add a gate to the circuit
qc.measure_all() # add measurement at the end
# run
sim = Aer.get_backend('aer_simulator')
qobj = assemble(qc) # Assemble a list of circuits or pulse schedules into a Qobj
result = sim.run(qobj).result() # run circuit, get results
# output statistics
counts = result.get_counts() # extract statistics from results
print(counts)
plot_histogram(counts)
qc.draw("mpl")
from qiskit.visualization import plot_bloch_vector
vector = [0, 1, 0] # coordinates [x, y, z]
plot_bloch_vector(vector) # plot in the Bloch sphere
qc = QuantumCircuit(1)
qc.x(0)
qc.y(0)
qc.z(0)
qc.draw("mpl")
from qiskit import QuantumCircuit, assemble, Aer
from qiskit.visualization import plot_bloch_multivector
import numpy as np
# create quantum circuit
qc = QuantumCircuit(1)
qc.x(0) # add gate x(qubit)
# run
sim = Aer.get_backend('aer_simulator')
qc.save_statevector() # we want to use statevector later
qobj = assemble(qc)
result = sim.run(qobj).result() # run circuit, get results
final_state = result.get_statevector() # get the final state from the result
# visualize
plot_bloch_multivector(final_state) # display final state directly on Bloch sphere
from qiskit import QuantumCircuit, assemble, Aer
from qiskit.visualization import plot_bloch_multivector
import numpy as np
# create quantum circuit
qc = QuantumCircuit(1)
init_state = [1. / np.sqrt(2), 1. / np.sqrt(2)] # define initial state [a,b] like a**2 + b**2 = 1 (normalization)
qc.initialize(init_state, 0) # initialize qubit 0 to init_state
qc.z(0) # add gate z(qubit)
# run
sim = Aer.get_backend('aer_simulator')
qc.save_statevector() # we want to use statevector later
qobj = assemble(qc)
result = sim.run(qobj).result() # run circuit, get results
final_state = result.get_statevector() # get the final state from the result
# visualize
plot_bloch_multivector(final_state) # display final state directly on Bloch sphere
|
https://github.com/draentropia/Qiskit_PyLadiesBCN
|
draentropia
|
from qiskit import QuantumCircuit, assemble, Aer
from qiskit.visualization import plot_bloch_multivector
import numpy as np
# create quantum circuit
qc = QuantumCircuit(1)
qc.h(0) # add h(qubit)
# run
sim = Aer.get_backend('aer_simulator')
qc.save_statevector() # we want to use statevector later
qobj = assemble(qc)
result = sim.run(qobj).result() # run circuit, get results
final_state = result.get_statevector() # get the final state from the result
# visualize
plot_bloch_multivector(final_state) # display final state directly on Bloch sphere
qc = QuantumCircuit(2)
qc.cx(0,1) # First element is the control qubit, second element the target (the affected)
qc.draw("mpl")
from qiskit import QuantumCircuit, assemble, Aer
from qiskit import QuantumRegister, ClassicalRegister
from qiskit.visualization import plot_histogram
# create quantum circuit
qc = QuantumCircuit(2)
qc.h(0) # apply a Hadamard gate to the first qubit
qc.cx(0,1) #
qc.measure_all() # finally measure all
# run
sim = Aer.get_backend('aer_simulator')
qobj = assemble(qc)
result = sim.run(qobj, shots=1024).result() # run circuit, get results
# output statistics
counts = result.get_counts() # extract statistics from results
plot_histogram(counts)
from qiskit import QuantumCircuit, assemble, Aer
from qiskit.visualization import plot_bloch_multivector
import numpy as np
# create quantum circuit
qc = QuantumCircuit(3)
qc.h(0)
qc.z(1)
qc.h(0)
qc.h(2)
# run
sim = Aer.get_backend('aer_simulator')
qc.save_statevector()
qobj = assemble(qc)
result = sim.run(qobj, shots=100).result() # run circuit, get results
# get state
final_state = result.get_statevector()
# visualize
plot_bloch_multivector(final_state) # display final state directly on Bloch sphere
|
https://github.com/pedroripper/qiskit_tutoriais
|
pedroripper
|
# Importando módulos
from qiskit import *
from qiskit.tools.visualization import plot_histogram
# Inicializando o circuito
nQubits = 2
nBits = 2
circuitoQuantico = QuantumCircuit(nQubits, nBits)
# Para aplicar uma porta no circuito devemos seguir o seguinte exemplo onde aplicamos uma Hadamard Gate
circuitoQuantico.h(0)
# Nesse exemplo h() é a função que usamos para aplicar uma Hadamard Gate e o argumento é o índice do qubit
# onde se deseja aplica a porta
# Podemos ver ao chamar draw() que a Hadamard Gate fica no qubit desejado
circuitoQuantico.draw(output = 'mpl')
# Podemos aplicar também portas que envolvem mais de um qubit, como a CNOT(Controlled NOT) Gate
circuitoQuantico.cx(0,1)
# Visualização do circuito após chamar a CNOT Gate
circuitoQuantico.draw(output = 'mpl')
# Agora podemos medir esses qubits após as operações chamando measure()
circuitoQuantico.measure(0,0)
circuitoQuantico.measure(1,1)
# Visualização do circuito após chamar measure()
circuitoQuantico.draw(output = 'mpl')
# Para simular um circuito quântico usamos um elemento do Qiskit chamado Aer, que tem como
# uma de suas funções a simulação de circuitos
simulador = Aer.get_backend('qasm_simulator')
# Para executar o circuito chamamos execute() que leva como argumento o circuito a ser executado e o
# backend(aonde o circuito vai ser executado) que nesse caso é no simulador do Aer
resultado = execute(circuitoQuantico, backend = simulador).result()
# Usamos a variável resultado para guardar os dados do resultado
# Para exibir os resultados chamamos plot_histogram()
plot_histogram(resultado.get_counts(circuitoQuantico))
# Antes de tudo é necessário imp
|
https://github.com/pedroripper/qiskit_tutoriais
|
pedroripper
|
from qiskit import *
# Para representar o qubit em uma esfera de bloch devemos pensar nele na seguinte forma:
# Depois de encontrar o theta, phi que desejamos, vamos ter os valores necessários para plotar nossa
# esfera de bloch
# Para plotar precisamos chamar a função plot_bloch_vector_spherical() que leva como parâmetro
# o vetor de bloch
# para encontrar o vetor de bloch seguimos a fórmula
# Para o exemplo vamos usar o qubit no estado |+> que fica da seguinte forma:
# Para conseguir representar esse estado no formato dado anteriormente vamos precisar
# de um theta valendo pi/2 e de um phi valendo 0
# portanto vamos ter o vetor de bloch como (1,0,0)
# Finalmente podemos exibir a esfera de bloch
from qiskit.visualization import plot_bloch_vector
%matplotlib inline
plot_bloch_vector([1,0,0], title="Minha Primeira Esfera de Bloch")
|
https://github.com/pedroripper/qiskit_tutoriais
|
pedroripper
|
from qiskit import *
# Primeiramente vamos iniciar um circuito
circuitoQ = QuantumCircuit(1,1)
# No qiskit os qubits são inicializados por default com o estado |0>
# Podemos ver isso plotando a esfera de bloch que representa ele
from qiskit.tools.visualization import plot_bloch_multivector
simulator = Aer.get_backend('statevector_simulator')
result = execute(circuitoQ, backend = simulator).result()
statevector = result.get_statevector()
plot_bloch_multivector(statevector)
# As portas Rx,Ry,Rz servem para fazer rotações nos eixos X,Y,Z
# Para demonstrar vamos inicializar outro circuito de 1 qubit
circuito2 = QuantumCircuit(1)
# Agora para aplicar a porta usamos .rx(rotacao_em_radianos,qubit_a_passar_pela_porta)
# Nesse exemplo vamos rotacionar o qubit no eixo x em pi/2
# antes é importante importar o pi da biblioteca math
from math import pi
circuito2.rx(pi/2,0)
circuito2.draw(output = 'mpl')
# Vendo o resultado:
from qiskit.tools.visualization import plot_bloch_multivector
simulator = Aer.get_backend('statevector_simulator')
result = execute(circuito2, backend = simulator).result()
statevector = result.get_statevector()
plot_bloch_multivector(statevector)
|
https://github.com/pedroripper/qiskit_tutoriais
|
pedroripper
|
from qiskit import *
circuito = QuantumCircuit(2,2)
circuito.draw(output = 'mpl')
from qiskit.tools.visualization import plot_bloch_multivector
simulator = Aer.get_backend('statevector_simulator')
result = execute(circuito, backend = simulator).result()
statevector = result.get_statevector()
plot_bloch_multivector(statevector)
# Primeiramente o qiskit inicializa os qubits nos estados 0 e 1
circuito = QuantumCircuit(2,2)
circuito.x(0)
circuito.draw(output = 'mpl')
from qiskit.tools.visualization import plot_bloch_multivector
simulator = Aer.get_backend('statevector_simulator')
result = execute(circuito, backend = simulator).result()
statevector = result.get_statevector()
plot_bloch_multivector(statevector)
circuito.y(0)
circuito.draw(output = 'mpl')
from qiskit.tools.visualization import plot_bloch_multivector
simulator = Aer.get_backend('statevector_simulator')
result = execute(circuito, backend = simulator).result()
statevector = result.get_statevector()
plot_bloch_multivector(statevector)
# No tutorial sobre as portas Rx, Ry e Rz vimos que usando a porta Ry para rotacionar o qubit em pi/2 conseguimos
# o estado |+>
import math
circuito.ry(math.pi/2,1)
circuito.draw(output = 'mpl')
from qiskit.tools.visualization import plot_bloch_multivector
simulator = Aer.get_backend('statevector_simulator')
result = execute(circuito, backend = simulator).result()
statevector = result.get_statevector()
plot_bloch_multivector(statevector)
# Agora aplicando a porta Z
circuito.z(1)
circuito.draw(output = 'mpl')
from qiskit.tools.visualization import plot_bloch_multivector
simulator = Aer.get_backend('statevector_simulator')
result = execute(circuito, backend = simulator).result()
statevector = result.get_statevector()
plot_bloch_multivector(statevector)
circuito.id(1)
circuito.draw(output = 'mpl')
from qiskit.tools.visualization import plot_bloch_multivector
simulator = Aer.get_backend('statevector_simulator')
result = execute(circuito, backend = simulator).result()
statevector = result.get_statevector()
plot_bloch_multivector(statevector)
|
https://github.com/pedroripper/qiskit_tutoriais
|
pedroripper
|
from qiskit import *
# Para representar o qubit em uma esfera de bloch devemos pensar nele na seguinte forma:
# Depois de encontrar o theta, phi que desejamos, vamos ter os valores necessários para plotar nossa
# esfera de bloch
# Para plotar precisamos chamar a função plot_bloch_vector_spherical() que leva como parâmetro
# o vetor de bloch
# para encontrar o vetor de bloch seguimos a fórmula
# Para o exemplo vamos usar o qubit no estado |+> que fica da seguinte forma:
# Para conseguir representar esse estado no formato dado anteriormente vamos precisar
# de um theta valendo pi/2 e de um phi valendo 0
# portanto vamos ter o vetor de bloch como (1,0,0)
# Finalmente podemos exibir a esfera de bloch
from qiskit.visualization import plot_bloch_vector
%matplotlib inline
plot_bloch_vector([1,0,0], title="Minha Primeira Esfera de Bloch")
|
https://github.com/pedroripper/qiskit_tutoriais
|
pedroripper
|
from qiskit import *
global c
c = QuantumCircuit(2,2)
def ua(bit_0 , bit_1):
global c
if(bit_0 == 1):
if(bit_1 == 0):
c.x(0)
else:
c.h(0)
ua(0,0)
c.draw()
c.reset(0)
c.reset(1)
c.draw()
def ub(numeo_bob):
2 -> comp
3 -> diag
0 == 0
0 == 1
qc = QuantumCircuit(2,2)
qc.y(1)
qc.measure(1,1)
qc.draw()
backend = Aer.get_backend('qasm_simulator')
result = execute(qc, backend, shots = 1).result()
count = result.get_counts()
count
int(count.popitem()[0][0])
import random
def index(abc):
index = random.randint(0, abc)
i = index(len(lista_bases))
[c,d,c,d,c]
[c,c,c,d,c]
|
https://github.com/pedroripper/qiskit_tutoriais
|
pedroripper
|
from qiskit import *
%matplotlib inline
import numpy as np
qc = QuantumCircuit(2,2)
qc.rx(np.pi/2,0)
qc.z(0)
qc.draw(output='mpl')
qc2 = QuantumCircuit(2,2)
qc2.z(0)
qc2.rx(-np.pi/2,0)
qc2.draw(output='mpl')
|
https://github.com/pedroripper/qiskit_tutoriais
|
pedroripper
|
from qiskit import *
%matplotlib inline
from qiskit.tools.visualization import plot_histogram
from qiskit.visualization import plot_bloch_vector
from qiskit.visualization import plot_bloch_multivector
import math
theta = math.pi/2
phi = math.pi/2
vetor_bloch = [math.cos(phi)*math.sin(theta),math.sin(theta)*math.sin(phi),math.cos(theta)]
plot_bloch_vector(vetor_bloch, title='Pedro')
qc = QuantumCircuit(1,1)
qc.x(0)
qc.draw()
backend_pe = Aer.get_backend('qasm_simulator')
job = execute(qc, backend=backend_pe, shots=1000)
print(backend)
|
https://github.com/pedroripper/qiskit_tutoriais
|
pedroripper
|
from qiskit import *
global x
x = QuantumCircuit(2,2)
def ua(bit_0 , bit_1):
global x
if(bit_0 == 1 and bit_1 == 0):
x.cx(0,1)
ua(0,0)
x.draw()
0 == 0
0 == 1
|
https://github.com/pedroripper/qiskit_tutoriais
|
pedroripper
|
from qiskit import *
%matplotlib inline
import numpy as np
qc = QuantumCircuit(2,2)
qc.rx(np.pi/2,0)
qc.z(0)
qc.draw(output='mpl')
qc2 = QuantumCircuit(2,2)
qc2.z(0)
qc2.rx(-np.pi/2,0)
qc2.draw(output='mpl')
|
https://github.com/pedroripper/qiskit_tutoriais
|
pedroripper
|
# Importando módulos
from qiskit import *
# Uma das formas de se inicializar um circuito quântico é usando "QuantumCircuit(x,y)"
# que é armazenado em uma variável.
# Nele, onde x é o número de qubits
# e y o número de bits clássicos.
# Usamos os bits clássicos para armazenar as medições dos qubits.
nQubits = 2
nBits = 2
circuitoQuantico = QuantumCircuit(nQubits, nBits)
# Nesse caso cada qubit tem o seu bit aonde será armazenado seu valor após a medição
# (o primeiro bit armazena o valor do primeiro qubit, o segundo bit do segundo qubit,...)
# Logo depois de inicializar o circuito e durante todo o processo de adicionar as operações desejadas,
# podemos visualizar o circuito, chamando a função draw(output = 'mpl') pertencente a variável do circuito quântico
circuitoQuantico.draw(output = 'mpl')
# Depois de realizar as operações desejadas nos qubits, medimos chamando a função measure(x,y),
# pertencente a variável de circuito quântico.
# Nele o x e y são os ÍNDICES do qubit e bit respectivamente(lembrar que o índice começa a contar em 0).
circuitoQuantico.measure(0,0)
circuitoQuantico.measure(1,1)
# Chamando o draw() para exibir novamente o circuito, mas agora exibindo a medições
circuitoQuantico.draw(output = 'mpl')
|
https://github.com/pedroripper/qiskit_tutoriais
|
pedroripper
|
# Importando módulos
from qiskit import *
from qiskit.tools.visualization import plot_histogram
# Inicializando o circuito
nQubits = 2
nBits = 2
circuitoQuantico = QuantumCircuit(nQubits, nBits)
# Para aplicar uma porta no circuito devemos seguir o seguinte exemplo onde aplicamos uma Hadamard Gate
circuitoQuantico.h(0)
# Nesse exemplo h() é a função que usamos para aplicar uma Hadamard Gate e o argumento é o índice do qubit
# onde se deseja aplica a porta
# Podemos ver ao chamar draw() que a Hadamard Gate fica no qubit desejado
circuitoQuantico.draw(output = 'mpl')
# Podemos aplicar também portas que envolvem mais de um qubit, como a CNOT(Controlled NOT) Gate
circuitoQuantico.cx(0,1)
# Visualização do circuito após chamar a CNOT Gate
circuitoQuantico.draw(output = 'mpl')
# Agora podemos medir esses qubits após as operações chamando measure()
circuitoQuantico.measure(0,0)
circuitoQuantico.measure(1,1)
# Visualização do circuito após chamar measure()
circuitoQuantico.draw(output = 'mpl')
# Para simular um circuito quântico usamos um elemento do Qiskit chamado Aer, que tem como
# uma de suas funções a simulação de circuitos
simulador = Aer.get_backend('qasm_simulator')
# Para executar o circuito chamamos execute() que leva como argumento o circuito a ser executado e o
# backend(aonde o circuito vai ser executado) que nesse caso é no simulador do Aer
resultado = execute(circuitoQuantico, backend = simulador).result()
# Usamos a variável resultado para guardar os dados do resultado
# Para exibir os resultados chamamos plot_histogram()
plot_histogram(resultado.get_counts(circuitoQuantico))
# Antes de tudo é necessário importar o módulo da IBMQ Experience e carregar a sua conta
from qiskit import IBMQ
IBMQ.load_account()
# Agora precisamos inicializar a variável de provider que vai ser responsável por ter o acesso a
# um dos computadores quanticos da IBM
provedor = IBMQ.get_provider('ibm-q')
# Podemos agora escolher um dos computadores disponíveis da IBM para podermos rodar nosso circuito
computadorQuantico = provedor.get_backend('ibmq_16_melbourne')
# Para simular no nosso próprio computado tivemos que usar
# " execute(circuitoQuantico, backend = simulador) "
# Agora vamos ter que fazer algo similar
executar = execute(circuitoQuantico, backend=computadorQuantico)
# Depois de rodar o comando " execute(circuitoQuantico, backend=computadorQuantico).result() "
# o nosso circuito entra numa fila do computador da IBM que escolhemos roda. Como se fosse uma
# lista de pedidos num restaurante para o cozinheiro preparar.
# Podemos checar o status do nosso "pedido" chamando o job_monitor
from qiskit.tools.monitor import job_monitor
job_monitor(executar)
# Para pegar o resultado do circuito fazemos o seguinte
resultado = executar.result()
# Da mesma forma como na simulação no próprio computador podemos exibir os resultados num histograma
plot_histogram(resultado.get_counts(circuitoQuantico))
|
https://github.com/pedroripper/qiskit_tutoriais
|
pedroripper
|
from qiskit import *
# Para representar o qubit em uma esfera de bloch devemos pensar nele na seguinte forma:
# Depois de encontrar o theta, phi que desejamos, vamos ter os valores necessários para plotar nossa
# esfera de bloch
# Para plotar precisamos chamar a função plot_bloch_vector_spherical() que leva como parâmetro
# o vetor de bloch
# para encontrar o vetor de bloch seguimos a fórmula
# Para o exemplo vamos usar o qubit no estado |+> que fica da seguinte forma:
# Para conseguir representar esse estado no formato dado anteriormente vamos precisar
# de um theta valendo pi/2 e de um phi valendo 0
# portanto vamos ter o vetor de bloch como (1,0,0)
# Finalmente podemos exibir a esfera de bloch
from qiskit.visualization import plot_bloch_vector
%matplotlib inline
plot_bloch_vector([1,0,0], title="Minha Primeira Esfera de Bloch")
|
https://github.com/pedroripper/qiskit_tutoriais
|
pedroripper
|
from qiskit import *
# Primeiramente vamos iniciar um circuito
circuitoQ = QuantumCircuit(1,1)
# No qiskit os qubits são inicializados por default com o estado |0>
# Podemos ver isso plotando a esfera de bloch que representa ele
from qiskit.tools.visualization import plot_bloch_multivector
simulator = Aer.get_backend('statevector_simulator')
result = execute(circuitoQ, backend = simulator).result()
statevector = result.get_statevector()
plot_bloch_multivector(statevector)
# As portas Rx,Ry,Rz servem para fazer rotações nos eixos X,Y,Z
# Para demonstrar vamos inicializar outro circuito de 1 qubit
circuito2 = QuantumCircuit(1)
# Agora para aplicar a porta usamos .rx(rotacao_em_radianos,qubit_a_passar_pela_porta)
# Nesse exemplo vamos rotacionar o qubit no eixo x em pi/2
# antes é importante importar o pi da biblioteca math
from math import pi
circuito2.rx(pi/2,0)
circuito2.draw(output = 'mpl')
# Vendo o resultado:
from qiskit.tools.visualization import plot_bloch_multivector
simulator = Aer.get_backend('statevector_simulator')
result = execute(circuito2, backend = simulator).result()
statevector = result.get_statevector()
plot_bloch_multivector(statevector)
|
https://github.com/pedroripper/qiskit_tutoriais
|
pedroripper
|
from qiskit import *
circuito = QuantumCircuit(2,2)
circuito.draw(output = 'mpl')
from qiskit.tools.visualization import plot_bloch_multivector
simulator = Aer.get_backend('statevector_simulator')
result = execute(circuito, backend = simulator).result()
statevector = result.get_statevector()
plot_bloch_multivector(statevector)
# Primeiramente o qiskit inicializa os qubits nos estados 0 e 1
circuito = QuantumCircuit(2,2)
circuito.x(0)
circuito.draw(output = 'mpl')
from qiskit.tools.visualization import plot_bloch_multivector
simulator = Aer.get_backend('statevector_simulator')
result = execute(circuito, backend = simulator).result()
statevector = result.get_statevector()
plot_bloch_multivector(statevector)
circuito.y(0)
circuito.draw(output = 'mpl')
from qiskit.tools.visualization import plot_bloch_multivector
simulator = Aer.get_backend('statevector_simulator')
result = execute(circuito, backend = simulator).result()
statevector = result.get_statevector()
plot_bloch_multivector(statevector)
# No tutorial sobre as portas Rx, Ry e Rz vimos que usando a porta Ry para rotacionar o qubit em pi/2 conseguimos
# o estado |+>
import math
circuito.ry(math.pi/2,1)
circuito.draw(output = 'mpl')
from qiskit.tools.visualization import plot_bloch_multivector
simulator = Aer.get_backend('statevector_simulator')
result = execute(circuito, backend = simulator).result()
statevector = result.get_statevector()
plot_bloch_multivector(statevector)
# Agora aplicando a porta Z
circuito.z(1)
circuito.draw(output = 'mpl')
from qiskit.tools.visualization import plot_bloch_multivector
simulator = Aer.get_backend('statevector_simulator')
result = execute(circuito, backend = simulator).result()
statevector = result.get_statevector()
plot_bloch_multivector(statevector)
circuito.id(1)
circuito.draw(output = 'mpl')
from qiskit.tools.visualization import plot_bloch_multivector
simulator = Aer.get_backend('statevector_simulator')
result = execute(circuito, backend = simulator).result()
statevector = result.get_statevector()
plot_bloch_multivector(statevector)
|
https://github.com/pedroripper/qiskit_tutoriais
|
pedroripper
|
from qiskit import *
%matplotlib inline
qc1 = QuantumCircuit(1)
qc1.h(0)
qc1.draw(output = 'mpl')
qc2 = QuantumCircuit(1)
qc2.x(0)
qc2.draw(output = 'mpl')
print(qc1)
print(qc2)
qc3 = qc1 + qc2
qc3.draw(output = 'mpl')
qc1[0]
qc3.z(0)
qc3.draw(output = 'mpl')
|
https://github.com/pedroripper/qiskit_tutoriais
|
pedroripper
|
from qiskit import *
import numpy as np
circuito = QuantumCircuit(2,2)
circuito.x(0)
circuito.z(0)
circuito.h(1)
# circuito.measure([0,1],[0,1])
circuito.draw(output = 'mpl')
# Podemos encontrar a matriz unitária que representa as operacoes no circuito
backend = Aer.get_backend('unitary_simulator')
job = execute(circuito, backend)
resultado = job.result()
unitaria = resultado.get_unitary()
print(unitaria)
|
https://github.com/pedroripper/qiskit_tutoriais
|
pedroripper
|
from qiskit import *
import numpy as np
# Podemos aplicar uma matriz unitária em um circuito
matriz = [[1,0],
[0,1]]
circuito = QuantumCircuit(1)
circuito.unitary(matriz,[0])
circuito.draw(output='mpl')
# É possivel dar nome para essas operações
circuito = QuantumCircuit(1)
circuito.unitary(matriz,[0],label='minha porta')
circuito.draw(output='mpl')
|
https://github.com/pedroripper/qiskit_tutoriais
|
pedroripper
|
from qiskit import *
%matplotlib inline
# Podemos transformar o nosso circuito em apenas uma porta
circuito = QuantumCircuit(2)
circuito.x(0)
circuito.h(1)
circuito.draw(output='mpl')
# Para conseguir uma porta que represente essas operações fazemos
# Podemos ainda adicionar um titulo para a nossa porta ou apenas deixar em branco
minha_porta = circuito.to_gate(label='Minha porta')
# Agora vamos adicionar ela em outro circuito
c2 = QuantumCircuit(2)
# Para adicionar uma porta dessa forma usamos o comando append()
c2.append(minha_porta,[0,1])
c2.draw(output='mpl')
# Para conferir se essa porta realmente representa a original fazemos
c2.decompose().draw(output='mpl')
|
https://github.com/pedroripper/qiskit_tutoriais
|
pedroripper
|
from qiskit import *
%matplotlib inline
# Para facilitar a visualização dos nossos circuitos podemos usar .barrier() para criar
# "separadores" nos circuitos
# Essas barras tem uma outra função que pode ser vista no futuro, mas por enquanto podemos
# usar apenas para separar partes do circuito
qc = QuantumCircuit(2,2)
qc.x(0)
qc.y(0)
qc.z(0)
qc.x(1)
qc.y(0)
qc.z(1)
qc.draw(output='mpl')
# Agora vamos separar essa parte
qc.barrier()
qc.draw(output='mpl')
# Com isso podemos continuar a segunda parte do circuito
qc.x(0)
qc.y(0)
qc.z(0)
qc.x(1)
qc.y(0)
qc.z(1)
qc.draw(output='mpl')
|
https://github.com/pedroripper/qiskit_tutoriais
|
pedroripper
|
from qiskit import *
%matplotlib inline
import numpy as np
# Podemos encontrar o operador de densidade de estados
# Para isso vamos primeiramente usar o statevector_simulator para encontrar o vetor de
# estado desejado
qc = QuantumCircuit(1)
qc.ry(3*np.pi/2,0)
qc.draw(output='mpl')
backend = Aer.get_backend('statevector_simulator')
job = execute(qc,backend)
result = job.result()
statevector = result.get_statevector(qc, decimals = 3)
# Aqui está o nosso vetor de estado
print(statevector)
# Agora para encontrar o seu operador de densidade
from qiskit.quantum_info import *
op_densidade = DensityMatrix(statevector)
print(op_densidade.data)
# É possível também visualizar a matriz de densidade por meio de um histograma
from qiskit.visualization import plot_state_city
plot_state_city(statevector)
# Também é possivel visualizar as matrizes de Pauli que compõem o seu operador de densidade
from qiskit.tools.visualization import plot_state_paulivec
plot_state_paulivec(statevector)
# Podemos ver o traço do nosso operador
op_densidade.trace()
estado = [np.sqrt(2),np.sqrt(2)]
print(np.inner(np.inner(estado, op_densidade.data), estado))
rho_2 = np.matmul(op_densidade.data,op_densidade.data)
trace = rho_2.trace()
print(trace)
def bloch_vector(op):
pauli_x = [[0,1],[1,0]]
pauli_y = [[0,-1j],[1j,0]]
pauli_z = [[1,0],[0,-1]]
x = np.matmul(op,pauli_x).trace()
y = np.matmul(op,pauli_y).trace()
z = np.matmul(op,pauli_z).trace()
return [np.absolute(x),np.absolute(y),np.absolute(z)]
from qiskit.tools.visualization import plot_bloch_vector
plot_bloch_vector(bloch_vector(op_densidade.data))
# Exemplo de estado misto:
estado_misto = [[0.5, 0.25],[0.25,0.5]]
plot_bloch_vector(bloch_vector(estado_misto))
|
https://github.com/pedroripper/qiskit_tutoriais
|
pedroripper
|
from qiskit import *
%matplotlib inline
import numpy as np
qc = QuantumCircuit(2,2)
qc.h(0)
qc.cx(0,1)
qc.measure([0,1],[0,1])
qc.draw(output='mpl')
backend = Aer.get_backend('qasm_simulator')
result = execute(qc,backend).result()
from qiskit.tools.visualization import plot_histogram
plot_histogram(result.get_counts(qc))
counts = result.get_counts(qc)
legenda = ['Meu resultado']
plot_histogram(counts,color='red' ,legend=legenda)
IBMQ.load_account()
provedor = IBMQ.get_provider('ibm-q')
backend = provedor.get_backend('ibmq_valencia')
job = execute(qc,backend)
from qiskit.tools.monitor import job_monitor
job_monitor(job)
result2 = job.result()
counts2 = result2.get_counts(qc)
legenda = ['Simulador','CQ Real']
plot_histogram([counts,counts2],color=['red','green'] ,legend=legenda)
qc2 = QuantumCircuit(2,2)
qc2.h(0)
qc2.cx(0,1)
backend_st = Aer.get_backend('statevector_simulator')
result3 = execute(qc2, backend_st).result()
statevector = result3.get_statevector()
from qiskit.tools.visualization import plot_state_city
plot_state_city(statevector)
from qiskit.tools.visualization import plot_state_paulivec
plot_state_paulivec(statevector)
from qiskit.tools.visualization import plot_state_hinton
plot_state_hinton(statevector)
from qiskit.tools.visualization import plot_bloch_multivector
plot_bloch_multivector(statevector)
%matplotlib notebook
# Repare que não está escrito inline como geralmente
plot_bloch_multivector(statevector)
# Para voltar ao normal é necessário apenas rodar o comando original
%matplotlib inline
from qiskit.tools.visualization import plot_bloch_vector
plot_bloch_vector([1,0,0])
|
https://github.com/pedroripper/qiskit_tutoriais
|
pedroripper
|
from qiskit import *
%matplotlib inline
# Podemos transformar o nosso circuito em apenas uma porta
circuito = QuantumCircuit(2)
circuito.x(0)
circuito.h(1)
circuito.draw(output='mpl')
# Para conseguir uma porta que represente essas operações fazemos
# Podemos ainda adicionar um titulo para a nossa porta ou apenas deixar em branco
minha_porta = circuito.to_gate(label='Minha porta')
# Agora vamos adicionar ela em outro circuito
c2 = QuantumCircuit(2)
# Para adicionar uma porta dessa forma usamos o comando append()
c2.append(minha_porta,[0,1])
c2.draw(output='mpl')
# Para conferir se essa porta realmente representa a original fazemos
c2.decompose().draw(output='mpl')
|
https://github.com/pedroripper/qiskit_tutoriais
|
pedroripper
|
from qiskit import *
%matplotlib inline
# Para facilitar a visualização dos nossos circuitos podemos usar .barrier() para criar
# "separadores" nos circuitos
# Essas barras tem uma outra função que pode ser vista no futuro, mas por enquanto podemos
# usar apenas para separar partes do circuito
qc = QuantumCircuit(2,2)
qc.x(0)
qc.y(0)
qc.z(0)
qc.x(1)
qc.y(0)
qc.z(1)
qc.draw(output='mpl')
# Agora vamos separar essa parte
qc.barrier()
qc.draw(output='mpl')
# Com isso podemos continuar a segunda parte do circuito
qc.x(0)
qc.y(0)
qc.z(0)
qc.x(1)
qc.y(0)
qc.z(1)
qc.draw(output='mpl')
|
https://github.com/pedroripper/qiskit_tutoriais
|
pedroripper
|
from qiskit import *
%matplotlib inline
import numpy as np
# Podemos encontrar o operador de densidade de estados
# Para isso vamos primeiramente usar o statevector_simulator para encontrar o vetor de
# estado desejado
qc = QuantumCircuit(1)
qc.rx(np.pi/2,0)
qc.draw(output='mpl')
backend = Aer.get_backend('statevector_simulator')
job = execute(qc,backend)
result = job.result()
statevector = result.get_statevector()
# Aqui está o nosso vetor de estado
print(statevector)
# Agora para encontrar o seu operador de densidade
from qiskit.quantum_info import *
op_densidade = DensityMatrix(statevector)
print(op_densidade.data)
# Podemos ver o traço do nosso operador
op_densidade.trace()
estado = [np.sqrt(2),np.sqrt(2)]
print(np.inner(np.inner(estado, op_densidade.data), estado))
rho_2 = np.matmul(op_densidade.data,op_densidade.data)
trace = rho_2.trace()
print(trace)
def bloch_vector(op):
pauli_x = [[0,1],[1,0]]
pauli_y = [[0,-1j],[1j,0]]
pauli_z = [[1,0],[0,-1]]
x = np.matmul(op,pauli_x).trace()
y = np.matmul(op,pauli_y).trace()
z = np.matmul(op,pauli_z).trace()
return [np.absolute(x),np.absolute(y),np.absolute(z)]
from qiskit.tools.visualization import plot_bloch_vector
plot_bloch_vector(bloch_vector(op_densidade.data))
# Exemplo de estado misto:
estado_misto = [[0.5, 0.25],[0.25,0.5]]
plot_bloch_vector(bloch_vector(estado_misto))
|
https://github.com/pedroripper/qiskit_tutoriais
|
pedroripper
|
from qiskit import *
%matplotlib inline
import numpy as np
qc = QuantumCircuit(2,2)
qc.h(0)
qc.cx(0,1)
qc.measure([0,1],[0,1])
qc.draw(output='mpl')
backend = Aer.get_backend('qasm_simulator')
result = execute(qc,backend).result()
from qiskit.tools.visualization import plot_histogram
plot_histogram(result.get_counts(qc))
counts = result.get_counts(qc)
legenda = ['Meu resultado']
plot_histogram(counts,color='red' ,legend=legenda)
IBMQ.load_account()
provedor = IBMQ.get_provider('ibm-q')
backend = provedor.get_backend('ibmq_valencia')
job = execute(qc,backend)
from qiskit.tools.monitor import job_monitor
job_monitor(job)
result2 = job.result()
counts2 = result2.get_counts(qc)
legenda = ['Simulador','CQ Real']
plot_histogram([counts,counts2],color=['red','green'] ,legend=legenda)
qc2 = QuantumCircuit(2,2)
qc2.h(0)
qc2.cx(0,1)
backend_st = Aer.get_backend('statevector_simulator')
result3 = execute(qc2, backend_st).result()
statevector = result3.get_statevector()
from qiskit.tools.visualization import plot_state_city
plot_state_city(statevector)
from qiskit.tools.visualization import plot_state_paulivec
plot_state_paulivec(statevector)
from qiskit.tools.visualization import plot_state_hinton
plot_state_hinton(statevector)
from qiskit.tools.visualization import plot_bloch_multivector
plot_bloch_multivector(statevector)
%matplotlib notebook
# Repare que não está escrito inline como geralmente
plot_bloch_multivector(statevector)
# Para voltar ao normal é necessário apenas rodar o comando original
%matplotlib inline
from qiskit.tools.visualization import plot_bloch_vector
plot_bloch_vector([1,0,0])
|
https://github.com/Fergus-Hayes/qiskit_tools
|
Fergus-Hayes
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ
import qiskit_tools as qt
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
in_digit = np.pi
print(in_digit)
n = 20
nint = qt.get_nint(in_digit)
print(nint)
in_binary = qt.my_binary_repr(in_digit, n, nint=nint, phase=False)
print(in_binary)
out_digit = qt.bin_to_dec(in_binary, nint=nint, phase=False)
print(out_digit)
n-nint
in_digit = -3.25
print(in_digit)
nint = qt.get_nint(in_digit)
print(nint)
npres = qt.get_npres(in_digit)
print(npres)
n = npres + nint + 1
in_binary = qt.my_binary_repr(in_digit, n, nint=nint, phase=True)
print(in_binary)
out_digit = qt.bin_to_dec(in_binary, nint=nint, phase=True)
print(out_digit)
sm_binary = qt.my_binary_repr(in_digit, n, nint=nint, phase=True, signmag=True)
print(sm_binary, qt.bin_to_dec(sm_binary, nint=nint, phase=True, signmag=True))
qreg = QuantumRegister(n, 'bit')
circ = QuantumCircuit(qreg)
circ = qt.input_bits_to_qubits(in_binary, circ, qreg)
circ.draw(output="latex")
|
https://github.com/Fergus-Hayes/qiskit_tools
|
Fergus-Hayes
|
def QFT(N):
'''
Constructing the fourier transform of size NxN.
'''
return np.array([[(np.exp(2.*i*j*1j*np.pi/N))
for j in np.arange(N)]
for i in np.arange(N)])*1./np.sqrt(N)
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ
import qiskit_tools as qt
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
n = 5
xreg = QuantumRegister(n, 'x')
circ = QuantumCircuit(xreg)
circ = qt.QFT(circ, xreg)
circ.draw(output="latex")
backend = Aer.get_backend('unitary_simulator')
job = execute(circ, backend)
result = job.result()
unit_mat = np.array(result.get_unitary(circ, decimals=8))
print(np.sum(np.abs(unit_mat-QFT(2**n))**2))
|
https://github.com/Fergus-Hayes/qiskit_tools
|
Fergus-Hayes
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ
import qiskit_tools as qt
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
n = 5
xreg = QuantumRegister(n, 'x')
circ = QuantumCircuit(xreg)
circ = qt.QFT(circ, xreg)
circ.draw(output="latex")
backend = Aer.get_backend('unitary_simulator')
job = execute(circ, backend)
result = job.result()
unit_mat = np.array(result.get_unitary(circ, decimals=5))
xreg = QuantumRegister(n, 'x')
circ = QuantumCircuit(xreg)
QFT_gate = qt.QFT(circ, xreg, wrap=True)
circ.append(QFT_gate, xreg);
circ.draw(output="latex")
backend = Aer.get_backend('unitary_simulator')
job = execute(circ, backend)
result = job.result()
unit_mat_wrap = np.array(result.get_unitary(circ, decimals=5))
print(np.sum(np.abs(unit_mat-unit_mat_wrap)**2))
xreg = QuantumRegister(n, 'x')
circ = QuantumCircuit(xreg)
QFT_gate = qt.QFT(circ, xreg, wrap=True)
circ.append(QFT_gate, xreg);
iQFT_gate = qt.QFT(circ, xreg, wrap=True, inverse=True)
circ.append(iQFT_gate, xreg);
circ.draw(output="latex")
backend = Aer.get_backend('unitary_simulator')
job = execute(circ, backend)
result = job.result()
unit_mat = np.array(result.get_unitary(circ, decimals=5))
print(np.sum(np.abs(unit_mat - np.eye(2**n))**2))
|
https://github.com/Fergus-Hayes/qiskit_tools
|
Fergus-Hayes
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ
import qiskit_tools as qt
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
digit_A = 5.25
digit_B = 7.5
print(digit_A,'+',digit_B,'=',digit_A+digit_B)
nint = qt.get_nint([digit_A+digit_B,digit_A,digit_B])
npres = qt.get_npres([digit_A+digit_B,digit_A,digit_B])
n = nint + npres + 1
phase = True
binary_A = qt.my_binary_repr(digit_A, n, nint=nint, phase=phase)
binary_B = qt.my_binary_repr(digit_B, n, nint=nint, phase=phase)
print(binary_A,binary_B)
qregA = QuantumRegister(n, 'A')
qregB = QuantumRegister(n, 'B')
out_reg = ClassicalRegister(n, 'A+B')
circ = QuantumCircuit(qregA, qregB, out_reg)
A_gate = qt.input_bits_to_qubits(binary_A, circ, reg=qregA, wrap=True)
B_gate = qt.input_bits_to_qubits(binary_B, circ, reg=qregB, wrap=True)
circ.append(A_gate, qregA);
circ.append(B_gate, qregB);
add_gate = qt.QFTAddition(circ, qregA, qregB, wrap=True)
circ.append(add_gate, [*qregA, *qregB]);
circ.measure(qregB, out_reg);
circ.draw(output="latex")
shots=20
emulator = Aer.get_backend('qasm_simulator')
job = execute(circ, emulator, shots=shots )
hist = job.result().get_counts()
print('Target:')
print(digit_B,'+',digit_A,'=',digit_B+digit_A,'->',qt.my_binary_repr(digit_B+digit_A, n, nint=nint, phase=phase))
print('Result:')
for label in hist.keys():
print(digit_B,'+',digit_A,'=',qt.bin_to_dec(label, nint=nint, phase=phase),'->',label,'with probability',float(hist[label])/shots)
digit_A = 5.25
digit_B = -7.5
print(digit_A,'+',digit_B,'=',digit_A+digit_B)
nint = qt.get_nint([digit_A+digit_B,digit_A,digit_B])
npres = qt.get_npres([digit_A+digit_B,digit_A,digit_B])
n = nint + npres + 1
phase = True
binary_A = qt.my_binary_repr(digit_A, n, nint=nint, phase=phase)
binary_B = qt.my_binary_repr(digit_B, n, nint=nint, phase=phase)
print(binary_A,binary_B)
qregA = QuantumRegister(n, 'A')
qregB = QuantumRegister(n, 'B')
out_reg = ClassicalRegister(n, 'A+B')
circ = QuantumCircuit(qregA, qregB, out_reg)
A_gate = qt.input_bits_to_qubits(binary_A, circ, reg=qregA, wrap=True)
B_gate = qt.input_bits_to_qubits(binary_B, circ, reg=qregB, wrap=True)
circ.append(A_gate, qregA);
circ.append(B_gate, qregB);
add_gate = qt.QFTAddition(circ, qregA, qregB, wrap=True)
circ.append(add_gate, [*qregA, *qregB]);
circ.measure(qregB, out_reg);
circ.draw(output="latex")
shots=20
emulator = Aer.get_backend('qasm_simulator')
job = execute(circ, emulator, shots=shots )
hist = job.result().get_counts()
print('Target:')
print(digit_B,'+',digit_A,'=',digit_B+digit_A,'->',qt.my_binary_repr(digit_B+digit_A, n, nint=nint, phase=phase))
print('Result:')
for label in hist.keys():
print(digit_B,'+',digit_A,'=',qt.bin_to_dec(label, nint=nint, phase=phase),'->',label,'with probability',float(hist[label])/shots)
digit_A = 5.25
digit_B = 7.5
nint = qt.get_nint([digit_A-digit_B,digit_A,digit_B])
npres = qt.get_npres([digit_A-digit_B,digit_A,digit_B])
n = nint + npres + 1
phase = True
binary_A = qt.my_binary_repr(digit_A, n, nint=nint, phase=phase)
binary_B = qt.my_binary_repr(digit_B, n, nint=nint, phase=phase)
print(binary_A,binary_B)
qregA = QuantumRegister(n, 'A')
qregB = QuantumRegister(n, 'B')
out_reg = ClassicalRegister(n, 'A+B')
circ = QuantumCircuit(qregA, qregB, out_reg)
A_gate = qt.input_bits_to_qubits(binary_A, circ, reg=qregA, wrap=True)
B_gate = qt.input_bits_to_qubits(binary_B, circ, reg=qregB, wrap=True)
circ.append(A_gate, qregA);
circ.append(B_gate, qregB);
tc_gate = qt.TwosCompliment(circ, qregB, wrap=True)
circ.append(tc_gate, qregB);
add_gate = qt.QFTAddition(circ, qregA, qregB, wrap=True)
circ.append(add_gate, [*qregA, *qregB]);
circ.measure(qregB, out_reg);
circ.draw(output="latex")
shots=20
emulator = Aer.get_backend('qasm_simulator')
job = execute(circ, emulator, shots=shots )
hist = job.result().get_counts()
print('Target:')
print(digit_B,'-',digit_A,'=',digit_B-digit_A,'->',qt.my_binary_repr(digit_A-digit_B, n, nint=nint, phase=phase))
print('Result:')
for label in hist.keys():
print(digit_B,'-',digit_A,'=',qt.bin_to_dec(label, nint=nint, phase=phase),'->',label,'with probability',float(hist[label])/shots)
digit_A = -5.5
digit_B = 7.25
nintA = qt.get_nint([digit_A])
npresA = qt.get_npres([digit_A])
nA = nintA + npresA + 1
nintB = qt.get_nint([digit_B,digit_A+digit_B])
npresB = qt.get_npres([digit_B,digit_A+digit_B])
nB = nintB + npresB + 1
phase = True
binary_A = qt.my_binary_repr(digit_A, nA, nint=nintA, phase=phase)
binary_B = qt.my_binary_repr(digit_B, nB, nint=nintB, phase=phase)
print(binary_A,binary_B)
qregA = QuantumRegister(nA, 'A')
qregB = QuantumRegister(nB, 'B')
out_reg = ClassicalRegister(nB, 'A+B')
circ = QuantumCircuit(qregA, qregB, out_reg)
A_gate = qt.input_bits_to_qubits(binary_A, circ, reg=qregA, wrap=True)
B_gate = qt.input_bits_to_qubits(binary_B, circ, reg=qregB, wrap=True)
circ.append(A_gate, qregA);
circ.append(B_gate, qregB);
circ = qt.QFTAddition(circ, qregA, qregB, nint1=nintA, nint2=nintB, phase=phase)
circ.measure(qregB, out_reg);
shots=20
emulator = Aer.get_backend('qasm_simulator')
job = execute(circ, emulator, shots=shots )
hist = job.result().get_counts()
print('Target:')
print(digit_B,'+',digit_A,'=',digit_B+digit_A,'->',qt.my_binary_repr(digit_A+digit_B, nB, nint=nintB, phase=phase))
print('Result:')
for label in hist.keys():
print(digit_B,'+',digit_A,'=',qt.bin_to_dec(label, nint=nintB, phase=phase),'->',label,'with probability',float(hist[label])/shots)
|
https://github.com/Fergus-Hayes/qiskit_tools
|
Fergus-Hayes
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ
import qiskit_tools as qt
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
phase = True
digit_A = 5.25
digit_B = 7.5
print(digit_A,'x',digit_B,'=',digit_A*digit_B)
nintA = qt.get_nint(digit_A)
npresA = qt.get_npres(digit_A)
nA = nintA + npresA
if phase:
nA += 1
print(nA, nintA, npresA)
nintB = qt.get_nint(digit_B)
npresB = qt.get_npres(digit_B)
nB = nintB + npresB
if phase:
nB += 1
print(nB, nintB, npresB)
nintC = qt.get_nint(digit_A*digit_B)
npresC = qt.get_npres(digit_A*digit_B)
nC = nintC + npresC
if phase:
nC += 1
print(nC, nintC, npresC)
binary_A = qt.my_binary_repr(digit_A, nA, nint=nintA, phase=phase)
binary_B = qt.my_binary_repr(digit_B, nB, nint=nintB, phase=phase)
binary_C = qt.my_binary_repr(digit_A*digit_B, nC, nint=nintC, phase=phase)
print(binary_A,binary_B,binary_C)
qregA = QuantumRegister(nA, 'A')
qregB = QuantumRegister(nB, 'B')
qregC = QuantumRegister(nC, 'C')
out_reg = ClassicalRegister(nC,'out_reg')
circ = QuantumCircuit(qregA, qregB, qregC, out_reg)
A_gate = qt.input_bits_to_qubits(binary_A, circ, reg=qregA, wrap=True)
B_gate = qt.input_bits_to_qubits(binary_B, circ, reg=qregB, wrap=True)
circ.append(A_gate, qregA);
circ.append(B_gate, qregB);
mult_gate = qt.QFTMultiply(circ, qregA, qregB, qregC, nint1=nintA, nint2=nintB, nint3=nintC, phase=True, wrap=True)
circ.append(mult_gate, [*qregA, *qregB, *qregC]);
circ.measure(qregC, out_reg);
circ.draw('latex')
shots=10
emulator = Aer.get_backend('qasm_simulator')
job = execute(circ, emulator, shots=shots )
hist = job.result().get_counts()
print('Target:')
print(digit_B,'x',digit_A,'=',digit_B*digit_A,'->',binary_C)
print('Result:')
for label in hist.keys():
print(digit_B,'x',digit_A,'=',qt.bin_to_dec(label, nint=nintC, phase=phase),'->',label,'with probability',float(hist[label])/shots)
phase = True
digit_A = 5.25
digit_B = -7.5
print(digit_A,'x',digit_B,'=',digit_A*digit_B)
binary_A = qt.my_binary_repr(digit_A, nA, nint=nintA, phase=phase)
binary_B = qt.my_binary_repr(digit_B, nB, nint=nintB, phase=phase)
binary_C = qt.my_binary_repr(digit_A*digit_B, nC, nint=nintC, phase=phase)
print(binary_A,binary_B,binary_C)
qregA = QuantumRegister(nA, 'A')
qregB = QuantumRegister(nB, 'B')
qregC = QuantumRegister(nC, 'C')
out_reg = ClassicalRegister(nC,'out_reg')
circ = QuantumCircuit(qregA, qregB, qregC, out_reg)
A_gate = qt.input_bits_to_qubits(binary_A, circ, reg=qregA, wrap=True)
B_gate = qt.input_bits_to_qubits(binary_B, circ, reg=qregB, wrap=True)
circ.append(A_gate, qregA);
circ.append(B_gate, qregB);
mult_gate = qt.QFTMultiply(circ, qregA, qregB, qregC, nint1=nintA, nint2=nintB, nint3=nintC, phase=True, wrap=True)
circ.append(mult_gate, [*qregA, *qregB, *qregC]);
circ.measure(qregC, out_reg);
shots=10
emulator = Aer.get_backend('qasm_simulator')
job = execute(circ, emulator, shots=shots )
hist = job.result().get_counts()
print('Target:')
print(digit_B,'x',digit_A,'=',digit_B*digit_A,'->',binary_C)
print('Result:')
for label in hist.keys():
print(digit_B,'x',digit_A,'=',qt.bin_to_dec(label, nint=nintC, phase=phase),'->',label,'with probability',float(hist[label])/shots)
qregA = QuantumRegister(nA, 'A')
qregB = QuantumRegister(nB, 'B')
qregC = QuantumRegister(nC, 'C')
out_reg = ClassicalRegister(nC,'out_reg')
circ = QuantumCircuit(qregA, qregB, qregC, out_reg)
# Input the A and B binary strings into their registers
A_gate = qt.input_bits_to_qubits(binary_A, circ, reg=qregA, wrap=True)
B_gate = qt.input_bits_to_qubits(binary_B, circ, reg=qregB, wrap=True)
circ.append(A_gate, qregA);
circ.append(B_gate, qregB);
circ.barrier()
# Define the twos-complement operations
tc_gate_A = qt.TwosCompliment(circ, qregA[:-1], wrap=True).control(1)
tc_gate_B = qt.TwosCompliment(circ, qregB[:-1], wrap=True).control(1)
tc_gate_C = qt.TwosCompliment(circ, qregC[:-1], wrap=True).control(2)
# Add the twos-complement operations to convert registers A and B to sign-magnitude notation
circ.append(tc_gate_A, [qregA[-1], *qregA[:-1]]);
circ.append(tc_gate_B, [qregB[-1], *qregB[:-1]]);
circ.barrier()
# Apply simple QFT multiplication
mult_gate = qt.QFTMultiply(circ, qregA[:-1], qregB[:-1], qregC[:-1], nint1=nintA, nint2=nintB, nint3=nintC, wrap=True)
circ.append(mult_gate, [*qregA[:-1], *qregB[:-1], *qregC[:-1]]);
circ.barrier()
# If register A is positive, but register B is negative, then twos-complement operator on C
circ.x(qregA[-1]);
circ.append(tc_gate_C, [qregA[-1], qregB[-1], *qregC[:-1]]);
circ.x(qregA[-1]);
# If register B is positive, but register A is negative, then twos-complement operator on C
circ.x(qregB[-1]);
circ.append(tc_gate_C, [qregA[-1], qregB[-1], *qregC[:-1]]);
circ.x(qregB[-1]);
circ.barrier()
# If A is negative flip phase qubit of C, and if B is negative flip phase qubit of C
circ.cx(qregA[-1], qregC[-1]);
circ.cx(qregB[-1], qregC[-1]);
circ.barrier()
# Restore registers A and B to original twos-complement notation
circ.append(tc_gate_A, [qregA[-1], *qregA[:-1]]);
circ.append(tc_gate_B, [qregB[-1], *qregB[:-1]]);
circ.barrier()
circ.measure(qregC, out_reg);
circ.draw('latex')
shots=10
emulator = Aer.get_backend('qasm_simulator')
job = execute(circ, emulator, shots=shots )
hist = job.result().get_counts()
print('Target:')
print(digit_B,'x',digit_A,'=',digit_B*digit_A,'->',binary_C)
print('Result:')
for label in hist.keys():
print(digit_B,'x',digit_A,'=',qt.bin_to_dec(label, nint=nintC, phase=phase),'->',label,'with probability',float(hist[label])/shots)
phase = True
digit_A = 0.
digit_B = -7.5
print(digit_A,'x',digit_B,'=',digit_A*digit_B)
binary_A = qt.my_binary_repr(digit_A, nA, nint=nintA, phase=phase)
binary_B = qt.my_binary_repr(digit_B, nB, nint=nintB, phase=phase)
binary_C = qt.my_binary_repr(digit_A*digit_B, nC, nint=nintC, phase=phase)
print(binary_A,binary_B,binary_C)
qregA = QuantumRegister(nA, 'A')
qregB = QuantumRegister(nB, 'B')
qregC = QuantumRegister(nC, 'C')
out_reg = ClassicalRegister(nC,'out_reg')
circ = QuantumCircuit(qregA, qregB, qregC, out_reg)
# Input the A and B binary strings into their registers
A_gate = qt.input_bits_to_qubits(binary_A, circ, reg=qregA, wrap=True)
B_gate = qt.input_bits_to_qubits(binary_B, circ, reg=qregB, wrap=True)
circ.append(A_gate, qregA);
circ.append(B_gate, qregB);
circ.barrier()
# Define the twos-complement operations
tc_gate_A = qt.TwosCompliment(circ, qregA[:-1], wrap=True).control(1)
tc_gate_B = qt.TwosCompliment(circ, qregB[:-1], wrap=True).control(1)
tc_gate_C = qt.TwosCompliment(circ, qregC[:-1], wrap=True).control(2)
# Add the twos-complement operations to convert registers A and B to sign-magnitude notation
circ.append(tc_gate_A, [qregA[-1], *qregA[:-1]]);
circ.append(tc_gate_B, [qregB[-1], *qregB[:-1]]);
circ.barrier()
# Apply simple QFT multiplication
mult_gate = qt.QFTMultiply(circ, qregA[:-1], qregB[:-1], qregC[:-1], nint1=nintA, nint2=nintB, nint3=nintC, wrap=True)
circ.append(mult_gate, [*qregA[:-1], *qregB[:-1], *qregC[:-1]]);
circ.barrier()
# If register A is positive, but register B is negative, then twos-complement operator on C
circ.x(qregA[-1]);
circ.append(tc_gate_C, [qregA[-1], qregB[-1], *qregC[:-1]]);
circ.x(qregA[-1]);
# If register B is positive, but register A is negative, then twos-complement operator on C
circ.x(qregB[-1]);
circ.append(tc_gate_C, [qregA[-1], qregB[-1], *qregC[:-1]]);
circ.x(qregB[-1]);
circ.barrier()
# If A is negative flip phase qubit of C, and if B is negative flip phase qubit of C
circ.cx(qregA[-1], qregC[-1]);
circ.cx(qregB[-1], qregC[-1]);
circ.barrier()
# Restore registers A and B to original twos-complement notation
circ.append(tc_gate_A, [qregA[-1], *qregA[:-1]]);
circ.append(tc_gate_B, [qregB[-1], *qregB[:-1]]);
circ.barrier()
circ.measure(qregC, out_reg);
shots=10
emulator = Aer.get_backend('qasm_simulator')
job = execute(circ, emulator, shots=shots )
hist = job.result().get_counts()
print('Target:')
print(digit_B,'x',digit_A,'=',digit_B*digit_A,'->',binary_C)
print('Result:')
for label in hist.keys():
print(digit_B,'x',digit_A,'=',qt.bin_to_dec(label, nint=nintC, phase=phase),'->',label,'with probability',float(hist[label])/shots)
qregA = QuantumRegister(nA, 'A')
qregB = QuantumRegister(nB, 'B')
qregC = QuantumRegister(nC, 'C')
out_reg = ClassicalRegister(nC,'out_reg')
circ = QuantumCircuit(qregA, qregB, qregC, out_reg)
# Input the A and B binary strings into their registers
A_gate = qt.input_bits_to_qubits(binary_A, circ, reg=qregA, wrap=True)
B_gate = qt.input_bits_to_qubits(binary_B, circ, reg=qregB, wrap=True)
circ.append(A_gate, qregA);
circ.append(B_gate, qregB);
circ.barrier()
# Define the twos-complement operations
tc_gate_A = qt.TwosCompliment(circ, qregA[:-1], wrap=True).control(1)
tc_gate_B = qt.TwosCompliment(circ, qregB[:-1], wrap=True).control(1)
tc_gate_C = qt.TwosCompliment(circ, qregC[:-1], wrap=True).control(2)
# Add the twos-complement operations to convert registers A and B to sign-magnitude notation
circ.append(tc_gate_A, [qregA[-1], *qregA[:-1]]);
circ.append(tc_gate_B, [qregB[-1], *qregB[:-1]]);
circ.barrier()
# Apply simple QFT multiplication
mult_gate = qt.QFTMultiply(circ, qregA[:-1], qregB[:-1], qregC[:-1], nint1=nintA, nint2=nintB, nint3=nintC, wrap=True)
circ.append(mult_gate, [*qregA[:-1], *qregB[:-1], *qregC[:-1]]);
circ.barrier()
# If register A is positive, but register B is negative, then twos-complement operator on C
circ.x(qregA[-1]);
circ.append(tc_gate_C, [qregA[-1], qregB[-1], *qregC[:-1]]);
circ.x(qregA[-1]);
# If register B is positive, but register A is negative, then twos-complement operator on C
circ.x(qregB[-1]);
circ.append(tc_gate_C, [qregA[-1], qregB[-1], *qregC[:-1]]);
circ.x(qregB[-1]);
circ.barrier()
# If A is negative flip phase qubit of C, and if B is negative flip phase qubit of C
circ.cx(qregA[-1], qregC[-1]);
circ.cx(qregB[-1], qregC[-1]);
circ.barrier()
# Restore registers A and B to original twos-complement notation
circ.append(tc_gate_A, [qregA[-1], *qregA[:-1]]);
circ.append(tc_gate_B, [qregB[-1], *qregB[:-1]]);
circ.barrier()
# Flip register A
for qubit in np.arange(nA):
circ.x(qregA[qubit]);
# If register A is all zeros and phase of B is negative, then flip the phase of C
circ.mcx([*qregA, qregB[-1]], qregC[-1], mode='noancilla')
# Flip back register A
for qubit in np.arange(nA):
circ.x(qregA[qubit]);
circ.barrier()
# Flip register B
for qubit in np.arange(nB):
circ.x(qregB[qubit]);
# If register B is all zeros and phase of A is negative, then flip the phase of C
circ.mcx([*qregB, qregA[-1]], qregC[-1], mode='noancilla')
# Flip back register B
for qubit in np.arange(nB):
circ.x(qregB[qubit]);
circ.barrier()
circ.measure(qregC, out_reg);
circ.draw('latex')
shots=10
emulator = Aer.get_backend('qasm_simulator')
job = execute(circ, emulator, shots=shots )
hist = job.result().get_counts()
print('Target:')
print(digit_B,'x',digit_A,'=',digit_B*digit_A,'->',binary_C)
print('Result:')
for label in hist.keys():
print(digit_B,'x',digit_A,'=',qt.bin_to_dec(label, nint=nintC, phase=phase),'->',label,'with probability',float(hist[label])/shots)
phase = True
digit_A = 5.25
digit_B = -7.5
print(digit_A,'x',digit_B,'=',digit_A*digit_B)
binary_A = qt.my_binary_repr(digit_A, nA, nint=nintA, phase=phase)
binary_B = qt.my_binary_repr(digit_B, nB, nint=nintB, phase=phase)
binary_C = qt.my_binary_repr(digit_A*digit_B, nC, nint=nintC, phase=phase)
print(binary_A,binary_B,binary_C)
qregA = QuantumRegister(nA, 'A')
qregB = QuantumRegister(nB, 'B')
qregC = QuantumRegister(nC, 'C')
out_reg = ClassicalRegister(nC,'out_reg')
circ = QuantumCircuit(qregA, qregB, qregC, out_reg)
A_gate = qt.input_bits_to_qubits(binary_A, circ, reg=qregA, wrap=True)
B_gate = qt.input_bits_to_qubits(binary_B, circ, reg=qregB, wrap=True)
circ.append(A_gate, qregA);
circ.append(B_gate, qregB);
mult_gate = qt.QFTMultPhase(circ, qregA, qregB, qregC, nint1=nintA, nint2=nintB, nint3=nintC, wrap=True)
circ.append(mult_gate, [*qregA, *qregB, *qregC]);
circ.measure(qregC, out_reg);
circ.draw(output='latex')
shots=10
emulator = Aer.get_backend('qasm_simulator')
job = execute(circ, emulator, shots=shots )
hist = job.result().get_counts()
print('Target:')
print(digit_B,'x',digit_A,'=',digit_B*digit_A,'->',binary_C)
print('Result:')
for label in hist.keys():
print(digit_B,'x',digit_A,'=',qt.bin_to_dec(label, nint=nintC, phase=phase),'->',label,'with probability',float(hist[label])/shots)
phase = True
signmag = True
digit_A = -5.25
digit_B = 0
print(digit_A,'x',digit_B,'=',digit_A*digit_B)
binary_A = qt.my_binary_repr(digit_A, nA, nint=nintA, phase=phase, signmag=signmag)
binary_B = qt.my_binary_repr(digit_B, nB, nint=nintB, phase=phase, signmag=signmag)
binary_C = qt.my_binary_repr(digit_A*digit_B, nC, nint=nintC, phase=phase, signmag=signmag)
print(binary_A,binary_B,binary_C)
qregA = QuantumRegister(nA, 'A')
qregB = QuantumRegister(nB, 'B')
qregC = QuantumRegister(nC, 'C')
out_reg = ClassicalRegister(nC,'out_reg')
circ = QuantumCircuit(qregA, qregB, qregC, out_reg)
A_gate = qt.input_bits_to_qubits(binary_A, circ, reg=qregA, wrap=True)
B_gate = qt.input_bits_to_qubits(binary_B, circ, reg=qregB, wrap=True)
circ.append(A_gate, qregA);
circ.append(B_gate, qregB);
mult_gate = qt.QFTMultPhase(circ, qregA, qregB, qregC, nint1=nintA, nint2=nintB, nint3=nintC, wrap=True, signmag1=True, signmag2=True, signmag3=True)
circ.append(mult_gate, [*qregA, *qregB, *qregC]);
circ.measure(qregC, out_reg);
circ.decompose(reps=1).draw(output='latex')
shots=10
emulator = Aer.get_backend('qasm_simulator')
job = execute(circ, emulator, shots=shots )
hist = job.result().get_counts()
print('Target:')
print(digit_B,'x',digit_A,'=',digit_B*digit_A,'->',binary_C)
print('Result:')
for label in hist.keys():
print(digit_B,'x',digit_A,'=',qt.bin_to_dec(label, nint=nintC, phase=phase, signmag=signmag),'->',label,'with probability',float(hist[label])/shots)
phase = True
signmag = True
digit_A = -5.25
digit_B = 0
print(digit_A,'x',digit_B,'=',digit_A*digit_B)
binary_A = qt.my_binary_repr(digit_A, nA, nint=nintA, phase=phase, signmag=signmag)
binary_B = qt.my_binary_repr(digit_B, nB, nint=nintB, phase=phase, signmag=signmag)
binary_C = qt.my_binary_repr(digit_A*digit_B, nC, nint=nintC, phase=phase, signmag=signmag)
print(binary_A,binary_B,binary_C)
qregA = QuantumRegister(nA, 'A')
qregB = QuantumRegister(nB, 'B')
qregC = QuantumRegister(nC, 'C')
out_reg = ClassicalRegister(nC,'out_reg')
circ = QuantumCircuit(qregA, qregB, qregC, out_reg)
A_gate = qt.input_bits_to_qubits(binary_A, circ, reg=qregA, wrap=True)
B_gate = qt.input_bits_to_qubits(binary_B, circ, reg=qregB, wrap=True)
circ.append(A_gate, qregA);
circ.append(B_gate, qregB);
circ = qt.QFTMultPhase(circ, qregA, qregB, qregC, nint1=nintA, nint2=nintB, nint3=nintC, poszero=True, signmag1=True, signmag2=True, signmag3=True)
circ.measure(qregC, out_reg);
circ.decompose(reps=1).draw(output='latex')
shots=10
emulator = Aer.get_backend('qasm_simulator')
job = execute(circ, emulator, shots=shots )
hist = job.result().get_counts()
print('Target:')
print(digit_B,'x',digit_A,'=',digit_B*digit_A,'->',binary_C)
print('Result:')
for label in hist.keys():
print(digit_B,'x',digit_A,'=',qt.bin_to_dec(label, nint=nintC, phase=phase, signmag=signmag),'->',label,'with probability',float(hist[label])/shots)
|
https://github.com/Fergus-Hayes/qiskit_tools
|
Fergus-Hayes
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ
import qiskit_tools as qt
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
digit = 10.25
k = 2
target = np.power(digit, k)
print(digit,'^'+str(k),'=',target)
nintx = qt.get_nint(digit)
npresx = qt.get_npres(digit)
nx = nintx + npresx + 1
print(nx, nintx, npresx)
nint = qt.get_nint(target)
npres = qt.get_npres(target)
n = nint + npres + 1
print(n, nint)
phase = True
binary = qt.my_binary_repr(digit, nx, nint=nintx, phase=phase)
binary_t = qt.my_binary_repr(target, n, nint=nint, phase=phase)
qx = QuantumRegister(nx, 'x')
qtarg = QuantumRegister(n,'targ')
c_out = ClassicalRegister(n, 'c_out')
circ = QuantumCircuit(qx, qtarg, c_out)
in_gate = qt.input_bits_to_qubits(binary, circ, reg=qx, wrap=True)
circ.append(in_gate, qx);
power_gate = qt.QFTPowerN(circ, qx, qtarg, k, wrap=True, nintx=nintx, nint=nint)
circ.append(power_gate, [*qx, *qtarg]);
circ.measure(qtarg, c_out);
circ.draw('latex')
shots=10
emulator = Aer.get_backend('qasm_simulator')
job = execute(circ, emulator, shots=shots )
hist = job.result().get_counts()
print('Target:')
print(digit,'^'+str(k),'=',target,'->',binary_t)
print('Result:')
for label in hist.keys():
print(digit,'^'+str(k),'=',qt.bin_to_dec(label, nint=nint, phase=phase),'->',label,'with probability',float(hist[label])/shots)
digit = 1.25
k = 5
target = np.power(digit, k)
print(digit,'^'+str(k),'=',target)
nintx = qt.get_nint(digit)
npresx = qt.get_npres(digit)
nx = nintx + npresx + 1
print(nx, nintx, npresx)
nint = qt.get_nint(target)
npres = qt.get_npres(target)
n = nint + npres + 1
print(n, nint)
phase = True
binary = qt.my_binary_repr(digit, nx, nint=nintx, phase=phase)
binary_t = qt.my_binary_repr(target, n, nint=nint, phase=phase)
qx = QuantumRegister(nx, 'x')
qtarg = QuantumRegister(n,'targ')
c_out = ClassicalRegister(n, 'c_out')
circ = QuantumCircuit(qx, qtarg, c_out)
in_gate = qt.input_bits_to_qubits(binary, circ, reg=qx, wrap=True)
circ.append(in_gate, qx);
power_gate = qt.QFTPowerN(circ, qx, qtarg, k, wrap=True, nintx=nintx, nint=nint)
circ.append(power_gate, [*qx, *qtarg]);
circ.measure(qtarg, c_out);
shots=10
emulator = Aer.get_backend('qasm_simulator')
job = execute(circ, emulator, shots=shots )
hist = job.result().get_counts()
print('Target:')
print(digit,'^'+str(k),'=',target,'->',binary_t)
print('Result:')
for label in hist.keys():
print(digit,'^'+str(k),'=',qt.bin_to_dec(label, nint=nint, phase=phase),'->',label,'with probability',float(hist[label])/shots)
|
https://github.com/Fergus-Hayes/qiskit_tools
|
Fergus-Hayes
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ
import qiskit_tools as qt
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
digit = 2
a = 1
phase = False
nint = qt.get_nint([digit,a])
npres = qt.get_npres([digit,a])
n = nint + npres
if phase:
n+=1
print(n, nint, npres)
binary_x = qt.my_binary_repr(digit, n, nint=nint, phase=phase)
binary_a = qt.my_binary_repr(a, n, nint=nint, phase=phase)
print(binary_x,binary_a)
print('It is',digit>=a,'that',str(digit)+' >= '+str(a)+'.')
qx = QuantumRegister(n, 'x')
qtarg = QuantumRegister(1, 'targ')
qans = QuantumRegister(n-1, 'anc')
out_reg = ClassicalRegister(1,'out_reg')
circ = QuantumCircuit(qx, qtarg, qans, out_reg)
x_gate = qt.input_bits_to_qubits(binary_x, circ, reg=qx, wrap=True)
circ.append(x_gate, qx);
intcomp_gate = qt.integer_compare(circ, qx, qtarg, qans, a, geq=True, wrap=True)
circ.append(intcomp_gate, [*qx, *qtarg, *qans]);
circ.measure(qtarg, out_reg);
circ.draw('latex')
circ.decompose(reps=1).draw('latex')
shots=10
emulator = Aer.get_backend('qasm_simulator')
job = execute(circ, emulator, shots=shots )
hist = job.result().get_counts()
print('Target:')
print(digit,'>=',a,'=',digit>=a)
print('Result:')
for label in hist.keys():
print(digit,'>=',a,'=',bool(qt.bin_to_dec(label, nint=nint, phase=False)),'->',label,'with probability',float(hist[label])/shots)
digit = 1.5
a = 2.25
phase = False
nint = qt.get_nint([digit,a])
npres = qt.get_npres([digit,a])
n = nint + npres
if phase:
n+=1
print(n, nint, npres)
binary_x = qt.my_binary_repr(digit, n, nint=nint, phase=phase)
binary_a = qt.my_binary_repr(a, n, nint=nint, phase=phase)
int_x = qt.bin_to_dec(binary_x, nint=None, phase=False)
int_a = qt.bin_to_dec(binary_a, nint=None, phase=False)
print(digit,'->',binary_x,'->',int(int_x),',',a,'->',binary_a,'->',int(int_a))
print('It is',digit>=a,'that',str(digit)+' >= '+str(a)+', and it is',int_x>=int_a,'that',str(int_x)+' >= '+str(int_a))
qx = QuantumRegister(n, 'x')
qtarg = QuantumRegister(1, 'targ')
qans = QuantumRegister(n-1, 'anc')
out_reg = ClassicalRegister(1,'out_reg')
circ = QuantumCircuit(qx, qtarg, qans, out_reg)
x_gate = qt.input_bits_to_qubits(binary_x, circ, reg=qx, wrap=True)
circ.append(x_gate, qx);
intcomp_gate = qt.integer_compare(circ, qx, qtarg, qans, int_a, geq=True, wrap=True)
circ.append(intcomp_gate, [*qx, *qtarg, *qans]);
circ.measure(qtarg, out_reg);
shots=10
emulator = Aer.get_backend('qasm_simulator')
job = execute(circ, emulator, shots=shots )
hist = job.result().get_counts()
print('Target:')
print(digit,'>=',a,'=',digit>=a)
print('Result:')
for label in hist.keys():
print(digit,'>=',a,'=',bool(qt.bin_to_dec(label, nint=nint, phase=False)),'->',label,'with probability',float(hist[label])/shots)
digit = -1.5
a = 2.25
phase = True
nint = qt.get_nint([digit,a])
npres = qt.get_npres([digit,a])
n = nint + npres
if phase:
n+=1
print(n, nint, npres)
binary_x = qt.my_binary_repr(digit, n, nint=nint, phase=phase)
binary_a = qt.my_binary_repr(a, n, nint=nint, phase=phase)
binary_a_ = qt.my_binary_repr(a, n, nint=nint, phase=phase)
if binary_a[0]=='0':
binary_a_ = '1'+binary_a[1:]
elif binary_a[0]=='1':
binary_a_ = '0'+binary_a[1:]
binary_x_ = qt.my_binary_repr(digit, n, nint=nint, phase=phase)
if binary_x[0]=='0':
binary_x_ = '1'+binary_x[1:]
elif binary_x[0]=='1':
binary_x_ = '0'+binary_x[1:]
int_x = qt.bin_to_dec(binary_x_, nint=None, phase=False)
int_a = qt.bin_to_dec(binary_a_, nint=None, phase=False)
print(digit,'->',binary_x,'->',binary_x_,'->',int(int_x),',',a,'->',binary_a,'->',binary_a_,'->',int(int_a))
print('It is',digit>=a,'that',str(digit)+' >= '+str(a)+', and it is',int_x>=int_a,'that',str(int_x)+' >= '+str(int_a))
qx = QuantumRegister(n, 'x')
qtarg = QuantumRegister(1, 'targ')
qans = QuantumRegister(n-1, 'anc')
out_reg = ClassicalRegister(1,'out_reg')
circ = QuantumCircuit(qx, qtarg, qans, out_reg)
x_gate = qt.input_bits_to_qubits(binary_x, circ, reg=qx, wrap=True)
circ.append(x_gate, qx);
circ.x(qx[-1]);
intcomp_gate = qt.integer_compare(circ, qx, qtarg, qans, int_a, geq=True, wrap=True)
circ.append(intcomp_gate, [*qx, *qtarg, *qans]);
circ.x(qx[-1]);
circ.measure(qtarg, out_reg);
circ.draw('latex')
shots=10
emulator = Aer.get_backend('qasm_simulator')
job = execute(circ, emulator, shots=shots )
hist = job.result().get_counts()
print('Target:')
print(digit,'>=',a,'=',digit>=a)
print('Result:')
for label in hist.keys():
print(digit,'>=',a,'=',bool(qt.bin_to_dec(label, nint=nint, phase=False)),'->',label,'with probability',float(hist[label])/shots)
digit = -1.5
a = 2.25
phase = True
nint = qt.get_nint([digit,a])
npres = qt.get_npres([digit,a])
n = nint + npres
if phase:
n+=1
binary_x = qt.my_binary_repr(digit, n, nint=nint, phase=phase)
binary_a = qt.my_binary_repr(a, n, nint=nint, phase=phase)
binary_x_ = qt.my_binary_repr(digit, n, nint=nint, phase=phase)
if binary_x[0]=='0':
binary_x_ = '1'+binary_x[1:]
elif binary_x[0]=='1':
binary_x_ = '0'+binary_x[1:]
binary_a_ = qt.my_binary_repr(a, n, nint=nint, phase=phase)
if binary_a[0]=='0':
binary_a_ = '1'+binary_a[1:]
elif binary_a[0]=='1':
binary_a_ = '0'+binary_a[1:]
int_x = qt.bin_to_dec(binary_x_, nint=None, phase=False)
int_a = qt.bin_to_dec(binary_a_, nint=None, phase=False)
qx = QuantumRegister(n, 'x')
qtarg = QuantumRegister(1, 'targ')
qans = QuantumRegister(n-1, 'anc')
out_reg = ClassicalRegister(1,'out_reg')
circ = QuantumCircuit(qx, qtarg, qans, out_reg)
x_gate = qt.input_bits_to_qubits(binary_x, circ, reg=qx, wrap=True)
circ.append(x_gate, qx);
circ.x(qx[-1]);
intcomp_gate = qt.integer_compare(circ, qx, qtarg, qans, int_a, geq=False, wrap=True)
circ.append(intcomp_gate, [*qx, *qtarg, *qans]);
circ.x(qx[-1]);
circ.measure(qtarg, out_reg);
shots=10
emulator = Aer.get_backend('qasm_simulator')
job = execute(circ, emulator, shots=shots )
hist = job.result().get_counts()
print('Target:')
print(digit,'<=',a,'=',digit<=a)
print('Result:')
for label in hist.keys():
print(digit,'<=',a,'=',bool(qt.bin_to_dec(label, nint=nint, phase=False)),'->',label,'with probability',float(hist[label])/shots)
digit = 3.5
a = 2.25
phase = True
nint = qt.get_nint([digit,a])
npres = qt.get_npres([digit,a])
n = nint + npres
if phase:
n+=1
binary_x = qt.my_binary_repr(digit, n, nint=nint, phase=phase)
qx = QuantumRegister(n, 'x')
qtarg = QuantumRegister(1, 'targ')
qans = QuantumRegister(n-1, 'anc')
out_reg = ClassicalRegister(1,'out_reg')
circ = QuantumCircuit(qx, qtarg, qans, out_reg)
x_gate = qt.input_bits_to_qubits(binary_x, circ, reg=qx, wrap=True)
circ.append(x_gate, qx);
comp_gate = qt.inequal_cond(circ, qx, qtarg, qans, a, nint=nint, phase=phase, geq=False, wrap=True)
circ.append(comp_gate, [*qx, *qtarg, *qans]);
circ.measure(qtarg, out_reg);
shots=10
emulator = Aer.get_backend('qasm_simulator')
job = execute(circ, emulator, shots=shots )
hist = job.result().get_counts()
print('Target:')
print(digit,'<=',a,'=',digit<=a)
print('Result:')
for label in hist.keys():
print(digit,'<=',a,'=',bool(qt.bin_to_dec(label, nint=nint, phase=False)),'->',label,'with probability',float(hist[label])/shots)
|
https://github.com/Fergus-Hayes/qiskit_tools
|
Fergus-Hayes
|
import qiskit_tools as qt
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
matplotlib.rcParams['mathtext.fontset'] = 'stix'
matplotlib.rcParams['font.family'] = 'STIXGeneral'
width=0.75
color='black'
fontsize=28
ticksize=22
figsize=(10,8)
def f_x(x):
return np.arctan(x)
phase = True
nx = 5
nintx = 3
npresx = nx - nintx
if phase:
npresx -= 1
xmin = -2.**(nintx)
xmax = 2.**(nintx) - 2.**(-npresx)
xs = np.linspace(xmin,xmax,2**nx)
print(xmin, xmax)
print(npresx,qt.get_npres(xs))
m = 3
bounds = np.linspace(xmin, xmax, (2**m))
norder = 1
coeffs = qt.get_bound_coeffs(f_x, bounds, norder, reterr=False).T
ys = qt.piecewise_poly(xs, coeffs.T, bounds)
fig = plt.figure(figsize=figsize)
ax = fig.gca()
for bound in bounds:
ax.axvline(bound, ls=':', color='black')
ax.plot(xs, f_x(xs), color='black');
ax.plot(xs, ys, color='black', ls='--', lw=3);
ax.set_xlabel(r'$x$', fontsize=fontsize);
ax.set_ylabel(r'$f(x)$', fontsize=fontsize);
ax.set_xlim(xmin,xmax);
ax.tick_params(axis='both', labelsize=ticksize);
# The number of integer bits of A1, A0 and the result
nint0 = qt.get_nint(coeffs[0])
nint1 = qt.get_nint(coeffs[1])
nint = nintx + nint0
# The number of precision bits of A1, A0 and the result
npres0 = qt.get_npres(coeffs[0])
npres1 = qt.get_npres(coeffs[1])
npres = npresx + npres0
# The total number of bits of A1, A0 and the result
n0 = npres0 + nint0 + 1
n1 = npres1 + nint1 + 1
n = npres + nint + 1
print('A0 bits:', n0)
print('A1 bits:', n1)
print('Result bits:', n)
nsig0, nsig1 = 5, 5
coeffs[0] = qt.round_sig(coeffs[0], nsig0)
coeffs[1] = qt.round_sig(coeffs[1], nsig1)
# The number of integer bits of A1, A0 and the result
nint0 = qt.get_nint(coeffs[0])
nint1 = qt.get_nint(coeffs[1])
nint = nintx + nint0
# The number of precision bits of A1, A0 and the result
npres0 = qt.get_npres(coeffs[0])
npres1 = qt.get_npres(coeffs[1])
npres = npresx + npres0
# The total number of bits of A1, A0 and the result
n0 = npres0 + nint0 + 1
n1 = npres1 + nint1 + 1
n = npres + nint + 1
print('A0 bits:', n0)
print('A1 bits:', n1)
print('Result bits:', n)
npres0, npres1 = 4, 4
n0 = npres0 + nint0 + 1
n1 = npres1 + nint1 + 1
rcoeffs = []
for coeff in coeffs[0]:
# Convert coefficient to binary string of new length n0, then calculate the corresponding decimal value
rcoeff = qt.bin_to_dec(qt.my_binary_repr(coeff, n0, nint=nint0, phase=phase), nint=nint0, phase=phase)
rcoeffs.append(rcoeff)
coeffs[0] = np.array(rcoeffs)
# Calculate the differences between the f(x) and A1x over all x
fdifs = f_x(xs) - qt.piecewise_poly(xs, np.array([coeffs[0],np.zeros(len(coeffs[1]))]).T, bounds)
coeffs_ = []
bounds__ = bounds
bounds__[-1] = np.inf
for i in np.arange(len(bounds__))[:-1]:
# Calculate the mean differences in each domain to be the new bias A0
coeffs_.append(np.mean(fdifs[np.greater_equal(xs,bounds__[i])&np.greater(bounds__[i+1],xs)]))
coeffs[1] = np.array(coeffs_)
nint1 = qt.get_nint(coeffs[1])
print(nint1)
rcoeffs = []
for coeff in coeffs[1]:
# Convert coefficient to binary string of new length n1, then calculate the corresponding decimal value
rcoeff = qt.bin_to_dec(qt.my_binary_repr(coeff, n1, nint=nint1, phase=phase), nint=nint1, phase=phase)
rcoeffs.append(rcoeff)
coeffs[1] = np.array(rcoeffs)
# The number of integer bits of A1, A0 and the result
nint0 = qt.get_nint(coeffs[0])
nint1 = qt.get_nint(coeffs[1])
nint = nintx + nint0
# The number of precision bits of the result
npres = npresx + npres0
# The total number of bits of A1, A0 and the result
n0 = npres0 + nint0 + 1
n1 = npres1 + nint1 + 1
n = npres + nint + 1
print('A0 bits:', n0)
print('A1 bits:', n1)
print('Result bits:', n)
ys_rnd = qt.piecewise_poly(xs, coeffs.T, bounds)
fig = plt.figure(figsize=figsize)
ax = fig.gca()
for bound in bounds:
ax.axvline(bound, ls=':', color='black')
ax.plot(xs, f_x(xs), color='black');
ax.plot(xs, ys, color='black', ls='--', lw=3);
ax.plot(xs, ys_rnd, color='black', ls=':', lw=3);
ax.set_xlabel(r'$x$', fontsize=fontsize);
ax.set_ylabel(r'$f(x)$', fontsize=fontsize);
ax.set_xlim(xmin,xmax);
ax.tick_params(axis='both', labelsize=ticksize);
A1x = qt.piecewise_poly(xs, np.array([coeffs[0],np.zeros(len(coeffs[1]))]).T, bounds)
nint = qt.get_nint([A1x, ys_rnd])
n = npres + nint + 1
print(nint, npres, n)
n, n0, nint, nintcs, coeffs, bounds = qt.optimize_coeffs_qubits(f_x, xs, m, npres0, npres1, norder=norder, phase=phase)
|
https://github.com/Fergus-Hayes/qiskit_tools
|
Fergus-Hayes
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ
import qiskit_tools as qt
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
matplotlib.rcParams['mathtext.fontset'] = 'stix'
matplotlib.rcParams['font.family'] = 'STIXGeneral'
width=0.75
color='black'
fontsize=28
ticksize=22
figsize=(10,8)
digit = 1.
bounds = np.array([-2., 0., 1.5, 3.])
print('Domain boundaries:',bounds)
m = int(np.ceil(np.log2(len(bounds))))
print('Label qubits:',m)
phase = True
nint = qt.get_nint([digit,*bounds])
npres = qt.get_npres([digit,*bounds])
n = nint + npres
if phase:
n+=1
binary_x = qt.my_binary_repr(digit, n, nint=nint, phase=phase)
qx = QuantumRegister(n, 'x')
qtarg = QuantumRegister(1, 'targ')
qans = QuantumRegister(n-1, 'a')
qlab = QuantumRegister(m, 'l')
out_reg = ClassicalRegister(m,'out')
circ = QuantumCircuit(qx, qtarg, qans, qlab, out_reg)
x_gate = qt.input_bits_to_qubits(binary_x, circ, reg=qx, wrap=True)
circ.append(x_gate, qx);
circ = qt.label_gate(circ, qx, qtarg, qans, qlab, bounds=bounds, nint=nint, phase=phase)
circ.measure(qlab, out_reg);
circ.draw('latex')
shots=10
emulator = Aer.get_backend('qasm_simulator')
job = execute(circ, emulator, shots=shots )
hist = job.result().get_counts()
print('Result:')
for label in hist.keys():
if qt.bin_to_dec(label, nint=None, phase=False)==0.:
print(digit,'is outwith the bounds of','['+str(bounds[0])+',',str(bounds[-1])+')','with probability',float(hist[label])/shots)
else:
print(bounds[int(qt.bin_to_dec(label, nint=None, phase=False))-1],'<=',digit,'<',bounds[int(qt.bin_to_dec(label, nint=None, phase=False))],'with probability',float(hist[label])/shots)
digit = 1.
bounds = np.array([-2., 0., 1.5, 3.])
print('Domain boundaries:',bounds)
m = int(np.ceil(np.log2(len(bounds))))
phase = True
nint = qt.get_nint([digit,*bounds])
npres = qt.get_npres([digit,*bounds])
n = nint + npres
if phase:
n+=1
binary_x = qt.my_binary_repr(digit, n, nint=nint, phase=phase)
print('Label qubits:',m)
A1s = np.array([3., -1., 2.5, -0.5])
nintc = qt.get_nint(A1s)
npresc = qt.get_npres(A1s)
nc = nintc + npresc
if phase:
nc+=1
n = np.max([n,nc])
qx = QuantumRegister(n, 'x')
qcoff = QuantumRegister(n, 'c')
qlab = QuantumRegister(m, 'l')
out_reg = ClassicalRegister(n,'out')
circ = QuantumCircuit(qx, qcoff, qlab, out_reg)
qtarg = qcoff[0]
qans = qcoff[1:]
x_gate = qt.input_bits_to_qubits(binary_x, circ, reg=qx, wrap=True)
circ.append(x_gate, qx);
l_gate = qt.label_gate(circ, qx, qtarg, qans, qlab, bounds=bounds, nint=nint, phase=phase, wrap=True)
circ.append(l_gate, [*qx, qtarg, *qans, *qlab]);
circ = qt.cin_gate(circ, qcoff, qlab, A1s, nint=nintc, phase=phase)
circ.measure(qcoff, out_reg);
circ.draw('latex')
shots=10
emulator = Aer.get_backend('qasm_simulator')
job = execute(circ, emulator, shots=shots )
hist = job.result().get_counts()
print('Target:')
ind = np.argwhere((np.array([bounds[-1],*bounds[:-1]])<=digit)*(bounds>digit)).flatten()[0]
print(A1s[ind],'as',bounds[ind-1],'<=',digit,'<',bounds[ind])
print('Result:')
for label in hist.keys():
print(qt.bin_to_dec(label, nint=nintc, phase=phase),'->',label,'with probability',float(hist[label])/shots)
qx = QuantumRegister(n, 'x')
qcoff = QuantumRegister(n, 'c')
qlab = QuantumRegister(m, 'l')
out_reg = ClassicalRegister(n,'out')
circ = QuantumCircuit(qx, qcoff, qlab, out_reg)
qtarg = qcoff[0]
qans = qcoff[1:]
x_gate = qt.input_bits_to_qubits(binary_x, circ, reg=qx, wrap=True)
circ.append(x_gate, qx);
l_gate = qt.label_gate(circ, qx, qtarg, qans, qlab, bounds=bounds, nint=nint, phase=phase, wrap=True)
circ.append(l_gate, [*qx, qtarg, *qans, *qlab]);
X_gate = qt.cin_gate(circ, qcoff, qlab, A1s, nint=nintc, phase=phase, wrap=True, label='X')
X_gate_inv = qt.cin_gate(circ, qcoff, qlab, A1s, nint=nintc, phase=phase, wrap=True, inverse=True, label='X')
circ.append(X_gate, [*qcoff, *qlab]);
circ.append(X_gate_inv, [*qcoff, *qlab]);
circ.measure(qcoff, out_reg);
circ.draw('latex')
shots=10
emulator = Aer.get_backend('qasm_simulator')
job = execute(circ, emulator, shots=shots )
hist = job.result().get_counts()
print('Result:')
for label in hist.keys():
print(qt.bin_to_dec(label, nint=nintc, phase=phase),'->',label,'with probability',float(hist[label])/shots)
def f_x(x):
return np.arctan(x)
phase = True
nintx = 3
nx = 5
npresx = nx - nintx
if phase:
npresx-=1
xmin = -2.**(nintx)
xmax = 2.**(nintx) - 2.**(-npresx)
xs = np.linspace(xmin,xmax,2**nx)
npres0, npres1 = 4, 4
norder = 1
m = 3
n, n0, nint, nintcs, coeffs, bounds = qt.optimize_coeffs_qubits(f_x, xs, m, npres0, npres1, norder=norder, phase=phase, label_swap=True)
print('Qubits:', nx, n, n0, m)
print('Integer qubits:', nintx, nint, nintcs[0,0], nintcs[0,1])
print('Memory:', 16*(2**(n+n0+nx+m))/2**20)
_, _, _, _, coeffs_, _ = qt.optimize_coeffs_qubits(f_x, xs, m, npres0, npres1, norder=norder, phase=phase, label_swap=False)
ys_rnd = qt.piecewise_poly(xs, coeffs_.T, bounds)
qx = QuantumRegister(nx, 'x')
qout = QuantumRegister(n, 'o')
qlab = QuantumRegister(m, 'l')
qcoff = QuantumRegister(n0, 'c')
circ = QuantumCircuit(qx, qout, qlab, qcoff)
# 1. Initialize the x register (let as produce a superposition across all x values)
for i in np.arange(nx):
circ.h(qx[i]);
# We can use the coefficient register as the ancillary register for the labelling step as before
qtarg = qcoff[0]
qans = [*qcoff[1:], *qout][:nx-1]
# 2. Label the data with the labelling operation
l_gate = qt.label_gate(circ, qx, qtarg, qans, qlab, bounds=bounds, nint=nintx, phase=phase, wrap=True)
circ.append(l_gate, [*qx, qtarg, *qans, *qlab]);
# 3. Load A1 into the coefficient register conditioned on the label register
X1_gate = qt.cin_gate(circ, qcoff, qlab, coeffs[0], nint=nintcs[0,0], phase=phase, wrap=True)
circ.append(X1_gate, [*qcoff, *qlab]);
# 4. Multiply the coefficient and x registers and save the output on the output register
mul_gate = qt.QFTMultPhase(circ, qcoff, qx, qout, wrap=True, nint1=nintcs[0,0], nint2=nintx, nint3=nint)
circ.append(mul_gate, [*qcoff, *qx, *qout]);
# 5. Unload A1 from the coefficient register with the inverse load operation
X1_gate_inv = qt.cin_gate(circ, qcoff, qlab, coeffs[0], nint=nintcs[0,0], phase=phase, wrap=True, inverse=True)
circ.append(X1_gate_inv, [*qcoff, *qlab]);
# 6. Load A0 into the coefficient register conditioned on the label register
X0_gate = qt.cin_gate(circ, qcoff, qlab, coeffs[1], nint=nintcs[0,1], phase=phase, wrap=True)
circ.append(X0_gate, [*qcoff, *qlab]);
# 7. Add the coefficient register to the output register
add_gate = qt.QFTAddition(circ, qcoff, qout, nint1=nintcs[0,1], nint2=nint, wrap=True, phase=phase)
circ.append(add_gate, [*qcoff, *qout]);
# Unload A0 to clear the coefficient register
X0_gate_inv = qt.cin_gate(circ, qcoff, qlab, coeffs[1], nint=nintcs[0,1], phase=phase, wrap=True, inverse=True)
circ.append(X0_gate_inv, [*qcoff, *qlab]);
# Unlabel the label register
l_gate_inv = qt.label_gate(circ, qx, qtarg, qans, qlab, bounds=bounds, nint=nintx, phase=phase, wrap=True, inverse=True)
circ.append(l_gate_inv, [*qx, qtarg, *qans, *qlab]);
backend = Aer.get_backend('statevector_simulator')
job = execute(circ, backend)
result = job.result()
state_vector = result.get_statevector()
state_v = np.asarray(state_vector).reshape((2**n0,2**m,2**n,2**nx)).T
state_v = np.sum(state_v, axis=(2,3))
y_unorm = np.argwhere(np.round(np.abs(state_v)**2,15)>0.)[:,1]
y_out = []
for y in y_unorm:
y_out.append(qt.bin_to_dec(qt.my_binary_repr(y, n=n, nint=None, phase=False), nint=nint, phase=phase))
xs_comp = []
xs_ = np.linspace(-2**(nx-1),2**(nx-1)-1,2**nx)
for x in xs_:
binary = qt.my_binary_repr(x, nx, nint=None, phase=True)
xs_comp.append(int(qt.bin_to_dec(binary, nint=None, phase=False)))
y_out = np.array(y_out)[xs_comp]
fig = plt.figure(figsize=figsize)
ax = fig.gca()
for bound in bounds:
ax.axvline(bound, ls=':', color='black')
ax.plot(xs, f_x(xs), color='black');
ax.scatter(xs, y_out, color='black', lw=2);
ax.plot(xs, ys_rnd, color='black', ls=':', lw=3);
ax.set_xlabel(r'$x$', fontsize=fontsize);
ax.set_ylabel(r'$f(x)$', fontsize=fontsize);
ax.set_xlim(xmin,xmax);
ax.tick_params(axis='both', labelsize=ticksize);
plt.show()
def f_x(x):
return np.arctan(x)
phase = True
phasex = True
nintx = 3
nx = 5
npresx = nx - nintx
xmin = 0.
if phasex:
npresx-=1
xmin = -2.**(nintx)
xmax = 2.**(nintx) - 2.**(-npresx)
xs = np.linspace(xmin,xmax,2**nx)
n, n0, nint, nintcs, coeffs, bounds = qt.optimize_coeffs_qubits(f_x, xs, m, npres0, npres1, norder=norder, phase=phase, label_swap=True)
print('Qubits:', nx, n, n0, m)
print('Integer qubits:', nintx, nint, nintcs[0,0], nintcs[0,1])
print('Memory:', 16*(2**(n+n0+nx+m))/2**20)
qx = QuantumRegister(nx, 'x')
qout = QuantumRegister(n, 'o')
qlab = QuantumRegister(m, 'l')
qcoff = QuantumRegister(n0, 'c')
circ = QuantumCircuit(qx, qout, qlab, qcoff)
for i in np.arange(nx):
circ.h(qx[i]);
lpf_gate = qt.lpf(circ, qx, qout, qlab, qcoff, coeffs, bounds, nintx=nintx, nintcs=nintcs, nint=nint, phase=phase, phasex=phasex, wrap=True)
circ.append(lpf_gate, [*qx, *qout, *qlab, *qcoff]);
backend = Aer.get_backend('statevector_simulator')
job = execute(circ, backend)
result = job.result()
state_vector = result.get_statevector()
state_v = np.asarray(state_vector).reshape((2**n0,2**m,2**n,2**nx)).T
state_v = np.sum(state_v, axis=(2,3))
y_unorm = np.argwhere(np.round(np.abs(state_v)**2,15)>0.)[:,1]
y_out = []
for y in y_unorm:
y_out.append(qt.bin_to_dec(qt.my_binary_repr(y, n=n, nint=None, phase=False), nint=nint, phase=phase))
xs_comp = []
xs_ = np.linspace(-2**(nx-1),2**(nx-1)-1,2**nx)
for x in xs_:
binary = qt.my_binary_repr(x, nx, nint=None, phase=True)
xs_comp.append(int(qt.bin_to_dec(binary, nint=None, phase=False)))
y_out = np.array(y_out)[xs_comp]
Ax = qt.piecewise_poly(xs, np.array([coeffs_[0],np.zeros(len(coeffs_[1]))]).T, bounds)
fig = plt.figure(figsize=figsize)
ax = fig.gca()
for bound in bounds:
ax.axvline(bound, ls=':', color='black')
ax.plot(xs, f_x(xs), color='black');
ax.scatter(xs, y_out, color='black', lw=2);
#ax.plot(xs, Ax, color='black', lw=2);
ax.set_xlabel(r'$x$', fontsize=fontsize);
ax.set_ylabel(r'$f(x)$', fontsize=fontsize);
ax.set_xlim(xmin,xmax);
ax.tick_params(axis='both', labelsize=ticksize);
plt.show()
|
https://github.com/Fergus-Hayes/qiskit_tools
|
Fergus-Hayes
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ
import qiskit_tools as qt
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
from qiskit.circuit.library.standard_gates import RYGate
matplotlib.rcParams['mathtext.fontset'] = 'stix'
matplotlib.rcParams['font.family'] = 'STIXGeneral'
width=0.75
color='black'
fontsize=28
ticksize=22
figsize=(10,8)
def targ_dist(x, bias=0):
y = (x+bias)**(-7./6)
return y/np.sqrt(np.sum(np.abs(y)**2))
nx = 6
nintx = 4
xmin = -2.**(nintx)
xmax = 2.**(nintx) - 2.**(-nx+nintx+1)
xs = np.linspace(xmin, xmax, 2**nx)
amps = targ_dist(xs, bias=2.**(nintx+1))
probs = np.abs(amps)**2
fig = plt.figure(figsize=figsize)
ax = fig.gca()
ax.plot(xs, probs, color='black')
ax.set_xlabel(r'$x$', fontsize=fontsize);
ax.set_ylabel(r'$\sqrt{p(x)}$', fontsize=fontsize);
ax.set_xlim(xmin,xmax);
ax.tick_params(axis='both', labelsize=ticksize);
def GR_func(j, probs, m, n):
j = np.array(j).astype(int)
As = []
for i in np.arange(2**m):
As.append(np.sum(probs[i*2**(n-m):(i+1)*2**(n-m)]))
As1 = []
for i in np.arange(2**(m+1)):
As1.append(np.sum(probs[i*2**(n-(m+1)):(i+1)*2**(n-(m+1))]))
return np.arccos(np.sqrt(np.array(As1)[::2][j]/np.array(As)[j]))
qx = QuantumRegister(nx, 'x')
circ = QuantumCircuit(qx)
coeffs = np.arccos(np.sqrt(np.sum(probs[:2**(nx-1)])))
circ.ry(2*coeffs, qx[nx-1]);
for m in np.arange(1,nx):
js = np.arange(2**m)
coeffs = GR_func(js, probs, m, nx)
for j in np.arange(2**m):
control_bits = qt.my_binary_repr(j, m, nint=None, phase=False)
if j>0:
control_bits_ = qt.my_binary_repr(j-1, m, nint=None, phase=False)[::-1]
else:
control_bits_ = np.ones(m).astype(int).astype(str)
for i,control_bit in enumerate(control_bits[::-1]):
if control_bit=='0' and control_bits_[i]=='1':
circ.x(qx[nx-i-1]);
R_gate = RYGate(2*coeffs[j]).control(int(m))
circ.append(R_gate, [*qx[nx-m-1:][::-1]]);
if j<2**m-1:
control_bits_ = qt.my_binary_repr(j+1, m, nint=None, phase=False)[::-1]
else:
control_bits_ = np.ones(m).astype(int).astype(str)
for i,control_bit in enumerate(control_bits[::-1]):
if control_bit=='0' and control_bits_[i]=='1':
circ.x(qx[nx-i-1]);
backend = Aer.get_backend('statevector_simulator')
job = execute(circ, backend)
result = job.result()
state_vector = np.asarray(result.get_statevector())
if np.any(state_vector.imag>0.):
state_v = np.copy(state_vector)
else:
state_v = state_vector.real
fig = plt.figure(figsize=figsize)
ax = fig.gca()
ax.scatter(xs, np.abs(state_v)**2, color='black')
ax.plot(xs, probs, color='black')
ax.set_xlabel(r'$x$', fontsize=fontsize);
ax.set_ylabel(r'$\sqrt{p(x)}$', fontsize=fontsize);
ax.set_xlim(xmin,xmax);
ax.tick_params(axis='both', labelsize=ticksize);
circ.draw('latex')
# Register size for storing the zeta angles
nanc = 8
# Register size for storing the linear coefficients for the piecewise function
ncoff = 8
# Register size for the label register
nlab = 4
print('Qubits:', nx, nanc, ncoff, nlab,'total:',nanc+ncoff+nx+nlab)
print('Memory:', 16*(2**(nanc+ncoff+nx+nlab))/2**20)
qx = QuantumRegister(nx, 'x')
qanc = QuantumRegister(nanc, 'anc')
qlab = QuantumRegister(nlab, 'l')
qcoff = QuantumRegister(ncoff, 'c')
circ = QuantumCircuit(qx, qanc, qlab, qcoff)
mlow = 4
probs_ = []
for i in np.arange(2**mlow):
probs_.append(np.sum(probs[i*2**(nx-mlow):(i+1)*2**(nx-mlow)]))
probs_ = np.array(probs_)
GRl_gate = qt.Grover_Rudolph_load(circ, qx[nx-mlow:], probs_, wrap=True)
circ.append(GRl_gate, qx[nx-mlow:]);
for m in np.arange(mlow,nx):
js = np.arange(2**m)
coeffs = GR_func(js, probs, m, nx)
f_x = lambda x: GR_func(x, probs, m, nx)
bounds_ = np.linspace(0,2**m,(2**nlab)+1).astype(int)
coeffs = qt.get_bound_coeffs(f_x, bounds_, 1, reterr=False).T#[::-1]
bounds = bounds_[1:]
max_list0 = np.array([coeffs[0], coeffs[1], coeffs[0]*2**nx, (coeffs[0]*2**nx)+coeffs[-1]])
max_list1 = max_list0
nintcs = []
nintcs.append(int(np.ceil(np.log2(np.max(np.abs(max_list0))))))
nintcs.append(int(np.ceil(np.log2(np.max(np.abs(max_list1))))))
nint = nintcs[-1]
nintcs = np.array([nintcs])
func_gate = qt.linear_piecewise_approx(circ, qx[nx-m:], qanc, qlab, qcoff, coeffs, bounds, nint=nint, nintx=nx, nintcs=nintcs, phase=False, wrap=True)
circ.append(func_gate, [*qx[nx-m:], *qanc, *qlab, *qcoff]);
rot_gate = qt.CRotation(circ, qanc, qx[nx-m-1], nint=nint, wrap=True)
circ.append(rot_gate, [*qanc, qx[nx-m-1]])
func_gate_inv = qt.linear_piecewise_approx(circ, qx[nx-m:], qanc, qlab, qcoff, coeffs, bounds, nint=nint, nintx=nx, nintcs=nintcs, phase=False, wrap=True, inverse=True)
circ.append(func_gate_inv, [*qx[nx-m:], *qanc, *qlab, *qcoff]);
circ.draw('latex')
backend = Aer.get_backend('statevector_simulator')
job = execute(circ, backend)
result = job.result()
state_vector = np.asarray(result.get_statevector())
if np.any(state_vector.imag>0.):
state_v = np.copy(state_vector)
else:
state_v = state_vector.real
state_v = np.asarray(state_vector).reshape((2**ncoff,2**nlab,2**nanc,2**nx)).T
state_v = np.sum(state_v, axis=(1,2,3))
fig = plt.figure(figsize=figsize)
ax = fig.gca()
ax.scatter(xs, np.abs(state_v)**2, color='black')
ax.plot(xs, probs, color='black')
ax.set_xlabel(r'$x$', fontsize=fontsize);
ax.set_ylabel(r'$\sqrt{p(x)}$', fontsize=fontsize);
ax.set_xlim(xmin,xmax);
ax.tick_params(axis='both', labelsize=ticksize);
|
https://github.com/Fergus-Hayes/qiskit_tools
|
Fergus-Hayes
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ
from qiskit.circuit.library import PhaseGate
from qiskit.extensions import HamiltonianGate
from qiskit.quantum_info import random_hermitian
import qiskit_tools as qt
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
matplotlib.rcParams['mathtext.fontset'] = 'stix'
matplotlib.rcParams['font.family'] = 'STIXGeneral'
width=0.75
color='black'
fontsize=28
ticksize=22
figsize=(10,8)
nx = 1
A = random_hermitian(2**nx).to_matrix()
print(A)
p_suc = 0.95
phase = True
n = nx + int(np.ceil(np.log2(2. + 1./(2.*(1-p_suc)))))
print('The number of output qubits is set to',n)
lambda_min = np.real(np.min(np.linalg.eigvals(A)))
lambda_max = np.real(np.max(np.linalg.eigvals(A)))
kappa = np.abs(lambda_max/lambda_min)
print('Minimum eigenvalue, maximum eigenvalue and conditional number of A:', lambda_min, lambda_max, kappa)
# Calculate the new scale of the relative magnitudes of maximum and minimum eigenvalues
rescale = int((2**(n-phase)-1)/kappa)
# Make sure this scaling is not vanishingly small
if rescale < 1.e-7:
rescale = 1
# determine the number of integer qubits required
nint = qt.get_nint(rescale)
# Assert that the number of integer qubits is equal to or greater than the number of ancillary qubits assigned
if nint < n - phase:
nint = n - phase
t0 = qt.bin_to_dec(qt.my_binary_repr(rescale, nint=nint, n=nint, phase=False), nint=0, phase=False) / (lambda_min * (2**phase))
t = 2 * np.pi * t0
qreg = QuantumRegister(nx, 'x')
qout = QuantumRegister(n, 'out')
circ = QuantumCircuit(qreg, qout)
A_gate = HamiltonianGate(A, t)
circ.h(qreg[0]);
circ = qt.PhaseEst(circ, qreg, qout, A_gate)
circ.draw('latex')
backend = Aer.get_backend('statevector_simulator')
job = execute(circ, backend)
result = job.result()
state_vector = np.asarray(result.get_statevector())
state_v = np.asarray(state_vector).reshape((2**n,2**nx)).T
state_v = np.sum(state_v, axis=0)
state_v = state_v/np.sqrt(np.sum(np.abs(state_v)**2))
xs = np.fft.fftfreq(2**n,2.**(-n))/(t0*2**(n))
fig = plt.figure(figsize=np.array(figsize)*[1,2])
ax = fig.add_subplot(211)
plt.scatter(xs, state_v.real, marker='.', color='black')
plt.scatter(xs, state_v.imag, marker='.', color='grey')
ax.set_ylabel('Amplitude', fontsize=fontsize);
ax.tick_params(axis='both', labelsize=ticksize);
ax.axvline(lambda_min, ls='--', color='black')
ax.axvline(lambda_max, ls=':', color='black')
ax = fig.add_subplot(212)
plt.scatter(xs, np.abs(state_v)**2, marker='.', color='black')
ax.set_xlabel(r'$\theta$', fontsize=fontsize);
ax.set_ylabel('Probability', fontsize=fontsize);
ax.tick_params(axis='both', labelsize=ticksize);
ax.axvline(lambda_min, ls='--', color='black')
ax.axvline(lambda_max, ls=':', color='black')
plt.show()
|
https://github.com/Fergus-Hayes/qiskit_tools
|
Fergus-Hayes
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ
from qiskit.circuit.library import ExactReciprocal
from qiskit.extensions import HamiltonianGate
from qiskit.quantum_info import random_hermitian
import qiskit_tools as qt
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
matplotlib.rcParams['mathtext.fontset'] = 'stix'
matplotlib.rcParams['font.family'] = 'STIXGeneral'
width=0.75
color='black'
fontsize=28
ticksize=22
figsize=(10,8)
def HHL(circ, qb, qanc, qtarg, A, t=2.*np.pi, scaling=None, wrap=False, inverse=False, phase=True, label='HHL'):
n = len(qb)
nanc = len(qanc)
if inverse:
wrap = True
if wrap:
qb = QuantumRegister(n, 'b')
qanc = QuantumRegister(nanc, 'anc')
qtarg = QuantumRegister(1, 'targ')
circ = QuantumCircuit(qb, qanc, qtarg)
# Define unitary operator given matrix A and evolution time t
A_gate = HamiltonianGate(A, t)
# Apply phase estimation
qe_gate = qt.PhaseEst(circ, qb, qanc, A_gate, wrap=True, do_swaps=False, reverse_bits=True)
circ.append(qe_gate, [*qb, *qanc]);
# Apply ExactReciprocal to rotate the target qubit proportionally to the given scaling and the inverse of the
# values stored in the computational basis of the ancillary register
rec_gate = ExactReciprocal(nanc, scaling=scaling, neg_vals=phase).to_gate()
circ.append(rec_gate, [*qanc[::-1], qtarg]);
# Apply the inverse phase estimation
qe_gate_inv = qt.PhaseEst(circ, qb, qanc, A_gate, wrap=True, inverse=True, do_swaps=False, reverse_bits=True)
circ.append(qe_gate_inv, [*qb, *qanc]);
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
n = 2
A = random_hermitian(2**n).to_matrix()
print(A)
lambda_min = np.min(np.abs(np.linalg.eigvals(A)))
lambda_max = np.max(np.abs(np.linalg.eigvals(A)))
kappa = np.abs(lambda_max/lambda_min)
print('Minimum eigenvalue, maximum eigenvalue and conditional number of A:', lambda_min, lambda_max, kappa)
phase = True
# Choose a success probability of determining eigenvalue estimation
p_suc = 0.99
# Determine the number of ancillary qubits to ensure the given success probability
nanc = n + int(np.ceil(np.log2(2. + 1./(2.*(1-p_suc)))))
# Calculate the new scale of the relative magnitudes of maximum and minimum eigenvalues
rescale = int((2**(nanc-phase)-1)/kappa)
# Make sure this scaling is not vanishingly small
if rescale < 1.e-7:
rescale = 1
# determine the number of integer qubits required
nint = qt.get_nint(rescale)
# Assert that the number of integer qubits is equal to or greater than the number of ancillary qubits assigned
if nint < nanc - phase:
nint = nanc - phase
# We can determine the scaling of the rotation of step 3 (variable c)
scaling = qt.bin_to_dec(qt.my_binary_repr(rescale, nint=nint, n=nint, phase=False), nint=0, phase=False)
t0 = scaling / (lambda_min * (2**phase))
t = 2 * np.pi * t0
qb = QuantumRegister(n, 'b')
circ = QuantumCircuit(qb)
circ.h(qb);
backend = Aer.get_backend('statevector_simulator')
job = execute(circ, backend)
result = job.result()
in_vector = np.asarray(result.get_statevector())
print('The state amplitudes of b are:',in_vector)
targ = np.matmul(np.linalg.inv(A),in_vector)
print('The target state amplitudes of x are:',targ)
qanc = QuantumRegister(nanc, 'anc')
qtarg = QuantumRegister(1, 'targ')
circ.add_register(qanc, qtarg)
circ = HHL(circ, qb, qanc, qtarg, A, t=t, scaling=scaling)
circ.draw('latex')
backend = Aer.get_backend('statevector_simulator')
job = execute(circ, backend)
result = job.result()
state_vector = np.asarray(result.get_statevector())
state_v = np.asarray(state_vector).reshape((2**1,2**nanc,2**n))
# 1, nanc, n
print(state_v.shape)
norm_ = np.sqrt(np.sum(np.abs(state_v[1])**2))
print('The target qubit is in the 1 state with probability:',norm_)
state_v = state_v[1,0]
print(state_v)
state_v = np.array(state_v/np.sqrt(np.sum(np.abs(state_v)**2)))
norm = norm_/lambda_min
out = state_v*norm
print('The amplitudes of the resulting states are:', out)
print('Ratio of real part of output to target:',out.real/targ.real)
print('Ratio of imaginary part of output to target:',out.imag/targ.imag)
|
https://github.com/Fergus-Hayes/qiskit_tools
|
Fergus-Hayes
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ
from qiskit.circuit.library import StatePreparation, RYGate
from qiskit.quantum_info import Statevector
import qiskit_tools as qt
import numpy as np
import matplotlib.pyplot as plt
import matplotlib
from tqdm import tqdm
from datetime import datetime
# Shake things up by changing the random seed
rseed = int(datetime.now().timestamp())
np.random.seed(rseed)
from sklearn.gaussian_process.kernels import RBF
from sklearn.gaussian_process import GaussianProcessRegressor
matplotlib.rcParams['mathtext.fontset'] = 'stix'
matplotlib.rcParams['font.family'] = 'STIXGeneral'
width=0.75
color='black'
fontsize=28
ticksize=22
figsize=(10,8)
N = 4
n = int(np.ceil(np.log2(N)))
xmin, xmax = 0, 8
X_train = np.linspace(start=xmin, stop=xmax, num=2**n).reshape(-1, 1)
def y_targ(x):
return np.squeeze(x*np.sin(x))
noise_std = 0.75
y_train = y_targ(X_train) + np.random.normal(0,noise_std,N)
Nast = 16
X = np.linspace(start=xmin, stop=xmax, num=Nast).reshape(-1, 1)
y = y_targ(X)
def SEK(X1, X2, ls=1.0, sig=1.0):
sqdist = np.sum(X1**2, 1).reshape(-1, 1) + np.sum(X2**2, 1) - 2 * np.dot(X1, X2.T)
return sig * np.exp(-0.5 * sqdist / ls**2)
sigma = 2*noise_std
ls = 2.**(-(xmax-xmin)/Nast)
def posterior(X_s, X_train, Y_train, l=1.0, sigma_f=1.0, sigma_y=1e-8):
K = SEK(X_train, X_train, l, sigma_f) + sigma_y**2 * np.eye(len(X_train))
K_s = SEK(X_train, X_s, l, sigma_f)
K_ss = SEK(X_s, X_s, l, sigma_f)
K_inv = np.linalg.inv(K)
mu_s = K_s.T.dot(K_inv).dot(Y_train)
cov_s = K_ss - K_s.T.dot(K_inv).dot(K_s)
return mu_s, cov_s
mean_prediction, cov_s = posterior(X, X_train, y_train, l=ls, sigma_f=sigma, sigma_y=noise_std)
std_prediction = np.diag(cov_s)
fig = plt.figure(figsize=figsize)
ax = fig.add_subplot(111)
ax.plot(X, y, label=r"$f(x) = x \sin(x)$", linestyle="dotted")
ax.errorbar(
X_train,
y_train,
noise_std,
linestyle="None",
color="tab:blue",
marker=".",
markersize=10,
label="Observations",
)
ax.plot(X, mean_prediction, label="Mean prediction", marker='.')
ax.fill_between(
X.ravel(),
mean_prediction - 1.96 * std_prediction,
mean_prediction + 1.96 * std_prediction,
color="tab:orange",
alpha=0.5,
label=r"95% confidence interval",
)
ax.legend()
ax.set_xlabel("$x$")
ax.set_ylabel("$f(x)$")
plt.show()
# Pick the middle x* to evaluate
u_ind = (len(X)//2) - 1
# Define v and u
v = y_train
u = SEK(X, X_train, ls, sig=sigma)[u_ind]
# Determine normalisation of v and u
v_norm = np.sqrt(np.sum(np.abs(v)**2))
u_norm = np.sqrt(np.sum(np.abs(u)**2))
# Normalised vectors v and u
v_ = v/v_norm
u_ = u/u_norm
# Determine A
A = SEK(X_train, X_train, ls, sig=sigma) + (np.eye(len(X_train))*noise_std**2)
kappa = np.linalg.cond(A)
lambda_min = np.min(np.abs(np.linalg.eigvals(A)))
lambda_max = np.max(np.abs(np.linalg.eigvals(A)))
# Choose a success probability of determining eigenvalue estimation
p_suc = 0.99
# Determine the number of ancillary qubits to ensure the given success probability
nanc = n + int(np.ceil(np.log2(2. + 1./(2.*(1-p_suc)))))
phase = True
# Calculate the new scale of the relative magnitudes of maximum and minimum eigenvalues
rescale = int((2**(nanc-phase)-1)/kappa)
# Make sure this scaling is not vanishingly small
if rescale < 1.e-7:
rescale = 1
# determine the number of integer qubits required
nint = qt.get_nint(rescale)
# Assert that the number of integer qubits is equal to or greater than the number of ancillary qubits assigned
if nint < nanc - phase:
nint = nanc - phase
# We can determine the scaling of the rotation of step 3 (variable c)
scaling = qt.bin_to_dec(qt.my_binary_repr(rescale, nint=nint, n=nint, phase=False), nint=0, phase=False)
t0 = scaling / (lambda_min * (2**phase))
t = 2 * np.pi * t0
qcont = QuantumRegister(1, 'cont')
qtarg = QuantumRegister(1, 'targ')
qreg = QuantumRegister(n, 'x')
qanc = QuantumRegister(nanc, 'anc')
circ = QuantumCircuit(qanc, qtarg, qreg, qcont)
circ.h(qcont);
circ.barrier();
prepv_gate = StatePreparation(Statevector(v_)).control(1)
circ.append(prepv_gate, [qcont, *qreg]);
circ.barrier();
circ.x(qcont);
circ.cx(qcont, qtarg);
circ.barrier();
prepu_gate = StatePreparation(Statevector(u_)).control(1)
circ.append(prepu_gate, [qcont, *qreg]);
circ.x(qcont);
circ.barrier();
hhl_gate = qt.HHL(circ, qreg, qanc, qtarg, A, t=t, scaling=scaling, wrap=True).control(1)
circ.append(hhl_gate, [qcont, *qreg, *qanc, qtarg]);
circ.draw('latex')
backend = Aer.get_backend('statevector_simulator')
job = execute(circ, backend)
result = job.result()
state_vector = np.asarray(result.get_statevector())
state_v = np.asarray(state_vector).reshape((2**1, 2**n, 2**1, 2**nanc)).T
state_v = state_v[0,1,:,1]
targ_v = np.matmul(np.linalg.inv(A),v_)*np.sqrt(2.)
fig = plt.figure(figsize=figsize)
ax = fig.add_subplot(111)
plt.scatter(np.arange(2**n), targ_v, marker='o', color='red')
plt.scatter(np.arange(2**n), state_v.real, marker='.', color='black')
ax.set_ylabel('Amplitude', fontsize=fontsize);
ax.tick_params(axis='both', labelsize=ticksize);
state_u = np.asarray(state_vector).reshape((2**1, 2**n, 2**1, 2**nanc)).T
state_u = state_u[0,1,:,0]
targ_u = u_/np.sqrt(2.)
fig = plt.figure(figsize=np.array(figsize))
ax = fig.add_subplot(111)
plt.scatter(np.arange(2**n), targ_u, marker='o', color='red')
plt.scatter(np.arange(2**n), state_u.real, marker='.', color='black')
ax.set_ylabel('Amplitude', fontsize=fontsize);
ax.tick_params(axis='both', labelsize=ticksize);
state_v = np.asarray(state_vector).reshape((2**1, 2**n, 2**1, 2**nanc)).T
state_v = state_v[0,1].T
X_matrix = np.array([[0,1],[1,0]])
mu_out = np.matmul(state_v.flatten(),np.matmul(X_matrix, state_v.real).flatten()).real*(u_norm*v_norm*scaling/np.sqrt(2.))
print(mu_out, mean_prediction[u_ind])
mus = []
stds = []
for i in tqdm(np.arange(Nast)):
v = y_train
u = SEK(X, X_train, ls, sig=sigma)[i]
v_norm = np.sqrt(np.sum(np.abs(v)**2))
u_norm = np.sqrt(np.sum(np.abs(u)**2))
v_ = v/v_norm
u_ = u/u_norm
v_gate = StatePreparation(Statevector(v_))
u_gate = StatePreparation(Statevector(u_))
qcont = QuantumRegister(1, 'cont')
qtarg = QuantumRegister(1, 'targ')
qreg = QuantumRegister(n, 'reg')
qanc = QuantumRegister(nanc, 'anc')
circ = QuantumCircuit(qanc, qtarg, qreg, qcont)
QGPR_gate = qt.QGPR(circ, qreg, qanc, qtarg, qcont, v_gate, u_gate, A, t, scaling, wrap=True)
circ.append(QGPR_gate, [*qreg, *qanc, qtarg, qcont]);
backend = Aer.get_backend('statevector_simulator')
job = execute(circ, backend)
result = job.result()
state_vector = np.asarray(result.get_statevector())
state_v = np.asarray(state_vector).reshape((2**1, 2**n, 2**1, 2**nanc)).T[0,1].T
mus.append(np.matmul(state_v.flatten(),np.matmul(X_matrix, state_v.real).flatten()).real*(u_norm*v_norm*scaling/np.sqrt(2)))
qcont = QuantumRegister(1, 'cont')
qtarg = QuantumRegister(1, 'targ')
qreg = QuantumRegister(n, 'reg')
qanc = QuantumRegister(nanc, 'anc')
circ = QuantumCircuit(qanc, qtarg, qreg, qcont)
QGPR_gate = qt.QGPR(circ, qreg, qanc, qtarg, qcont, u_gate, u_gate, A, t, scaling, wrap=True)
circ.append(QGPR_gate, [*qreg, *qanc, qtarg, qcont]);
backend = Aer.get_backend('statevector_simulator')
job = execute(circ, backend)
result = job.result()
state_vector = np.asarray(result.get_statevector())
state_v = np.asarray(state_vector).reshape((2**1, 2**n, 2**1, 2**nanc)).T[0,1].T
M_exp = np.matmul(state_v.flatten(),np.matmul(X_matrix, state_v.real).flatten()).real*((u_norm**2)*scaling/np.sqrt(2))
stds.append(SEK(X, X, ls, sig=sigma)[i,i]-M_exp)
mus = np.array(mus)
stds = np.array(stds)
fig = plt.figure(figsize=figsize)
ax = fig.add_subplot(111)
ax.plot(X, y, label=r"$f(x) = x \sin(x)$", linestyle="dotted")
ax.errorbar(
X_train,
y_train,
noise_std,
linestyle="None",
color="tab:blue",
marker=".",
markersize=10,
label="Observations",
)
ax.plot(X, mean_prediction, marker='.', label="Classical mean prediction")
ax.fill_between(
X.ravel(),
mean_prediction - 1.96 * std_prediction,
mean_prediction + 1.96 * std_prediction,
color="tab:orange",
alpha=0.5,
label=r"95% confidence interval",
)
ax.plot(X, mus, color='violet', marker='.', label="Quantum mean prediction")
ax.fill_between(
X.ravel(),
mus - 1.96 * stds,
mus + 1.96 * stds,
color="tab:purple",
alpha=0.5,
label=r"95% confidence interval",
)
ax.legend()
ax.set_xlabel("$x$")
ax.set_ylabel("$f(x)$")
plt.show()
|
https://github.com/Fergus-Hayes/qiskit_tools
|
Fergus-Hayes
|
from qiskit.utils import algorithm_globals
from qiskit import QuantumCircuit, Aer, execute
from qiskit.circuit.library import RealAmplitudes
from qiskit.primitives import Sampler
from qiskit_machine_learning.connectors import TorchConnector
from qiskit_machine_learning.neural_networks import SamplerQNN
from torch import nn
from torch.optim import Adam
import torch, time, argparse, sys
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
from datetime import datetime
from tqdm import tqdm
matplotlib.rcParams['mathtext.fontset'] = 'stix'
matplotlib.rcParams['font.family'] = 'STIXGeneral'
width=0.75
color='black'
fontsize=28
ticksize=22
figsize=(10,10)
# For this example, I have chosen a power-law with power -7/3
def targ_prob(xs):
px = xs**(-7./3)
return px/np.sum(px)
# Set the number of qubits
n = 4
# Number of dimensions (currently hard coded to 1 but can be expanded)
num_dim = 1
# Number of evaluation points
num_discrete_values = 2**n
# Range of x and the intervals between points
xmin, xmax = 40., 168.
dx = (xmax-xmin)/num_discrete_values
# Full set of x values
xs = np.arange(xmin, xmax, dx)
# Evaluate the target distribution over this range
prob_data = targ_prob(xs)
coords = np.linspace(-2, 2, num_discrete_values)
grid_elements = np.expand_dims(coords,axis=1)
# Set the number of samples S we wish to take from the PQC and target distribution
shots=10000
# Set the random seed used in the simulation (the outcome is highly sensitive to this)
rseed = 1696004649
# Uncomment line below to change the random seed for the training
#rseed = int(datetime.now().timestamp())
algorithm_globals.random_seed = rseed
_ = torch.manual_seed(rseed)
# Define the sampler object
sampler = Sampler(options={"shots": shots, "seed": algorithm_globals.random_seed})
qc = QuantumCircuit(n)
# Begin by initiallising the qubits in an equal superposition
qc.h(qc.qubits);
# Set the number of layers L
reps = 12
ansatz = RealAmplitudes(n, reps=reps)
qc.compose(ansatz, inplace=True)
def create_generator() -> TorchConnector:
qnn = SamplerQNN(
circuit=qc,
sampler=sampler,
input_params=[],
weight_params=qc.parameters,
sparse=False,
)
initial_weights = algorithm_globals.random.random(qc.num_parameters)
return TorchConnector(qnn, initial_weights)
class Discriminator(nn.Module):
def __init__(self, input_size):
super(Discriminator, self).__init__()
self.linear_input = nn.Linear(input_size, 20)
self.leaky_relu = nn.LeakyReLU(0.2)
self.linear20 = nn.Linear(20, 1)
self.sigmoid = nn.Sigmoid()
def forward(self, input: torch.Tensor) -> torch.Tensor:
x = self.linear_input(input)
x = self.leaky_relu(x)
x = self.linear20(x)
x = self.sigmoid(x)
return x
generator = create_generator()
discriminator = Discriminator(num_dim)
def adversarial_loss(input, target, w):
bce_loss = target * torch.log(input) + (1 - target) * torch.log(1 - input)
weighted_loss = w * bce_loss
total_loss = -torch.sum(weighted_loss)
return total_loss
lr=0.01
b1=0.7
b2=0.999
generator_optimizer = Adam(generator.parameters(), lr=lr, betas=(b1, b2), weight_decay=0.005)
discriminator_optimizer = Adam(discriminator.parameters(), lr=lr, betas=(b1, b2), weight_decay=0.005)
generator_loss_values = []
discriminator_loss_values = []
entropy_values = []
# Set the number of epochs
n_epochs=1000
num_qnn_outputs = num_discrete_values**num_dim
# Resume training if already performed some iterations
n_epochs = n_epochs-len(entropy_values)
start = time.time()
for epoch in tqdm(range(n_epochs)):
# Define torch target objects
valid = torch.ones(num_qnn_outputs, 1, dtype=torch.float)
fake = torch.zeros(num_qnn_outputs, 1, dtype=torch.float)
# Define torch tensor representing the target probability distribution
real_dist = torch.tensor(prob_data, dtype=torch.float).reshape(-1, 1)
# Define torch tensor representing the grid over which samples are taken
samples = torch.tensor(grid_elements, dtype=torch.float)
disc_value = discriminator(samples)
# Generate data
gen_dist = generator(torch.tensor([])).reshape(-1, 1)
# Train generator
generator_optimizer.zero_grad()
generator_loss = adversarial_loss(disc_value, valid, gen_dist)
# store for plotting
generator_loss_values.append(generator_loss.detach().item())
generator_loss.backward(retain_graph=True)
generator_optimizer.step()
# Train Discriminator
discriminator_optimizer.zero_grad()
real_loss = adversarial_loss(disc_value, valid, real_dist)
fake_loss = adversarial_loss(disc_value, fake, gen_dist.detach())
discriminator_loss = (real_loss + fake_loss) / 2
# Store for plotting
discriminator_loss_values.append(discriminator_loss.detach().item())
discriminator_loss.backward()
discriminator_optimizer.step()
# Retreive trained parameters
with torch.no_grad():
generated_weights = generator.weight.detach().numpy().reshape((reps+1,n))
# Build circuit to execute given trained parameters
circ = QuantumCircuit(n)
circ.h(circ.qubits)
# Implement parameterised quantum circuit equvalent to RealAmplitude
for rep in np.arange(reps+1):
for i in np.arange(n):
circ.ry(generated_weights[rep,i],circ.qubits[i])
for i in np.arange(n):
if i!=n-1 and rep!=reps:
circ.cx(circ.qubits[i], circ.qubits[i+1])
# Produce resulting state vector
backend = Aer.get_backend('statevector_simulator')
job = execute(circ, backend)
result = job.result()
state_vector = np.asarray(result.get_statevector())
# Calculate value equivalent to mismatch from fidelity
entropy_value = 1-np.sqrt(np.abs(np.dot(np.sqrt(prob_data),np.conjugate(state_vector)))**2)
entropy_values.append(entropy_value)
print(np.round(100.*(epoch/n_epochs),2),'%','Mismatch:',"{:.2e}".format(entropy_value),'Generator loss:', np.round(generator_loss_values[-1],2), 'Discriminator loss:', np.round(discriminator_loss_values[-1],2))
elapsed = time.time() - start
print(f"Fit in {elapsed:0.2f} sec")
fig = plt.figure(figsize=np.array(figsize)*[1,2])
ax = fig.add_subplot(211)
plt.plot(generator_loss_values, lw=2, color='black')
plt.plot(discriminator_loss_values, lw=2, color='grey')
ax.set_ylabel('Loss function', fontsize=fontsize);
ax.tick_params(axis='both', labelsize=ticksize);
ax = fig.add_subplot(212)
plt.plot(np.log10(entropy_values), lw=2, color='black')
ax.set_ylabel(r'log$_{10}(1-\sqrt{\mathcal{F}})$', fontsize=fontsize);
ax.set_xlabel('Iterations', fontsize=fontsize);
ax.tick_params(axis='both', labelsize=ticksize);
with torch.no_grad():
generated_weights = generator.weight.detach().numpy().reshape((reps+1,n))
circ = QuantumCircuit(n)
circ.h(circ.qubits)
for rep in np.arange(reps+1):
for i in np.arange(n):
circ.ry(generated_weights[rep,i],circ.qubits[i])
for i in np.arange(n):
if i!=n-1 and rep!=reps:
circ.cx(circ.qubits[i], circ.qubits[i+1])
backend = Aer.get_backend('statevector_simulator')
job = execute(circ, backend)
result = job.result()
state_vector = np.asarray(result.get_statevector())
fidelity = np.abs(np.dot(np.sqrt(prob_data),np.conjugate(state_vector)))**2
mismatch = 1. - np.sqrt(fidelity)
print('Fidelity:', fidelity, 'Mismatch:', mismatch)
target_state = np.sqrt(targ_prob(xs))
fig, ax = plt.subplots(2, 1, figsize=figsize, gridspec_kw={'height_ratios': [1.5, 1]})
color1 = 'black'
color2 = 'grey'
ax[0].scatter(xs, state_vector.real, color=color1, lw=2)
ax[0].plot(xs, state_vector.real, color=color1, ls='-', lw=1)
ax[0].plot(xs, target_state, color=color1, ls='--', lw=2)
ax[0].tick_params(axis='both', labelsize=ticksize)
ax[1].set_xlabel(r'$x$', fontsize=fontsize)
ax[0].set_ylabel(r'Amplitude', fontsize=fontsize)
ax[0].set_xlim(xmin-1,xmax+1)
ax[0].set_xticks([])
ax[1].scatter(xs, state_vector.real-target_state.real, color=color1, lw=2)
ax[1].set_ylabel(r'$\Delta$ Amplitude', fontsize=fontsize)
ax[1].tick_params(axis='both', labelsize=ticksize)
ax[1].set_xlim(xmin-1,xmax+1)
fig.tight_layout()
plt.show()
|
https://github.com/Fergus-Hayes/qiskit_tools
|
Fergus-Hayes
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ
from scipy.interpolate import approximate_taylor_polynomial
from qiskit.circuit.library import RGQFTMultiplier, DraperQFTAdder, ExactReciprocal
from qiskit.circuit.library.basis_change import QFT as QFT_pre
from qiskit.extensions import HamiltonianGate
from qiskit.circuit.library.standard_gates import PhaseGate, RYGate, CSwapGate
from qiskit.circuit.library.arithmetic.integer_comparator import IntegerComparator
from qiskit.circuit.library.standard_gates import XGate
from qiskit.quantum_info.operators.pauli import Pauli
from qiskit.circuit.library.boolean_logic import OR
from qiskit.quantum_info import random_unitary
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import Unroller
import itertools as it
import numpy as np
import sympy
def signmag_bin_to_dec(binary, nint=None):
mag = bin_to_dec(binary[1:], nint=nint)
sign = (-1)**(int(binary[0]))
return mag*sign
def bin_to_dec(binary, nint=None, phase=False, signmag=False):
"""
Convert a binary string to a floating point number
binary - input binary (string)
nint - number of integer bits. Default to all (int)
"""
if signmag:
return signmag_bin_to_dec(binary, nint)
basis = 0.
n = len(binary)
if phase:
if binary[0]=='1':
if nint is None:
nint_ = n-1
else:
nint_ = nint
basis = -(2.**(nint_))
binary = binary[1:]
n = len(binary)
if nint is None:
nint = n
digit = 0.
for i,bit in enumerate(np.arange(nint-n,nint)[::-1]):
digit+=(2.**bit)*int(binary[i])
return digit + basis
def my_binary_repr(digit, n, nint=None, phase=False, nround=True, overflow_error=True, signmag=False):
"""
Convert a floating point digit to binary string
digit - input number (float)
n - total number of bits (int)
nint - number of integer bits. Default to lowest required (int)
"""
if signmag and phase:
bin_out = my_binary_repr(np.abs(digit), n-1, nint=nint, phase=False, signmag=False)
if digit<0.:
return '1'+ bin_out
else:
return '0'+ bin_out
if nint is None:# or nint==n:
if phase:
nint = n - 1
else:
nint = n
if phase:
p = n - nint - 1
dmax = 2.**(nint) - 2.**(-p)
dmin = -2.**(nint)
else:
p = n - nint
dmax = 2.**(nint) - 2.**(-p)
dmin = 0.
if overflow_error:
if digit>dmax or digit<dmin:
raise ValueError('Digit '+str(digit)+' does not lie in the range:',dmin,'-',dmax,n,nint,p)
if nround:
n += 1
p += 1
value = digit
bin_out = ''
if phase:
if value<0.:
value+=2.**nint
bin_out+='1'
else:
bin_out+='0'
for i,bit in enumerate(np.arange(-p,nint)[::-1]):
bin_out+=str(int(np.floor(value/2.**bit)))
if value>=2.**bit:
value-=2.**bit
if nround:
carry = True
bin_out = np.array(list(bin_out))
for i in np.arange(n)[::-1]:
if not carry:
break
if bin_out[i]=='1':
bin_out[i]='0'
elif bin_out[i]=='0':
bin_out[i]='1'
carry = False
bin_out = ("").join(list(bin_out[:-1]))
return bin_out
def pres_est(digit, n, nint=None, phase=False):
if phase:
n -= 1
if nint is None:
nint = n
if digit==0.:
return 0.
if digit!=0.:
return (digit/np.abs(digit))*bin_to_dec(my_binary_repr(digit, n, nint=nint, phase=phase), nint=nint, phase=phase)
else:
return 0.
def twos_compliment(binary):
n = len(binary)
if np.sum(np.array(list(binary)).astype(int))==0:
compliment = binary
else:
compliment = my_binary_repr(bin_to_dec(''.join(list(np.logical_not(np.array(list(binary)).astype(bool)).astype(int).astype(str))), nint=None, phase=False) + 1, n, nint=None, phase=False, overflow_error=False)
return compliment
def get_nint(digits):
if np.array(digits).ndim==0:
digits=np.array([digits])
digits = np.where(np.abs(digits)>1.,np.modf(digits)[1],digits)
digits = digits[digits!=0.]
if len(digits)==0:
return 0
nint = int(np.ceil(np.log2(np.max(np.abs(digits)+1))))
return nint
def get_npres(digits):
if np.array(digits).ndim==0:
digits=np.array([digits])
digdecs = np.modf(digits)[0]
digdecs = digdecs[digdecs!=0]
if len(digdecs)==0:
return 0
mindec = np.min(np.abs(digdecs))
switch = True
p = 0
while switch:
if mindec%(2.**-p)==0.:
switch=False
p+=1
return p-1
def piecewise_poly(xs, coeffs, bounds_):
ys = np.array([])
bounds__ = np.copy(bounds_)
bounds__[-1] = np.inf
for i in np.arange(len(bounds__))[:-1]:
ys_ = np.array(np.polyval(coeffs[i], xs[np.greater_equal(xs,bounds__[i])&np.greater(bounds__[i+1],xs)]))
ys = np.concatenate([ys, ys_])
return ys
def get_coefficients(xs, coeffs, bounds_):
ys = np.array([])
bounds__ = np.copy(bounds_)
bounds__[-1] = np.inf
for i in np.arange(len(bounds__))[:-1]:
#print(np.where(np.greater_equal(xs,bounds[i])&np.greater(bounds[i+1],xs), coeffs[i]))
ys_ = np.ones(np.sum(np.greater_equal(xs,bounds__[i])&np.greater(bounds__[i+1],xs)))*coeffs[i]
#ys_ = np.array(np.polyval(coeffs[i], xs[np.greater_equal(xs,bounds[i])&np.greater(bounds[i+1],xs)]))
ys = np.concatenate([ys, ys_])
return ys
def get_bound_coeffs(func, bounds, norder, reterr=False):
if np.array(bounds).ndim==0:
print('Bounds must be a list of two entries!')
if len(bounds)==1:
print('Bounds must be a list of two entries!')
coeffs = []
errs = []
for i in np.arange(len(bounds))[:-1]:
coeffs_, err_ = run_remez(func, bounds[i], bounds[i+1], norder)
coeffs.append(np.array(coeffs_))
errs.append(err_)
if reterr:
return np.array(coeffs), np.array(errs)
else:
return np.array(coeffs)
def input_bits_to_qubits(binary, circ, reg, wrap=False, inverse=False, phase=False, qphase=None, label='Input'):
# Flips the qubits to match a classical bit string
n = len(binary)
if inverse:
wrap = True
if wrap:
regs = []
reg = QuantumRegister(n, 'reg')
regs.append(reg)
if qphase!=None:
qphase = QuantumRegister(1, 'phase')
regs.append(qphase)
circ = QuantumCircuit(*regs)
if phase and qphase==None:
qphase = QuantumRegister(1, 'phase')
circ.add(qphase)
for bit in np.arange(n):
if int(binary[::-1][bit])==1:
circ.x(reg[bit])
if phase<0.:
circ.x(qphase[0])
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def binary_input(data_ins, n, nint=None):
#Return the binary representation of the input number as a string
data_outs=[]
for data_in in data_ins:
data_outs.append(my_binary_repr(data_in, n, nint=nint))
return np.array(data_outs)
def qft_rotations(circuit, n):
"""Performs qft on the first n qubits in circuit (without swaps)"""
circuit.h(n)
for qubit in np.arange(n):
circuit.cp(np.pi/2.**(n-qubit), qubit, n)
# At the end of our function, we call the same function again on
# the next qubits (we reduced n by one earlier in the function)
return circuit
def swap_registers(circuit, n):
for qubit in range(n//2):
circuit.swap(qubit, n-qubit-1)
return circuit
def qft(circuit, n):
"""QFT on the first n qubits in circuit"""
for qubit in np.arange(n)[::-1]:
circuit = qft_rotations(circuit, qubit)
swap_registers(circuit, n)
return circuit
def QFT(circ, qreg, do_swaps=True, approximation_degree=0., insert_barriers=False, wrap=False, inverse=False, label='QFT'):
n = len(qreg)
if inverse:
wrap = True
if wrap:
qreg = QuantumRegister(n, 'q_reg')
circ = QuantumCircuit(qreg)
for j in reversed(np.arange(n)):
circ.h(j)
num_entanglements = max(0, j - max(0, approximation_degree - (n - j - 1)))
for k in reversed(np.arange(j - num_entanglements, j)):
lam = np.pi * (2.0 ** (k - j))
circ.cp(lam, j, k)
if insert_barriers:
circ.barrier()
if do_swaps:
for i in np.arange(n // 2):
circ.swap(i, n - i - 1)
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def QFTAddition(circ, qreg1, qreg2, wrap=False, inverse=False, label='Add', QFT_on=True, iQFT_on=True, nint1=None, nint2=None, phase=False, signmag=False):
r"""
|qreg1>|qreg2> -> |qreg1>|qreg2 + qreg1>
"""
n1 = len(qreg1)
n2 = len(qreg2)
#if n1>n2:
# raise ValueError('First register cannot be greater than the second!',n1,n2)
if inverse:
wrap = True
if wrap:
qreg1 = QuantumRegister(n1, 'q_reg1')
qreg2 = QuantumRegister(n2, 'q_reg2')
circ = QuantumCircuit(qreg1, qreg2)
if nint1==None:
nint1 = n1
if nint2==None:
nint2 = n2
dp = (n2 - nint2) - (n1 - nint1)
dpn = 0
if dp<0:
dpn = np.abs(dp)
dp = 0
add_gate = QFTAddition_(circ, qreg1[dpn:], qreg2[dp:], wrap=True, phase=False, QFT_on=QFT_on, iQFT_on=iQFT_on, signmag=signmag)
circ.append(add_gate, [*qreg1[dpn:], *qreg2[dp:]]);
if n1!=n2 and not signmag and phase:
for i in np.arange(nint2-nint1):
circ.cx(qreg1[-1], qreg2[-i-1]);
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def QFTAddition_(circ, qreg1, qreg2, wrap=False, inverse=False, label='Add', QFT_on=True, iQFT_on=True, pm=1, phase=False, signmag=False):
r"""
|qreg1>|qreg2> -> |qreg1>|qreg2 + qreg1>
"""
n1 = len(qreg1)
n2 = len(qreg2)
if inverse:
wrap = True
if wrap:
qreg1 = QuantumRegister(n1, 'q_reg1')
qreg2 = QuantumRegister(n2, 'q_reg2')
circ = QuantumCircuit(qreg1, qreg2)
if QFT_on:
circ.append(QFT(circ, qreg2, do_swaps=False, wrap=True), qreg2[:])
jend = n1
if phase and signmag:
circ.append(TwosCompliment(circ, qreg1[:-1], wrap=True).control(1), [qreg1[-1], *qreg1[:-1]]);
jend -= 1
for j in np.arange(0,jend):
for l in np.arange(0,n2):
lam = pm*2*np.pi*2.**(j-l-1)
if lam%(2*np.pi)==0:
continue
circ.cp(lam, qreg1[j], qreg2[l])
if phase and n1!=n2 and lam%np.pi!=0:
circ.append(PhaseGate(-2.*lam).control(2), [qreg1[-1], qreg1[j], qreg2[l]]);
if phase and signmag:
circ.append(TwosCompliment(circ, qreg1[:-1], wrap=True).control(1), [qreg1[-1], *qreg1[:-1]]);
if iQFT_on:
circ.append(QFT(circ, qreg2, do_swaps=False, wrap=True, inverse=True), qreg2[:])
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def QFTSubtraction(circ, qreg1, qreg2, wrap=False, inverse=False, label='Sub', QFT_on=True, iQFT_on=True):
r"""
|qreg1>|qreg2> -> |qreg1>|qreg2 - qreg1>
"""
n1 = qreg1.size
n2 = qreg2.size
if inverse:
wrap = True
if wrap:
qreg1 = QuantumRegister(n1, 'q_reg1')
qreg2 = QuantumRegister(n2, 'q_reg2')
circ = QuantumCircuit(qreg1, qreg2)
if QFT_on:
circ.append(QFT(circ, qreg2, do_swaps=False, wrap=True), qreg2[:])
for j in np.arange(n1):
for k in np.arange(n2 - j):
lam = -np.pi / (2.**(k))
if lam%(2*np.pi)==0.:
continue
circ.cp(lam, qreg1[j], qreg2[j + k])
if iQFT_on:
circ.append(QFT(circ, qreg2, do_swaps=False, wrap=True, inverse=True), qreg2[:])
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def QFTSubtractionRHS(circ, qreg1, qreg2, wrap=False, inverse=False, label='Sub', QFT_on=True, iQFT_on=True):
r"""
|qreg1>|qreg2> -> |qreg1>|qreg1 - qreg2>
"""
n1 = qreg1.size
n2 = qreg2.size
if inverse:
wrap = True
if wrap:
qreg1 = QuantumRegister(n1, 'q_reg1')
qreg2 = QuantumRegister(n2, 'q_reg2')
circ = QuantumCircuit(qreg1, qreg2)
if QFT_on:
circ.append(QFT(circ, qreg2, do_swaps=False, wrap=True, inverse=True), qreg2[:])
for j in np.arange(n1):
for k in np.arange(n2 - j):
lam = np.pi / (2.**(k))
if lam%(2*np.pi)==0.:
continue
circ.cp(lam, qreg1[j], qreg2[j + k])
if iQFT_on:
circ.append(QFT(circ, qreg2, do_swaps=False, wrap=True, inverse=True), qreg2[:])
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def OnebitSub(circ, qbit1, qbit2, qans, wrap=True, inverse=False, label='Sub1'):
if len(qans)!=2:
print('Ancillary register must be of 2 qubits, length:', len(qans))
return 0
if inverse:
wrap = True
if wrap:
qbit1 = QuantumRegister(1, 'q_bit1')
qbit2 = QuantumRegister(1, 'q_bit2')
qans = QuantumRegister(2, 'q_ans')
circ = QuantumCircuit(qbit1, qbit2, qans)
circ.x(qbit2)
circ.ccx(qbit1, qbit2, qans[0])
circ.x(qbit1)
circ.x(qbit2)
circ.ccx(qbit1, qbit2, qans[1])
circ.x(qbit1)
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def BitStringCompare(circ, qreg1, qreg2, qans, wrap=False, inverse=False, label='BitComp'):
n = qreg1.size
if n!=qreg1.size:
print('Registers must be of equal length to compare!')
return 0
if len(qans)!=(3*n)-1:
print('Ancillary register must be 3xlength of input register - 1, length = ', len(qans))
return 0
if inverse:
wrap = True
if wrap:
qreg1 = QuantumRegister(n, 'q_reg1')
qreg2 = QuantumRegister(n, 'q_reg2')
qans = QuantumRegister((3*n)-1, 'q_ans')
circ = QuantumCircuit(qreg1, qreg2, qans)
for i in np.arange(n):
bit_gate = OnebitSub(circ, qreg1[i], qreg2[i], qans[3*i:(3*i)+2], wrap=True)
circ.append(bit_gate, [qreg1[i], qreg2[i], *qans[3*i:(3*i)+2]])
if i+1<n:
circ.x(qans[3*i])
circ.x(qans[(3*i)+1])
circ.ccx(*qans[3*i:(3*i)+3])
circ.x(qans[3*i])
circ.x(qans[(3*i)+1])
for i in np.arange(n)[1:][::-1]:
circ.ccx(qans[(3*(i-1))+2], qans[3*i], qans[3*(i-1)])
circ.ccx(qans[(3*(i-1))+2], qans[(3*i)+1], qans[(3*(i-1))+1])
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def TwosCompliment(circ, qreg, wrap=False, inverse=False, QFT_on=True, iQFT_on=True, label='comp2'):
n = len(qreg)
if inverse:
wrap = True
if wrap:
qreg = QuantumRegister(n, 'q_reg')
circ = QuantumCircuit(qreg)
for qubit in qreg:
circ.x(qubit)
inc_gate = QFTBinaryAdd(circ, qreg, ''.join(np.zeros(n-1).astype(int).astype(str))+'1', wrap=True)
circ.append(inc_gate, qreg)
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def QFTMultiply(circ, qreg1, qreg2, qreg3, A=1., wrap=False, inverse=False, nint1=None, nint2=None, nint3=None, phase=False, label='Mult', QFT_on=True, iQFT_on=True):
r"""
|qreg1>|qreg2>|qreg3> -> |qreg1>|qreg2>|qreg1 x qreg2>
"""
n1 = len(qreg1)
n2 = len(qreg2)
n3 = len(qreg3)
if n3!=n1+n2 and nint3 == None:
raise ValueError('Output register should be the combined length of both input registers if no integer bit length is specified.')
if nint1==None:
nint1=n1
if nint2==None:
nint2=n2
if nint3==None:
nint3=n3
nshift = (nint1 + nint2)-nint3
if phase:
nshift+=1
if inverse:
wrap = True
if wrap:
qreg1 = QuantumRegister(n1, 'q_reg1')
qreg2 = QuantumRegister(n2, 'q_reg2')
qreg3 = QuantumRegister(n3, 'q_reg3')
circ = QuantumCircuit(qreg1, qreg2, qreg3)
if QFT_on:
circ.append(QFT(circ, qreg3, do_swaps=False, wrap=True), qreg3[:])
for j in np.arange(1, n1 + 1):
for i in np.arange(1, n2 + 1):
for k in np.arange(1, n3 + 1):
lam = A*(2 * np.pi) / (2. ** (i + j + k - n3 - nshift))
if lam%(2*np.pi)==0.:
continue
circ.append(PhaseGate(lam).control(2),[qreg1[n1 - j], qreg2[n2 - i], qreg3[k - 1]])
if iQFT_on:
circ.append(QFT(circ, qreg3, do_swaps=False, wrap=True, inverse=True), qreg3[:])
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def QFTMultPhase(circ, qreg1, qreg2, qreg3, wrap=False, inverse=False, nint1=None, nint2=None, nint3=None, label='MultPhase', QFT_on=True, iQFT_on=True, signmag1=False, signmag2=False, signmag3=False, poszero=False):
r"""
|qreg1>|qreg2>|qreg3> -> |qreg1>|qreg2>|qreg1 x qreg2>
"""
n1 = len(qreg1)
n2 = len(qreg2)
n3 = len(qreg3)
if n3>n1+n2:
raise ValueError('The output register is greater than necessary.')
if n3!=n1+n2 and nint3 == None:
raise ValueError('Output register should be the combined length of both input registers if no integer bit length is specified.')
if nint1==None:
nint1=n1
if nint2==None:
nint2=n2
if nint3==None:
nint3=n3
if inverse:
wrap = True
if wrap:
qreg1 = QuantumRegister(n1, 'q_reg1')
qreg2 = QuantumRegister(n2, 'q_reg2')
qreg3 = QuantumRegister(n3, 'q_reg3')
circ = QuantumCircuit(qreg1, qreg2, qreg3)
# Define the twos-complement operations
tc_gate_1 = TwosCompliment(circ, qreg1[:-1], wrap=True).control(1)
tc_gate_2 = TwosCompliment(circ, qreg2[:-1], wrap=True).control(1)
tc_gate_3 = TwosCompliment(circ, qreg3[:-1], wrap=True).control(2)
# Add the twos-complement operations to convert registers 1 and 2 to sign-magnitude notation
if not signmag1:
circ.append(tc_gate_1, [qreg1[-1], *qreg1[:-1]]);
if not signmag2:
circ.append(tc_gate_2, [qreg2[-1], *qreg2[:-1]]);
# Apply simple QFT multiplication
mult_gate = QFTMultiply(circ, qreg1[:-1], qreg2[:-1], qreg3[:-1], nint1=nint1, nint2=nint2, nint3=nint3, wrap=True)
circ.append(mult_gate, [*qreg1[:-1], *qreg2[:-1], *qreg3[:-1]]);
if not signmag3:
# If register 1 is positive, but register 2 is negative, then twos-complement operator on 3
circ.x(qreg1[-1]);
circ.append(tc_gate_3, [qreg1[-1], qreg2[-1], *qreg3[:-1]]);
circ.x(qreg1[-1]);
# If register 2 is positive, but register 1 is negative, then twos-complement operator on 3
circ.x(qreg2[-1]);
circ.append(tc_gate_3, [qreg1[-1], qreg2[-1], *qreg3[:-1]]);
circ.x(qreg2[-1]);
# If 1 is negative flip phase qubit of 3, and if 2 is negative flip phase qubit of 3
circ.cx(qreg1[-1], qreg3[-1]);
circ.cx(qreg2[-1], qreg3[-1]);
if not signmag1:
# Restore register 1 to original twos-complement notation
circ.append(tc_gate_1, [qreg1[-1], *qreg1[:-1]]);
if not signmag2:
# Restore register 2 to original twos-complement notation
circ.append(tc_gate_2, [qreg2[-1], *qreg2[:-1]]);
if poszero or not signmag3:
# Flip register 1
for qubit in np.arange(n1):
circ.x(qreg1[qubit]);
# If register 1 is all zeros and phase of 2 is negative, then flip the phase of 3
circ.mcx([*qreg1, qreg2[-1]], qreg3[-1], mode='noancilla')
# Flip back register A
for qubit in np.arange(n1):
circ.x(qreg1[qubit]);
# Flip register B
for qubit in np.arange(n2):
circ.x(qreg2[qubit]);
# If register 2 is all zeros and phase of 1 is negative, then flip the phase of 3
circ.mcx([*qreg2, qreg1[-1]], qreg3[-1], mode='noancilla')
# Flip back register 2
for qubit in np.arange(n2):
circ.x(qreg2[qubit]);
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def QFTMultBinPhase(circ, qreg1, qreg3, binary, wrap=False, inverse=False, nint=None, label='MultBinPhase', QFT_on=True, iQFT_on=True):
r"""
|qreg1>|qreg2> -> |qreg1>|qreg1 x A>
"""
n1 = len(qreg1)
n2 = len(binary)
n3 = len(qreg3)
#if n3>n1+n2:
# raise ValueError('The output register is greater than necessary.')
if n3!=n1+n2 and nint == None:
raise ValueError('Output register should be the combined length of both input registers if no integer bit length is specified.')
if nint==None:
nint=n1
if inverse:
wrap = True
if wrap:
qreg1 = QuantumRegister(n1, 'q_reg1')
qreg3 = QuantumRegister(n3, 'q_reg3')
circ = QuantumCircuit(qreg1, qreg3)
comp_gate1_inv = TwosCompliment(circ, qreg1[:-1], wrap=True, inverse=True).control(1)
circ.append(comp_gate1_inv, [qreg1[-1], *qreg1[:-1]]);
if binary[0]=='1':
twoscomp = twos_compliment(binary)
else:
twoscomp = binary
mult_gate = QFTBinaryMult(circ, qreg1[:-1], qreg3[:-1], twoscomp[1:], nint=nint, wrap=True)
circ.append(mult_gate, [*qreg1[:-1], *qreg3[:-1]]);
# if reg1 was neg, but binary is pos, then flip 2comp of reg3
# then vise versa
if binary[0]=='1':
circ.x(qreg1[-1]);
comp_gate = TwosCompliment(circ, qreg3[:-1], wrap=True).control(1)
circ.append(comp_gate, [qreg1[-1], *qreg3[:-1]]);
circ.x(qreg1[-1]);
elif binary[0]=='0':
comp_gate = TwosCompliment(circ, qreg3[:-1], wrap=True).control(1)
circ.append(comp_gate, [qreg1[-1], *qreg3[:-1]]);
# if reg1(bin) is neg, flip sign of reg3
circ.cx(qreg1[-1], qreg3[-1]);
if binary[0]=='1':
circ.x(qreg3[-1]);
# reverse the twos comp
comp_gate1 = TwosCompliment(circ, qreg1[:-1], wrap=True).control(1)
circ.append(comp_gate1, [qreg1[-1], *qreg1[:-1]]);
# flip all reg1 qubits
# and all but last binary
if binary[0]=='1':
for qubit in np.arange(n1):
circ.x(qreg1[qubit]);
circ.mcx(qreg1, qreg3[-1], mode='noancilla')
for qubit in np.arange(n1):
circ.x(qreg1[qubit]);
if np.sum(np.array(list(binary)).astype(int))==0:
circ.cx(qreg1[-1], qreg3[-1]);
#for qubit in np.arange(n3-1):
# circ.x(qreg3[qubit])
#circ.mcx(qreg3[:-1], qreg3[-1], mode='noancilla')
#for qubit in np.arange(n3-1):
# circ.x(qreg3[qubit])
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def QFTBinaryAdd(circ, qreg, binary, wrap=False, inverse=False, QFT_on=True, iQFT_on=True, label='AddA'):
r"""
|qreg> -> |qreg + A>
"""
n1 = len(qreg)
n2 = len(binary)
if inverse:
wrap = True
if wrap:
qreg = QuantumRegister(n1, 'q_reg1')
circ = QuantumCircuit(qreg)
if QFT_on:
circ.append(QFT(circ, qreg, do_swaps=False, wrap=True), qreg[:])
for i in np.arange(1, n1 + 1):
for k in np.arange(1, n2 + 1):
lam = (2. * np.pi) / (2. ** (i + k - n2))
if lam%(2*np.pi)==0.:
continue
if binary[i-1]=='1':
circ.p(lam,qreg[k-1])
if iQFT_on:
circ.append(QFT(circ, qreg, do_swaps=False, wrap=True, inverse=True), qreg[:])
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def QFTBinarySub(circ, qreg, binary, wrap=False, inverse=False, label='SubA'):
r"""
|qreg> -> |qreg - A>
"""
n1 = len(qreg)
n2 = len(binary)
if inverse:
wrap = True
if wrap:
qreg = QuantumRegister(n1, 'q_reg1')
circ = QuantumCircuit(qreg)
circ.append(QFT(circ, qreg, do_swaps=False, wrap=True), qreg[:])
for i in np.arange(1, n2 + 1):
for k in np.arange(1, n1 + 1):
lam = -(2. * np.pi) / (2. ** (i + k - n1))
if lam%(2*np.pi)==0.:
continue
if binary[k-1]=='1':
circ.p(lam,qreg[i-1])
circ.append(QFT(circ, qreg, do_swaps=False, wrap=True, inverse=True), qreg[:])
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def QFTBinarySubRHS(circ, qreg, binary, wrap=False, inverse=False, label='SubA'):
r"""
|qreg> -> |A - qreg>
"""
n1 = qreg.size
n2 = len(binary)
if inverse:
wrap = True
if wrap:
qreg = QuantumRegister(n1, 'q_reg1')
circ = QuantumCircuit(qreg)
circ.append(QFT(circ, qreg, do_swaps=False, wrap=True, inverse=False), qreg[:])
for i in np.arange(1, n1 + 1):
for k in np.arange(1, n2 + 1):
lam = -(2. * np.pi) / (2. ** (i + k - n2))
if lam%(2*np.pi)==0.:
continue
if binary[i-1]=='1':
circ.p(lam,qreg[k-1])
circ.append(QFT(circ, qreg, do_swaps=False, wrap=True, inverse=True), qreg[:])
for i in np.arange(1, n2):
circ.x(qreg[i])
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def qubit_to_phase(circ, qreg, nint=None, wrap=False, inverse=False, phase=False, factor=1, label='Amp2Phase'):
r"""
|qreg> -> e^(2pi i qreg)|qreg>
"""
n = len(qreg)
if inverse:
wrap = True
if wrap:
qreg = QuantumRegister(n, 'q_reg')
circ = QuantumCircuit(qreg)
if phase:
n -= 1
if nint==None:
nint = n
for k in np.arange(1,n-nint+1):
lam = 2.*np.pi*(2.**(-k))*factor
qubit = n-nint-k
circ.p(lam,qreg[qubit])
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def CRotation(circ, qreg, qtarg, nint=None, phase=False, label='CRot', wrap=False, inverse=False):
n = len(qreg)
if nint is None:
nint = n
if inverse:
wrap = True
if wrap:
qreg = QuantumRegister(n, 'qreg')
qtarg = QuantumRegister(1, 'q_targ')
circ = QuantumCircuit(qreg, qtarg)
for i in np.arange(n):
circ.cry(2.**(i+1+nint-n), qreg[i], qtarg)
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def QFTPowerN(circ, qreg1, qreg2, N, wrap=False, inverse=False, nintx=None, nint=None, label='PowN', QFT_on=True, iQFT_on=True):
r"""
|qreg1>|qreg2> -> |qreg1>|qreg1**N>
"""
n1 = qreg1.size
n2 = qreg2.size
if n2>(n1*N):
raise ValueError('The output register is greater than necessary.')
if n2!=(n1*N) and nint == None:
raise ValueError('Output register should be '+str(N)+'x the length of the input register if no integer bit length is specified.')
if nintx==None:
nintx=0
if nint==None:
nint=0
nshift = N-1+(N*nintx)-nint
if inverse:
wrap = True
if wrap:
qreg1 = QuantumRegister(n1, 'q_reg1')
qreg2 = QuantumRegister(n2, 'q_reg2')
circ = QuantumCircuit(qreg1, qreg2)
if QFT_on:
circ.append(QFT(circ, qreg2, do_swaps=False, wrap=True), qreg2[:])
qubit_grid = np.meshgrid(*[np.arange(1,n1+1) for i in np.arange(N)], indexing='ij')
grid_shape = [n1 for i in np.arange(N)]
grid_shape.append(n2)
gridouts = np.ones(grid_shape)*np.arange(1,n2+1)
gridouts = 2*np.pi/(np.power(2.,np.sum(qubit_grid,axis=0)+gridouts.T-n2-nshift))
cond = gridouts%(2.*np.pi)!=0.
inds = np.argwhere(cond)+1
lams = gridouts[cond]
for j,ind in enumerate(inds):
k = ind[0]
ind_ = ind[1:]
cnt = len(np.unique(ind_))
cqubits = [n1-i for i in np.unique(ind_)]
cqubits = [qreg1[n1-i] for i in np.unique(ind_)]
cqubits.append(qreg2[k-1])
circ.append(PhaseGate(lams[j]).control(cnt),cqubits)
if iQFT_on:
circ.append(QFT(circ, qreg2, do_swaps=False, wrap=True, inverse=True), qreg2[:])
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'†'
return circ
def QFTDivision(circ, qreg1, qreg2, c_div, acc, backend=Aer.get_backend('qasm_simulator'), shots=10, wrap=False, inverse=False, label='DivInt'):
if inverse:
wrap = True
if wrap:
qreg1 = QuantumRegister(qreg1.size, 'q_reg1')
qreg2 = QuantumRegister(qreg2.size, 'q_reg2')
acc = QuantumRegister(acc.size, 'acc')
c_div = ClassicalRegister(c_div.size, 'c_div')
circ = QuantumCircuit(qreg1, qreg2, acc, c_div)
d = QuantumRegister(1, 'd')
circ.add_register(d)
circ.x(d[0])
c_dividend_str = '0'
while c_dividend_str[0] == '0':
print(c_dividend_str)
circ = QFTSubtraction(circ, qreg1, qreg2)
circ = QFTAddition(circ, acc, d)
circ.measure(qreg1[:], c_div[:])
result = execute(circ, backend=backend, shots=shots).result()
counts = result.get_counts()
c_dividend_str = list(counts.keys())[0]
print(c_dividend_str)
circ = QFTSubtract(circ, acc, d)
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def taylor_coeffs(f_, args=[], a=0., norders=3):
x = sympy.Symbol('x')
f = f_(x)
coeffs = []
for norder in np.arange(norders):
coeffs.append(float(sympy.diff(f, x, norder).subs(x, a) / sympy.factorial(norder)))
return np.array(coeffs)
def Gaussian_noise_amp(circ, qreg, reps=2, wrap=False, inverse=False, label='GaussNoise'):
n = qreg.size
if inverse:
wrap = True
if wrap:
qreg = QuantumRegister(n, 'q_reg')
circ = QuantumCircuit(qreg)
for level in np.arange(reps+1):
for i in np.arange(n-1):
for j in np.arange(i+1,n):
rand_op = random_unitary(4)
circ.append(rand_op,[qreg[i],qreg[j]])
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def depolarisation_channel(circ, qreg, p, wrap=False, inverse=False, label='depol_channel'):
n = qreg.size
if inverse:
wrap = True
if wrap:
qreg = QuantumRegister(n, 'q_reg')
circ = QuantumCircuit(qreg)
num_terms = 4**n
max_param = num_terms / (num_terms - 1)
if p < 0 or p > max_param:
raise NoiseError("Depolarizing parameter must be in between 0 "
"and {}.".format(max_param))
prob_iden = 1 - p / max_param
prob_pauli = p / num_terms
probs = [prob_iden] + (num_terms - 1) * [prob_pauli]
paulis = [Pauli("".join(tup)) for tup in it.product(['I', 'X', 'Y', 'Z'], repeat=n)]
gates_ind = np.random.choice(num_terms, p=probs, size=1)[0]
gates = paulis[gates_ind]
circ.append(gates, qreg[:])
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def increment_gate(circ, qreg, wrap=False, inverse=False, QFT_on=True, iQFT_on=True, ncut=0, label='inc'):
n = len(qreg)
if inverse:
wrap = True
if wrap:
qreg = QuantumRegister(n, 'q_reg')
circ = QuantumCircuit(qreg)
if n<ncut:
for i in np.arange(n)[1:][::-1]:
if i!=0:
xgate = XGate().control(i)
circ.append(xgate, [*qreg[:i+1]])
circ.x(qreg[0])
else:
bin_one = ''.join(np.zeros(n-1).astype(int).astype(str))+'1'
inc_gate = QFTBinaryAdd(circ, qreg, bin_one, wrap=True, QFT_on=QFT_on, iQFT_on=iQFT_on)
circ.append(inc_gate, qreg)
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def integer_compare(circ, qreg, qtarg, qans, value, geq=True, wrap=False, inverse=False, uncomp=True, label='intP'):
n = len(qreg)
if len(qans)!=n-1:
raise ValueError('Ancilla register must be 1 qubit fewer than input register.')
if len(qtarg)!=1:
raise ValueError('Target register must be of 1 qubit.')
if wrap:
qreg = QuantumRegister(n, 'q_reg')
qans = QuantumRegister(n, 'q_ans')
circ = QuantumCircuit(qreg, qans)
qtarg = qans[0]
qans = qans[1:]
if value<=0.:
if geq:
circ.x(qtarg);
elif value < np.power(2,n):
if n>1:
twos = np.array(list(twos_compliment(my_binary_repr(value, n=n, phase=False))))[::-1]
for i in np.arange(n):
if i==0:
if twos[i]=='1':
circ.cx(qreg[i], qans[i])
elif i<n-1:
if twos[i]=='1':
circ.compose(OR(2), [qreg[i], qans[i-1], qans[i]], inplace=True);
else:
circ.ccx(qreg[i], qans[i - 1], qans[i]);
else:
if twos[i]=='1':
circ.compose(OR(2), [qreg[i], qans[i-1], qtarg], inplace=True);
else:
circ.ccx(qreg[i], qans[i - 1], qtarg);
if not geq:
circ.x(qtarg);
if uncomp:
for i in np.arange(n-1)[::-1]:
if i==0:
if twos[i]=='1':
circ.cx(qreg[i], qans[i]);
else:
if twos[i]=='1':
circ.compose(OR(2), [qreg[i], qans[i-1], qans[i]], inplace=True);
else:
circ.ccx(qreg[i], qans[i-1], qans[i]);
else:
circ.cx(qreg[0], qtarg);
if not geq:
circ.x(qtarg);
else:
if not geq:
circ.x(qtarg);
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def inequal_cond(circ, qreg, qtarg, qans, value, nint=None, phase=False, comp2=True, geq=True, wrap=False, inverse=False, uncomp=True, xflip=True, label='P'):
n = len(qreg)
if len(qans)!=n-1:
raise ValueError('Ancilla register must be 1 qubit fewer than input register.')
if len(qtarg)!=1:
raise ValueError('Target register must be of 1 qubit.')
if phase and not comp2:
raise ValueError('Only twos-compliment representation for signed numbers is currently implemented')
if wrap:
qreg = QuantumRegister(n, 'q_reg')
qans = QuantumRegister(n-1, 'q_ans')
qtarg = QuantumRegister(1, 'q_targ')
circ = QuantumCircuit(qreg, qtarg, qans)
binary = my_binary_repr(value, n, phase=phase, nint=nint)
if phase:
if xflip:
circ.x(qreg[-1]);
if binary[0]=='0':
binary = '1'+binary[1:]
elif binary[0]=='1':
binary = '0'+binary[1:]
int_value = bin_to_dec(binary, nint=None, phase=False)
intcomp_gate = integer_compare(circ, qreg, qtarg, qans, int_value, geq=geq, wrap=wrap, inverse=inverse, uncomp=uncomp)
circ.append(intcomp_gate, [*qreg, *qtarg, *qans]);
if phase and xflip:
circ.x(qreg[-1]);
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def label_gate(circ, qreg, qtarg, qans, qlab, bounds=None, wrap=False, nint=None, inverse=False, phase=False, ncut=0, label='LABEL'):
n = len(qreg)
if nint is None:
nint = n
if phase:
nint -= 1
if inverse:
wrap = True
if bounds is None:
bounds = [0, 2**n]
nlab = int(np.ceil(np.log2(len(bounds))))
if nlab!=qlab.size:
raise ValueError('Size of label register does not match the number of bounds placed.')
if len(qans)!= n-1:
raise ValueError('Ancilla register must have one fewer qubit than input register.')
if wrap:
qreg = QuantumRegister(n, 'q_reg')
qtarg = QuantumRegister(1, 'q_targ')
qans = QuantumRegister(n-1, 'q_ans')
qlab = QuantumRegister(nlab, 'q_lab')
circ = QuantumCircuit(qreg, qtarg, qans, qlab)
circ.x(qreg[-1]);
if nlab>=ncut:
circ.append(QFT(circ, qlab, do_swaps=False, wrap=True), qlab)
for i,bound_ in enumerate(bounds):
binary = my_binary_repr(bound_, n=n, nint=nint, phase=phase)
if binary[0]=='0':
binary = '1'+binary[1:]
elif binary[0]=='1':
binary = '0'+binary[1:]
bound = bin_to_dec(binary, nint=None, phase=False)
intcomp_gate = integer_compare(circ, qreg, qtarg, qans, bound, geq=True, wrap=True, uncomp=False, label='P'+str(i))
circ.append(intcomp_gate, [*qreg, qtarg[0], *qans[:]])
inc_gate = increment_gate(circ, qlab, wrap=True, label='SET'+str(i), ncut=ncut, QFT_on=False, iQFT_on=False).control(1)
circ.append(inc_gate, [qtarg[0], *qlab[:]])
intcomp_gate_inv = integer_compare(circ, qreg, qtarg, qans, bound, geq=True, wrap=True, uncomp=False, inverse=True, label='P'+str(i))
circ.append(intcomp_gate_inv, [*qreg, qtarg[0], *qans[:]])
if nlab>=ncut:
circ.append(QFT(circ, qlab, do_swaps=False, wrap=True, inverse=True), qlab)
circ.x(qreg[-1]);
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def cin_gate(circ, qcoff, qlab, coeffs_in, nint=None, phase=False, wrap=False, inverse=False, label='X', comp2=True):
n = len(qcoff)
nlab = len(qlab)
if 2**nlab<len(coeffs_in):
print('Not enough label states to coefficents.')
return 0
if inverse:
wrap = True
if wrap:
qcoff = QuantumRegister(n, 'q_reg')
qlab = QuantumRegister(nlab, 'q_lab')
circ = QuantumCircuit(qcoff, qlab)
for i in np.arange(len(coeffs_in)):
control_bits = my_binary_repr(i, nlab, nint=nlab, phase=False)
if i>0:
control_bits_ = my_binary_repr(i-1, nlab, nint=nlab, phase=False)[::-1]
else:
control_bits_ = np.ones(nlab).astype(int).astype(str)
for j,control_bit in enumerate(control_bits[::-1]):
if control_bit=='0' and control_bits_[j]=='1':
circ.x(qlab[j])
if comp2:
input_gate = input_bits_to_qubits(my_binary_repr(coeffs_in[i], n, nint=nint, phase=phase), circ, reg=qcoff, wrap=True).control(nlab)
circ.append(input_gate, [*qlab, *qcoff]);
else:
input_gate = input_bits_to_qubits(my_binary_repr(np.abs(coeffs_in[i]), n-1, nint=nint, phase=False), circ, reg=qcoff[:-1], wrap=True).control(nlab)
circ.append(input_gate, [*qlab, *qcoff[:-1]]);
if coeffs_in[i]<0.:
circ.append(XGate().control(nlab), [*qlab, qcoff[-1]]);
if i<len(coeffs_in)-1:
control_bits_ = my_binary_repr(i+1, nlab, nint=nlab, phase=False)[::-1]
else:
control_bits_ = np.ones(nlab).astype(int).astype(str)
for j,control_bit in enumerate(control_bits[::-1]):
if control_bit=='0' and control_bits_[j]=='1':
circ.x(qlab[j])
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def classic_piecewise_function(x_, coeffs_, n, bounds, nint=None, phase=False):
nintx = int(np.ceil(np.log2(np.max(bounds))))
x = pres_est(x_, n, nint=n, phase=phase)
coeff_ind = np.argwhere(bounds>=x)[0].flatten()
if coeff_ind!=0:
coeff_ind = coeff_ind-1
coeffs_ = coeffs_.T[coeff_ind].flatten()
nintc = int(np.ceil(np.log2(np.max(np.abs(coeffs_)))))
coeffs = []
for coeff in coeffs_:
coeffs.append(pres_est(coeff, n, nint=nintc, phase=phase))
coeffs = np.array(coeffs)[::-1]
y = pres_est(x*coeffs[0], n, nint=nint, phase=phase)
y = pres_est(y + coeffs[1], n, nint=nint, phase=phase)
for i in np.arange(2,len(coeffs)):
y = pres_est(y*x, n, nint=nint, phase=phase)
y = pres_est(y + coeffs[i], n, nint=nint, phase=phase)
return y
def linear_piecewise_approx(circ, qx, qout, qlab, qcoff, coeffs, bounds, nint=None, nintx=None, nintcs=None, phase=False, wrap=False, inverse=False, unlabel=False, label='f(x)'):
m = int(np.ceil(np.log2(len(bounds))))
nx = len(qx)
n = len(qout)
n0 = len(qcoff)
Nord, Ncoeffs = coeffs.shape
if Nord!=2:
raise ValueError('Currently only working for linear piecewise approximations.')
if nint is None:
nint = n
if m!=len(qlab):
raise ValueError('Size of label register is smaller than number of bounds.')
return 0
if np.any(nintcs==None):
nintcs = []
for coeffs_ in coeffs:
nintcs.append(int(np.ceil(np.log2(np.max(np.abs(coeffs_))))))
nintcs[-1] = nint
nintcs = np.array(nintcs).astype(int)
if nintx is None:
nintx = int(np.ceil(np.log2(np.max(np.abs(bounds)))))
if inverse:
wrap = True
if wrap:
qx = QuantumRegister(nx, 'x')
qout = QuantumRegister(n, 'o')
qlab = QuantumRegister(m, 'l')
qcoff = QuantumRegister(n0, 'c')
circ = QuantumCircuit(qx, qout, qlab, qcoff)
# We can use the coefficient register as the ancillary register for
#the labelling step as before
qtarg = qcoff[0]
qans = [*qcoff[1:], *qout][:nx-1]
# Label the data with the labelling operation
l_gate = label_gate(circ, qx, qtarg, qans, qlab, bounds=bounds, nint=nintx, phase=phase, wrap=True)
circ.append(l_gate, [*qx, qtarg, *qans, *qlab]);
# Load A1 into the coefficient register conditioned on the label register
X1_gate = cin_gate(circ, qcoff, qlab, coeffs[0], nint=nintcs[0,0], phase=phase, wrap=True)
circ.append(X1_gate, [*qcoff, *qlab]);
# Multiply the coefficient and x registers and save the output on the output register
mul_gate = QFTMultPhase(circ, qcoff, qx, qout, wrap=True, nint1=nintcs[0,0], nint2=nintx, nint3=nint)
circ.append(mul_gate, [*qcoff, *qx, *qout]);
# Unload A1 from the coefficient register with the inverse load operation
X1_gate_inv = cin_gate(circ, qcoff, qlab, coeffs[0], nint=nintcs[0,0], phase=phase, wrap=True, inverse=True)
circ.append(X1_gate_inv, [*qcoff, *qlab]);
# Load A0 into the coefficient register conditioned on the label register
X0_gate = cin_gate(circ, qcoff, qlab, coeffs[1], nint=nintcs[0,1], phase=phase, wrap=True)
circ.append(X0_gate, [*qcoff, *qlab]);
# Add the coefficient register to the output register
add_gate = QFTAddition(circ, qcoff, qout, nint1=nintcs[0,1], nint2=nint, wrap=True, phase=phase)
circ.append(add_gate, [*qcoff, *qout]);
# Unload A0 to clear the coefficient register
X0_gate_inv = cin_gate(circ, qcoff, qlab, coeffs[1], nint=nintcs[0,1], phase=phase, wrap=True, inverse=True)
circ.append(X0_gate_inv, [*qcoff, *qlab]);
# Unlabel the label register
l_gate_inv = label_gate(circ, qx, qtarg, qans, qlab, bounds=bounds, nint=nintx, phase=phase, wrap=True, inverse=True)
circ.append(l_gate_inv, [*qx, qtarg, *qans, *qlab]);
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def piecewise_function_posmulti(circ, q_x, q_y, q_lab, q_coff, coeffs, bounds, nint=None, nintx=None, nintcs=None, phase=False, wrap=False, inverse=False, unlabel=False, unfirst=False, comp2=False, label='f_x'):
nlab = int(np.ceil(np.log2(len(bounds))))
nx = len(q_x)
n = len(q_y)
nc = len(q_coff)
Nord, Ncoeffs = coeffs.shape
if Nord!=2:
raise ValueError('Currently only working for linear piecewise approximations.')
if nint is None:
nint = n
if nlab!=len(q_lab):
raise ValueError('Size of label register is smaller than number of bounds.')
return 0
if np.any(nintcs==None):
nintcs = []
for coeffs_ in coeffs:
nintcs.append(int(np.ceil(np.log2(np.max(np.abs(coeffs_))))))
nintcs[-1] = nint
nintcs = np.array(nintcs).astype(int)
if nintx is None:
nintx = int(np.ceil(np.log2(np.max(np.abs(bounds)))))
if inverse:
wrap = True
if wrap:
q_x = QuantumRegister(nx, 'q_x')
q_y = QuantumRegister(n, 'q_y0')
q_lab = QuantumRegister(nlab, 'q_lab')
q_coff = QuantumRegister(nc, 'q_coff')
circ = QuantumCircuit(q_x, q_y, q_lab, q_coff)
q_ans = [*q_coff, *q_y]
if len(q_ans)<nx:
raise ValueError('Coefficient/output register must be greater than half the length of the x register.')
lab_gate = label_gate(circ, q_x, q_ans[0], q_ans[1:nx+2], q_lab, bounds=bounds, nint=nintx, phase=False, wrap=True)
circ.append(lab_gate, [*q_x, *q_ans[:nx+2], *q_lab]);
#y1in_gate = cin_gate(circ, q_y, q_lab, coeffs[1], nint=nintcs[0,1], phase=phase, wrap=True)
#circ.append(y1in_gate, [*q_y, *q_lab]);
#circ.append(QFT(circ, q_y, do_swaps=False, wrap=True), q_y);
for i in np.arange(1, Nord):
y0in_gate = cin_gate(circ, q_coff, q_lab, coeffs[i-1], nint=nintcs[i-1,0], phase=phase, wrap=True, comp2=comp2)
circ.append(y0in_gate, [*q_coff, *q_lab]);
mul_gate = QFTPosMultiplicand(circ, q_coff, q_x, q_y, wrap=True, nint1=nintcs[i-1,0], nint2=nintx, nint3=nint, iQFT_on=True, QFT_on=True, comp2=comp2)
circ.append(mul_gate, [*q_coff, *q_x, *q_y]);
if unfirst or True:
y0in_gate_inv = cin_gate(circ, q_coff, q_lab, coeffs[i-1], nint=nintcs[i-1,0], phase=phase, wrap=True, comp2=comp2, inverse=True)
circ.append(y0in_gate_inv, [*q_coff, *q_lab]);
y1in_gate = cin_gate(circ, q_coff, q_lab, coeffs[i], nint=nintcs[i-1,1], phase=phase, wrap=True)
circ.append(y1in_gate, [*q_coff, *q_lab]);
add_gate = QFTAddition(circ, q_coff, q_y, wrap=True, phase=phase, nint1=nintcs[i-1,1], nint2=nint, QFT_on=True, iQFT_on=True)
circ.append(add_gate, [*q_coff, *q_y]);
#circ.append(QFT(circ, q_y, do_swaps=False, wrap=True, inverse=True), q_y);
if unlabel:
lab_gate_inv = label_gate(circ, q_x, q_ans[0], q_ans[1:nx+2], q_lab, bounds=bounds, nint=nintx, phase=False, wrap=True, inverse=True)
circ.append(lab_gate_inv, [*q_x, *q_ans[:nx+2], *q_lab]);
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def SWAP_test(circ, q_1, q_2, q_a, wrap=False, inverse=False, label='SWAP'):
n = len(q_1)
if len(q_1)!=len(q_2):
raise ValueError('The two registers should be the same size!')
if inverse:
wrap = True
if wrap:
q_1 = QuantumRegister(n, 'q_1')
q_2 = QuantumRegister(n, 'q_2')
q_a = QuantumRegister(1, 'q_a')
circ = QuantumCircuit(q_1, q_2, q_a)
circ.h(q_a[0]);
for qubit in np.arange(n):
circ.cswap(q_a,q_1[qubit],q_2[qubit])
circ.h(q_a[0]);
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def gate_decompose(qc):
"""decompose circuit to evaluate cost"""
pass_ = Unroller(["u3", "cx"])
return PassManager(pass_).run(qc).count_ops()
def Grover_Rudolph_load(circ, qx, probs, wrap=False, inverse=False, nstart=0, nend=None, label='GR_load'):
nx = len(qx)
if nend==None:
nend=nx
if len(probs)!=2**nx:
raise ValueError('Probabilities must equal length of x register')
if inverse:
wrap = True
if wrap:
qx = QuantumRegister(nx, 'q_x')
circ = QuantumCircuit(qx)
for m in np.arange(nstart, nend):
def GR_func(j):
j = np.array(j).astype(int)
As = []
for i in np.arange(2**m):
As.append(np.sum(probs[i*2**(nx-m):(i+1)*2**(nx-m)]))
As1 = []
for i in np.arange(2**(m+1)):
As1.append(np.sum(probs[i*2**(nx-(m+1)):(i+1)*2**(nx-(m+1))]))
return np.arccos(np.sqrt(np.array(As1)[::2][j]/np.array(As)[j]))
if m==0:
coeffs = np.arccos(np.sqrt(np.sum(probs[:2**(nx-1)])))
circ.ry(2*coeffs, qx[nx-m-1]);
else:
js = np.arange(2**m)
coeffs = GR_func(js)
for i in np.arange(2**m):
control_bits = my_binary_repr(i, m, nint=None, phase=False)
if i>0:
control_bits_ = my_binary_repr(i-1, m, nint=None, phase=False)[::-1]
else:
control_bits_ = np.ones(m).astype(int).astype(str)
for j,control_bit in enumerate(control_bits[::-1]):
if control_bit=='0' and control_bits_[j]=='1':
circ.x(qx[nx-j-1]);
R_gate = RYGate(2*coeffs[i]).control(int(m))
circ.append(R_gate, [*qx[nx-m-1:][::-1]]);
if i<2**m-1:
control_bits_ = my_binary_repr(i+1, m, nint=None, phase=False)[::-1]
else:
control_bits_ = np.ones(m).astype(int).astype(str)
for j,control_bit in enumerate(control_bits[::-1]):
if control_bit=='0' and control_bits_[j]=='1':
circ.x(qx[nx-j-1]);
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def Grover_Rudolph_func(circ, qx, qanc, qlab, qcoff, probs, wrap=False, inverse=False, mtol=1, mmax=None, norder=1, label='GR_func'):
nx = len(qx)
n = len(qcoff)
nanc = len(qanc)
nlab = len(qlab)
if mmax==None:
mmax=nx
if n!=nanc:
raise ValueError('I think ancilla and coefficient reg should be the same size')
if len(probs)!=2**nx:
raise ValueError('Probabilities must equal length of x register')
if inverse:
wrap = True
if wrap:
qx = QuantumRegister(nx, 'q_x')
qanc = QuantumRegister(nanc, 'q_anc')
qlab = QuantumRegister(nlab, 'q_lab')
qcoff = QuantumRegister(nanc, 'q_coff')
circ = QuantumCircuit(qx, qanc, qlab, qcoff)
if mtol>nx:
GRL_gate = Grover_Rudolph_load(circ, qx, probs, wrap=True)
circ.append(GRL_gate, qx);
elif mtol!=0:
probs_ = []
for i in np.arange(2**mtol):
probs_.append(np.sum(probs[i*2**(nx-mtol):(i+1)*2**(nx-mtol)]))
probs_ = np.array(probs_)
GRL_gate = Grover_Rudolph_load(circ, qx[nx-mtol:], probs_, wrap=True)
circ.append(GRL_gate, qx[nx-mtol:]);
for m in np.arange(mtol,mmax):
def GR_func(j):
j = np.array(j).astype(int)
As = []
for i in np.arange(2**m):
As.append(np.sum(probs[i*2**(nx-m):(i+1)*2**(nx-m)]))
As1 = []
for i in np.arange(2**(m+1)):
As1.append(np.sum(probs[i*2**(nx-(m+1)):(i+1)*2**(nx-(m+1))]))
return np.arccos(np.sqrt(np.array(As1)[::2][j]/np.array(As)[j]))
js = np.arange(2**m)
coeffs = GR_func(js)
bounds_ = np.linspace(0,2**m,(2**nlab)+1).astype(int)
coeffs = get_bound_coeffs(GR_func, bounds_, norder, reterr=False).T#[::-1]
bounds = bounds_[1:]
max_list0 = np.array([coeffs[0], coeffs[1], coeffs[0]*2**nx, (coeffs[0]*2**nx)+coeffs[-1]])
max_list1 = max_list0
nintcs = []
nintcs.append(int(np.ceil(np.log2(np.max(np.abs(max_list0))))))
nintcs.append(int(np.ceil(np.log2(np.max(np.abs(max_list1))))))
nint = nintcs[-1]
nintcs = np.array([nintcs])
func_gate = piecewise_function_posmulti(circ, qx[nx-m:], qanc, qlab, qcoff, coeffs, bounds, nint=nint, nintx=nx, nintcs=nintcs, phase=False, wrap=True, unlabel=False, unfirst=False)
circ.append(func_gate, [*qx[nx-m:], *qanc, *qlab, *qcoff]);
rot_gate = CRotation(circ, qanc, qx[nx-m-1], nint=nint, wrap=True)
circ.append(rot_gate, [*qanc, qx[nx-m-1]])
func_gate_inv = piecewise_function_posmulti(circ, qx[nx-m:], qanc, qlab, qcoff, coeffs, bounds, nint=nint, nintx=nx, nintcs=nintcs, phase=False, wrap=True, inverse=True, unlabel=False, unfirst=False)
circ.append(func_gate_inv, [*qx[nx-m:], *qanc, *qlab, *qcoff]);
for m in np.arange(mmax,nx):
circ.h(qx[nx-m-1]);
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def lpf(circ, qx, qout, qlab, qcoff, coeffs, bounds, nintx=None, nintcs=None, nint=None, phasex=False, phase=True, wrap=False, inverse=False, label='f_x'):
nlab = int(np.ceil(np.log2(len(bounds))))
nx = len(qx)
n = len(qout)
nc = len(qcoff)
Nord, Ncoeffs = coeffs.shape
if Nord!=2:
raise ValueError('Currently only working for linear piecewise approximations.')
if nlab!=len(qlab):
raise ValueError('Size of label register is smaller than number of bounds.')
return 0
if nint==None:
nint=n
if np.any(nintcs==None):
nintcs = []
for coeffs_ in coeffs:
nintcs.append(int(np.ceil(np.log2(np.max(np.abs(coeffs_))))))
nintcs[-1] = nint
nintcs = np.array(nintcs).astype(int)
if nintx is None:
nintx = int(np.ceil(np.log2(np.max(np.abs(bounds)))))
if inverse:
wrap = True
if wrap:
qx = QuantumRegister(nx, 'x')
qout = QuantumRegister(n, 'out')
qlab = QuantumRegister(nlab, 'lab')
qcoff = QuantumRegister(nc, 'coff')
circ = QuantumCircuit(qx, qout, qlab, qcoff)
qans = [*qcoff[1:], *qout][:nx-1]
qtarg = qcoff[0]
# Label the data with the labelling operation
l_gate = label_gate(circ, qx, qtarg, qans, qlab, bounds=bounds, nint=nintx, phase=phase, wrap=True)
circ.append(l_gate, [*qx, qtarg, *qans, *qlab]);
# Load A1 into the coefficient register conditioned on the label register
X1_gate = cin_gate(circ, qcoff, qlab, coeffs[0], nint=nintcs[0,0], phase=phase, wrap=True)
circ.append(X1_gate, [*qcoff, *qlab]);
# Multiply the coefficient and x registers and save the output on the output register
mul_gate = QFTMultPhase(circ, qcoff, qx, qout, wrap=True, nint1=nintcs[0,0], nint2=nintx, nint3=nint)
circ.append(mul_gate, [*qcoff, *qx, *qout]);
# Unload A1 from the coefficient register with the inverse load operation
X1_gate_inv = cin_gate(circ, qcoff, qlab, coeffs[0], nint=nintcs[0,0], phase=phase, wrap=True, inverse=True)
circ.append(X1_gate_inv, [*qcoff, *qlab]);
# Load A0 into the coefficient register conditioned on the label register
X0_gate = cin_gate(circ, qcoff, qlab, coeffs[1], nint=nintcs[0,1], phase=phase, wrap=True)
circ.append(X0_gate, [*qcoff, *qlab]);
# Add the coefficient register to the output register
add_gate = QFTAddition(circ, qcoff, qout, nint1=nintcs[0,1], nint2=nint, wrap=True, phase=phase)
circ.append(add_gate, [*qcoff, *qout]);
# Unload A0 to clear the coefficient register
X0_gate_inv = cin_gate(circ, qcoff, qlab, coeffs[1], nint=nintcs[0,1], phase=phase, wrap=True, inverse=True)
circ.append(X0_gate_inv, [*qcoff, *qlab]);
# Unlabel the label register
l_gate_inv = label_gate(circ, qx, qtarg, qans, qlab, bounds=bounds, nint=nintx, phase=phase, wrap=True, inverse=True)
circ.append(l_gate_inv, [*qx, qtarg, *qans, *qlab]);
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def PQC_realamp(circ, qreg, weights, wrap=False, inverse=False, label='PQCrealamp'):
n = len(qreg)
reps = weights.shape[0] - 1
if weights.shape[1]!=n:
raise ValueError('Shape of weight array does not match the number of qubits of the target register.')
if inverse:
wrap = True
if wrap:
qreg = QuantumRegister(n, 'q_reg')
circ = QuantumCircuit(qreg)
circ.h(qreg);
for rep in np.arange(reps+1):
for i in np.arange(n):
circ.ry(weights[rep,i],qreg[i])
for i in np.arange(n):
if i!=n-1 and rep!=reps:
circ.cx(qreg[i], qreg[i+1])
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def round_sig(xs, sigfig=0):
if np.array(xs).ndim==0:
xs = np.array([xs])
rxs = []
for x in xs:
if x!=0.:
rxs.append(np.round(x, sigfig-int(np.floor(np.log10(np.abs(x))))))
else:
rxs.append(0.)
rxs = np.array(rxs)
return rxs
def optimize_coeffs_qubits(f_x, xs, m, n=None, npres0=None, npres1=None, norder=1, phase=True, label_swap=False):
if n==None and npres0==None and npres1==None:
raise ValueError('Must specify either the number of qubits of the output register or the precision qubits of sets of coefficients.')
if npres0==None and npres1!=None or npres0!=None and npres1==None:
raise ValueError('Must leave both precision qubit options as None.')
xmin = xs[0]
xmax = xs[-1]
nx = int(np.log2(len(xs)))
nintx = get_nint(xs)
npresx = int(-np.log2(xs[1]-xs[0]))
if xmin==0.:
xphase=False
else:
xphase=True
bounds_ = np.linspace(xs[1], xmax, (2**m))
bounds__ = []
for bound in bounds_:
bounds__.append(bin_to_dec(my_binary_repr(bound, n=nx, nint=nintx, phase=xphase), nint=nintx, phase=xphase))
bounds_ = bounds__
bounds_[0] = xs[1]
bounds_ = np.append(xmin, bounds_)
coeffs = get_bound_coeffs(f_x, bounds_, norder, reterr=False).T
#bounds = np.copy(np.array(bounds_[:-1]))
bounds = np.copy(np.array(bounds_))
# The number of integer bits of A1, A0 and the result
nint0 = get_nint(coeffs[0])
nint1 = get_nint(coeffs[1])
nint = nintx + nint0
nswitch = False
if n==None:
nswitch = True
# The number of precision bits of the result
npres = npresx + npres0
# The total number of bits of A1, A0 and the result
n0 = npres0 + nint0 + 1
n1 = npres1 + nint1 + 1
n = npres + nint + 1
else:
npres = n - nint - 1
npres0 = npres - npresx
n0 = npres0 + nint0 + 1
npres1 = n0 - nint1 - 1
n1 = npres1 + nint1 + 1
rcoeffs = []
for coeff in coeffs[0]:
# Convert coefficient to binary string of new length n0, then calculate the corresponding decimal value
rcoeff = bin_to_dec(my_binary_repr(coeff, n0, nint=nint0, phase=phase), nint=nint0, phase=phase)
rcoeffs.append(rcoeff)
coeffs[0] = np.array(rcoeffs)
# Calculate the differences between the f(x) and A1x over all x
fdifs = f_x(xs) - piecewise_poly(xs, np.array([coeffs[0],np.zeros(len(coeffs[1]))]).T, bounds)
coeffs_ = []
bounds__ = np.copy(bounds_)
bounds__[-1] = np.inf
for i in np.arange(len(bounds__))[:-1]:
# Calculate the mean differences in each domain to be the new bias A0
coeffs_.append(np.mean(fdifs[np.greater_equal(xs,bounds__[i])&np.greater(bounds__[i+1],xs)]))
coeffs[1] = np.array(coeffs_)
nint1 = get_nint(coeffs[1])
rcoeffs = []
for coeff in coeffs[1]:
# Convert coefficient to binary string of new length n1, then calculate the corresponding decimal value
rcoeff = bin_to_dec(my_binary_repr(coeff, n1, nint=nint1, phase=phase), nint=nint1, phase=phase)
rcoeffs.append(rcoeff)
coeffs[1] = np.array(rcoeffs)
coeffs[0,0] = 0.
coeffs[1,0] = bin_to_dec(my_binary_repr(f_x(bounds[0]), n1, nint=nint1, phase=phase), nint=nint1, phase=phase)
# The number of integer bits of A1, A0 and the result
nint0 = get_nint(coeffs[0])
nint1 = get_nint(coeffs[1])
nint = nintx + nint0
if nswitch:
# The number of precision bits of the result
npres = npresx + npres0
# The total number of bits of A1, A0 and the result
n0 = npres0 + nint0 + 1
n1 = npres1 + nint1 + 1
n = npres + nint + 1
else:
npres = n - nint - 1
npres0 = npres - npresx
n0 = npres0 + nint0 + 1
npres1 = n0 - nint1 - 1
n1 = npres1 + nint1 + 1
ys_rnd = piecewise_poly(xs, coeffs.T, bounds)
A1x = piecewise_poly(xs, np.array([coeffs[0],np.zeros(len(coeffs[1]))]).T, bounds)
nint = get_nint([A1x, ys_rnd])
if nswitch:
n = npres + nint + 1
nintcs = np.array([[nint0,nint1]])
if 16*(2**(n0+n+nx+m))/2**20>7568:
raise ValueError('Too many qubits!',n0+n+nx+m)
if label_swap:
coeffs[0] = np.array([coeffs[0,-1],*coeffs[0,:-1]])
coeffs[1] = np.array([coeffs[1,-1],*coeffs[1,:-1]])
return n, n0, nint, nintcs, coeffs, bounds[:-1], npres0, npres1
def get_bound_coeffs(func, bounds, norder, reterr=False):
if np.array(bounds).ndim==0:
print('Bounds must be a list of two entries!')
if len(bounds)==1:
print('Bounds must be a list of two entries!')
coeffs = []
errs = []
for i in np.arange(len(bounds))[:-1]:
coeffs_, err_ = run_remez(func, bounds[i], bounds[i+1], norder)
coeffs.append(np.array(coeffs_))
errs.append(err_)
if reterr:
return np.array(coeffs), np.array(errs)
else:
return np.array(coeffs)
def _get_chebyshev_nodes(n, a, b):
nodes = [.5 * (a + b) + .5 * (b - a) * np.cos((2 * k + 1) / (2. * n) * np.pi)
for k in range(n)]
return nodes
def _get_errors(exact_values, poly_coeff, nodes):
ys = np.polyval(poly_coeff, nodes)
for i in range(len(ys)):
ys[i] = abs(ys[i] - exact_values[i])
return ys
def run_remez(fun, a, b, d=5, odd=False, even=False, tol=1.e-13):
finished = False
# initial set of points for the interpolation
cn = _get_chebyshev_nodes(d + 2, a, b)
# mesh on which we'll evaluate the error
cn2 = _get_chebyshev_nodes(100 * d, a, b)
# do at most 50 iterations and cancel if we "lose" an interpolation
# point
it = 0
while not finished and len(cn) == d + 2 and it < 50:
it += 1
# set up the linear system of equations for Remez' algorithm
b = np.array([fun(c) for c in cn])
A = np.matrix(np.zeros([d + 2,d + 2]))
for i in range(d + 2):
x = 1.
if odd:
x *= cn[i]
for j in range(d + 2):
A[i, j] = x
x *= cn[i]
if odd or even:
x *= cn[i]
A[i, -1] = (-1)**(i + 1)
# this will give us a polynomial interpolation
res = np.linalg.solve(A, b)
# add padding for even/odd polynomials
revlist = reversed(res[0:-1])
sc_coeff = []
for c in revlist:
sc_coeff.append(c)
if odd or even:
sc_coeff.append(0)
if even:
sc_coeff = sc_coeff[0:-1]
# evaluate the approximation error
errs = _get_errors([fun(c) for c in cn2], sc_coeff, cn2)
maximum_indices = []
# determine points of locally maximal absolute error
if errs[0] > errs[1]:
maximum_indices.append(0)
for i in range(1, len(errs) - 1):
if errs[i] > errs[i-1] and errs[i] > errs[i+1]:
maximum_indices.append(i)
if errs[-1] > errs[-2]:
maximum_indices.append(-1)
# and choose those as new interpolation points
# if not converged already.
finished = True
for idx in maximum_indices[1:]:
if abs(errs[idx] - errs[maximum_indices[0]]) > tol:
finished = False
cn = [cn2[i] for i in maximum_indices]
return sc_coeff, max(abs(errs))
def PhaseEst(circ, qreg, qanc, A_gate, wrap=False, inverse=False, do_swaps=True, reverse_bits=False, label='QPE'):
n = len(qreg)
nanc = len(qanc)
if inverse:
wrap = True
if wrap:
qreg = QuantumRegister(n, 'q_reg')
qanc = QuantumRegister(nanc, 'q_anc')
circ = QuantumCircuit(qreg, qanc)
circ.h(qanc);
for i in np.arange(nanc):
A_gate_i = A_gate.power(-2.**(i)).control(1)
circ.append(A_gate_i, [qanc[i], *qreg]);
iqft_gate = QFT(circ, qanc, do_swaps=do_swaps, wrap=True, inverse=True)
if reverse_bits:
circ.append(iqft_gate, qanc[::-1]);
else:
circ.append(iqft_gate, qanc);
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def HHL(circ, qb, qanc, qtarg, A, t=2.*np.pi, scaling=None, wrap=False, inverse=False, phase=True, label='HHL'):
n = len(qb)
nanc = len(qanc)
if inverse:
wrap = True
if wrap:
qb = QuantumRegister(n, 'b')
qanc = QuantumRegister(nanc, 'anc')
qtarg = QuantumRegister(1, 'targ')
circ = QuantumCircuit(qb, qanc, qtarg)
# Define unitary operator given matrix A and evolution time t
A_gate = HamiltonianGate(A, t)
# Apply phase estimation
qe_gate = PhaseEst(circ, qb, qanc, A_gate, wrap=True, do_swaps=False, reverse_bits=True)
circ.append(qe_gate, [*qb, *qanc]);
# Apply ExactReciprocal to rotate the target qubit proportionally to the given scaling and the inverse of the
# values stored in the computational basis of the ancillary register
rec_gate = ExactReciprocal(nanc, scaling=scaling, neg_vals=phase).to_gate()
circ.append(rec_gate, [*qanc[::-1], qtarg]);
# Apply the inverse phase estimation
qe_gate_inv = PhaseEst(circ, qb, qanc, A_gate, wrap=True, inverse=True, do_swaps=False, reverse_bits=True)
circ.append(qe_gate_inv, [*qb, *qanc]);
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
def QGPR(circ, qreg, qanc, qtarg, qcont, v_gate, u_gate, A, t, scaling, wrap=False, inverse=False, neg_vals=True, label='QGPR'):
n = len(qreg)
nanc = len(qanc)
if inverse:
wrap = True
if wrap:
qcont = QuantumRegister(1, 'q_cont')
qtarg = QuantumRegister(1, 'q_targ')
qreg = QuantumRegister(n, 'q_reg')
qanc = QuantumRegister(nanc, 'anc')
circ = QuantumCircuit(qreg, qanc, qtarg, qcont)
circ.h(qcont);
circ.append(v_gate.control(1), [qcont, *qreg]);
circ.x(qcont);
circ.cx(qcont, qtarg);
circ.append(u_gate.control(1), [qcont, *qreg]);
circ.x(qcont);
hhl_gate = HHL(circ, qreg, qanc, qtarg, A, t=t, scaling=scaling, wrap=True).control(1)
circ.append(hhl_gate, [qcont, *qreg, *qanc, qtarg]);
if wrap:
circ = circ.to_gate()
circ.label = label
if inverse:
circ = circ.inverse()
circ.label = label+'\dag'
return circ
|
https://github.com/googlercolin/Qiskit-Course
|
googlercolin
|
import numpy as np
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile, assemble, Aer, IBMQ, execute
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_bloch_multivector, plot_histogram
from qiskit_textbook.problems import dj_problem_oracle
from qiskit.providers.ibmq import least_busy
from qiskit.tools.jupyter import *
provider = IBMQ.load_account()
def lab1_ex1():
qc = QuantumCircuit(1)
qc.x(0)
return qc
state = Statevector.from_instruction(lab1_ex1())
plot_bloch_multivector(state)
def lab1_ex2():
qc = QuantumCircuit(1)
qc.h(0)
return qc
state = Statevector.from_instruction(lab1_ex2())
plot_bloch_multivector(state)
def lab1_ex3():
qc = QuantumCircuit(1)
qc.x(0)
qc.h(0)
return qc
state = Statevector.from_instruction(lab1_ex3())
plot_bloch_multivector(state)
def lab1_ex4():
qc = QuantumCircuit(1)
qc.x(0)
qc.h(0)
qc.s(0)
return qc
state = Statevector.from_instruction(lab1_ex4())
plot_bloch_multivector(state)
def lab1_ex5():
qc = QuantumCircuit(2,2) # this time, we not only want two qubits, but also two classical bits for the measurement
qc.h(0)
qc.x(1)
qc.cx(0,1)
return qc
qc = lab1_ex5()
qc.draw() # we draw the circuit
qc.measure_all() # we measure all the qubits
backend = Aer.get_backend('qasm_simulator') # we choose the simulator as our backend
counts = execute(qc, backend, shots = 1000).result().get_counts() # we run the simulation and get the counts
plot_histogram(counts) # let us plot a histogram to see the possible outcomes and corresponding probabilities
def lab1_ex6():
qc = QuantumCircuit(3,3)
qc.x(0)
qc.h(0)
qc.x(1)
qc.x(2)
qc.cx(0,1)
qc.cx(1,2)
return qc
qc = lab1_ex6()
qc.draw() # we draw the circuit
oraclenr = 2 # determines the oracle (can range from 1 to 5)
oracle = dj_problem_oracle(oraclenr) # gives one out of 5 oracles
oracle.name = "DJ-Oracle"
def dj_classical(n, input_str):
# build a quantum circuit with n qubits and 1 classical readout bit
dj_circuit = QuantumCircuit(n+1,1)
# Prepare the initial state corresponding to your input bit string
for i in range(n):
if input_str[i] == '1':
dj_circuit.x(i)
# append oracle
dj_circuit.append(oracle, range(n+1))
# measure the fourth qubit
dj_circuit.measure(n,0)
return dj_circuit
n = 4 # number of qubits
input_str = '1111'
dj_circuit = dj_classical(n, input_str)
dj_circuit.draw() # draw the circuit
input_str = '1011'
dj_circuit = dj_classical(n, input_str)
qasm_sim = Aer.get_backend('qasm_simulator')
transpiled_dj_circuit = transpile(dj_circuit, qasm_sim)
qobj = assemble(transpiled_dj_circuit, qasm_sim)
results = qasm_sim.run(qobj).result()
answer = results.get_counts()
plot_histogram(answer)
def lab1_ex7():
min_nr_inputs = 2 # put your answer here, then uncomment
max_nr_inputs = (2**n)/2 + 1 # put your answer here, then uncomment
return [min_nr_inputs, max_nr_inputs]
n=4
def psi_0(n):
qc = QuantumCircuit(n+1,n)
# Build the state (|00000> - |10000>)/sqrt(2)
qc.x(4)
qc.h(4)
qc.barrier()
return qc
dj_circuit = psi_0(n)
dj_circuit.draw()
def psi_1(n):
# obtain the |psi_0> = (|00000> - |10000>)/sqrt(2) state
qc = psi_0(n)
# create the superposition state |psi_1>
for i in range(4):
qc.h(i)
return qc
dj_circuit = psi_1(n)
dj_circuit.draw()
def psi_2(oracle,n):
# circuit to obtain psi_1
qc = psi_1(n)
# append the oracle
qc.append(oracle, range(n+1))
return qc
dj_circuit = psi_2(oracle, n)
dj_circuit.draw()
def lab1_ex8(oracle, n): # note that this exercise also depends on the code in the functions psi_0 (In [24]) and psi_1 (In [25])
qc = psi_2(oracle, n)
# apply n-fold hadamard gate
for i in range(n):
qc.h(i)
qc.barrier()
# add the measurement by connecting qubits to classical bits
for j in range(n):
qc.measure(j, j)
return qc
dj_circuit = lab1_ex8(oracle, n)
dj_circuit.draw()
qasm_sim = Aer.get_backend('qasm_simulator')
transpiled_dj_circuit = transpile(dj_circuit, qasm_sim)
qobj = assemble(transpiled_dj_circuit)
results = qasm_sim.run(qobj).result()
answer = results.get_counts()
plot_histogram(answer)
backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= (n+1) and not
x.configuration().simulator and x.status().operational==True))
print('least busy backend: ', backend)
%qiskit_job_watcher
job = execute(dj_circuit, backend=backend, shots=1024, optimization_level=3)
# Get results of computation
results = job.result()
answer = results.get_counts()
plot_histogram(answer)
# Jobs I ran before
backend = provider.get_backend('ibmq_quito')
old_job = backend.retrieve_job('61cbfe7be867009014a0362e')
results = old_job.result()
answer = results.get_counts()
plot_histogram(answer)
|
https://github.com/googlercolin/Qiskit-Course
|
googlercolin
|
import numpy as np
from mitiq import cdr, Observable, PauliString, Executor
import cirq
from cirq.contrib.qasm_import import circuit_from_qasm
from cirq.circuits.qasm_output import QasmUGate
from qiskit import *
from qiskit import transpile, assemble, IBMQ
from qiskit.visualization import *
from qiskit import Aer, QuantumCircuit
from qiskit.circuit import ParameterVector
pi = np.pi
feature_dim = 2
reps = 2
duplicates = 1
feature_map_circuit = QuantumCircuit(feature_dim, name='feature_map_circuit')
# x = ParameterVector('x', feature_dim * reps)
x = [0.1, 0.2]
for i in range(reps):
for i in range(feature_dim):
feature_map_circuit.h(i)
feature_map_circuit.rz(2.0*x[0], 0)
feature_map_circuit.rz(2.0*x[1], 1)
feature_map_circuit.cnot(0, 1)
feature_map_circuit.rz(2.0*(pi - x[0])*(pi - x[1]), 1)
feature_map_circuit.cnot(0, 1)
feature_map_circuit.draw()
qasm_feature_map = feature_map_circuit.qasm(filename='feature_map.qasm')
print(qasm_feature_map)
cirq_feature_map = circuit_from_qasm(qasm_feature_map)
cirq_3_feature_map = cirq_feature_map * 3
print(cirq_3_feature_map)
from mitiq.interface.mitiq_cirq import compute_density_matrix
compute_density_matrix(cirq_feature_map).round(3)
obs = Observable(PauliString("ZZ"))
print(obs)
def simulate(circuit: cirq.Circuit) -> np.ndarray:
return compute_density_matrix(circuit, noise_level=(0.0,))
simulate(cirq_feature_map).round(3)
ideal_measurement = obs.expectation(cirq_feature_map, simulate).real
print("ideal_measurement = ",ideal_measurement)
unmitigated_measurement = obs.expectation(cirq_feature_map, compute_density_matrix).real
print("unmitigated_measurement = ", unmitigated_measurement)
mitigated_measurement = cdr.execute_with_cdr(
cirq_feature_map,
compute_density_matrix,
observable=obs,
simulator=simulate,
seed=0,
).real
print("mitigated_measurement = ", mitigated_measurement)
from mitiq.zne import scaling
vncdr = cdr.execute_with_cdr(
cirq_feature_map,
compute_density_matrix,
observable=obs,
simulator=simulate,
seed=0,
scale_factors=(1.0, 3.0),
).real
print("vncdr = ", vncdr)
error_unmitigated = abs(unmitigated_measurement-ideal_measurement)
error_mitigated = abs(mitigated_measurement-ideal_measurement)
error_vn_mitigated = abs(vncdr-ideal_measurement)
print("Error (unmitigated):", error_unmitigated)
print("Error (mitigated with CDR):", error_mitigated)
print("Error (mitigated with VNCDR):", error_vn_mitigated)
print("Relative error (unmitigated):", (error_unmitigated/ideal_measurement))
print("Relative error (mitigated with CDR):",
error_mitigated/ideal_measurement)
print("Relative error (mitigated with VNCDR):",
error_vn_mitigated/ideal_measurement)
print(
f"Error reduction with CDR: {(error_unmitigated-error_mitigated)/error_unmitigated :.1%}.")
print(
f"Error reduction with VNCDR: {(error_unmitigated-error_vn_mitigated)/error_unmitigated :.1%}.")
num_qubits = 2
ansatz_circuit = QuantumCircuit(num_qubits, name='ansatz_circuit')
reps = 1
# params = ParameterVector('θ', num_qubits + num_qubits * reps)
params = [0.7, 0.3, 0.5, 1.2]
counter = 0
for i in range(num_qubits):
ansatz_circuit.ry(params[counter], i)
counter += 1
for j in range(reps):
for k in range(num_qubits-1):
ansatz_circuit.cnot(k, k+1)
for m in range(num_qubits):
ansatz_circuit.ry(params[counter], m)
counter += 1
ansatz_circuit.draw()
qasm_ansatz = ansatz_circuit.qasm(filename='ansatz.qasm')
print(qasm_ansatz)
cirq_ansatz = circuit_from_qasm(qasm_ansatz) * 1
print(cirq_ansatz)
compute_density_matrix(cirq_ansatz).round(3)
simulate(cirq_ansatz).round(3)
ideal_measurement = obs.expectation(cirq_ansatz, simulate).real
print("ideal_measurement = ",ideal_measurement)
unmitigated_measurement = obs.expectation(cirq_ansatz, compute_density_matrix).real
print("unmitigated_measurement = ", unmitigated_measurement)
mitigated_measurement = cdr.execute_with_cdr(
cirq_ansatz,
compute_density_matrix,
observable=obs,
simulator=simulate,
seed=0,
).real
print("mitigated_measurement = ", mitigated_measurement)
from mitiq.zne import scaling
vncdr = cdr.execute_with_cdr(
cirq_ansatz,
compute_density_matrix,
observable=obs,
simulator=simulate,
seed=0,
scale_factors=(1.0, 3.0),
).real
print("vncdr = ", vncdr)
error_unmitigated = abs(unmitigated_measurement-ideal_measurement)
error_mitigated = abs(mitigated_measurement-ideal_measurement)
error_vn_mitigated = abs(vncdr-ideal_measurement)
print("Error (unmitigated):", error_unmitigated)
print("Error (mitigated with CDR):", error_mitigated)
print("Error (mitigated with VNCDR):", error_vn_mitigated)
print("Relative error (unmitigated):", (error_unmitigated/ideal_measurement))
print("Relative error (mitigated with CDR):",
error_mitigated/ideal_measurement)
print("Relative error (mitigated with VNCDR):",
error_vn_mitigated/ideal_measurement)
print(
f"Error reduction with CDR: {(error_unmitigated-error_mitigated)/error_unmitigated :.1%}.")
print(
f"Error reduction with VNCDR: {(error_unmitigated-error_vn_mitigated)/error_unmitigated :.1%}.")
|
https://github.com/googlercolin/Qiskit-Course
|
googlercolin
|
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 *
from qiskit.providers.aer import QasmSimulator
# Loading your IBM Quantum account(s)
provider = IBMQ.load_account()
import math
desired_state = [
0,
0,
0,
0,
0,
1 / math.sqrt(2),
0,
1 / math.sqrt(2)]
qc = QuantumCircuit(3)
qc.initialize(desired_state, [0,1,2])
qc.decompose().decompose().decompose().decompose().decompose().draw()
desired_state = [
1 / math.sqrt(15.25) * 1.5,
0,
1 / math.sqrt(15.25) * -2,
1 / math.sqrt(15.25) * 3]
qc = QuantumCircuit(2)
qc.initialize(desired_state, [0,1])
qc.decompose().decompose().decompose().decompose().decompose().draw()
qc = QuantumCircuit(3)
qc.ry(0, 0)
qc.ry(math.pi/4, 1)
qc.ry(math.pi/2, 2)
qc.draw()
from qiskit.circuit.library import ZZFeatureMap
circuit = ZZFeatureMap(3, reps=1, insert_barriers=True)
circuit.decompose().draw()
x = [0.1, 0.2, 0.3]
encode = circuit.bind_parameters(x)
encode.decompose().draw()
from qiskit.circuit.library import EfficientSU2
circuit = EfficientSU2(num_qubits=3, reps=1, insert_barriers=True)
circuit.decompose().draw()
x = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2]
encode = circuit.bind_parameters(x)
encode.decompose().draw()
|
https://github.com/googlercolin/Qiskit-Course
|
googlercolin
|
import numpy as np
from qiskit.quantum_info import state_fidelity, Statevector
def getStatevector(circuit):
return Statevector(circuit).data
import warnings
warnings.filterwarnings('ignore')
def P_haar(N, F):
if F == 1:
return 0
else:
return (N - 1) * ((1 - F) ** (N - 2))
def KL(P, Q):
epsilon = 1e-8
kl_divergence = 0.0
for p, q in zip(P, Q):
kl_divergence += p * np.log( (p + epsilon) / (q + epsilon) )
return abs(kl_divergence)
def expressibility(qubits, sampler, *, bins=100, epoch=3000, layer=1, encode=False, return_detail=False):
unit = 1 / bins
limits = []
probabilities = np.array([0] * bins)
for i in range(1, bins + 1):
limits.append(unit * i)
for i in range(epoch):
circuit_1 = sampler(layer=layer, qubits=qubits)
circuit_2 = sampler(layer=layer, qubits=qubits)
f = state_fidelity(
getStatevector(circuit_1),
getStatevector(circuit_2)
)
for j in range(bins):
if f <= limits[j]:
probabilities[j] += 1
break
pHaar_vqc = [ P_haar(2 ** qubits, f - (unit/2)) / bins for f in limits]
probabilities = [ p / epoch for p in probabilities ]
if return_detail:
return pHaar_vqc, probabilities
else:
return KL(probabilities, pHaar_vqc)
|
https://github.com/googlercolin/Qiskit-Course
|
googlercolin
|
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
from torchsummary import summary
import qiskit
from qiskit import transpile, assemble, IBMQ
from qiskit.visualization import *
from qiskit.providers.aer import AerSimulator
from qiskit.test.mock import FakeBelem
provider = IBMQ.load_account()
class QuantumCircuit:
"""
This class provides a simple interface for interaction
with the quantum circuit
"""
def __init__(self, n_qubits, backend, shots):
# --- Circuit definition ---
self._circuit = qiskit.QuantumCircuit(n_qubits)
all_qubits = [i for i in range(n_qubits)]
self.theta = qiskit.circuit.Parameter('theta')
self._circuit.h(all_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):
t_qc = transpile(self._circuit,
self.backend)
qobj = assemble(t_qc,
shots=self.shots,
parameter_binds = [{self.theta: theta} for theta in thetas])
job = self.backend.run(qobj)
result = job.result().get_counts()
# print(f"Result is {result}")
counts = np.array(list(result.values()))
states = np.array(list(result.keys())).astype(float)
# Compute probabilities for each state
probabilities = counts / self.shots
# Get state expectation
expectation = np.sum(states * probabilities)
return np.array([expectation])
# Using a noisy simulator
noisy_backend = FakeBelem()
simulator = AerSimulator.from_backend(noisy_backend)
# simulator = qiskit.Aer.get_backend('aer_simulator')
circuit = QuantumCircuit(1, simulator, 100)
print('Expected value for rotation pi {}'.format(circuit.run([np.pi])[0]))
circuit._circuit.draw('mpl')
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
expectation_z = ctx.quantum_circuit.run(input[0].tolist())
result = torch.tensor([expectation_z])
ctx.save_for_backward(input, result)
return result
@staticmethod
def backward(ctx, grad_output):
""" Backward pass computation """
input, expectation_z = ctx.saved_tensors
input_list = np.array(input.tolist())
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)):
expectation_right = ctx.quantum_circuit.run(shift_right[i])
expectation_left = ctx.quantum_circuit.run(shift_left[i])
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
class Hybrid(nn.Module):
""" Hybrid quantum - classical layer definition """
def __init__(self, backend, shots, shift):
super(Hybrid, self).__init__()
self.quantum_circuit = QuantumCircuit(2, backend, shots) # initialize 2 qubit VQC
self.shift = shift
def forward(self, input):
return HybridFunction.apply(input, self.quantum_circuit, self.shift)
# Concentrating on the first 100 samples
n_samples = 100
X_train = datasets.MNIST(root='./data', train=True, download=True,
transform=transforms.Compose([transforms.ToTensor()]))
# 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]
train_loader = torch.utils.data.DataLoader(X_train, batch_size=1, 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].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.item()))
n_samples_show -= 1
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)
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
# 1 input image channel, 6 output channels, 5x5 square convolution
self.conv1 = nn.Conv2d(1, 6, kernel_size=5)
# 6 input channels, 16 output channels, 5x5 square convolution
self.conv2 = nn.Conv2d(6, 16, kernel_size=5)
self.dropout = nn.Dropout2d()
self.fc1 = nn.Linear(256, 64) # fc stands for fully connected layer
self.fc2 = nn.Linear(64, 2) # output 1 to be run on 2 qubit VQC
# self.hybrid = Hybrid(qiskit.Aer.get_backend('aer_simulator'), 100, np.pi / 2)
self.hybrid = [Hybrid(qiskit.Aer.get_backend('aer_simulator'), 100, np.pi / 2) for i in range(2)]
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)
# Here is where the matrixes/channels are flattened into one long vector
x = torch.flatten(x, start_dim=1)
# x = x.view(1, -1) # make it the same shape as output
x = F.relu(self.fc1(x)) # ReLu is applied to fc1(x) where fc1 is channel which it takes an input of 256 and outputs a vector of a size of 64.
x = self.fc2(x) # Final step where input is a size of 64 and output is a size of 10.
x = torch.chunk(x, 2, dim=1)
# x = self.hybrid(x)
x = tuple([hybr(x_) for hybr, x_ in zip(self.hybrid, x)])
return torch.cat(x, -1)
# class Net(nn.Module):
# def __init__(self):
# super(Net, self).__init__()
# self.conv1 = nn.Conv2d(1, 6, kernel_size=5)
# self.conv2 = nn.Conv2d(6, 16, kernel_size=5)
# self.dropout = nn.Dropout2d()
# self.fc1 = nn.Linear(256, 64)
# self.fc2 = nn.Linear(64, 1)
# self.hybrid = Hybrid(qiskit.Aer.get_backend('aer_simulator'), 100, np.pi / 2)
# 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(1, -1)
# x = F.relu(self.fc1(x))
# x = self.fc2(x)
# x = self.hybrid(x)
# return torch.cat((x, 1 - x), -1)
model = Net()
summary(model, (1, 28, 28), device='cpu')
optimizer = optim.Adam(model.parameters(), lr=0.001)
loss_func = nn.NLLLoss()
epochs = 20
loss_list = []
model.train()
for epoch in range(epochs):
total_loss = []
for batch_idx, (data, target) in enumerate(train_loader):
optimizer.zero_grad() # clears old gradients from the last step (otherwise you’d just accumulate the gradients from all loss.backward() calls).
# Forward pass
output = model(data)
# Calculating loss
loss = loss_func(output, target)
# Backward pass
loss.backward() # computes the derivative of the loss w.r.t. the parameters (or anything requiring gradients) using backpropagation.
# Optimize the weights
optimizer.step() # causes the optimizer to take a step based on the gradients of the parameters.
total_loss.append(loss.item())
loss_list.append(sum(total_loss)/len(total_loss))
print('Training [{:.0f}%]\tLoss: {:.4f}'.format(
100. * (epoch + 1) / epochs, loss_list[-1]))
plt.plot(loss_list)
plt.title('Hybrid NN Training Convergence')
plt.xlabel('Training Iterations')
plt.ylabel('Negative Log Likelihood Loss')
model.eval()
with torch.no_grad():
correct = 0
for batch_idx, (data, target) in enumerate(test_loader):
output = model(data)
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) * 100)
)
n_samples_show = 6
count = 0
fig, axes = plt.subplots(nrows=1, ncols=n_samples_show, figsize=(10, 3))
model.eval()
with torch.no_grad():
for batch_idx, (data, target) in enumerate(test_loader):
if count == n_samples_show:
break
output = model(data)
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
|
https://github.com/googlercolin/Qiskit-Course
|
googlercolin
|
# !pip install -r 'requirements.txt' --quiet
import numpy as np
import torch
from torchvision.transforms import ToTensor
from torch import no_grad
from torchvision import datasets
import torch.optim as optim
from torch.nn import (Module, Conv2d, Linear, Dropout2d, NLLLoss, MaxPool2d, Flatten, Sequential, ReLU)
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader
from qiskit import *
from qiskit import transpile, assemble, IBMQ
from qiskit.visualization import *
from qiskit import Aer, QuantumCircuit
from qiskit.utils import QuantumInstance, algorithm_globals
from qiskit.opflow import AerPauliExpectation
from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap
from qiskit.circuit import ParameterVector
from qiskit_machine_learning.neural_networks import CircuitQNN, TwoLayerQNN
from qiskit_machine_learning.connectors import TorchConnector
import qiskit.providers.fake_provider as fake
from qiskit.providers.aer.noise import NoiseModel
from qiskit.providers.aer import AerSimulator
import matplotlib.pyplot as plt
provider = IBMQ.load_account()
# Declare Quantum instance
noisy_backend = provider.get_backend('ibmq_manila')
backend_sim = AerSimulator.from_backend(noisy_backend)
qi = QuantumInstance(backend_sim)
print(backend_sim)
### Training and test data downloaded from FashionMNIST and transformed into tensors ###
training_data = datasets.FashionMNIST(
root="data",
train=True,
download=True,
transform=ToTensor()
)
test_data = datasets.FashionMNIST(
root="data",
train=False,
download=True,
transform=ToTensor()
)
### Inspecting the images in the training data set with their labels ###
labels_map = {
0: "T-Shirt",
1: "Trouser",
2: "Pullover",
3: "Dress",
4: "Coat",
5: "Sandal",
6: "Shirt",
7: "Sneaker",
8: "Bag",
9: "Ankle Boot",
}
figure = plt.figure(figsize=(8, 8))
cols, rows = 3, 3
for i in range(1, cols * rows + 1):
sample_idx = torch.randint(len(training_data), size=(1,)).item()
img, label = training_data[sample_idx]
figure.add_subplot(rows, cols, i)
plt.title(labels_map[label])
plt.axis("off")
plt.imshow(img.squeeze(), cmap="gray")
plt.show()
### Load training data into Torch DataLoader ###
X_train = training_data
n_samples = 500
batch_size = 64
# 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]
# A torch dataloader is defined with filtered data
train_loader = DataLoader(X_train, batch_size=64, shuffle=True)
# Load test data into Torch DataLoader
X_test = test_data
# 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=64, shuffle=True)
### Two layer QNN constructed ###
feature_map_lib = ZZFeatureMap(feature_dimension=2, entanglement='linear')
ansatz_lib = RealAmplitudes(2, reps=1, entanglement='linear')
print(feature_map_lib.decompose())
print(ansatz_lib.decompose())
qnn2 = TwoLayerQNN(2, feature_map_lib, ansatz_lib, input_gradients=True,
exp_val=AerPauliExpectation(), quantum_instance=qi)
print(qnn2.operator)
### Torch NN module from Qiskit ###
class Net(Module):
def __init__(self):
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
# Apply torch connector, weights chosen
self.qnn = TorchConnector(qnn2)
# 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 torch.cat((x, 1 - x), -1)
### Model trained and the loss computed ###
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.001)
loss_func = nn.NLLLoss()
epochs = 20
loss_list = []
model.train()
for epoch in range(epochs):
total_loss = []
for batch_idx, (data, target) in enumerate(train_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
loss = loss_func(output, target)
# Backward pass
loss.backward()
# Optimize the weights
optimizer.step()
total_loss.append(loss.item())
loss_list.append(sum(total_loss)/len(total_loss))
print('Training [{:.0f}%]\tLoss: {:.4f}'.format(
100. * (epoch + 1) / epochs, loss_list[-1]))
### Loss convergence plotted ###
plt.plot(loss_list)
plt.title('Hybrid NN Training Convergence')
plt.xlabel('Training Iterations')
plt.ylabel('Neg. Log Likelihood Loss')
plt.show()
### Model evaluated ###
model.eval()
with torch.no_grad():
correct = 0
for batch_idx, (data, target) in enumerate(test_loader):
output = model(data)
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))
### Predicted images displayed. Either T-shirt or Trouser ###
n_samples_show = 6
count = 0
fig, axes = plt.subplots(nrows=1, ncols=n_samples_show, figsize=(15, 5))
model.eval()
with no_grad():
for batch_idx, (data, target) in enumerate(test_loader):
if count == n_samples_show:
break
output = model(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([])
if pred.item() == 0:
axes[count].set_title('Predicted item: T-Shirt')
elif pred.item() == 1:
axes[count].set_title('Predicted item: Trouser')
count += 1
pi = np.pi
feature_dim = 2
reps = 2
duplicates = 1
feature_map_circuit = QuantumCircuit(feature_dim, name='feature_map_circuit')
x = ParameterVector('x', feature_dim * reps)
for i in range(reps):
for i in range(feature_dim):
feature_map_circuit.h(i)
feature_map_circuit.p(2.0*x[0], 0)
feature_map_circuit.p(2.0*x[1], 1)
feature_map_circuit.cnot(0, 1)
feature_map_circuit.p(2.0*(pi - x[0])*(pi - x[1]), 1)
feature_map_circuit.cnot(0, 1)
feature_map_circuit.draw()
num_qubits = 2
ansatz_circuit = QuantumCircuit(num_qubits, name='ansatz_circuit')
reps = 1
params = ParameterVector('θ', num_qubits + num_qubits * reps)
counter = 0
for i in range(num_qubits):
ansatz_circuit.ry(params[counter], i)
counter += 1
for j in range(reps):
for k in range(num_qubits-1):
ansatz_circuit.cnot(k, k+1)
for m in range(num_qubits):
ansatz_circuit.ry(params[counter], m)
counter += 1
ansatz_circuit.draw()
qnn2 = TwoLayerQNN(2, feature_map_circuit, ansatz_circuit, input_gradients=True,
exp_val=AerPauliExpectation(), quantum_instance=qi)
print(qnn2.operator)
### Torch NN module from Qiskit ###
class Net(Module):
def __init__(self):
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
# Apply torch connector, weights chosen
self.qnn = TorchConnector(qnn2)
# 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 torch.cat((x, 1 - x), -1)
### Model trained and the loss computed ###
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.001)
loss_func = nn.NLLLoss()
epochs = 20
loss_list = []
model.train()
for epoch in range(epochs):
total_loss = []
for batch_idx, (data, target) in enumerate(train_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
loss = loss_func(output, target)
# Backward pass
loss.backward()
# Optimize the weights
optimizer.step()
total_loss.append(loss.item())
loss_list.append(sum(total_loss)/len(total_loss))
print('Training [{:.0f}%]\tLoss: {:.4f}'.format(
100. * (epoch + 1) / epochs, loss_list[-1]))
### Loss convergence plotted ###
plt.plot(loss_list)
plt.title('Hybrid NN Training Convergence')
plt.xlabel('Training Iterations')
plt.ylabel('Neg. Log Likelihood Loss')
plt.show()
torch.save(model.state_dict(
), 'Models/defaultZZDefaultRealAmp.pth')
### Model evaluated ###
model.eval()
with torch.no_grad():
correct = 0
for batch_idx, (data, target) in enumerate(test_loader):
output = model(data)
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))
### Predicted images displayed. Either T-shirt or Trouser ###
n_samples_show = 6
count = 0
fig, axes = plt.subplots(nrows=1, ncols=n_samples_show, figsize=(15, 5))
model.eval()
with no_grad():
for batch_idx, (data, target) in enumerate(test_loader):
if count == n_samples_show:
break
output = model(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([])
if pred.item() == 0:
axes[count].set_title('Predicted item: T-Shirt')
elif pred.item() == 1:
axes[count].set_title('Predicted item: Trouser')
count += 1
|
https://github.com/googlercolin/Qiskit-Course
|
googlercolin
|
import numpy as np
import torch
from torchvision.transforms import ToTensor
from torch import no_grad
from torchvision import datasets
import torch.optim as optim
from torch.nn import (Module, Conv2d, Linear, Dropout2d, NLLLoss, MaxPool2d, Flatten, Sequential, ReLU)
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader
from qiskit import *
from qiskit import transpile, assemble, IBMQ
from qiskit.visualization import *
from qiskit import Aer, QuantumCircuit
from qiskit.utils import QuantumInstance, algorithm_globals
from qiskit.opflow import AerPauliExpectation
from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap
from qiskit.circuit import ParameterVector
from qiskit_machine_learning.neural_networks import CircuitQNN, TwoLayerQNN
from qiskit_machine_learning.connectors import TorchConnector
import qiskit.providers.fake_provider as fake
from qiskit.providers.aer.noise import NoiseModel
from qiskit.providers.aer import AerSimulator, QasmSimulator
import matplotlib.pyplot as plt
provider = IBMQ.load_account()
# Declare Quantum instance
noisy_backend = provider.get_backend('ibmq_manila')
backend_sim = AerSimulator.from_backend(noisy_backend)
qi = QuantumInstance(backend_sim)
print(backend_sim)
### Training and test data downloaded from FashionMNIST and transformed into tensors ###
training_data = datasets.FashionMNIST(
root="data",
train=True,
download=True,
transform=ToTensor()
)
test_data = datasets.FashionMNIST(
root="data",
train=False,
download=True,
transform=ToTensor()
)
### Inspecting the images in the training data set with their labels ###
labels_map = {
0: "T-Shirt",
1: "Trouser",
2: "Pullover",
3: "Dress",
4: "Coat",
5: "Sandal",
6: "Shirt",
7: "Sneaker",
8: "Bag",
9: "Ankle Boot",
}
figure = plt.figure(figsize=(8, 8))
cols, rows = 3, 3
for i in range(1, cols * rows + 1):
sample_idx = torch.randint(len(training_data), size=(1,)).item()
img, label = training_data[sample_idx]
figure.add_subplot(rows, cols, i)
plt.title(labels_map[label])
plt.axis("off")
plt.imshow(img.squeeze(), cmap="gray")
plt.show()
### Load training data into Torch DataLoader ###
X_train = training_data
n_samples = 500
batch_size = 64
# 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]
# A torch dataloader is defined with filtered data
train_loader = DataLoader(X_train, batch_size=64, shuffle=True)
# Load test data into Torch DataLoader
X_test = test_data
# 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=64, shuffle=True)
pi = np.pi
feature_dim = 2
reps = 2
duplicates = 3 # only use odd integers here
feature_map_circuit = QuantumCircuit(feature_dim, name=f'feature_map_circuit, duplicates = {duplicates}')
x = ParameterVector('x', feature_dim * reps)
for i in range(reps):
for j in range(feature_dim):
for k in range(duplicates):
feature_map_circuit.h(j)
for m in range(duplicates):
feature_map_circuit.p(2.0*x[0], 0)
feature_map_circuit.p(2.0*x[1], 1)
for m in range(duplicates):
feature_map_circuit.cnot(0, 1)
for m in range(duplicates):
feature_map_circuit.p(2.0*(pi - x[0])*(pi - x[1]), 1)
for m in range(duplicates):
feature_map_circuit.cnot(0, 1)
feature_map_circuit.draw()
num_qubits = 2
ansatz_circuit = QuantumCircuit(num_qubits, name=f'ansatz_circuit, duplicates = {duplicates}')
reps = 1
params = ParameterVector('θ', num_qubits + num_qubits * reps)
counter = 0
for i in range(num_qubits):
for n in range(duplicates):
ansatz_circuit.ry(params[counter], i)
counter += 1
for j in range(reps):
for k in range(num_qubits-1):
for n in range(duplicates):
ansatz_circuit.cnot(k, k+1)
for m in range(num_qubits):
for n in range(duplicates):
ansatz_circuit.ry(params[counter], m)
counter += 1
ansatz_circuit.draw()
qnn2 = TwoLayerQNN(2, feature_map_circuit, ansatz_circuit, input_gradients=True,
exp_val=AerPauliExpectation(), quantum_instance=qi)
print(qnn2.operator)
### Torch NN module from Qiskit ###
class Net(Module):
def __init__(self):
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
# Apply torch connector, weights chosen
self.qnn = TorchConnector(qnn2)
# 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 torch.cat((x, 1 - x), -1)
### Model trained and the loss computed ###
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.001)
loss_func = nn.NLLLoss()
epochs = 20
loss_list = []
model.train()
for epoch in range(epochs):
total_loss = []
for batch_idx, (data, target) in enumerate(train_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
loss = loss_func(output, target)
# Backward pass
loss.backward()
# Optimize the weights
optimizer.step()
total_loss.append(loss.item())
loss_list.append(sum(total_loss)/len(total_loss))
print('Training [{:.0f}%]\tLoss: {:.4f}'.format(
100. * (epoch + 1) / epochs, loss_list[-1]))
### Loss convergence plotted ###
plt.plot(loss_list)
plt.title('Hybrid NN Training Convergence')
plt.xlabel('Training Iterations')
plt.ylabel('Neg. Log Likelihood Loss')
plt.show()
torch.save(model.state_dict(
), 'Models/d3ZZ_d3RealAmp.pth')
### Model evaluated ###
model.eval()
with torch.no_grad():
correct = 0
for batch_idx, (data, target) in enumerate(test_loader):
output = model(data)
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))
### Predicted images displayed. Either T-shirt or Trouser ###
n_samples_show = 6
count = 0
fig, axes = plt.subplots(nrows=1, ncols=n_samples_show, figsize=(15, 5))
model.eval()
with no_grad():
for batch_idx, (data, target) in enumerate(test_loader):
if count == n_samples_show:
break
output = model(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([])
if pred.item() == 0:
axes[count].set_title('Predicted item: T-Shirt')
elif pred.item() == 1:
axes[count].set_title('Predicted item: Trouser')
count += 1
|
https://github.com/googlercolin/Qiskit-Course
|
googlercolin
|
# !pip install -r 'requirements.txt' --quiet
import numpy as np
import torch
from torchvision.transforms import ToTensor
from torch import no_grad
from torchvision import datasets
import torch.optim as optim
from torch.nn import (Module, Conv2d, Linear, Dropout2d, NLLLoss, MaxPool2d, Flatten, Sequential, ReLU)
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader
import qiskit
from qiskit import transpile, assemble
from qiskit.visualization import *
from qiskit import Aer, QuantumCircuit
from qiskit.utils import QuantumInstance
from qiskit.opflow import AerPauliExpectation
from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap
from qiskit_machine_learning.neural_networks import CircuitQNN, TwoLayerQNN
from qiskit_machine_learning.connectors import TorchConnector
import matplotlib.pyplot as plt
# Declare Quantum instance
qi = QuantumInstance(Aer.get_backend('aer_simulator_statevector'))
### Training and test data downloaded from FashionMNIST and transformed into tensors ###
training_data = datasets.FashionMNIST(
root="data",
train=True,
download=True,
transform=ToTensor()
)
test_data = datasets.FashionMNIST(
root="data",
train=False,
download=True,
transform=ToTensor()
)
### Inspecting the images in the training data set with their labels ###
labels_map = {
0: "T-Shirt",
1: "Trouser",
2: "Pullover",
3: "Dress",
4: "Coat",
5: "Sandal",
6: "Shirt",
7: "Sneaker",
8: "Bag",
9: "Ankle Boot",
}
figure = plt.figure(figsize=(8, 8))
cols, rows = 3, 3
for i in range(1, cols * rows + 1):
sample_idx = torch.randint(len(training_data), size=(1,)).item()
img, label = training_data[sample_idx]
figure.add_subplot(rows, cols, i)
plt.title(labels_map[label])
plt.axis("off")
plt.imshow(img.squeeze(), cmap="gray")
plt.show()
### Load training data into Torch DataLoader ###
X_train = training_data
n_samples = 500
batch_size = 64
# 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]
# A torch dataloader is defined with filtered data
train_loader = DataLoader(X_train, batch_size=64, shuffle=True)
# Load test data into Torch DataLoader
X_test = test_data
# 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=64, shuffle=True)
### Two layer QNN constructed ###
feature_map = ZZFeatureMap(feature_dimension=2, entanglement='linear')
ansatz = RealAmplitudes(2, reps=1, entanglement='linear')
qnn2 = TwoLayerQNN(2, feature_map, ansatz, input_gradients=True,
exp_val=AerPauliExpectation(), quantum_instance=qi)
print(qnn2.operator)
### Torch NN module from Qiskit ###
class Net(Module):
def __init__(self):
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
# Apply torch connector, weights chosen
self.qnn = TorchConnector(qnn2)
# 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 torch.cat((x, 1 - x), -1)
### Model trained and the loss computed ###
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.001)
loss_func = nn.NLLLoss()
epochs = 20
loss_list = []
model.train()
for epoch in range(epochs):
total_loss = []
for batch_idx, (data, target) in enumerate(train_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
loss = loss_func(output, target)
# Backward pass
loss.backward()
# Optimize the weights
optimizer.step()
total_loss.append(loss.item())
loss_list.append(sum(total_loss)/len(total_loss))
print('Training [{:.0f}%]\tLoss: {:.4f}'.format(
100. * (epoch + 1) / epochs, loss_list[-1]))
### Loss convergence plotted ###
plt.plot(loss_list)
plt.title('Hybrid NN Training Convergence')
plt.xlabel('Training Iterations')
plt.ylabel('Neg. Log Likelihood Loss')
plt.show()
### Model evaluated ###
model.eval()
with torch.no_grad():
correct = 0
for batch_idx, (data, target) in enumerate(test_loader):
output = model(data)
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))
### Predicted images displayed. Either T-shirt or Trouser ###
n_samples_show = 6
count = 0
fig, axes = plt.subplots(nrows=1, ncols=n_samples_show, figsize=(15, 5))
model.eval()
with no_grad():
for batch_idx, (data, target) in enumerate(test_loader):
if count == n_samples_show:
break
output = model(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([])
if pred.item() == 0:
axes[count].set_title('Predicted item: T-Shirt')
elif pred.item() == 1:
axes[count].set_title('Predicted item: Trouser')
count += 1
|
https://github.com/googlercolin/Qiskit-Course
|
googlercolin
|
import numpy as np
import networkx as nx
import timeit
from qiskit import Aer
from qiskit.circuit.library import TwoLocal
from qiskit_optimization.applications import Maxcut
from qiskit.algorithms import VQE, NumPyMinimumEigensolver
from qiskit.algorithms.optimizers import SPSA
from qiskit.utils import algorithm_globals, QuantumInstance
from qiskit_optimization.algorithms import MinimumEigenOptimizer
# Generating a graph of 6 nodes
n = 6 # Number of nodes in graph
G = nx.Graph()
G.add_nodes_from(np.arange(0, n, 1))
elist = [(0, 1, 1.0), (0, 2, 1.0), (0, 3, 1.0), (1, 2, 1.0), (1, 3, 1.0), (2, 4, 1.0), (3, 5, 1.0), (4, 5, 1.0)]
# tuple is (i,j,weight) where (i,j) is the edge
G.add_weighted_edges_from(elist)
colors = ["y" for node in G.nodes()]
pos = nx.spring_layout(G)
def draw_graph(G, colors, pos):
default_axes = plt.axes(frameon=True)
nx.draw_networkx(G, node_color=colors, node_size=600, alpha=0.6, ax=default_axes, pos=pos)
edge_labels = nx.get_edge_attributes(G, "weight")
nx.draw_networkx_edge_labels(G, pos=pos, edge_labels=edge_labels)
draw_graph(G, colors, pos)
# Computing the weight matrix from the random graph
w = np.zeros([n, n])
for i in range(n):
for j in range(n):
temp = G.get_edge_data(i, j, default=0)
if temp != 0:
w[i, j] = temp["weight"]
print(w)
def brute():
max_cost_brute = 0
for b in range(2**n):
x = [int(t) for t in reversed(list(bin(b)[2:].zfill(n)))] # create reverse of binary combinations from 0 to 2**n to create every possible set
cost = 0
for i in range(n):
for j in range(n):
cost = cost + w[i, j] * x[i] * (1 - x[j])
if cost > max_cost_brute:
max_cost_brute = cost
xmax_brute = x
max_cost_brute = 0
for b in range(2**n):
x = [int(t) for t in reversed(list(bin(b)[2:].zfill(n)))] # create reverse of binary combinations from 0 to 2**n to create every possible set
cost = 0
for i in range(n):
for j in range(n):
cost = cost + w[i, j] * x[i] * (1 - x[j])
if cost > max_cost_brute:
max_cost_brute = cost
xmax_brute = x
print("case = " + str(x) + " cost = " + str(cost))
colors = ["m" if xmax_brute[i] == 0 else "c" for i in range(n)]
draw_graph(G, colors, pos)
print("\nBest solution = " + str(xmax_brute) + " with cost = " + str(max_cost_brute))
time = timeit.timeit(brute, number = 1)
print(f"\nTime taken for brute force: {time}")
max_cut = Maxcut(w)
qp = max_cut.to_quadratic_program()
print(qp.export_as_lp_string())
qubitOp, offset = qp.to_ising()
print("Offset:", offset)
print("Ising Hamiltonian:")
print(str(qubitOp))
# solving Quadratic Program using exact classical eigensolver
exact = MinimumEigenOptimizer(NumPyMinimumEigensolver())
def classical_eigen():
result = exact.solve(qp)
result = exact.solve(qp)
print(result)
time = timeit.timeit(classical_eigen, number = 1)
print(f"\nTime taken for exact classical eigensolver force: {time}")
# Making the Hamiltonian in its full form and getting the lowest eigenvalue and eigenvector
ee = NumPyMinimumEigensolver()
result = ee.compute_minimum_eigenvalue(qubitOp)
x = max_cut.sample_most_likely(result.eigenstate)
print("energy:", result.eigenvalue.real)
print("max-cut objective:", result.eigenvalue.real + offset)
print("solution:", x)
print("solution objective:", qp.objective.evaluate(x))
colors = ["m" if x[i] == 0 else "c" for i in range(n)]
draw_graph(G, colors, pos)
algorithm_globals.random_seed = 99
seed = 1010
backend = Aer.get_backend("aer_simulator_statevector")
quantum_instance = QuantumInstance(backend, seed_simulator=seed, seed_transpiler=seed)
# construct VQE
spsa = SPSA(maxiter=300)
ry = TwoLocal(qubitOp.num_qubits, "ry", "cz", reps=5, entanglement="linear")
vqe = VQE(ry, optimizer=spsa, quantum_instance=quantum_instance)
# run VQE
# def vqe_solve():
# result = vqe.compute_minimum_eigenvalue(qubitOp)
# time = timeit.timeit(vqe_solve, number = 1)
result = vqe.compute_minimum_eigenvalue(qubitOp)
# print results
x = max_cut.sample_most_likely(result.eigenstate)
print("energy:", result.eigenvalue.real)
print("time:", result.optimizer_time)
print("max-cut objective:", result.eigenvalue.real + offset)
print("solution:", x)
print("solution objective:", qp.objective.evaluate(x))
# print(f"\nTime taken for VQE: {time}")
# plot results
colors = ["m" if x[i] == 0 else "c" for i in range(n)]
draw_graph(G, colors, pos)
# create minimum eigen optimizer based on VQE
vqe_optimizer = MinimumEigenOptimizer(vqe)
# solve quadratic program
result = vqe_optimizer.solve(qp)
print(result)
colors = ["m" if result.x[i] == 0 else "c" for i in range(n)]
draw_graph(G, colors, pos)
|
https://github.com/googlercolin/Qiskit-Course
|
googlercolin
|
!pip install mitiq --quiet
import warnings
warnings.filterwarnings(action='ignore') # Optional warning filter
from qiskit import IBMQ
IBMQ.save_account('0238b0afc0dc515fe7987b02706791d1719cb89b68befedc125eded0607e6e9e9f26d3eed482f66fdc45fdfceca3aab2edb9519d96b39e9c78040194b86e7858', overwrite=True)
import qiskit
import qiskit.ignis.verification.randomized_benchmarking as rb
from qiskit.transpiler.passes import RemoveBarriers, RemoveFinalMeasurements
from mitiq.interface import convert_to_mitiq, convert_from_mitiq
n_qubits = 2
depth = 20
qiskit_circuit = rb.randomized_benchmarking_seq(
length_vector=[depth], rb_pattern=[range(n_qubits)], group_gates="0", rand_seed=1,
)[0][0][0]
# Remove Barriers
qiskit_circuit=RemoveBarriers()(qiskit_circuit)
# Remove Measurements
qiskit_circuit=RemoveFinalMeasurements()(qiskit_circuit)
# print(qiskit_circuit)
# Double conversion trick to rename qubit register
circuit = convert_from_mitiq(convert_to_mitiq(qiskit_circuit)[0], "qiskit")
print(f"Randomized benchmarking circuit with {len(circuit)} gates generated.")
print(circuit)
# Set the number of shots
shots = 10 ** 5
# Initialize ideal backend (classical noiseless simulator)
ideal_backend = qiskit.Aer.get_backend('aer_simulator')
# Append measurements
circuit_to_run = circuit.copy()
circuit_to_run.measure_all()
# Run and get count
job = ideal_backend.run(circuit_to_run, shots=shots)
counts = job.result().get_counts()
# Expectation value of A=|00><00|
ideal_value = counts["00"] / shots
ideal_value
from qiskit.test.mock import FakeLima
from qiskit.providers.aer.noise import NoiseModel
# Set the number of shots
shots = 20000
# Select a noisy backend
# noisy_backend = qiskit.IBMQ.load_account().get_backend("ibmq_lima")
noisy_backend = FakeLima() # Simulator with noise model similar to "ibmq_lima"
# Append measurements
circuit_to_run = circuit.copy()
circuit_to_run.measure_all()
# Run and get counts
print(f"Executing circuit with {len(circuit)} gates using {shots} shots.")
job = noisy_backend.run(circuit_to_run, shots=shots)
counts = job.result().get_counts()
# Compute expectation value of the observable A=|0><0|
noisy_value = counts["00"] / shots
noisy_value
def executor(circuit, shots=10 ** 5):
"""Executes the input circuit and returns the noisy expectation value <A>, where A=|00>00|.
"""
# Select a noisy backend
# noisy_backend = qiskit.IBMQ.load_account().get_backend("ibmq_lima")
noisy_backend = FakeLima() # Simulator with noise model similar to "ibmq_lima"
# Append measurements
circuit_to_run = circuit.copy()
circuit_to_run.measure_all()
# Run and get counts
print(f"Executing circuit with {len(circuit)} gates using {shots} shots.")
job = noisy_backend.run(circuit_to_run, shots=shots)
counts = job.result().get_counts()
# Compute expectation value of the observable A=|0><0|
noisy_value = counts["00"] / shots
return noisy_value
noisy_value = executor(circuit)
noisy_value
from mitiq import zne
# By default, noise is scaled by locally folding gates at random, and the default extrapolation is Richardson. Scale factor = 3.
zne_value = zne.execute_with_zne(circuit, executor)
unmitigated_error = abs(ideal_value - noisy_value)
zne_error = abs(ideal_value - zne_value)
print(f"Estimation error without Mitiq : {unmitigated_error}")
print(f"Estimation error with Mitiq (ZNE): {zne_error}")
print(f"ZNE reduced the estimation error by {(unmitigated_error - zne_error) / unmitigated_error :.1%}.")
import mitiq
@mitiq.zne.zne_decorator()
def executor(circuit, shots=10 ** 5):
"""Executes the input circuit and returns the noisy expectation value <A>, where A=|00>00|.
"""
# Select a noisy backend
# noisy_backend = qiskit.IBMQ.load_account().get_backend("ibmq_lima")
noisy_backend = FakeLima() # Simulator with noise model similar to "ibmq_lima"
# Append measurements
circuit_to_run = circuit.copy()
circuit_to_run.measure_all()
# Run and get counts
print(f"Executing circuit with {len(circuit)} gates using {shots} shots.")
job = noisy_backend.run(circuit_to_run, shots=shots)
counts = job.result().get_counts()
# Compute expectation value of the observable A=|0><0|
noisy_value = counts["00"] / shots
return noisy_value
noisy_value = executor(circuit)
noisy_value
# Choose a unitary folding function
noise_scaling_function = zne.scaling.fold_global
noise_scaled_circuit = noise_scaling_function(circuit, scale_factor=3.5)
print(f"The input circuit has {len(circuit)} gates")
print(f"The scaled circuit has {len(noise_scaled_circuit)} gates")
# Examples:
# Richardson extrapolation
# factory = zne.inference.RichardsonFactory(scale_factors = [1, 1.2, 2, 3, 5.5])
# Exponential extrapolation
factory = zne.inference.ExpFactory(scale_factors = [1, 1.5, 2, 3, 3.5], asymptote=0.25)
# Exponential adaptive extrapolation
# factory = zne.inference.AdaExpFactory(steps=10, asymptote=0.25)
zne_value = zne.execute_with_zne(circuit, executor, scale_noise=noise_scaling_function, factory=factory)
unmitigated_error = abs(ideal_value - noisy_value)
zne_error = abs(ideal_value - zne_value)
print(f"Estimation error without Mitiq : {unmitigated_error}")
print(f"Estimation error with Mitiq (ZNE): {zne_error}")
print(f"ZNE reduced the estimation error by {(unmitigated_error - zne_error) / unmitigated_error :.1%}.")
_ = factory.plot_fit()
factory.get_expectation_values()
factory.get_scale_factors()
factory.get_zero_noise_limit()
from mitiq import pec
# Print error probability of CNOT gate
cnot_error_prob = noisy_backend.properties().gate_error("cx", qubits=(0, 1))
cnot_error_prob # a very rough approximation of the error acting on a CNOT gate
# print(qiskit.transpile(circuit, backend=noisy_backend))
from mitiq.pec.representations.depolarizing import represent_operation_with_global_depolarizing_noise
# Define ideal operation that we aim to represent
cnot_circuit = qiskit.QuantumCircuit(qiskit.QuantumRegister(2, name="q"))
cnot_circuit.cx(0, 1)
# Build representation
cnot_rep = represent_operation_with_global_depolarizing_noise(cnot_circuit, noise_level=cnot_error_prob)
print(f"Quasi-probability representation with one-norm {cnot_rep.norm :g} generated.")
print(cnot_rep) # full quasi-probability representation of the CNOT gate
import mitiq.pec.representations.optimal.find_optimal_representation
from functools import partial
# Set number of probabilistically generated circuits
num_samples = 100
# Distribute budget of shots among all circuits
shots_per_circuit = shots // num_samples
pec_executor = partial(executor, shots=shots_per_circuit)
# Run PEC
pec_value = pec.execute_with_pec(
circuit, pec_executor, representations = [cnot_rep], num_samples=num_samples, random_state=0,
)
unmitigated_error = abs(ideal_value - noisy_value)
pec_error = abs(ideal_value - pec_value)
print(f"Estimation error without Mitiq : {unmitigated_error}")
print(f"Estimation error with Mitiq (PEC): {pec_error}")
print(f"PEC reduced the estimation error by {(unmitigated_error - pec_error) / unmitigated_error :.1%}.")
from mitiq.pec import NoisyOperation, OperationRepresentation
def get_richardson_coefficients(scale_factors):
"""Returns the array of Richardson extrapolation coefficients associated
to the input array of scale factors."""
# This is based on the Lagrange interpolation formula
richardson_coeffs = []
for l in scale_factors:
coeff = 1.0
for l_prime in scale_factors:
if l_prime == l:
continue
coeff *= l_prime / (l_prime - l)
richardson_coeffs.append(coeff)
return richardson_coeffs
def represent_operation_with_nepec(ideal_operation, scale_factors):
"""Returns the OperationRepresentation contructed by noise scaling and extrapolation."""
coeffs = get_richardson_coefficients(scale_factors)
basis_expansion = {}
for scale_factor, coeff in zip(scale_factors, coeffs):
scaled_op = NoisyOperation(noise_scaling_function(ideal_operation, scale_factor))
basis_expansion[scaled_op] = coeff
return OperationRepresentation(ideal_operation, basis_expansion)
# scale_factors = [1, 3, 5]
scale_factors = [1, 100] # Large scale factors reduce the PEC sampling cost.
agn_rep = represent_operation_with_nepec(cnot_circuit, scale_factors)
print(f"NEPEC quasi-probability representation with one-norm {agn_rep.norm :g} generated.")
print(agn_rep)
nepec_value = pec.execute_with_pec(
circuit, pec_executor, representations = [agn_rep], num_samples=num_samples, random_state=0,
)
unmitigated_error = abs(ideal_value - noisy_value)
nepec_error = abs(ideal_value - nepec_value)
print(f"Estimation error without Mitiq : {unmitigated_error}")
print(f"Estimation error with Mitiq (NEPEC): {nepec_error}")
print(f"NEPEC reduced the estimation error by {(unmitigated_error - nepec_error) / unmitigated_error :.1%}.")
|
https://github.com/googlercolin/Qiskit-Course
|
googlercolin
|
import numpy as np
from sklearn.datasets.samples_generator import make_blobs
from qiskit.aqua.utils import split_dataset_to_data_and_labels
from sklearn import svm
from utility import breast_cancer_pca
from matplotlib import pyplot as plt
%matplotlib inline
%load_ext autoreload
%autoreload 2
n = 2 # number of principal components kept
training_dataset_size = 20
testing_dataset_size = 10
sample_Total, training_input, test_input, class_labels = breast_cancer_pca(training_dataset_size, testing_dataset_size, n)
data_train, _ = split_dataset_to_data_and_labels(training_input)
data_test, _ = split_dataset_to_data_and_labels(test_input)
print (f"data_train[0].shape: {data_train[0].shape}" )
print (f"data_train[1].shape: {data_train[1].shape}" )
# We use the function of scikit learn to generate linearly separable blobs
centers = [(2.5,0),(0,2.5)]
x, y = make_blobs(n_samples=100, centers=centers, n_features=2,random_state=0,cluster_std=0.5)
fig,ax=plt.subplots(1,2,figsize=(12,4))
ax[0].scatter(data_train[0][:,0],data_train[0][:,1],c=data_train[1])
ax[0].set_title('Breast Cancer dataset');
ax[1].scatter(x[:,0],x[:,1],c=y)
ax[1].set_title('Blobs linearly separable');
plt.scatter(data_train[0][:,0],data_train[0][:,1],c=data_train[1])
plt.title('Breast Cancer dataset');
model= svm.LinearSVC()
model.fit(data_train[0], data_train[1])
#small utility function
# some utility functions
def make_meshgrid(x, y, h=.02):
x_min, x_max = x.min() - 1, x.max() + 1
y_min, y_max = y.min() - 1, y.max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
np.arange(y_min, y_max, h))
return xx, yy
def plot_contours(ax, clf, xx, yy, **params):
Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
out = ax.contourf(xx, yy, Z, **params)
return out
accuracy_train = model.score(data_train[0], data_train[1])
accuracy_test = model.score(data_test[0], data_test[1])
X0, X1 = data_train[0][:, 0], data_train[0][:, 1]
xx, yy = make_meshgrid(X0, X1)
Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
fig,ax=plt.subplots(1,2,figsize=(15,5))
ax[0].contourf(xx, yy, Z, cmap=plt.cm.coolwarm)
ax[0].scatter(data_train[0][:,0], data_train[0][:,1], c=data_train[1])
ax[0].set_title('Accuracy on the training set: '+str(accuracy_train));
ax[1].contourf(xx, yy, Z, cmap=plt.cm.coolwarm)
ax[1].scatter(data_test[0][:,0], data_test[0][:,1], c=data_test[1])
ax[1].set_title('Accuracy on the test set: '+str(accuracy_test));
clf = svm.SVC(gamma = 'scale')
clf.fit(data_train[0], data_train[1]);
accuracy_train = clf.score(data_train[0], data_train[1])
accuracy_test = clf.score(data_test[0], data_test[1])
X0, X1 = data_train[0][:, 0], data_train[0][:, 1]
xx, yy = make_meshgrid(X0, X1)
Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
fig,ax=plt.subplots(1,2,figsize=(15,5))
ax[0].contourf(xx, yy, Z, cmap=plt.cm.coolwarm)
ax[0].scatter(data_train[0][:,0], data_train[0][:,1], c=data_train[1])
ax[0].set_title('Accuracy on the training set: '+str(accuracy_train));
ax[1].contourf(xx, yy, Z, cmap=plt.cm.coolwarm)
ax[1].scatter(data_test[0][:,0], data_test[0][:,1], c=data_test[1])
ax[1].set_title('Accuracy on the test set: '+str(accuracy_test));
import qiskit as qk
# Creating Qubits
q = qk.QuantumRegister(2)
# Creating Classical Bits
c = qk.ClassicalRegister(2)
circuit = qk.QuantumCircuit(q, c)
circuit.draw('mpl')
# Initialize empty circuit
circuit = qk.QuantumCircuit(q, c)
# Hadamard Gate on the first Qubit
circuit.h(q[0])
# CNOT Gate on the first and second Qubits
circuit.cx(q[0], q[1])
# Measuring the Qubits
circuit.measure(q, c)
circuit.draw('mpl')
# Using Qiskit Aer's Qasm Simulator: Define where do you want to run the simulation.
simulator = qk.BasicAer.get_backend('qasm_simulator')
# Simulating the circuit using the simulator to get the result
job = qk.execute(circuit, simulator, shots=100)
result = job.result()
# Getting the aggregated binary outcomes of the circuit.
counts = result.get_counts(circuit)
print (counts)
from qiskit.aqua.components.feature_maps import SecondOrderExpansion
feature_map = SecondOrderExpansion(feature_dimension=2, depth=1)
x = np.array([0.6, 0.3])
#feature_map.construct_circuit(x)
print(feature_map.construct_circuit(x))
from qiskit.aqua.algorithms import QSVM
qsvm = QSVM(feature_map, training_input, test_input)
#from qiskit.aqua import run_algorithm, QuantumInstance
from qiskit.aqua import algorithm, QuantumInstance
from qiskit import BasicAer
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=1024, seed_simulator=10598, seed_transpiler=10598)
result = qsvm.run(quantum_instance)
plt.scatter(training_input['Benign'][:,0], training_input['Benign'][:,1])
plt.scatter(training_input['Malignant'][:,0], training_input['Malignant'][:,1])
length_data = len(training_input['Benign']) + len(training_input['Malignant'])
print("size training set: {}".format(length_data))
#print("Matrix dimension: {}".format(result['kernel_matrix_training'].shape))
print("testing success ratio: ", result['testing_accuracy'])
test_set = np.concatenate((test_input['Benign'], test_input['Malignant']))
y_test = qsvm.predict(test_set, quantum_instance)
plt.scatter(test_set[:, 0], test_set[:,1], c=y_test)
plt.show()
plt.scatter(test_input['Benign'][:,0], test_input['Benign'][:,1])
plt.scatter(test_input['Malignant'][:,0], test_input['Malignant'][:,1])
plt.show()
|
https://github.com/googlercolin/Qiskit-Course
|
googlercolin
|
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 *
from qiskit.providers.aer import QasmSimulator
# Loading your IBM Quantum account(s)
provider = IBMQ.load_account()
from qiskit.circuit.library import RealAmplitudes
ansatz = RealAmplitudes(num_qubits=2, reps=1,
entanglement='linear').decompose()
ansatz.draw()
from qiskit.opflow import Z, I
hamiltonian = Z ^ Z
from qiskit.opflow import StateFn, PauliExpectation
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(ansatz)
pauli_basis = PauliExpectation().convert(expectation)
print(pauli_basis)
from qiskit import Aer
from qiskit.utils import QuantumInstance
from qiskit.opflow import CircuitSampler
quantum_instance = QuantumInstance(Aer.get_backend('qasm_simulator'),
# we'll set a seed for reproducibility
shots = 8192, seed_simulator = 2718,
seed_transpiler = 2718)
sampler = CircuitSampler(quantum_instance)
def evaluate_expectation(x):
value_dict = dict(zip(ansatz.parameters, x))
result = sampler.convert(pauli_basis, params=value_dict).eval()
return np.real(result)
import numpy as np
point = np.random.random(ansatz.num_parameters)
index = 2
eps = 0.2
# make identity vector with a 1 at index ``index``, otherwise 0
e_i = np.identity(point.size)[:, index]
print(e_i)
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
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]
plus = point + eps * e_i
minus = point - eps * e_i
finite_difference = (
evaluate_expectation(plus) - evaluate_expectation(minus)) / 2
print(finite_difference)
shifter = Gradient() # 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]) # now fix and initial point for reproducibility
gradient = Gradient().convert(expectation)
gradient_in_pauli_basis = PauliExpectation().convert(gradient)
sampler = CircuitSampler(quantum_instance)
def evaluate_gradient(x):
value_dict = dict(zip(ansatz.parameters, x))
result = sampler.convert(gradient_in_pauli_basis,
params=value_dict).eval()
return np.real(result)
from qiskit.algorithms.optimizers 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 gradient
initial_point=initial_point # initial point
)
import matplotlib
import matplotlib.pyplot as plt
plt.figure(figsize=(7, 3))
plt.plot(gd_loss, label='vanilla gradient descent')
plt.axhline(-1, ls='--', c='C3', label='target')
plt.ylabel('loss')
plt.xlabel('iterations')
plt.legend()
|
https://github.com/googlercolin/Qiskit-Course
|
googlercolin
|
#!pip install PySCF --upgrade
import networkx as nx
import numpy as np
import plotly.graph_objects as go
import matplotlib as mpl
import pandas as pd
from IPython.display import clear_output
from plotly.subplots import make_subplots
from matplotlib import pyplot as plt
from qiskit import Aer, transpile, assemble, IBMQ, execute
from qiskit import QuantumCircuit
from qiskit.visualization import plot_state_city
from qiskit.algorithms.optimizers import COBYLA, SLSQP, ADAM
from time import time
from copy import copy
from typing import List
from qc_grader.graph_util import display_maxcut_widget, QAOA_widget, graphs
mpl.rcParams['figure.dpi'] = 300
from qiskit.circuit import Parameter, ParameterVector
#Parameters are initialized with a simple string identifier
parameter_0 = Parameter('θ[0]')
parameter_1 = Parameter('θ[1]')
circuit = QuantumCircuit(1)
#We can then pass the initialized parameters as the rotation angle argument to the Rx and Ry gates
circuit.ry(theta = parameter_0, qubit = 0)
circuit.rx(theta = parameter_1, qubit = 0)
circuit.draw('mpl')
parameter = Parameter('θ')
circuit = QuantumCircuit(1)
circuit.ry(theta = parameter, qubit = 0)
circuit.rx(theta = parameter, qubit = 0)
circuit.draw('mpl')
#Set the number of layers and qubits
n=3
num_layers = 2
#ParameterVectors are initialized with a string identifier and an integer specifying the vector length
parameters = ParameterVector('θ', n*(num_layers+1))
circuit = QuantumCircuit(n, n)
for layer in range(num_layers):
#Appending the parameterized Ry gates using parameters from the vector constructed above
for i in range(n):
circuit.ry(parameters[n*layer+i], i)
circuit.barrier()
#Appending the entangling CNOT gates
for i in range(n):
for j in range(i):
circuit.cx(j,i)
circuit.barrier()
#Appending one additional layer of parameterized Ry gates
for i in range(n):
circuit.ry(parameters[n*num_layers+i], i)
circuit.barrier()
circuit.draw('mpl')
print(circuit.parameters)
#Create parameter dictionary with random values to bind
param_dict = {parameter: np.random.random() for parameter in parameters}
print(param_dict)
#Assign parameters using the assign_parameters method
bound_circuit = circuit.assign_parameters(parameters = param_dict)
bound_circuit.draw('mpl')
new_parameters = ParameterVector('Ψ',9)
new_circuit = circuit.assign_parameters(parameters = [k*new_parameters[k] for k in range(9)])
new_circuit.draw('mpl')
#Run the circuit with assigned parameters on Aer's statevector simulator
simulator = Aer.get_backend('statevector_simulator')
result = simulator.run(bound_circuit).result()
statevector = result.get_statevector(bound_circuit)
plot_state_city(statevector)
#The following line produces an error when run because 'circuit' still contains non-assigned parameters
#result = simulator.run(circuit).result()
for key in graphs.keys():
print(key)
graph = nx.Graph()
#Add nodes and edges
graph.add_nodes_from(np.arange(0,6,1))
edges = [(0,1,2.0),(0,2,3.0),(0,3,2.0),(0,4,4.0),(0,5,1.0),(1,2,4.0),(1,3,1.0),(1,4,1.0),(1,5,3.0),(2,4,2.0),(2,5,3.0),(3,4,5.0),(3,5,1.0)]
graph.add_weighted_edges_from(edges)
graphs['custom'] = graph
#Display widget
display_maxcut_widget(graphs['custom'])
def maxcut_cost_fn(graph: nx.Graph, bitstring: List[int]) -> float:
"""
Computes the maxcut cost function value for a given graph and cut represented by some bitstring
Args:
graph: The graph to compute cut values for
bitstring: A list of integer values '0' or '1' specifying a cut of the graph
Returns:
The value of the cut
"""
#Get the weight matrix of the graph
weight_matrix = nx.adjacency_matrix(graph).toarray()
size = weight_matrix.shape[0]
value = 0.
#INSERT YOUR CODE TO COMPUTE THE CUT VALUE HERE
for i in range(size):
for j in range(size):
value += weight_matrix[i][j]*bitstring[i]*(1-bitstring[j])
return value
def plot_maxcut_histogram(graph: nx.Graph) -> None:
"""
Plots a bar diagram with the values for all possible cuts of a given graph.
Args:
graph: The graph to compute cut values for
"""
num_vars = graph.number_of_nodes()
#Create list of bitstrings and corresponding cut values
bitstrings = ['{:b}'.format(i).rjust(num_vars, '0')[::-1] for i in range(2**num_vars)]
values = [maxcut_cost_fn(graph = graph, bitstring = [int(x) for x in bitstring]) for bitstring in bitstrings]
#Sort both lists by largest cut value
values, bitstrings = zip(*sorted(zip(values, bitstrings)))
#Plot bar diagram
bar_plot = go.Bar(x = bitstrings, y = values, marker=dict(color=values, colorscale = 'plasma', colorbar=dict(title='Cut Value')))
fig = go.Figure(data=bar_plot, layout = dict(xaxis=dict(type = 'category'), width = 1500, height = 600))
fig.show()
plot_maxcut_histogram(graph = graphs['custom'])
from qc_grader import grade_lab2_ex1
bitstring = [1, 0, 1, 1, 0, 0] #DEFINE THE CORRECT MAXCUT BITSTRING HERE
# Note that the grading function is expecting a list of integers '0' and '1'
grade_lab2_ex1(bitstring)
from qiskit_optimization import QuadraticProgram
quadratic_program = QuadraticProgram('sample_problem')
print(quadratic_program.export_as_lp_string())
quadratic_program.binary_var(name = 'x_0')
quadratic_program.integer_var(name = 'x_1')
quadratic_program.continuous_var(name = 'x_2', lowerbound = -2.5, upperbound = 1.8)
quadratic = [[0,1,2],[3,4,5],[0,1,2]]
linear = [10,20,30]
quadratic_program.minimize(quadratic = quadratic, linear = linear, constant = -5)
print(quadratic_program.export_as_lp_string())
def quadratic_program_from_graph(graph: nx.Graph) -> QuadraticProgram:
"""Constructs a quadratic program from a given graph for a MaxCut problem instance.
Args:
graph: Underlying graph of the problem.
Returns:
QuadraticProgram
"""
#Get weight matrix of graph
weight_matrix = nx.adjacency_matrix(graph)
shape = weight_matrix.shape
size = shape[0]
#Build qubo matrix Q from weight matrix W
qubo_matrix = np.zeros((size, size))
for i in range(size):
for j in range(size):
qubo_matrix[i, j] -= weight_matrix[i, j]
#INSERT YOUR CODE HERE
#Define quadratic_program
quadratic_program = QuadraticProgram('quadratic_program_from_graph')
#Initiate binary variables
for i in range(size):
quadratic_program.binary_var(name = f'x_{i}')
#Build the qubo vector c_vector from weight matrix W
c_vector = np.zeros(size)
for i in range(size):
for j in range(size):
c_vector[i] += weight_matrix[i, j]
quadratic_program.maximize(quadratic = qubo_matrix, linear = c_vector)
return quadratic_program
quadratic_program = quadratic_program_from_graph(graphs['custom'])
print(quadratic_program.export_as_lp_string())
from qc_grader import grade_lab2_ex2
# Note that the grading function is expecting a quadratic program
grade_lab2_ex2(quadratic_program)
def qaoa_circuit(qubo: QuadraticProgram, p: int = 1):
"""
Given a QUBO instance and the number of layers p, constructs the corresponding parameterized QAOA circuit with p layers.
Args:
qubo: The quadratic program instance
p: The number of layers in the QAOA circuit
Returns:
The parameterized QAOA circuit
"""
size = len(qubo.variables)
qubo_matrix = qubo.objective.quadratic.to_array(symmetric=True)
qubo_linearity = qubo.objective.linear.to_array()
#Prepare the quantum and classical registers
qaoa_circuit = QuantumCircuit(size,size)
#Apply the initial layer of Hadamard gates to all qubits
qaoa_circuit.h(range(size))
#Create the parameters to be used in the circuit
gammas = ParameterVector('gamma', p)
betas = ParameterVector('beta', p)
#Outer loop to create each layer
for i in range(p):
#Apply R_Z rotational gates from cost layer
#INSERT YOUR CODE HERE
for j in range(size):
qubo_matrix_row_sum = 0
for k in range(size):
qubo_matrix_row_sum += qubo_matrix[j, k]
qaoa_circuit.rz((qubo_linearity[j]+qubo_matrix_row_sum)*gammas[i], j)
qaoa_circuit.barrier()
#Apply R_ZZ rotational gates for entangled qubit rotations from cost layer
#INSERT YOUR CODE HERE
for j in range(size):
for k in range(size):
if j>=k:
continue
qaoa_circuit.rzz(0.5*qubo_matrix[j, k]*gammas[i], j, k)
qaoa_circuit.barrier()
# Apply single qubit X - rotations with angle 2*beta_i to all qubits
#INSERT YOUR CODE HERE
for j in range(size):
qaoa_circuit.rx(2.0*betas[i], j)
qaoa_circuit.barrier()
return qaoa_circuit
quadratic_program = quadratic_program_from_graph(graphs['custom'])
custom_circuit = qaoa_circuit(qubo = quadratic_program)
test = custom_circuit.assign_parameters(parameters=[1.0]*len(custom_circuit.parameters))
custom_circuit.draw()
from qc_grader import grade_lab2_ex3
# Note that the grading function is expecting a quantum circuit
grade_lab2_ex3(test)
from qiskit.algorithms import QAOA
from qiskit_optimization.algorithms import MinimumEigenOptimizer
backend = Aer.get_backend('statevector_simulator')
qaoa = QAOA(optimizer = ADAM(), quantum_instance = backend, reps=1, initial_point = [0.1,0.1])
eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver = qaoa)
quadratic_program = quadratic_program_from_graph(graphs['custom'])
result = eigen_optimizer.solve(quadratic_program)
print(result)
def plot_samples(samples):
"""
Plots a bar diagram for the samples of a quantum algorithm
Args:
samples
"""
#Sort samples by probability
samples = sorted(samples, key = lambda x: x.probability)
#Get list of probabilities, function values and bitstrings
probabilities = [sample.probability for sample in samples]
values = [sample.fval for sample in samples]
bitstrings = [''.join([str(int(i)) for i in sample.x]) for sample in samples]
#Plot bar diagram
sample_plot = go.Bar(x = bitstrings, y = probabilities, marker=dict(color=values, colorscale = 'plasma',colorbar=dict(title='Function Value')))
fig = go.Figure(
data=sample_plot,
layout = dict(
xaxis=dict(
type = 'category'
)
)
)
fig.show()
plot_samples(result.samples)
graph_name = 'custom'
quadratic_program = quadratic_program_from_graph(graph=graphs[graph_name])
trajectory={'beta_0':[], 'gamma_0':[], 'energy':[]}
offset = 1/4*quadratic_program.objective.quadratic.to_array(symmetric = True).sum() + 1/2*quadratic_program.objective.linear.to_array().sum()
def callback(eval_count, params, mean, std_dev):
trajectory['beta_0'].append(params[1])
trajectory['gamma_0'].append(params[0])
trajectory['energy'].append(-mean + offset)
optimizers = {
'cobyla': COBYLA(),
'slsqp': SLSQP(),
'adam': ADAM()
}
qaoa = QAOA(optimizer = optimizers['cobyla'], quantum_instance = backend, reps=1, initial_point = [6.2,1.8],callback = callback)
eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver = qaoa)
result = eigen_optimizer.solve(quadratic_program)
fig = QAOA_widget(landscape_file=f'./resources/energy_landscapes/{graph_name}.csv', trajectory = trajectory, samples = result.samples)
fig.show()
graph_name = 'custom'
quadratic_program = quadratic_program_from_graph(graphs[graph_name])
#Create callback to record total number of evaluations
max_evals = 0
def callback(eval_count, params, mean, std_dev):
global max_evals
max_evals = eval_count
#Create empty lists to track values
energies = []
runtimes = []
num_evals=[]
#Run QAOA for different values of p
for p in range(1,10):
print(f'Evaluating for p = {p}...')
qaoa = QAOA(optimizer = optimizers['cobyla'], quantum_instance = backend, reps=p, callback=callback)
eigen_optimizer = MinimumEigenOptimizer(min_eigen_solver = qaoa)
start = time()
result = eigen_optimizer.solve(quadratic_program)
runtimes.append(time()-start)
num_evals.append(max_evals)
#Calculate energy of final state from samples
avg_value = 0.
for sample in result.samples:
avg_value += sample.probability*sample.fval
energies.append(avg_value)
#Create and display plots
energy_plot = go.Scatter(x = list(range(1,10)), y =energies, marker=dict(color=energies, colorscale = 'plasma'))
runtime_plot = go.Scatter(x = list(range(1,10)), y =runtimes, marker=dict(color=runtimes, colorscale = 'plasma'))
num_evals_plot = go.Scatter(x = list(range(1,10)), y =num_evals, marker=dict(color=num_evals, colorscale = 'plasma'))
fig = make_subplots(rows = 1, cols = 3, subplot_titles = ['Energy value', 'Runtime', 'Number of evaluations'])
fig.update_layout(width=1800,height=600, showlegend=False)
fig.add_trace(energy_plot, row=1, col=1)
fig.add_trace(runtime_plot, row=1, col=2)
fig.add_trace(num_evals_plot, row=1, col=3)
clear_output()
fig.show()
def plot_qaoa_energy_landscape(graph: nx.Graph, cvar: float = None):
num_shots = 1000
seed = 42
simulator = Aer.get_backend('qasm_simulator')
simulator.set_options(seed_simulator = 42)
#Generate circuit
circuit = qaoa_circuit(qubo = quadratic_program_from_graph(graph), p=1)
circuit.measure(range(graph.number_of_nodes()),range(graph.number_of_nodes()))
#Create dictionary with precomputed cut values for all bitstrings
cut_values = {}
size = graph.number_of_nodes()
for i in range(2**size):
bitstr = '{:b}'.format(i).rjust(size, '0')[::-1]
x = [int(bit) for bit in bitstr]
cut_values[bitstr] = maxcut_cost_fn(graph, x)
#Perform grid search over all parameters
data_points = []
max_energy = None
for beta in np.linspace(0,np.pi, 50):
for gamma in np.linspace(0, 4*np.pi, 50):
bound_circuit = circuit.assign_parameters([beta, gamma])
result = simulator.run(bound_circuit, shots = num_shots).result()
statevector = result.get_counts(bound_circuit)
energy = 0
measured_cuts = []
for bitstring, count in statevector.items():
measured_cuts = measured_cuts + [cut_values[bitstring]]*count
if cvar is None:
#Calculate the mean of all cut values
energy = sum(measured_cuts)/num_shots
else:
# raise NotImplementedError()
# INSERT YOUR CODE HERE
measured_cuts.sort(reverse=True) # sort the measured_cuts in descending order
reduced_size = cvar*num_shots
energy = sum(measured_cuts[:int(reduced_size)])/(reduced_size) # average only from the reduced sample
#Update optimal parameters
if max_energy is None or energy > max_energy:
max_energy = energy
optimum = {'beta': beta, 'gamma': gamma, 'energy': energy}
#Update data
data_points.append({'beta': beta, 'gamma': gamma, 'energy': energy})
#Create and display surface plot from data_points
df = pd.DataFrame(data_points)
df = df.pivot(index='beta', columns='gamma', values='energy')
matrix = df.to_numpy()
beta_values = df.index.tolist()
gamma_values = df.columns.tolist()
surface_plot = go.Surface(
x=gamma_values,
y=beta_values,
z=matrix,
coloraxis = 'coloraxis'
)
fig = go.Figure(data = surface_plot)
fig.show()
#Return optimum
return optimum
graph = graphs['custom']
optimal_parameters = plot_qaoa_energy_landscape(graph = graph)
print('Optimal parameters:')
print(optimal_parameters)
optimal_parameters = plot_qaoa_energy_landscape(graph = graph, cvar = 0.2)
print(optimal_parameters)
from qc_grader import grade_lab2_ex4
# Note that the grading function is expecting a python dictionary
# with the entries 'beta', 'gamma' and 'energy'
grade_lab2_ex4(optimal_parameters)
|
https://github.com/googlercolin/Qiskit-Course
|
googlercolin
|
import numpy as np
from numpy import pi
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile, assemble, Aer, IBMQ, execute
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_bloch_multivector, plot_histogram
from qiskit_textbook.problems import dj_problem_oracle
def lab1_ex1():
qc = QuantumCircuit(1)
#
#
# FILL YOUR CODE IN HERE
qc.x(0)
#
#
return qc
state = Statevector.from_instruction(lab1_ex1())
plot_bloch_multivector(state)
from qc_grader.challenges.qgss_2022 import grade_lab1_ex1
# Note that the grading function is expecting a quantum circuit without measurements
grade_lab1_ex1(lab1_ex1())
def lab1_ex2():
qc = QuantumCircuit(1)
#
#
# FILL YOUR CODE IN HERE
qc.h(0)
#
#
return qc
state = Statevector.from_instruction(lab1_ex2())
plot_bloch_multivector(state)
from qc_grader.challenges.qgss_2022 import grade_lab1_ex2
# Note that the grading function is expecting a quantum circuit without measurements
grade_lab1_ex2(lab1_ex2())
def lab1_ex3():
qc = QuantumCircuit(1)
#
#
# FILL YOUR CODE IN HERE
qc.h(0)
qc.z(0)
#
#
return qc
state = Statevector.from_instruction(lab1_ex3())
plot_bloch_multivector(state)
from qc_grader.challenges.qgss_2022 import grade_lab1_ex3
# Note that the grading function is expecting a quantum circuit without measurements
grade_lab1_ex3(lab1_ex3())
def lab1_ex4():
qc = QuantumCircuit(1)
#
# FILL YOUR CODE IN HERE
qc.h(0)
qc.sdg(0)
#
#
return qc
state = Statevector.from_instruction(lab1_ex4())
plot_bloch_multivector(state)
from qc_grader.challenges.qgss_2022 import grade_lab1_ex4
# Note that the grading function is expecting a quantum circuit without measurements
grade_lab1_ex4(lab1_ex4())
def lab1_ex5():
# This time, we not only want two qubits, but also two classical bits for the measurement
qc = QuantumCircuit(2,2)
#
#
# FILL YOUR CODE IN HERE
qc.x(1)
qc.h(0)
qc.cx(0,1)
#
#
return qc
qc = lab1_ex5()
qc.draw() # we draw the circuit
from qc_grader.challenges.qgss_2022 import grade_lab1_ex5
# Note that the grading function is expecting a quantum circuit without measurements
grade_lab1_ex5(lab1_ex5())
qc.measure_all() # we measure all the qubits
backend = Aer.get_backend('qasm_simulator') # we choose the simulator as our backend
counts = execute(qc, backend, shots = 1000).result().get_counts() # we run the simulation and get the counts
plot_histogram(counts) # let us plot a histogram to see the possible outcomes and corresponding probabilities
def lab1_ex6():
# This time, we need 3 qubits and also add 3 classical bits in case we want to measure
qc = QuantumCircuit(3,3)
#
#
# FILL YOUR CODE IN HERE
qc.h(0)
qc.z(0)
qc.cx(0,1)
qc.x(2)
qc.cx(1,2)
#
return qc
qc = lab1_ex6()
qc.draw() # we draw the circuit
qc.measure_all() # we measure all the qubits
backend = Aer.get_backend('qasm_simulator') # we choose the simulator as our backend
counts = execute(qc, backend, shots = 1000).result().get_counts() # we run the simulation and get the counts
plot_histogram(counts) # let us plot a histogram to see the possible outcomes and corresponding probabilities
from qc_grader.challenges.qgss_2022 import grade_lab1_ex6
# Note that the grading function is expecting a quantum circuit without measurements
grade_lab1_ex6(lab1_ex6())
qc = QuantumCircuit(3)
qc.h(0)
qc.cx(0,1)
qc.cx(0,2)
print(qc.size())
print(qc.num_nonlocal_gates())
def qft_rotations(circuit, n):
"""Performs qft on the first n qubits in circuit (without swaps)"""
if n == 0:
return circuit
n -= 1
circuit.h(n)
for qubit in range(n):
circuit.cp(pi/2**(n-qubit), qubit, n)
# At the end of our function, we call the same function again on
# the next qubits (we reduced n by one earlier in the function)
qft_rotations(circuit, n)
def swap_registers(circuit, n):
"""Swaps registers to match the definition"""
for qubit in range(n//2):
circuit.swap(qubit, n-qubit-1)
return circuit
def qft(circuit, n):
"""QFT on the first n qubits in circuit"""
qft_rotations(circuit, n)
swap_registers(circuit, n)
return circuit
qft_rotations(qc,3)
print(qc.size())
print(qc.num_nonlocal_gates())
qc.draw()
def lab1_ex7(n:int) -> int:
#Here we want you to build a function calculating the number of gates needed by the fourier rotation for n qubits.
numberOfGates=0
#
# FILL YOUR CODE IN HERE
# TRY TO FIND AN EXPLIZIT (NON RECURSIVE) FUNCTION
qc = QuantumCircuit(n)
qft_rotations(qc, n)
numberOfGates = qc.size()
#
return numberOfGates
print(lab1_ex7(3))
print(lab1_ex7(4))
print(lab1_ex7(5))
print(lab1_ex7(10))
print(lab1_ex7(100))
print(lab1_ex7(200))
# Lab 1, Exercise 7
from qc_grader.challenges.qgss_2022 import grade_lab1_ex7
# Note that the grading function is expecting as input a function!
#(And the function takes n as an input and outputs the number of gates constructed)
grade_lab1_ex7(lab1_ex7)
qc = QuantumCircuit(4)
qc.h(0)
qc.s(0)
qc.s(0)
qc.s(0)
qc.cx(0,1)
qc.cx(1,3)
print(qc.depth())
qc.draw()
qc2 = QuantumCircuit(4)
qc2.h(0)
qc2.s(1)
qc2.cx(0,1)
qc2.s(2)
qc2.s(3)
qc2.cx(2,3)
print(qc2.depth())
qc2.draw()
qc = QuantumCircuit(16)
#Step 1: Preparing the first qubit in superposition
qc.h(0)
#Step 2: Entangling all other qubits with it (1 is included 16 is exclude)
for x in range(1, 16):
qc.cx(0,x)
print(qc.depth())
qc = QuantumCircuit(16) #Same as above
#Step 1: Preparing the first qubit in superposition
qc.h(0)
qc.cx(0,1)
for i in range(2):
qc.cx(i,i+2)
for i in range(4):
qc.cx(i,i+4)
for i in range(8):
qc.cx(i,i+8)
#
qc.draw()
def lab1_ex8():
qc = QuantumCircuit(16) #Same as above
#Step 1: Preparing the first qubit in superposition
qc.h(0)
#
#
# FILL YOUR CODE IN HERE
qc.cx(0,1)
for i in range(2):
qc.cx(i,i+2)
for i in range(4):
qc.cx(i,i+4)
for i in range(8):
qc.cx(i,i+8)
#
return qc
qc = lab1_ex8()
print(qc.depth())
from qc_grader.challenges.qgss_2022 import grade_lab1_ex8
# Note that the grading function is expecting a quantum circuit without measurements
grade_lab1_ex8(lab1_ex8())
|
https://github.com/googlercolin/Qiskit-Course
|
googlercolin
|
import numpy as np
from qiskit.opflow import I, X, Y, Z, MatrixEvolution, PauliTrotterEvolution
from qiskit.circuit import Parameter
from qiskit import QuantumCircuit
from qiskit import Aer
from qiskit.compiler import transpile
import qc_grader
# Define which will contain the Paulis
pauli_list = []
# Define Paulis and add them to the list
###INSERT CODE BELOW THIS LINE
pauli_list = [X, Y, Z, I]
###DO NOT EDIT BELOW THIS LINE
for pauli in pauli_list:
print(pauli, '\n')
from qc_grader.challenges.qgss_2022 import grade_lab2_ex1
grade_lab2_ex1(pauli_list)
# Define list of ladder operators
ladder_operator_list = []
# Define ladder operators and add the to the list
###INSERT CODE BELOW THIS LINE
ladder_operator_list = [0.5*(X+(1j*Y)), 0.5*(X-(1j*Y))]
###DO NOT EDIT BELOW THIS LINE
for ladder_operator in ladder_operator_list:
print(ladder_operator, '\n')
from qc_grader.challenges.qgss_2022 import grade_lab2_ex2
grade_lab2_ex2(ladder_operator_list)
# Define list which will contain the matrices representing the Pauli operators
matrix_sigma_list = []
# Add matrix representation of Paulis to the list
###INSERT CODE BELOW THIS LINE
matrix_sigma_list = [X.to_matrix(), Y.to_matrix(), Z.to_matrix(), I.to_matrix()]
###DO NOT EDIT BELOW THIS LINE
for matrix_sigma in matrix_sigma_list:
print(matrix_sigma, '\n')
from qc_grader.challenges.qgss_2022 import grade_lab2_ex3
grade_lab2_ex3(matrix_sigma_list)
# Define a list which will contain the circuit representation of the Paulis
circuit_sigma_list = []
# Add circuits to list
###INSERT CODE BELOW THIS LINE
circuit_sigma_list = [X.to_circuit(), Y.to_circuit(), Z.to_circuit(), I.to_circuit()]
###DO NOT EDIT BELOW THIS LINE
for circuit in circuit_sigma_list:
print(circuit, '\n')
from qc_grader.challenges.qgss_2022 import grade_lab2_ex4
grade_lab2_ex4(circuit_sigma_list)
# Define a variable theta to be a parameter with name 'theta'
theta = Parameter('theta')
# Set number of qubits to 1
qubits_count = 1
# Initialize a quantum circuit with one qubit
quantum_circuit = QuantumCircuit(qubits_count)
# Add a parametrized RX rotation on the qubit
###INSERT CODE BELOW THIS LINE
quantum_circuit.rx(theta, 0)
###DO NOT EDIT BELOW THIS LINE
print(quantum_circuit)
from qc_grader.challenges.qgss_2022 import grade_lab2_ex5
grade_lab2_ex5(quantum_circuit)
# Set the value of the parameter
theta_value = np.pi
# Bind the value to the parametrized circuit
###INSERT CODE BELOW THIS LINE
quantum_circuit = quantum_circuit.bind_parameters({theta: theta_value})
###DO NOT EDIT BELOW THIS LINE
print(quantum_circuit)
from qc_grader.challenges.qgss_2022 import grade_lab2_ex6
grade_lab2_ex6(quantum_circuit)
# Use the formula above to define the Hamiltonian operator
###INSERT CODE BELOW THIS LINE
H = 0.5*((I^I)+(X^X)+(Y^Y)+(Z^Z))
###DO NOT EDIT BELOW THIS LINE
# Get its matrix representation
H_matrix = H.to_matrix()
print(H_matrix)
from qc_grader.challenges.qgss_2022 import grade_lab2_ex7
grade_lab2_ex7(H_matrix)
# Define a parameter t for the time in the time evolution operator
t = Parameter('t')
# Follow the instructions above to define a time-evolution operator
###INSERT CODE BELOW THIS LINE
time_evolution_operator = (H*t).exp_i()
###DO NOT EDIT BELOW THIS LINE
print(time_evolution_operator)
from qc_grader.challenges.qgss_2022 import grade_lab2_ex8
grade_lab2_ex8(time_evolution_operator)
# Set a total time for the time evolution
evolution_time = 0.5
# Instantiate a MatrixEvolution() object to convert the time evolution operator
# and bind the value for the time parameter
###INSERT CODE BELOW THIS LINE
matrix_evol = MatrixEvolution()
bound_matrix_exponentiation_circuit = matrix_evol.convert(time_evolution_operator)
bound_matrix_exponentiation_circuit = bound_matrix_exponentiation_circuit.bind_parameters({t:evolution_time})
###DO NOT EDIT BELOW THIS LINE
print(bound_matrix_exponentiation_circuit)
from qc_grader.challenges.qgss_2022 import grade_lab2_ex9
grade_lab2_ex9(bound_matrix_exponentiation_circuit)
# Define a value for the duration of the time-step
time_step_value = 0.1
# Instantiate a PauliTrotterEvolution() object and convert the time-evolution operator
# to then bind the value of the time step
###INSERT CODE BELOW THIS LINE
pauli_t_evol = PauliTrotterEvolution()
bound_trotter_exponentiation_circuit = pauli_t_evol.convert(time_evolution_operator)
bound_trotter_exponentiation_circuit = bound_trotter_exponentiation_circuit.bind_parameters({
t: time_step_value
})
###DO NOT EDIT BELOW THIS LINE
print(bound_trotter_exponentiation_circuit)
from qc_grader.challenges.qgss_2022 import grade_lab2_ex10
grade_lab2_ex10(bound_trotter_exponentiation_circuit)
# Define the number of steps needed to reach the previously set total time-evolution
steps = int(evolution_time/time_step_value)
# Compose the operator for a Trotter step several times to generate the
# operator for the full time-evolution
###INSERT CODE BELOW THIS LINE
total_time_evolution_circuit = bound_trotter_exponentiation_circuit
for i in range(1, steps):
total_time_evolution_circuit = total_time_evolution_circuit @ bound_trotter_exponentiation_circuit
###DO NOT EDIT BELOW THIS LINE
print(total_time_evolution_circuit)
from qc_grader.challenges.qgss_2022 import grade_lab2_ex11
grade_lab2_ex11(total_time_evolution_circuit)
# Set number of qubits
num_qubits = 3
# Define time parameter
t = Parameter('t')
# Set total evolution time
evolution_time_t = 2
# Set size of time-step for Trotter evolution
time_step_value_t = 0.1
# Define the number of steps
steps_t = int(evolution_time_t/time_step_value_t)
# Create circuit
tight_binding_circuit = QuantumCircuit(num_qubits)
# Add initial state preparation
tight_binding_circuit.x(0)
# Define the Hamiltonian, the time-evolution operator, the Trotter step and the total evolution
###INSERT CODE BELOW THIS LINE
H = (I^X^X) + (X^X^I) + (I^Y^Y) + (Y^Y^I)
# Define a parameter t for the time in the time evolution operator
t = Parameter('t')
time_evolution_operator = (H*t).exp_i()
pauli_t_evol = PauliTrotterEvolution()
bound_trotter_exponentiation_circuit = pauli_t_evol.convert(time_evolution_operator)
bound_trotter_exponentiation_circuit = bound_trotter_exponentiation_circuit.bind_parameters({
t: time_step_value_t
})
total_time_evolution_circuit = bound_trotter_exponentiation_circuit
for i in range(1, steps_t):
total_time_evolution_circuit = total_time_evolution_circuit @ bound_trotter_exponentiation_circuit
full_time_evolution_circuit = tight_binding_circuit + total_time_evolution_circuit.to_circuit()
###DO NOT EDIT BELOW THIS LINE
print(full_time_evolution_circuit)
from qc_grader.challenges.qgss_2022 import grade_lab2_ex12
grade_lab2_ex12(full_time_evolution_circuit)
|
https://github.com/googlercolin/Qiskit-Course
|
googlercolin
|
import numpy as np
import qiskit
from qiskit.circuit.library import RXGate
from qiskit.providers.aer.noise import NoiseModel, ReadoutError, depolarizing_error, coherent_unitary_error
from scipy.stats import norm
from scipy.optimize import curve_fit
import matplotlib.pylab as plt
import qc_grader
# Create circuit to generate an equal superposition of quantum states
# Set the number of qubits
qubits_count = 1
# Set the number of bits
cbits_count = 1
# Instantiate a quantum register
quantum_register = qiskit.QuantumRegister(qubits_count)
# Instantiate a classical register
classical_register = qiskit.ClassicalRegister(cbits_count)
# Instantiate a quantum circuit
circuit = qiskit.QuantumCircuit(quantum_register, classical_register)
# Add a Hadamard gate and measurement
###INSERT CODE BELOW THIS LINE
circuit.h(0)
circuit.measure(0,0)
###DO NOT EDIT BELOW THIS LINE
from qc_grader.challenges.qgss_2022 import grade_lab3_ex1
grade_lab3_ex1(circuit)
# Run the quantum circuit on a simulator backend which returns measured shots in the Z basis
shots_backend = qiskit.Aer.get_backend('qasm_simulator')
# Fix number of times to repeat the experiment
num_shots = 10
# Create a job, run on the simulator, extract the results and get the counts dictionary
###INSERT CODE BELOW THIS LINE
job = shots_backend.run(circuit, shots = num_shots).result()
counts = job.get_counts()
###DO NOT EDIT BELOW THIS LINE
print(counts)
from qc_grader.challenges.qgss_2022 import grade_lab3_ex2
grade_lab3_ex2(counts)
# Set different number of shots
num_shots_list = [10, 100, 1000, 10000]
# For each number of shots, extract the probability of |0> from the experimental counts
p0_list = []
for num_shots in num_shots_list:
# Create a job, run on the simulator, extract the results and get the counts dictionary
###INSERT CODE BELOW THIS LINE
job = shots_backend.run(circuit, shots = num_shots).result()
counts = job.get_counts()
counts_0 = counts['0']
prob = counts_0/num_shots
p0_list.append(prob)
###DO NOT EDIT BELOW THIS LINE
for num_shots, p0 in zip(num_shots_list, p0_list):
print(f"The probability of observing the 0 state with {num_shots} shots is: {p0}")
from qc_grader.challenges.qgss_2022 import grade_lab3_ex3
grade_lab3_ex3(p0_list)
# Set the number of shots
num_shots = 10
# Set the number of times to repeat the experiment
iterations = 10000
# Set the number of bins for the histogram
bin_count = 100
# For each iteration, create job, run the experiment,
# collect results and calculate probability of |0>
p0_list = []
for _ in range(iterations):
job = shots_backend.run(circuit, shots=num_shots)
result = job.result()
if '0' in result.get_counts().keys():
p0 = result.get_counts()['0']/num_shots
else:
p0 = 1 - result.get_counts()['1']/num_shots
p0_list.append(p0)
# Calculate a histogram from the results
yhist, xhist = np.histogram(p0_list, bins=bin_count)
# Restrict horizontal axis to 0-1
x_01 = np.array([xhist[n] + (xhist[n + 1] - xhist[n])/2 for n in range(len(xhist)-1)])
# Find x-points for which the histogram has more than zero counts
xh = np.where(yhist > 0)[0]
# Get the y-points of the corresponding x ones
yh = yhist[xh]
# Get the x-points
x_01_h = x_01[xh]
# Plot
plt.scatter(x_01_h, yh, color = 'red')
plt.title(f"Using {num_shots} shots to estimate probability")
plt.xlim((0, 1))
plt.xlabel(r'probability of $\vert 0 \rangle$')
plt.ylabel('counts')
plt.show()
# Define a Gaussian function for the fit
def gaussian(x, a, mean, sigma):
return a * (1/(sigma*np.sqrt(2*np.pi)))*np.exp(-((x - mean)**2 / (2 * sigma**2)))
# Set initial estimates for the fit: the maximum height of the histogram, the theoretical
# average and the theoretical standard deviation
height_estimate = np.max(yh)
mu_estimate = 0.5
sigma_estimate = np.sqrt(mu_estimate*(1-mu_estimate)/num_shots)
# Define list to store the estimated values of the average (mu_sigma[0]) and standard deviation (mu_sigma[1])
mu_sigma = []
# Use the curve_fit function to fit the experimental data using the definition of the Gaussian function
# which will return the estimate of the parameters.
###INSERT CODE BELOW THIS LINE
popt, pcov = curve_fit(gaussian, x_01_h, yh, [height_estimate, mu_estimate, sigma_estimate])
# (x_01_h, 1, mu_estimate, sigma_estimate)
mu_sigma.append(popt[1])
mu_sigma.append(popt[2])
# ###DO NOT EDIT BELOW THIS LINE
print("The mean is ", mu_sigma[0])
print("The standard deviation is ", mu_sigma[1])
# Plot experimental data and the fit
plt.scatter(x_01_h, yh, label = 'data', color = 'red')
plt.plot(x_01, gaussian(x_01, *popt), label = 'fit', linestyle = '--')
plt.title(f"Using {num_shots} shots to estimate probability")
plt.xlim((0, 1))
plt.xlabel(r'probability of $\vert 0 \rangle$')
plt.ylabel('counts')
plt.legend()
plt.show()
from qc_grader.challenges.qgss_2022 import grade_lab3_ex4
grade_lab3_ex4(mu_sigma)
# Set different number of shots
num_shots_list = [10, 100, 1000,10000]
# Set the number of times to repeat the experiment
iterations = 10000
# Set the number of bins for the histogram
bin_count = 100
# Repeat the protocol above for different number of shots to see how the parameters of the
# estimated Gaussian change with the number of shots
popt_list = []
gaussian_curve_list, x_01_list = [], []
for num_shots in num_shots_list:
p0_list = []
for _ in range(iterations):
job = shots_backend.run(circuit, shots=num_shots)
result = job.result()
if '0' in result.get_counts().keys():
p0 = result.get_counts()['0']/num_shots
else:
p0 = 1 - result.get_counts()['1']/num_shots
p0_list.append(p0)
yhist, xhist = np.histogram(p0_list, bins=bin_count)
norm_y = np.sum(yhist)
yhist = yhist/iterations
x_01 = np.array([xhist[n] + (xhist[n + 1] - xhist[n])/2 for n in range(len(xhist)-1)])
xh = np.where(yhist > 0)[0]
yh = yhist[xh]
x_01_h = x_01[xh]
height_estimate = np.max(yh)
mu_estimate = p0
sigma_estimate = np.sqrt(mu_estimate*(1-mu_estimate)/num_shots)
popt, pcov = curve_fit(gaussian, x_01_h, yh, [height_estimate, mu_estimate, sigma_estimate])
gaussian_curve = gaussian(x_01, *popt)
gaussian_curve_list.append(gaussian_curve)
x_01_list.append(x_01)
popt_list.append(popt)
plt.scatter(x_01_h, yh, label = 'data', color = 'red')
plt.plot(x_01, gaussian_curve, label = 'fit', linestyle = '--')
plt.title(f"Using {num_shots} shots to estimate probability")
plt.xlim((0, 1))
plt.xlabel(r'probability of $\vert 0 \rangle$')
plt.ylabel('counts')
plt.legend()
plt.show()
# Define list which will contain the experimental standard deviations
sigma_exp_list = []
# Append the standard deviations from the experiments with different number of shots to sigma_exp_list
###INSERT CODE BELOW THIS LINE
for popt in popt_list:
sigma_exp_list.append(popt[2])
###DO NOT EDIT BELOW THIS LINE
# Define theoretical sigma
p=0.5
sigma_th_list = [np.sqrt(p*(1-p)/num_shots) for num_shots in num_shots_list]
for sigma_exp, sigma_th in zip(sigma_exp_list, sigma_th_list):
print(f"The variance from experiment is {sigma_exp} while the theoretical one is {sigma_th}")
from qc_grader.challenges.qgss_2022 import grade_lab3_ex5
grade_lab3_ex5(sigma_exp_list)
# Set number of shots
num_shots_measurement = 10000
# Create an empty noise model
readout_noise_model = NoiseModel()
# Measurement miss-assignement probabilities
p0given1 = 0.3 # Probability of measuuring |0> given the state is |1>
p1given0 = 0.05 # Probability of measuring |1> given the state is |0>
readout_error = ReadoutError([[1 - p1given0, p1given0], [p0given1, 1 - p0given1]]) # Define readout error
readout_noise_model.add_readout_error(readout_error, [0]) # Add error to noise model
# Calculate probability of seeing |0> given that |0> is prepared
circuit_0 = qiskit.QuantumCircuit(quantum_register, classical_register)
# Add measurement
###INSERT CODE BELOW THIS LINE
circuit_0.measure(0,0)
###DO NOT EDIT BELOW THIS LINE
from qc_grader.challenges.qgss_2022 import grade_lab3_ex6
grade_lab3_ex6(circuit_0)
# Run the experiment
job = shots_backend.run(circuit_0, shots=num_shots_measurement, noise_model=readout_noise_model)
# Retrieve results
result = job.result()
# Calculate probability of |0>
if '0' in result.get_counts().keys():
p0_0 = result.get_counts()['0']/num_shots_measurement
else:
p0_0 = 1 - result.get_counts()['1']/num_shots_measurement
p1_0 = 1 - p0_0
print('Probability of measuring |0> when |0> is prepared:', p0_0)
print('Probability of measuring |1> when |0> is prepared:', p1_0)
# Calculate probability of seeing |1> given that |1> is prepared
circuit_1 = qiskit.QuantumCircuit(quantum_register, classical_register)
# Add X gate and measurement
###INSERT CODE BELOW THIS LINE
circuit_1.x(0)
circuit_1.measure(0,0)
###DO NOT EDIT BELOW THIS LINE
from qc_grader.challenges.qgss_2022 import grade_lab3_ex7
grade_lab3_ex7(circuit_1)
# Run the experiment
job = shots_backend.run(circuit_1, shots=num_shots_measurement, noise_model=readout_noise_model)
# Retrieve results
result = job.result()
# Calculate probability of |0>
if '0' in result.get_counts().keys():
p1_1 = 1 - result.get_counts()['0']/num_shots_measurement
else:
p1_1 = result.get_counts()['1']/num_shots_measurement
p0_1 = 1 - p1_1
print('Probability of measuring |0> when |1> is prepared:', p0_1)
print('Probability of measuring |1> when |1> is prepared:', p1_1)
# Define the confusion matrix from the probabilities found above
###INSERT CODE BELOW THIS LINE
confusion_matrix = np.array([[p0_0, p0_1], [p1_0, p1_1]])
###DO NOT EDIT BELOW THIS LINE
print("Confusion matrix:")
print(confusion_matrix)
from qc_grader.challenges.qgss_2022 import grade_lab3_ex8
# The grader expects a np.array object (not list)
grade_lab3_ex8(confusion_matrix)
# Run experiments
job = shots_backend.run(circuit, shots=num_shots_measurement, noise_model=readout_noise_model)
# Extract results
result = job.result()
# Calculate probability of |0>
if '0' in result.get_counts().keys():
p0_noisy = result.get_counts()['0']/num_shots_measurement
p1_noisy = 1 - p0_noisy
else:
p0_noisy = 1 - result.get_counts()['1']/num_shots_measurement
p1_noisy = 1 - p0_noisy
p_vector_noisy = np.array([p0_noisy, p1_noisy])
print("Noisy probability of |0>: ", p0_noisy)
print("Noisy probability of |1>: ", p1_noisy)
# Invert the confusion matrix
inverse_confusion_matrix = np.linalg.inv(confusion_matrix)
# Mitigate the counts using the inverse of the confusion matrix
###INSERT CODE BELOW THIS LINE
p_vector_mitigated = (inverse_confusion_matrix @ p_vector_noisy)
###DO NOT EDIT BELOW THIS LINE
print("Mitigated probability of |0>: ", p_vector_mitigated[0])
print("Mitigated probability of |1>: ", p_vector_mitigated[1])
from qc_grader.challenges.qgss_2022 import grade_lab3_ex9
# The grader expects a np.array object (not list)
grade_lab3_ex9(p_vector_mitigated)
# Run ideal experiments
job = shots_backend.run(circuit, shots=num_shots_measurement)
# Extract results
result = job.result()
# Calculate probability of |0>
if '0' in result.get_counts().keys():
p0_ideal = result.get_counts()['0']/num_shots_measurement
p1_ideal = 1 - p0_ideal
else:
p0_ideal = 1 - result.get_counts()['1']/num_shots_measurement
p1_ideal = 1 - p0_ideal
print("Ideal probability of |0>: ", p0_ideal)
print("Ideal probability of |1>: ", p1_ideal)
# Set number of shots
num_shots_coherent = 100
# Create an empty noise model
rx_overrotation_noise_model = NoiseModel()
# Construct a 1 qubit over-rotation of the RX gate
epsilon = np.pi/5 # over rotation amount
epsilon_rotation = RXGate(epsilon).to_matrix() # get matrix representation
# Create coherent error
over_rotation = coherent_unitary_error(epsilon_rotation)
# Add error to error model
rx_overrotation_noise_model.add_quantum_error(over_rotation, ['rx'], qubits = [0])
# Set value of rotation
theta = np.pi
# Instantiate a quantum circuit
circuit = qiskit.QuantumCircuit(quantum_register, classical_register)
# Add a parametrized RX rotation and bind the value of the parameter. (By default, parameter binding is not an in-place operation)
# Then measure the qubit and calculate probability of seeing |0> after rx(np.pi)
###INSERT CODE BELOW THIS LINE
circuit.rx(theta, 0)
circuit.measure(0,0)
###DO NOT EDIT BELOW THIS LINE
from qc_grader.challenges.qgss_2022 import grade_lab3_ex10
grade_lab3_ex10(circuit)
# Run experiments
job = shots_backend.run(circuit, shots=num_shots_coherent, noise_model=rx_overrotation_noise_model)
# Extract results
result = job.result()
# Calculate the probability of |0>
if '0' in result.get_counts().keys():
p0 = result.get_counts()['0']/num_shots_coherent
else:
p0 = 1 - result.get_counts()['1']/num_shots_coherent
print("Noisy probability of |0> after coherent error in idling: ", p0)
print("Noisy probability of |1> after coherent error in idling: ", 1-p0)
# Define number of shots
num_shots_incoherent = 10000
# Create an empty noise model
depolarizing_noise_model = NoiseModel()
# Define a depolarizing error on the identity gate for qubit zero and add it to the noise model
###INSERT CODE BELOW THIS LINE
lamb = float(5/100)
depolarizing = depolarizing_error(lamb, 1)
depolarizing_noise_model.add_quantum_error(depolarizing, ['id'], qubits = [0])
###DO NOT EDIT BELOW THIS LINE
from qc_grader.challenges.qgss_2022 import grade_lab3_ex11
grade_lab3_ex11(depolarizing_noise_model)
# Create a circuit with an idle instruction
circuit_idle = qiskit.QuantumCircuit(quantum_register, classical_register)
circuit_idle.id(0)
circuit_idle.measure(0,0)
# Run experiments
job = shots_backend.run(circuit_idle, shots=num_shots_incoherent, noise_model=depolarizing_noise_model)
# Extract results
result = job.result()
# Calculate probability of seeing |0> after idle time
if '0' in result.get_counts().keys():
p0 = result.get_counts()['0']/num_shots_incoherent
else:
p0 = 1 - result.get_counts()['1']/num_shots_incoherent
print("Noisy probability of |0> after incoherent error in idling: ", p0)
print("Noisy probability of |1> after incoherent error in idling: ", 1-p0)
|
https://github.com/googlercolin/Qiskit-Course
|
googlercolin
|
import numpy as np
import matplotlib.pyplot as plt
plt.rcParams.update({'font.size': 16}) # enlarge matplotlib fonts
# Import qubit states Zero (|0>) and One (|1>), Pauli operators (X, Y, Z), and the identity operator (I)
from qiskit.opflow import Zero, One, X, Y, Z, I
# Returns the XXX Heisenberg model for 3 spin-1/2 particles in a line
def ex1_compute_H_heis3():
# FILL YOUR CODE IN HERE
H = (I^X^X) + (X^X^I) + (I^Y^Y) + (Y^Y^I) + (I^Z^Z) + (Z^Z^I)
# Return Hamiltonian
return H
from qc_grader.challenges.qgss_2022 import grade_lab4_ex1
# The grading function is expecting a PauliSumOp operator
grade_lab4_ex1(ex1_compute_H_heis3())
# Returns the time evolution operator U_heis3(t) for a given time t assuming an XXX Heisenberg Hamiltonian for 3 spins-1/2 particles in a line
def ex2_compute_U_heis3(t):
# FILL YOUR CODE IN HERE
H = ex1_compute_H_heis3()
U = (t*H).exp_i()
return U
from qc_grader.challenges.qgss_2022 import grade_lab4_ex2
# The grading function is expecting a funtion that returns PauliSumOp operator
grade_lab4_ex2(ex2_compute_U_heis3)
# Define array of time points
ts = np.linspace(0, np.pi, 100)
# Define initial state |110>
initial_state = One^One^Zero
# Compute probability of remaining in |110> state over the array of time points
# ~initial_state gives the bra of the initial state (<110|)
# @ is short hand for matrix multiplication
# ex2_compute_U_heis3(t) is the unitary time evolution at time t
# t needs to be wrapped with float(t) to avoid a bug
# (...).eval() returns the inner product <110|ex2_compute_U_heis3(t)|110>
# np.abs(...)**2 is the modulus squared of the innner product which is the expectation value, or probability, of remaining in |110>
probs_110 = [np.abs((~initial_state @ ex2_compute_U_heis3(float(t)) @ initial_state).eval())**2 for t in ts]
# Plot evolution of |110>
plt.plot(ts, probs_110, linewidth=2)
plt.xlabel('time')
plt.ylabel(r'probability of state $|110\rangle$')
plt.title(r'Evolution of state $|110\rangle$ under $H_{Heis3}$')
plt.ylim([-0.05,1.05])
plt.grid()
plt.show()
!pip install qiskit_ignis --quiet
# Importing standard Qiskit modules
from qiskit import QuantumCircuit, QuantumRegister, IBMQ, execute, transpile
from qiskit.providers.aer import QasmSimulator
from qiskit.tools.monitor import job_monitor
from qiskit.circuit import Parameter
# Import state tomography modules
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.quantum_info import state_fidelity
# load IBMQ Account data
# IBMQ.save_account(TOKEN) # replace TOKEN with your API token string (https://quantum-computing.ibm.com/lab/docs/iql/manage/account/ibmq)
provider = IBMQ.load_account()
# Get backend for experiment
provider = IBMQ.get_provider(hub='ibm-q')
manila = provider.get_backend('ibmq_manila')
# properties = manila.properties()
# Simulated backend based on ibmq_manila's device noise profile
sim_noisy_manila = QasmSimulator.from_backend(provider.get_backend('ibmq_manila'))
# Noiseless simulated backend
sim = QasmSimulator()
# Parameterize variable t to be evaluated at t=pi later
t = Parameter('t')
# Build a subcircuit for XX(t) two-qubit gate
def compute_XX_gate(t):
XX_qr = QuantumRegister(2)
XX_qc = QuantumCircuit(XX_qr, name='XX')
XX_qc.ry(np.pi/2,[0,1])
XX_qc.cnot(0,1)
XX_qc.rz(2 * t, 1)
XX_qc.cnot(0,1)
XX_qc.ry(-np.pi/2,[0,1])
# Convert custom quantum circuit into a gate
XX = XX_qc.to_instruction()
return XX
# Build a subcircuit for YY(t) two-qubit gate
def ex3_compute_YY_gate(t):
# FILL YOUR CODE IN HERE
YY_qr = QuantumRegister(2)
YY_qc = QuantumCircuit(YY_qr, name='YY')
YY_qc.s(0)
YY_qc.s(1)
XX = compute_XX_gate(t)
YY_qc.append(XX, [YY_qr[0], YY_qr[1]])
YY_qc.sdg(0)
YY_qc.sdg(1)
YY = YY_qc.to_instruction()
return YY
from qc_grader.challenges.qgss_2022 import grade_lab4_ex3
# The grading function is expecting an Instruction
grade_lab4_ex3(ex3_compute_YY_gate(t))
# Build a subcircuit for ZZ(t) two-qubit gate
def ex4_compute_ZZ_gate(t):
# FILL YOUR CODE IN HERE
ZZ_qr = QuantumRegister(2)
ZZ_qc = QuantumCircuit(ZZ_qr, name='ZZ')
ZZ_qc.h(0)
ZZ_qc.h(1)
XX = compute_XX_gate(t)
ZZ_qc.append(XX, [ZZ_qr[0], ZZ_qr[1]])
ZZ_qc.h(0)
ZZ_qc.h(1)
ZZ = ZZ_qc.to_instruction()
return ZZ
from qc_grader.challenges.qgss_2022 import grade_lab4_ex4
# The grading function is expecting an Instruction
grade_lab4_ex4(ex4_compute_ZZ_gate(t))
# Combine subcircuits into a single multiqubit gate representing a single trotter step
num_qubits = 3
# Define two-qubit interactions Parameterized by t
XX = compute_XX_gate(t)
YY = ex3_compute_YY_gate(t)
ZZ = ex4_compute_ZZ_gate(t)
Trot_qr = QuantumRegister(num_qubits)
Trot_qc = QuantumCircuit(Trot_qr, name='Trot')
for i in range(0, num_qubits - 1):
Trot_qc.append(ZZ, [Trot_qr[i], Trot_qr[i+1]])
Trot_qc.append(YY, [Trot_qr[i], Trot_qr[i+1]])
Trot_qc.append(XX, [Trot_qr[i], Trot_qr[i+1]])
# Convert custom quantum circuit into a gate
Trot_gate = Trot_qc.to_instruction()
# Setup experiment parameters
# The final time of the state evolution
target_time = np.pi # DO NOT MODIFY
# Number of trotter steps
trotter_steps = 20 ### CAN BE >= 4
# Select which qubits to use for the simulation
q_regs = [0,1,2]
# Initialize quantum circuit for 3 qubits
qr = QuantumRegister(5)
qc = QuantumCircuit(qr)
# Prepare initial state (remember we are only evolving 3 of the 7 qubits on manila qubits (q_5, q_3, q_1) corresponding to the state |110>)
qc.x([q_regs[2], q_regs[1]]) # For example this could be (q_regs=[2, 1, 0] which corresponds to => |110>)
# Simulate time evolution under H_heis3 Hamiltonian
for _ in range(trotter_steps):
qc.append(Trot_gate, q_regs)
# Evaluate simulation at target_time (t=pi) meaning each trotter step evolves pi/trotter_steps in time
qc = qc.bind_parameters({t: target_time/trotter_steps})
# Generate state tomography circuits to evaluate fidelity of simulation
st_qcs = state_tomography_circuits(qc, q_regs)
# Display circuit for confirmation
# st_qcs[-1].decompose().draw() # view decomposition of trotter gates
st_qcs[-1].draw() # only view trotter gates
shots = 8192
reps = 4
# Pick the simulated or real backend for manila
# backend = sim # Noiseless simulator
backend = sim_noisy_manila # Simulator that mimics ibmq_manila
# backend = manila # The real manila backend
jobs = []
for _ in range(reps):
# Execute
job = execute(st_qcs, backend, shots=shots)
print('Job ID', job.job_id())
jobs.append(job)
for job in jobs:
job_monitor(job)
try:
if job.error_message() is not None:
print(job.error_message())
except:
pass
# Compute the state tomography based on the st_qcs quantum circuits and the results from those ciricuits
def state_tomo(result, st_qcs):
# The expected final state; necessary to determine state tomography fidelity
target_state = (One^One^Zero).to_matrix() # DO NOT MODIFY
# Fit state tomography results
tomo_fitter = StateTomographyFitter(result, st_qcs)
rho_fit = tomo_fitter.fit(method='lstsq')
# Compute fidelity
fid = state_fidelity(rho_fit, target_state)
return fid
# Compute tomography fidelities for each repetition
fids = []
for job in jobs:
fid = state_tomo(job.result(), st_qcs)
fids.append(fid)
# Share tomography fidelity of discord to compete and collaborate with other students
print('state tomography fidelity on ' + str(backend) + ' = {:.4f} \u00B1 {:.4f}'.format(np.mean(fids), np.std(fids)))
# Share what lectures and techniques were useful in optimizing your results
print('Inspiration: Measurement error mitigation, Olivia Lanes\'s 2nd lecture')
import qiskit.tools.jupyter
%qiskit_version_table
|
https://github.com/greatdevaks/geopython-qiskit
|
greatdevaks
|
import numpy as np
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile, assemble, Aer, IBMQ
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from ibm_quantum_widgets import *
# Importing basic math libraries
from math import pi, sqrt
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
# Definining the simulator: statevector_simulator, or qasm_simulator
simulator = "qasm_simulator"
# Function to plot the Quantum Circuit / Quantum State
def get_plot(quantum_circuit):
"""
Parameters:
quantum_circuit: The Quantum Circuit to visualize
Returns:
return: Plot/Visualization of the Quantum State
"""
sim = Aer.get_backend(simulator)
quantum_object = assemble(quantum_circuit)
if simulator == "statevector_simulator":
result = sim.run(quantum_object).result()
statevector = result.get_statevector()
return plot_bloch_multivector(statevector)
elif simulator == "qasm_simulator":
result = sim.run(quantum_object).result()
count = result.get_counts()
return plot_histogram(count)
# Creating a single qubit Quantum Circuit
num_qubits = 2
qc = QuantumCircuit(num_qubits) # Creates a Quantum Circuit with 1 qubit
num_input_qubits = num_qubits # defines the number of qubits in the circuit
num_output_qubits = num_qubits # defines the number of output bits that we want to extract from the circuit
# Note: The extraction of output from a Quantum Circuit is done via a process called `measurement`
# Each measurement tells a specific qubit to give an output to a specific output bit
qc_output = QuantumCircuit(num_input_qubits, num_output_qubits) # qc_output is the Quantum Circuit
# Visualizing the Quantum Wire
qc_output.draw() # Drawing the Quantum Circuit
# Here C is represents the measurement results / count
# Applying H-gate to the first qubit q0:
qc_output.h(0)
# Applying X-gate to the first qubit q:
qc_output.x(1)
qc_output.draw() # Drawing the Quantum Circuit
# TAKING MEASUREMENT ONLY FOR EXPLANATION PURPOSES
# IN REAL CIRCUITS, MEASUREMENTS SHOULD NOT BE TAKEN LIKE THIS IN THE INTERMEDIATE STATES
# MEASUREMENT CHANGES THE QUBIT'S STATE
# Measuring the results
for qubit in range(num_qubits):
qc_output.measure(qubit, qubit)
qc_output.draw() # Drawing the Quantum Circuit
# Initial state of each qubit is |0>
# After Hadamard gate is applied to q0, q0 can be in 0 or 1 state when measured (as Hadamard Gate
# will bring q0 to some superposition state)
# H q0 => |0> -> |0> or |1>
# Applying Pauli-X Gate on q1 will flip its qubit state
# X q1 => |0> -> |1>
# Quantum State analysis for the above circuit
# q0 q1 output
# 0 1 0 1
# 1 1 1 1
# Getting the plot and visualization
get_plot(qc_output)
# Applying a CNOT gate from qubit q0 to qubit q1:
qc_output.cx(0,1)
qc_output.draw() # Drawing the Quantum Circuit
# Measuring the results
for qubit in range(num_qubits):
qc_output.measure(qubit, qubit)
# Visualizing the Quantum Circuit using Simulator
qc_output.draw() # Drawing the Quantum Circuit
# Quantum State analysis for the previously measure circuit
# q0 q1 output
# 0 1 0 1
# 1 1 1 1
# Applying CNOT Gate on from q0 to q1 will conditionally flip the q1 qubit
# q0 q1 output
# 0 1 0 1
# 1 1 1 0
# Getting the plot and visualization
get_plot(qc_output)
|
https://github.com/greatdevaks/geopython-qiskit
|
greatdevaks
|
import numpy as np
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile, assemble, Aer, IBMQ
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from ibm_quantum_widgets import *
# Importing basic math libraries
from math import pi, sqrt
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
# Definining the simulator: statevector_simulator, or qasm_simulator
simulator = "statevector_simulator"
# Function to plot the Quantum Circuit / Quantum State
def get_plot(quantum_circuit):
"""
Parameters:
quantum_circuit: The Quantum Circuit to visualize
Returns:
return: Plot/Visualization of the Quantum State
"""
sim = Aer.get_backend(simulator)
quantum_object = assemble(quantum_circuit)
if simulator == "statevector_simulator":
result = sim.run(quantum_object).result()
statevector = result.get_statevector()
return plot_bloch_multivector(statevector)
elif simulator == "qasm_simulator":
result = sim.run(quantum_object).result()
count = result.get_counts()
return plot_histogram(count)
# Creating a single qubit Quantum Circuit
num_qubits = 1
qc = QuantumCircuit(num_qubits) # Creates a Quantum Circuit with 1 qubit
# Visualizing the Quantum Wire
qc.draw() # Drawing the Quantum Circuit
# Visualizing the Quantum Circuit using Simulator
get_plot(qc) # Drawing the Quantum Circuit
# Pauli-X Gate Demonstration
# Let's do an X-gate on a |0> qubit
qc.x(0) # Applies Pauli-X Gate to the |0> qubit
qc.draw() # Drawing the Quantum Circuit
# Visualize the Quantum Circuit using Simulator
get_plot(qc)
|
https://github.com/mhlr/qiskit-meetup
|
mhlr
|
#%pip install qiskit-aqua qiskit
from qiskit.visualization import iplot_histogram, plot_histogram
%pylab inline
import qiskit as qk
qr = qk.QuantumRegister(2)
cr = qk.ClassicalRegister(2)
qc = qk.QuantumCircuit(qr,cr)
qc.h(qr[0])
qc.draw(output='mpl')
qc.cx(qr[0], qr[1])
qc.draw(output='mpl')
qc.measure(qr,cr)
qc.draw(output='mpl')
qk.Aer.backends()
sim = qk.Aer.get_backend('qasm_simulator')
res = qk.execute(qc, sim).result()
res
plot_histogram(res.get_counts())
from qiskit import IBMQ
IBMQ.delete_account()
IBMQ.save_account('4fd56...',
overwrite=True) # the token you obtained above
IBMQ.load_account()
provider = IBMQ.get_provider()
procs=provider.backends(operational=True, simulator=False)
procs
from qiskit.tools.jupyter import *
%qiskit_backend_overview
from qiskit.tools import monitor
backend = qk.providers.ibmq.least_busy([p for p in procs if len(p.properties().qubits) >= 2])
from qiskit.tools.monitor import backend_overview, backend_monitor
backend_monitor(backend)
#%%qiskit_job_status
#%%qiskit_progress_bar
%time job = qk.execute(qc, backend=backend, shots=2**10)
#mon = monitor.job_monitor(job)
%time res2 = job.result()
plot_histogram(res2.get_counts(qc))
res2.get_counts(qc)
|
https://github.com/AbeerVaishnav13/Using-Qiskit
|
AbeerVaishnav13
|
import qiskit as q
%matplotlib inline
circuit = q.QuantumCircuit(3, 2)
# Grover Search algorithm for 2 qubits and 1 control bit
# Preparation using superposition
circuit.h(0)
circuit.h(1)
circuit.x(2)
circuit.h(2)
circuit.barrier()
# Function Uw
circuit.x(0)
circuit.ccx(0, 1, 2)
circuit.x(0)
circuit.barrier()
# Function Us
circuit.h(0)
circuit.h(1)
circuit.x(0)
circuit.x(1)
circuit.ccx(0, 1, 2)
circuit.x(0)
circuit.x(1)
circuit.h(0)
circuit.h(1)
circuit.barrier()
# Measure
circuit.measure([0, 1], [0, 1])
# Draw the circuit
circuit.draw()
circuit.draw(output='mpl')
from qiskit import IBMQ
# IBM-Q Account credentials initialization
IBMQ.load_account()
# List all backends available with us
provider = IBMQ.get_provider('ibm-q')
for backend in provider.backends():
try:
qubit_count = len(backend.properties().qubits)
except:
qubit_count = 'simulated'
print(f'{backend.name()} ({qubit_count}) : {backend.status().pending_jobs} queued job(s).')
from qiskit.tools.monitor import job_monitor
# Executing a job on the IBM-Q quantum computer
backend = provider.get_backend('ibmq_ourense')
job = q.execute(circuit, backend = backend, shots = 1024)
job_monitor(job)
from qiskit.visualization import plot_histogram
from matplotlib import style
style.use('dark_background')
# Display histogram for results
result = job.result()
counts = result.get_counts(circuit)
plot_histogram([counts])
# Trying on ibmq-qasm-simulator
sim_backend = provider.get_backend('ibmq_qasm_simulator')
sim_job = q.execute(circuit, backend = sim_backend, shots = 1024)
job_monitor(sim_job)
# Results of the ibmq-qasm-simulator
sim_result = sim_job.result()
sim_counts = sim_result.get_counts(circuit)
plot_histogram([sim_counts])
|
https://github.com/AbeerVaishnav13/Using-Qiskit
|
AbeerVaishnav13
|
import numpy as np
from qiskit import *
from qiskit.visualization import plot_histogram, plot_gate_map
from qiskit.tools.monitor import job_monitor
from qiskit.test.mock import FakeProvider
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')
%matplotlib inline
backends = list(filter(lambda x:
not (x.configuration().simulator or
x.configuration().n_qubits <= 5),
FakeProvider().backends()))
ghz = QuantumCircuit(5, 5)
ghz.h(0)
for idx in range(1, 5):
ghz.cx(0, idx)
ghz.barrier()
ghz.measure(range(5), range(5))
ghz.draw(output='mpl')
ghz_basis = ghz.decompose()
ghz_basis.draw(output='mpl')
import inspect
inspect.signature(transpile)
qc = QuantumCircuit(3, 2)
# Preparation using superposition
qc.h(0)
qc.h(1)
qc.x(2)
qc.h(2)
qc.barrier()
# Function Uw
qc.x(0)
qc.ccx(0, 1, 2)
qc.x(0)
qc.barrier()
# Function Us
qc.h(0)
qc.h(1)
qc.x(0)
qc.x(1)
qc.ccx(0, 1, 2)
qc.x(0)
qc.x(1)
qc.h(0)
qc.h(1)
qc.barrier()
# Measure
qc.measure([0, 1], [0, 1])
qc.draw(output='mpl')
qc_basis = qc.decompose()
qc_basis.draw(output='mpl')
print(qc.depth(), ', ', qc_basis.depth())
# Without barrier
qc = QuantumCircuit(3, 2)
# Preparation using superposition
qc.h(0)
qc.h(1)
qc.x(2)
qc.h(2)
# Function Uw
qc.x(0)
qc.ccx(0, 1, 2)
qc.x(0)
# Function Us
qc.h(0)
qc.h(1)
qc.x(0)
qc.x(1)
qc.ccx(0, 1, 2)
qc.x(0)
qc.x(1)
qc.h(0)
qc.h(1)
# Measure
qc.measure([0, 1], [0, 1])
qc.draw(output='mpl')
qc_basis = qc.decompose()
qc_basis.draw(output='mpl')
print(qc.depth(), ', ', qc_basis.depth())
|
https://github.com/at2005/hodl-qiskit
|
at2005
|
from qiskit import *
from qiskit.visualization import plot_histogram
import re
import subprocess
import os
### define a class to hold hodl oracle code alongside parameters
### this allows many instances of an oracle to be defined --> not limited to
### input-dependent compilation
class HODLOracle:
def __init__(self, func_name, init_params, program):
### accepts body of the oracle, parameters to the oracle in order, and the oracle name
self.program = program
self.params = init_params
self.fname = func_name
### compilation function --> this takes an oracle instance, generates a HODL program,
### invokes the compiler binary, converts the output assembly to a qiskit circuit, and returns it
def to_circ(self,params):
main = "function main() {"
### iterate over each parameter and if a quantum register then declare it as
### a |0>^n register. This initialization is such so that the circuit can be concatenated
## with any desired input register
param_lst = []
for q in params:
if isinstance(q, QuantumRegister):
main += f"\nsuper {q.name} = {2**(q.size)};\nH({q.name});"
param_lst.append(q.name)
else:
param_lst.append(str(q))
main += f"\n{self.fname}({','.join(param_lst)});"
result = self.program + main + "\n}"
f = open("program.hodl", "w")
f.write(result)
f.close()
os.system("hodl --target qasm -o out.qasm program.hodl")
circ = QuantumCircuit.from_qasm_file("out.qasm")
os.remove("program.hodl")
os.remove("out.qasm")
return circ
### takes an oracle and outputs a HODL object
def init_oracle(code):
fname = re.search("function (.*)\(", code).group(1)
params = re.search("\((.*)\)",code).group(1)
params = params.split(",")
### parameter map --> {type: name}
param_dict = {}
for p in params:
p = p.split()
param_dict[p[0]] = p[1]
oracle = HODLOracle(fname, param_dict, code)
return oracle
|
https://github.com/oierajenjo/q-Grover-Algorithm
|
oierajenjo
|
import qiskit
qiskit.__qiskit_version__
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
# importing Qiskit
from qiskit import BasicAer, IBMQ
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.compiler import transpile
from qiskit.tools.visualization import plot_histogram
q = QuantumRegister(6)
qc = QuantumCircuit(q)
qc.x(q[2])
qc.cx(q[1], q[5])
qc.cx(q[2], q[5])
qc.cx(q[3], q[5])
qc.ccx(q[1], q[2], q[4])
qc.ccx(q[3], q[4], q[5])
qc.ccx(q[1], q[2], q[4])
qc.x(q[2])
qc.draw(output='mpl')
def black_box_u_f(circuit, f_in, f_out, aux, n, exactly_1_3_sat_formula):
"""Circuit that computes the black-box function from f_in to f_out.
Create a circuit that verifies whether a given exactly-1 3-SAT
formula is satisfied by the input. The exactly-1 version
requires exactly one literal out of every clause to be satisfied.
"""
num_clauses = len(exactly_1_3_sat_formula)
for (k, clause) in enumerate(exactly_1_3_sat_formula):
# This loop ensures aux[k] is 1 if an odd number of literals
# are true
for literal in clause:
if literal > 0:
circuit.cx(f_in[literal-1], aux[k])
else:
circuit.x(f_in[-literal-1])
circuit.cx(f_in[-literal-1], aux[k])
# Flip aux[k] if all literals are true, using auxiliary qubit
# (ancilla) aux[num_clauses]
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
circuit.ccx(f_in[2], aux[num_clauses], aux[k])
# Flip back to reverse state of negative literals and ancilla
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
for literal in clause:
if literal < 0:
circuit.x(f_in[-literal-1])
# The formula is satisfied if and only if all auxiliary qubits
# except aux[num_clauses] are 1
if (num_clauses == 1):
circuit.cx(aux[0], f_out[0])
elif (num_clauses == 2):
circuit.ccx(aux[0], aux[1], f_out[0])
elif (num_clauses == 3):
circuit.ccx(aux[0], aux[1], aux[num_clauses])
circuit.ccx(aux[2], aux[num_clauses], f_out[0])
circuit.ccx(aux[0], aux[1], aux[num_clauses])
else:
raise ValueError('We only allow at most 3 clauses')
# Flip back any auxiliary qubits to make sure state is consistent
# for future executions of this routine; same loop as above.
for (k, clause) in enumerate(exactly_1_3_sat_formula):
for literal in clause:
if literal > 0:
circuit.cx(f_in[literal-1], aux[k])
else:
circuit.x(f_in[-literal-1])
circuit.cx(f_in[-literal-1], aux[k])
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
circuit.ccx(f_in[2], aux[num_clauses], aux[k])
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
for literal in clause:
if literal < 0:
circuit.x(f_in[-literal-1])
# -- end function
def n_controlled_Z(circuit, controls, target):
"""Implement a Z gate with multiple controls"""
if (len(controls) > 2):
raise ValueError('The controlled Z with more than 2 ' +
'controls is not implemented')
elif (len(controls) == 1):
circuit.h(target)
circuit.cx(controls[0], target)
circuit.h(target)
elif (len(controls) == 2):
circuit.h(target)
circuit.ccx(controls[0], controls[1], target)
circuit.h(target)
# -- end function
def inversion_about_average(circuit, f_in, n):
"""Apply inversion about the average step of Grover's algorithm."""
# Hadamards everywhere
for j in range(n):
circuit.h(f_in[j])
# D matrix: flips the sign of the state |000> only
for j in range(n):
circuit.x(f_in[j])
n_controlled_Z(circuit, [f_in[j] for j in range(n-1)], f_in[n-1])
for j in range(n):
circuit.x(f_in[j])
# Hadamards everywhere again
for j in range(n):
circuit.h(f_in[j])
# -- end function
qr = QuantumRegister(3)
qInvAvg = QuantumCircuit(qr)
inversion_about_average(qInvAvg, qr, 3)
qInvAvg.draw(output='mpl')
"""
Grover search implemented in Qiskit.
This module contains the code necessary to run Grover search on 3
qubits, both with a simulator and with a real quantum computing
device. This code is the companion for the paper
"An introduction to quantum computing, without the physics",
Giacomo Nannicini, https://arxiv.org/abs/1708.03684.
"""
def input_state(circuit, f_in, f_out, n):
"""(n+1)-qubit input state for Grover search."""
for j in range(n):
circuit.h(f_in[j])
circuit.x(f_out)
circuit.h(f_out)
# -- end function
# Make a quantum program for the n-bit Grover search.
n = 3
# Exactly-1 3-SAT formula to be satisfied, in conjunctive
# normal form. We represent literals with integers, positive or
# negative, to indicate a Boolean variable or its negation.
exactly_1_3_sat_formula = [[1, 2, -3], [-1, -2, -3], [-1, 2, 3]]
# Define three quantum registers: 'f_in' is the search space (input
# to the function f), 'f_out' is bit used for the output of function
# f, aux are the auxiliary bits used by f to perform its
# computation.
f_in = QuantumRegister(n)
f_out = QuantumRegister(1)
aux = QuantumRegister(len(exactly_1_3_sat_formula) + 1)
# Define classical register for algorithm result
ans = ClassicalRegister(n)
# Define quantum circuit with above registers
grover = QuantumCircuit()
grover.add_register(f_in)
grover.add_register(f_out)
grover.add_register(aux)
grover.add_register(ans)
input_state(grover, f_in, f_out, n)
T = 2
for t in range(T):
# Apply T full iterations
black_box_u_f(grover, f_in, f_out, aux, n, exactly_1_3_sat_formula)
inversion_about_average(grover, f_in, n)
# Measure the output register in the computational basis
for j in range(n):
grover.measure(f_in[j], ans[j])
# Execute circuit
backend = BasicAer.get_backend('qasm_simulator')
job = execute([grover], backend=backend, shots=1000)
result = job.result()
# Get counts and plot histogram
counts = result.get_counts(grover)
plot_histogram(counts)
IBMQ.load_account()
# get ibmq_16_melbourne configuration and coupling map
backend = IBMQ.get_backend('ibmq_16_melbourne')
# compile the circuit for ibmq_16_rueschlikon
grover_compiled = transpile(grover, backend=backend, seed_transpiler=1, optimization_level=3)
print('gates = ', grover_compiled.count_ops())
print('depth = ', grover_compiled.depth())
grover.draw(output='mpl', scale=0.5)
|
https://github.com/oierajenjo/q-Grover-Algorithm
|
oierajenjo
|
# -*- 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.
"""
Created on Wed Mar 11 18:03:12 2020
Functional interface to Qasm2 source loading and exporting
Supersede QuantumCircuit member functions
Provide for pluggable qasm translator
Based on conversation with Dr. Luciano Bello
@author: jax
"""
from importlib import import_module
from os import linesep
from typing import List, BinaryIO, TextIO
from qiskit import QuantumCircuit, QiskitError
from qiskit_openqasm2 import Qasm
from .funhelp import qasm_load, qasm_export
def _load_from_string(qasm_src: str or List[str],
loader: str = None,
include_path: str = '') -> QuantumCircuit:
"""
Parameters
----------
qasm_src : str or List[str]
Qasm program source as string or list of string.
loader : str, optional
Name of module with functional attribute
load(filename: str = None,
data: str = None,
include_path: str = None) -> QuantumCircuit:
... to use for qasm translation.
None means "use Qiskit qasm"
The default is None.
include_path : str, optional
Loader-specific include path for qasm include directives.
The default is ''.
Raises
------
QiskitError
If unknown loader.
Returns
-------
QuantumCircuit
Circuit factoried from Qasm src.
"""
circ = None
if not loader:
if isinstance(qasm_src, list):
qasm_src = ''.join(s + linesep for s in qasm_src)
qasm = Qasm(data=qasm_src)
circ = qasm_load(qasm)
else:
m_m = import_module(loader)
circ = getattr(m_m, 'load')(data=qasm_src,
include_path=include_path)
return circ
def _load_from_file(filename: str,
loader: str = None,
include_path: str = '') -> QuantumCircuit:
"""
Parameters
----------
filename : str
Filepath to qasm program source.
loader : str, optional
Name of module with functional attribute
load(filename: str = None,
data: str = None,
include_path: str = None) -> QuantumCircuit:
... to use for qasm translation.
None means "use Qiskit qasm"
The default is None.
include_path : str, optional
Loader-specific include path for qasm include directives.
The default is ''.
Returns
-------
QuantumCircuit
Circuit factoried from Qasm src.
"""
circ = None
if not loader:
qasm = Qasm(filename=filename)
circ = qasm_load(qasm)
else:
m_m = import_module(loader)
circ = getattr(m_m, 'load')(filename=filename,
include_path=include_path)
return circ
def load(data: str or List[str] = None,
filename: str = None,
loader: str = None,
include_path: str = None) -> QuantumCircuit:
"""
Parameters
----------
data : str or List[str], optional
Qasm program source as string or list of string. The default is None.
filename : str, optional
Filepath to qasm program source. The default is None.
loader : str, optional
Name of module with functional attribute
load(filename: str = None,
data: str = None,
include_path: str = None) -> QuantumCircuit:
... to use for qasm translation.
None means "use Qiskit qasm"
The default is None.
include_path : str, optional
Loader-specific include path for qasm include directives.
The default is None.
Raises
------
QiskitError
If both filename and data or neither filename nor data.
Returns
-------
QuantumCircuit
The factoried circuit.
"""
if (not data and not filename) or (data and filename):
raise QiskitError("To load, either filename or data (and not both) must be provided.")
circ = None
if data:
circ = _load_from_string(data, loader=loader, include_path=include_path)
elif filename:
circ = _load_from_file(filename, loader=loader, include_path=include_path)
return circ
def export(qc: QuantumCircuit,
exporter: str = None,
file: BinaryIO or TextIO = None,
filename: str = None,
include_path: str = None,) -> str:
"""
Decompile a QuantumCircuit into Return OpenQASM string
Parameters
----------
qc : QuantumCircuit
Circuit to decompile ("export")
exporter : str, optional
Name of module with functional attribute
export(qc: QuantumCircuit,
include_path: str = None) -> QuantumCircuit:
... to use for qasm translation.
None means "use Qiskit qasm"
The default is None.
file : BinaryIO or TextIO, optional
File object to write to as well as return str
Written in UTF-8
Caller must close file.
Mutually exclusive with filename=
The default is None.
filename : str, optional
Name of file to write export to as well as return str
Mutually exclusive with file=
The default is None.
include_path: str, optional
Unloader-specific include path for qasm include directives
Raises
------
QiskitError
If both filename and file
Returns
-------
str
OpenQASM source for circuit.
"""
if filename and file:
raise QiskitError("export: file= and filename= are mutually exclusive")
qasm_src = None
if not exporter:
qasm_src = qasm_export(qc)
else:
m_m = import_module(exporter)
qasm_src = getattr(m_m, 'export')(qc, include_path=include_path)
if filename:
f_f = open(filename, 'w')
f_f.write(qasm_src)
f_f.close()
elif file:
if 'b' in file.mode:
file.write(bytes(qasm_src, 'utf-8'))
else:
file.write(qasm_src)
return qasm_src
|
https://github.com/apozas/qaoa-color
|
apozas
|
from functools import reduce
from itertools import product
from qiskit import BasicAer, QuantumRegister
from qiskit_aqua import QuantumInstance
from qiskit_aqua import Operator, run_algorithm
from qiskit.quantum_info import Pauli
from qiskit_aqua.components.optimizers import COBYLA
from constrainedqaoa import constrainedQAOA
import numpy as np
edges = [(0, 0)]
vertices = 1
colors = 2
n_qubits = vertices * colors
zr = np.zeros(n_qubits)
ws = np.eye(n_qubits)
cost_operator = reduce(
lambda x, y: x + y,
[
Operator([[1, (Pauli(ws[colors*v1 + j, :], zr)
*Pauli(ws[colors*v2 + j, :], zr))]])
for (v1, v2), j in product(edges, range(colors))
]
)
mixer_operator = reduce(
lambda x, y: x + y,
[
Operator([[1, (Pauli(zr, ws[colors*i + j, :])
*Pauli(zr, ws[colors*i + (j+1) % colors, :]))]]) +
Operator([[1, (Pauli(ws[colors*i + j % colors, :], ws[colors*i + j % colors, :])
*Pauli(ws[colors*i + (j+1) % colors, :], ws[colors*i + (j+1) % colors, :]))]])
for i, j in product(range(vertices), range(colors))
]
)
if colors == 2:
mixer_operator.scaling_coeff(1/2)
print(mixer_operator.print_operators())
what = 'circuit'
circ = mixer_operator.evolve(np.eye(4), np.pi*0.35, what, 1, QuantumRegister(2))
if what == 'matrix':
print(np.round(circ, 4))
elif what == 'circuit':
print(circ.draw())
cobyla = COBYLA()
cobyla.set_options(maxiter=250)
constrained = constrainedQAOA(cost_operator, cobyla, mixer_operator, 1)
backend = BasicAer.get_backend('statevector_simulator')
seed = 50
constrained.random_seed = seed
quantum_instance = QuantumInstance(backend=backend, seed=seed, seed_mapper=seed)
result = constrained.run(quantum_instance)
result['eigvecs']
|
https://github.com/apozas/qaoa-color
|
apozas
|
#!/usr/bin/env python
# coding: utf-8
# In[65]:
# useful additional packages
import matplotlib.pyplot as plt
get_ipython().run_line_magic('matplotlib', 'inline')
import numpy as np
import time
from pprint import pprint
# importing Qiskit
from qiskit import Aer, IBMQ
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
# import basic plot tools
from qiskit.tools.visualization import plot_histogram
# In[72]:
"Choice of the backend"
# using local qasm simulator
backend = Aer.get_backend('qasm_simulator')
# using IBMQ qasm simulator
# backend = IBMQ.get_backend('ibmq_qasm_simulator')
# using real device
# backend = least_busy(IBMQ.backends(simulator=False))
flag_qx2 = True
if backend.name() == 'ibmqx4':
flag_qx2 = False
print("Your choice for the backend is: ", backend, "flag_qx2 is: ", flag_qx2)
# In[73]:
# Here, two useful routine
# Define a F_gate
def G_gate(circ, p, q , i, j) :
theta = np.arctan(np.sqrt(p/(1-p)))
circ.ry(theta,q[j])
circ.cx(q[i],q[j])
circ.ry(-theta,q[j])
#circ.cx(q[i],q[j])
circ.barrier(q[i])
# Define the cxrv gate which uses reverse CNOT instead of CNOT
def cxrv(circ,q,i,j) :
circ.h(q[i])
circ.h(q[j])
circ.cx(q[j],q[i])
circ.h(q[i])
circ.h(q[j])
circ.barrier(q[i],q[j])
# In[78]:
# 3-qubit W state
n = 8
q = QuantumRegister(n)
c = ClassicalRegister(n)
W_states = QuantumCircuit(q,c)
W_states.x(q[n-1]) #start is |100>
# In[79]:
for i in range(1,n) :
p=1/(n+1-i)
print(n-i, n-i-1, p)
print(p/(1-p))
print(np.arctan(np.sqrt(p/(1-p)))*180/3.14)
G_gate(W_states, p, q, n-i, n-i-1)
W_states.cx(q[n-i-1], q[n-i])
# In[80]:
for i in range(n) :
W_states.measure(q[i] , c[i])
shots = 10000
time_exp = time.strftime('%d/%m/%Y %H:%M:%S')
print('start W state 3-qubit on', backend, "N=", shots,time_exp)
result = execute(W_states, backend=backend, shots=shots)
time_exp = time.strftime('%d/%m/%Y %H:%M:%S')
print('end W state 3-qubit on', backend, "N=", shots,time_exp)
W_states.draw(output="mpl")
plot_histogram(result.result().get_counts(W_states))
# In[81]:
# In[ ]:
|
https://github.com/apozas/qaoa-color
|
apozas
|
from functools import reduce
from itertools import product
from qiskit import BasicAer, QuantumRegister, ClassicalRegister
from qiskit_aqua import QuantumInstance
from qiskit_aqua import Operator, run_algorithm
from qiskit.quantum_info import Pauli
from qiskit_aqua.components.optimizers import COBYLA
from qiskit_aqua.algorithms import QAOA
import numpy as np
import qutip as qt
from qiskit_aqua.components.initial_states import Custom
edges = [(0, 1), (1, 2), (2, 3)]
colors = 4
vertices = max(reduce(lambda x, y: x + y, [list(edge) for edge in edges])) + 1
logcolors = int(np.log2(colors))
n_qubits = int(vertices * logcolors)
zr = np.zeros(n_qubits)
ws = np.eye(n_qubits)
up = qt.basis(2, 0)
dn = qt.basis(2, 1)
cost_operator = reduce(
lambda x, y: x + y,
[
Operator([[1, (Pauli(ws[logcolors*v1 + j, :], zr)
*Pauli(ws[logcolors*v2 + j, :], zr))]])
for (v1, v2), j in product(edges, range(logcolors))
]
)
cobyla = COBYLA()
cobyla.set_options(maxiter=250)
p = 2 # steps of QAOA
constrained = QAOA(cost_operator, cobyla, p)
backend = BasicAer.get_backend('statevector_simulator')
seed = 50
constrained.random_seed = seed
quantum_instance = QuantumInstance(backend=backend, seed=seed, seed_mapper=seed)
result = constrained.run(quantum_instance)
result['eigvals']
result['opt_params']
result['eigvecs']
|
https://github.com/apozas/qaoa-color
|
apozas
|
from functools import reduce
from itertools import product
from qiskit import BasicAer, QuantumRegister
from qiskit_aqua import QuantumInstance
from qiskit_aqua import Operator, run_algorithm
from qiskit.quantum_info import Pauli
from qiskit_aqua.components.optimizers import COBYLA
from qiskit_aqua.components.initial_states import Custom
from constrainedqaoa import constrainedQAOA
import numpy as np
import qutip as qt
edges = [(0, 1), (1, 2), (2, 3)]
vertices = max(reduce(lambda x, y: x + y, [list(edge) for edge in edges])) + 1
colors = 2
n_qubits = vertices * colors
zr = np.zeros(n_qubits)
ws = np.eye(n_qubits)
up = qt.basis(2, 0)
dn = qt.basis(2, 1)
def W(size, copies):
initial_list = [dn] + [up] * (size - 1)
cycles = [[initial_list[i - j] for i in range(size)] for j in range(size)]
W_1copy = sum([qt.tensor(states) for states in cycles])
return qt.tensor([W_1copy] * copies)
amplitudes = W(colors, vertices).full().T.tolist()[0]
init_state = Custom(n_qubits, state_vector=amplitudes)
cost_operator = reduce(
lambda x, y: x + y,
[
Operator([[1, (Pauli(ws[colors*v1 + j, :], zr)
*Pauli(ws[colors*v2 + j, :], zr))]])
for (v1, v2), j in product(edges, range(colors))
]
)
mixer_operator = reduce(
lambda x, y: x + y,
[
Operator([[1, (Pauli(zr, ws[colors*i + j, :])
*Pauli(zr, ws[colors*i + (j+1) % colors, :]))]]) +
Operator([[1, (Pauli(ws[colors*i + j % colors, :], ws[colors*i + j % colors, :])
*Pauli(ws[colors*i + (j+1) % colors, :], ws[colors*i + (j+1) % colors, :]))]])
for i, j in product(range(vertices), range(colors))
]
)
# Fix redundancies
if colors == 2:
mixer_operator.scaling_coeff(1/2)
cobyla = COBYLA()
cobyla.set_options(maxiter=250)
p = 1 # steps of QAOA
constrained = constrainedQAOA(cost_operator, cobyla, mixer_operator, p, init_state)
backend = BasicAer.get_backend('statevector_simulator')
seed = 50
constrained.random_seed = seed
quantum_instance = QuantumInstance(backend=backend, seed=seed, seed_mapper=seed)
result = constrained.run(quantum_instance)
result['eigvals']
np.round(result['eigvecs'], 4)
np.savetxt('4_line_2colors_p1', result['eigvecs'][0])
|
https://github.com/apozas/qaoa-color
|
apozas
|
# Copied and modified from qiskit_aqua.algorithms.adaptive.qaoa.qaoa.py
# and qiskit_aqua.algorithms.adaptive.qaoa.varform.py
# =============================================================================
import logging
from qiskit_aqua.algorithms import QuantumAlgorithm
from qiskit_aqua import AquaError, PluggableType, get_pluggable_class
from qiskit_aqua.algorithms.adaptive import VQE
from qiskit_aqua.algorithms.adaptive.qaoa.varform import QAOAVarForm
logger = logging.getLogger(__name__)
class constrainedQAOA(VQE):
"""
The Quantum Approximate Optimization Algorithm.
See https://arxiv.org/abs/1411.4028
"""
CONFIGURATION = {
'name': 'QAOA.Variational',
'description': 'Quantum Approximate Optimization Algorithm',
'input_schema': {
'$schema': 'http://json-schema.org/schema#',
'id': 'qaoa_schema',
'type': 'object',
'properties': {
'operator_mode': {
'type': 'string',
'default': 'matrix',
'oneOf': [
{'enum': ['matrix', 'paulis', 'grouped_paulis']}
]
},
'p': {
'type': 'integer',
'default': 1,
'minimum': 1
},
'initial_point': {
'type': ['array', 'null'],
"items": {
"type": "number"
},
'default': None
},
'batch_mode': {
'type': 'boolean',
'default': False
}
},
'additionalProperties': False
},
'problems': ['ising'],
'depends': ['optimizer'],
'defaults': {
'optimizer': {
'name': 'COBYLA'
},
}
}
def __init__(self, cost, optimizer, mixer, p=1, initial_state=None, operator_mode='matrix', initial_point=None,
batch_mode=False, aux_operators=None):
"""
Args:
operator (Operator): Qubit operator
operator_mode (str): operator mode, used for eval of operator
p (int) : the integer parameter p as specified in https://arxiv.org/abs/1411.4028
optimizer (Optimizer) : the classical optimization algorithm.
initial_point (numpy.ndarray) : optimizer initial point.
"""
self.validate(locals())
var_form = constrainedQAOAVarForm(cost, p, mixer, initial_state)
super().__init__(cost, var_form, optimizer,
operator_mode=operator_mode, initial_point=initial_point)
@classmethod
def init_params(cls, params, algo_input):
"""
Initialize via parameters dictionary and algorithm input instance
Args:
params (dict): parameters dictionary
algo_input (EnergyInput): EnergyInput instance
"""
if algo_input is None:
raise AquaError("EnergyInput instance is required.")
operator = algo_input.qubit_op
qaoa_params = params.get(QuantumAlgorithm.SECTION_KEY_ALGORITHM)
operator_mode = qaoa_params.get('operator_mode')
p = qaoa_params.get('p')
initial_point = qaoa_params.get('initial_point')
batch_mode = qaoa_params.get('batch_mode')
# Set up optimizer
opt_params = params.get(QuantumAlgorithm.SECTION_KEY_OPTIMIZER)
optimizer = get_pluggable_class(PluggableType.OPTIMIZER,
opt_params['name']).init_params(opt_params)
return cls(operator, optimizer, p=p, operator_mode=operator_mode,
initial_point=initial_point, batch_mode=batch_mode,
aux_operators=algo_input.aux_ops)
class constrainedQAOAVarForm(QAOAVarForm):
def __init__(self, cost_operator, p, mixer_operator=None, initial_state=None):
super().__init__(cost_operator, p, initial_state)
if mixer_operator is None:
v = np.zeros(self._cost_operator.num_qubits)
ws = np.eye(self._cost_operator.num_qubits)
self._mixer_operator = reduce(
lambda x, y: x + y,
[
Operator([[1, Pauli(v, ws[i, :])]])
for i in range(self._cost_operator.num_qubits)
]
)
else:
self._mixer_operator = mixer_operator
from functools import reduce
from itertools import product
from qiskit import BasicAer, QuantumRegister
from qiskit_aqua import QuantumInstance
from qiskit_aqua import Operator, run_algorithm
from qiskit.quantum_info import Pauli
from qiskit_aqua.components.optimizers import COBYLA
from qiskit_aqua.components.initial_states import Custom
#from constrainedqaoa import constrainedQAOA
import numpy as np
import qutip as qt
edges = [(0, 1), (1, 2), (2, 0)]
vertices = 3
colors = 3
n_qubits = vertices * colors
zr = np.zeros(n_qubits)
ws = np.eye(n_qubits)
up = qt.basis(2, 0)
dn = qt.basis(2, 1)
def W(size, copies):
initial_list = [dn] + [up] * (size - 1)
cycles = [[initial_list[i - j] for i in range(size)] for j in range(size)]
W_1copy = sum([qt.tensor(states) for states in cycles])
return qt.tensor([W_1copy] * copies)
amplitudes = W(colors, vertices).full().T.tolist()[0]
init_state = Custom(n_qubits, state_vector=amplitudes)
W(colors, vertices)
cost_operator = reduce(
lambda x, y: x + y,
[
Operator([[1, (Pauli(ws[colors*v1 + j, :], zr)
*Pauli(ws[colors*v2 + j, :], zr))]])
for (v1, v2), j in product(edges, range(colors))
]
)
mixer_operator = reduce(
lambda x, y: x + y,
[
Operator([[1, (Pauli(zr, ws[colors*i + j, :])
*Pauli(zr, ws[colors*i + (j+1) % colors, :]))]]) +
Operator([[1, (Pauli(ws[colors*i + j % colors, :], ws[colors*i + j % colors, :])
*Pauli(ws[colors*i + (j+1) % colors, :], ws[colors*i + (j+1) % colors, :]))]])
for i, j in product(range(vertices), range(colors))
]
)
# Fix redundancies
if colors == 2:
mixer_operator.scaling_coeff(1/2)
cobyla = COBYLA()
cobyla.set_options(maxiter=250)
p = 1 # steps of QAOA
constrained = constrainedQAOA(cost_operator, cobyla, mixer_operator, p, init_state)
from qiskit import IBMQ
IBMQ.load_accounts()
# Please input the 20 qubit architecture!
backend = IBMQ.get_backend('ibmq_20_tokyo')
quantum_instance = QuantumInstance(backend=backend_melbourne)
result = constrained.run(quantum_instance)
result['eigvals']
np.round(result['eigvecs'], 4)
result['eval_count']
np.savetxt('3_triangle_3colors_p1_20q_qpu', result['eigvecs'][0])
|
https://github.com/apozas/qaoa-color
|
apozas
|
import qiskit
qiskit.__version__
from functools import reduce
from itertools import product
from qiskit import BasicAer, QuantumRegister
from qiskit_aqua import QuantumInstance
from qiskit_aqua import Operator, run_algorithm
from qiskit.quantum_info import Pauli
from qiskit_aqua.components.optimizers import COBYLA
from qiskit_aqua.components.initial_states import Custom
from constrainedqaoa import constrainedQAOA
import numpy as np
import qutip as qt
edges = [(0, 1), (1, 2), (2, 3)]
vertices = 4
colors = 2
n_qubits = vertices * colors
zr = np.zeros(n_qubits)
ws = np.eye(n_qubits)
up = qt.basis(2, 0)
dn = qt.basis(2, 1)
reduce(
lambda x, y: x + y, [list(edge) for edge in edges])
def W(size, copies):
initial_list = [dn] + [up] * (size - 1)
cycles = [[initial_list[i - j] for i in range(size)] for j in range(size)]
W_1copy = sum([qt.tensor(states) for states in cycles])
return qt.tensor([W_1copy] * copies)
amplitudes = W(colors, vertices).full().T.tolist()[0]
init_state = Custom(n_qubits, state_vector=amplitudes)
W(colors, vertices)
cost_operator = reduce(
lambda x, y: x + y,
[
Operator([[1, (Pauli(ws[colors*v1 + j, :], zr)
*Pauli(ws[colors*v2 + j, :], zr))]])
for (v1, v2), j in product(edges, range(colors))
]
)
mixer_operator = reduce(
lambda x, y: x + y,
[
Operator([[1, (Pauli(zr, ws[colors*i + j, :])
*Pauli(zr, ws[colors*i + (j+1) % colors, :]))]]) +
Operator([[1, (Pauli(ws[colors*i + j % colors, :], ws[colors*i + j % colors, :])
*Pauli(ws[colors*i + (j+1) % colors, :], ws[colors*i + (j+1) % colors, :]))]])
for i, j in product(range(vertices), range(colors))
]
)
# Fix redundancies
if colors == 2:
mixer_operator.scaling_coeff(1/2)
cobyla = COBYLA()
cobyla.set_options(maxiter=250)
p = 2 # steps of QAOA
constrained = constrainedQAOA(cost_operator, cobyla, mixer_operator, p, init_state)
from qiskit import BasicAer
backend = BasicAer.get_backend('statevector_simulator')
seed = 50
constrained.random_seed = seed
quantum_instance = QuantumInstance(backend=backend, seed=seed, seed_mapper=seed)
result = constrained.run(quantum_instance)
result['eigvals']
np.round(result['eigvecs'], 4)
result['eval_count']
|
https://github.com/apozas/qaoa-color
|
apozas
|
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit import IBMQ
from qiskit import BasicAer, execute
from qiskit.providers.aer import QasmSimulator
from qiskit.tools.visualization import plot_histogram
import matplotlib.pyplot as plt
import numpy as np
import numpy.random as rand
import networkx as nx
from random_graph import random_graph
from itertools import product
#take a state vector and turn it into an array for
vertices=2
colors=2
qubits=vertices*colors
#Assume qubits (0,1) represent (red0,blue0) and (2,3) represent (red1,blue1)
#lists of q and c registers
qr=QuantumRegister(qubits)
cr=ClassicalRegister(qubits)
#for i in range(vertices):
# #make a list of quantum registers for the qubits in each vertex with a qubit in each register for each color
# vertex_q_registers.append(QuantumRegister(colors))
# vertext_c_registers.append(ClassicalRegister(colors))
circ=QuantumCircuit(qr,cr)
#circ=QuantumCircuit(vertex_q_regs[i] for i in range(vertices),vertex_c_regs[i] for i in range(vertices))
#generage some sample state
for i in range(qubits):
circ.h(qr[i])
circ.measure(qr,cr)
backend_sim=BasicAer.get_backend('qasm_simulator')
result=execute(circ, backend_sim).result()
counts=result.get_counts(circ)
plot_histogram(counts)
#for n qubits what construct the hamming weight 1 binary strings
#data={'1001':30,'1101':11,'0101':15}
data=counts
bad_strings=[]
good_data={}
dumpster={'bad':0}
for k,v in data.items():
for j in range(vertices):
if k[j*colors:(j+1)*colors].count('1') != 1 and k not in bad_strings:
bad_strings.append(k)
for i in bad_strings:
dumpster['bad'] += data[i]
for k,v in data.items():
if k not in bad_strings:
good_data[k]=v
color_data={}
if colors==2:
for k,v in good_data.items():
color_code=''
for j in range(vertices):
if k[j*colors:(j+1)*colors]=='01':
color_code+='0'
else:
color_code+='1'
color_data[k]=color_code
elif colors==3:
for k,v in good_data.items():
color_code=''
for j in range(vertices):
if k[j*colors:(j+1)*colors]=='001':
color_code+='0'
elif k[j*colors:(j+1)*colors]=='010':
color_code+='1'
else:
color_code+='2'
color_data[k]=color_code
elif colors==4:
for k,v in good_data.items():
color_code=''
for j in range(vertices):
if k[j*colors:(j+1)*colors]=='0001':
color_code+='0'
elif k[j*colors:(j+1)*colors]=='0010':
color_code+='1'
elif k[j*colors:(j+1)*colors]=='0010':
color_code+='2'
else:
color_code+='3'
color_data[k]=color_code
best_solution=max(good_data, key=good_data.get)
best_color=color_data[best_solution]
total_data={**good_data,**dumpster}
plot_histogram(total_data)
#graph=random_graph(vertices,edge_prob=1)
#G = nx.from_numpy_matrix(graph)
color_map=[]
for node in G:
if best_color[node]=='0':
color_map.append('red')
elif best_color[node]=='1':
color_map.append('blue')
elif best_color[node]=='2':
color_map.append('green')
elif best_color[node]=='3':
color_map.append('yellow')
nx.draw(G,node_color=color_map, with_labels=True)
def generate_histogram(vertices,colors,counts):
data=counts
bad_strings=[]
#bin_string_list = [''.join(p) for p in product('10', repeat=N)]
#bin_string_list.sort(key=lambda s: s.count('1'))
# ex. N=3bits ['000', '100', '010', '001', '110', '101', '011', '111']
good_data={}
dumpster={'bad':0}
for k,v in data.items():
for j in range(vertices):
if k[j*colors:(j+1)*colors].count('1') != 1 and k not in bad_strings:
bad_strings.append(k)
for i in bad_strings:
dumpster['bad'] += data[i]
for k,v in data.items():
if k not in bad_strings:
good_data[k]=v
color_data={}
if colors==2:
for k,v in good_data.items():
color_code=''
for j in range(vertices):
if k[j*colors:(j+1)*colors]=='01':
color_code+='0'
else:
color_code+='1'
color_data[k]=color_code
elif colors==3:
for k,v in good_data.items():
color_code=''
for j in range(vertices):
if k[j*colors:(j+1)*colors]=='001':
color_code+='0'
elif k[j*colors:(j+1)*colors]=='010':
color_code+='1'
else:
color_code+='2'
color_data[k]=color_code
elif colors==4:
for k,v in good_data.items():
color_code=''
for j in range(vertices):
if k[j*colors:(j+1)*colors]=='0001':
color_code+='0'
elif k[j*colors:(j+1)*colors]=='0010':
color_code+='1'
elif k[j*colors:(j+1)*colors]=='0010':
color_code+='2'
else:
color_code+='3'
color_data[k]=color_code
try:
best_solution=max(good_data, key=good_data.get)
best_color=color_data[best_solution]
except ValueError:
print('no solutions in dataset')
total_data={**good_data,**dumpster}
print(total_data)
plot_histogram(total_data)
|
https://github.com/apozas/qaoa-color
|
apozas
|
from qiskit.tools.visualization import plot_histogram
import matplotlib.pyplot as plt
import numpy as np
import numpy.random as rand
import networkx as nx
from random_graph import random_graph
from itertools import product
from ast import literal_eval
import qutip as qt
import os
def get_probs(filename):
with open(filename) as file:
amplitudes = file.read()
result = [[literal_eval(amplitude)] for amplitude in amplitudes[1:].split('\n ')]
n_qubits = int(np.log2(len(result)))
q_state = qt.Qobj(result, dims=[[2]*n_qubits, [1]*n_qubits])
prob_vector = np.abs(q_state.full())**2
n_qubits = len(q_state.dims[0])
strings = product('01', repeat=n_qubits)
return {''.join(string): prob[0] for string, prob in zip(strings, prob_vector)}
def draw_best_coloring_2colors(probs, edges):
labels = list(probs.keys())
probabilities = list(probs.values())
best_prob = np.max(probabilities)
best_coloring = labels[np.argmax(probabilities)].replace('0', 'r').replace('1', 'b')
print('Probability of coloring: ' + str(np.round(best_prob, 4)))
nx.draw(nx.Graph(edges), node_color=best_coloring, with_labels=False)
def draw_best_coloring_4colors(probs, edges):
labels = list(probs.keys())
probabilities = list(probs.values())
best_prob = np.max(probabilities)
best_coloring = labels[np.argmax(probabilities)]
best_colors = [best_coloring[2*i:2*(i+1)] for i in range(int(len(best_coloring) / 2))]
color_dict = {'00': 'r', '01': 'g', '10': 'b', '11': 'k'}
best_colors =[color_dict[color] for color in best_colors]
print('Probability of coloring: ' + str(np.round(best_prob, 4)))
nx.draw(nx.Graph(edges), node_color=best_colors, with_labels=False)
to_graph_2colors = [file for file in os.listdir('results') if (file[-10:] == 'binary.txt') and (file.split('_')[2] == '2colors')]
to_graph_4colors = [file for file in os.listdir('results') if (file[-10:] == 'binary.txt') and (file.split('_')[2] == '4colors')]
structures_2colors = [file.split('_')[1] for file in to_graph_2colors]
structures_4colors = [file.split('_')[1] for file in to_graph_4colors]
graphs = {'triang': [(0, 1), (1, 2), (2, 0)],
'line': [(0, 1), (1, 2), (2, 3)],
'square1diag': [(0, 1), (1, 2), (2, 3), (3, 0), (0, 2)]}
for graph, structure in zip(to_graph_2colors, structures_2colors):
probs = get_probs('results/' + graph)
print('---------------' + graph[:-11] + '---------------')
draw_best_coloring_2colors(probs, graphs[structure])
plt.show()
for graph, structure in zip(to_graph_4colors, structures_4colors):
probs = get_probs('results/' + graph)
print('---------------' + graph[:-11] + '---------------')
draw_best_coloring_4colors(probs, graphs[structure])
plt.show()
|
https://github.com/apozas/qaoa-color
|
apozas
|
import time
# Import the Qiskit modules(Qiskit Terra)
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, QISKitError
from qiskit import QISKitError,execute, IBMQ, Aer
import numpy as np
# Set your API Token.
# You can get it from https://quantumexperience.ng.bluemix.net/qx/account,
# looking for "Personal Access Token" section.
QX_TOKEN = "3e30646ac6c9ac8bae7e1ab0802d14f67ed3667a6aa12e2328a46043dd8102f83de09858a41b43bd0c35f8e44eb6eb46ed27046ea61363354599d8f3a79bfa02"
QX_URL = "https://quantumexperience.ng.bluemix.net/api"
# Authenticate with the IBM Q API in order to use online devices.
# You need the API Token and the QX URL.
IBMQ.enable_account(QX_TOKEN, QX_URL)
# import basic plot tools
from qiskit.tools.visualization import plot_histogram
"Choice of the backend"
# using local qasm simulator
backend = Aer.get_backend('qasm_simulator')
# using IBMQ qasm simulator
# backend = IBMQ.get_backend('ibmq_qasm_simulator')
# using real device
# backend = least_busy(IBMQ.backends(simulator=False))
# backend = IBMQ.get_backend('ibmq_16_melbourne')
flag_qx2 = True
if backend.name() == 'ibmqx4':
flag_qx2 = False
print("Your choice for the backend is: ", backend, "flag_qx2 is: ", flag_qx2)
# Define a F_gate
def F_gate(circ,q,i,j,n,k) :
theta = np.arccos(np.sqrt(1/(n-k+1)))
circ.ry(-theta,q[j])
circ.cz(q[i],q[j])
circ.ry(theta,q[j])
circ.barrier(q[i])
# Define the cxrv gate which uses reverse CNOT instead of CNOT
def cxrv(circ,q,i,j) :
circ.h(q[i])
circ.h(q[j])
circ.cx(q[j],q[i])
circ.h(q[i])
circ.h(q[j])
circ.barrier(q[i],q[j])
def wstategenrate(W_states) :
# 3-qubit W state
W_states.x(q[2]) #start is |100>
F_gate(W_states,q,2,1,3,1) # Applying F12
F_gate(W_states,q,1,0,3,2) # Applying F23
# option ibmqx4
cxrv(W_states,q,1,2)
cxrv(W_states,q,0,1)
return W_states
n = 3
q = QuantumRegister(n)
c = ClassicalRegister(n)
W_states = QuantumCircuit(q,c)
wstate = wstategenrate(W_states)
for i in range(3) :
wstate.measure(q[i] , c[i])
shots = 8192
time_exp = time.strftime('%d/%m/%Y %H:%M:%S')
print('start W state 3-qubit on', backend, "N=", shots,time_exp)
result = execute(wstate, backend=backend, shots=shots)
time_exp = time.strftime('%d/%m/%Y %H:%M:%S')
print('end W state 3-qubit on', backend, "N=", shots,time_exp)
plot_histogram(result.result().get_counts(W_states))
W_states.draw(output="mpl")
|
https://github.com/GBisi/QiskitFallFest2023
|
GBisi
| |
https://github.com/GBisi/QiskitFallFest2023
|
GBisi
|
from qiskit import QuantumCircuit # Importiamo la libreria Qiskit e in particolare la classe QuantumCircuit
qc = QuantumCircuit(3, 3) # Creiamo un QuantumCircuit chiamato qc avente 3 qubit e 3 bit classici
qc.draw() # Visualizziamo graficamente il circuito
from qiskit import QuantumCircuit
qc = QuantumCircuit(3, 3)
qc.measure([0, 1, 2], [0, 1, 2]) # Misuriamo i qubit
qc.draw(output="mpl")
from qiskit.providers.aer import AerSimulator # Importiamo il simulatore locale Aer di Qiskit
sim = AerSimulator() # Creiamo un simulatore Aer chiamato sim
job = sim.run(qc) # Eseguiamo il circuito qc nel simulatore
result = job.result() # Memorizziamo i risultati dell'esecuzione in una variabile chiamata result
result.get_counts() # Visualizziamo i risultati
# -------------
# --- BUILD ---
# -------------
from qiskit import QuantumCircuit # Importiamo la libreria Qiskit e in particolare la classe QuantumCircuit
qc = QuantumCircuit(3, 3) # Creiamo un QuantumCircuit chiamato qc avente 3 qubit e 3 bit classici
qc.measure([0, 1, 2], [0, 1, 2]) # Misuriamo i qubit
# ---------------
# --- EXECUTE ---
# ---------------
from qiskit.providers.aer import AerSimulator # Importiamo il simulatore locale Aer di Qiskit
sim = AerSimulator() # Creiamo un simulatore Aer chiamato sim
job = sim.run(qc) # Eseguiamo il circuito qc nel simulatore
result = job.result() # Memorizziamo i risultati dell'esecuzione in una variabile chiamata result
result.get_counts() # Visualizziamo i risultati
from qiskit_ibm_runtime import QiskitRuntimeService, Sampler, Estimator, Session, Options # Importiamo tutto il necessario
service = QiskitRuntimeService(channel="ibm_quantum") # Colleghiamoci al nostro account IBM Quantum
service.backends() # Visualizziamo i backend disponibili
backend = Sampler("ibmq_qasm_simulator")
job = backend.run(qc) #
result = job.result()
result.quasi_dists
backend = Sampler("ibmq_qasm_simulator")
job = backend.run(qc) #
result = job.result()
result
from qiskit import QuantumCircuit
qc = QuantumCircuit(2)
qc.x(0)
qc.h(0)
qc.cx(0, 1)
qc.draw()
|
https://github.com/GBisi/QiskitFallFest2023
|
GBisi
|
import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit
from qiskit import(QuantumCircuit, QuantumRegister, ClassicalRegister, transpile)
from qiskit.visualization import plot_histogram, plot_gate_map
from qiskit.quantum_info import Statevector
from qiskit.circuit.library import QFT
from qiskit_aer import AerSimulator
from qiskit_ibm_provider import IBMProvider
plt.style.use('default')
#IBMProvider.save_account('YOUR_TOKEN',overwrite=True)
provider = IBMProvider(instance="ibm-q/open/main")
print(provider.backends(min_num_qubits=5, simulator=False, operational=True))
print(provider.backends(min_num_qubits=5, simulator=True, operational=True))
backend = provider.get_backend("ibm_lagos")
backend.status()
props = backend.properties()
def describe_qubit(qubit, properties):
"""Print a string describing some of reported properties of the given qubit."""
# Conversion factors from standard SI units
us = 1e6
ns = 1e9
GHz = 1e-9
print("Qubit {0} has a \n"
" - T1 time of {1} microseconds\n"
" - T2 time of {2} microseconds\n"
" - U2 gate error of {3}\n"
" - U2 gate duration of {4} nanoseconds\n"
" - resonant frequency of {5} GHz".format(
qubit,
properties.t1(qubit) * us,
properties.t2(qubit) * us,
properties.gate_error('x', qubit),
properties.gate_length('x', qubit) * ns,
properties.frequency(qubit) * GHz))
describe_qubit(0, props)
plot_gate_map(backend)
simulator = AerSimulator()
backendSimulator = AerSimulator.from_backend(backend)
qr = QuantumRegister(2, 'q')
cr = ClassicalRegister(2, 'c')
circuit = QuantumCircuit(qr, cr,name="bell state")
circuit.h(0)
circuit.cx(0,1)
circuit.draw('mpl')
vector=Statevector(circuit)
display(vector.draw('latex'))
circuit = QuantumCircuit(qr, cr,name="bell state")
circuit.h(0)
circuit.cx(0,1)
circuit.measure([0,1],[0,1])
circuit.draw('mpl')
counts=simulator.run(circuit,shots=1000).result().get_counts()
display(counts)
plot_histogram(counts)
circuit = QuantumCircuit(qr, cr,name="bell state")
circuit.h(0)
circuit.cx(0,1)
circuit.measure([0,1],[0,1])
circuit.draw('mpl')
layout=[0,1]
circuitTranspiled=transpile(circuit,backendSimulator,initial_layout=layout,optimization_level=1)
circuitTranspiled.draw('mpl')
counts=backendSimulator.run(circuitTranspiled,shots=1000).result().get_counts()
display(counts)
plot_histogram(counts)
layout=[0,6]
circuitTranspiled=transpile(circuit,backendSimulator,initial_layout=layout,optimization_level=1)
circuitTranspiled.draw('mpl')
counts=backendSimulator.run(circuitTranspiled,shots=1000).result().get_counts()
display(counts)
plot_histogram(counts)
from qiskit_ibm_runtime import QiskitRuntimeService
service = QiskitRuntimeService(channel="ibm_quantum")
backend = service.backend("ibmq_qasm_simulator")
#backend = provider.get_backend("ibmq_qasm_simulator")
from qiskit.circuit.random import random_circuit
circuit = random_circuit(2, 2, seed=0, measure=True).decompose(reps=1)
circuit.draw("mpl")
from qiskit_ibm_runtime import Sampler
sampler = Sampler(backend=backend)
#from qiskit.primitives import Sampler
#sampler = Sampler()
job = sampler.run(circuit)
print(f">>> Job ID: {job.job_id()}")
print(f">>> Job Status: {job.status()}")
result = job.result()
print(f">>> {result}")
print(f" > Quasi-probability distribution: {result.quasi_dists[0]}")
print(f" > Metadata: {result.metadata[0]}")
from qiskit_ibm_runtime import Options
options = Options()
options.optimization_level = 1
options.execution.shots = 2048
sampler = Sampler(backend=backend, options=options)
job=sampler.run(circuit)
print(f">>> Job ID: {job.job_id()}")
print(f">>> Job Status: {job.status()}")
result = job.result()
print(f">>> Metadata: {result.metadata[0]}")
from qiskit_aer.noise import NoiseModel
device = provider.get_backend("ibm_lagos")
noise_model = NoiseModel.from_backend(device)
coupling_map = device.configuration().coupling_map
basis_gates=device.configuration().basis_gates
options_with_nm = Options()
options_with_nm.simulator = {
"noise_model": noise_model,
"basis_gates": basis_gates,
"coupling_map": coupling_map,
"seed_simulator": 42
}
# Set number of shots, optimization_level and resilience_level
options_with_nm.execution.shots = 1000
options_with_nm.optimization_level = 0 # no optimization
options_with_nm.resilience_level = 1 # M3 for Sampler and T-REx for Estimator
sampler = Sampler(backend=backend, options=options_with_nm)
job = sampler.run(circuit)
print(f">>> Job ID: {job.job_id()}")
print(f">>> Job Status: {job.status()}")
result=job.result()
print(f" > Quasi-probability distribution: {result.quasi_dists[0]}")
plot_histogram(result.quasi_dists[0])
circuitList=[]
for t in np.linspace(0,10000,101):
circuit = QuantumCircuit(1, 1)
circuit.x(0)
#circuit.h(0)
circuit.barrier()
for i in range(int(t)):
circuit.id(0)
circuit.barrier()
#circuit.h(0)
circuit.measure(0,0)
circuitList.append(circuit)
circuitListTranspiled=transpile(circuitList,backendSimulator,initial_layout=[0],optimization_level=0)
countsList=backendSimulator.run(circuitListTranspiled,shots=1000).result().get_counts()
probabiltyVec=[]
for counts in countsList:
probabiltyVec.append(counts.get('1')/1000)
timeVec=np.linspace(0,10000,101)* props.gate_length('id', 0) *10**6
plt.plot(timeVec,probabiltyVec)
plt.xlabel('Time [$\mu$s]')
plt.ylabel('$p_1$')
plt.show()
def func(x, amp, tau,c):
return amp* np.exp(-x/tau)+c
popt, pcov = curve_fit(func, timeVec, probabiltyVec) # scipy's curve fitting tool
print(popt)
plt.plot(timeVec,probabiltyVec)
plt.plot(timeVec, func(timeVec, *popt), label="Fitted Curve")
plt.xlabel('Time [$\mu$s]')
plt.ylabel('$p_1$')
plt.legend()
plt.show()
transpile(QFT(4,do_swaps=True,inverse=False,insert_barriers=True),simulator).draw('mpl')
backend = provider.get_backend("ibm_brisbane")
plot_gate_map(backend,figsize=(16,10))
backendSimulator = AerSimulator.from_backend(backend)
circuitQFT=QFT(5,do_swaps=True,inverse=False)
circuitQFT.draw('mpl')
nQubit=8
qr = QuantumRegister(nQubit, 'q')
circuit = QuantumCircuit(qr,name=" QFT calculation")
#circuit.x(4)
for i in range(nQubit):
circuit.h(i)
circuit.barrier()
circuit.append(QFT(nQubit,do_swaps=True,inverse=True),range(nQubit))
circuit.draw('mpl')
vector=Statevector(circuit)
display( vector.draw('latex') )
circuit.measure_all()
circuit.draw('mpl')
layout=[0,34,4,8,100,45,12,5]
circuitTranspiled=transpile(circuit,backendSimulator,initial_layout=layout,optimization_level=1)
#circuitTranspiled.draw('mpl')
# NON ESEGUIRE!!!!!
counts=backendSimulator.run(circuitTranspiled,shots=1000).result().get_counts()
layout=[0,1,2,3,4,5,6,7]
circuitTranspiled=transpile(circuit,backendSimulator,initial_layout=layout,optimization_level=1)
#circuitTranspiled.draw('mpl')
counts=backendSimulator.run(circuitTranspiled,shots=1000).result().get_counts()
#display(counts)
plot_histogram(counts,figsize=(26,6))
nQubit=8
qr = QuantumRegister(nQubit, 'q')
circuit = QuantumCircuit(qr,name=" QFT calculation")
circuit.x(3)
circuit.append(QFT(nQubit,do_swaps=False,inverse=False),range(nQubit))
circuit.barrier()
circuit.append(QFT(nQubit,do_swaps=False,inverse=True),range(nQubit))
circuit.barrier()
circuit.append(QFT(nQubit,do_swaps=False,inverse=False),range(nQubit))
circuit.barrier()
circuit.append(QFT(nQubit,do_swaps=False,inverse=True),range(nQubit))
circuit.measure_all()
layout=[0,1,2,3,4,5,6,7]
circuitTranspiled=transpile(circuit,backendSimulator,initial_layout=layout,optimization_level=1)
counts=backendSimulator.run(circuitTranspiled,shots=1000).result().get_counts()
plot_histogram(counts,figsize=(40,6))
from qiskit_ibm_runtime import QiskitRuntimeService
service = QiskitRuntimeService(channel="ibm_quantum")
backend = service.backend("ibmq_qasm_simulator")
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_ibm_runtime import Estimator
estimator = Estimator(backend=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]}")
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)
print(f">>> Job ID: {job.job_id()}")
print(f">>> Job Status: {job.status()}")
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)
print(f">>> Job ID: {job.job_id()}")
print(f">>> Job Status: {job.status()}")
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]}")
# General imports
import time
import numpy as np
# Pre-defined ansatz circuit and operator class for Hamiltonian
from qiskit.circuit.library import EfficientSU2
from qiskit.quantum_info import SparsePauliOp
# The IBM Qiskit Runtime / Primitives
#from qiskit_ibm_runtime import QiskitRuntimeService
#from qiskit_ibm_runtime import Estimator, Session
from qiskit.primitives import Estimator
# SciPy minimizer routine
from scipy.optimize import minimize
# Plotting functions
import matplotlib.pyplot as plt
hamiltonian = SparsePauliOp.from_list(
[("YZ", 0.3980), ("ZI", -0.3980), ("ZZ", -0.0113), ("XX", 0.1810)]
)
ansatz = EfficientSU2(hamiltonian.num_qubits)
ansatz.draw("mpl")
transpile(ansatz,simulator).draw('mpl')
num_params = ansatz.num_parameters
num_params
def cost_func(params, ansatz, hamiltonian, estimator):
"""Return estimate of energy from estimator
Parameters:
params (ndarray): Array of ansatz parameters
ansatz (QuantumCircuit): Parameterized ansatz circuit
hamiltonian (SparsePauliOp): Operator representation of Hamiltonian
estimator (Estimator): Estimator primitive instance
Returns:
float: Energy estimate
"""
energy = estimator.run(ansatz, hamiltonian, parameter_values=params).result().values[0]
return energy
x0 = 2 * np.pi * np.random.random(num_params)
estimator = Estimator(options={"shots": int(1e4)})
res = minimize(cost_func, x0, args=(ansatz, hamiltonian, estimator), method="cobyla")
display(res)
def build_callback(ansatz, hamiltonian, estimator, callback_dict):
"""Return callback function that uses Estimator instance,
and stores intermediate values into a dictionary.
Parameters:
ansatz (QuantumCircuit): Parameterized ansatz circuit
hamiltonian (SparsePauliOp): Operator representation of Hamiltonian
estimator (Estimator): Estimator primitive instance
callback_dict (dict): Mutable dict for storing values
Returns:
Callable: Callback function object
"""
def callback(current_vector):
"""Callback function storing previous solution vector,
computing the intermediate cost value, and displaying number
of completed iterations and average time per iteration.
Values are stored in pre-defined 'callback_dict' dictionary.
Parameters:
current_vector (ndarray): Current vector of parameters
returned by optimizer
"""
# Keep track of the number of iterations
callback_dict["iters"] += 1
# Set the prev_vector to the latest one
callback_dict["prev_vector"] = current_vector
# Compute the value of the cost function at the current vector
callback_dict["cost_history"].append(
estimator.run(ansatz, hamiltonian, parameter_values=current_vector).result().values[0]
)
# Grab the current time
current_time = time.perf_counter()
# Find the total time of the execute (after the 1st iteration)
if callback_dict["iters"] > 1:
callback_dict["_total_time"] += current_time - callback_dict["_prev_time"]
# Set the previous time to the current time
callback_dict["_prev_time"] = current_time
# Compute the average time per iteration and round it
time_str = (
round(callback_dict["_total_time"] / (callback_dict["iters"] - 1), 2)
if callback_dict["_total_time"]
else "-"
)
# Print to screen on single line
print(
"Iters. done: {} [Avg. time per iter: {}]".format(callback_dict["iters"], time_str),
end="\r",
flush=True,
)
return callback
callback_dict = {
"prev_vector": None,
"iters": 0,
"cost_history": [],
"_total_time": 0,
"_prev_time": None,}
estimator = Estimator(options={"shots": int(1e4)})
callback = build_callback(ansatz, hamiltonian, estimator, callback_dict)
res = minimize(cost_func,x0,args=(ansatz, hamiltonian, estimator),method="cobyla",callback=callback)
all(callback_dict["prev_vector"] == res.x)
callback_dict["iters"] == res.nfev
fig, ax = plt.subplots()
ax.plot(range(callback_dict["iters"]), callback_dict["cost_history"])
ax.set_xlabel("Iterations")
ax.set_ylabel("Cost");
# General imports
import time
import numpy as np
# The IBM Qiskit Runtime / Primitives
from qiskit.primitives import Sampler
# SciPy minimizer routine
from scipy.optimize import minimize
# Datasets
from sklearn.datasets import make_moons
# Plotting functions
import matplotlib.pyplot as plt
# Set random seeds
np.random.seed(42)
# number of samples
N=500
# Let's use the Moons dataset
X, Y = make_moons(n_samples=N, noise=0.1)
c = ["#1f77b4" if y_ == 0 else "#ff7f0e" for y_ in Y] # colours for each class
#plt.axis("off")
plt.scatter(X[:, 0], X[:, 1], c=c)
plt.show()
display(X,Y)
from qiskit.circuit import ParameterVector
# data re-uploading classifier circuit
L=5
x=ParameterVector('x',2)
thetas = ParameterVector('θ',3*L)
qr = QuantumRegister(1, name="q")
cr = ClassicalRegister(1, name='c')
ansatz = QuantumCircuit(qr, cr)
for k in range(L):
ansatz.u(x[0],x[1],0.0,qr)
ansatz.u(thetas[3*k+0], thetas[3*k+1], thetas[3*k+2], qr) # su(2) rotation
ansatz.measure(qr, cr)
ansatz.draw('mpl')
num_params = ansatz.num_parameters
display(num_params)
params0 = 2 * np.pi * np.random.random(3*L)
circuit=ansatz.assign_parameters({x:X[0], thetas:params0})
circuit.draw('mpl')
sampler=Sampler()
def loss(params, ansatz, x , y , sampler):
"""Return the loss for a pattern
Parameters:
params (ndarray): Array of ansatz parameters
ansatz (QuantumCircuit): Parameterized ansatz circuit
x (numpyArray): Array of the pattern features
y (integer): Class of the pattern 0 or 1
sampler (Estimator): Sampler primitive instance
Returns:
float: loss function (cost function)
"""
parameter_values=np.concatenate((x,params))
job = sampler.run(ansatz, parameter_values=parameter_values)
loss = 1 - job.result().quasi_dists[0].get(y)
return loss
def cost_func( params, ansatz, trainingX , trainingY , sampler):
N=len(trainingY)
return sum(loss(params,ansatz,trainingX[k],trainingY[k],sampler) for k in range(N))/N
def predict(params,x,ansatz,sampler):
if loss(params,ansatz,x,0,sampler) < 0.5:
return 0
else:
return 1
cost_func(params0,ansatz,X,Y,sampler)
Ypred = [predict(params0,x,ansatz,sampler) for x in X]
c = ["#1f77b4" if y == 0 else "#ff7f0e" for y in Y] # colours for each class
cpred = ["#1f77b4" if y == 0 else "#ff7f0e" for y in Ypred] # colours for each class
plt.figure(figsize=(15,5))
plt.subplot(1,2,1)
plt.axis("off")
plt.title("true")
plt.scatter(X[:, 0], X[:, 1], c=c)
plt.subplot(1,2,2)
plt.axis("off")
plt.title("predicted")
plt.scatter(X[:, 0], X[:, 1], c=cpred)
plt.show()
trainingX=X[0:100]
trainingY=Y[0:100]
res = minimize(cost_func, params0, args=(ansatz, trainingX , trainingY , sampler), method="cobyla")
res.fun
paramsOpt=res.x
Ypred = [predict(paramsOpt,x,ansatz,sampler) for x in X[200:]]
c = ["#1f77b4" if y == 0 else "#ff7f0e" for y in Y[200:]] # colours for each class
cpred = ["#1f77b4" if y == 0 else "#ff7f0e" for y in Ypred] # colours for each class
plt.figure(figsize=(15,5))
plt.subplot(1,2,1)
plt.axis("off")
plt.title("true")
plt.scatter(X[200:, 0], X[200:, 1], c=c)
plt.subplot(1,2,2)
plt.axis("off")
plt.title("predicted")
plt.scatter(X[200:, 0], X[200:, 1], c=cpred)
plt.show()
from qutip import basis,Bloch, expect, sigmax,sigmay,sigmaz
#import qutip as qt
L=5
x=ParameterVector('x',2)
thetas = ParameterVector('θ',3*L)
qr = QuantumRegister(1, name="q")
cr = ClassicalRegister(1, name='c')
qc = QuantumCircuit(qr, cr)
for k in range(L):
qc.u(x[0],x[1],0.0,qr)
qc.u(thetas[3*k+0], thetas[3*k+1], thetas[3*k+2], qr) # su(2) rotation
def blochPoints(X,Y,params,ansatz):
xp1=[]
yp1=[]
zp1=[]
xp0=[]
yp0=[]
zp0=[]
for i in range(len(X)):
circuit=ansatz.assign_parameters({x:X[i], thetas:params})
state=Statevector(circuit)
pnt=state[0]*basis(2,0)+state[1]*basis(2,1)
if Y[i]==0:
xp0.append(expect(sigmax(),pnt))
yp0.append(expect(sigmay(),pnt))
zp0.append(expect(sigmaz(),pnt))
else:
xp1.append(expect(sigmax(),pnt))
yp1.append(expect(sigmay(),pnt))
zp1.append(expect(sigmaz(),pnt))
return [[xp0,yp0,zp0],[xp1,yp1,zp1]]
b1=Bloch()
b2=Bloch()
b1.add_points(blochPoints(X[200:300],Y[200:300],params0,qc)[0])
b1.add_points(blochPoints(X[200:300],Y[200:300],params0,qc)[1])
b2.add_points(blochPoints(X[200:300],Y[200:300],paramsOpt,qc)[0])
b2.add_points(blochPoints(X[200:300],Y[200:300],paramsOpt,qc)[1])
b1.show()
b2.show()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/simanraj1123/n-qubit-Grover-s-search-on-IBM-Qiskit
|
simanraj1123
|
# Importing libraries
from qiskit import QuantumCircuit, execute, Aer, IBMQ, QuantumRegister, ClassicalRegister
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
import numpy as np
import matplotlib.pyplot as plt
from qiskit.converters import circuit_to_gate
from qiskit.circuit.library.standard_gates import ZGate
def oracle(n, targets):
'''
Given the number of qubits "n" and a list of target states "targets", the function returns the quantum circuit
for the oracle.
'''
qbits = QuantumRegister(n,'q')
circ = QuantumCircuit(qbits, name="Oracle")
# Creating a sequential circuit for each target state.
for target in targets:
# Each string representing a target state is reversed so that the indexing matches with the indices of
# the corresponding qubits.
target = list(target)
target.reverse()
target = ''.join(target)
# Flip zero bits
for i in range(len(target)):
if target[i]=='0':
circ.x(i)
# Apply a n-1 CZ
CZ = ZGate().control(n-1)
circ.append(CZ, qbits)
# Flip back
for i in range(len(target)):
if target[i]=='0':
circ.x(i)
# Uncomment the following line if you the circuit to be converted to a gate. This step is not essential to the
# function of the quantum circuit.
# circ = circuit_to_gate(circ)
return circ
def diffusion(n):
'''
Given the number of qubits "n", the function returns the circuit for the n-qubit diffusion operation.
'''
qbits = QuantumRegister(n,'q')
circ = QuantumCircuit(qbits, name="Diffusion")
circ.h(qbits)
# Call the oracle function with target state set to the n-qubit zero state.
circ.append(oracle(n,['0'*n]), qbits)
circ.h(qbits)
return circ
def grover(n, oracle, m,threshold=0):
'''
The "grover" function returns the quantum circuit to implement Grover's search algorithm for an "n"-qubit
system to search for "m" targets. The argument "oracle" is the quantum circuit for the Oracle for the
target state/states. The argument "threshold" is the user-given threshold on the success probability. The
default value of "threshold is zero."
'''
qbits = QuantumRegister(n,'q')
circ = QuantumCircuit(n, name="Grover")
# Initial state: Prepare equal superposition
circ.h(qbits)
# Number of iterations required
N = 2**n # Size of the database
theta = np.arcsin(np.sqrt(m/N))%(2*np.pi) # The value of theta
''' The following loop searches for the optimum value of "p" and the corresponding number of iterations
such that the success probability of the search is equal to or more than the threshold.'''
p=0 # Initialized to zero
while True:
k = (2*p+1)*np.pi/(4*theta)-0.5 # The optimal k is close to this value.
tk_down = theta*(1+2*np.floor(k)) # Final angle theta_k with k rounded down.
tk_up = theta*(1+2*np.ceil(k)) # Final angle theta_k with k rounded up.
# Condition to check if the success probability crosses the threshold.
if max(np.sin(tk_down)**2, np.sin(tk_up)**2) >= threshold:
# If tk_down satisfies the condition choose the floor of k.
if np.sin(tk_down)**2 >= threshold:
k = int(np.floor(k))
print(np.sin(tk_down)**2) # Print the value of success probability.
# If tk_up satisfies the condition choose the ceil of k.
else:
k = int(np.ceil(k))
print(np.sin(tk_up)**2) # Print the value of success probability.
print('p =',p) # Print the value of optimal p.
break # Break the loop if the optimal p is found.
p+=1
print('k =',k) # Print the value of optimal k.
# Append the oracle followed by diffusion operation k number of times.
for i in range(k):
circ.append(oracle, qbits)
circ.append(diffusion(n), qbits)
return circ
'''
Each n-qubit computational basis state is represented by its corresponding n-digit binary string. For example,
the state |001101> is represented by the string '0001101'.
'''
n= # Set the number of qubits.
form = f'{{0:0{str(n)}b}}' # Format to convert decimal number to n-digit binary string.
all_states = [form.format(i) for i in range(2**n)] # A list of all possible orthogonal states
tars = [] # "tars" is a list of binary strings for all the target states.
success_rate = # Set the threshold for success probability.
orc = oracle(n, tars) # The circuit for Oracle given the target states in the list tars.
# Construction of the circuit for Grover's search.
circuit = grover(n, orc, len(tars), success_rate)
# Applying projective measurement to each qubit at the end of the circuit.
circuit.measure_all()
# Running the "circuit" using the QASM simulator.
sim = Aer.get_backend('qasm_simulator') # Calling the qasm_simulator.
job = execute(circuit, sim, shots=1000000) # Executing the circuit with 1,000,000 shots.
result = job.result()
count = result.get_counts(circuit) # "count" is a dict of counts after the projective measurements.
''' If the count of a state is zero in the output, it is not included in the dict.
The following loop includes the absent states in the dict and sets their counts to zero. '''
for x in all_states:
if x not in count.keys():
count[x]=0
final_counts = count
''' Uncomment the following lines, if you want the collective counts of the target and non-target states.'''
# collective_count = {'Others':0, 'Target':0}
# for x in all_states:
# if x in tars:
# collective_count['Target'] += count[x]
# else:
# collective_count['Others'] += count[x]
# final_counts = collective_count
plot_histogram(final_counts) # Plot the probability histogram of the final_counts.
|
https://github.com/QForestCommunity/launchpad
|
QForestCommunity
|
import qiskit
qiskit.__qiskit_version__
from qiskit import QuantumRegister, ClassicalRegister
from qiskit import Aer, execute, QuantumCircuit
from qiskit.circuit.library.standard_gates import RYGate
from qiskit.tools.visualization import circuit_drawer
from numpy import pi, e, sqrt, arccos, log2
from scipy.integrate import quad
%matplotlib inline
import matplotlib.pyplot as plt
def distribution(x):
"""
Returns the value of a chosen probability distribution at the given value
of x. Mess around with this function to see how the encoder works!
The current distribution being used is N(0, 2).
"""
# Use these with normal distributions
mu = 0
sigma = 2
return (((e ** (-0.5 * ((x - mu) / sigma) ** 2)) / (sigma * sqrt(2 * pi))) / 0.99993665)
def integrate(dist, lower, upper):
"""
Perform integration using numpy's quad method. We can use parametrized
distributions as well by using this syntax instead:
quad(integrand, lower, upper, args=(tupleOfArgsForIntegrand))
"""
return quad(dist, lower, upper)[0]
def computeRegionProbability(dist, regBounds, numRegions, j):
"""
Given a distribution dist, a list of adjacent regions regBounds, the
current level of discretization numRegions, a region number j, computes
the probability that the value random variable following dist lies in
region j given that it lies in the larger region made up of regions
[(j // 2) * 2, ((j + 2) // 2) * 2]
"""
totalRegions = len(regBounds) - 1
k = 2 * j
prob = integrate(dist, regBounds[(totalRegions // numRegions) * k],
regBounds[(totalRegions // numRegions) * (k + 1)]) / integrate(
dist, regBounds[(totalRegions // numRegions) * ((k // 2) * 2)],
regBounds[(totalRegions // numRegions) * (((k + 2) // 2) * 2)])
return prob
def encodeDist(dist, regBounds):
numQubits = int(log2(len(regBounds) - 1))
a = QuantumRegister(2 * numQubits - 2)
c = ClassicalRegister(numQubits)
qc = QuantumCircuit(a, c)
for i in range(numQubits):
numRegions = int(2 ** (i + 1))
for j in range(numRegions // 2):
prob = computeRegionProbability(dist, regBounds, numRegions, j)
if not i:
qc.ry(2 * arccos(sqrt(prob)), a[2 * numQubits - 3])
else:
cGate = RYGate(2 * arccos(sqrt(prob))).control(i)
def getFlipList(i, j, numQubits):
"""
Given the current level of desired level of discretization, the
current level of discretization i and a region number j,
returns the binary bit string associated with j in the form of
a list of bits to be flipped.
"""
binString = str(bin(j))[2:]
binString = ("0" * (numQubits - len(binString))) + binString
bitFlips = []
for k in range(numQubits - i, numQubits):
if binString[k] == '0':
bitFlips.append(3 * numQubits - 3 - k - i)
return bitFlips
for k in listOfFlips:
qc.x(a[k])
qubitsUsed = [a[k] for k in
range(2 * numQubits - 2 - i, 2 * numQubits - 2)]
qubitsUsed.append(a[2 * numQubits - 3 - i])
qc.append(cGate, qubitsUsed)
for k in listOfFlips:
qc.x(a[k])
return qc, a, c
def encodeDist(dist, regBounds):
"""
Discretize the distribution dist into multiple regions with boundaries
given by regBounds, and store the associated quantum superposition
state in a new quantum register reg. Please make sure the number of
regions is a power of 2, i.e. len(regBounds) = (2 ** n) + 1.
Additionally, the number of regions is limited to a maximum of
2^(n // 2 + 1), where n is the number of qubits available in the backend
being used - this is due to the requirement of (n - 2) ancilla qubits in
order to perform (n - 1) control operations with minimal possible depth.
Returns a new quantum circuit containing the instructions and registers
needed to create the superposition state, along with the size of the
quantum register.
"""
numQubits = int(log2(len(regBounds) - 1))
a = QuantumRegister(2 * numQubits - 2)
c = ClassicalRegister(numQubits)
qc = QuantumCircuit(a, c)
for i in range(numQubits):
numRegions = int(2 ** (i + 1))
for j in range(numRegions // 2):
prob = computeRegionProbability(dist, regBounds, numRegions, j)
if not i:
qc.ry(2 * arccos(sqrt(prob)), a[2 * numQubits - 3])
else:
cGate = RYGate(2 * arccos(sqrt(prob))).control(i)
listOfFlips = getFlipList(i, j, numQubits)
for k in listOfFlips:
qc.x(a[k])
qubitsUsed = [a[k] for k in
range(2 * numQubits - 2 - i, 2 * numQubits - 2)]
qubitsUsed.append(a[2 * numQubits - 3 - i])
qc.append(cGate, qubitsUsed)
for k in listOfFlips:
qc.x(a[k])
return qc, a, c
def pad(x, numQubits):
"""
Utility function that returns a left padded version of the bit string
passed.
"""
string = str(x)[2:]
string = ('0' * (numQubits - len(string))) + string
return string
regBounds = [i for i in range(-16, 17)]
qc, a, c = encodeDist(distribution, regBounds)
numQubits = (qc.num_qubits + 2) // 2
for i in range(numQubits - 2, 2 * numQubits - 2):
qc.measure(a[i], c[i - (numQubits - 2)])
backend = Aer.get_backend('qasm_simulator')
shots = 100000
job = execute(qc, backend=backend, shots=shots)
results = job.result().get_counts()
resultsX = []
resultsY = []
for i in [pad(bin(x), numQubits) for x in range(2 ** (numQubits))]:
resultsX.append(i)
if i in results.keys():
resultsY.append(results[i])
else:
resultsY.append(0)
truthDisc = [integrate(distribution, regBounds[i], regBounds[i + 1]) * shots for i in range(
len(regBounds) - 1)]
plt.figure(figsize=[16, 9])
plt.plot(resultsX, resultsY)
plt.plot(resultsX, truthDisc, '--')
plt.legend(['quantum estimate', 'classical estimate'])
plt.show()
circuit_drawer(qc, output='mpl')
|
https://github.com/QForestCommunity/launchpad
|
QForestCommunity
|
from pyqubo import Spin, solve_ising
x1, x2, x3 = Spin("x1"), Spin("x2"), Spin("x3")
Quad_form = 2*(x1) + x2 - 3*(x3)
model = Quad_form.compile()
deg1, deg2, off = model.to_ising()
print('Degree1:',deg1,' Degree2:',deg2,' Offset:',off)
res = solve_ising(deg1,deg2)
print(res)
shots = 10 #variable used to specify number of times you want to solve the model
ans = []
for i in range(shots):
res = solve_ising(deg1, deg2)
ans.append(res)
result = ans[0]
maxim = 0
for i in ans:
freq = ans.count(i)
if freq>maxim:
maxim = freq
result = i
print(str(result))
|
https://github.com/QForestCommunity/launchpad
|
QForestCommunity
|
import qiskit
qiskit.__qiskit_version__
from qiskit import QuantumCircuit, BasicAer, execute
from qiskit.visualization import plot_histogram
qcSwap = QuantumCircuit(2, 2) #create a quantum circuit with 2 quantum bits and 2 classical bits.
qcSwap.x(0) #apply a pauli X gate to the first qubit to better demonstrate the swap.
qcSwap.swap(0, 1) #apply a swap gate on the first and second qubits.
qcSwap.measure([0, 1], [0, 1]) #measure the qubits to see what their states end up being
qcSwap.draw(output = "mpl") #draw the circuit.
backend = BasicAer.get_backend("statevector_simulator")
state = execute(qcSwap, backend, shots=1024).result().get_counts()
#the initial state should've been '01' before the swap,
#go ahead and comment the swap gate out and run the code!
#the state is '01' before the swap because of qiskit's little endian encoding.
print(state)
n = 4 #number of data qubits.
ancilla = n #number of ancillary qubits is the same as number of qubits in this example.
#number of classical registers is equal to the number of data qubits, since we want the values of only those.
qcShift = QuantumCircuit(n + ancilla, n)
seed = "1011" #this is the initial value of our data qubits.
seed = list(map(int, list(seed)))[::-1] #reverse the list to follow qiskit's encoding scheme.
#to encode the seed, when we encounter a 1, we apply a pauli x gate.
for bit in range(len(seed)):
if seed[bit] == 1:
qcShift.x(bit)
qcShift.barrier(range(n + ancilla)) #add a barrier to mark the end of the encoding phase.
#to apply the swap gates
for qubit in range(1, n + ancilla)[::-1]:
qcShift.swap(qubit, qubit - 1)
qcShift.barrier(range(n + ancilla)) #add a barrier to mark the end of the swapping phase.
#measure the values of the data qubits.
qcShift.measure(range(n), range(n))
qcShift.barrier(range(n + ancilla)) #add a barrier to mark the end of the measuring phase.
qcShift.draw(output = "mpl")
def create_shift_gate(n:int, circular:bool = False):
"""Creates a gate out of a shift circuit.
Args:
n : number of data qubits.
seed : initial state of the data qubits.
circular : flag indicating whether the shift register is circular in nature or not.
"""
if circular:
name = "Circular Left Shift"
else:
name = "Left Shift"
ancilla = n
#n data qubits and the same number of ancillary qubits and one extra qubit to act as the control
#bit for deciding if the operation should be a left shift or a circular left shift.
shiftGate = QuantumCircuit(n + ancilla + 1, name=name)
for qubit in range(1, n + ancilla)[::-1]:
shiftGate.swap(qubit, qubit - 1)
#implement the controlled swap.
shiftGate.cx(0, n)
shiftGate.toffoli(n + ancilla, n, 0)
shiftGate.cx(0, n)
return shiftGate.to_gate()
n = 4
seed = '1011'
ancilla = n
#n data qubits and the same number of ancillary qubits and one extra qubit to act as the control
#bit for deciding if the operation should be a left shift or a circular left shift.
shiftCirc = QuantumCircuit(n + ancilla + 1, n)
seed = list(map(int, list(seed)))[::-1]
circular = True
#encode the circuit
for bit in range(len(seed)):
if seed[bit] == 1:
shiftCirc.x(bit)
if circular:
shiftCirc.x(n + ancilla) #encode the control qubit.
shiftCirc.barrier(range(n + ancilla + 1))
shiftGate = create_shift_gate(n, circular)
#perform 2 shift operations.
shiftCirc.append(shiftGate, range(n + ancilla + 1))
shiftCirc.append(shiftGate, range(n + ancilla + 1))
shiftCirc.barrier(range(n + ancilla + 1))
#get the state of the data qubits.
shiftCirc.measure(range(n), range(n))
shiftCirc.barrier(range(n + ancilla))
#draw the circuit.
shiftCirc.draw(output="mpl")
#get the state of the shift register
backend = BasicAer.get_backend("statevector_simulator")
register_state = execute(shiftCirc, backend, shots=1024).result().get_counts()
plot_histogram(register_state)
#as it can be seen, the state of the register is '1110' which is what
#you would get by performing two left shift operations circularly.
#to see what the shift gate is acutally made up of.
seeShiftGate = QuantumCircuit(n + ancilla + 1)
seeShiftGate.append(shiftGate, range(n + ancilla + 1))
seeShiftGate.decompose().draw(output = "mpl")
#q8 is the control qubit. q0-q3 are the data qubits and q4-q7 are the ancillary qubits.
|
https://github.com/QForestCommunity/launchpad
|
QForestCommunity
|
import qiskit
qiskit.__qiskit_version__
from qiskit import QuantumRegister, ClassicalRegister
from qiskit import Aer, execute, QuantumCircuit
from qiskit.circuit.library.standard_gates import RYGate
from numpy import pi, e, sqrt, arccos, log2
from scipy.integrate import quad
%matplotlib inline
import matplotlib.pyplot as plt
def distribution(x):
"""
Returns the value of a chosen probability distribution at the given value
of x. Mess around with this function to see how the encoder works!
The current distribution being used is N(0, 2).
"""
# Use these with normal distributions
mu = 0
sigma = 2
return (((e ** (-0.5 * ((x - mu) / sigma) ** 2)) / (sigma * sqrt(2 * pi))) / 0.99993665)
def integrate(dist, lower, upper):
"""
Perform integration using numpy's quad method. We can use parametrized
distributions as well by using this syntax instead:
quad(integrand, lower, upper, args=(tupleOfArgsForIntegrand))
"""
return quad(dist, lower, upper)[0]
def computeRegionProbability(dist, regBounds, numRegions, j):
"""
Given a distribution dist, a list of adjacent regions regBounds, the
current level of discretization numRegions, a region number j, computes
the probability that the value random variable following dist lies in
region j given that it lies in the larger region made up of regions
[(j // 2) * 2, ((j + 2) // 2) * 2]
"""
totalRegions = len(regBounds) - 1
k = 2 * j
prob = integrate(dist, regBounds[(totalRegions // numRegions) * k],
regBounds[(totalRegions // numRegions) * (k + 1)]) / integrate(
dist, regBounds[(totalRegions // numRegions) * ((k // 2) * 2)],
regBounds[(totalRegions // numRegions) * (((k + 2) // 2) * 2)])
return prob
def encodeDist(dist, regBounds):
numQubits = int(log2(len(regBounds) - 1))
a = QuantumRegister(2 * numQubits - 2)
c = ClassicalRegister(numQubits)
qc = QuantumCircuit(a, c)
for i in range(numQubits):
numRegions = int(2 ** (i + 1))
for j in range(numRegions // 2):
prob = computeRegionProbability(dist, regBounds, numRegions, j)
if not i:
qc.ry(2 * arccos(sqrt(prob)), a[2 * numQubits - 3])
else:
cGate = RYGate(2 * arccos(sqrt(prob))).control(i)
def getFlipList(i, j, numQubits):
"""
Given the current level of desired level of discretization, the
current level of discretization i and a region number j,
returns the binary bit string associated with j in the form of
a list of bits to be flipped.
"""
binString = str(bin(j))[2:]
binString = ("0" * (numQubits - len(binString))) + binString
bitFlips = []
for k in range(numQubits - i, numQubits):
if binString[k] == '0':
bitFlips.append(3 * numQubits - 3 - k - i)
return bitFlips
for k in listOfFlips:
qc.x(a[k])
qubitsUsed = [a[k] for k in
range(2 * numQubits - 2 - i, 2 * numQubits - 2)]
qubitsUsed.append(a[2 * numQubits - 3 - i])
qc.append(cGate, qubitsUsed)
for k in listOfFlips:
qc.x(a[k])
return qc, a, c
def encodeDist(dist, regBounds):
"""
Discretize the distribution dist into multiple regions with boundaries
given by regBounds, and store the associated quantum superposition
state in a new quantum register reg. Please make sure the number of
regions is a power of 2, i.e. len(regBounds) = (2 ** n) + 1.
Additionally, the number of regions is limited to a maximum of
2^(n // 2 + 1), where n is the number of qubits available in the backend
being used - this is due to the requirement of (n - 2) ancilla qubits in
order to perform (n - 1) control operations with minimal possible depth.
Returns a new quantum circuit containing the instructions and registers
needed to create the superposition state, along with the size of the
quantum register.
"""
numQubits = int(log2(len(regBounds) - 1))
a = QuantumRegister(2 * numQubits - 2)
c = ClassicalRegister(numQubits)
qc = QuantumCircuit(a, c)
for i in range(numQubits):
numRegions = int(2 ** (i + 1))
for j in range(numRegions // 2):
prob = computeRegionProbability(dist, regBounds, numRegions, j)
if not i:
qc.ry(2 * arccos(sqrt(prob)), a[2 * numQubits - 3])
else:
cGate = RYGate(2 * arccos(sqrt(prob))).control(i)
listOfFlips = getFlipList(i, j, numQubits)
for k in listOfFlips:
qc.x(a[k])
qubitsUsed = [a[k] for k in
range(2 * numQubits - 2 - i, 2 * numQubits - 2)]
qubitsUsed.append(a[2 * numQubits - 3 - i])
qc.append(cGate, qubitsUsed)
for k in listOfFlips:
qc.x(a[k])
return qc, a, c
def pad(x, numQubits):
"""
Utility function that returns a left padded version of the bit string
passed.
"""
string = str(x)[2:]
string = ('0' * (numQubits - len(string))) + string
return string
regBounds = [i for i in range(-16, 17)]
qc, a, c = encodeDist(distribution, regBounds)
numQubits = (qc.num_qubits + 2) // 2
for i in range(numQubits - 2, 2 * numQubits - 2):
qc.measure(a[i], c[i - (numQubits - 2)])
backend = Aer.get_backend('qasm_simulator')
shots = 100000
job = execute(qc, backend=backend, shots=shots)
results = job.result().get_counts()
resultsX = []
resultsY = []
for i in [pad(bin(x), numQubits) for x in range(2 ** (numQubits))]:
resultsX.append(i)
if i in results.keys():
resultsY.append(results[i])
else:
resultsY.append(0)
truthDisc = [integrate(distribution, regBounds[i], regBounds[i + 1]) * shots for i in range(
len(regBounds) - 1)]
plt.figure(figsize=[16, 9])
plt.plot(resultsX, resultsY)
plt.plot(resultsX, truthDisc, '--')
plt.legend(['quantum estimate', 'classical estimate'])
plt.show()
circuit_drawer(qc, output='latex')
|
https://github.com/QForestCommunity/launchpad
|
QForestCommunity
|
import qiskit
qiskit.__qiskit_version__
from qiskit import QuantumCircuit, BasicAer, execute
from qiskit.visualization import plot_histogram
qcSwap = QuantumCircuit(2, 2) #create a quantum circuit with 2 quantum bits and 2 classical bits.
qcSwap.x(0) #apply a pauli X gate to the first qubit to better demonstrate the swap.
qcSwap.swap(0, 1) #apply a swap gate on the first and second qubits.
qcSwap.measure([0, 1], [0, 1]) #measure the qubits to see what their states end up being
qcSwap.draw(output = "mpl") #draw the circuit.
backend = BasicAer.get_backend("statevector_simulator")
state = execute(qcSwap, backend, shots=1024).result().get_counts()
#the initial state should've been '01' before the swap,
#go ahead and comment the swap gate out and run the code!
#the state is '01' before the swap because of qiskit's little endian encoding.
print(state)
n = 4 #number of data qubits.
ancilla = n #number of ancillary qubits is the same as number of qubits in this example.
#number of classical registers is equal to the number of data qubits, since we want the values of only those.
qcShift = QuantumCircuit(n + ancilla, n)
seed = "1011" #this is the initial value of our data qubits.
seed = list(map(int, list(seed)))[::-1] #reverse the list to follow qiskit's encoding scheme.
#to encode the seed, when we encounter a 1, we apply a pauli x gate.
for bit in range(len(seed)):
if seed[bit] == 1:
qcShift.x(bit)
qcShift.barrier(range(n + ancilla)) #add a barrier to mark the end of the encoding phase.
#to apply the swap gates
for qubit in range(1, n + ancilla)[::-1]:
qcShift.swap(qubit, qubit - 1)
qcShift.barrier(range(n + ancilla)) #add a barrier to mark the end of the swapping phase.
#measure the values of the data qubits.
qcShift.measure(range(n), range(n))
qcShift.barrier(range(n + ancilla)) #add a barrier to mark the end of the measuring phase.
qcShift.draw(output = "mpl")
def create_shift_gate(n:int, circular:bool = False):
"""Creates a gate out of a shift circuit.
Args:
n : number of data qubits.
seed : initial state of the data qubits.
circular : flag indicating whether the shift register is circular in nature or not.
"""
if circular:
name = "Circular Left Shift"
else:
name = "Left Shift"
ancilla = n
#n data qubits and the same number of ancillary qubits and one extra qubit to act as the control
#bit for deciding if the operation should be a left shift or a circular left shift.
shiftGate = QuantumCircuit(n + ancilla + 1, name=name)
for qubit in range(1, n + ancilla)[::-1]:
shiftGate.swap(qubit, qubit - 1)
#implement the controlled swap.
shiftGate.cx(0, n)
shiftGate.toffoli(n + ancilla, n, 0)
shiftGate.cx(0, n)
return shiftGate.to_gate()
n = 4
seed = '1011'
ancilla = n
#n data qubits and the same number of ancillary qubits and one extra qubit to act as the control
#bit for deciding if the operation should be a left shift or a circular left shift.
shiftCirc = QuantumCircuit(n + ancilla + 1, n)
seed = list(map(int, list(seed)))[::-1]
circular = True
#encode the circuit
for bit in range(len(seed)):
if seed[bit] == 1:
shiftCirc.x(bit)
if circular:
shiftCirc.x(n + ancilla) #encode the control qubit.
shiftCirc.barrier(range(n + ancilla + 1))
shiftGate = create_shift_gate(n, circular)
#perform 2 shift operations.
shiftCirc.append(shiftGate, range(n + ancilla + 1))
shiftCirc.append(shiftGate, range(n + ancilla + 1))
shiftCirc.barrier(range(n + ancilla + 1))
#get the state of the data qubits.
shiftCirc.measure(range(n), range(n))
shiftCirc.barrier(range(n + ancilla))
#draw the circuit.
shiftCirc.draw(output="mpl")
#get the state of the shift register
backend = BasicAer.get_backend("statevector_simulator")
register_state = execute(shiftCirc, backend, shots=1024).result().get_counts()
plot_histogram(register_state)
#as it can be seen, the state of the register is '1110' which is what
#you would get by performing two left shift operations circularly.
#to see what the shift gate is acutally made up of.
seeShiftGate = QuantumCircuit(n + ancilla + 1)
seeShiftGate.append(shiftGate, range(n + ancilla + 1))
seeShiftGate.decompose().draw(output = "mpl")
#q8 is the control qubit. q0-q3 are the data qubits and q4-q7 are the ancillary qubits.
|
https://github.com/jenglick/scipy22-qiskit-runtime-tutorial
|
jenglick
|
# import functionality from qiskit for building and running circuits
from qiskit import QuantumCircuit, BasicAer, transpile
# here we'll create a GHZ state
circuit = QuantumCircuit(3)
circuit.h(0)
circuit.cnot(0,1)
circuit.cnot(1,2)
circuit.measure_all()
print(circuit.draw())
# select a quantum backend and run the circuit
backend = BasicAer.get_backend('qasm_simulator')
shots = 2**13
job = backend.run(transpile(circuit, backend), shots=shots)
result = job.result()
counts = result.get_counts()
from qiskit.visualization import plot_histogram
plot_histogram(counts)
# defining the state |1>
import numpy as np
a = 0
b = 1
state = np.array([a,b])
norm = np.linalg.norm(state)
normalized_state_ONE = state/norm
print(normalized_state_ONE)
# define the state |+>
a = 0.70710678 # 1/sqrt(2)
b = 0.70710678
state = np.array([a,b])
norm = np.linalg.norm(state)
normalized_state_PLUS = state/norm
print(normalized_state_PLUS)
# define the Pauli X operator
x = np.array([[0, 1],
[1, 0]])
from qiskit.visualization import plot_state_city, plot_bloch_multivector
x_eigenvals, x_eigenvecs = np.linalg.eigh(x)
print('\nEigensystem of X:')
print(x_eigenvals)
print(x_eigenvecs)
plot_bloch_multivector(x_eigenvecs[:,1])
circuit = QuantumCircuit(1)
circuit.initialize(normalized_state_ONE)
circuit.h(0)
circuit.measure_all()
print(circuit)
job = backend.run(transpile(circuit, backend), shots=shots)
result = job.result()
counts = result.get_counts()
print(counts)
expval = (counts.get('0',0)-counts.get('1',0)) / shots
print('expectation value: {}'.format(expval))
circuit = QuantumCircuit(1)
circuit.initialize(normalized_state_PLUS)
circuit.h(0)
circuit.measure_all()
print(circuit)
job = backend.run(transpile(circuit, backend), shots=shots)
result = job.result()
counts = result.get_counts()
print(counts)
expval = (counts.get('0',0)-counts.get('1',0)) / shots
print('expectation value: {}'.format(expval))
circuit = QuantumCircuit(1)
circuit.initialize(normalized_state_ONE)
circuit.sdg(0)
circuit.h(0)
circuit.measure_all()
print(circuit)
job = backend.run(transpile(circuit, backend), shots=shots)
result = job.result()
counts = result.get_counts()
print(counts)
expval = (counts.get('0',0)-counts.get('1',0)) / shots
print('expectation value: {}'.format(expval))
circuit = QuantumCircuit(1)
circuit.initialize(normalized_state_PLUS)
circuit.sdg(0)
circuit.h(0)
circuit.measure_all()
print(circuit)
job = backend.run(transpile(circuit, backend), shots=shots)
result = job.result()
counts = result.get_counts()
print(counts)
expval = (counts.get('0',0)-counts.get('1',0)) / shots
print('expectation value: {}'.format(expval))
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/jenglick/scipy22-qiskit-runtime-tutorial
|
jenglick
|
# import functionality from qiskit for building and running circuits
from qiskit import QuantumCircuit, BasicAer, transpile
import numpy as np
# define a quantum circuit with a single "X" gate
circuit = QuantumCircuit(1)
circuit.x(0)
circuit.measure_all()
circuit.draw()
# select a quantum backend and run the circuit
backend = BasicAer.get_backend('qasm_simulator')
shots = 2**13
job = backend.run(circuit, shots=shots)
result = job.result()
# get the measurement counts from the circuit
counts = result.get_counts()
print(counts)
print('probability to measure state 0: {}%'.format(counts.get('0', 0) / shots * 100))
print('probability to measure state 1: {}%'.format(counts.get('1', 0) / shots * 100))
# define a quantum circuit with a single Hadamard gate
circuit = QuantumCircuit(1)
circuit.h(0)
circuit.measure_all()
circuit.draw()
job = backend.run(transpile(circuit, backend), shots=shots)
result = job.result()
counts = result.get_counts()
print(counts)
print('probability to measure state 0: {}%'.format(counts.get('0', 0) / shots * 100))
print('probability to measure state 1: {}%'.format(counts.get('1', 0) / shots * 100))
# define the state |1>
a = 0
b = 1
state = np.array([a,b])
norm = np.linalg.norm(state)
normalized_state_ONE = state/norm
print(normalized_state_ONE)
# then, initialize this state as a quantum circuit and measure in computational (Z) basis
circuit = QuantumCircuit(1)
circuit.initialize(normalized_state_ONE)
circuit.measure_all()
print(circuit)
# run the circuit and then subtract the two probabilities p(0)-p(1)
job = backend.run(transpile(circuit, backend), shots=shots)
result = job.result()
counts = result.get_counts()
print(counts)
expval = (counts.get('0',0)-counts.get('1',0)) / shots
print('expectation value: {}'.format(expval))
# define the state |+>
a = 0.70710678 # 1/sqrt(2)
b = 0.70710678
state = np.array([a,b])
norm = np.linalg.norm(state)
normalized_state_PLUS = state/norm
print(normalized_state_PLUS)
# initialize as a quantum circuit and measure
circuit = QuantumCircuit(1)
circuit.initialize(normalized_state_PLUS)
circuit.measure_all()
print(circuit)
# run the circuit and then subtract the two probabilities p(0)-p(1)
job = backend.run(transpile(circuit, backend), shots=shots)
result = job.result()
counts = result.get_counts()
print(counts)
expval = (counts.get('0',0)-counts.get('1',0)) / shots
print('expectation value: {}'.format(expval))
# define the Pauli Z operator
z = np.array([[1, 0],
[0, -1]])
# what are the eigenvectors of this operator?
from qiskit.visualization import plot_state_city, plot_bloch_multivector
z_eigenvals, z_eigenvecs = np.linalg.eigh(z)
print('Eigensystem of Z:')
print(z_eigenvals)
print(z_eigenvecs)
plot_bloch_multivector(z_eigenvecs[:,0])
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/jenglick/scipy22-qiskit-runtime-tutorial
|
jenglick
|
# Authenticate with the server.
from qiskit_ibm_runtime import QiskitRuntimeService
service = QiskitRuntimeService(channel="ibm_quantum")
# Prepare the circuit.
from qiskit import QuantumCircuit
qc1 = QuantumCircuit(1, 1)
qc1.x(0)
qc1.measure_all()
# Prepare the operators.
from qiskit.quantum_info import SparsePauliOp
x_op = SparsePauliOp.from_list([("X", 1)])
y_op = SparsePauliOp.from_list([("Y", 1)])
# Get the expectation values.
from qiskit_ibm_runtime import Estimator
with Estimator(
circuits=[qc1],
observables=[x_op, y_op],
service=service,
options={ "backend": "ibmq_qasm_simulator" }
) as estimator:
target = 0.01
exp_val = estimator(circuits=[0], observables=[x_op]).values[0]
print(f"Expectation value: {exp_val}")
while abs(exp_val) > target:
op = x_op if exp_val > 0 else y_op
exp_val = estimator(circuits=[0], observables=[op]).values[0]
print(f"Expectation value: {exp_val}")
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/jenglick/scipy22-qiskit-runtime-tutorial
|
jenglick
|
# Import the module needed to access Qiskit Runtime
from qiskit_ibm_runtime import QiskitRuntimeService
# Save account on disk.
# QiskitRuntimeService.save_account(channel="ibm_quantum", token=<IBM Quantum API token>)
# Load your IBM Quantum account or enable the account if it's not previously saved.
service = QiskitRuntimeService(channel="ibm_quantum")
# service = QiskitRuntimeService(channel="ibm_quantum", token=<IBM Quantum API token>)
# Specify the backend name.
options = {"backend_name": "ibmq_qasm_simulator"}
job = service.run(
program_id="hello-world",
options=options,
inputs={},
)
# Get the job result - this is blocking and control may not return immediately.
result = job.result()
print(result)
from qiskit.circuit.library import RealAmplitudes
pqc = RealAmplitudes(num_qubits=2, reps=2)
pqc.measure_all()
print(f"The circuit has {pqc.num_parameters} parameters")
pqc.decompose().draw()
# You can also check the backend configuration and properties.
# Backend configuration contains (mostly) static information about the backend.
# Backend properties contains dynamic information about the backend.
backend = service.least_busy(simulator=False, min_num_qubits=5)
print(f"Backend {backend.name} has {backend.configuration().num_qubits} qubits.")
print(f"T1 value for qubit 0 is {backend.properties().t1(0)}s")
# In this workshop we will be using the simulator.
backend = "ibmq_qasm_simulator"
from qiskit_ibm_runtime import Sampler
# Use a context manager to open a session.
with Sampler(circuits=pqc, service=service, options={"backend": backend}) as sampler:
pass
with Sampler(circuits=pqc, service=service, options={"backend": backend}) as sampler:
result = sampler(circuits=[0], parameter_values=[[0, 1, 1, 2, 3, 5]])
print(result)
from qiskit.circuit.library import EfficientSU2
pqc2 = EfficientSU2(num_qubits=2, reps=1)
pqc2.measure_all()
print(f"The circuit has {pqc2.num_parameters} parameters")
pqc2.decompose().draw()
from qiskit_ibm_runtime import Sampler
theta1 = [0, 1, 1, 2, 3, 5]
theta2 = [1, 2, 3, 4, 5, 6]
theta3 = [0, 1, 2, 3, 4, 5, 6, 7]
with Sampler(circuits=[pqc, pqc2], service=service, options={"backend": backend}) as sampler:
result = sampler(circuits=[0], parameter_values=[theta1], shots=2000)
print(f"Result from circuit 0 with parameter {theta1}: {result}\n")
result = sampler(circuits=[0, 0], parameter_values=[theta1, theta2])
print(f"Result from circuit 0 with parameters {theta1, theta2}: {result}\n")
result = sampler(circuits=[0, 1], parameter_values=[theta1, theta3])
print(f"Result from circuits 0, 1 with parameters {theta1, theta2}: {result}")
from qiskit.circuit import Parameter, QuantumCircuit
# Create a custom parameterized circuit.
theta = Parameter('θ')
qc = QuantumCircuit(1)
qc.rx(theta, 0)
qc.measure_all()
qc.draw()
from math import pi
from qiskit_ibm_runtime import Sampler
theta_val = 0.25*pi
with Sampler(circuits=[qc], service=service, options={"backend": backend}) as sampler:
result = sampler(circuits=[0], parameter_values=[[theta_val]], shots=100)
while result.quasi_dists[0].get('1', 0) < 0.5:
print(f"Result is {result.quasi_dists} when using theta {theta_val}")
theta_val += (result.quasi_dists[0].get('1', 0.25)*pi)
result = sampler(circuits=[0], parameter_values=[[theta_val]], shots=100)
print(f"All done. Result is {result.quasi_dists} when using theta {theta_val}")
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/jenglick/scipy22-qiskit-runtime-tutorial
|
jenglick
|
from qiskit_nature.drivers import Molecule
from qiskit_nature.drivers.second_quantization import ElectronicStructureDriverType, ElectronicStructureMoleculeDriver
dist = 0.72
molecule = Molecule(geometry=[['H', [0., 0., 0.]], ['H', [0., 0., dist]]])
driver = ElectronicStructureMoleculeDriver(molecule, basis='sto3g', \
driver_type=ElectronicStructureDriverType.PYSCF)
print(molecule)
from qiskit_nature.problems.second_quantization import ElectronicStructureProblem
es_problem = ElectronicStructureProblem(driver)
second_q_ops = es_problem.second_q_ops()
print(second_q_ops[0])
from qiskit_nature.converters.second_quantization import QubitConverter
from qiskit_nature.mappers.second_quantization import ParityMapper
qubit_converter = QubitConverter(ParityMapper(), two_qubit_reduction=True)
hamiltonian = qubit_converter.convert(second_q_ops[0], num_particles=es_problem.num_particles)
print(hamiltonian)
from qiskit.algorithms import NumPyMinimumEigensolver
from qiskit.algorithms import MinimumEigensolverResult
# Generate the exact solution
sol = MinimumEigensolverResult()
sol.eigenvalue = NumPyMinimumEigensolver().compute_minimum_eigenvalue(hamiltonian).eigenvalue
exact_solution = es_problem.interpret(sol).total_energies[0]
print('exact_solution:\n{}'.format(exact_solution))
from qiskit.opflow import TaperedPauliSumOp
import numpy as np
ops = []
h = hamiltonian.primitive
h.coeffs = np.real(hamiltonian.coeffs)
ops.append(TaperedPauliSumOp(h, hamiltonian.z2_symmetries))
from qiskit_ibm_runtime import QiskitRuntimeService, Estimator
service = QiskitRuntimeService()
options = {"backend" : "ibmq_qasm_simulator"}
from qiskit.algorithms.optimizers import NELDER_MEAD
from qiskit.circuit.library import RealAmplitudes
circuit = RealAmplitudes(num_qubits=hamiltonian.num_qubits, reps=2)
circuit.decompose().draw()
convergence = []
with Estimator(
circuits=circuit,
observables=ops,
options=options,
service=service
) as estimator:
def evaluate_expectation(x):
x = list(x)
results = estimator(circuits=[0], observables=[0], parameter_values=[x]).values[0]
return np.real(results)
def callback(fx):
expval = evaluate_expectation(fx)
print('expval: {}'.format(expval))
convergence.append(expval)
np.random.seed(1)
initial_point = np.random.uniform(-np.pi, np.pi, len(circuit.parameters))
optimizer = NELDER_MEAD(40, callback=callback)
result = optimizer.minimize(fun=evaluate_expectation, x0=initial_point)
total_energy = []
for i in range(len(convergence)):
sol = MinimumEigensolverResult()
sol.eigenvalue = convergence[i]
sol = es_problem.interpret(sol).total_energies[0]
total_energy.append(sol)
print(total_energy)
import matplotlib.pyplot as plt
plt.rcParams["font.size"] = 14
plt.figure(figsize=(12, 6))
plt.plot(total_energy, label="Estimator VQE")
plt.axhline(y=exact_solution, 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()
from qiskit.tools.jupyter import *
%qiskit_version_table
%qiskit_copyright
|
https://github.com/jenglick/scipy22-qiskit-runtime-tutorial
|
jenglick
|
from qiskit.quantum_info import SparsePauliOp
op = SparsePauliOp.from_list([("ZZII", 1)])
num_qubits = op.num_qubits
ops = [op]
print(op)
target_energy = -1
from qiskit.circuit.library import EfficientSU2
circuit = EfficientSU2(num_qubits, reps=1, entanglement="linear", insert_barriers=True)
circuit.decompose().draw()
from qiskit_ibm_runtime import QiskitRuntimeService, Estimator
from qiskit.algorithms.optimizers import SPSA
import numpy as np
service = QiskitRuntimeService()
options = {"backend" : "ibmq_qasm_simulator"}
# Callback: number of function evals, parameters, function value, stepsize, whether step was accepted
history = {"nfevs": [], "points": [], "fvals": [], "updates": [], "accepted": []}
with Estimator(circuits=circuit, observables=ops, options=options, service=service) as estimator:
def evaluate_expectation(x):
x = list(x)
results = estimator(circuits=[0], observables=[0], parameter_values=[x]).values[0]
return np.real(results)
def callback(nfev, point, fval, update, accepted):
print('expectation value: {}'.format(fval))
history["nfevs"].append(nfev)
history["points"].append(point)
history["fvals"].append(fval)
history["updates"].append(update)
history["accepted"].append(accepted)
initial_point = np.random.random(circuit.num_parameters)
optimizer = SPSA(20, callback=callback)
result = optimizer.minimize(fun=evaluate_expectation, x0=initial_point)
history["fvals"][-1] - target_energy
print('optimal point:\n{}'.format(result.x))
import qiskit_ibm_runtime
qiskit_ibm_runtime.version.get_version_info()
from qiskit.tools.jupyter import *
%qiskit_version_table
%qiskit_copyright
|
https://github.com/jenglick/scipy22-qiskit-runtime-tutorial
|
jenglick
|
import numpy as np
w = np.array([[0., 1., 1., 1.],
[1., 0., 1., 0.],
[1., 1., 0., 1.],
[1., 0., 1., 0.]])
from qiskit_optimization.applications import Maxcut
max_cut = Maxcut(w)
qp = max_cut.to_quadratic_program()
print(qp.export_as_lp_string())
qubitOp, offset = qp.to_ising()
num_qubits = qubitOp.num_qubits
print("Offset:", offset)
print("Ising Hamiltonian:")
print(str(qubitOp))
from qiskit_optimization.algorithms import MinimumEigenOptimizer
from qiskit.algorithms import NumPyMinimumEigensolver
exact = MinimumEigenOptimizer(NumPyMinimumEigensolver())
result = exact.solve(qp)
print(result)
from qiskit.opflow import PauliSumOp
import numpy as np
ops = []
h = qubitOp.primitive
h.coeffs = np.real(qubitOp.coeffs)
ops.append(PauliSumOp(h))
print(ops)
from qiskit_ibm_runtime import QiskitRuntimeService
service = QiskitRuntimeService()
options = {"backend" : "ibmq_qasm_simulator"}
from qiskit.circuit.library import TwoLocal
circuit = TwoLocal(qubitOp.num_qubits, "ry", "cz", reps=5, entanglement="linear")
circuit.decompose().draw(fold=300)
from qiskit_ibm_runtime import Estimator
from qiskit.algorithms.optimizers import SPSA
history = {"nfevs": [], "points": [], "fvals": [], "updates": [], "accepted": []}
with Estimator(
circuits=circuit,
observables=ops,
options=options,
service=service
) as estimator:
def evaluate_expectation(x):
x = list(x)
results = estimator(circuits=[0], observables=[0], parameter_values=[x]).values[0]
return np.real(results)
def callback(nfev, point, fval, update, accepted):
print('expectation value: {}'.format(fval))
history["nfevs"].append(nfev)
history["points"].append(point)
history["fvals"].append(fval)
history["updates"].append(update)
history["accepted"].append(accepted)
np.random.seed(1)
initial_point = np.random.uniform(-np.pi, np.pi, len(circuit.parameters))
optimizer = SPSA(50, callback=callback)
result = optimizer.minimize(fun=evaluate_expectation, x0=initial_point)
print('optimized circuit parameters:\n{}'.format(result.x))
from qiskit_ibm_runtime import Sampler
circut = circuit.measure_all()
with Sampler(
circuits=circuit,
options=options,
service=service
) as sampler:
sampler_result = sampler(circuits=[0], parameter_values=[result.x], shots=8000)
print(result)
bitstrings = sampler_result.quasi_dists[0] # get the dictionary of bitstring counts
import matplotlib.pyplot as plt
fig, axs = plt.subplots(1, 2, figsize=(14, 5))
axs[0].plot(history['fvals'])
axs[1].bar(list(bitstrings.keys()), list(bitstrings.values()))
axs[0].set_xlabel("Energy Evaluation Number")
axs[0].set_ylabel("Energy")
axs[1].set_xlabel("Objective Function Value")
axs[1].set_ylabel("Probability")
samples = []
for x, probability in bitstrings.items():
x = list(map(int, x)) # convert bitstring to list
status = qp.is_feasible(x)
fval = qp.objective.evaluate(x)
samples.append((x, fval, probability, status))
sorted_samples = sorted(
samples,
key=lambda v: (1-v[3], qp.objective.sense.value * v[1]) # feasible: 0; infeasible: 1
)
print('\nsorted')
for sample in sorted_samples:
print(sample)
best = sorted_samples[0]
print('optimal value: {}'.format(best[0]))
print('optimal function value: {}'.format(best[1]))
print('probability of optimal value: {}'.format(best[2]))
from qiskit_optimization import QuadraticProgram
qp = QuadraticProgram()
qp.binary_var("x")
qp.binary_var("y")
qp.binary_var("z")
qp.minimize(linear=[1, -2, 3], quadratic={("x", "y"): 1, ("x", "z"): -1, ("y", "z"): 2})
print(qp.export_as_lp_string())
qubitOp, offset = qp.to_ising()
num_qubits = qubitOp.num_qubits
print("offset: {}".format(offset))
print("operator:\n{}".format(qubitOp))
from qiskit_optimization.algorithms import MinimumEigenOptimizer
from qiskit.algorithms import NumPyMinimumEigensolver
exact = MinimumEigenOptimizer(NumPyMinimumEigensolver())
result = exact.solve(qp)
print(result)
from qiskit.opflow import PauliSumOp
import numpy as np
ops = []
h = qubitOp.primitive
h.coeffs = np.real(qubitOp.coeffs)
ops.append(PauliSumOp(h))
print(ops)
from qiskit_ibm_runtime import QiskitRuntimeService
service = QiskitRuntimeService()
options = {"backend" : "ibmq_qasm_simulator"}
from qiskit.circuit.library import RealAmplitudes
circuit = RealAmplitudes(num_qubits=num_qubits, reps=2)
circuit.decompose().draw(fold=100)
from qiskit_ibm_runtime import Estimator
from qiskit.algorithms.optimizers import SPSA
history = {"nfevs": [], "points": [], "fvals": [], "updates": [], "accepted": []}
with Estimator(
circuits=circuit,
observables=ops,
options=options,
service=service
) as estimator:
def evaluate_expectation(x):
x = list(x)
results = estimator(circuits=[0], observables=[0], parameter_values=[x]).values[0]
return np.real(results)
def callback(nfev, point, fval, update, accepted):
print('expectation value: {}'.format(fval))
history["nfevs"].append(nfev)
history["points"].append(point)
history["fvals"].append(fval)
history["updates"].append(update)
history["accepted"].append(accepted)
np.random.seed(1)
initial_point = np.random.uniform(-np.pi, np.pi, len(circuit.parameters))
optimizer = SPSA(30, callback=callback)
result = optimizer.minimize(fun=evaluate_expectation, x0=initial_point)
print('optimized circuit parameters:\n{}'.format(result.x))
from qiskit_ibm_runtime import Sampler
circut = circuit.measure_all()
with Sampler(
circuits=circuit,
options=options,
service=service
) as sampler:
sampler_result = sampler(circuits=[0], parameter_values=[result.x], shots=8000)
print(sampler_result)
bitstrings = sampler_result.quasi_dists[0] # get the dictionary of bitstring counts
import matplotlib.pyplot as plt
fig, axs = plt.subplots(1, 2, figsize=(14, 5))
axs[0].plot(history['fvals'])
axs[1].bar(list(bitstrings.keys()), list(bitstrings.values()))
axs[0].set_xlabel("Energy Evaluation Number")
axs[0].set_ylabel("Energy")
axs[1].set_xlabel("Objective Function Value")
axs[1].set_ylabel("Probability")
samples = []
for x, probability in bitstrings.items():
x = list(map(int, x)) # convert bitstring to list
status = qp.is_feasible(x)
fval = qp.objective.evaluate(x)
samples.append((x, fval, probability, status))
sorted_samples = sorted(
samples,
key=lambda v: (1-v[3], qp.objective.sense.value * v[1]) # feasible: 0; infeasible: 1
)
print('\nsorted')
for sample in sorted_samples:
print(sample)
best = sorted_samples[0]
print('optimal value: {}'.format(best[0]))
print('optimal function value: {}'.format(best[1]))
print('probability of optimal value: {}'.format(best[2]))
import qiskit_ibm_runtime
qiskit_ibm_runtime.version.get_version_info()
from qiskit.tools.jupyter import *
%qiskit_version_table
%qiskit_copyright
|
https://github.com/jayeshparashar/Bloch-sphere-
|
jayeshparashar
|
# in this step, we will generate a 2 dim random statevector using quantum_info random_statevector method
from qiskit.quantum_info import random_statevector, Statevector
rand_sv = random_statevector(2).data
print(rand_sv) # print the vector components (complex amplitudes) associated with bais |0> and |1> from rand_sv
#Lets plot the rand_sv using plot_bloch_multivector, before that import plot_bloch vector from qiskit.visualization
from qiskit.visualization import plot_bloch_multivector
plot_bloch_multivector(rand_sv)
# once we will have the cartesian cordinates calculated we can use plot_bloch_vector from visualization as shown below
from qiskit.visualization import plot_bloch_vector
plot_bloch_vector([1,0,0])
# break down complex amplitudes α and β in real and imaginary parts to express same in polar form.
import math
import numpy as np
print('The random statevector', rand_sv)
alpha_real = rand_sv[0].real
alpha_imag = rand_sv[0].imag
alpha_theta = math.atan(alpha_imag/alpha_real)
if alpha_real < 0 and alpha_imag > 0 :
alpha_theta = math.atan(alpha_imag/alpha_real) + math.pi
if alpha_real < 0 and alpha_imag < 0 :
alpha_theta = math.atan(alpha_imag/alpha_real) + math.pi
print ('alpha and alpha_theta ', np.around(alpha_real,8), np.around(alpha_imag,8), math.degrees(alpha_theta))
r_alpha = math.sqrt((alpha_real**2) + (alpha_imag**2))
beta_real = rand_sv[1].real
beta_imag = rand_sv[1].imag
beta_theta = math.atan(beta_imag/beta_real)
if beta_real < 0 and beta_imag > 0 :
beta_theta = math.atan(beta_imag/beta_real) + math.pi
if beta_real < 0 and beta_imag < 0 :
beta_theta = math.atan(beta_imag/beta_real) + math.pi
print ('beta and beta_theta ', np.around(beta_real,8), np.around(beta_imag,8), math.degrees(beta_theta))
r_beta = math.sqrt((beta_real**2) + (beta_imag**2))
# use global phase to get a real only value for amplitude associated with state |0> on bloch sphere
phi = beta_theta - alpha_theta
print('r_alpha, r_beta, Phase differnce phi: ',phi)
theta = 2 * np.arccos(r_alpha)
print('Spherical Coordinates of Blochsphere are theta and phi : 1, ', theta, beta_theta - alpha_theta)
x = math.sin(theta)*math.cos(phi)
y = math.sin(theta)*math.sin(phi)
z = math.cos(theta)
print(x,y,z)
plot_bloch_vector([x,y,z])
#plot_bloch_vector([1, theta, phi], coord_type='spherical') # also try it out with spherical coordinates
#once agian we plot rand_sv state to check if that is same as what we have calculated above
plot_bloch_multivector(rand_sv)
|
https://github.com/jayeshparashar/Bloch-sphere-
|
jayeshparashar
|
from qiskit import *
import numpy as np
import math
from qiskit.visualization import plot_bloch_multivector, plot_state_qsphere, plot_histogram
# Define a function which will return a gate equivalent to (control-Z)^n, this gate is used in a below circuit to change
# the phase of control qubits by various powers of 2.
def CU_Z(power) :
circ = QuantumCircuit(2)
circ.cz(0,1)
Unitary = circ.to_gate()
ret_unitary = Unitary.power(power)
return ret_unitary
# Define a function which will return a gate equivalent to (control-RZ(pi))^n, it is used in below circuit to change
# the phase of control qubits by powers of 2, such that the control qubits carries the value of global phase introduced
# by a single RZ(pi) in fourier (phase) basis.
def CU_RZ(power) :
circ = QuantumCircuit(2)
circ.crz(np.pi, 0,1)
Unitary = circ.to_gate()
ret_unitary = Unitary.power(power)
return ret_unitary
# define a function that will convert the information from phase basis to computational basis
def inv_qft(circuit, n):
for qubit in range(n//2):
circuit.swap(qubit, n-qubit-1) # you don't need this step if you apply control Ops on qubits in reversed order
for j in range(n):
for m in range(j):
circuit.cp(-math.pi/float(2**(j-m)), m, j)
circuit.h(j)
# Run a circuit to calculate global phase introduced by a Rz(pi) gate
nqubits = 3
qc = QuantumCircuit(nqubits + 1, nqubits)
qc.h(range(nqubits)) # set control qubits to phase basis
qc.x(nqubits) # comment this line to choose |0> eigen vector, it will not change the results
qc.append(CU_RZ(1), [0, nqubits]) # Kickback a phase introduced by Rz(pi) times 2^0 to 0th control qubit
qc.append(CU_RZ(2), [1, nqubits]) # Kickback the phase introduced by Rz(pi) times 2^1 to 1st control qubit
qc.append(CU_RZ(4), [2, nqubits]) # Kickback the phase introduced by Rz(pi) times 2^2 to 2nd control qubit
qc.draw()
# print qubits on Bloch sphere to witness the global phase introduced by a Rz(pi) rotation
bkend = Aer.get_backend('statevector_simulator')
job = execute(qc, bkend)
sv1 = job.result().get_statevector(qc)
#print(sv1)
plot_bloch_multivector(sv1)
# apply inverse qft to read convert infomration coded in phase basis to computational basis
inv_qft(qc, nqubits)
qc.measure(range(nqubits), range(nqubits))
qc.draw()
# Run circuit with qasm simulator or real quantum computer on cloud to obtain the value of global phase using IQFT
# We only have to measure first three qubits from LSB as the state on MSB qubit will remain unchanged
bkend = Aer.get_backend('qasm_simulator')
job = execute(qc, bkend, shots=100)
cnt1 = job.result().get_counts(qc)
print(cnt1)
max_val = max(cnt1, key=cnt1.get)
max_val_dec = int(max_val, 2)
print('Global Phase introduced by Rz(pi) gate is = ', (2*np.pi)/(2**nqubits) * max_val_dec, ' radians and ', (360/(2**nqubits) * max_val_dec), ' Degrees.')
plot_histogram(cnt1)
#### Lets run same routine with Z gate that rotate the state vector on bloch sphere by pi radians around Z axis
# Run below circuit to calculate the global phase introduced by Z gate
nqubits = 3
qc_z = QuantumCircuit(nqubits + 1, nqubits)
qc_z.h(range(nqubits))
qc_z.x(nqubits)
qc_z.append(CU_Z(1), [0, nqubits]) #Kickback the phase introduced by a Z gate times 2^0 to 0th control qubit
qc_z.append(CU_Z(2), [1, nqubits]) #Kickback a phase introduced by a Z gate times 2^1 to 0th control qubit
qc_z.append(CU_Z(4), [2, nqubits]) #Kickback a phase introduced by a Z gate times 2^2 to 0th control qubit
qc_z.draw()
# print qubits on Bloch Sphere to get the global phase introduced by a Z gate
bkend = Aer.get_backend('statevector_simulator')
job = execute(qc_z, bkend)
sv2 = job.result().get_statevector(qc_z)
#print(sv2)
plot_bloch_multivector(sv2)
# apply inverse qft to read convert information coded in phase basis to computational basis
inv_qft(qc_z, nqubits)
qc_z.measure(range(nqubits), range(nqubits))
qc_z.draw()
# Run circuit with qasm simulator or real quantum computer on cloud to extract and print the value of global phase
# using IQFT introduced by a Z gate, We only have to measure the first three qubits from LSB as the state on MSB qubit
# will remain unchanged
bkend = Aer.get_backend('qasm_simulator')
job = execute(qc_z, bkend, shots=100)
cnt2 = job.result().get_counts(qc_z)
print(cnt2)
max_val = max(cnt2, key=cnt2.get)
max_val_dec = int(max_val, 2)
print('Global Phase introduced by a Z gate is = ', (2*np.pi)/(2**nqubits) * max_val_dec, ' radians and ', (360/(2**nqubits) * max_val_dec), ' Degrees.')
plot_histogram(cnt2)
# end of program
|
https://github.com/jayeshparashar/Bloch-sphere-
|
jayeshparashar
|
#Let's start with importing packages
from qiskit import QuantumRegister, ClassicalRegister,QuantumCircuit, Aer, assemble, execute
from qiskit.visualization import plot_histogram, plot_bloch_vector, plot_bloch_multivector
import numpy as np
# import random_statevector to get a random two state quantum system
from qiskit.quantum_info import random_statevector, Statevector
# Use random_statevector method to get a valid random statevector representing a qubit in superposition of two states
rand_sv = random_statevector(2).data
print(rand_sv)
plot_bloch_multivector(rand_sv)
# Define a function to calculate and return the expectation values of X, Y and Z coordinates of a qubit vector situated
# on a blochsphere, since qiskit measurement operation is set to measure in default 'Z' axis, in order to measure qubit
# in 'X' and 'Y' direction/axis we have to rotate/adjust the final vector as it is measured in X and Y axis while performing
# a default Z measurement.
def Exp_Value(axis):
shots=10000
qc = QuantumCircuit(1,1)
qc.initialize(rand_sv,0)
if (axis == 'Y') :
qc.sdg(0)
if (axis == 'X' or axis == 'Y') :
qc.h(0)
qc.measure(0,0)
bkend = Aer.get_backend('qasm_simulator')
cnts = execute(qc,bkend,shots=shots).result().get_counts()
exp_val = (cnts['0'] * 1 + cnts['1']* -1 )/shots
print('counts and exp. value for qubit system for', axis,' measurement ', cnts['0'], cnts['1'], exp_val)
return exp_val
# The expectation values of X, Y and Z on same initial state is an indicator of average energy which is calculated with
# the help of eigenvalues (discrete energy states) obtained during the measurement in same repeated experiment.
ev_X = Exp_Value('X')
ev_Y = Exp_Value('Y')
ev_Z = Exp_Value('Z')
print(ev_X, ev_Y, ev_Z)
# let's plot the vector on blochsphere with help of cartesian coordinates and see if we get same representation as
# rand_sv
plot_bloch_vector([ev_X, ev_Y, ev_Z])
# lets calculate the spherical coordinates theta and phi as radius is 1
# since x = sin(θ)cos(φ), y = sin(θ)sin(φ) and z = cos(θ)
theta = np.arccos(ev_Z)
phi = np.arcsin(ev_Y/np.sin(theta))
print('theta, phi ', theta, phi)
plot_bloch_vector([1, theta, phi], coord_type='spherical')
#lets calculate the vector associated with this value of theta and phi using standard qubit's representation
# on blochsphere
amp_zero = np.cos(theta/2)
amp_one = np.cos(phi)*np.sin(theta/2) + (np.sin(phi)*np.sin(theta/2)) * complex(0, 1)
q_sv = [amp_zero, amp_one]
print(q_sv)
plot_bloch_multivector(q_sv)
# lets measure the state_fidelity to check if both the states (rand_sv and q_sv) are in-fact same
from qiskit.quantum_info import state_fidelity
print(rand_sv, q_sv)
state_fidelity(rand_sv, q_sv)
# End of program #
|
https://github.com/bringthehouse/qiskit-2019-purple-qubits-server
|
bringthehouse
|
#!/usr/bin/env python3
from qiskit import QuantumRegister, ClassicalRegister
from qiskit import QuantumCircuit, Aer, execute
def run_qasm(qasm, backend_to_run="qasm_simulator"):
qc = QuantumCircuit.from_qasm_str(qasm)
backend = Aer.get_backend(backend_to_run)
job_sim = execute(qc, backend)
sim_result = job_sim.result()
return sim_result.get_counts(qc)
|
https://github.com/ashishpatel26/IBM-Quantum-Challenge-Africa-2021
|
ashishpatel26
|
from qiskit import *
from qiskit.visualization import plot_histogram
import numpy as np
def NOT(inp):
"""An NOT gate.
Parameters:
inp (str): Input, encoded in qubit 0.
Returns:
QuantumCircuit: Output NOT circuit.
str: Output value measured from qubit 0.
"""
qc = QuantumCircuit(1, 1) # A quantum circuit with a single qubit and a single classical bit
qc.reset(0)
# We encode '0' as the qubit state |0⟩, and '1' as |1⟩
# Since the qubit is initially |0⟩, we don't need to do anything for an input of '0'
# For an input of '1', we do an x to rotate the |0⟩ to |1⟩
if inp=='1':
qc.x(0)
# barrier between input state and gate operation
qc.barrier()
# Now we've encoded the input, we can do a NOT on it using x
qc.x(0)
#barrier between gate operation and measurement
qc.barrier()
# Finally, we extract the |0⟩/|1⟩ output of the qubit and encode it in the bit c[0]
qc.measure(0,0)
qc.draw()
# We'll run the program on a simulator
backend = Aer.get_backend('qasm_simulator')
# Since the output will be deterministic, we can use just a single shot to get it
job = backend.run(qc, shots=1, memory=True)
output = job.result().get_memory()[0]
return qc, output
## Test the function
for inp in ['0', '1']:
qc, out = NOT(inp)
print('NOT with input',inp,'gives output',out)
display(qc.draw())
print('\n')
def XOR(inp1,inp2):
"""An XOR gate.
Parameters:
inpt1 (str): Input 1, encoded in qubit 0.
inpt2 (str): Input 2, encoded in qubit 1.
Returns:
QuantumCircuit: Output XOR circuit.
str: Output value measured from qubit 1.
"""
qc = QuantumCircuit(2, 1)
qc.reset(range(2))
if inp1=='1':
qc.x(0)
if inp2=='1':
qc.x(1)
# barrier between input state and gate operation
qc.barrier()
# this is where your program for quantum XOR gate goes
qc.cx(0, 1)
# barrier between input state and gate operation
qc.barrier()
qc.measure(1,0) # output from qubit 1 is measured
#We'll run the program on a simulator
backend = Aer.get_backend('qasm_simulator')
#Since the output will be deterministic, we can use just a single shot to get it
job = backend.run(qc, shots=1, memory=True)
output = job.result().get_memory()[0]
return qc, output
## Test the function
for inp1 in ['0', '1']:
for inp2 in ['0', '1']:
qc, output = XOR(inp1, inp2)
print('XOR with inputs',inp1,inp2,'gives output',output)
display(qc.draw())
print('\n')
def AND(inp1,inp2):
"""An AND gate.
Parameters:
inpt1 (str): Input 1, encoded in qubit 0.
inpt2 (str): Input 2, encoded in qubit 1.
Returns:
QuantumCircuit: Output XOR circuit.
str: Output value measured from qubit 2.
"""
qc = QuantumCircuit(3, 1)
qc.reset(range(2))
if inp1=='1':
qc.x(0)
if inp2=='1':
qc.x(1)
qc.barrier()
# this is where your program for quantum AND gate goes
qc.ccx(0,1,2)
qc.barrier()
qc.measure(2, 0) # output from qubit 2 is measured
# We'll run the program on a simulator
backend = Aer.get_backend('qasm_simulator')
# Since the output will be deterministic, we can use just a single shot to get it
job = backend.run(qc, shots=1, memory=True)
output = job.result().get_memory()[0]
return qc, output
## Test the function
for inp1 in ['0', '1']:
for inp2 in ['0', '1']:
qc, output = AND(inp1, inp2)
print('AND with inputs',inp1,inp2,'gives output',output)
display(qc.draw())
print('\n')
def NAND(inp1,inp2):
"""An NAND gate.
Parameters:
inpt1 (str): Input 1, encoded in qubit 0.
inpt2 (str): Input 2, encoded in qubit 1.
Returns:
QuantumCircuit: Output NAND circuit.
str: Output value measured from qubit 2.
"""
qc = QuantumCircuit(3, 1)
qc.reset(range(3))
if inp1=='1':
qc.x(0)
if inp2=='1':
qc.x(1)
qc.barrier()
# this is where your program for quantum NAND gate goes
qc.ccx(0,1,2)
if inp=='1':
qc.x(2)
qc.barrier()
qc.measure(2, 0) # output from qubit 2 is measured
# We'll run the program on a simulator
backend = Aer.get_backend('aer_simulator')
# Since the output will be deterministic, we can use just a single shot to get it
job = backend.run(qc,shots=1,memory=True)
output = job.result().get_memory()[0]
return qc, output
## Test the function
for inp1 in ['0', '1']:
for inp2 in ['0', '1']:
qc, output = NAND(inp1, inp2)
print('NAND with inputs',inp1,inp2,'gives output',output)
display(qc.draw())
print('\n')
def OR(inp1,inp2):
"""An OR gate.
Parameters:
inpt1 (str): Input 1, encoded in qubit 0.
inpt2 (str): Input 2, encoded in qubit 1.
Returns:
QuantumCircuit: Output XOR circuit.
str: Output value measured from qubit 2.
"""
qc = QuantumCircuit(3, 1)
qc.reset(range(3))
if inp1=='1':
qc.x(0)
if inp2=='1':
qc.x(1)
qc.barrier()
# this is where your program for quantum OR gate goes
qc.cx(0, 2)
qc.cx(1, 2)
qc.barrier()
qc.measure(2, 0) # output from qubit 2 is measured
# We'll run the program on a simulator
backend = Aer.get_backend('aer_simulator')
# Since the output will be deterministic, we can use just a single shot to get it
job = backend.run(qc,shots=1,memory=True)
output = job.result().get_memory()[0]
return qc, output
## Test the function
for inp1 in ['0', '1']:
for inp2 in ['0', '1']:
qc, output = OR(inp1, inp2)
print('OR with inputs',inp1,inp2,'gives output',output)
display(qc.draw())
print('\n')
from qiskit import IBMQ
#IBMQ.save_account("a68a35747d4eccd1d58f275e637909987c789ce5c0edd8a4f43014672bf0301b54b28b1b5f44ba8ff87500777429e1e4ceb79621a6ba248d6cca6bca0e233d23", overwrite=True)
IBMQ.load_account()
IBMQ.providers()
provider = IBMQ.get_provider('ibm-q')
provider.backends()
import qiskit.tools.jupyter
# run this cell
backend = provider.get_backend('ibmq_quito')
qc_and = QuantumCircuit(3)
qc_and.ccx(0,1,2)
print('AND gate')
display(qc_and.draw())
print('\n\nTranspiled AND gate with all the required connectivity')
qc_and.decompose().draw()
from qiskit.tools.monitor import job_monitor
# run the cell to define AND gate for real quantum system
def AND(inp1, inp2, backend, layout):
qc = QuantumCircuit(3, 1)
qc.reset(range(3))
if inp1=='1':
qc.x(0)
if inp2=='1':
qc.x(1)
qc.barrier()
qc.ccx(0, 1, 2)
qc.barrier()
qc.measure(2, 0)
qc_trans = transpile(qc, backend, initial_layout=layout, optimization_level=3)
job = backend.run(qc_trans, shots=8192)
print(job.job_id())
job_monitor(job)
output = job.result().get_counts()
return qc_trans, output
backend
layout = [0, 1, 2]
output_all = []
qc_trans_all = []
prob_all = []
worst = 1
best = 0
for input1 in ['0','1']:
for input2 in ['0','1']:
qc_trans, output = AND(input1, input2, backend, layout)
output_all.append(output)
qc_trans_all.append(qc_trans)
prob = output[str(int( input1=='1' and input2=='1' ))]/8192
prob_all.append(prob)
print('\nProbability of correct answer for inputs',input1,input2)
print('{:.2f}'.format(prob) )
print('---------------------------------')
worst = min(worst,prob)
best = max(best, prob)
print('')
print('\nThe highest of these probabilities was {:.2f}'.format(best))
print('The lowest of these probabilities was {:.2f}'.format(worst))
print('Transpiled AND gate circuit for ibmq_vigo with input 0 0')
print('\nThe circuit depth : {}'.format (qc_trans_all[0].depth()))
print('# of nonlocal gates : {}'.format (qc_trans_all[0].num_nonlocal_gates()))
print('Probability of correct answer : {:.2f}'.format(prob_all[0]) )
qc_trans_all[0].draw()
print('Transpiled AND gate circuit for ibmq_vigo with input 0 1')
print('\nThe circuit depth : {}'.format (qc_trans_all[1].depth()))
print('# of nonlocal gates : {}'.format (qc_trans_all[1].num_nonlocal_gates()))
print('Probability of correct answer : {:.2f}'.format(prob_all[1]) )
qc_trans_all[1].draw()
print('Transpiled AND gate circuit for ibmq_vigo with input 1 0')
print('\nThe circuit depth : {}'.format (qc_trans_all[2].depth()))
print('# of nonlocal gates : {}'.format (qc_trans_all[2].num_nonlocal_gates()))
print('Probability of correct answer : {:.2f}'.format(prob_all[2]) )
qc_trans_all[2].draw()
print('Transpiled AND gate circuit for ibmq_vigo with input 1 1')
print('\nThe circuit depth : {}'.format (qc_trans_all[3].depth()))
print('# of nonlocal gates : {}'.format (qc_trans_all[3].num_nonlocal_gates()))
print('Probability of correct answer : {:.2f}'.format(prob_all[3]) )
qc_trans_all[3].draw()
|
https://github.com/ashishpatel26/IBM-Quantum-Challenge-Africa-2021
|
ashishpatel26
|
import numpy as np
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile, Aer, execute
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from qiskit.providers.aer import QasmSimulator
backend = Aer.get_backend('statevector_simulator')
qc1 = QuantumCircuit(4)
# perform gate operations on individual qubits
qc1.x(0)
qc1.y(1)
qc1.z(2)
qc1.s(3)
# Draw circuit
qc1.draw()
# Plot blochshere
out1 = execute(qc1,backend).result().get_statevector()
plot_bloch_multivector(out1)
qc2 = QuantumCircuit(4)
# initialize qubits
qc2.x(range(4))
# perform gate operations on individual qubits
qc2.x(0)
qc2.y(1)
qc2.z(2)
qc2.s(3)
# Draw circuit
qc2.draw()
# Plot blochshere
out2 = execute(qc2,backend).result().get_statevector()
plot_bloch_multivector(out2)
qc3 = QuantumCircuit(4)
# initialize qubits
qc3.h(range(4))
# perform gate operations on individual qubits
qc3.x(0)
qc3.y(1)
qc3.z(2)
qc3.s(3)
# Draw circuit
qc3.draw()
# Plot blochshere
out3 = execute(qc3,backend).result().get_statevector()
plot_bloch_multivector(out3)
qc4 = QuantumCircuit(4)
# initialize qubits
qc4.x(range(4))
qc4.h(range(4))
# perform gate operations on individual qubits
qc4.x(0)
qc4.y(1)
qc4.z(2)
qc4.s(3)
# Draw circuit
qc4.draw()
# Plot blochshere
out4 = execute(qc4,backend).result().get_statevector()
plot_bloch_multivector(out4)
qc5 = QuantumCircuit(4)
# initialize qubits
qc5.h(range(4))
qc5.s(range(4))
# perform gate operations on individual qubits
qc5.x(0)
qc5.y(1)
qc5.z(2)
qc5.s(3)
# Draw circuit
qc5.draw()
# Plot blochshere
out5 = execute(qc5,backend).result().get_statevector()
plot_bloch_multivector(out5)
qc6 = QuantumCircuit(4)
# initialize qubits
qc6.x(range(4))
qc6.h(range(4))
qc6.s(range(4))
# perform gate operations on individual qubits
qc6.x(0)
qc6.y(1)
qc6.z(2)
qc6.s(3)
# Draw circuit
qc6.draw()
# Plot blochshere
out6 = execute(qc6,backend).result().get_statevector()
plot_bloch_multivector(out6)
import qiskit
qiskit.__qiskit_version__
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.