repo
stringclasses 885
values | file
stringclasses 741
values | content
stringlengths 4
215k
|
|---|---|---|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### added y gate ###
qc.y(0)
qc.h(1)
return qc
|
https://github.com/zapata-engineering/orquestra-qiskit
|
zapata-engineering
|
################################################################################
# © Copyright 2021-2022 Zapata Computing Inc.
################################################################################
import pytest
import qiskit
from orquestra.quantum.circuits.symbolic.expressions import FunctionCall, Symbol
from orquestra.quantum.circuits.symbolic.translations import translate_expression
from orquestra.integrations.qiskit.conversions._qiskit_expressions import (
QISKIT_DIALECT,
expression_from_qiskit,
integer_pow,
)
THETA = qiskit.circuit.Parameter("theta")
PHI = qiskit.circuit.Parameter("phi")
EQUIVALENT_EXPRESSIONS = [
(
FunctionCall(
name="add",
args=(1, FunctionCall(name="mul", args=(2, Symbol(name="theta")))),
),
THETA * 2 + 1,
),
(
FunctionCall(
name="add",
args=(1, FunctionCall(name="pow", args=(Symbol(name="theta"), 2))),
),
THETA * THETA + 1,
),
(
FunctionCall(
name="sub",
args=(
2,
FunctionCall(
name="mul", args=(Symbol(name="phi"), Symbol(name="theta"))
),
),
),
2 - THETA * PHI,
),
]
INTERMEDIATE_EXPRESSIONS = [expr for expr, _ in EQUIVALENT_EXPRESSIONS]
class TestParsingQiskitExpressions:
@pytest.mark.parametrize("intermediate_expr, qiskit_expr", EQUIVALENT_EXPRESSIONS)
def test_parsed_intermediate_expression_matches_equivalent_expression(
self, intermediate_expr, qiskit_expr
):
parsed_expr = expression_from_qiskit(qiskit_expr)
assert parsed_expr == intermediate_expr
@pytest.mark.parametrize("expr", INTERMEDIATE_EXPRESSIONS)
def test_translate_parse_identity(self, expr):
# NOTE: the other way round (Qiskit -> intermediate -> Qiskit) can't be done
# directly, because Qiskit expressions don't implement equality checks.
qiskit_expr = translate_expression(expr, QISKIT_DIALECT)
parsed_expr = expression_from_qiskit(qiskit_expr)
assert parsed_expr == expr
class TestIntegerPower:
def test_only_integer_exponents_are_valid(self):
with pytest.raises(ValueError):
integer_pow(2, 2.5)
@pytest.mark.parametrize("base", [10, THETA])
def test_with_exponent_0_is_equal_to_one(self, base):
assert integer_pow(base, 0) == 1
@pytest.mark.parametrize(
"base, exponent, expected_result",
[(2.5, 3, 2.5**3), (THETA, 2, THETA * THETA)],
)
def test_with_positive_exponent_is_converted_to_repeated_multiplication(
self, base, exponent, expected_result
):
assert integer_pow(base, exponent) == expected_result
def test_negative_exponent_cannot_be_used_if_base_is_zero(self):
with pytest.raises(ValueError):
integer_pow(0, -10)
@pytest.mark.parametrize(
"base, exponent, expected_result",
[(2.0, -4, 0.5**4), (THETA, -3, (1 / THETA) * (1 / THETA) * (1 / THETA))],
)
def test_with_neg_exponent_is_converted_to_repeated_multiplication_of_reciprocals(
self, base, exponent, expected_result
):
assert integer_pow(base, exponent) == expected_result
|
https://github.com/shesha-raghunathan/DATE2019-qiskit-tutorial
|
shesha-raghunathan
|
#Imports
from itertools import product
import matplotlib.pyplot as plt
%matplotlib inline
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, Result
from qiskit import available_backends, get_backend, execute, register, least_busy
from qiskit.tools.visualization import matplotlib_circuit_drawer, qx_color_scheme #require qiskit>0.5.5
%config InlineBackend.figure_format = 'svg'
style = qx_color_scheme()
style['compress'] = True
style['cregbundle'] = True
style['plotbarrier'] = True
circuit_drawer = lambda circuit: matplotlib_circuit_drawer(circuit, style=style)
# Creating registers
qa = QuantumRegister(1, 'alice')
qb = QuantumRegister(1, 'bob')
c = ClassicalRegister(2, 'c')
# Bell Measurement
bell_measurement = QuantumCircuit(qa, qb, c)
bell_measurement.cx(qa, qb)
bell_measurement.h(qa)
bell_measurement.measure(qa[0], c[0])
bell_measurement.measure(qb[0], c[1])
circuit_drawer(bell_measurement)
alice = {}
bob = {}
# eigenvalue
alice['+'] = QuantumCircuit(qa, qb, c) # do nothing
alice['-'] = QuantumCircuit(qa, qb, c)
alice['-'] .x(qa)
bob['+'] = QuantumCircuit(qa, qb, c) # do nothing
bob['-'] = QuantumCircuit(qa, qb, c)
bob['-'].x(qb)
# matrix
alice['Z'] = QuantumCircuit(qa, qb, c) # do nothing
alice['X'] = QuantumCircuit(qa, qb, c)
alice['X'].h(qa)
bob['W'] = QuantumCircuit(qa, qb, c)
bob['W'].h(qb)
bob['W'].t(qb)
bob['W'].h(qb)
bob['W'].s(qb)
bob['V'] = QuantumCircuit(qa, qb, c)
bob['V'].h(qb)
bob['V'].tdg(qb)
bob['V'].h(qb)
bob['V'].s(qb)
qc = alice['+'] + alice['Z'] + bob['+'] + bob['V']
circuit_drawer(qc)
qc = alice['-'] + alice['X'] + bob['+'] + bob['W']
circuit_drawer(qc)
backend = 'local_qasm_simulator'
shots = 1024
circuits = {}
for a_sign, a_basis, b_sign, b_basis in product(['+', '-'], ['Z', 'X'], ['+', '-'], ['V', 'W']):
name = a_sign + a_basis + b_sign + b_basis
circuits[name] = QuantumCircuit(qa, qb, c)
circuits[name] += alice[a_sign]
circuits[name] += alice[a_basis]
circuits[name] += bob[b_sign]
circuits[name] += bob[b_basis]
circuits[name].barrier(qa)
circuits[name].barrier(qb)
circuits[name] += bell_measurement
# Example
print('A quantum circuit of -X+V.')
circuit_drawer(circuits['-X+V'])
job = execute(circuits.values(), backend=backend, shots=shots)
result = job.result()
completely_mixed = {'00': 0, '01': 0, '10': 0, '11': 0}
for a_sign, a_basis, b_sign, b_basis in product(['+', '-'], ['Z', 'X'], ['+', '-'], ['V', 'W']):
name = a_sign + a_basis + b_sign + b_basis
completely_mixed['00'] += result.average_data(circuits[name], {'00': 1})/16
completely_mixed['01'] += result.average_data(circuits[name], {'01': 1})/16
completely_mixed['10'] += result.average_data(circuits[name], {'10': 1})/16
completely_mixed['11'] += result.average_data(circuits[name], {'11': 1})/16
plt.bar(completely_mixed.keys(), completely_mixed.values(), width=0.5)
plt.xlabel('Outcome', fontsize=15)
plt.ylabel('Probability for the completely mixed state', fontsize=10)
plt.axhline(y=0.25, color='red', linewidth=1)
def E(result: Result, observable: dict, a_basis: str, b_basis: str) -> float:
val = 0
str2int = lambda x: 1 if x == '+' else -1
for a_sign, b_sign in product(['+', '-'], ['+', '-']):
name = a_sign + a_basis + b_sign + b_basis
sign = str2int(a_sign) * str2int(b_sign)
val += sign * result.average_data(circuits[name], observable)
return val
def D(result: Result, outcome: str) -> float:
val = 0
for a_basis, b_basis in product(['Z', 'X'], ['V', 'W']):
if outcome[0] == outcome[1] and a_basis == 'X' and b_basis == 'V':
sign = -1
elif outcome[0] != outcome[1] and a_basis == 'X' and b_basis == 'W':
sign = -1
else:
sign = 1
val += sign * E(result, {outcome: 1}, a_basis=a_basis, b_basis=b_basis)
return val
for outcome in ['00', '01', '10', '11']:
if completely_mixed[outcome] <= 1/4: # check the condition
print('D is equal to {} for the outcome {}.'.format(D(result, outcome), outcome))
# Connecting to the IBM Quantum Experience
import sys, getpass
try:
sys.path.append("../../") # go to parent dir
import Qconfig
qx_config = {
"APItoken": Qconfig.APItoken,
"url": Qconfig.config['url']}
print('Qconfig loaded from %s.' % Qconfig.__file__)
except:
APItoken = getpass.getpass('Please input your token and hit enter: ')
qx_config = {
"APItoken": APItoken,
"url":"https://quantumexperience.ng.bluemix.net/api"}
print('Qconfig.py not found in qiskit-tutorial directory; Qconfig loaded using user input.')
register(qx_config['APItoken'], qx_config['url'])
device_shots = 1024
device_name = least_busy(available_backends({'simulator': False, 'local': False}))
device = get_backend(device_name)
device_coupling = device.configuration['coupling_map']
print("the best backend is " + device_name + " with coupling " + str(device_coupling))
job = execute(circuits.values(), backend=device_name, shots=device_shots)
result = job.result()
completely_mixed = {'00': 0, '01': 0, '10': 0, '11': 0}
for a_sign, a_basis, b_sign, b_basis in product(['+', '-'], ['Z', 'X'], ['+', '-'], ['V', 'W']):
name = a_sign + a_basis + b_sign + b_basis
completely_mixed['00'] += result.average_data(circuits[name], {'00': 1})/16
completely_mixed['01'] += result.average_data(circuits[name], {'01': 1})/16
completely_mixed['10'] += result.average_data(circuits[name], {'10': 1})/16
completely_mixed['11'] += result.average_data(circuits[name], {'11': 1})/16
plt.bar(completely_mixed.keys(), completely_mixed.values(), width=0.5)
plt.xlabel('Outcome', fontsize=15)
plt.ylabel('Probability for the completely mixed state', fontsize=10)
plt.axhline(y=0.25, color='red', linewidth=1)
for outcome in ['00', '01', '10', '11']:
if completely_mixed[outcome] <= 1/4: # check the condition
print('D is equal to {} for the outcome {}.'.format(D(result, outcome), outcome))
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
top = QuantumCircuit(1)
top.x(0);
bottom = QuantumCircuit(2)
bottom.cry(0.2, 0, 1);
tensored = bottom.tensor(top)
tensored.draw('mpl')
|
https://github.com/quantum-tokyo/qiskit-handson
|
quantum-tokyo
|
# Qiskitライブラリーを導入
from qiskit import *
# 描画のためのライブラリーを導入
import matplotlib.pyplot as plt
%matplotlib inline
# Qiskitバージョンの確認
qiskit.__qiskit_version__
# 2量子ビット回路を用意
q = QuantumCircuit(2,2) # ２量子ビット回路と２ビットの古典レジスターを用意します。
# 回路を描画
q.draw(output="mpl")
# 量子ゲートで回路を作成
q.h(0) # Hゲートを量子ビットq0に実行します。
q.h(1) # Hゲートを量子ビットq1に実行します。
# q.h([0,1]) # またはこのように書くこともできます。
# 回路を描画
q.draw(output="mpl")
# 状態ベクトルシミュレーターの実行
vector_sim = Aer.get_backend('statevector_simulator')
job = execute(q, vector_sim )
result = job.result().get_statevector(q, decimals=3)
print(result)
# 回路を測定
q.measure(0,0)
q.measure(1,1)
# 回路を描画
q.draw(output='mpl')
# QASMシミュレーターで実験
simulator = Aer.get_backend('qasm_simulator')
job = execute(q, backend=simulator, shots=1024)
result = job.result()
# 測定された回数を表示
counts = result.get_counts(q)
print(counts)
## ヒストグラムで測定された確率をプロット
from qiskit.visualization import *
plot_histogram( counts )
|
https://github.com/Spintronic6889/Introduction-of-Quantum-walk-its-application-on-search-and-decision-making
|
Spintronic6889
|
!python --version
!pip install qiskit
!pip install pylatexenc
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer
from qiskit.visualization import plot_histogram
from qiskit.visualization import plot_state_city
import matplotlib.pyplot as plt
%matplotlib inline
import matplotlib as mpl
from random import randrange
import numpy as np
import networkx as nx
import random
import math
from qiskit.tools.monitor import job_monitor
from random import randrange
pose=[]
for i in range(400):
pose.append([])
#print(pose)
#pose[-1]=1
#print(pose[-1])
pose[0]=200
for k in range(200):
rand = randrange(0,2)
if rand==0:
#print(rand)
pose[k+1]=pose[k]+1
if rand==1:
pose[k+1]=pose[k]-1
#print(pose)
yc=[]
for e in range(400):
yc.append([])
for q in range(400):
yc[q]=0
for h in range(400):
if pose[h]==q:
yc[q]=yc[q]+1
#print((yc))
#print(len(yc))
xc = np.arange(0, 400, 1)
plt.plot(yc)
plt.xlim(150, 250)
#discrete time quantum random walk with a hadamard coin
n=2
steps=1
qpos = QuantumRegister(n,'qpos')
qcoin = QuantumRegister(1,'qcoin')
cpos = ClassicalRegister(n,'cr')
QC = QuantumCircuit(qpos, qcoin)
#initialized
#QC.x(qcoin[0])
for i in range(steps):
#coin
QC.h(qcoin[0])
QC.barrier()
#increment gate operator
for i in range(n):
QC.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
QC.barrier()
#decrement gate operator
QC.x(qcoin[0])
for i in range(n):
if i+1 < n: QC.x(qpos[i+1:])
QC.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
if i+1 < n: QC.x(qpos[i+1:])
QC.barrier()
a=n/2
p=math.floor(a)
#print(p)
for k in range(n):
if(k<p):
QC.swap(qpos[n-1-k],qpos[k])
#print(a)
display(QC.draw(output="mpl"))
QC.measure_all()
# # Execute the circuit on the qasm simulator
job = execute(QC,Aer.get_backend('aer_simulator'),shots=10000)
counts = job.result().get_counts(QC)
print(counts)
plot_histogram(counts, color='midnightblue', title="New Histogram")
#aer_sim = Aer.get_backend('aer_simulator')
#qobj = assemble(had)
#result = aer_sim.run(qobj).result()
#counts = result.get_counts()
#plot_histogram(counts)
#discrete time quantum random walk with a hadamard coin
n=2
steps=2
qpos = QuantumRegister(n,'qpos')
qcoin = QuantumRegister(1,'qcoin')
cpos = ClassicalRegister(n,'cr')
QC = QuantumCircuit(qpos, qcoin)
#initialized
#QC.x(qcoin[0])
for i in range(steps):
#coin
QC.h(qcoin[0])
QC.barrier()
#increment gate operator
for i in range(n):
QC.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
QC.barrier()
#decrement gate operator
QC.x(qcoin[0])
for i in range(n):
if i+1 < n: QC.x(qpos[i+1:])
QC.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
if i+1 < n: QC.x(qpos[i+1:])
QC.barrier()
a=n/2
p=math.floor(a)
#print(p)
for k in range(n):
if(k<p):
QC.swap(qpos[n-1-k],qpos[k])
#print(a)
display(QC.draw(output="mpl"))
QC.measure_all()
# # Execute the circuit on the qasm simulator
job = execute(QC,Aer.get_backend('aer_simulator'),shots=10000)
counts = job.result().get_counts(QC)
print(counts)
plot_histogram(counts, color='midnightblue', title="New Histogram")
#aer_sim = Aer.get_backend('aer_simulator')
#qobj = assemble(had)
#result = aer_sim.run(qobj).result()
#counts = result.get_counts()
#plot_histogram(counts)
#discrete time quantum random walk with a hadamard coin
n=2
steps=3
qpos = QuantumRegister(n,'qpos')
qcoin = QuantumRegister(1,'qcoin')
cpos = ClassicalRegister(n,'cr')
QC = QuantumCircuit(qpos, qcoin)
#initialized
#QC.x(qcoin[0])
for i in range(steps):
#coin
QC.h(qcoin[0])
QC.barrier()
#increment gate operator
for i in range(n):
QC.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
QC.barrier()
#decrement gate operator
QC.x(qcoin[0])
for i in range(n):
if i+1 < n: QC.x(qpos[i+1:])
QC.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
if i+1 < n: QC.x(qpos[i+1:])
QC.barrier()
a=n/2
p=math.floor(a)
#print(p)
for k in range(n):
if(k<p):
QC.swap(qpos[n-1-k],qpos[k])
#print(a)
display(QC.draw(output="mpl"))
QC.measure_all()
# # Execute the circuit on the qasm simulator
job = execute(QC,Aer.get_backend('aer_simulator'),shots=10000)
counts = job.result().get_counts(QC)
print(counts)
plot_histogram(counts, color='midnightblue', title="New Histogram")
#aer_sim = Aer.get_backend('aer_simulator')
#qobj = assemble(had)
#result = aer_sim.run(qobj).result()
#counts = result.get_counts()
#plot_histogram(counts)
from qiskit.quantum_info import DensityMatrix
from qiskit.visualization import plot_state_city
#discrete time quantum random walk with a hadamard coin
n=3
steps=11
qpos = QuantumRegister(n,'qpos')
qcoin = QuantumRegister(1,'qcoin')
cpos = ClassicalRegister(n,'cr')
QC = QuantumCircuit(qpos, qcoin)
#initialized
#QC.x(qcoin[0])
for i in range(steps):
#coin
QC.h(qcoin[0])
QC.barrier()
#increment gate operator
for i in range(n):
QC.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
QC.barrier()
#decrement gate operator
QC.x(qcoin[0])
for i in range(n):
if i+1 < n: QC.x(qpos[i+1:])
QC.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
if i+1 < n: QC.x(qpos[i+1:])
QC.barrier()
a=n/2
p=math.floor(a)
#print(p)
for k in range(n):
if(k<p):
QC.swap(qpos[n-1-k],qpos[k])
#print(a)
display(QC.draw(output="mpl"))
state = DensityMatrix.from_instruction(QC)
plot_state_city(state,figsize=(15, 8), color=['midnightblue', 'midnightblue'],
title="New State City")
QC.measure_all()
# # Execute the circuit on the qasm simulator
job = execute(QC,Aer.get_backend('aer_simulator'),shots=10000)
counts = job.result().get_counts(QC)
print(counts)
plot_histogram(counts, figsize=(10, 2), color='midnightblue', title="New Histogram")
#aer_sim = Aer.get_backend('aer_simulator')
#qobj = assemble(had)
#result = aer_sim.run(qobj).result()
#counts = result.get_counts()
#plot_histogram(counts)
# Import Aer
from qiskit import Aer
# Run the quantum circuit on a statevector simulator backend
backend = Aer.get_backend('statevector_simulator')
# Create a Quantum Program for execution
job = execute(QC, backend)
result = job.result()
outputstate = result.get_statevector(QC, decimals=3)
print(outputstate)
#discrete time quantum random walk with a hadamard coin
n=6
steps=11
qpos = QuantumRegister(n,'qpos')
qcoin = QuantumRegister(1,'qcoin')
cpos = ClassicalRegister(n,'cr')
QC = QuantumCircuit(qpos, qcoin)
#initialized coin |0>
#QC.x(qcoin[0])
for i in range(steps):
#coin
QC.h(qcoin[0])
QC.barrier()
#increment gate operator
for i in range(n):
QC.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
QC.barrier()
#decrement gate operator
QC.x(qcoin[0])
for i in range(n):
if i+1 < n: QC.x(qpos[i+1:])
QC.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
if i+1 < n: QC.x(qpos[i+1:])
QC.barrier()
a=n/2
p=math.floor(a)
#print(p)
for k in range(n):
if(k<p):
QC.swap(qpos[n-1-k],qpos[k])
QC.measure_all()
# # Execute the circuit on the qasm simulator
job = execute(QC,Aer.get_backend('aer_simulator'),shots=10000)
counts = job.result().get_counts(QC)
print(counts)
plot_histogram(counts, figsize=(10, 2), color='midnightblue', title="New Histogram")
#aer_sim = Aer.get_backend('aer_simulator')
#qobj = assemble(had)
#result = aer_sim.run(qobj).result()
#counts = result.get_counts()
#plot_histogram(counts)
#discrete time quantum random walk with a hadamard coin
n=6
steps=11
qpos = QuantumRegister(n,'qpos')
qcoin = QuantumRegister(1,'qcoin')
cpos = ClassicalRegister(n,'cr')
QC = QuantumCircuit(qpos, qcoin)
#initialized coin |1>
QC.x(qcoin[0])
for i in range(steps):
#coin
QC.h(qcoin[0])
QC.barrier()
#increment gate operator
for i in range(n):
QC.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
QC.barrier()
#decrement gate operator
QC.x(qcoin[0])
for i in range(n):
if i+1 < n: QC.x(qpos[i+1:])
QC.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
if i+1 < n: QC.x(qpos[i+1:])
QC.barrier()
a=n/2
p=math.floor(a)
#print(p)
for k in range(n):
if(k<p):
QC.swap(qpos[n-1-k],qpos[k])
QC.measure_all()
# # Execute the circuit on the qasm simulator
job = execute(QC,Aer.get_backend('aer_simulator'),shots=10000)
counts = job.result().get_counts(QC)
print(counts)
plot_histogram(counts, figsize=(10, 2), color='midnightblue', title="New Histogram")
#aer_sim = Aer.get_backend('aer_simulator')
#qobj = assemble(had)
#result = aer_sim.run(qobj).result()
#counts = result.get_counts()
#plot_histogram(counts)
from qiskit import *
%matplotlib inline
#discrete time quantum random walk with a hadamard coin
n=6
steps=11
qpos = QuantumRegister(n,'qpos')
qcoin = QuantumRegister(1,'qcoin')
cpos = ClassicalRegister(n,'cr')
QC = QuantumCircuit(qpos, qcoin)
pi=math.pi
#initialized coin Ugate
QC.u(pi/2, 3*pi/2, 0, qcoin[0])
for i in range(steps):
#coin
QC.h(qcoin[0])
QC.barrier()
#increment gate operator
for i in range(n):
QC.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
QC.barrier()
#decrement gate operator
QC.x(qcoin[0])
for i in range(n):
if i+1 < n: QC.x(qpos[i+1:])
QC.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
if i+1 < n: QC.x(qpos[i+1:])
QC.barrier()
a=n/2
p=math.floor(a)
#print(p)
for k in range(n):
if(k<p):
QC.swap(qpos[n-1-k],qpos[k])
QC.measure_all()
# # Execute the circuit on the qasm simulator
job = execute(QC,Aer.get_backend('aer_simulator'),shots=10000)
counts = job.result().get_counts(QC)
print(counts)
plot_histogram(counts, figsize=(10, 2), color='midnightblue', title="New Histogram")
#aer_sim = Aer.get_backend('aer_simulator')
#qobj = assemble(had)
#result = aer_sim.run(qobj).result()
#counts = result.get_counts()
#plot_histogram(counts)
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer,assemble, transpile
from qiskit import BasicAer
from random import randrange
from qiskit.tools.visualization import plot_histogram, plot_state_city
import numpy as np
from qiskit.quantum_info.operators import Operator, Pauli
from qiskit.quantum_info import Operator, Statevector
q = QuantumRegister(6) # "Qubits q[0] and q[1] for coin 1 and 2", "q[2] and q[3] for player 1" and q[4] and q[5] for player 2"
c = ClassicalRegister(6)
Q = QuantumCircuit(q,c)
#Coin Operators
# Apply u gate as Hadamard gate to each coin
Q.u(np.pi/2,0,np.pi,q[0])
Q.u(np.pi/2,0,np.pi,q[1])
#S operator
Q.x(q[0])
Q.x(q[1])
Q.mct([q[0],q[1]],q[3])
Q.mct([q[0],q[1]],q[5])
Q.x(q[0])
Q.x(q[1])
Q.barrier()
Q.x(q[0])
Q.mct([q[0],q[1]],q[2])
Q.mct([q[0],q[1]],q[3])
Q.x(q[0])
Q.barrier()
Q.x(q[1])
Q.mct([q[0],q[1]],q[4])
Q.mct([q[0],q[1]],q[5])
Q.x(q[1])
Q.barrier()
Q.mct([q[0],q[1]],q[2])
Q.mct([q[0],q[1]],q[4])
Q.measure_all()
Q.draw(output='mpl')
# Execute the circuit on the qasm simulator
# Use Aer's qasm_simulator
backend_sim = Aer.get_backend('qasm_simulator')
# Execute the circuit on the qasm simulator.
# We've set the number of repeats of the circuit
# to be 1024, which is the default.
job_sim = execute(Q, backend_sim, shots=1000)
# Grab the results from the job.
result_sim = job_sim.result()
counts = result_sim.get_counts(Q)
print(counts)
plot_histogram(counts, color='midnightblue', title="Decision Histogram")
q_o = QuantumRegister(6) # "Qubits q[0] and q[1] for coin 1 and 2", "q[2] and q[3] for player 1" and q[4] and q[5] for player 2"
c_o = ClassicalRegister(6)
Q_o = QuantumCircuit(q,c)
#Coin Operators
# Apply u gate as Hadamard gate to each coin
Q_o.u(2*np.pi/3,0,np.pi,q[0])
Q_o.u(np.pi/2,0,np.pi,q[1])
#S operator
Q_o.x(q[0])
Q_o.x(q[1])
Q_o.mct([q[0],q[1]],q[3])
Q_o.mct([q[0],q[1]],q[5])
Q_o.x(q[0])
Q_o.x(q[1])
Q_o.barrier()
Q_o.x(q[0])
Q_o.mct([q[0],q[1]],q[2])
Q_o.mct([q[0],q[1]],q[3])
Q_o.x(q[0])
Q_o.barrier()
Q_o.x(q[1])
Q_o.mct([q[0],q[1]],q[4])
Q_o.mct([q[0],q[1]],q[5])
Q_o.x(q[1])
Q_o.barrier()
Q_o.mct([q[0],q[1]],q[2])
Q_o.mct([q[0],q[1]],q[4])
Q_o.measure_all()
# Execute the circuit on the qasm simulator
# Use Aer's qasm_simulator
backend_sim_o = Aer.get_backend('qasm_simulator')
# Execute the circuit on the qasm simulator.
# We've set the number of repeats of the circuit
# to be 1024, which is the default.
job_sim_o = execute(Q_o, backend_sim, shots=1000)
# Grab the results from the job.
result_sim_o = job_sim_o.result()
counts_o = result_sim_o.get_counts(Q_o)
print(counts_o)
plot_histogram(counts_o, color='midnightblue', title="Decision Histogram")
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
qc = QuantumCircuit(1, 1)
qc.h(0)
qc.measure(0,0)
qc.x(0).c_if(0, 0)
qc.draw(output='mpl')
from qiskit import QuantumRegister, ClassicalRegister
q = QuantumRegister(3, 'q')
c = ClassicalRegister(3, 'c')
qc = QuantumCircuit(q, c)
qc.h([0, 1, 2])
qc.barrier()
qc.measure(q, c)
qc.draw('mpl')
print(bin(3))
print(bin(7))
qc.x(2).c_if(c, 3) # for the 011 case
qc.x(2).c_if(c, 7) # for the 111 case
qc.draw(output='mpl')
nq = 2
m = 2
q = QuantumRegister(nq, 'q')
c = ClassicalRegister(m, 'c')
qc_S = QuantumCircuit(q,c)
qc_S.h(0)
qc_S.x(1)
qc_S.draw('mpl')
from math import pi
cu_circ = QuantumCircuit(2)
cu_circ.cp(pi/2, 0, 1)
cu_circ.draw('mpl')
for _ in range(2 ** (m - 1)):
qc_S.cp(pi/2, 0, 1)
qc_S.draw('mpl')
def x_measurement(qc, qubit, cbit):
"""Measure 'qubit' in the X-basis, and store the result in 'cbit'"""
qc.h(qubit)
qc.measure(qubit, cbit)
x_measurement(qc_S, q[0], c[0])
qc_S.draw('mpl')
qc_S.reset(0)
qc_S.h(0)
qc_S.draw('mpl')
qc_S.p(-pi/2, 0).c_if(c, 1)
qc_S.draw('mpl')
## 2^t c-U operations (with t=m-2)
for _ in range(2 ** (m - 2)):
qc_S.cp(pi/2, 0, 1)
x_measurement(qc_S, q[0], c[1])
qc_S.draw('mpl')
import matplotlib.pyplot as plt
from qiskit.tools.visualization import plot_histogram
from qiskit_aer.primitives import Sampler
sampler = Sampler()
job = sampler.run(qc_S)
result = job.result()
dist0 = result.quasi_dists[0]
key_new = [str(key/2**m) for key in list(dist0.keys())]
dist1 = dict(zip(key_new, dist0.values()))
fig, ax = plt.subplots(1,2)
plot_histogram(dist0, ax=ax[0])
plot_histogram(dist1, ax=ax[1])
plt.tight_layout()
nq = 3 # number of qubits
m = 3 # number of classical bits
q = QuantumRegister(nq,'q')
c = ClassicalRegister(m,'c')
qc = QuantumCircuit(q,c)
qc.h(0)
qc.x([1, 2])
qc.draw('mpl')
cu_circ = QuantumCircuit(nq)
cu_circ.mcp(pi/4, [0, 1], 2)
cu_circ.draw('mpl')
for _ in range(2 ** (m - 1)):
qc.mcp(pi/4, [0, 1], 2)
qc.draw('mpl')
x_measurement(qc, q[0], c[0])
qc.draw('mpl')
qc.reset(0)
qc.h(0)
qc.draw('mpl')
qc.p(-pi/2, 0).c_if(c, 1)
qc.draw('mpl')
for _ in range(2 ** (m - 2)):
qc.mcp(pi/4, [0, 1], 2)
x_measurement(qc, q[0], c[1])
qc.draw('mpl')
# initialization of qubit q0
qc.reset(0)
qc.h(0)
# phase correction
qc.p(-pi/4, 0).c_if(c, 1)
qc.p(-pi/2, 0).c_if(c, 2)
qc.p(-3*pi/2, 0).c_if(c, 3)
# c-U operations
for _ in range(2 ** (m - 3)):
qc.mcp(pi/4, [0, 1], 2)
# X measurement
qc.h(0)
qc.measure(0, 2)
qc.draw('mpl')
result = sampler.run(qc).result()
dist0 = result.quasi_dists[0]
key_new = [str(key/2**m) for key in list(dist0.keys())]
dist1 = dict(zip(key_new, dist0.values()))
fig, ax = plt.subplots(1,2)
plot_histogram(dist0, ax=ax[0])
plot_histogram(dist1, ax=ax[1])
plt.tight_layout()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/primaryobjects/oracle
|
primaryobjects
|
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates.z import ZGate
def oracle(logic, n):
'''
Returns a quantum circuit that recognizes odd numbers. We do this by checking if qubit 0 equals 1 (odd).
Upon starting, all qubits are assumed to have a value of 1. We only need to consider qubit 0, the other qubits may be ignored.
Parameters:
logic: not used (should be None).
n: the number of qubits in the circuit.
'''
# We use a circuit of size n+1 to include an output qubit.
qc = QuantumCircuit(n+1)
# Apply a controlled Z-gate from qubit 0 to each of the other qubits. When qubit 0 is 1, the others are flipped, setting the phase.
qc.append(ZGate().control(1), [0,range(1,n+1)])
# qc.append(ZGate().control(1), [0,1])
# qc.append(ZGate().control(1), [0,2])
# qc.append(ZGate().control(1), [0,3])
print(qc.draw())
# Convert the oracle to a gate.
gate = qc.to_gate()
gate.name = "oracle"
return gate
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
from qiskit.quantum_info import Clifford, random_clifford
qc = QuantumCircuit(3)
cliff = random_clifford(2)
qc.append(cliff, [0, 1])
qc.ccx(0, 1, 2)
qc.draw('mpl')
|
https://github.com/Tojarieh97/VQE
|
Tojarieh97
|
from qiskit.opflow import X, Z, I
H2_op = (-1.052373245772859 * I ^ I) + \
(0.39793742484318045 * I ^ Z) + \
(-0.39793742484318045 * Z ^ I) + \
(-0.01128010425623538 * Z ^ Z) + \
(0.18093119978423156 * X ^ X)
import numpy as np
from qiskit.opflow import X, Z, I
N = 2
H = 0*X
for i in range(1,N+1):
a_i = np.random.random_sample()
for j in range(1,i+1):
J_ij = np.random.random_sample()
H += J_ij*Z*Z
H += a_i*X
print(H)
import numpy as np
from qiskit.opflow import X, Z, I
N = 2
a_1 = np.random.random_sample()
a_2 = np.random.random_sample()
J_21 = np.random.random_sample()
H = a_1*(I^X) + a_2*(X^I) + J_21*(Z^Z)
print(H.to_matrix())
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute, assemble, Aer
from qiskit.tools.visualization import plot_histogram
from math import pi
import matplotlib.pyplot as plt
q = QuantumRegister(1,'q')
c = ClassicalRegister(1,'c')
qc = QuantumCircuit(q, c)
qc.h(0)
qc.measure(0,0)
qc.x(0).c_if(c, 0)
qc.draw(output='mpl')
q = QuantumRegister(3,'q')
c = ClassicalRegister(3,'c')
qc = QuantumCircuit(q, c)
qc.h(q[0])
qc.h(q[1])
qc.h(q[2])
qc.barrier()
qc.measure(q,c)
qc.draw('mpl')
print(bin(3))
print(bin(7))
q = QuantumRegister(3,'q')
c = ClassicalRegister(3,'c')
qc = QuantumCircuit(q, c)
qc.h(0)
qc.h(1)
qc.h(2)
qc.barrier()
qc.measure(q,c)
qc.x(2).c_if(c, 3) # for the 011 case
qc.x(2).c_if(c, 7) # for the 111 case
qc.draw(output='mpl')
nq = 2
m = 2
q = QuantumRegister(nq,'q')
c = ClassicalRegister(m,'c')
qc_S = QuantumCircuit(q,c)
qc_S.h(0)
qc_S.x(1)
qc_S.draw('mpl')
cu_circ = QuantumCircuit(2)
cu_circ.cp(pi/2,0,1)
cu_circ.draw('mpl')
for _ in range(2**(m-1)):
qc_S.cp(pi/2,0,1)
qc_S.draw('mpl')
def x_measurement(qc, qubit, cbit):
"""Measure 'qubit' in the X-basis, and store the result in 'cbit'"""
qc.h(qubit)
qc.measure(qubit, cbit)
x_measurement(qc_S, q[0], c[0])
qc_S.draw('mpl')
qc_S.reset(0)
qc_S.h(0)
qc_S.draw('mpl')
qc_S.p(-pi/2,0).c_if(c,1)
qc_S.draw('mpl')
## 2^t c-U operations (with t=m-2)
for _ in range(2**(m-2)):
qc_S.cp(pi/2,0,1)
x_measurement(qc_S, q[0], c[1])
qc_S.draw('mpl')
sim = Aer.get_backend('qasm_simulator')
count0 = execute(qc_S, sim).result().get_counts()
key_new = [str(int(key,2)/2**m) for key in list(count0.keys())]
count1 = dict(zip(key_new, count0.values()))
fig, ax = plt.subplots(1,2)
plot_histogram(count0, ax=ax[0])
plot_histogram(count1, ax=ax[1])
plt.tight_layout()
nq = 3 # number of qubits
m = 3 # number of classical bits
q = QuantumRegister(nq,'q')
c = ClassicalRegister(m,'c')
qc = QuantumCircuit(q,c)
qc.h(0)
qc.x([1,2])
qc.draw('mpl')
cu_circ = QuantumCircuit(nq)
cu_circ.mcp(pi/4,[0,1],2)
cu_circ.draw('mpl')
for _ in range(2**(m-1)):
qc.mcp(pi/4,[0,1],2)
qc.draw('mpl')
x_measurement(qc, q[0], c[0])
qc.draw('mpl')
qc.reset(0)
qc.h(0)
qc.draw('mpl')
qc.p(-pi/2,0).c_if(c,1)
qc.draw('mpl')
for _ in range(2**(m-2)):
qc.mcp(pi/4,[0,1],2)
x_measurement(qc, q[0], c[1])
qc.draw('mpl')
# initialization of qubit q0
qc.reset(0)
qc.h(0)
# phase correction
qc.p(-pi/4,0).c_if(c,1)
qc.p(-pi/2,0).c_if(c,2)
qc.p(-3*pi/4,0).c_if(c,3)
# c-U operations
for _ in range(2**(m-3)):
qc.mcp(pi/4,[0,1],2)
# X measurement
qc.h(0)
qc.measure(0,2)
qc.draw('mpl')
count0 = execute(qc, sim).result().get_counts()
key_new = [str(int(key,2)/2**m) for key in list(count0.keys())]
count1 = dict(zip(key_new, count0.values()))
fig, ax = plt.subplots(1,2)
plot_histogram(count0, ax=ax[0])
plot_histogram(count1, ax=ax[1])
fig.tight_layout()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
import cirq
import random
import matplotlib.pyplot as plt
import numpy as np
def set_measure_x(circuit, qubits, n):
for num in range(n):
circuit.append(cirq.H(qubits[num]))
def set_measure_y(circuit, qubits, n):
for num in range(n):
circuit.append((cirq.Z**(-1/2))(qubits[num]))
circuit.append(cirq.H(qubits[num]))
def qft_rotations_cirq(circuit, qubits, n):
if n == 0:
#print(circuit)
set_measure_x(circuit, qubits, 4)
circuit.append(cirq.measure(*qubits, key='this'))
return circuit
n -= 1
circuit.append(cirq.H(qubits[n]))
for qubit in range(n):
circuit.append((cirq.CZ**(1/2**(n-qubit)))(qubits[qubit],qubits[n]))
return qft_rotations_cirq(circuit, qubits, n)
qubits = cirq.LineQubit.range(4)
circuit = cirq.Circuit()
circuit.append(cirq.X(qubits[0]))
qft_rotations_cirq(circuit, qubits, 4)
##set it to measure Y axis
#set_measure_x(circuit, qubits, 4)
#circuit.append(cirq.measure(*qubits, key='this'))
simulator = cirq.Simulator()
results = simulator.run(circuit , repetitions =100000)
#results = simulator.run(circuit)
print(circuit)
print(results.histogram(key="this"))
def qft_rotations_cirq(circuit, qubits, n):
#this implementation is taken from https://qiskit.org/textbook/ch-algorithms/quantum-fourier-transform.html
#if qubit amount is 0, then do nothing and return
#print("loop n# %s"%n)
if n == 0:
#print(circuit)
return circuit
n -= 1
circuit.append(cirq.H(qubits[n]))
for qubit in range(n):
circuit.append((cirq.CZ**(1/2**(n-qubit)))(qubits[qubit],qubits[n]))
#print(n)
#print(qubit)
return qft_rotations_cirq(circuit, qubits, n)
qubits = cirq.LineQubit.range(4)
circuit = cirq.Circuit()
circuit.append(cirq.X(qubits[0]))
qft_rotations_cirq(circuit, qubits, 4)
##set it to measure Y axis
set_measure_x(circuit, qubits, 4)
##measure the first qubit ---------V
circuit.append(cirq.measure(qubits[0], key='this'))
simulator = cirq.Simulator()
results = simulator.run(circuit , repetitions =1000000)
#results = simulator.run(circuit)
print(circuit)
print(results.histogram(key="this"))
|
https://github.com/carstenblank/dc-qiskit-qml
|
carstenblank
|
import qiskit
from qiskit_aer.backends.aerbackend import AerBackend
from dc_qiskit_qml.encoding_maps import NormedAmplitudeEncoding
from dc_qiskit_qml.distance_based.hadamard import QmlHadamardNeighborClassifier
from dc_qiskit_qml.distance_based.hadamard.state import QmlGenericStateCircuitBuilder
from dc_qiskit_qml.distance_based.hadamard.state.sparsevector import MottonenStatePreparation
initial_state_builder = QmlGenericStateCircuitBuilder(MottonenStatePreparation())
encoding_map = NormedAmplitudeEncoding()
execution_backend: AerBackend = qiskit.Aer.get_backend('qasm_simulator')
qml = QmlHadamardNeighborClassifier(backend=execution_backend,
shots=8192,
classifier_circuit_factory=initial_state_builder,
encoding_map=encoding_map)
from sklearn.datasets import load_iris
import numpy as np
import matplotlib.pyplot as plt
X, y = load_iris(return_X_y=True)
X = np.asarray([x[0:2] for x, yy in zip(X, y) if yy != 2])
y = np.asarray([yy for x, yy in zip(X, y) if yy != 2])
figure = plt.figure(figsize=(5,3.5), num=2)
sub1 = figure.subplots(nrows=1, ncols=1)
class_0_data = np.asarray([X[i] for i in range(len(X)) if y[i] == 0])
class_1_data = np.asarray([X[i] for i in range(len(X)) if y[i] == 1])
class_0 = sub1.scatter(class_0_data[:,0], class_0_data[:,1], color='red', marker='x', s=50)
class_1 = sub1.scatter(class_1_data[:,0], class_1_data[:,1], color='blue', marker='x', s=50)
sub1.plot([np.cos(x) for x in np.arange(0, 2*np.pi + 0.1, 0.1)], [np.sin(x) for x in np.arange(0, 2*np.pi + 0.1, 0.1)],
color='black', linewidth=1)
sub1.set_title("Iris Data")
sub1.legend([class_0, class_1], ["Class 1", "Class 2"])
sub1.axvline(color='gray')
sub1.axhline(color='gray')
from sklearn.preprocessing import StandardScaler, Normalizer
from sklearn.pipeline import Pipeline
pipeline = Pipeline([
('scaler', StandardScaler()),
('l2norm', Normalizer(norm='l2', copy=True)),
('qml', qml)
])
_X = pipeline.fit_transform(X, y)
figure = plt.figure(figsize=(5,5), num=2)
sub1 = figure.subplots(nrows=1, ncols=1)
class_0_data = np.asarray([_X[i] for i in range(len(X)) if y[i] == 0])
class_1_data = np.asarray([_X[i] for i in range(len(X)) if y[i] == 1])
class_0 = sub1.scatter(class_0_data[:,0], class_0_data[:,1], color='red', marker='x', s=50)
class_1 = sub1.scatter(class_1_data[:,0], class_1_data[:,1], color='blue', marker='x', s=50)
sub1.plot([np.cos(x) for x in np.arange(0, 2*np.pi, 0.1)], [np.sin(x) for x in np.arange(0, 2*np.pi, 0.1)],
color='black', linewidth=1)
sub1.set_title("Iris Data")
sub1.legend([class_0, class_1], ["Class 1", "Class 2"])
sub1.axvline(color='gray')
sub1.axhline(color='gray')
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.10, random_state=42)
_X_train = pipeline.fit_transform(X_train, y_train)
_X_test = pipeline.transform(X_test)
figure = plt.figure(figsize=(10,4.5), num=2)
sub1, sub2 = figure.subplots(nrows=1, ncols=2)
class_0_data = np.asarray([_X_train[i] for i in range(len(X_train)) if y_train[i] == 0])
class_1_data = np.asarray([_X_train[i] for i in range(len(X_train)) if y_train[i] == 1])
class_0 = sub1.scatter(class_0_data[:,0], class_0_data[:,1], color='red', marker='x', s=50)
class_1 = sub1.scatter(class_1_data[:,0], class_1_data[:,1], color='blue', marker='x', s=50)
sub1.plot([np.cos(x) for x in np.arange(0, 2*np.pi, 0.1)], [np.sin(x) for x in np.arange(0, 2*np.pi, 0.1)],
color='black', linewidth=1)
sub1.set_title("Training data")
sub1.legend([class_0, class_1], ["Class 1", "Class 2"])
sub1.axvline(color='gray')
sub1.axhline(color='gray')
class_0_data_test = np.asarray([_X_test[i] for i in range(len(X_test)) if y_test[i] == 0])
class_1_data_test = np.asarray([_X_test[i] for i in range(len(X_test)) if y_test[i] == 1])
class_0 = sub2.scatter(class_0_data_test[:,0], class_0_data_test[:,1], color='red', marker='x', s=50)
class_1 = sub2.scatter(class_1_data_test[:,0], class_1_data_test[:,1], color='blue', marker='x', s=50)
sub2.plot([np.cos(x) for x in np.arange(0, 2*np.pi, 0.1)], [np.sin(x) for x in np.arange(0, 2*np.pi, 0.1)],
color='black', linewidth=1)
sub2.set_title("Testing data")
sub2.legend([class_0, class_1], ["Class 1", "Class 2"])
sub2.axvline(color='gray')
sub2.axhline(color='gray')
len(X_train), np.ceil(np.log2(len(X_train)))
pipeline.fit(X_train, y_train)
prediction = pipeline.predict(X_test)
list(zip(prediction, y_test))
"Test Accuracy: {}".format(
sum([1 if p == t else 0 for p, t in zip(prediction, y_test)])/len(prediction)
)
prediction_train = pipeline.predict(X_train)
"Train Accuracy: {}".format(
sum([1 if p == t else 0 for p, t in zip(prediction_train, y_train)])/len(prediction_train)
)
list(zip(prediction_train, y_train))
for i in range(len(X_test)):
acc = QmlHadamardNeighborClassifier.p_acc_theory(X_train, y_train, X_test[i])
print(f"{qml.last_predict_p_acc[i]:.4f} ~~ {acc:.4f}")
for i in range(len(X_test)):
label = QmlHadamardNeighborClassifier.p_label_theory(X_train, y_train, X_test[i], prediction[i])
print(f"{qml.last_predict_probability[i]:.4f} ~~ {label:.4f}")
|
https://github.com/shesha-raghunathan/DATE2019-qiskit-tutorial
|
shesha-raghunathan
|
# first we import a procedure for picking a random number
from random import randrange
# randrange(m) returns a number randomly from the list {0,1,...,m-1}
# randrange(10) returns a number randomly from the list {0,1,...,9}
# here is an example
r=randrange(5)
print("I picked a random number between 0 and 4, which is ",r)
#
# your solution is here
#
# first we import a procedure for picking a random number
from random import randrange
#
# your solution is here
#
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import numpy as np
from qiskit import pulse
d0 = pulse.DriveChannel(0)
x90 = pulse.Gaussian(10, 0.1, 3)
x180 = pulse.Gaussian(10, 0.2, 3)
def udd10_pos(j):
return np.sin(np.pi*j/(2*10 + 2))**2
with pulse.build() as udd_sched:
pulse.play(x90, d0)
with pulse.align_func(duration=300, func=udd10_pos):
for _ in range(10):
pulse.play(x180, d0)
pulse.play(x90, d0)
udd_sched.draw()
|
https://github.com/ronitd2002/IBM-Quantum-challenge-2024
|
ronitd2002
|
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
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 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 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.x(0)
qc.h(0)
return qc
state = Statevector.from_instruction(lab1_ex3())
plot_bloch_multivector(state)
from qc_grader 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 import grade_lab1_ex4
# Note that the grading function is expecting a quantum circuit without measurements
grade_lab1_ex4(lab1_ex4())
def lab1_ex5():
qc = QuantumCircuit(2,2) # this time, we not only want two qubits, but also two classical bits for the measurement
#
#
# FILL YOUR CODE IN HERE
#
#
qc.h(0)
qc.cx(0,1)
qc.x(0)
return qc
qc = lab1_ex5()
qc.draw() # we draw the circuit
from qc_grader import grade_lab1_ex5
# Note that the grading function is expecting a quantum circuit without measurements
grade_lab1_ex5(lab1_ex5())
qc.measure(0, 0) # we perform a measurement on qubit q_0 and store the information on the classical bit c_0
qc.measure(1, 1) # we perform a measurement on qubit q_1 and store the information on the classical bit c_1
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():
#
#
# FILL YOUR CODE IN HERE
#
#
qc = QuantumCircuit(3,3)
qc.h(0)
qc.cx(0,1)
qc.cx(1,2)
qc.y(1)
return qc
qc = lab1_ex6()
qc.draw() # we draw the circuit
from qc_grader import grade_lab1_ex6
# Note that the grading function is expecting a quantum circuit without measurements
grade_lab1_ex6(lab1_ex6())
oraclenr = 4 # 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 = '1111'
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
max_nr_inputs = 9
return [min_nr_inputs, max_nr_inputs]
from qc_grader import grade_lab1_ex7
# Note that the grading function is expecting a list of two integers
grade_lab1_ex7(lab1_ex7())
n=4
def psi_0(n):
qc = QuantumCircuit(n+1,n)
# Build the state (|00000> - |10000>)/sqrt(2)
#
#
# FILL YOUR CODE IN HERE
#
#
qc.x(4)
qc.h(4)
return qc
dj_circuit = psi_0(n)
dj_circuit.draw()
def psi_1(n):
# obtain the |psi_0> = |00001> state
qc = psi_0(n)
# create the superposition state |psi_1>
#
#
qc.h(0)
qc.h(1)
qc.h(2)
qc.h(3)
#
#
qc.barrier()
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
#
#
# FILL YOUR CODE IN HERE
#
#
qc.h(0)
qc.h(1)
qc.h(2)
qc.h(3)
# add the measurement by connecting qubits to classical bits
#
#
qc.measure(0,0)
qc.measure(1,1)
qc.measure(2,2)
qc.measure(3,3)
#
#
return qc
dj_circuit = lab1_ex8(oracle, n)
dj_circuit.draw()
from qc_grader import grade_lab1_ex8
# Note that the grading function is expecting a quantum circuit with measurements
grade_lab1_ex8(lab1_ex8(dj_problem_oracle(4),n))
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)
|
https://github.com/scaleway/qiskit-scaleway
|
scaleway
|
# Copyright 2024 Scaleway
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from qiskit import QuantumCircuit
from qiskit_scaleway import ScalewayProvider
provider = ScalewayProvider(
project_id="<your-scaleway-project-id>",
secret_key="<your-scaleway-secret-key>",
)
# Retrieve a backend by providing search criteria. The search must have a single match
backend = provider.get_backend("aer_simulation_2l4")
# Define a quantum circuit that produces a 4-qubit GHZ state.
qc = QuantumCircuit(4)
qc.h(0)
qc.cx(0, 1)
qc.cx(0, 2)
qc.cx(0, 3)
qc.measure_all()
# Create a QPU's session for a limited duration, a max_idle_duration can also be specified
session_id = backend.start_session(
deduplication_id="my-aer-session-workshop", max_duration="2h"
)
# Create and send a job to the target session
result = backend.run(qc, shots=1000, session_id=session_id).result()
if result.success:
print(result.get_counts())
else:
print(result.to_dict()["error"])
# Revoke manually the QPU's session if needed
# If not done, will be revoked automatically after 2 hours
backend.stop_session(session_id)
|
https://github.com/GroenteLepel/qiskit-quantum-knn
|
GroenteLepel
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# pylint: disable=wrong-import-order
"""Main Qiskit public functionality."""
import pkgutil
# First, check for required Python and API version
from . import util
# qiskit errors operator
from .exceptions import QiskitError
# The main qiskit operators
from qiskit.circuit import ClassicalRegister
from qiskit.circuit import QuantumRegister
from qiskit.circuit import QuantumCircuit
# pylint: disable=redefined-builtin
from qiskit.tools.compiler import compile # TODO remove after 0.8
from qiskit.execute import execute
# The qiskit.extensions.x imports needs to be placed here due to the
# mechanism for adding gates dynamically.
import qiskit.extensions
import qiskit.circuit.measure
import qiskit.circuit.reset
# Allow extending this namespace. Please note that currently this line needs
# to be placed *before* the wrapper imports or any non-import code AND *before*
# importing the package you want to allow extensions for (in this case `backends`).
__path__ = pkgutil.extend_path(__path__, __name__)
# Please note these are global instances, not modules.
from qiskit.providers.basicaer import BasicAer
# Try to import the Aer provider if installed.
try:
from qiskit.providers.aer import Aer
except ImportError:
pass
# Try to import the IBMQ provider if installed.
try:
from qiskit.providers.ibmq import IBMQ
except ImportError:
pass
from .version import __version__
from .version import __qiskit_version__
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""
Initialize qubit registers to desired arbitrary state.
"""
import numpy as np
from qiskit.circuit import QuantumCircuit
from qiskit.circuit import QuantumRegister
from qiskit.circuit import Instruction
from qiskit.circuit import Qubit
from qiskit.circuit.library.data_preparation import StatePreparation
_EPS = 1e-10 # global variable used to chop very small numbers to zero
class Initialize(Instruction):
"""Complex amplitude initialization.
Class that initializes some flexible collection of qubit registers, implemented by calling
the :class:`qiskit.extensions.StatePreparation` Class.
Note that Initialize is an Instruction and not a Gate since it contains a reset instruction,
which is not unitary.
"""
def __init__(self, params, num_qubits=None, normalize=False):
r"""Create new initialize composite.
Args:
params (str, list, int or Statevector):
* Statevector: Statevector to initialize to.
* list: vector of complex amplitudes to initialize to.
* string: labels of basis states of the Pauli eigenstates Z, X, Y. See
:meth:`.Statevector.from_label`.
Notice the order of the labels is reversed with respect to the qubit index to
be applied to. Example label '01' initializes the qubit zero to :math:`|1\rangle`
and the qubit one to :math:`|0\rangle`.
* int: an integer that is used as a bitmap indicating which qubits to initialize
to :math:`|1\rangle`. Example: setting params to 5 would initialize qubit 0 and qubit 2
to :math:`|1\rangle` and qubit 1 to :math:`|0\rangle`.
num_qubits (int): This parameter is only used if params is an int. Indicates the total
number of qubits in the `initialize` call. Example: `initialize` covers 5 qubits
and params is 3. This allows qubits 0 and 1 to be initialized to :math:`|1\rangle`
and the remaining 3 qubits to be initialized to :math:`|0\rangle`.
normalize (bool): Whether to normalize an input array to a unit vector.
"""
self._stateprep = StatePreparation(params, num_qubits, normalize=normalize)
super().__init__("initialize", self._stateprep.num_qubits, 0, self._stateprep.params)
def _define(self):
q = QuantumRegister(self.num_qubits, "q")
initialize_circuit = QuantumCircuit(q, name="init_def")
initialize_circuit.reset(q)
initialize_circuit.append(self._stateprep, q)
self.definition = initialize_circuit
def gates_to_uncompute(self):
"""Call to create a circuit with gates that take the desired vector to zero.
Returns:
QuantumCircuit: circuit to take self.params vector to :math:`|{00\\ldots0}\\rangle`
"""
return self._stateprep._gates_to_uncompute()
@property
def params(self):
"""Return initialize params."""
return self._stateprep.params
@params.setter
def params(self, parameters):
"""Set initialize params."""
self._stateprep.params = parameters
def broadcast_arguments(self, qargs, cargs):
return self._stateprep.broadcast_arguments(qargs, cargs)
def initialize(self, params, qubits=None, normalize=False):
r"""Initialize qubits in a specific state.
Qubit initialization is done by first resetting the qubits to :math:`|0\rangle`
followed by calling :class:`qiskit.extensions.StatePreparation`
class to prepare the qubits in a specified state.
Both these steps are included in the
:class:`qiskit.extensions.Initialize` instruction.
Args:
params (str or list or int):
* str: labels of basis states of the Pauli eigenstates Z, X, Y. See
:meth:`.Statevector.from_label`. Notice the order of the labels is reversed with respect
to the qubit index to be applied to. Example label '01' initializes the qubit zero to
:math:`|1\rangle` and the qubit one to :math:`|0\rangle`.
* list: vector of complex amplitudes to initialize to.
* int: an integer that is used as a bitmap indicating which qubits to initialize
to :math:`|1\rangle`. Example: setting params to 5 would initialize qubit 0 and qubit 2
to :math:`|1\rangle` and qubit 1 to :math:`|0\rangle`.
qubits (QuantumRegister or Qubit or int):
* QuantumRegister: A list of qubits to be initialized [Default: None].
* Qubit: Single qubit to be initialized [Default: None].
* int: Index of qubit to be initialized [Default: None].
* list: Indexes of qubits to be initialized [Default: None].
normalize (bool): whether to normalize an input array to a unit vector.
Returns:
qiskit.circuit.Instruction: a handle to the instruction that was just initialized
Examples:
Prepare a qubit in the state :math:`(|0\rangle - |1\rangle) / \sqrt{2}`.
.. code-block::
import numpy as np
from qiskit import QuantumCircuit
circuit = QuantumCircuit(1)
circuit.initialize([1/np.sqrt(2), -1/np.sqrt(2)], 0)
circuit.draw()
output:
.. parsed-literal::
┌──────────────────────────────┐
q_0: ┤ Initialize(0.70711,-0.70711) ├
└──────────────────────────────┘
Initialize from a string two qubits in the state :math:`|10\rangle`.
The order of the labels is reversed with respect to qubit index.
More information about labels for basis states are in
:meth:`.Statevector.from_label`.
.. code-block::
import numpy as np
from qiskit import QuantumCircuit
circuit = QuantumCircuit(2)
circuit.initialize('01', circuit.qubits)
circuit.draw()
output:
.. parsed-literal::
┌──────────────────┐
q_0: ┤0 ├
│ Initialize(0,1) │
q_1: ┤1 ├
└──────────────────┘
Initialize two qubits from an array of complex amplitudes.
.. code-block::
import numpy as np
from qiskit import QuantumCircuit
circuit = QuantumCircuit(2)
circuit.initialize([0, 1/np.sqrt(2), -1.j/np.sqrt(2), 0], circuit.qubits)
circuit.draw()
output:
.. parsed-literal::
┌────────────────────────────────────┐
q_0: ┤0 ├
│ Initialize(0,0.70711,-0.70711j,0) │
q_1: ┤1 ├
└────────────────────────────────────┘
"""
if qubits is None:
qubits = self.qubits
elif isinstance(qubits, (int, np.integer, slice, Qubit)):
qubits = [qubits]
num_qubits = len(qubits) if isinstance(params, int) else None
return self.append(Initialize(params, num_qubits, normalize), qubits)
QuantumCircuit.initialize = initialize
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Test cases for the circuit qasm_file and qasm_string method."""
import os
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.circuit import Gate, Parameter
from qiskit.exceptions import QiskitError
from qiskit.test import QiskitTestCase
from qiskit.transpiler.passes import Unroller
from qiskit.converters.circuit_to_dag import circuit_to_dag
class LoadFromQasmTest(QiskitTestCase):
"""Test circuit.from_qasm_* set of methods."""
def setUp(self):
super().setUp()
self.qasm_file_name = "entangled_registers.qasm"
self.qasm_dir = os.path.join(
os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "qasm"
)
self.qasm_file_path = os.path.join(self.qasm_dir, self.qasm_file_name)
def test_qasm_file(self):
"""
Test qasm_file and get_circuit.
If all is correct we should get the qasm file loaded in _qasm_file_path
"""
q_circuit = QuantumCircuit.from_qasm_file(self.qasm_file_path)
qr_a = QuantumRegister(4, "a")
qr_b = QuantumRegister(4, "b")
cr_c = ClassicalRegister(4, "c")
cr_d = ClassicalRegister(4, "d")
q_circuit_2 = QuantumCircuit(qr_a, qr_b, cr_c, cr_d)
q_circuit_2.h(qr_a)
q_circuit_2.cx(qr_a, qr_b)
q_circuit_2.barrier(qr_a)
q_circuit_2.barrier(qr_b)
q_circuit_2.measure(qr_a, cr_c)
q_circuit_2.measure(qr_b, cr_d)
self.assertEqual(q_circuit, q_circuit_2)
def test_loading_all_qelib1_gates(self):
"""Test setting up a circuit with all gates defined in qiskit/qasm/libs/qelib1.inc."""
from qiskit.circuit.library import U1Gate, U2Gate, U3Gate, CU1Gate, CU3Gate, UGate
all_gates_qasm = os.path.join(self.qasm_dir, "all_gates.qasm")
qasm_circuit = QuantumCircuit.from_qasm_file(all_gates_qasm)
ref_circuit = QuantumCircuit(3, 3)
# abstract gates (legacy)
ref_circuit.append(UGate(0.2, 0.1, 0.6), [0])
ref_circuit.cx(0, 1)
# the hardware primitives
ref_circuit.append(U3Gate(0.2, 0.1, 0.6), [0])
ref_circuit.append(U2Gate(0.1, 0.6), [0])
ref_circuit.append(U1Gate(0.6), [0])
ref_circuit.id(0)
ref_circuit.cx(0, 1)
# the standard single qubit gates
ref_circuit.u(0.2, 0.1, 0.6, 0)
ref_circuit.p(0.6, 0)
ref_circuit.x(0)
ref_circuit.y(0)
ref_circuit.z(0)
ref_circuit.h(0)
ref_circuit.s(0)
ref_circuit.t(0)
ref_circuit.sdg(0)
ref_circuit.tdg(0)
ref_circuit.sx(0)
ref_circuit.sxdg(0)
# the standard rotations
ref_circuit.rx(0.1, 0)
ref_circuit.ry(0.1, 0)
ref_circuit.rz(0.1, 0)
# the barrier
ref_circuit.barrier()
# the standard user-defined gates
ref_circuit.swap(0, 1)
ref_circuit.cswap(0, 1, 2)
ref_circuit.cy(0, 1)
ref_circuit.cz(0, 1)
ref_circuit.ch(0, 1)
ref_circuit.csx(0, 1)
ref_circuit.append(CU1Gate(0.6), [0, 1])
ref_circuit.append(CU3Gate(0.2, 0.1, 0.6), [0, 1])
ref_circuit.cp(0.6, 0, 1)
ref_circuit.cu(0.2, 0.1, 0.6, 0, 0, 1)
ref_circuit.ccx(0, 1, 2)
ref_circuit.crx(0.6, 0, 1)
ref_circuit.cry(0.6, 0, 1)
ref_circuit.crz(0.6, 0, 1)
ref_circuit.rxx(0.2, 0, 1)
ref_circuit.rzz(0.2, 0, 1)
ref_circuit.measure([0, 1, 2], [0, 1, 2])
self.assertEqual(qasm_circuit, ref_circuit)
def test_fail_qasm_file(self):
"""
Test fail_qasm_file.
If all is correct we should get a QiskitError
"""
self.assertRaises(QiskitError, QuantumCircuit.from_qasm_file, "")
def test_qasm_text(self):
"""
Test qasm_text and get_circuit.
If all is correct we should get the qasm file loaded from the string
"""
qasm_string = "// A simple 8 qubit example\nOPENQASM 2.0;\n"
qasm_string += 'include "qelib1.inc";\nqreg a[4];\n'
qasm_string += "qreg b[4];\ncreg c[4];\ncreg d[4];\nh a;\ncx a, b;\n"
qasm_string += "barrier a;\nbarrier b;\nmeasure a[0]->c[0];\n"
qasm_string += "measure a[1]->c[1];\nmeasure a[2]->c[2];\n"
qasm_string += "measure a[3]->c[3];\nmeasure b[0]->d[0];\n"
qasm_string += "measure b[1]->d[1];\nmeasure b[2]->d[2];\n"
qasm_string += "measure b[3]->d[3];"
q_circuit = QuantumCircuit.from_qasm_str(qasm_string)
qr_a = QuantumRegister(4, "a")
qr_b = QuantumRegister(4, "b")
cr_c = ClassicalRegister(4, "c")
cr_d = ClassicalRegister(4, "d")
ref = QuantumCircuit(qr_a, qr_b, cr_c, cr_d)
ref.h(qr_a[3])
ref.cx(qr_a[3], qr_b[3])
ref.h(qr_a[2])
ref.cx(qr_a[2], qr_b[2])
ref.h(qr_a[1])
ref.cx(qr_a[1], qr_b[1])
ref.h(qr_a[0])
ref.cx(qr_a[0], qr_b[0])
ref.barrier(qr_b)
ref.measure(qr_b, cr_d)
ref.barrier(qr_a)
ref.measure(qr_a, cr_c)
self.assertEqual(len(q_circuit.cregs), 2)
self.assertEqual(len(q_circuit.qregs), 2)
self.assertEqual(q_circuit, ref)
def test_qasm_text_conditional(self):
"""
Test qasm_text and get_circuit when conditionals are present.
"""
qasm_string = (
"\n".join(
[
"OPENQASM 2.0;",
'include "qelib1.inc";',
"qreg q[1];",
"creg c0[4];",
"creg c1[4];",
"x q[0];",
"if(c1==4) x q[0];",
]
)
+ "\n"
)
q_circuit = QuantumCircuit.from_qasm_str(qasm_string)
qr = QuantumRegister(1, "q")
cr0 = ClassicalRegister(4, "c0")
cr1 = ClassicalRegister(4, "c1")
ref = QuantumCircuit(qr, cr0, cr1)
ref.x(qr[0])
ref.x(qr[0]).c_if(cr1, 4)
self.assertEqual(len(q_circuit.cregs), 2)
self.assertEqual(len(q_circuit.qregs), 1)
self.assertEqual(q_circuit, ref)
def test_opaque_gate(self):
"""
Test parse an opaque gate
See https://github.com/Qiskit/qiskit-terra/issues/1566.
"""
qasm_string = (
"\n".join(
[
"OPENQASM 2.0;",
'include "qelib1.inc";',
"opaque my_gate(theta,phi,lambda) a,b;",
"qreg q[3];",
"my_gate(1,2,3) q[1],q[2];",
]
)
+ "\n"
)
circuit = QuantumCircuit.from_qasm_str(qasm_string)
qr = QuantumRegister(3, "q")
expected = QuantumCircuit(qr)
expected.append(Gate(name="my_gate", num_qubits=2, params=[1, 2, 3]), [qr[1], qr[2]])
self.assertEqual(circuit, expected)
def test_qasm_example_file(self):
"""Loads qasm/example.qasm."""
qasm_filename = os.path.join(self.qasm_dir, "example.qasm")
expected_circuit = QuantumCircuit.from_qasm_str(
"\n".join(
[
"OPENQASM 2.0;",
'include "qelib1.inc";',
"qreg q[3];",
"qreg r[3];",
"creg c[3];",
"creg d[3];",
"h q[2];",
"cx q[2],r[2];",
"measure r[2] -> d[2];",
"h q[1];",
"cx q[1],r[1];",
"measure r[1] -> d[1];",
"h q[0];",
"cx q[0],r[0];",
"measure r[0] -> d[0];",
"barrier q[0],q[1],q[2];",
"measure q[2] -> c[2];",
"measure q[1] -> c[1];",
"measure q[0] -> c[0];",
]
)
+ "\n"
)
q_circuit = QuantumCircuit.from_qasm_file(qasm_filename)
self.assertEqual(q_circuit, expected_circuit)
self.assertEqual(len(q_circuit.cregs), 2)
self.assertEqual(len(q_circuit.qregs), 2)
def test_qasm_qas_string_order(self):
"""Test that gates are returned in qasm in ascending order."""
expected_qasm = (
"\n".join(
[
"OPENQASM 2.0;",
'include "qelib1.inc";',
"qreg q[3];",
"h q[0];",
"h q[1];",
"h q[2];",
]
)
+ "\n"
)
qasm_string = """OPENQASM 2.0;
include "qelib1.inc";
qreg q[3];
h q;"""
q_circuit = QuantumCircuit.from_qasm_str(qasm_string)
self.assertEqual(q_circuit.qasm(), expected_qasm)
def test_from_qasm_str_custom_gate1(self):
"""Test load custom gates (simple case)"""
qasm_string = """OPENQASM 2.0;
include "qelib1.inc";
gate rinv q {sdg q; h q; sdg q; h q; }
qreg qr[1];
rinv qr[0];"""
circuit = QuantumCircuit.from_qasm_str(qasm_string)
rinv_q = QuantumRegister(1, name="q")
rinv_gate = QuantumCircuit(rinv_q, name="rinv")
rinv_gate.sdg(rinv_q)
rinv_gate.h(rinv_q)
rinv_gate.sdg(rinv_q)
rinv_gate.h(rinv_q)
rinv = rinv_gate.to_instruction()
qr = QuantumRegister(1, name="qr")
expected = QuantumCircuit(qr, name="circuit")
expected.append(rinv, [qr[0]])
self.assertEqualUnroll(["sdg", "h"], circuit, expected)
def test_from_qasm_str_custom_gate2(self):
"""Test load custom gates (no so simple case, different bit order)
See: https://github.com/Qiskit/qiskit-terra/pull/3393#issuecomment-551307250
"""
qasm_string = """OPENQASM 2.0;
include "qelib1.inc";
gate swap2 a,b {
cx a,b;
cx b,a; // different bit order
cx a,b;
}
qreg qr[3];
swap2 qr[0], qr[1];
swap2 qr[1], qr[2];"""
circuit = QuantumCircuit.from_qasm_str(qasm_string)
ab_args = QuantumRegister(2, name="ab")
swap_gate = QuantumCircuit(ab_args, name="swap2")
swap_gate.cx(ab_args[0], ab_args[1])
swap_gate.cx(ab_args[1], ab_args[0])
swap_gate.cx(ab_args[0], ab_args[1])
swap = swap_gate.to_instruction()
qr = QuantumRegister(3, name="qr")
expected = QuantumCircuit(qr, name="circuit")
expected.append(swap, [qr[0], qr[1]])
expected.append(swap, [qr[1], qr[2]])
self.assertEqualUnroll(["cx"], expected, circuit)
def test_from_qasm_str_custom_gate3(self):
"""Test load custom gates (no so simple case, different bit count)
See: https://github.com/Qiskit/qiskit-terra/pull/3393#issuecomment-551307250
"""
qasm_string = """OPENQASM 2.0;
include "qelib1.inc";
gate cswap2 a,b,c
{
cx c,b; // different bit count
ccx a,b,c; //previously defined gate
cx c,b;
}
qreg qr[3];
cswap2 qr[1], qr[0], qr[2];"""
circuit = QuantumCircuit.from_qasm_str(qasm_string)
abc_args = QuantumRegister(3, name="abc")
cswap_gate = QuantumCircuit(abc_args, name="cswap2")
cswap_gate.cx(abc_args[2], abc_args[1])
cswap_gate.ccx(abc_args[0], abc_args[1], abc_args[2])
cswap_gate.cx(abc_args[2], abc_args[1])
cswap = cswap_gate.to_instruction()
qr = QuantumRegister(3, name="qr")
expected = QuantumCircuit(qr, name="circuit")
expected.append(cswap, [qr[1], qr[0], qr[2]])
self.assertEqualUnroll(["cx", "h", "tdg", "t"], circuit, expected)
def test_from_qasm_str_custom_gate4(self):
"""Test load custom gates (parameterized)
See: https://github.com/Qiskit/qiskit-terra/pull/3393#issuecomment-551307250
"""
qasm_string = """OPENQASM 2.0;
include "qelib1.inc";
gate my_gate(phi,lambda) q {u(1.5707963267948966,phi,lambda) q;}
qreg qr[1];
my_gate(pi, pi) qr[0];"""
circuit = QuantumCircuit.from_qasm_str(qasm_string)
my_gate_circuit = QuantumCircuit(1, name="my_gate")
phi = Parameter("phi")
lam = Parameter("lambda")
my_gate_circuit.u(1.5707963267948966, phi, lam, 0)
my_gate = my_gate_circuit.to_gate()
qr = QuantumRegister(1, name="qr")
expected = QuantumCircuit(qr, name="circuit")
expected.append(my_gate, [qr[0]])
expected = expected.bind_parameters({phi: 3.141592653589793, lam: 3.141592653589793})
self.assertEqualUnroll("u", circuit, expected)
def test_from_qasm_str_custom_gate5(self):
"""Test load custom gates (parameterized, with biop and constant)
See: https://github.com/Qiskit/qiskit-terra/pull/3393#issuecomment-551307250
"""
qasm_string = """OPENQASM 2.0;
include "qelib1.inc";
gate my_gate(phi,lambda) q {u(pi/2,phi,lambda) q;} // biop with pi
qreg qr[1];
my_gate(pi, pi) qr[0];"""
circuit = QuantumCircuit.from_qasm_str(qasm_string)
my_gate_circuit = QuantumCircuit(1, name="my_gate")
phi = Parameter("phi")
lam = Parameter("lambda")
my_gate_circuit.u(1.5707963267948966, phi, lam, 0)
my_gate = my_gate_circuit.to_gate()
qr = QuantumRegister(1, name="qr")
expected = QuantumCircuit(qr, name="circuit")
expected.append(my_gate, [qr[0]])
expected = expected.bind_parameters({phi: 3.141592653589793, lam: 3.141592653589793})
self.assertEqualUnroll("u", circuit, expected)
def test_from_qasm_str_custom_gate6(self):
"""Test load custom gates (parameters used in expressions)
See: https://github.com/Qiskit/qiskit-terra/pull/3393#issuecomment-591668924
"""
qasm_string = """OPENQASM 2.0;
include "qelib1.inc";
gate my_gate(phi,lambda) q
{rx(phi+pi) q; ry(lambda/2) q;} // parameters used in expressions
qreg qr[1];
my_gate(pi, pi) qr[0];"""
circuit = QuantumCircuit.from_qasm_str(qasm_string)
my_gate_circuit = QuantumCircuit(1, name="my_gate")
phi = Parameter("phi")
lam = Parameter("lambda")
my_gate_circuit.rx(phi + 3.141592653589793, 0)
my_gate_circuit.ry(lam / 2, 0)
my_gate = my_gate_circuit.to_gate()
qr = QuantumRegister(1, name="qr")
expected = QuantumCircuit(qr, name="circuit")
expected.append(my_gate, [qr[0]])
expected = expected.bind_parameters({phi: 3.141592653589793, lam: 3.141592653589793})
self.assertEqualUnroll(["rx", "ry"], circuit, expected)
def test_from_qasm_str_custom_gate7(self):
"""Test load custom gates (build in functions)
See: https://github.com/Qiskit/qiskit-terra/pull/3393#issuecomment-592208951
"""
qasm_string = """OPENQASM 2.0;
include "qelib1.inc";
gate my_gate(phi,lambda) q
{u(asin(cos(phi)/2), phi+pi, lambda/2) q;} // build func
qreg qr[1];
my_gate(pi, pi) qr[0];"""
circuit = QuantumCircuit.from_qasm_str(qasm_string)
qr = QuantumRegister(1, name="qr")
expected = QuantumCircuit(qr, name="circuit")
expected.u(-0.5235987755982988, 6.283185307179586, 1.5707963267948966, qr[0])
self.assertEqualUnroll("u", circuit, expected)
def test_from_qasm_str_nested_custom_gate(self):
"""Test chain of custom gates
See: https://github.com/Qiskit/qiskit-terra/pull/3393#issuecomment-592261942
"""
qasm_string = """OPENQASM 2.0;
include "qelib1.inc";
gate my_other_gate(phi,lambda) q
{u(asin(cos(phi)/2), phi+pi, lambda/2) q;}
gate my_gate(phi) r
{my_other_gate(phi, phi+pi) r;}
qreg qr[1];
my_gate(pi) qr[0];"""
circuit = QuantumCircuit.from_qasm_str(qasm_string)
qr = QuantumRegister(1, name="qr")
expected = QuantumCircuit(qr, name="circuit")
expected.u(-0.5235987755982988, 6.283185307179586, 3.141592653589793, qr[0])
self.assertEqualUnroll("u", circuit, expected)
def test_from_qasm_str_delay(self):
"""Test delay instruction/opaque-gate
See: https://github.com/Qiskit/qiskit-terra/issues/6510
"""
qasm_string = """OPENQASM 2.0;
include "qelib1.inc";
opaque delay(time) q;
qreg q[1];
delay(172) q[0];"""
circuit = QuantumCircuit.from_qasm_str(qasm_string)
qr = QuantumRegister(1, name="q")
expected = QuantumCircuit(qr, name="circuit")
expected.delay(172, qr[0])
self.assertEqualUnroll("u", circuit, expected)
def test_definition_with_u_cx(self):
"""Test that gate-definition bodies can use U and CX."""
qasm_string = """
OPENQASM 2.0;
gate bell q0, q1 { U(pi/2, 0, pi) q0; CX q0, q1; }
qreg q[2];
bell q[0], q[1];
"""
circuit = QuantumCircuit.from_qasm_str(qasm_string)
qr = QuantumRegister(2, "q")
expected = QuantumCircuit(qr)
expected.h(0)
expected.cx(0, 1)
self.assertEqualUnroll(["u", "cx"], circuit, expected)
def assertEqualUnroll(self, basis, circuit, expected):
"""Compares the dags after unrolling to basis"""
circuit_dag = circuit_to_dag(circuit)
expected_dag = circuit_to_dag(expected)
circuit_result = Unroller(basis).run(circuit_dag)
expected_result = Unroller(basis).run(expected_dag)
self.assertEqual(circuit_result, expected_result)
|
https://github.com/hamburgerguy/Quantum-Algorithm-Implementations
|
hamburgerguy
|
"""Python implementation of Grovers algorithm through use of the Qiskit library to find the value 3 (|11>)
out of four possible values."""
#import numpy and plot library
import matplotlib.pyplot as plt
import numpy as np
# importing Qiskit
from qiskit import IBMQ, Aer, QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.providers.ibmq import least_busy
from qiskit.quantum_info import Statevector
# import basic plot tools
from qiskit.visualization import plot_histogram
# define variables, 1) initialize qubits to zero
n = 2
grover_circuit = QuantumCircuit(n)
#define initialization function
def initialize_s(qc, qubits):
'''Apply a H-gate to 'qubits' in qc'''
for q in qubits:
qc.h(q)
return qc
### begin grovers circuit ###
#2) Put qubits in equal state of superposition
grover_circuit = initialize_s(grover_circuit, [0,1])
# 3) Apply oracle reflection to marked instance x_0 = 3, (|11>)
grover_circuit.cz(0,1)
statevec = job_sim.result().get_statevector()
from qiskit_textbook.tools import vector2latex
vector2latex(statevec, pretext="|\\psi\\rangle =")
# 4) apply additional reflection (diffusion operator)
grover_circuit.h([0,1])
grover_circuit.z([0,1])
grover_circuit.cz(0,1)
grover_circuit.h([0,1])
# 5) measure the qubits
grover_circuit.measure_all()
# Load IBM Q account and get the least busy backend device
provider = IBMQ.load_account()
device = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 3 and
not x.configuration().simulator and x.status().operational==True))
print("Running on current least busy device: ", device)
from qiskit.tools.monitor import job_monitor
job = execute(grover_circuit, backend=device, shots=1024, optimization_level=3)
job_monitor(job, interval = 2)
results = job.result()
answer = results.get_counts(grover_circuit)
plot_histogram(answer)
#highest amplitude should correspond with marked value x_0 (|11>)
|
https://github.com/mmetcalf14/Hamiltonian_Downfolding_IBM
|
mmetcalf14
|
from math import pi
import numpy as np
import scipy as sp
# importing Qiskit
from qiskit import Aer
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute
from qiskit.tools.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor
# We first define controlled gates used in the IPEA
def cu1fixed(qProg, c, t, a):
qProg.u1(-a, t)
qProg.cx(c, t)
qProg.u1(a, t)
qProg.cx(c, t)
def cu5pi8(qProg, c, t):
cu1fixed(qProg, c, t, -5.0*pi/8.0)
backend = Aer.get_backend('statevector_simulator')
# backend = Aer.get_backend('qasm_simulator')
# We then prepare quantum and classical registers and the circuit
qr = QuantumRegister(2)
cr = ClassicalRegister(1)
Circuit = QuantumCircuit(qr,cr)
# Apply IPEA
Circuit.h(qr[0])
cu5pi8(Circuit, qr[0], qr[1])
# for i in range(8):
# cu5pi8(Circuit, qr[0], qr[1])
# Circuit.u1(-3*pi/4,qr[0])
Circuit.h(qr[0])
#Circuit.measure(qr[0], cr[0])
print('Circuit for least significant bit',Circuit)
alg = execute(Circuit, backend)
result = alg.result()
print(result)
vec = result.get_statevector(Circuit)
vecx = np.conj(vec)
print(vec)
#plot_histogram(result.get_counts())
'''
Circuit.h(qr[0])
Circuit.u1(-pi/4., qr[1])
Circuit.cx(qr[0], qr[1])
Circuit.u1(pi/4., qr[1])
Circuit.cx(qr[0], qr[1])
Circuit.h(qr[0])
Circuit.measure(qr[0], cr[0])
print(Circuit)
alg = execute(Circuit, backend)
result = alg.result()
count = result.get_counts(Circuit)
print(count)
# state_vec = result.get_statevector(Circuit)
# vecx = np.conj(state_vec)
# print(np.outer(vecx,state_vec))
'''
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
from qiskit.algorithms import IterativeAmplitudeEstimation, EstimationProblem
from qiskit.circuit.library import LinearAmplitudeFunction
from qiskit_aer.primitives import Sampler
from qiskit_finance.circuit.library import LogNormalDistribution
# number of qubits to represent the uncertainty
num_uncertainty_qubits = 3
# parameters for considered random distribution
S = 2.0 # initial spot price
vol = 0.4 # volatility of 40%
r = 0.05 # annual interest rate of 4%
T = 40 / 365 # 40 days to maturity
# resulting parameters for log-normal distribution
mu = (r - 0.5 * vol**2) * T + np.log(S)
sigma = vol * np.sqrt(T)
mean = np.exp(mu + sigma**2 / 2)
variance = (np.exp(sigma**2) - 1) * np.exp(2 * mu + sigma**2)
stddev = np.sqrt(variance)
# lowest and highest value considered for the spot price; in between, an equidistant discretization is considered.
low = np.maximum(0, mean - 3 * stddev)
high = mean + 3 * stddev
# construct A operator for QAE for the payoff function by
# composing the uncertainty model and the objective
uncertainty_model = LogNormalDistribution(
num_uncertainty_qubits, mu=mu, sigma=sigma**2, bounds=(low, high)
)
# plot probability distribution
x = uncertainty_model.values
y = uncertainty_model.probabilities
plt.bar(x, y, width=0.2)
plt.xticks(x, size=15, rotation=90)
plt.yticks(size=15)
plt.grid()
plt.xlabel("Spot Price at Maturity $S_T$ (\$)", size=15)
plt.ylabel("Probability ($\%$)", size=15)
plt.show()
# set the strike price (should be within the low and the high value of the uncertainty)
strike_price = 2.126
# set the approximation scaling for the payoff function
rescaling_factor = 0.25
# setup piecewise linear objective fcuntion
breakpoints = [low, strike_price]
slopes = [-1, 0]
offsets = [strike_price - low, 0]
f_min = 0
f_max = strike_price - low
european_put_objective = LinearAmplitudeFunction(
num_uncertainty_qubits,
slopes,
offsets,
domain=(low, high),
image=(f_min, f_max),
breakpoints=breakpoints,
rescaling_factor=rescaling_factor,
)
# construct A operator for QAE for the payoff function by
# composing the uncertainty model and the objective
european_put = european_put_objective.compose(uncertainty_model, front=True)
# plot exact payoff function (evaluated on the grid of the uncertainty model)
x = uncertainty_model.values
y = np.maximum(0, strike_price - x)
plt.plot(x, y, "ro-")
plt.grid()
plt.title("Payoff Function", size=15)
plt.xlabel("Spot Price", size=15)
plt.ylabel("Payoff", size=15)
plt.xticks(x, size=15, rotation=90)
plt.yticks(size=15)
plt.show()
# evaluate exact expected value (normalized to the [0, 1] interval)
exact_value = np.dot(uncertainty_model.probabilities, y)
exact_delta = -sum(uncertainty_model.probabilities[x <= strike_price])
print("exact expected value:\t%.4f" % exact_value)
print("exact delta value: \t%.4f" % exact_delta)
# set target precision and confidence level
epsilon = 0.01
alpha = 0.05
problem = EstimationProblem(
state_preparation=european_put,
objective_qubits=[num_uncertainty_qubits],
post_processing=european_put_objective.post_processing,
)
# construct amplitude estimation
ae = IterativeAmplitudeEstimation(
epsilon_target=epsilon, alpha=alpha, sampler=Sampler(run_options={"shots": 100})
)
result = ae.estimate(problem)
conf_int = np.array(result.confidence_interval_processed)
print("Exact value: \t%.4f" % exact_value)
print("Estimated value: \t%.4f" % (result.estimation_processed))
print("Confidence interval:\t[%.4f, %.4f]" % tuple(conf_int))
# setup piecewise linear objective fcuntion
breakpoints = [low, strike_price]
slopes = [0, 0]
offsets = [1, 0]
f_min = 0
f_max = 1
european_put_delta_objective = LinearAmplitudeFunction(
num_uncertainty_qubits,
slopes,
offsets,
domain=(low, high),
image=(f_min, f_max),
breakpoints=breakpoints,
)
# construct circuit for payoff function
european_put_delta = european_put_delta_objective.compose(uncertainty_model, front=True)
# set target precision and confidence level
epsilon = 0.01
alpha = 0.05
problem = EstimationProblem(
state_preparation=european_put_delta, objective_qubits=[num_uncertainty_qubits]
)
# construct amplitude estimation
ae_delta = IterativeAmplitudeEstimation(
epsilon_target=epsilon, alpha=alpha, sampler=Sampler(run_options={"shots": 100})
)
result_delta = ae_delta.estimate(problem)
conf_int = -np.array(result_delta.confidence_interval)[::-1]
print("Exact delta: \t%.4f" % exact_delta)
print("Esimated value: \t%.4f" % -result_delta.estimation)
print("Confidence interval: \t[%.4f, %.4f]" % tuple(conf_int))
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.transpiler import CouplingMap
from qiskit.converters import dag_to_circuit
from qiskit.transpiler.layout import Layout
import numpy as np
from qiskit.transpiler.passes import Unroller
from qiskit.quantum_info import Operator
from qiskit.transpiler.passes import (
TrivialLayout,
BasicSwap,
ApplyLayout,
SetLayout,
SabreLayout,
FullAncillaAllocation,
EnlargeWithAncilla,
)
from qiskit.transpiler.passmanager import PassManager
# from virtual_swap.cns_sabre import CNS_SabreSwap
# from virtual_swap.cns_sabre_v2 import CNS_SabreSwap_V2 as CNS_SabreSwap
from virtual_swap.cns_sabre_v3 import SabreMS as CNS_SabreSwap
# # load a dummy circuit
# # generate network of random cnots
# n, M = 2, 5
# N = n**2
# register = QuantumRegister(N)
# qc = QuantumCircuit(register)
# for _ in range(M):
# # choose 2 random qubits
# qargs = np.random.choice(N, 2, replace=False)
# qc.cx(*qargs)
# qc.u(np.random.rand(), np.random.rand(), np.random.rand(), qargs[0])
# qc.u(np.random.rand(), np.random.rand(), np.random.rand(), qargs[1])
# qc.decompose().draw("mpl")
N = 3
register = QuantumRegister(N)
qc = QuantumCircuit(register)
qc.ccx(0, 1, 2)
qc = qc.decompose()
qc.draw("mpl")
# load a dummy coupling map and layout
coupling = CouplingMap.from_line(N)
layout = Layout({q: i for q, i in zip(register, range(N))})
# print DAG
from qiskit.converters import circuit_to_dag
dag = circuit_to_dag(qc)
# dag.draw("mpl")
qc.draw("mpl")
from qiskit import transpile
qiskit_qc = transpile(
qc, coupling_map=coupling, initial_layout=layout, optimization_level=3
)
qiskit_qc.draw("mpl")
from qiskit import transpile
from virtual_swap.sqiswap_equiv import sel
qiskit_qc = transpile(
qc,
coupling_map=coupling,
initial_layout=layout,
optimization_level=3,
basis_gates=["u", "xx_plus_yy"],
)
qiskit_qc.draw("mpl")
# for every swap gate, append a swap gate to the end of the circuit
# this forces the qubit register ordering to be the same as the input
from qiskit.converters import circuit_to_dag
temp_dag = circuit_to_dag(qiskit_qc)
for node in list(temp_dag.topological_op_nodes())[::-1]:
if node.name == "swap":
qiskit_qc.append(node.op, node.qargs)
print(Operator(qiskit_qc).equiv(qc))
qiskit_qc.draw("mpl")
# make sure the old sabre python code works with our new qiskit version
from qiskit.transpiler.passes import Optimize1qGates
pm = PassManager()
routing = CNS_SabreSwap(coupling, heuristic="lookahead")
# pm.append(SabreLayout(coupling, routing_pass=routing))
# pm.append(TrivialLayout(coupling))
pm.append(SetLayout(layout))
pm.append([FullAncillaAllocation(coupling), EnlargeWithAncilla(), ApplyLayout()])
pm.append(routing)
pm.append(Unroller(["u", "cx", "iswap", "swap"]))
pm.append(Optimize1qGates(["u", "cx", "iswap", "swap"]))
# pm.append(Unroller(["u", "cx", "iswap", "swap"]))
qc_swapped = pm.run(qc)
print(pm.property_set["accepted_subs"])
qc_swapped.draw("mpl")
# for every swap gate, append a swap gate to the end of the circuit
# this forces the qubit register ordering to be the same as the input
from qiskit.converters import circuit_to_dag
from qiskit.circuit.library import SwapGate
temp_dag = circuit_to_dag(qc_swapped)
for node in list(temp_dag.topological_op_nodes())[::-1]:
if node.name == "swap" or node.name == "iswap":
qc_swapped.append(SwapGate(), node.qargs)
print(Operator(qc_swapped).equiv(qc))
qc_swapped.draw("mpl")
snapshots = pm.property_set["mapped_dag_snaps"]
for snap in snapshots:
display(snap)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
qc.draw('mpl')
|
https://github.com/MonitSharma/Qiskit-Summer-School-and-Quantum-Challenges
|
MonitSharma
|
%set_env QC_GRADE_ONLY=true
from qiskit.circuit import QuantumCircuit
from qiskit.primitives import Estimator, Sampler
from qiskit.quantum_info import SparsePauliOp
from qiskit.visualization import plot_histogram
import numpy as np
import matplotlib.pyplot as plt
plt.style.use('dark_background') # optional
# create excited |1> state
qc_1 = QuantumCircuit(1)
qc_1.x(0)
qc_1.draw('mpl')
# create superposition |+> state
qc_plus = QuantumCircuit(1)
qc_plus.h(0)
qc_plus.draw('mpl')
qc_1.measure_all()
qc_plus.measure_all()
sampler = Sampler()
job_1 = sampler.run(qc_1)
job_plus = sampler.run(qc_plus)
job_1.result().quasi_dists
job_plus.result().quasi_dists
legend = ["Excited State", "Plus State"] # TODO: Excited State does not appear
plot_histogram([job_1.result().quasi_dists[0], job_plus.result().quasi_dists[0]], legend=legend)
qc_1.remove_final_measurements()
qc_plus.remove_final_measurements()
# rotate into the X-basis
qc_1.h(0)
qc_plus.h(0)
qc_1.measure_all()
qc_plus.measure_all()
sampler = Sampler()
job_1 = sampler.run(qc_1)
job_plus = sampler.run(qc_plus)
plot_histogram([job_1.result().quasi_dists[0], job_plus.result().quasi_dists[0]], legend=legend)
qc2_1 = QuantumCircuit(1)
qc2_1.x(0)
qc2_plus = QuantumCircuit(1)
qc2_plus.h(0)
obsvs = list(SparsePauliOp(['Z', 'X']))
estimator = Estimator()
job2_1 = estimator.run([qc2_1]*len(obsvs), observables=obsvs)
job2_plus = estimator.run([qc2_plus]*len(obsvs), observables=obsvs)
job2_1.result()
# TODO: make this into module that outputs a nice table
print(f' | <Z> | <X> ')
print(f'----|------------------')
print(f'|1> | {job2_1.result().values[0]} | {job2_1.result().values[1]}')
print(f'|+> | {job2_plus.result().values[0]} | {job2_plus.result().values[1]}')
# this is a correct answer:
obsv = SparsePauliOp('X').tensor(SparsePauliOp(['X', 'Z'], coeffs=[1, -1])) + SparsePauliOp('Z').tensor(SparsePauliOp(['X', 'Z'], coeffs=[1, 1]))
from qc_grader.challenges.qgss_2023 import grade_lab2_ex1
grade_lab2_ex1(obsv)
from qiskit.circuit import Parameter
theta = Parameter('θ')
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.ry(theta, 0)
qc.draw('mpl')
# this is a correct answer
num_params = 21
angles=[[angle] for angle in np.linspace(-np.pi, np.pi, num_params)]
estimator = Estimator()
job = estimator.run([qc]*len(angles), observables=[obsv]*len(angles), parameter_values=angles)
exps = job.result().values
plt.plot(angles, exps, marker='x', ls='-', color='green')
plt.plot(angles, [2]*len(angles), ls='--', color='red', label='Classical Bound')
plt.plot(angles, [-2]*len(angles), ls='--', color='red')
plt.xlabel('angle (rad)')
plt.ylabel('CHSH Witness')
plt.legend(loc=4)
from qc_grader.challenges.qgss_2023 import grade_lab2_ex2
grade_lab2_ex2(obsv, angles)
from qiskit.circuit import ClassicalRegister, QuantumRegister
theta = Parameter('θ')
qr = QuantumRegister(1, 'q')
qc = QuantumCircuit(qr)
qc.ry(theta, 0)
qc.draw('mpl')
tele_qc = qc.copy()
bell = QuantumRegister(2, 'Bell')
alice = ClassicalRegister(2, 'Alice')
bob = ClassicalRegister(1, 'Bob')
tele_qc.add_register(bell, alice, bob)
tele_qc.draw('mpl')
# create Bell state with other two qubits
tele_qc.barrier()
tele_qc.h(1)
tele_qc.cx(1, 2)
tele_qc.barrier()
tele_qc.draw('mpl')
# alice operates on her qubits
tele_qc.cx(0, 1)
tele_qc.h(0)
tele_qc.barrier()
tele_qc.draw('mpl')
tele_qc.measure([qr[0], bell[0]], alice)
tele_qc.draw('mpl')
# either pairs are correct
# tele_qc.x(2).c_if(alice[1], 1)
# tele_qc.z(2).c_if(alice[0], 1)
with tele_qc.if_test((alice[1], 1)):
tele_qc.x(2)
with tele_qc.if_test((alice[0], 1)):
tele_qc.z(2)
tele_qc.draw('mpl')
tele_qc.barrier()
tele_qc.measure(bell[1], bob)
tele_qc.draw('mpl')
from qc_grader.challenges.qgss_2023 import grade_lab2_ex3
grade_lab2_ex3(tele_qc, theta, 5*np.pi/7)
from qiskit_aer.primitives import Sampler
angle = 5*np.pi/7
sampler = Sampler()
qc.measure_all()
job_static = sampler.run(qc.bind_parameters({theta: angle}))
job_dynamic = sampler.run(tele_qc.bind_parameters({theta: angle}))
print(f"Original Dists: {job_static.result().quasi_dists[0].binary_probabilities()}")
print(f"Teleported Dists: {job_dynamic.result().quasi_dists[0].binary_probabilities()}")
from qiskit.result import marginal_counts
# this is correct
tele_counts = marginal_counts(job_dynamic.result().quasi_dists[0].binary_probabilities(), indices=[2])
legend = ['Original State', 'Teleported State']
plot_histogram([job_static.result().quasi_dists[0].binary_probabilities(), tele_counts], legend=legend)
from qc_grader.challenges.qgss_2023 import grade_lab2_ex4
grade_lab2_ex4(tele_counts, job_dynamic.result().quasi_dists[0])
import qiskit.tools.jupyter
%qiskit_version_table
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from sklearn.datasets import make_blobs
# example dataset
features, labels = make_blobs(n_samples=20, n_features=2, centers=2, random_state=3, shuffle=True)
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
features = MinMaxScaler(feature_range=(0, np.pi)).fit_transform(features)
train_features, test_features, train_labels, test_labels = train_test_split(
features, labels, train_size=15, shuffle=False
)
# number of qubits is equal to the number of features
num_qubits = 2
# number of steps performed during the training procedure
tau = 100
# regularization parameter
C = 1000
from qiskit import BasicAer
from qiskit.circuit.library import ZFeatureMap
from qiskit.utils import algorithm_globals
from qiskit_machine_learning.kernels import FidelityQuantumKernel
algorithm_globals.random_seed = 12345
feature_map = ZFeatureMap(feature_dimension=num_qubits, reps=1)
qkernel = FidelityQuantumKernel(feature_map=feature_map)
from qiskit_machine_learning.algorithms import PegasosQSVC
pegasos_qsvc = PegasosQSVC(quantum_kernel=qkernel, C=C, num_steps=tau)
# training
pegasos_qsvc.fit(train_features, train_labels)
# testing
pegasos_score = pegasos_qsvc.score(test_features, test_labels)
print(f"PegasosQSVC classification test score: {pegasos_score}")
grid_step = 0.2
margin = 0.2
grid_x, grid_y = np.meshgrid(
np.arange(-margin, np.pi + margin, grid_step), np.arange(-margin, np.pi + margin, grid_step)
)
meshgrid_features = np.column_stack((grid_x.ravel(), grid_y.ravel()))
meshgrid_colors = pegasos_qsvc.predict(meshgrid_features)
import matplotlib.pyplot as plt
plt.figure(figsize=(5, 5))
meshgrid_colors = meshgrid_colors.reshape(grid_x.shape)
plt.pcolormesh(grid_x, grid_y, meshgrid_colors, cmap="RdBu", shading="auto")
plt.scatter(
train_features[:, 0][train_labels == 0],
train_features[:, 1][train_labels == 0],
marker="s",
facecolors="w",
edgecolors="r",
label="A train",
)
plt.scatter(
train_features[:, 0][train_labels == 1],
train_features[:, 1][train_labels == 1],
marker="o",
facecolors="w",
edgecolors="b",
label="B train",
)
plt.scatter(
test_features[:, 0][test_labels == 0],
test_features[:, 1][test_labels == 0],
marker="s",
facecolors="r",
edgecolors="r",
label="A test",
)
plt.scatter(
test_features[:, 0][test_labels == 1],
test_features[:, 1][test_labels == 1],
marker="o",
facecolors="b",
edgecolors="b",
label="B test",
)
plt.legend(bbox_to_anchor=(1.05, 1), loc="upper left", borderaxespad=0.0)
plt.title("Pegasos Classification")
plt.show()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 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.
"""Tests for pass cancelling 2 consecutive CNOTs on the same qubits."""
from qiskit import QuantumRegister, QuantumCircuit
from qiskit.circuit import Clbit, Qubit
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import CXCancellation
from qiskit.test import QiskitTestCase
class TestCXCancellation(QiskitTestCase):
"""Test the CXCancellation pass."""
def test_pass_cx_cancellation(self):
"""Test the cx cancellation pass.
It should cancel consecutive cx pairs on same qubits.
"""
qr = QuantumRegister(2)
circuit = QuantumCircuit(qr)
circuit.h(qr[0])
circuit.h(qr[0])
circuit.cx(qr[0], qr[1])
circuit.cx(qr[0], qr[1])
circuit.cx(qr[0], qr[1])
circuit.cx(qr[0], qr[1])
circuit.cx(qr[1], qr[0])
circuit.cx(qr[1], qr[0])
pass_manager = PassManager()
pass_manager.append(CXCancellation())
out_circuit = pass_manager.run(circuit)
expected = QuantumCircuit(qr)
expected.h(qr[0])
expected.h(qr[0])
self.assertEqual(out_circuit, expected)
def test_pass_cx_cancellation_intermixed_ops(self):
"""Cancellation shouldn't be affected by the order of ops on different qubits."""
qr = QuantumRegister(4)
circuit = QuantumCircuit(qr)
circuit.h(qr[0])
circuit.h(qr[1])
circuit.cx(qr[0], qr[1])
circuit.cx(qr[2], qr[3])
circuit.cx(qr[0], qr[1])
circuit.cx(qr[2], qr[3])
pass_manager = PassManager()
pass_manager.append(CXCancellation())
out_circuit = pass_manager.run(circuit)
expected = QuantumCircuit(qr)
expected.h(qr[0])
expected.h(qr[1])
self.assertEqual(out_circuit, expected)
def test_pass_cx_cancellation_chained_cx(self):
"""Include a test were not all operations can be cancelled."""
# ┌───┐
# q0_0: ┤ H ├──■─────────■───────
# ├───┤┌─┴─┐ ┌─┴─┐
# q0_1: ┤ H ├┤ X ├──■──┤ X ├─────
# └───┘└───┘┌─┴─┐└───┘
# q0_2: ──────────┤ X ├──■────■──
# └───┘┌─┴─┐┌─┴─┐
# q0_3: ───────────────┤ X ├┤ X ├
# └───┘└───┘
qr = QuantumRegister(4)
circuit = QuantumCircuit(qr)
circuit.h(qr[0])
circuit.h(qr[1])
circuit.cx(qr[0], qr[1])
circuit.cx(qr[1], qr[2])
circuit.cx(qr[0], qr[1])
circuit.cx(qr[2], qr[3])
circuit.cx(qr[2], qr[3])
pass_manager = PassManager()
pass_manager.append(CXCancellation())
out_circuit = pass_manager.run(circuit)
# ┌───┐
# q0_0: ┤ H ├──■─────────■──
# ├───┤┌─┴─┐ ┌─┴─┐
# q0_1: ┤ H ├┤ X ├──■──┤ X ├
# └───┘└───┘┌─┴─┐└───┘
# q0_2: ──────────┤ X ├─────
# └───┘
# q0_3: ────────────────────
expected = QuantumCircuit(qr)
expected.h(qr[0])
expected.h(qr[1])
expected.cx(qr[0], qr[1])
expected.cx(qr[1], qr[2])
expected.cx(qr[0], qr[1])
self.assertEqual(out_circuit, expected)
def test_swapped_cx(self):
"""Test that CX isn't cancelled if there are intermediary ops."""
qr = QuantumRegister(4)
circuit = QuantumCircuit(qr)
circuit.cx(qr[1], qr[0])
circuit.swap(qr[1], qr[2])
circuit.cx(qr[1], qr[0])
pass_manager = PassManager()
pass_manager.append(CXCancellation())
out_circuit = pass_manager.run(circuit)
self.assertEqual(out_circuit, circuit)
def test_inverted_cx(self):
"""Test that CX order dependence is respected."""
qr = QuantumRegister(4)
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.cx(qr[1], qr[0])
circuit.cx(qr[0], qr[1])
pass_manager = PassManager()
pass_manager.append(CXCancellation())
out_circuit = pass_manager.run(circuit)
self.assertEqual(out_circuit, circuit)
def test_if_else(self):
"""Test that the pass recurses in a simple if-else."""
pass_ = CXCancellation()
inner_test = QuantumCircuit(4, 1)
inner_test.cx(0, 1)
inner_test.cx(0, 1)
inner_test.cx(2, 3)
inner_expected = QuantumCircuit(4, 1)
inner_expected.cx(2, 3)
test = QuantumCircuit(4, 1)
test.h(0)
test.measure(0, 0)
test.if_else((0, True), inner_test.copy(), inner_test.copy(), range(4), [0])
expected = QuantumCircuit(4, 1)
expected.h(0)
expected.measure(0, 0)
expected.if_else((0, True), inner_expected, inner_expected, range(4), [0])
self.assertEqual(pass_(test), expected)
def test_nested_control_flow(self):
"""Test that collection recurses into nested control flow."""
pass_ = CXCancellation()
qubits = [Qubit() for _ in [None] * 4]
clbit = Clbit()
inner_test = QuantumCircuit(qubits, [clbit])
inner_test.cx(0, 1)
inner_test.cx(0, 1)
inner_test.cx(2, 3)
inner_expected = QuantumCircuit(qubits, [clbit])
inner_expected.cx(2, 3)
true_body = QuantumCircuit(qubits, [clbit])
true_body.while_loop((clbit, True), inner_test.copy(), [0, 1, 2, 3], [0])
test = QuantumCircuit(qubits, [clbit])
test.for_loop(range(2), None, inner_test.copy(), [0, 1, 2, 3], [0])
test.if_else((clbit, True), true_body, None, [0, 1, 2, 3], [0])
expected_if_body = QuantumCircuit(qubits, [clbit])
expected_if_body.while_loop((clbit, True), inner_expected, [0, 1, 2, 3], [0])
expected = QuantumCircuit(qubits, [clbit])
expected.for_loop(range(2), None, inner_expected, [0, 1, 2, 3], [0])
expected.if_else((clbit, True), expected_if_body, None, [0, 1, 2, 3], [0])
self.assertEqual(pass_(test), expected)
|
https://github.com/ka-us-tubh/quantum-computing-qiskit-
|
ka-us-tubh
|
import numpy as np
# Importing standard Qiskit libraries
from qiskit import *
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from ibm_quantum_widgets import *
from qiskit.providers.aer import QasmSimulator
from qiskit.extensions import Initialize
from qiskit_textbook.tools import random_state
# Loading your IBM Quantum account(s)
provider = IBMQ.load_account()
qr =QuantumRegister(3,name='q')
crz=ClassicalRegister(1,name='crz')
crx =ClassicalRegister(1,name='crx')
qc=QuantumCircuit(qr,crz,crx)
def create_bell_pair(qc,a,b):
qc.h(a)
qc.cx(a,b)
def alice_gates(qc,psi,a):
qc.cx(psi,a)
qc.h(psi)
def measure_and_send(qr,a,b):
qc.barrier()
qc.measure(a,0)
qc.measure(b,1)
def bob_gates(qc,qubit,crz,crx):
qc.x(qubit).c_if(crx,1)
qc.z(qubit).c_if(crz,1)
psi =random_state(1)
display(array_to_latex(psi,prefix="|\\psi\\rangle="))
plot_bloch_multivector(psi)
init_gate=Initialize(psi)
init_gate.label='init'
qc.append(init_gate,[0])
qc.barrier()
create_bell_pair(qc,1,2)
qc.barrier()
alice_gates(qc,0,1)
measure_and_send(qc,0,1)
bob_gates(qc,2,crz,crx)
qc.draw()
sim=Aer.get_backend('aer_simulator')
qc.save_statevector()
out_vector=sim.run(qc).result().get_statevector()
plot_bloch_multivector(out_vector)
#usinng qasm sim
inverse_init_gate=init_gate.gates_to_uncompute()
qc.append(init_gate,[0])
qc.barrier()
create_bell_pair(qc,1,2)
qc.barrier()
alice_gates(qc,0,1)
measure_and_send(qc,0,1)
bob_gates(qc,2,crz,crx)
qc.append(inverse_init_gate,[2])
cr_result=ClassicalRegister(1)
qc.add_register(cr_result)
qc.measure(2,2)
qc.draw()
t_qc=transpile(qc,sim)
t_qc.save_statevector()
counts =sim.run(t_qc).result().get_counts()
plot_histogram(counts)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, transpile
from qiskit.visualization import plot_circuit_layout
from qiskit.providers.fake_provider import FakeVigo
backend = FakeVigo()
ghz = QuantumCircuit(3, 3)
ghz.h(0)
ghz.cx(0,range(1,3))
ghz.barrier()
ghz.measure(range(3), range(3))
new_circ_lv0 = transpile(ghz, backend=backend, optimization_level=0)
plot_circuit_layout(new_circ_lv0, backend)
|
https://github.com/shantomborah/Quantum-Algorithms
|
shantomborah
|
import numpy as np
from math import pi
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import Aer, execute
from qiskit.circuit import Gate
from qiskit.visualization import plot_histogram
from qiskit.circuit.library.standard_gates import ZGate, XGate
# Define circuit parameters
a = '10x01xx'
n = len(a)
k = 7
circ = QuantumCircuit(k+n, k)
circ.reset(range(k+n))
circ.h(range(k+n))
circ.barrier()
for i in range(k):
name = '$G_' + str(i) + '$'
circ.append(QuantumCircuit(n, name=name).to_gate().control(1), [n+i]+list(range(n)))
circ.barrier()
circ.append(Gate(name="$QFT^{-1}$", num_qubits=k, params=[]), range(n, k+n))
circ.barrier()
circ.measure(range(n, k+n), range(k))
circ.draw('mpl', reverse_bits=True, scale=0.5)
def Gop(j):
p = 2 ** j
ctrl_bits = []
ctrl_state = ''
for i in range(n):
if a[n-i-1] != 'x':
ctrl_bits.append(i+1)
ctrl_state += a[n-i-1]
G = QuantumCircuit(n+1, name='G'+str(j))
for i in range(p):
G.append(XGate().control(len(ctrl_bits), ctrl_state=ctrl_state[::-1]), ctrl_bits + [0])
G.h(range(1, n+1))
G.x(range(1, n+1))
G.append(ZGate().control(n-1), reversed(range(1, n+1)))
G.x(range(1, n+1))
G.h(range(1, n+1))
return G
Gop(3).draw('mpl', reverse_bits=True, scale=0.5)
QFT_inv = QuantumCircuit(k, name='QFT^{-1}')
for i in reversed(range(k)):
if i != k-1:
QFT_inv.barrier()
for j in reversed(range(i+1,k)):
QFT_inv.cu1(-pi/(2 ** (j-i)), i, j)
QFT_inv.h(i)
QFT_inv.draw('mpl', reverse_bits=True)
circ = QuantumCircuit(k+n+1, k)
circ.reset(range(k+n+1))
circ.x(0)
circ.h(range(k+n+1))
circ.z(n+1)
circ.barrier()
for i in range(k):
circ.append(Gop(i).to_gate().control(1), [n+i+1]+list(range(n+1)))
circ.barrier()
circ.append(QFT_inv, range(n+1, k+n+1))
circ.barrier()
circ.measure(range(n+1, k+n+1), range(k))
circ.draw(reverse_bits=True, scale=0.5)
delta = 64
simulator = Aer.get_backend('qasm_simulator')
result = execute(circ, simulator, shots=delta).result()
counts = result.get_counts(circ)
plot_histogram(counts)
x = list(counts.keys())
x = [pi*int(i[::-1], 2)/(2 ** k) for i in x]
p = list(counts.values())
p = p.index(max(p))
theta = min(x[p], pi-x[p])
m_estimate = (2 ** n) * (theta ** 2)
m = 2 ** a.count('x')
print('Estimated Count:')
print(m_estimate)
print('Actual Count:')
print(m)
|
https://github.com/ctuning/ck-qiskit
|
ctuning
|
#!/usr/bin/env python3
import qiskit.tools.apps.optimization
num_of_qubits = 2
circuit_depth = 6
num_params = 2 * num_of_qubits * circuit_depth # make sure you set this correctly to the number of parameters used by the ansatz
## Previously used for Hydrogen VQE in QISKit implementation
#
def universal_ansatz(current_params, entangler_map=None):
if entangler_map==None:
# Which qubits to use (0 to 1 best to avoid qiskit bugs)
entangler_map = {1: [0]}
return qiskit.tools.apps.optimization.trial_circuit_ryrz(num_of_qubits, circuit_depth, current_params, entangler_map, None, False)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.quantum_info import SparsePauliOp
H2_op = SparsePauliOp.from_list(
[
("II", -1.052373245772859),
("IZ", 0.39793742484318045),
("ZI", -0.39793742484318045),
("ZZ", -0.01128010425623538),
("XX", 0.18093119978423156),
]
)
from qiskit.primitives import Estimator
estimator = Estimator()
import numpy as np
from qiskit.algorithms.minimum_eigensolvers import VQE
from qiskit.algorithms.optimizers import COBYLA, L_BFGS_B, SLSQP
from qiskit.circuit.library import TwoLocal
from qiskit.utils import algorithm_globals
# we will iterate over these different optimizers
optimizers = [COBYLA(maxiter=80), L_BFGS_B(maxiter=60), SLSQP(maxiter=60)]
converge_counts = np.empty([len(optimizers)], dtype=object)
converge_vals = np.empty([len(optimizers)], dtype=object)
for i, optimizer in enumerate(optimizers):
print("\rOptimizer: {} ".format(type(optimizer).__name__), end="")
algorithm_globals.random_seed = 50
ansatz = TwoLocal(rotation_blocks="ry", entanglement_blocks="cz")
counts = []
values = []
def store_intermediate_result(eval_count, parameters, mean, std):
counts.append(eval_count)
values.append(mean)
vqe = VQE(estimator, ansatz, optimizer, callback=store_intermediate_result)
result = vqe.compute_minimum_eigenvalue(operator=H2_op)
converge_counts[i] = np.asarray(counts)
converge_vals[i] = np.asarray(values)
print("\rOptimization complete ");
import pylab
pylab.rcParams["figure.figsize"] = (12, 8)
for i, optimizer in enumerate(optimizers):
pylab.plot(converge_counts[i], converge_vals[i], label=type(optimizer).__name__)
pylab.xlabel("Eval count")
pylab.ylabel("Energy")
pylab.title("Energy convergence for various optimizers")
pylab.legend(loc="upper right");
from qiskit.algorithms.minimum_eigensolvers import NumPyMinimumEigensolver
from qiskit.opflow import PauliSumOp
numpy_solver = NumPyMinimumEigensolver()
result = numpy_solver.compute_minimum_eigenvalue(operator=PauliSumOp(H2_op))
ref_value = result.eigenvalue.real
print(f"Reference value: {ref_value:.5f}")
pylab.rcParams["figure.figsize"] = (12, 8)
for i, optimizer in enumerate(optimizers):
pylab.plot(
converge_counts[i],
abs(ref_value - converge_vals[i]),
label=type(optimizer).__name__,
)
pylab.xlabel("Eval count")
pylab.ylabel("Energy difference from solution reference value")
pylab.title("Energy convergence for various optimizers")
pylab.yscale("log")
pylab.legend(loc="upper right");
from qiskit.algorithms.gradients import FiniteDiffEstimatorGradient
estimator = Estimator()
gradient = FiniteDiffEstimatorGradient(estimator, epsilon=0.01)
algorithm_globals.random_seed = 50
ansatz = TwoLocal(rotation_blocks="ry", entanglement_blocks="cz")
optimizer = SLSQP(maxiter=100)
counts = []
values = []
def store_intermediate_result(eval_count, parameters, mean, std):
counts.append(eval_count)
values.append(mean)
vqe = VQE(
estimator, ansatz, optimizer, callback=store_intermediate_result, gradient=gradient
)
result = vqe.compute_minimum_eigenvalue(operator=H2_op)
print(f"Value using Gradient: {result.eigenvalue.real:.5f}")
pylab.rcParams["figure.figsize"] = (12, 8)
pylab.plot(counts, values, label=type(optimizer).__name__)
pylab.xlabel("Eval count")
pylab.ylabel("Energy")
pylab.title("Energy convergence using Gradient")
pylab.legend(loc="upper right");
print(result)
cost_function_evals = result.cost_function_evals
initial_pt = result.optimal_point
estimator1 = Estimator()
gradient1 = FiniteDiffEstimatorGradient(estimator, epsilon=0.01)
ansatz1 = TwoLocal(rotation_blocks="ry", entanglement_blocks="cz")
optimizer1 = SLSQP(maxiter=1000)
vqe1 = VQE(
estimator1, ansatz1, optimizer1, gradient=gradient1, initial_point=initial_pt
)
result1 = vqe1.compute_minimum_eigenvalue(operator=H2_op)
print(result1)
cost_function_evals1 = result1.cost_function_evals
print()
print(
f"cost_function_evals is {cost_function_evals1} with initial point versus {cost_function_evals} without it."
)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/vandnaChaturvedi/Qauntum_algorithms_Qiskit
|
vandnaChaturvedi
|
#from qiskit_textbook.widgets import dj_widget
#dj_widget(size="small", case="balanced")
# initialization
####################################################################################################################### qiskit_edit_1
from qiskit import QuantumCircuit, execute
from qiskit import QuantumRegister, ClassicalRegister
from qiskit.tools.monitor import job_monitor
from qiskit import *
import time
import matplotlib.pyplot as plt
import argparse
import sys
from concurrent.futures import ThreadPoolExecutor
import resource
from time import sleep
#########################################################################################################################
import numpy as np
options = {
'plot': True,
"rotation_error": {'rx':[0.7, 0.5], 'ry':[0.7, 0.4], 'rz':[0.5, 0.5]},
"tsp_model_error": [0.5, 0.8],
"thermal_factor": 0.7,
"decoherence_factor": 0.8,
"depolarization_factor": 0.5,
"bell_depolarization_factor": 0.4,
"decay_factor": 0.6,
}
# importing Qiskit
#from qiskit import IBMQ, Aer
#from qiskit.providers.ibmq import least_busy
#from qiskit import QuantumCircuit, assemble, transpile
# import basic plot tools
from qiskit.visualization import plot_histogram
# set the length of the n-bit input string.
n = 3
const_oracle = QuantumCircuit(n+1)
output = np.random.randint(2)
if output == 1:
const_oracle.x(n)
const_oracle.draw()
balanced_oracle = QuantumCircuit(n+1)
b_str = "101"
balanced_oracle = QuantumCircuit(n+1)
b_str = "101"
# Place X-gates
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
balanced_oracle.x(qubit)
balanced_oracle.draw()
balanced_oracle = QuantumCircuit(n+1)
b_str = "101"
# Place X-gates
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
balanced_oracle.x(qubit)
# Use barrier as divider
balanced_oracle.barrier()
# Controlled-NOT gates
for qubit in range(n):
balanced_oracle.cx(qubit, n)
balanced_oracle.barrier()
balanced_oracle.draw()
balanced_oracle = QuantumCircuit(n+1)
b_str = "101"
# Place X-gates
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
balanced_oracle.x(qubit)
# Use barrier as divider
balanced_oracle.barrier()
# Controlled-NOT gates
for qubit in range(n):
balanced_oracle.cx(qubit, n)
balanced_oracle.barrier()
# Place X-gates
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
balanced_oracle.x(qubit)
# Show oracle
balanced_oracle.draw()
dj_circuit = QuantumCircuit(n+1, n+1)
# Apply H-gates
for qubit in range(n):
dj_circuit.h(qubit)
# Put qubit in state |->
dj_circuit.x(n)
dj_circuit.h(n)
dj_circuit.draw()
dj_circuit = QuantumCircuit(n+1, n+1)
# Apply H-gates
for qubit in range(n):
dj_circuit.h(qubit)
# Put qubit in state |->
dj_circuit.x(n)
dj_circuit.h(n)
# Add oracle
dj_circuit += balanced_oracle
dj_circuit.draw()
dj_circuit = QuantumCircuit(n+1, n+1)
# Apply H-gates
for qubit in range(n):
dj_circuit.h(qubit)
# Put qubit in state |->
dj_circuit.x(n)
dj_circuit.h(n)
# Add oracle
dj_circuit += balanced_oracle
# Repeat H-gates
for qubit in range(n):
dj_circuit.h(qubit)
dj_circuit.barrier()
# Measure
for i in range(n):
dj_circuit.measure(i, i, basis='Ensemble', add_param='Z')
# Display circuit
dj_circuit.draw()
# use local simulator
backend = qiskit.BasicAer.get_backend('dm_simulator')
# without noise
job = execute(dj_circuit, backend=backend, shots=1)
job_result = job.result()
#print(job_result['results'][0]['data']['densitymatrix'])
job_result['results'][0]['data']['ensemble_probability']
#with noise
job1 = execute(dj_circuit, backend=backend, backend_options=options, shots=1)
job_result1 = job1.result()
#print(job_result1['results'][0]['data']['densitymatrix'])
job_result1['results'][0]['data']['ensemble_probability']
no_noise=job_result['results'][0]['data']['ensemble_probability']
noisy=job_result1['results'][0]['data']['ensemble_probability']
labels = noisy.keys()
without_noise = no_noise.values()
with_noise = noisy.values()
x = np.arange(len(labels)) # the label locations
width = 0.35 # the width of the bars
fig, ax = plt.subplots()
rects1 = ax.bar(x - width/2, without_noise, width, label='Without Noise')
rects2 = ax.bar(x + width/2, with_noise, width, label='With Noise')
# Add some text for labels, title and custom x-axis tick labels, etc.
ax.set_ylabel('Probability')
ax.set_title('Ensemble Probabilities with Noise')
ax.set_xticks(x)
ax.set_xticklabels(labels)
ax.legend()
plt.show()
def dj_oracle(case, n):
# We need to make a QuantumCircuit object to return
# This circuit has n+1 qubits: the size of the input,
# plus one output qubit
oracle_qc = QuantumCircuit(n+1)
# First, let's deal with the case in which oracle is balanced
if case == "balanced":
# First generate a random number that tells us which CNOTs to
# wrap in X-gates:
b = np.random.randint(1,2**n)
# Next, format 'b' as a binary string of length 'n', padded with zeros:
b_str = format(b, '0'+str(n)+'b')
# Next, we place the first X-gates. Each digit in our binary string
# corresponds to a qubit, if the digit is 0, we do nothing, if it's 1
# we apply an X-gate to that qubit:
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
oracle_qc.x(qubit)
# Do the controlled-NOT gates for each qubit, using the output qubit
# as the target:
for qubit in range(n):
oracle_qc.cx(qubit, n)
# Next, place the final X-gates
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
oracle_qc.x(qubit)
# Case in which oracle is constant
if case == "constant":
# First decide what the fixed output of the oracle will be
# (either always 0 or always 1)
output = np.random.randint(2)
if output == 1:
oracle_qc.x(n)
oracle_gate = oracle_qc.to_gate()
oracle_gate.name = "Oracle" # To show when we display the circuit
return oracle_gate
def dj_algorithm(oracle, n):
dj_circuit = QuantumCircuit(n+1, n)
# Set up the output qubit:
dj_circuit.x(n)
dj_circuit.h(n)
# And set up the input register:
for qubit in range(n):
dj_circuit.h(qubit)
# Let's append the oracle gate to our circuit:
dj_circuit.append(oracle, range(n+1))
# Finally, perform the H-gates again and measure:
for qubit in range(n):
dj_circuit.h(qubit)
for i in range(n):
dj_circuit.measure(i, i, basis='Ensemble', add_param='Z')
return dj_circuit
n = 4
oracle_gate = dj_oracle('balanced', n)
dj_circuit = dj_algorithm(oracle_gate, n)
dj_circuit.draw()
##no_noise
backend = qiskit.BasicAer.get_backend('dm_simulator')
job = execute(dj_circuit, backend=backend, shots=1)
job_result = job.result()
#print(job_result['results'][0]['data']['densitymatrix'])
##noisy
job1 = execute(dj_circuit, backend=backend,backend_options=options, shots=1)
job_result1 = job1.result()
no_noise=job_result['results'][0]['data']['ensemble_probability']
noisy=job_result1['results'][0]['data']['ensemble_probability']
no_noise
#print(noisy)
#print(job_result1['results'][0]['data']['densitymatrix'])
##plot_histogram(answer) ###no histrogram because of single shot in DM simulator
noisy
no_noise=job_result['results'][0]['data']['ensemble_probability']
noisy=job_result1['results'][0]['data']['ensemble_probability']
labels = noisy.keys()
without_noise = no_noise.values()
with_noise = noisy.values()
x = np.arange(len(labels)) # the label locations
width = 0.5 # the width of the bars
fig, ax = plt.subplots()
rects1 = ax.bar(x - width/2, without_noise, width, label='Without Noise')
rects2 = ax.bar(x + width/2, with_noise, width, label='With Noise')
# Add some text for labels, title and custom x-axis tick labels, etc.
ax.set_ylabel('Probability')
ax.set_title('Ensemble Probabilities with Noise')
ax.set_xticks(x)
ax.set_xticklabels(labels)
ax.legend()
plt.show()
#plot_histogram(ax)
backend = qiskit.BasicAer.get_backend('dm_simulator')
# without noise
job = execute(dj_circuit, backend=backend, shots=1)
job_result = job.result()
#print(job_result['results'][0]['data']['densitymatrix'])
job_result['results'][0]['data']['ensemble_probability']
#with noise
job1 = execute(dj_circuit, backend=backend, backend_options=options, shots=1)
job_result1 = job1.result()
#print(job_result['results'][0]['data']['densitymatrix'])
job_result['results'][0]['data']['ensemble_probability']
job_result1['results'][0]['data']['ensemble_probability']
from qiskit.visualization import plot_state_city
%matplotlib inline
plot_state_city(job_result['results'][0]['data']['densitymatrix'], color=['midnightblue', 'midnightblue'],title="Density Matrix_no_noise")
from qiskit.visualization import plot_state_city
%matplotlib inline
plot_state_city(job_result1['results'][0]['data']['densitymatrix'], color=['midnightblue', 'midnightblue'],title="Density Matrix_no_noise")
plot_histogram(job_result['results'][0]['data']['ensemble_probability'], color='blue', title="No_noise")
plot_histogram(job_result1['results'][0]['data']['ensemble_probability'], color='coral', title="Noisy")
# Load our saved IBMQ accounts and get the least busy backend device with greater than or equal to (n+1) qubits
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
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)
# Run our circuit on the least busy backend. Monitor the execution of the job in the queue
from qiskit.tools.monitor import job_monitor
transpiled_dj_circuit = transpile(dj_circuit, backend, optimization_level=3)
job = backend.run(transpiled_dj_circuit)
job_monitor(job, interval=2)
# Get the results of the computation
results = job.result()
answer = results.get_counts()
plot_histogram(answer)
from qiskit_textbook.problems import dj_problem_oracle
oracle = dj_problem_oracle(1)
import qiskit.tools.jupyter
%qiskit_version_table
|
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/shesha-raghunathan/DATE2019-qiskit-tutorial
|
shesha-raghunathan
|
# import all necessary objects and methods for quantum circuits
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer
from qiskit.tools.visualization import matplotlib_circuit_drawer as drawer
#
# your solution is here
#
#
# your solution
#
#
# your code is here
#
|
https://github.com/InvictusWingsSRL/QiskitTutorials
|
InvictusWingsSRL
|
from qiskit import ClassicalRegister, QuantumRegister, QuantumCircuit, transpile
from qiskit_aer import Aer
from qiskit.primitives import BackendSampler
#from qiskit.extensions.simulator import snapshot
#from qiskit.tools.visualization import circuit_drawer
import numpy as np
import math as m
import scipy as sci
import random
import time
import matplotlib
import matplotlib.pyplot as plt
import ipywidgets as wd
S_simulator = Aer.backends(name='statevector_simulator')[0]
M_simulator = Aer.backends(name='qasm_simulator')[0]
def execute(circuit, backend, **kwargs):
s = 1024
if 'shots' in kwargs:
s = int( kwargs['shots'] )
new_circuit = transpile(circuit, backend)
return backend.run(new_circuit, shots = s)
#Displaying Results
def Wavefunction( obj , *args, **kwargs):
#Displays the wavefunction of the quantum system
if(type(obj) == QuantumCircuit ):
statevec = execute( obj, S_simulator, shots=1 ).result().get_statevector()
if(type(obj) == np.ndarray):
statevec = obj
sys = False
NL = False
dec = 5
if 'precision' in kwargs:
dec = int( kwargs['precision'] )
if 'column' in kwargs:
NL = kwargs['column']
if 'systems' in kwargs:
systems = kwargs['systems']
sys = True
last_sys = int(len(systems)-1)
show_systems = []
for s_chk in range(len(systems)):
if( type(systems[s_chk]) != int ):
raise Exception('systems must be an array of all integers')
if 'show_systems' in kwargs:
show_systems = kwargs['show_systems']
if( len(systems)!= len(show_systems) ):
raise Exception('systems and show_systems need to be arrays of equal length')
for ls in range(len(show_systems)):
if((show_systems[ls] != True) and (show_systems[ls] != False)):
raise Exception('show_systems must be an array of Truth Values')
if(show_systems[ls] == True):
last_sys = int(ls)
else:
for ss in range(len(systems)):
show_systems.append(True)
wavefunction = ''
qubits = int(m.log(len(statevec),2))
for i in range(int(len(statevec))):
#print(wavefunction)
value = round(statevec[i].real, dec) + round(statevec[i].imag, dec) * 1j
if( (value.real != 0) or (value.imag != 0)):
state = list(Binary(int(i),int(2**qubits)))
state.reverse()
state_str = ''
#print(state)
if( sys == True ): #Systems and SharSystems
k = 0
for s in range(len(systems)):
if(show_systems[s] == True):
if(int(s) != last_sys):
state.insert(int(k + systems[s]), '>|' )
k = int(k + systems[s] + 1)
else:
k = int(k + systems[s])
else:
for s2 in range(systems[s]):
del state[int(k)]
for j in range(len(state)):
if(type(state[j])!= str):
state_str = state_str + str(int(state[j]))
else:
state_str = state_str + state[j]
#print(state_str)
#print(value)
if( (value.real != 0) and (value.imag != 0) ):
if( value.imag > 0):
wavefunction = wavefunction + str(value.real) + '+' + str(value.imag) + 'j |' + state_str + '> '
else:
wavefunction = wavefunction + str(value.real) + '' + str(value.imag) + 'j |' + state_str + '> '
if( (value.real !=0 ) and (value.imag ==0) ):
wavefunction = wavefunction + str(value.real) + ' |' + state_str + '> '
if( (value.real == 0) and (value.imag != 0) ):
wavefunction = wavefunction + str(value.imag) + 'j |' + state_str + '> '
if(NL):
wavefunction = wavefunction + '\n'
#print(NL)
print(wavefunction)
return wavefunction
def Measurement(quantumcircuit, *args, **kwargs):
#Displays the measurement results of a quantum circuit
p_M = True
S = 1
ret = False
NL = False
if 'shots' in kwargs:
S = int(kwargs['shots'])
if 'return_M' in kwargs:
ret = kwargs['return_M']
if 'print_M' in kwargs:
p_M = kwargs['print_M']
if 'column' in kwargs:
NL = kwargs['column']
M1 = execute(quantumcircuit, M_simulator, shots=S).result().get_counts(quantumcircuit)
M2 = {}
k1 = list(M1.keys())
v1 = list(M1.values())
for k in range(len(k1)):
key_list = list(k1[k])
new_key = ''
for j in range(len(key_list)):
new_key = new_key+key_list[len(key_list)-(j+1)]
M2[new_key] = v1[k]
if(p_M):
k2 = list(M2.keys())
v2 = list(M2.values())
measurements = ''
for i in range(len(k2)):
m_str = str(v2[i])+'|'
for j in range(len(k2[i])):
if(k2[i][j] == '0'):
m_str = m_str + '0'
if(k2[i][j] == '1'):
m_str = m_str + '1'
if( k2[i][j] == ' ' ):
m_str = m_str +'>|'
m_str = m_str + '> '
if(NL):
m_str = m_str + '\n'
measurements = measurements + m_str
print(measurements)
if(ret):
return M2
def Most_Probable(M,N):
'''
Input: M (Dictionary) N (integer)
Returns the N most probable states accoding to the measurement counts stored in M
'''
count = []
state = []
if( len(M) < N ):
N = len(M)
for k in range(N):
count.append(0)
state.append(0)
for m in range(len(M)):
new = True
for n in range(N):
if( (list(M.values())[m] > count[n]) and new ):
for i in range( N-(n+1)):
count[-int(1+i)] = count[-int(1+i+1)]
state[-int(1+i)] = state[-int(1+i+1)]
count[int(n)] = list(M.values())[m]
state[int(n)] = list(M.keys())[m]
new = False
return count,state
#Math Operations
def Oplus(bit1,bit2):
'''Adds too bits of O's and 1's (modulo 2)'''
bit = np.zeros(len(bit1))
for i in range( len(bit) ):
if( (bit1[i]+bit2[i])%2 == 0 ):
bit[i] = 0
else:
bit[i] = 1
return bit
def Binary(number,total):
#Converts a number to binary, right to left LSB 152 153 o
qubits = int(m.log(total,2))
N = number
b_num = np.zeros(qubits)
for i in range(qubits):
if( N/((2)**(qubits-i-1)) >= 1 ):
b_num[i] = 1
N = N - 2 ** (qubits-i-1)
B = []
for j in range(len(b_num)):
B.append(int(b_num[j]))
return B
def BinaryL(number,total):
B = Binary(number, total)
B.reverse()
return B
def From_Binary(s):
num = 0
for i in range(len(s)):
num = num + int(s[-(i+1)]) * 2**i
return num
def From_BinaryLSB(S, LSB):
num = 0
for i in range(len(S)):
if(LSB=='R'):
num = num + int(S[-(i+1)]) * 2**i
elif(LSB=='L'):
num = num + int(S[i]) * 2**i
return num
def B2D(in_bi):
len_in = len(in_bi)
in_bi = in_bi[::-1]
dec = 0
for i in range(0,len_in):
if in_bi[i] != '0':
dec += 2**i
return dec
# Custom Gates
def X_Transformation(qc, qreg, state):
#Tranforms the state of the system, applying X gates according to as in the vector 'state'
for j in range(len(state)):
if( int(state[j]) == 0 ):
qc.x( qreg[int(j)] )
def n_NOT(qc, control, target, anc):
#performs an n-NOT gate
n = len(control)
instructions = []
active_ancilla = []
q_unused = []
q = 0
a = 0
while(n > 0):
if(n >= 2):
instructions.append( [control[q], control[q+1], anc[a]] )
active_ancilla.append(a)
a += 1
q += 2
n -= 2
if(n == 1):
q_unused.append(q)
n -= 1
while (len(q_unused) != 0):
if(len(active_ancilla)!=1):
instructions.append( [control[q], anc[active_ancilla[0]], anc[a]] )
del active_ancilla[0]
del q_unused[0]
active_ancilla.append(a)
a += 1
else:
instructions.append( [control[q], anc[active_ancilla[0]], target] )
del active_ancilla[0]
del q_unused[0]
while(len(active_ancilla) != 0):
if( len(active_ancilla) > 2 ):
instructions.append( [anc[active_ancilla[0]], anc[active_ancilla[1]], anc[a]] )
active_ancilla.append(a)
del active_ancilla[0]
del active_ancilla[0]
a += 1
elif( len(active_ancilla) == 2):
instructions.append([anc[active_ancilla[0]], anc[active_ancilla[1]], target])
del active_ancilla[0]
del active_ancilla[0]
elif( len(active_ancilla) == 1):
instructions.append([anc[active_ancilla[0]], target])
del active_ancilla[0]
for i in range( len(instructions) ):
if len(instructions[i]) == 2:
qc.cx( instructions[i][0], instructions[i][1])
else:
qc.ccx( instructions[i][0], instructions[i][1], instructions[i][2] )
del instructions[-1]
for i in range( len(instructions) ):
qc.ccx( instructions[0-(i+1)][0], instructions[0-(i+1)][1], instructions[0-(i+1)][2] )
def Control_Instruction( qc, vec ):
#Ammends the proper quantum circuit instruction based on the input 'vec'
#Used for the function 'n_Control_U
if( vec[0] == 'X' ):
qc.cx( vec[1], vec[2] )
elif( vec[0] == 'Z' ):
qc.cz( vec[1], vec[2] )
elif( vec[0] == 'CPHASE' ):
qc.cu1( vec[2], vec[1], vec[3] )
elif( vec[0] == 'SWAP' ):
qc.cswap( vec[1], vec[2], vec[3] )
def sinmons_solver(E,N):
'''Returns an array of s_prime candidates
'''
s_primes = []
for s in np.ararge(1,2**N):
sp = Binary( int(s), 2**N )
candidate = True
for e in range( len(E) ):
value = 0
for i in range( N ):
value = value + sp[i]*E[e][i]
if(value%2==1):
candidate=False
if(candidate):
s_primes.append(sp)
return s_primes
def Grover_Oracle(mark, qc, q, an1, an2):
'''
picks out the marked state and applies a negative phase
'''
qc.h( an1[0] )
X_Transformation(qc, q, mark)
if( len(mark) > 2 ):
n_NOT( qc, q, an1[0], an2 )
elif( len(mark) == 2 ):
qc.ccx( q[0], q[1], an1[0] )
X_Transformation(qc, q, mark)
qc.h( an1[0] )
def Grover_Diffusion(mark, qc, q, an1, an2):
'''
ammends the instructions for a Grover Diffusion Operation to the Quantum Circuit
'''
zeros_state = []
for i in range( len(mark) ):
zeros_state.append( 0 )
qc.h( q[int(i)] )
Grover_Oracle(zeros_state, qc, q, an1, an2)
for j in range( len(mark) ):
qc.h( q[int(j)] )
def Grover(Q, marked):
'''
Amends all the instructions for a Grover Search
'''
q = QuantumRegister(Q,name='q')
an1 = QuantumRegister(1,name='anc')
an2 = QuantumRegister(Q-2,name='nanc')
c = ClassicalRegister(Q,name='c')
qc = QuantumCircuit(q,an1,an2,c,name='qc')
for j in range(Q):
qc.h( q[int(j)] )
qc.x( an1[0] )
iterations = round( m.pi/4 * 2**(Q/2.0) )
for i in range( iterations ):
Grover_Oracle(marked, qc, q, an1, an2)
Grover_Diffusion(marked, qc, q, an1, an2)
return qc, q, an1, an2, c
def Multi_Grover(q, a1, a2, qc, marked, iters):
'''
Input: q (QuantumRegister) a1 (QuantumRegister) a2 (QuantumRegister) qc (QuantumCircuit)
marked (array) iters (integer)
Appends all of the gate operations for a multi-marked state Grover Search
'''
Q = int(len(marked))
for i in np.arange( iters ):
for j in np.arange(len(marked)):
M = list(marked[j])
for k in np.arange(len(M)):
if(M[k]=='1'):
M[k] = 1
else:
M[k] = 0
Grover_Oracle(M, qc, q, a1, a2)
Grover_Diffusion(M, qc, q, a1, a2)
return qc, q, a1, a2
def n_Control_U(qc, control, anc, gates):
#Performs a list of single control gates, as an n-control operation
instructions = []
active_ancilla = []
q_unused = []
n = len(control)
q = 0
a = 0
while(n > 0):
if(n >= 2) :
instructions.append([control[q], control[q+1], anc[a]])
active_ancilla.append(a)
a += 1
q += 2
n -= 2
if(n == 1):
q_unused.append( q )
n -= 1
while( len(q_unused) != 0 ) :
if(len(active_ancilla)>1):
instructions.append( [control[q] , anc[active_ancilla[0]], anc[a]])
del active_ancilla[0]
del q_unused[0]
active_ancilla.append(a)
a += 1
else:
instructions.append( [control[q] , anc[active_ancilla[0]], anc[a]])
del active_ancilla[0]
del q_unused[0]
c_a = anc[a]
while( len(active_ancilla) != 0 ) :
if( len(active_ancilla) > 2 ) :
instructions.append([anc[active_ancilla[0]], anc[active_ancilla[1]], anc[a]])
active_ancilla.append(a)
del active_ancilla[0]
del active_ancilla[0]
a += 1
elif( len(active_ancilla)==2):
instructions.append([anc[active_ancilla[0]], anc[active_ancilla[1]], anc[a]])
del active_ancilla[0]
del active_ancilla[0]
c_a = anc[a]
elif( len(active_ancilla)==1):
c_a = anc[active_ancilla[0]]
del active_ancilla[0]
for i in range( len(instructions) ) :
qc.ccx(instructions[i][0], instructions[i][1], instructions[i][2])
for j in range(len(gates)):
control_vec = [gates[j][0], c_a]
for k in range( 1, len(gates[j])):
control_vec.append( gates[j][k] )
Control_Instruction( qc, control_vec )
for i in range( len(instructions) ) :
qc.ccx(instructions[0-(i+1)][0],instructions[0-(i+1)][1], instructions[0-(i+1)][2])
def Control_Instructions(qc, vec):
if (vec[0] == 'X'):
qc.cx(vec[1], vec[2])
elif (vec[0] == 'Z'):
qc.cz(vec[1], vec[2])
def Blackbox_g_D(qc, qreg):
f_type=['f(0,1) -> (0,1)', 'f(0,1) -> (1,0)', 'f(0,1) -> 0', 'f(0,1) -> 1']
r = int(m.floor(4*np.random.rand()))
if (r == 0):
qc.cx(qreg[0],qreg[1])
if (r == 1):
qc.x(qreg[0])
qc.cx(qreg[0],qreg[1])
qc.x(qreg[0])
if (r == 2):
qc.id(qreg[0])
qc.id(qreg[1])
if (r == 3):
qc.x(qreg[1])
return f_type[r]
def Deutsch(qc,qreg):
qc.h(qreg[0])
qc.h(qreg[1])
f = Blackbox_g_D(qc, qreg)
qc.h(qreg[0])
qc.h(qreg[1])
return f
def Blackbox_g_DJ(Q, qc, qreg, an1):
f_type=['constant','balanced']
f=[]
r=int(m.floor(2**Q*np.random.rand()))
if r==0:
f.append(f_type[0])
elif r == 1:
qc.x(qreg[Q-1])
f.append(f_type[0])
else:
control = []
for i in range(Q):
control.append(qreg[i])
an2 = QuantumRegister(int(Q-2), name='nn_anc')
qc.add_register(an2)
f.append(f_type[1])
S=[]
for s in range(2**Q):
S.append(s)
for k in range(2**(Q-1)):
S_num = S[int(m.floor(len(S)*np.random.rand()))]
state = Binary(S_num,2**Q)
S.remove(S_num)
f_string = '|'
for j in range(len(state)):
f_string += str(int(state[j]))
if (state[j] == 0):
qc.x(qreg[j])
f.append(f_string + '>')
n_NOT(qc, control, an1[0], an2)
for j in range(len(state)):
if (state[j] == 0):
qc.x(qreg[j])
return f
def Deutsch_Josza(Q,qc,qreg,an1):
for i in range(Q):
qc.h(qreg[i])
qc.h(an1[0])
f = Blackbox_g_DJ(Q, qc, qreg, an1)
for i in range(Q):
qc.h(qreg[i])
qc.h(an1[0])
return f
def Blackbox_g_BV(Q,qc,qreg,an1):
a = Binary(int(m.floor(2**Q*np.random.rand())),2**Q)
control=[]
for i in range(Q):
control.append(qreg[i])
an2 = QuantumRegister(Q-2,name='nn_anc')
qc.add_register(an2)
for s in range(2**Q):
state = Binary(s,2**Q)
dp = np.vdot(a, state)
if (dp % 2 == 1):
for j in range(len(state)):
if int(state[j]) == 0:
qc.x(qreg[j])
n_NOT(qc, control, an1[0], an2)
for j in range(len(state)):
if int(state[j]) == 0:
qc.x(qreg[j])
return a
def Bernstein_Vazirani(Q,qc,qreg,an1):
for i in range(Q):
qc.h(qreg[i])
qc.h(an1[0])
a = Blackbox_g_BV(Q,qc,qreg,an1)
for i in range(Q):
qc.h(qreg[i])
qc.h(an1[0])
return a
def Blackbox_g_S(Q, qc, q, anc1):
anc2 = QuantumRegister(Q-1,name='nU_anc')
qc.add_register(anc2)
s = np.zeros(Q)
for i in range(Q):
s[i] = int(m.floor(2*np.random.rand()))
outputs=[]
for o in range(2**Q):
outputs.append(o)
f = np.zeros(2**Q)
for j in range(2**Q):
out = outputs[int(m.floor(len(outputs)*np.random.rand()))]
f[j] = out
f[int(From_Binary(Oplus(Binary(j, 2**Q),s)))] = out
outputs.remove(out)
output_states=[]
for k in range(2**Q):
output_states.append(Binary(f[k],2**Q))
for a in range(2**Q):
c_ops=[]
for b in range(Q):
if output_states[a][b] == 1:
c_ops.append(['X', anc1[b]])
X_Transformation(qc, q, Binary(a, 2**Q))
n_Control_U(qc, q, anc2, c_ops)
# instead of n_Control_U it would work witn n_NOT as well, but the overhead would be much higher:
#for b in range(Q):
# if output_states[a][b] == 1:
# n_NOT(qc, q, anc1[b], anc2)
X_Transformation(qc, q, Binary(a, 2**Q))
return qc, s, f
def Simons_Quantum(Q, qc, q, c, anc1):
for i in range(Q):
qc.h(q[i])
qc,s,f = Blackbox_g_S(Q,qc,q, anc1)
for i in range(Q):
qc.h(q[i])
qc.measure(q,c)
return qc, s
def Simons_Solver(E,N):
s_primes = []
for s in range(1, 2**N):
sp = Binary(s, 2**N)
candidate = True
for e in range(len(E)):
value = 0
for i in range(N):
value += sp[i] * E[e][i]
if value%2 == 1:
candidate = False
if candidate:
s_primes.append(sp)
return s_primes
def Simons_Classical(Q, qc):
run_quantum = True
Equations = []
Results = []
quantum_runs = 0
while(run_quantum):
quantum_runs += 1
M = Measurement(qc, shots = 20, return_M = True, print_M = False)
new_result = True
for r in range(len(Results)):
if list(M.keys())[0] == Results[r]:
new_result = False
break
if new_result:
Results.append(list(M.keys())[0])
eq = []
for e in range(Q):
eq.append(int(list(M.keys())[0][e]))
Equations.append(eq)
s_primes = Simons_Solver(Equations, Q)
if len(s_primes) == 1:
run_quantum = False
return s_primes, Results, quantum_runs
def DFT(x, **kwargs):
p = -1.0
if 'inverse' in kwargs:
P = kwargs['inverse']
if P == True:
p = 1.0
L = len(x)
X = []
for i in range(L):
value = 0
for j in range(L):
value += x[j] * np.exp(p * 2 * m.pi * 1.0j * i * j / L)
X.append(value)
for k in range(len(X)):
re = round(X[k].real,5)
im = round(X[k].imag,5)
if abs(im) == 0 and abs(re) != 0:
X[k] = re
elif abs(re) == 0 and abs(im) != 0:
X[k] = im * 1.0j
elif abs(re) == 0 and abs(im) == 0:
X[k] = 0
else:
X[k] = re + im * 1.0j
return X
def QFT(qc, q, qubits, **kwargs):
R_phis = [0]
for i in range(2, qubits+1):
R_phis.append( 2/(2**i) * m.pi )
for j in range(qubits):
qc.h( q[j] )
for k in range(qubits-j-1):
qc.cp( R_phis[k+1], q[j+k+1], q[j] )
if 'swap' in kwargs:
if(kwargs['swap'] == True):
for s in range(m.floor(qubits/2.0)):
qc.swap( q[s],q[qubits-1-s] )
def QFT_dgr(qc, q, qubits, **kwargs):
if 'swap' in kwargs:
if(kwargs['swap'] == True):
for s in range(m.floor(qubits/2.0)):
qc.swap( q[s],q[qubits-1-s] )
R_phis = [0]
for i in range(2,qubits+1):
R_phis.append( -2/(2**i) * m.pi )
for j in range(qubits):
for k in range(j):
qc.cp(R_phis[j-k], q[qubits-k-1], q[qubits-j-1] )
qc.h( q[qubits-j-1] )
def Quantum_Adder(qc, Qa, Qb, A, B):
Q = len(B)
for n in range(Q):
if( A[n] == 1 ):
qc.x( Qa[n+1] )
if( B[n] == 1 ):
qc.x( Qb[n] )
QFT(qc,Qa,Q+1)
p = 1
for j in range( Q ):
qc.cp( m.pi/(2**p), Qb[j], Qa[0] )
p = p + 1
for i in range(1,Q+1):
p = 0
for jj in np.arange( i-1, Q ):
qc.cp( m.pi/(2**p), Qb[jj], Qa[i] )
p = p + 1
QFT_dgr(qc,Qa,Q+1)
def QPE_phi(MP):
ms = [[],[]]
for i in range(2):
for j in range(len(MP[1][i])):
ms[i].append(int(MP[1][i][j]))
n = int(len(ms[0]))
MS1 = From_Binary(ms[0])
MS2 = From_Binary(ms[1])
estimatedProb = MP[0][0]
aproxPhi = 0
aproxProb = 1
for k in np.arange(1,5000):
phi = k/5000
prob = 1/(2**(2*n)) * abs((-1 + np.exp(2.0j*m.pi*phi) )/(-1 + np.exp(2.0j*m.pi*phi/(2**n))))**2
if abs(prob - estimatedProb) < abs(aproxProb - estimatedProb):
aproxProb = prob
aproxPhi = phi
if( (MS1 < MS2) and ( (MS1!=0) and (MS2!=(2**n-1)) ) ):
theta = (MS1+aproxPhi)/(2**n)
elif( (MS1 > MS2) and (MS1!=0) ):
theta = (MS1-aproxPhi)/(2**n)
else:
theta = 1+(MS1-aproxPhi)/(2**n)
return aproxPhi,theta
def C_Oracle(qc, c, q, a1, a2, state):
#qc.barrier()
N = len(q)
for i in np.arange(N):
if( state[i]==0 ):
qc.cx( c, q[int(i)] )
#---------------------------------
qc.ccx( q[0], q[1], a1[0] )
for j1 in np.arange(N-2):
qc.ccx( q[int(2+j1)], a1[int(j1)], a1[int(1+j1)] )
qc.ccx( c, a1[N-2], a2[0] )
for j2 in np.arange(N-2):
qc.ccx( q[int(N-1-j2)], a1[int(N-3-j2)], a1[int(N-2-j2)] )
qc.ccx( q[0], q[1], a1[0] )
#---------------------------------
for i2 in np.arange(N):
if( state[i2]==0 ):
qc.cx( c, q[int(i2)] )
#qc.barrier()
def C_Diffusion(qc, c, q, a1, a2, ref):
#qc.barrier()
Q = len(q)
N = 2**( Q )
for j in np.arange(Q):
qc.ch( c, q[int(j)] )
if( ref ):
for k in np.arange(1,N):
C_Oracle(qc,c,q,a1,a2,Binary(int(k),N))
else:
C_Oracle(qc,c,q,a1,a2,Binary(0,N))
for j2 in np.arange(Q):
qc.ch( c, q[int(j2)] )
#qc.barrier()
def C_Grover(qc, c, q, a1, a2, marked, **kwargs):
#qc.barrier()
Reflection=False
if 'proper' in kwargs:
Reflection = kwargs['proper']
M = []
for m1 in np.arange( len(marked) ):
M.append( list(marked[m1]) )
for m2 in np.arange( len(M[m1]) ):
M[m1][m2] = int( M[m1][m2] )
for i in np.arange(len(M)):
C_Oracle( qc,c,q,a1,a2,M[i] )
C_Diffusion( qc,c,q,a1,a2,Reflection )
#qc.barrier()
def GCD(a, b):
gcd = 0
if(a > b):
num1 = a
num2 = b
elif(b > a):
num1 = b
num2 = a
elif(a == b):
gcd = a
while( gcd == 0 ):
i = 1
while( num1 >= num2*i ):
i = i + 1
if( num1 == num2*(i-1) ):
gcd = num2
else:
r = num1 - num2*(i-1)
num1 = num2
num2 = r
return gcd
def Euclids_Alg(a, b):
if(a>=b):
num1 = a
num2 = b
else:
num1 = b
num2 = a
r_new = int( num1%num2 )
r_old = int( num2 )
while(r_new!=0):
r_old = r_new
r_new = int( num1%num2 )
num1 = num2
num2 = r_new
gcd = r_old
return gcd
def Modulo_f(Q, a, N):
mods = []
num = a%N
for i in np.arange(1,2**Q):
mods.append(num)
num = (num*a)%N
return mods
def Mod_Op(Q, qc, q1, q2, anc, a, N):
#mods = Modulo_f(Q,a,N)
num = a%N
for j in np.arange( 2**Q ):
q1_state = BinaryL( j, 2**Q )
#q2_state = BinaryL( mods[j-1], 2**Q )
q2_state = BinaryL(num, 2**Q )
num = (num*a)%N
X_Transformation(qc,q1,q1_state)
gates = []
for k in np.arange(Q):
if(q2_state[k]==1):
gates.append(['X',q2[int(k)]])
n_Control_U(qc, q1, anc, gates)
X_Transformation(qc,q1,q1_state)
def ConFrac(N, **kwargs):
imax = 20
r_a = False
if 'a_max' in kwargs:
imax = kwargs['a_max']
if 'return_a' in kwargs:
r_a = kwargs['return_a']
a = []
a.append( m.floor(N) )
b = N - a[0]
i = 1
while( (round(b,10) != 0) and (i < imax) ):
n = 1.0/b
a.append( m.floor(n) )
b = n - a[-1]
i = i + 1
#------------------------------
a_copy = []
for ia in np.arange(len(a)):
a_copy.append(a[ia])
for j in np.arange( len(a)-1 ):
if( j == 0 ):
p = a[-1] * a[-2] + 1
q = a[-1]
del a[-1]
del a[-1]
else:
p_new = a[-1] * p + q
q_new = p
p = p_new
q = q_new
del a[-1]
if(r_a == True):
return q,p,a_copy
return q,p
def r_Finder(a, N):
value1 = a**1 % N
r = 1
value2 = 0
while value1 != value2 or r > 1000:
value2 = a**(int(1+r)) % N
if( value1 != value2 ):
r = r + 1
return r
def Primality(N):
is_prime = True
if( (N==1) or (N==2) or (N==3) ):
is_prime = True
elif( (N%2==0) or (N%3==0) ):
is_prime = False
elif( is_prime==True ):
p = 5
while( (p**2 <= N) and (is_prime==True) ):
if( (N%p==0) or (N%(p+2)==0) ):
is_prime = False
p = p + 6
return is_prime
def Mod_r_Check(a, N, r):
v1 = a**(int(2)) % N
v2 = a**(int(2+r)) % N
if( (v1 == v2) and (r<N) and (r!=0) ):
return True
return False
def Evaluate_S(S, L, a, N):
Pairs = [[S,L]]
for s in np.arange(3):
S_new = int( S - 1 + s)
for l in np.arange(3):
L_new = int( L - 1 + l)
if( ((S_new!=S) or (L_new!=L)) and (S_new!=L_new) ):
Pairs.append( [S_new,L_new] )
#--------------------------- Try 9 combinations of S and L, plus or minus 1 from S & L
period = 0
r_attempts = []
found_r = False
while( (found_r==False) and (len(Pairs)!=0) ):
order = 1
S_o = Pairs[0][0]
L_o = Pairs[0][1]
q_old = -1
q = 999
while( q_old != q ):
q_old = int( q )
q,p = ConFrac(S_o/L_o,a_max=(order+1))
new_r = True
for i in np.arange(len(r_attempts)):
if( q == r_attempts[i] ):
new_r = False
if(new_r):
r_attempts.append( int(q) )
r_bool = Mod_r_Check(a,N,q)
if( r_bool ):
found_r = True
q_old = q
period = int(q)
order = order + 1
del Pairs[0]
#--------------------------- Try higher multiples of already attempted r values
r_o = 0
while( (found_r == False) and (r_o < len(r_attempts)) ):
k = 2
r2 = r_attempts[r_o]
while( k*r2 < N ):
r_try = int(k*r2)
new_r = True
for i2 in np.arange(len(r_attempts)):
if( r_try == r_attempts[i2] ):
new_r = False
if(new_r):
r_attempts.append( int(r_try) )
r_bool = Mod_r_Check(a,N,r_try)
if( r_bool ):
found_r = True
k = N
period = int(r_try)
k = k + 1
r_o = r_o + 1
#--------------------------- If a period is found, try factors of r for smaller periods
if( found_r == True ):
Primes = []
for i in np.arange(2,period):
if( Primality(int(i)) ):
Primes.append(int(i))
if( len(Primes) > 0 ):
try_smaller = True
while( try_smaller==True ):
found_smaller = False
p2 = 0
while( (found_smaller==False) and (p2 < len(Primes)) ):
#print('p2: ',p2)
#print( 'period: ',period,' ',Primes[p2] )
try_smaller = False
if( period/Primes[p2] == m.floor( period/Primes[p2] ) ):
r_bool_2 = Mod_r_Check(a,N,int(period/Primes[p2]))
if( r_bool_2 ):
period = int(period/Primes[p2])
found_smaller = True
try_smaller = True
p2 = p2 + 1
return period
def k_Data(k,n):
Centers = []
for i in np.arange(k):
Centers.append( [1.5+np.random.rand()*5,1.5*np.random.random()*5] )
count = int(round((0.7*n)/k))
Data = []
for j in range(len(Centers)):
for j2 in range(count):
r = np.random.random()*1.5
x = Centers[j][0]+r*np.cos(np.random.random()*2*m.pi)
y = Centers[j][1]+r*np.sin(np.random.random()*2*m.pi)
Data.append([x, y])
for j2 in range(n - k * count):
Data.append( [np.random.random()*8, np.random.random()*8] )
return Data
def Initial_Centroids(k, D):
D_copy = []
for i in np.arange( len(D) ):
D_copy.append( D[i] )
Centroids = []
for j in np.arange(k):
p = np.random.randint(0,int(len(D_copy)-1))
Centroids.append( [ D_copy[p][0] , D_copy[p][1] ] )
D_copy.remove( D_copy[p] )
return Centroids
def Update_Centroids(CT, CL):
old_Centroids = []
for c0 in np.arange(len(CT)):
old_Centroids.append(CT[c0])
Centroids = []
for c1 in np.arange(len(CL)):
mean_x = 0.
mean_y = 0.
for c2 in np.arange(len(CL[c1])):
mean_x += CL[c1][c2][0]
mean_y += CL[c1][c2][1]
l = len(CL[c1])
mean_x /= l
mean_y /= l
Centroids.append( [ mean_x,mean_y ] )
return Centroids, old_Centroids
def Update_Clusters(D, CT, CL):
old_Clusters = []
for c0 in np.arange(len(CL)):
old_Clusters.append(CL[c0])
Clusters = []
for c1 in np.arange( len(CT) ):
Clusters.append( [] )
for d in np.arange( len(D) ):
closest = 'c'
distance = 100000
for c2 in np.arange( len(Clusters) ):
Dist = m.sqrt( ( CT[c2][0] - D[d][0] )**2 + ( CT[c2][1] - D[d][1] )**2 )
if( Dist < distance ):
distance = Dist
closest = int(c2)
Clusters[closest].append( D[d] )
return Clusters,old_Clusters
def Check_Termination(CL, oCL ):
terminate = True
for c1 in np.arange( len(oCL) ):
for c2 in np.arange( len(oCL[c1]) ):
P_found = False
for c3 in np.arange( len(CL[c1]) ):
if( CL[c1][c3] == oCL[c1][c2] ):
P_found = True
break
if( P_found == False ):
terminate = False
break
return terminate
def Draw_Data(CL, CT, oCT, fig, ax, colors, colors2 ):
for j1 in np.arange( len(CL) ):
ax.scatter( oCT[j1][0],oCT[j1][1], color='white', marker='s',s=80 )
for cc in np.arange(len(CL)):
for ccc in np.arange( len( CL[cc] ) ):
ax.scatter( CL[cc][ccc][0],CL[cc][ccc][1], color=colors[cc],s=10 )
for j2 in np.arange( len(CL) ):
ax.scatter( CT[j2][0],CT[j2][1], color=colors2[j2], marker='x',s=50 )
fig.canvas.draw()
time.sleep(1)
def SWAP_Test( qc, control, q1, q2, classical, S ):
qc.h( control )
qc.cswap( control, q1, q2 )
qc.h( control )
qc.measure( control, classical )
D = {'0':0}
D.update( Measurement(qc,shots=S,return_M=True,print_M=False) )
return D['0']
def Bloch_State( p,P ):
x_min = P[0]
x_max = P[1]
y_min = P[2]
y_max = P[3]
theta = np.pi/2*( (p[0]-x_min)/(1.0*x_max-x_min) + (p[1]-y_min)/(1.0*y_max-y_min) )
phi = np.pi/2*( (p[0]-x_min)/(1.0*x_max-x_min) - (p[1]-y_min)/(1.0*y_max-y_min) + 1 )
return theta,phi
def Heatmap(data, show_text, show_ticks, ax, cmap, cbarlabel, **kwargs):
valfmt="{x:.1f}"
textcolors=["black", "white"]
threshold=None
cbar_kw={}
#----------------------------
if not ax:
ax = plt.gca()
im = ax.imshow(data, cmap=cmap, **kwargs)
cbar = ax.figure.colorbar(im, ax=ax, **cbar_kw)
cbar.ax.set_ylabel(cbarlabel, rotation=-90, va="bottom")
ax.grid(which="minor", color="black", linestyle='-', linewidth=1)
if( show_ticks == True ):
ax.set_xticks(np.arange(data.shape[1]))
ax.set_yticks(np.arange(data.shape[0]))
ax.tick_params(which="minor", bottom=False, left=False)
if threshold is not None:
threshold = im.norm(threshold)
else:
threshold = im.norm(data.max())/2.
kw = dict(horizontalalignment="center", verticalalignment="center")
if isinstance(valfmt, str):
valfmt = matplotlib.ticker.StrMethodFormatter(valfmt)
if( show_text == True ):
for i in range(data.shape[0]):
for j in range(data.shape[1]):
kw.update(color=textcolors[int(im.norm(data[i, j]) < threshold)])
text = im.axes.text(j, i, valfmt(data[i, j], None), **kw)
def Q_Update_Clusters(D, CT, CL, DS, shots):
old_Clusters = []
for c0 in np.arange(len(CL)):
old_Clusters.append(CL[c0])
Clusters = []
for c1 in np.arange( len(CT) ):
Clusters.append( [] )
#------------------------------------------------
for d in np.arange( len(D) ):
closest = 'c'
distance = 0
t,p = Bloch_State( D[d], DS )
for c2 in np.arange( len(Clusters) ):
t2,p2 = Bloch_State( CT[c2], DS )
q = QuantumRegister( 3, name='q' )
c = ClassicalRegister( 1, name='c' )
qc= QuantumCircuit( q,c, name='qc' )
qc.u( t, p, 0, q[1] )
qc.u( t2, p2, 0, q[2] )
IP = SWAP_Test( qc, q[0], q[1], q[2], c[0], shots )
if( IP > distance ):
distance = IP
closest = int(c2)
Clusters[closest].append(D[d] )
return Clusters,old_Clusters
def E_Expectation_Value( qc, Energies ):
SV = execute( qc, S_simulator, shots=1 ).result().get_statevector()
EV = 0
for i in range( len(SV) ):
EV += Energies[i] *abs( SV[i] * np.conj(SV[i]) )
EV = round(EV,4)
return EV
def Top_States(States, Energies, SV, top):
P = []
S = []
E = []
for a in np.arange( top ):
P.append(-1)
S.append('no state')
E.append('no energy')
for i in range(len(States)):
new_top = False
probs = abs(SV[i]*np.conj(SV[i]))*100
state = States[i]
energ = Energies[i]
j = 0
while( (new_top == False) and (j < top) ):
if( probs > P[j] ):
for k in np.arange( int( len(P) - (j+1) ) ):
P[int( -1-k )] = P[int( -1-(k+1) )]
S[int( -1-k )] = S[int( -1-(k+1) )]
E[int( -1-k )] = E[int( -1-(k+1) )]
P[j] = probs
S[j] = state
E[j] = energ
new_top = True
j = int(j+1)
for s in range( top ):
print('State ',S[s],' Probability: ',round(P[s],2),'%',' Energy: ',round(E[s],2))
def Ising_Energy(V, E, **kwargs):
Trans = False
if 'Transverse' in kwargs:
if( kwargs['Transverse'] == True ):
Trans = True
Energies = []
States = []
for s in range( 2**len(V) ):
B = BinaryL(int(s),2**len(V))
B2 = []
for i in range(len(B)):
if( B[i] == 0 ):
B2.append(1)
else:
B2.append(-1)
state = ''
energy = 0
for s2 in range(len(B)):
state = state+str(B[s2])
energy -= V[s2][1]*B2[s2]
States.append(state)
for j in range( len(E) ):
if( Trans == False ):
energy -= B2[int(E[j][0])] * B2[int(E[j][1])]
else:
energy -= B2[int(E[j][0])] * B2[int(E[j][1])] * E[j][2]
Energies.append(energy)
return Energies,States
def Ising_Circuit(qc, q, V, E, beta, gamma, **kwargs):
Trans = False
if 'Transverse' in kwargs:
if( kwargs['Transverse'] == True ):
Trans = True
Mixer = 1
if 'Mixing' in kwargs:
Mixer = int( kwargs['Mixing'] )
p = 1
if 'p' in kwargs:
p = int(kwargs['p'])
for c in range(p):
Uc_Ising(qc,q,gamma,V,E,Trans)
if( Mixer == 2 ):
Ub_Mixer2(qc,q,beta,V)
else:
Ub_Mixer1(qc,q,beta,V)
def Uc_Ising(qc, q, gamma, Vert, Edge, T):
for e in range( len(Edge) ): # ZZ
if( T == False ):
G = gamma
else:
G = gamma * Edge[e][2]
qc.cx( q[int(Edge[e][0])], q[int(Edge[e][1])] )
qc.rz( 2*G, q[int(Edge[e][1])] )
qc.cx( q[int(Edge[e][0])], q[int(Edge[e][1])] )
for v in range( len(Vert) ): # Z_gamma
# WARNING: This was with error in the article, the 'on site' magnetic field was not taken into account
qc.rz( gamma * Vert[v][1], q[int(Vert[v][0])] )
def Ub_Mixer1(qc, q, beta, Vert):
for v in np.arange( len(Vert) ):
qc.rx( beta, q[int(v)] )
def Ub_Mixer2(qc, q, beta, Vert):
for v in range( len(Vert) ):
qc.rx( beta, q[int(Vert[v][0])] )
qc.cx( q[0], q[1] )
qc.cx( q[1], q[2] )
qc.cx( q[2], q[0] )
for v2 in range( len(Vert) ):
qc.ry( beta, q[int(Vert[v2][0])] )
def Ising_Gradient_Descent(qc, q, Circ, V, E, beta, gamma, epsilon, En, step, **kwargs):
Trans = False
if 'Transverse' in kwargs:
if( kwargs['Transverse'] == True ):
Trans = True
Mixer = 1
if 'Mixing' in kwargs:
Mixer = int(kwargs['Mixing'])
params = [ [beta+epsilon,gamma],[beta-epsilon,gamma],[beta,gamma+epsilon],[beta,gamma-epsilon] ]
ev = []
for i in np.arange( 4 ):
q = QuantumRegister(len(V))
qc= QuantumCircuit(q)
for hh in np.arange(len(V)):
qc.h( q[int(hh)] )
Circ( qc, q, V, E, params[i][0], params[i][1], Transverse=Trans, Mixing=Mixer )
ev.append( E_Expectation_Value( qc, En ) )
beta_next = beta - ( ev[0] - ev[1] )/( 2.0*epsilon ) * step
gamma_next = gamma - ( ev[2] - ev[3] )/( 2.0*epsilon ) * step
return beta_next, gamma_next
def MaxCut_Energy(V, E):
Energies = []
States = []
for s in np.arange( 2**len(V) ):
B = BinaryL(int(s),2**len(V))
B2 = []
for i in np.arange(len(B)):
if( B[i] == 0 ):
B2.append(1)
else:
B2.append(-1)
state = ''
for s2 in np.arange(len(B)):
state = state+str(B[s2])
States.append(state)
energy = 0
for j in np.arange( len(E) ):
energy = energy + 0.5* ( 1.0 - B2[int(E[j][0])]*B2[int(E[j][1])] )
Energies.append(energy)
return Energies,States
def MaxCut_Circuit(qc, q, V, E, beta, gamma):
Uc_MaxCut( qc, q, gamma,E)
Ub_Mixer1(qc,q,beta,V)
def Uc_MaxCut(qc, q, gamma, edge):
for e in np.arange( len(edge) ):
qc.cx( q[int(edge[e][0])], q[int(edge[e][1])] )
qc.rz( gamma, q[int(edge[e][1])] )
qc.cx( q[int(edge[e][0])], q[int(edge[e][1])] )
def p_Gradient_Ascent(qc, q, Circ, V, E, p, Beta, Gamma, epsilon, En, step):
params = []
for i in np.arange(2):
for p1 in np.arange(p):
if( i == 0 ):
params.append( Beta[p1] )
elif( i == 1 ):
params.append( Gamma[p1] )
ep_params = []
for p2 in np.arange( len( params ) ):
for i2 in np.arange( 2 ):
ep = []
for p3 in np.arange( len(params) ):
ep.append( params[p3] )
ep[p2] = ep[p2] + (-1.0)**(i2+1)*epsilon
ep_params.append( ep )
ev = []
for p4 in np.arange( len( ep_params ) ):
run_params = ep_params[p4]
q = QuantumRegister(len(V))
qc= QuantumCircuit(q)
for hh in np.arange(len(V)):
qc.h( q[int(hh)] )
for p5 in np.arange(p):
Circ( qc, q, V, E, run_params[int(p5)], run_params[int(p5+p)] )
ev.append( E_Expectation_Value( qc, En ) )
Beta_next = []
Gamma_next = []
for k in np.arange( len( params ) ):
if( k < len( params )/2 ):
Beta_next.append( params[k] - (ev[int(2*k)] - ev[int(2*k+1)])/( 2.0*epsilon ) * step )
else:
Gamma_next.append( params[k] - (ev[int(2*k)] - ev[int(2*k+1)])/( 2.0*epsilon ) * step )
return Beta_next, Gamma_next
def Single_Qubit_Ansatz( qc, qubit, params ):
qc.ry( params[0], qubit )
qc.rz( params[1], qubit )
def VQE_Gradient_Descent(qc, q, H, Ansatz, theta, phi, epsilon, step, **kwargs):
EV_type = 'measure'
if 'measure' in kwargs:
M_bool = kwargs['measure']
if( M_bool == True ):
EV_type = 'measure'
else:
EV_type = 'wavefunction'
Shots = 1000
if 'shots' in kwargs:
Shots = kwargs['shots']
params = [theta,phi]
ep_params = [[theta+epsilon,phi],[theta-epsilon,phi],[theta,phi+epsilon],[theta,phi-epsilon]]
Hk = list( H.keys() )
EV = []
for p4 in np.arange( len( ep_params ) ):
H_EV = 0
qc_params = ep_params[p4]
for h in np.arange( len(Hk) ):
qc_params = ep_params[p4]
q = QuantumRegister(1)
c = ClassicalRegister(1)
qc= QuantumCircuit(q,c)
Ansatz( qc, q[0], [qc_params[0], qc_params[1]] )
if( Hk[h] == 'X' ):
qc.ry(-m.pi/2,q[0])
elif( Hk[h] == 'Y' ):
qc.rx(m.pi/2,q[0])
if( EV_type == 'wavefunction' ):
sv = execute( qc, S_simulator, shots=1 ).result().get_statevector()
H_EV = H_EV + H[Hk[h]]*( (np.conj(sv[0])*sv[0]).real - (np.conj(sv[1])*sv[1]).real )
elif( EV_type == 'measure' ):
qc.measure( q,c )
M = {'0':0,'1':0}
M.update( Measurement( qc, shots=Shots, print_M=False, return_M=True ) )
H_EV = H_EV + H[Hk[h]]*(M['0']-M['1'])/Shots
EV.append(H_EV)
theta_slope = ( EV[0]-EV[1] )/(2.0*epsilon)
phi_slope = ( EV[2]-EV[3] )/(2.0*epsilon)
next_theta = theta - theta_slope*step
next_phi = phi - phi_slope*step
return next_theta,next_phi
def Two_Qubit_Ansatz(qc, q, params):
Single_Qubit_Ansatz( qc, q[0], [params[0], params[1]] )
Single_Qubit_Ansatz( qc, q[1], [params[2], params[3]] )
qc.cx( q[0], q[1] )
Single_Qubit_Ansatz( qc, q[0], [params[4], params[5]] )
Single_Qubit_Ansatz( qc, q[1], [params[6], params[7]] )
def Calculate_MinMax(V, C_type):
if( C_type == 'min' ):
lowest = [V[0],0]
for i in np.arange(1,len(V)):
if( V[i] < lowest[0] ):
lowest[0] = V[i]
lowest[1] = int(i)
return lowest
elif( C_type == 'max' ):
highest = [V[0],0]
for i in np.arange(1,len(V)):
if( V[i] > highest[0] ):
highest[0] = V[i]
highest[1] = int(i)
return highest
def Compute_Centroid(V):
points = len( V )
dim = len( V[0] )
Cent = []
for d in np.arange( dim ):
avg = 0
for a in np.arange( points ):
avg = avg + V[a][d]/points
Cent.append( avg )
return Cent
def Reflection_Point(P1, P2, alpha):
P = []
for p in np.arange( len(P1) ):
D = P2[p] - P1[p]
P.append( P1[p]+alpha*D )
return P
def VQE_EV(params, Ansatz, H, EV_type, **kwargs):
Shots = 10000
if 'shots' in kwargs:
Shots = int( kwargs['shots'] )
Hk = list( H.keys() )
H_EV = 0
for k in range( len(Hk) ): # for each term in Hamiltonian
L = list( Hk[k] )
q = QuantumRegister(len(L))
c = ClassicalRegister(len(L))
qc= QuantumCircuit(q,c)
Ansatz( qc, q, params )
sv0 = execute( qc, S_simulator, shots=1 ).result().get_statevector()
if( EV_type == 'wavefunction' ):
for l in range( len(L) ):
if( L[l] == 'X' ):
qc.x( q[int(l)] )
elif( L[l] == 'Y' ):
qc.y( q[int(l)] )
elif( L[l] == 'Z' ):
qc.z( q[int(l)] )
sv = execute( qc, S_simulator, shots=1 ).result().get_statevector()
H_ev = 0
for l2 in range(len(sv)):
H_ev = H_ev + (np.conj(sv[l2])*sv0[l2]).real
H_EV = H_EV + H[Hk[k]] * H_ev
elif( EV_type == 'measure' ):
# apply Hamiltonian term
for l in range( len(L) ):
if( L[l] == 'X' ):
qc.ry(-m.pi/2,q[int(l)])
elif( L[l] == 'Y' ):
qc.rx( m.pi/2,q[int(l)])
# measure it
qc.measure( q,c )
M = Measurement( qc, shots=Shots, print_M=False, return_M=True )
Mk = list( M.keys() )
# compute energy estimate
H_ev = 0
for m1 in range(len(Mk)):
MS = list( Mk[m1] )
e = 1
for m2 in range(len(MS)):
if( MS[m2] == '1' ):
e = e*(-1)
H_ev = H_ev + e * M[Mk[m1]]
H_EV = H_EV + H[Hk[k]]*H_ev/Shots
return H_EV
def Nelder_Mead(H, Ansatz, Vert, Val, EV_type):
alpha = 2.0
gamma = 2.0
rho = 0.5
sigma = 0.5
add_reflect = False
add_expand = False
add_contract = False
shrink = False
add_bool = False
#----------------------------------------
hi = Calculate_MinMax( Val,'max' )
Vert2 = []
Val2 = []
for i in np.arange(len(Val)):
if( int(i) != hi[1] ):
Vert2.append( Vert[i] )
Val2.append( Val[i] )
Center_P = Compute_Centroid( Vert2 )
Reflect_P = Reflection_Point(Vert[hi[1]],Center_P,alpha)
Reflect_V = VQE_EV(Reflect_P,Ansatz,H,EV_type)
#------------------------------------------------- # Determine if: Reflect / Expand / Contract / Shrink
hi2 = Calculate_MinMax( Val2,'max' )
lo2 = Calculate_MinMax( Val2,'min' )
if( hi2[0] > Reflect_V >= lo2[0] ):
add_reflect = True
elif( Reflect_V < lo2[0] ):
Expand_P = Reflection_Point(Center_P,Reflect_P,gamma)
Expand_V = VQE_EV(Expand_P,Ansatz,H,EV_type)
if( Expand_V < Reflect_V ):
add_expand = True
else:
add_reflect = True
elif( Reflect_V > hi2[0] ):
if( Reflect_V < hi[0] ):
Contract_P = Reflection_Point(Center_P,Reflect_P,rho)
Contract_V = VQE_EV(Contract_P,Ansatz,H,EV_type)
if( Contract_V < Reflect_V ):
add_contract = True
else:
shrink = True
else:
Contract_P = Reflection_Point(Center_P,Vert[hi[1]],rho)
Contract_V = VQE_EV(Contract_P,Ansatz,H,EV_type)
if( Contract_V < Val[hi[1]] ):
add_contract = True
else:
shrink = True
#------------------------------------------------- # Apply: Reflect / Expand / Contract / Shrink
if( add_reflect == True ):
new_P = Reflect_P
new_V = Reflect_V
add_bool = True
elif( add_expand == True ):
new_P = Expand_P
new_V = Expand_V
add_bool = True
elif( add_contract == True ):
new_P = Contract_P
new_V = Contract_V
add_bool = True
if( add_bool ):
del Vert[hi[1]]
del Val[hi[1]]
Vert.append( new_P )
Val.append( new_V )
if( shrink ):
Vert3 = []
Val3 = []
lo = Calculate_MinMax( Val,'min' )
Vert3.append( Vert[lo[1]] )
Val3.append( Val[lo[1]] )
for j in np.arange( len(Val) ):
if( int(j) != lo[1] ):
Shrink_P = Reflection_Point(Vert[lo[1]],Vert[j],sigma)
Vert3.append( Shrink_P )
Val3.append( VQE_EV(Shrink_P,Ansatz,H,EV_type) )
for j2 in np.arange( len(Val) ):
del Vert[0]
del Val[0]
Vert.append( Vert3[j2] )
Val.append( Val3[j2] )
|
https://github.com/mmetcalf14/Hamiltonian_Downfolding_IBM
|
mmetcalf14
|
from qiskit.chemistry import FermionicOperator
from qiskit.chemistry.aqua_extensions.components.initial_states import HartreeFock
from qiskit.chemistry.aqua_extensions.components.variational_forms import UCCSD
from qiskit.chemistry import QMolecule as qm
from qiskit.aqua.components.optimizers import COBYLA
from qiskit.aqua import Operator
from qiskit.aqua.algorithms import VQE, ExactEigensolver
from qiskit import Aer
from qiskit.tools.visualization import circuit_drawer
from qiskit.chemistry.drivers import PySCFDriver, UnitsType
import numpy as np
import yaml as yml
from yaml import SafeLoader as Loader
import Load_Hamiltonians as lh
import os
#Importing data generated from NW Chem to run experiments
#Li2_cc-pVTZ_4_ORBITALS_Li2-4_ORBITALS-ccpVTZ-2_1384
root_dir = '/Users/mmetcalf/Dropbox/Quantum Embedding/Codes/Lithium_Downfolding/Qiskit Chem/HamiltonianDownfolding_w_IBM/IntegralData/H2_MEKENA/'
NW_data_file = str(root_dir+'h2_ccpvtz_ccsd_0_80au_ducc_1_3.yaml')
# NW_data_file = str('H2.yaml')
OE_data_file = str(root_dir+ 'h2_ccpvtz_ccsd_0_80au.FOCK')
# NW_data_file = 'H2.yaml'
doc_nw = open(NW_data_file,'r')
doc_oe = open(OE_data_file,'r')
data = yml.load(doc_nw,Loader)
content_oe = doc_oe.readlines()
#################
backend1 = Aer.get_backend('statevector_simulator')
backend2 = Aer.get_backend('qasm_simulator')
#################
###########################################################
#Initialize Variables
map_type = str('jordan_wigner')
truncation_threshold = 0.1
n_spatial_orbitals = data['integral_sets'][0]['n_orbitals']
nuclear_repulsion_energy = data['integral_sets'][0]['coulomb_repulsion']['value']
print('repulsion: ',nuclear_repulsion_energy)
n_orbitals = 2*n_spatial_orbitals
n_particles = data['integral_sets'][0]['n_electrons']
#Populating the QMolecule class with the data to make calculations easier
qm.num_orbitals = n_spatial_orbitals
qm.num_alpha = n_particles//2
qm.num_beta = n_particles//2
#This is just a place holder for freezing the core that I need for the MP2 calculations
qm.core_orbitals = 0
qm.nuclear_repulsion_energy = nuclear_repulsion_energy
qm.hf_energy = data['integral_sets'][0]['scf_energy']['value']
###################Get Orbital Energies from FOCK file########################
orbital_energies = []
found = False
count = 0
for line in content_oe:
if 'Eigenvalues:' in line.split()[0]:
found =True
if found and len(line.split()) > 1:
orbital_energies.append(float(line.split()[1]))
count += 1
if count >= n_spatial_orbitals:
break
qm.orbital_energies = orbital_energies
print(orbital_energies)
#7 orbitals
#qm.orbital_energies = [-2.4533,-2.4530,-0.1817,0.0065, 0.0273, 0.0273, 0.0385]
##############################################################################
dist = 2*data['integral_sets'][0]['geometry']['atoms'][1]['coords'][2]
if map_type == 'parity':
#For two-qubit reduction
n_qubits = n_orbitals-2
else:
n_qubits = n_orbitals
active_occ = n_particles//2
active_virt = (n_orbitals-n_particles)//2
active_occ_list = np.arange(active_occ)
active_occ_list = active_occ_list.tolist()
#print('Orbitals {} are occupied'.format(active_occ_list))
active_virt_list = np.arange(active_virt)
active_virt_list = active_virt_list.tolist()
#print('Orbitals {} are unoccupied'.format(active_virt_list))
###########################################################
#Output Files to Plot stuff
Fout = open('ErrorFromTruncation_Li2_Orb-{}_Dist-{}'.format(n_spatial_orbitals,dist),"w")
###########################################################
###Running Pyscf driver to check integrals
# driver = PySCFDriver(atom='Li .0 .0 .0; Li .0 .0 {}'.format(dist),
# unit=UnitsType.ANGSTROM,
# basis='cc-pvtz')
# molecule = driver.run()
# print(molecule.num_orbitals)
# print('Spatial Integrals from Pyscf\n',molecule.mo_eri_ints)
# Get Hamiltonian in array form from data and get excitations
#Setting singles so they are not us
dumpy_singles = [[0,0]]
one_electron_import = data['integral_sets'][0]['hamiltonian']['one_electron_integrals']['values']
two_electron_import = data['integral_sets'][0]['hamiltonian']['two_electron_integrals']['values']
one_electron_spatial_integrals, two_electron_spatial_integrals = lh.get_spatial_integrals(one_electron_import,two_electron_import,n_spatial_orbitals)
one_electron_spatial_integrals, two_electron_spatial_integrals = lh.trunctate_spatial_integrals(one_electron_spatial_integrals,two_electron_spatial_integrals,.001)
#print('Spatial Integrals from my program\n',two_electron_spatial_integrals)
#print('The difference\n',molecule.mo_eri_ints-two_electron_spatial_integrals)
#For the MP2 calculation
qm.mo_eri_ints = two_electron_spatial_integrals
# qm.mo_onee_ints = one_electron_spatial_integrals
h1, h2 = lh.convert_to_spin_index(one_electron_spatial_integrals,two_electron_spatial_integrals,n_spatial_orbitals, .001)
#print(h1)
# h1 = qm.onee_to_spin(one_electron_spatial_integrals)
# h2 = qm.twoe_to_spin(np.einsum('ijkl->ljik', two_electron_spatial_integrals))
#fop = FermionicOperator(one_temp,two_temp)
fop = FermionicOperator(h1, h2)
qop_paulis = fop.mapping(map_type)
qop = Operator(paulis=qop_paulis.paulis)
###########################################
#Exact Result to compare to: This can also be obtained via the yaml file once we verify correctness.
#Don't use trunctated Hamiltonian
# print('Getting energy')
# exact_eigensolver = ExactEigensolver(qop, k=2)
# ret = exact_eigensolver.run()
# print('The electronic energy is: {:.12f}'.format(ret['eigvals'][0].real))
# print('The total FCI energy is: {:.12f}'.format(ret['eigvals'][0].real + nuclear_repulsion_energy))
###########################################
init_state = HartreeFock(n_qubits, n_orbitals, n_particles, map_type,two_qubit_reduction=False)
#Keep in mind Jarrod didn't use any singles for his ansatz. Maybe just stick to some local doubles, diagonal cancel
var_op = UCCSD(num_qubits=n_qubits, depth=1, num_orbitals=n_orbitals, num_particles=n_particles, active_occupied=active_occ_list,\
active_unoccupied=active_virt_list,initial_state=init_state, qubit_mapping=map_type, mp2_reduction=True)
dumpy_params = np.random.rand(var_op.num_parameters)
#var_cirq = var_op.construct_circuit(dumpy_params)
# singles, doubles = var_op.return_excitations()
# setup a classical optimizer for VQE
# max_eval = 200
# #WOuld using a different optimizer yield better results at long distances?
# optimizer = COBYLA(maxiter=max_eval,disp=True, tol=1e-2)
# print('params: ',var_op.num_parameters)
# dumpy_params = np.random.rand(var_op.num_parameters)
# #Call the VQE algorithm class with your qubit operator for the Hamiltonian and the variational op
# # print('Doing VQE')
# algorithm = VQE(qop_paulis,var_op,optimizer,'paulis', initial_point=var_op._mp2_coeff)
# VQE_Circ = algorithm.construct_circuit(dumpy_params, backend=None)
# print('The VQE circuit:\n',circuit_drawer(VQE_Circ, output='text'))
# result = algorithm.run(backend1)
# print('The VQE energy is: ',result['energy']+nuclear_repulsion_energy)
# print('the params are {}.'.format(result['opt_params']))
# print(qop)
# exact_eigensolver = ExactEigensolver(qop, k=2)
# ret = exact_eigensolver.run()
# print('The total FCI energy is: {:.12f}'.format(ret['eigvals'][0].real + nuclear_repulsion_energy))
Fout.close()
# Junk Code I don't want to delete
# Determining a method to reduce the excitation list with MP2
# All I am missing are the orbital energies and then I am good to go
# It might be worth integrating this into the UCCSD class, so you can get the right circuit
# without having to redo it.
# mp2 = MP2Info(qm)
# mp2_coeff, new_energies = mp2.mp2_get_term_info(var_op._double_excitations)
#
# print('{} are the new MP2 coeffs with energies {}'.format(mp2_coeff,new_energies))
# new_doubles = []
# for i, val in enumerate(doubles):
# if mp2_coeff[i] != 0:
# new_doubles.append(val)
#print('These are the new doubles {}'.format(new_doubles))
|
https://github.com/dkp-quantum/Tutorials
|
dkp-quantum
|
import qiskit as qk
import numpy as np
from scipy.linalg import expm
import matplotlib.pyplot as plt
import math
# Single qubit operators
sx = np.array([[0.0, 1.0],[1.0, 0.0]])
sy = np.array([[0.0, -1.0*1j],[1.0*1j, 0.0]])
sz = np.array([[1.0, 0.0],[0.0, -1.0]])
idt = np.array([[1.0, 0.0],[0.0, 1.0]])
import warnings
warnings.filterwarnings("ignore", category=DeprecationWarning)
psi0 = np.array([1.0, 0.0])
thetas = np.linspace(0,4*math.pi,200)
avg_sx_tot = np.zeros(len(thetas))
for i in range(len(thetas)):
psi_theta = expm(-1j*0.5*thetas[i]*(sx+sz)/math.sqrt(2)).dot(psi0)
avg_sx_tot[i] = np.real(psi_theta.conjugate().transpose().dot(sx.dot(psi_theta)))
plt.plot(thetas,avg_sx_tot)
plt.xlabel(r'$\theta$')
plt.ylabel(r'$\langle\sigma_x\rangle_\theta$')
plt.show()
avg_sx_zx = np.zeros(len(thetas))
avg_sx_xz = np.zeros(len(thetas))
for i in range(len(thetas)):
psi_theta_zx = expm(-1j*0.5*thetas[i]*(sz)/math.sqrt(2)).dot(expm(-1j*0.5*thetas[i]*(sx)/math.sqrt(2)).dot(psi0))
psi_theta_xz = expm(-1j*0.5*thetas[i]*(sx)/math.sqrt(2)).dot(expm(-1j*0.5*thetas[i]*(sz)/math.sqrt(2)).dot(psi0))
avg_sx_zx[i] = np.real(psi_theta_zx.conjugate().transpose().dot(sx.dot(psi_theta_zx)))
avg_sx_xz[i] = np.real(psi_theta_xz.conjugate().transpose().dot(sx.dot(psi_theta_xz)))
plt.plot(thetas,avg_sx_tot)
plt.plot(thetas,avg_sx_zx)
plt.plot(thetas,avg_sx_xz)
plt.xlabel(r'$\theta$')
plt.ylabel(r'$\langle\sigma_x\rangle_\theta$')
plt.legend(['Around x = z', 'x first', 'z first'],loc=1)
plt.show()
# Try this with e.g. ntrot = 1, 5, 10, 50.
# You can also try to do sx and sz slices in the reverse order: both choices will become good approximations
# for large n
ntrot = 10
avg_sx_n = np.zeros(len(thetas))
for i in range(len(thetas)):
rot = expm(-1j*0.5*thetas[i]*(sx)/(ntrot*math.sqrt(2))).dot(expm(-1j*0.5*thetas[i]*(sz)/(ntrot*math.sqrt(2))))
for j in range(ntrot-1):
rot = expm(-1j*0.5*thetas[i]*(sx)/(ntrot*math.sqrt(2))).dot(expm(-1j*0.5*thetas[i]*(sz)/(ntrot*math.sqrt(2)))).dot(rot)
psi_theta_n = rot.dot(psi0)
avg_sx_n[i] = np.real(psi_theta_n.conjugate().transpose().dot(sx.dot(psi_theta_n)))
plt.plot(thetas,avg_sx_tot)
plt.plot(thetas,avg_sx_n,'--')
plt.xlabel(r'$\theta$')
plt.ylabel(r'$\langle\sigma_x\rangle_\theta$')
plt.legend(['Exact', 'ntrot = ' + str(ntrot)],loc=1)
plt.show()
delta = 0.1
qr = qk.QuantumRegister(2,name='qr')
zz_example = qk.QuantumCircuit(qr)
zz_example.cx(qr[0],qr[1])
zz_example.u1(2*delta,qr[1])
zz_example.cx(qr[0],qr[1])
zz_example.draw(output='mpl')
J = 1
c_times = np.linspace(0,0.5*math.pi/abs(J),1000)
q_times = np.linspace(0,0.5*math.pi/abs(J),10)
### Classical simulation of the Heisenberg dimer model
psi0 = np.kron( np.array([0,1]), np.array([1,0]) )
H = J * ( np.kron(sx,sx) + np.kron(sy,sy) + np.kron(sz,sz) )
sz1_t = np.zeros(len(c_times))
sz2_t = np.zeros(len(c_times))
sz1 = np.kron(sz,idt)
sz2 = np.kron(idt,sz)
for i in range(len(c_times)):
t = c_times[i]
psi_t = expm(-1j*H*t).dot(psi0)
sz1_t[i] = np.real(psi_t.conjugate().transpose().dot(sz1.dot(psi_t)))
sz2_t[i] = np.real(psi_t.conjugate().transpose().dot(sz2.dot(psi_t)))
### Digital quantum simulation of the Heisenberg dimer model using qiskit
nshots = 1024
sz1q_t = np.zeros(len(q_times))
sz2q_t = np.zeros(len(q_times))
for k in range(len(q_times)):
delta = J*q_times[k]
qr = qk.QuantumRegister(2,name='qr')
cr = qk.ClassicalRegister(2,name='cr')
Heis2 = qk.QuantumCircuit(qr,cr)
# Initial state preparation
Heis2.x(qr[0])
# ZZ
Heis2.cx(qr[0],qr[1])
Heis2.u1(-2*delta,qr[1])
Heis2.cx(qr[0],qr[1])
# YY
Heis2.u3(math.pi/2, -math.pi/2, math.pi/2, qr[0])
Heis2.u3(math.pi/2, -math.pi/2, math.pi/2, qr[1])
Heis2.cx(qr[0],qr[1])
Heis2.u1(-2*delta,qr[1])
Heis2.cx(qr[0],qr[1])
Heis2.u3(-math.pi/2, -math.pi/2, math.pi/2, qr[0])
Heis2.u3(-math.pi/2, -math.pi/2, math.pi/2, qr[1])
# XX
Heis2.u3(-math.pi/2, 0.0, 0.0, qr[0])
Heis2.u3(-math.pi/2, 0.0, 0.0, qr[1])
Heis2.cx(qr[0],qr[1])
Heis2.u1(-2*delta,qr[1])
Heis2.cx(qr[0],qr[1])
Heis2.u3(math.pi/2, 0.0, 0.0, qr[0])
Heis2.u3(math.pi/2, 0.0, 0.0, qr[1])
# measure
Heis2.measure(qr,cr)
# Run the quantum algorithm
backend = qk.Aer.get_backend('qasm_simulator')
job = qk.execute(Heis2, backend, shots=nshots)
result = job.result()
counts = result.get_counts()
# Post processing of outcomes to get sz expectation values
sz1q = 0
sz2q = 0
for key,value in counts.items():
if key == '00':
sz1q += value
sz2q += value
elif key == '01':
sz1q -= value
sz2q += value
elif key == '10':
sz1q += value
sz2q -= value
elif key == '11':
sz1q -= value
sz2q -= value
sz1q_t[k] = sz1q/nshots
sz2q_t[k] = sz2q/nshots
plt.plot(abs(J)*c_times,0.5*sz1_t,'b--')
plt.plot(abs(J)*c_times,0.5*sz2_t,'c')
plt.plot(abs(J)*q_times,0.5*sz1q_t,'rd')
plt.plot(abs(J)*q_times,0.5*sz2q_t,'ko')
plt.legend(['sz1','sz2','sz1q','sz2q'])
plt.xlabel(r'$\delta = |J|t$')
plt.show()
# WARNING: this cell can take a few minutes to run!
ntrotter = 5
J12 = 1
J23 = 1
c_times = np.linspace(0,math.pi/abs(J12),1000)
q_times = np.linspace(0,math.pi/abs(J12),20)
### Classical simulation of the Heisenberg trimer model
psi0 = np.kron( np.kron( np.array([0,1]), np.array([1,0]) ) , np.array([1,0]) )
sxsx12 = np.kron(sx, np.kron(sx,idt))
sysy12 = np.kron(sy, np.kron(sy,idt))
szsz12 = np.kron(sz, np.kron(sz,idt))
sxsx23 = np.kron(idt, np.kron(sx,sx))
sysy23 = np.kron(idt, np.kron(sy,sy))
szsz23 = np.kron(idt, np.kron(sz,sz))
H12 = J12 * ( sxsx12 + sysy12 + szsz12 )
H23 = J23 * ( sxsx23 + sysy23 + szsz23 )
H = H12 + H23
sz1_t = np.zeros(len(c_times))
sz2_t = np.zeros(len(c_times))
sz3_t = np.zeros(len(c_times))
sz1 = np.kron(sz, np.kron(idt,idt))
sz2 = np.kron(idt, np.kron(sz,idt))
sz3 = np.kron(idt, np.kron(idt,sz))
for i in range(len(c_times)):
t = c_times[i]
psi_t = expm(-1j*H*t).dot(psi0)
sz1_t[i] = np.real(psi_t.conjugate().transpose().dot(sz1.dot(psi_t)))
sz2_t[i] = np.real(psi_t.conjugate().transpose().dot(sz2.dot(psi_t)))
sz3_t[i] = np.real(psi_t.conjugate().transpose().dot(sz3.dot(psi_t)))
### Classical simulation of the Heisenberg trimer model WITH SUZUKI TROTTER DIGITALIZATION
sz1st_t = np.zeros(len(c_times))
sz2st_t = np.zeros(len(c_times))
sz3st_t = np.zeros(len(c_times))
for i in range(len(c_times)):
t = c_times[i]
Ust = expm(-1j*H23*t/ntrotter).dot(expm(-1j*H12*t/ntrotter))
for j in range(ntrotter-1):
Ust = expm(-1j*H23*t/ntrotter).dot(expm(-1j*H12*t/ntrotter)).dot(Ust)
psi_t = Ust.dot(psi0)
sz1st_t[i] = np.real(psi_t.conjugate().transpose().dot(sz1.dot(psi_t)))
sz2st_t[i] = np.real(psi_t.conjugate().transpose().dot(sz2.dot(psi_t)))
sz3st_t[i] = np.real(psi_t.conjugate().transpose().dot(sz3.dot(psi_t)))
### Digital quantum simulation of the Heisenberg model using qiskit
nshots = 1024
sz1q_t = np.zeros(len(q_times))
sz2q_t = np.zeros(len(q_times))
sz3q_t = np.zeros(len(q_times))
for k in range(len(q_times)):
delta12n = J12*q_times[k]/ntrotter
delta23n = J23*q_times[k]/ntrotter
qr = qk.QuantumRegister(3,name='qr')
cr = qk.ClassicalRegister(3,name='cr')
Heis3 = qk.QuantumCircuit(qr,cr)
# Initial state preparation
Heis3.x(qr[0])
for n in range(ntrotter):
# 1-2 bond mapped on qubits 0 and 1 in the quantum register
# ZZ
Heis3.cx(qr[0],qr[1])
Heis3.u1(-2*delta12n,qr[1])
Heis3.cx(qr[0],qr[1])
# YY
Heis3.u3(math.pi/2, -math.pi/2, math.pi/2, qr[0])
Heis3.u3(math.pi/2, -math.pi/2, math.pi/2, qr[1])
Heis3.cx(qr[0],qr[1])
Heis3.u1(-2*delta12n,qr[1])
Heis3.cx(qr[0],qr[1])
Heis3.u3(-math.pi/2, -math.pi/2, math.pi/2, qr[0])
Heis3.u3(-math.pi/2, -math.pi/2, math.pi/2, qr[1])
# XX
Heis3.u3(-math.pi/2, 0.0, 0.0, qr[0])
Heis3.u3(-math.pi/2, 0.0, 0.0, qr[1])
Heis3.cx(qr[0],qr[1])
Heis3.u1(-2*delta12n,qr[1])
Heis3.cx(qr[0],qr[1])
Heis3.u3(math.pi/2, 0.0, 0.0, qr[0])
Heis3.u3(math.pi/2, 0.0, 0.0, qr[1])
# 2-3 bond mapped on qubits 1 and 2 in the quantum register
# ZZ
Heis3.cx(qr[1],qr[2])
Heis3.u1(-2*delta12n,qr[2])
Heis3.cx(qr[1],qr[2])
# YY
Heis3.u3(math.pi/2, -math.pi/2, math.pi/2, qr[1])
Heis3.u3(math.pi/2, -math.pi/2, math.pi/2, qr[2])
Heis3.cx(qr[1],qr[2])
Heis3.u1(-2*delta12n,qr[2])
Heis3.cx(qr[1],qr[2])
Heis3.u3(-math.pi/2, -math.pi/2, math.pi/2, qr[1])
Heis3.u3(-math.pi/2, -math.pi/2, math.pi/2, qr[2])
# XX
Heis3.u3(-math.pi/2, 0.0, 0.0, qr[1])
Heis3.u3(-math.pi/2, 0.0, 0.0, qr[2])
Heis3.cx(qr[1],qr[2])
Heis3.u1(-2*delta12n,qr[2])
Heis3.cx(qr[1],qr[2])
Heis3.u3(math.pi/2, 0.0, 0.0, qr[1])
Heis3.u3(math.pi/2, 0.0, 0.0, qr[2])
# measure
Heis3.measure(qr,cr)
# Run the quantum algorithm
backend = qk.Aer.get_backend('qasm_simulator')
job = qk.execute(Heis3, backend, shots=nshots)
result = job.result()
counts = result.get_counts()
# Post processing of outcomes to get sz expectation values
sz1q = 0
sz2q = 0
sz3q = 0
for key,value in counts.items():
if key == '000':
sz1q += value
sz2q += value
sz3q += value
elif key == '001':
sz1q -= value
sz2q += value
sz3q += value
elif key == '010':
sz1q += value
sz2q -= value
sz3q += value
elif key == '011':
sz1q -= value
sz2q -= value
sz3q += value
elif key == '100':
sz1q += value
sz2q += value
sz3q -= value
elif key == '101':
sz1q -= value
sz2q += value
sz3q -= value
elif key == '110':
sz1q += value
sz2q -= value
sz3q -= value
elif key == '111':
sz1q -= value
sz2q -= value
sz3q -= value
sz1q_t[k] = sz1q/nshots
sz2q_t[k] = sz2q/nshots
sz3q_t[k] = sz3q/nshots
fig = plt.figure()
ax = plt.subplot(111)
ax.plot(abs(J12)*c_times,0.5*sz1_t,'b', label='sz1 full')
ax.plot(abs(J12)*c_times,0.5*sz2_t,'r', label='sz2 full')
ax.plot(abs(J12)*c_times,0.5*sz3_t,'g', label='sz3 full')
ax.plot(abs(J12)*c_times,0.5*sz1st_t,'b--',label='sz1 n = ' + str(ntrotter) + ' (classical)')
ax.plot(abs(J12)*c_times,0.5*sz2st_t,'r--', label='sz2 n = ' + str(ntrotter) + ' (classical)')
ax.plot(abs(J12)*c_times,0.5*sz3st_t,'g--', label='sz3 n = ' + str(ntrotter) + ' (classical)')
ax.plot(abs(J12)*q_times,0.5*sz1q_t,'b*',label='sz1 n = ' + str(ntrotter) + ' (quantum)')
ax.plot(abs(J12)*q_times,0.5*sz2q_t,'ro', label='sz2 n = ' + str(ntrotter) + ' (quantum)')
ax.plot(abs(J12)*q_times,0.5*sz3q_t,'gd', label='sz3 n = ' + str(ntrotter) + ' (quantum)')
chartBox = ax.get_position()
ax.set_position([chartBox.x0, chartBox.y0, chartBox.width*1, chartBox.height])
ax.legend(loc='upper center', bbox_to_anchor=(1.3, 0.8), shadow=True, ncol=1)
plt.xlabel(r'$\delta_{12} = |J_{12}|t$')
plt.show()
qr = qk.QuantumRegister(1,name='qr')
cr = qk.ClassicalRegister(1,name='cr')
x_meas = qk.QuantumCircuit(qr,cr)
# Here you can add any quantum circuit generating the quantum state
# that you with to measure at the end e.g.
#
# x_meas.u3(a,b,c,qr[0])
#
# Measurement in x direction
x_meas.h(qr[0])
x_meas.measure(qr,cr)
x_meas.draw(output='mpl')
nshots = 8192
backend = qk.Aer.get_backend('qasm_simulator')
job = qk.execute(x_meas, backend, shots=nshots)
result = job.result()
counts = result.get_counts()
print(counts)
average_sigma_x = 0
for key,value in counts.items():
if key == '0':
average_sigma_x += value
elif key == '1':
average_sigma_x -= value
average_sigma_x = average_sigma_x/nshots
print('Average of sx = ', average_sigma_x)
theta_a = np.linspace(0.0, 2*math.pi, 21) # Some angles for the a vector, with respect to the z axis
theta_b = 0.0 # If the b vector is the z axis -> angle = 0
theta_c = math.pi/2 # If the vector c is the x axis -> angle = pi/2 with respect to z
# Quantum version
nshots = 1024
Pab = np.zeros(len(theta_a))
Pac = np.zeros(len(theta_a))
# Quantum circuit to measure Pbc
qr = qk.QuantumRegister(2, name='qr')
cr = qk.ClassicalRegister(2, name='cr')
qc = qk.QuantumCircuit(qr, cr)
## Initialize Bell state
qc.x(qr[0])
qc.x(qr[1])
qc.h(qr[0])
qc.cx(qr[0],qr[1])
## Pre measurement unitaries to select the basis along a (for the first qubit) and b (for the second qubit)
qc.u3(theta_b,0,0,qr[0])
qc.u3(theta_c,0,0,qr[1])
## Measures
qc.measure(qr[0], cr[0])
qc.measure(qr[1], cr[1])
## Running and saving result
backend = qk.Aer.get_backend('qasm_simulator')
job = qk.execute(qc, backend, shots=nshots)
result = job.result()
counts = result.get_counts()
out = 0
for key,value in counts.items():
if (key == '00') or (key == '11'):
out += value
elif (key == '01') or (key == '10'):
out -= value
Pbc = out/nshots
# Now we compute Pab and Pac for different a vectors
for i in range(len(theta_a)):
ta = theta_a[i]
# Quantum circuit to measure Pab with the given a
qr = qk.QuantumRegister(2, name='qr')
cr = qk.ClassicalRegister(2, name='cr')
qc = qk.QuantumCircuit(qr, cr)
## Initialize Bell state
qc.x(qr[0])
qc.x(qr[1])
qc.h(qr[0])
qc.cx(qr[0],qr[1])
## Pre measurement unitaries to select the basis along a (for the first qubit) and b (for the second qubit)
qc.u3(ta,0,0,qr[0])
qc.u3(theta_b,0,0,qr[1])
## Measures
qc.measure(qr[0], cr[0])
qc.measure(qr[1], cr[1])
## Running and saving result
backend = qk.Aer.get_backend('qasm_simulator')
job = qk.execute(qc, backend, shots=nshots)
result = job.result()
counts = result.get_counts()
out = 0
for key,value in counts.items():
if (key == '00') or (key == '11'):
out += value
elif (key == '01') or (key == '10'):
out -= value
Pab[i] = out/nshots
# Quantum circuit to measure Pac with the given a
qr = qk.QuantumRegister(2, name='qr')
cr = qk.ClassicalRegister(2, name='cr')
qc = qk.QuantumCircuit(qr, cr)
## Initialize Bell state
qc.x(qr[0])
qc.x(qr[1])
qc.h(qr[0])
qc.cx(qr[0],qr[1])
## Pre measurement unitaries to select the basis along a (for the first qubit) and c (for the second qubit)
qc.u3(ta,0,0,qr[0])
qc.u3(theta_c,0,0,qr[1])
## Measures
qc.measure(qr[0], cr[0])
qc.measure(qr[1], cr[1])
## Running and saving result
backend = qk.Aer.get_backend('qasm_simulator')
job = qk.execute(qc, backend, shots=nshots)
result = job.result()
counts = result.get_counts()
out = 0
for key,value in counts.items():
if (key == '00') or (key == '11'):
out += value
elif (key == '01') or (key == '10'):
out -= value
Pac[i] = out/nshots
quantum_outs = Pab-Pac
# Classical calculations
thetas = np.linspace(0,2*math.pi,100)
classical_outs = np.zeros(len(thetas))
b_vec = np.array([math.sin(theta_b),0.0,math.cos(theta_b)])
c_vec = np.array([math.sin(theta_c),0.0,math.cos(theta_c)])
Bell_limit = (1 - b_vec.dot(c_vec))*np.ones(len(thetas))
for k in range(len(thetas)):
a_vec = np.array([math.sin(thetas[k]),0.0,math.cos(thetas[k])])
classical_outs[k] = -a_vec.dot(b_vec) + a_vec.dot(c_vec)
fig = plt.figure()
ax = plt.subplot(111)
ax.plot(thetas,classical_outs,'b', label='classical computation')
ax.plot(theta_a,quantum_outs,'r*', label='quantum algorithm')
ax.plot(thetas,Bell_limit,'--k', label='Bell bound') # If the data go beyond these boundaries,
ax.plot(thetas,-Bell_limit,'--k', label='Bell bound') # the inequality is violated
ax.plot(thetas,(1+Pbc)*np.ones(len(thetas)),'--c', label='Bell bound (quantum)')
ax.plot(thetas,-(1+Pbc)*np.ones(len(thetas)),'--c', label='Bell bound (quantum)')
chartBox = ax.get_position()
ax.set_position([chartBox.x0, chartBox.y0, chartBox.width*1, chartBox.height])
ax.legend(loc='upper center', bbox_to_anchor=(1.3, 0.8), shadow=True, ncol=1)
plt.xlabel(r'$\theta_a$')
plt.show()
from qiskit.tools.monitor import job_monitor
my_token = ''
ibmq_provider = qk.IBMQ.enable_account(my_token)
delta = 0.5*math.pi
qr = qk.QuantumRegister(2,name='qr')
cr = qk.ClassicalRegister(2,name='cr')
Heis2 = qk.QuantumCircuit(qr,cr)
# Initial state preparation
Heis2.x(qr[0])
# ZZ
Heis2.cx(qr[0],qr[1])
Heis2.u1(-2*delta,qr[1])
Heis2.cx(qr[0],qr[1])
# YY
Heis2.u3(math.pi/2, -math.pi/2, math.pi/2, qr[0])
Heis2.u3(math.pi/2, -math.pi/2, math.pi/2, qr[1])
Heis2.cx(qr[0],qr[1])
Heis2.u1(-2*delta,qr[1])
Heis2.cx(qr[0],qr[1])
Heis2.u3(-math.pi/2, -math.pi/2, math.pi/2, qr[0])
Heis2.u3(-math.pi/2, -math.pi/2, math.pi/2, qr[1])
# XX
Heis2.u3(-math.pi/2, 0.0, 0.0, qr[0])
Heis2.u3(-math.pi/2, 0.0, 0.0, qr[1])
Heis2.cx(qr[0],qr[1])
Heis2.u1(-2*delta,qr[1])
Heis2.cx(qr[0],qr[1])
Heis2.u3(math.pi/2, 0.0, 0.0, qr[0])
Heis2.u3(math.pi/2, 0.0, 0.0, qr[1])
# measure
Heis2.measure(qr,cr)
my_backend = ibmq_provider.get_backend('ibmqx2')
job = qk.execute(Heis2, backend=my_backend, shots=1024)
job_monitor(job, interval=5)
result = job.result()
counts = result.get_counts()
print(counts)
plot_histogram(counts)
my_backend.configuration().coupling_map # In the output, the first entry in a pair [a,b] is a control, second is the
# corresponding target for a CNOT
|
https://github.com/IBMDeveloperUK/Hello-Quantum-World.
|
IBMDeveloperUK
|
import numpy as np
import networkx as nx
import qiskit
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, assemble
from qiskit.quantum_info import Statevector
from qiskit.aqua.algorithms import NumPyEigensolver
from qiskit.quantum_info import Pauli
from qiskit.aqua.operators import op_converter
from qiskit.aqua.operators import WeightedPauliOperator
from qiskit.visualization import plot_histogram
from qiskit.providers.aer.extensions.snapshot_statevector import *
from thirdParty.classical import rand_graph, classical, bitstring_to_path, calc_cost
from utils import mapeo_grafo
from collections import defaultdict
from operator import itemgetter
from scipy.optimize import minimize
import matplotlib.pyplot as plt
LAMBDA = 10
SEED = 10
SHOTS = 10000
# returns the bit index for an alpha and j
def bit(i_city, l_time, num_cities):
return i_city * num_cities + l_time
# e^(cZZ)
def append_zz_term(qc, q_i, q_j, gamma, constant_term):
qc.cx(q_i, q_j)
qc.rz(2*gamma*constant_term,q_j)
qc.cx(q_i, q_j)
# e^(cZ)
def append_z_term(qc, q_i, gamma, constant_term):
qc.rz(2*gamma*constant_term, q_i)
# e^(cX)
def append_x_term(qc,qi,beta):
qc.rx(-2*beta, qi)
def get_not_edge_in(G):
N = G.number_of_nodes()
not_edge = []
for i in range(N):
for j in range(N):
if i != j:
buffer_tupla = (i,j)
in_edges = False
for edge_i, edge_j in G.edges():
if ( buffer_tupla == (edge_i, edge_j) or buffer_tupla == (edge_j, edge_i)):
in_edges = True
if in_edges == False:
not_edge.append((i, j))
return not_edge
def get_classical_simplified_z_term(G, _lambda):
# recorrer la formula Z con datos grafo se va guardando en diccionario que acumula si coinciden los terminos
N = G.number_of_nodes()
E = G.edges()
# z term #
z_classic_term = [0] * N**2
# first term
for l in range(N):
for i in range(N):
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += -1 * _lambda
# second term
for l in range(N):
for j in range(N):
for i in range(N):
if i < j:
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 2
# z_jl
z_jl_index = bit(j, l, N)
z_classic_term[z_jl_index] += _lambda / 2
# third term
for i in range(N):
for l in range(N):
for j in range(N):
if l < j:
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 2
# z_ij
z_ij_index = bit(i, j, N)
z_classic_term[z_ij_index] += _lambda / 2
# fourth term
not_edge = get_not_edge_in(G) # include order tuples ej = (1,0), (0,1)
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 4
# z_j(l+1)
l_plus = (l+1) % N
z_jlplus_index = bit(j, l_plus, N)
z_classic_term[z_jlplus_index] += _lambda / 4
# fifthy term
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# z_il
z_il_index = bit(edge_i, l, N)
z_classic_term[z_il_index] += weight_ij / 4
# z_jlplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_j, l_plus, N)
z_classic_term[z_jlplus_index] += weight_ij / 4
# add order term because G.edges() do not include order tuples #
# z_i'l
z_il_index = bit(edge_j, l, N)
z_classic_term[z_il_index] += weight_ji / 4
# z_j'lplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_i, l_plus, N)
z_classic_term[z_jlplus_index] += weight_ji / 4
return z_classic_term
def tsp_obj_2(x, G,_lambda):
# obtenemos el valor evaluado en f(x_1, x_2,... x_n)
not_edge = get_not_edge_in(G)
N = G.number_of_nodes()
tsp_cost=0
#Distancia
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# x_il
x_il_index = bit(edge_i, l, N)
# x_jlplus
l_plus = (l+1) % N
x_jlplus_index = bit(edge_j, l_plus, N)
tsp_cost+= int(x[x_il_index]) * int(x[x_jlplus_index]) * weight_ij
# add order term because G.edges() do not include order tuples #
# x_i'l
x_il_index = bit(edge_j, l, N)
# x_j'lplus
x_jlplus_index = bit(edge_i, l_plus, N)
tsp_cost += int(x[x_il_index]) * int(x[x_jlplus_index]) * weight_ji
#Constraint 1
for l in range(N):
penal1 = 1
for i in range(N):
x_il_index = bit(i, l, N)
penal1 -= int(x[x_il_index])
tsp_cost += _lambda * penal1**2
#Contstraint 2
for i in range(N):
penal2 = 1
for l in range(N):
x_il_index = bit(i, l, N)
penal2 -= int(x[x_il_index])
tsp_cost += _lambda*penal2**2
#Constraint 3
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# x_il
x_il_index = bit(i, l, N)
# x_j(l+1)
l_plus = (l+1) % N
x_jlplus_index = bit(j, l_plus, N)
tsp_cost += int(x[x_il_index]) * int(x[x_jlplus_index]) * _lambda
return tsp_cost
def get_classical_simplified_zz_term(G, _lambda):
# recorrer la formula Z con datos grafo se va guardando en diccionario que acumula si coinciden los terminos
N = G.number_of_nodes()
E = G.edges()
# zz term #
zz_classic_term = [[0] * N**2 for i in range(N**2) ]
# first term
for l in range(N):
for j in range(N):
for i in range(N):
if i < j:
# z_il
z_il_index = bit(i, l, N)
# z_jl
z_jl_index = bit(j, l, N)
zz_classic_term[z_il_index][z_jl_index] += _lambda / 2
# second term
for i in range(N):
for l in range(N):
for j in range(N):
if l < j:
# z_il
z_il_index = bit(i, l, N)
# z_ij
z_ij_index = bit(i, j, N)
zz_classic_term[z_il_index][z_ij_index] += _lambda / 2
# third term
not_edge = get_not_edge_in(G)
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# z_il
z_il_index = bit(i, l, N)
# z_j(l+1)
l_plus = (l+1) % N
z_jlplus_index = bit(j, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += _lambda / 4
# fourth term
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# z_il
z_il_index = bit(edge_i, l, N)
# z_jlplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_j, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += weight_ij / 4
# add order term because G.edges() do not include order tuples #
# z_i'l
z_il_index = bit(edge_j, l, N)
# z_j'lplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_i, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += weight_ji / 4
return zz_classic_term
def get_classical_simplified_hamiltonian(G, _lambda):
# z term #
z_classic_term = get_classical_simplified_z_term(G, _lambda)
# zz term #
zz_classic_term = get_classical_simplified_zz_term(G, _lambda)
return z_classic_term, zz_classic_term
def get_cost_circuit(G, gamma, _lambda):
N = G.number_of_nodes()
N_square = N**2
qc = QuantumCircuit(N_square,N_square)
z_classic_term, zz_classic_term = get_classical_simplified_hamiltonian(G, _lambda)
# z term
for i in range(N_square):
if z_classic_term[i] != 0:
append_z_term(qc, i, gamma, z_classic_term[i])
# zz term
for i in range(N_square):
for j in range(N_square):
if zz_classic_term[i][j] != 0:
append_zz_term(qc, i, j, gamma, zz_classic_term[i][j])
return qc
def get_mixer_operator(G,beta):
N = G.number_of_nodes()
qc = QuantumCircuit(N**2,N**2)
for n in range(N**2):
append_x_term(qc, n, beta)
return qc
def get_QAOA_circuit(G, beta, gamma, _lambda):
assert(len(beta)==len(gamma))
N = G.number_of_nodes()
qc = QuantumCircuit(N**2,N**2)
# init min mix state
qc.h(range(N**2))
p = len(beta)
for i in range(p):
qc = qc.compose(get_cost_circuit(G, gamma[i], _lambda))
qc = qc.compose(get_mixer_operator(G, beta[i]))
qc.barrier(range(N**2))
qc.snapshot_statevector("final_state")
qc.measure(range(N**2),range(N**2))
return qc
def invert_counts(counts):
return {k[::-1] :v for k,v in counts.items()}
# Sample expectation value
def compute_tsp_energy_2(counts, G):
energy = 0
get_counts = 0
total_counts = 0
for meas, meas_count in counts.items():
obj_for_meas = tsp_obj_2(meas, G, LAMBDA)
energy += obj_for_meas*meas_count
total_counts += meas_count
mean = energy/total_counts
return mean
def get_black_box_objective_2(G,p):
backend = Aer.get_backend('qasm_simulator')
sim = Aer.get_backend('aer_simulator')
# function f costo
def f(theta):
beta = theta[:p]
gamma = theta[p:]
# Anzats
qc = get_QAOA_circuit(G, beta, gamma, LAMBDA)
result = execute(qc, backend, seed_simulator=SEED, shots= SHOTS).result()
final_state_vector = result.data()["snapshots"]["statevector"]["final_state"][0]
state_vector = Statevector(final_state_vector)
probabilities = state_vector.probabilities()
probabilities_states = invert_counts(state_vector.probabilities_dict())
expected_value = 0
for state,probability in probabilities_states.items():
cost = tsp_obj_2(state, G, LAMBDA)
expected_value += cost*probability
counts = result.get_counts()
mean = compute_tsp_energy_2(invert_counts(counts),G)
return mean
return f
def crear_grafo(cantidad_ciudades):
pesos, conexiones = None, None
mejor_camino = None
while not mejor_camino:
pesos, conexiones = rand_graph(cantidad_ciudades)
mejor_costo, mejor_camino = classical(pesos, conexiones, loop=False)
G = mapeo_grafo(conexiones, pesos)
return G, mejor_costo, mejor_camino
def run_QAOA(p,ciudades, grafo):
if grafo == None:
G, mejor_costo, mejor_camino = crear_grafo(ciudades)
print("Mejor Costo")
print(mejor_costo)
print("Mejor Camino")
print(mejor_camino)
print("Bordes del grafo")
print(G.edges())
print("Nodos")
print(G.nodes())
print("Pesos")
labels = nx.get_edge_attributes(G,'weight')
print(labels)
else:
G = grafo
intial_random = []
# beta, mixer Hammiltonian
for i in range(p):
intial_random.append(np.random.uniform(0,np.pi))
# gamma, cost Hammiltonian
for i in range(p):
intial_random.append(np.random.uniform(0,2*np.pi))
init_point = np.array(intial_random)
obj = get_black_box_objective_2(G,p)
res_sample = minimize(obj, init_point,method="COBYLA",options={"maxiter":2500,"disp":True})
print(res_sample)
if __name__ == '__main__':
# Run QAOA parametros: profundidad p, numero d ciudades,
run_QAOA(5, 3, None)
|
https://github.com/crabster/qiskit-learning
|
crabster
|
import qiskit
from .common_gates import *
import random
def superdense_coding_circuit(msg):
qc = qiskit.QuantumCircuit(2)
phi_plus = phi_plus_gate()
qc.append(phi_plus, [0, 1])
qc.barrier()
if msg[1] == '1':
qc.z(0)
if msg[0] == '1':
qc.x(0)
qc.barrier()
qc.append(phi_plus.inverse(), [0, 1])
qc.name = "SC"
return qc
def superdense_coding_example():
msg = random.choice(["00", "01", "10", "11"])
qc = qiskit.QuantumCircuit(2, 2)
sc_qc = superdense_coding_circuit(msg)
qc.append(sc_qc, [0, 1])
if msg[0] == '1':
qc.x(1)
if msg[1] == '1':
qc.x(0)
qc.measure([0, 1], [0, 1])
print(msg)
print(qc.draw(output="text"))
return qc
|
https://github.com/aryashah2k/Quantum-Computing-Collection-Of-Resources
|
aryashah2k
|
%run qlatvia.py
draw_qubit_grover()
draw_quantum_state((5/8)**0.5,(3/8)**0.5,"|u>")
def query(elements=[1],marked_elements=[0]):
for i in marked_elements:
elements[i] = -1 * elements[i]
return elements
def inversion (elements=[1]):
# summation of all values
summation = 0
for i in range(len(elements)):
summation += elements[i]
# mean of all values
mean = summation / len(elements)
# reflection over mean
for i in range(len(elements)):
value = elements[i]
new_value = mean - (elements[i]-mean)
elements[i] = new_value
return elements
from math import asin, pi
# initial values
iteration = 5
N = 16
marked_elements = [0]
k = len(marked_elements)
elements = []
states_on_unit_circle= []
# initial quantum state
for i in range(N):
elements.append(1/N**0.5)
x = elements[N-1] * ((N-k)**0.5)
y = elements[0] * (k**0.5)
states_on_unit_circle.append([x,y,"0"])
# Execute Grover's search algorithm for $iteration steps
for step in range(iteration):
# query
elements = query(elements,marked_elements)
x = elements[N-1] * ((N-k)**0.5)
y = elements[0] * (k**0.5)
states_on_unit_circle.append([x,y,str(step)+"''"])
# inversion
elements = inversion(elements)
x = elements[N-1] * ((N-k)**0.5)
y = elements[0] * (k**0.5)
states_on_unit_circle.append([x,y,str(step+1)])
# draw all states
%run qlatvia.py
draw_qubit_grover()
for state in states_on_unit_circle:
draw_quantum_state(state[0],state[1],state[2])
# print the angles
print("angles in degree")
for state in states_on_unit_circle:
print(asin(state[1])/pi*180)
def query(elements=[1],marked_elements=[0]):
for i in marked_elements:
elements[i] = -1 * elements[i]
return elements
def inversion (elements=[1]):
# summation of all values
summation = 0
for i in range(len(elements)):
summation += elements[i]
# mean of all values
mean = summation / len(elements)
# reflection over mean
for i in range(len(elements)):
value = elements[i]
new_value = mean - (elements[i]-mean)
elements[i] = new_value
return elements
from math import asin, pi
# initial values
iteration = 10
N = 128
# try each case one by one
marked_elements = [0]
#marked_elements = [0,1]
#marked_elements = [0,1,2,3]
#marked_elements = [0,1,2,3,4,5,6,7]
k = len(marked_elements)
elements = []
states_on_unit_circle= []
# initial quantum state
for i in range(N):
elements.append(1/N**0.5)
x = elements[N-1] * ((N-k)**0.5)
y = elements[0] * (k**0.5)
states_on_unit_circle.append([x,y,"0"])
# Execute Grover's search algorithm for $iteration steps
for step in range(iteration):
# query
elements = query(elements,marked_elements)
x = elements[N-1] * ((N-k)**0.5)
y = elements[0] * (k**0.5)
states_on_unit_circle.append([x,y,str(step)+"''"])
# inversion
elements = inversion(elements)
x = elements[N-1] * ((N-k)**0.5)
y = elements[0] * (k**0.5)
states_on_unit_circle.append([x,y,str(step+1)])
# draw all states
%run qlatvia.py
draw_qubit_grover()
for state in states_on_unit_circle:
draw_quantum_state(state[0],state[1],state[2])
# print the angles
print("angles in degree")
for state in states_on_unit_circle:
print(asin(state[1])/pi*180)
def query(elements=[1],marked_elements=[0]):
for i in marked_elements:
elements[i] = -1 * elements[i]
return elements
def inversion (elements=[1]):
# summation of all values
summation = 0
for i in range(len(elements)):
summation += elements[i]
# mean of all values
mean = summation / len(elements)
# reflection over mean
for i in range(len(elements)):
value = elements[i]
new_value = mean - (elements[i]-mean)
elements[i] = new_value
return elements
from math import asin, pi
# initial values
iteration = 20
#iteration = 10
N = 256
# try each case one by one
marked_elements = [0]
#marked_elements = [0,1]
#marked_elements = [0,1,2,3]
#marked_elements = [0,1,2,3,4,5,6,7]
k = len(marked_elements)
elements = []
states_on_unit_circle= []
# initial quantum state
for i in range(N):
elements.append(1/N**0.5)
x = elements[N-1] * ((N-k)**0.5)
y = elements[0] * (k**0.5)
states_on_unit_circle.append([x,y,"0"])
# Execute Grover's search algorithm for $iteration steps
for step in range(iteration):
# query
elements = query(elements,marked_elements)
x = elements[N-1] * ((N-k)**0.5)
y = elements[0] * (k**0.5)
states_on_unit_circle.append([x,y,str(step)+"''"])
# inversion
elements = inversion(elements)
x = elements[N-1] * ((N-k)**0.5)
y = elements[0] * (k**0.5)
states_on_unit_circle.append([x,y,str(step+1)])
# draw all states
%run qlatvia.py
draw_qubit_grover()
for state in states_on_unit_circle:
draw_quantum_state(state[0],state[1],state[2])
# print the angles
print("angles in degree")
for state in states_on_unit_circle:
print(asin(state[1])/pi*180)
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
#Program 1.1 The first quantum program
from qiskit import QuantumCircuit
print("Hello, Qubit!")
qc = QuantumCircuit(1,1)
qc.measure([0], [0])
print("This is a quantum circuit of 1 qubit and 1 bit:")
qc.draw('mpl')
#Program 1.2 Design a quantum circuit with 5 qubits and 3 classical bits
from qiskit import QuantumCircuit
print("This is a quantum circuit of 5 qubits and 2 bits:")
qc = QuantumCircuit(5, 2)
qc.measure([1,3], [0,1])
qc.draw('mpl')
#Program 1.3 Name and label quantum bits and classical bits
from qiskit import QuantumRegister,ClassicalRegister,QuantumCircuit
qrx = QuantumRegister(3,'x')
qry = QuantumRegister(2,'y')
qrz = QuantumRegister(1,'z')
cr = ClassicalRegister(4,'c')
qc = QuantumCircuit(qrx,qry,qrz,cr)
qc.measure([qrx[1],qrx[2]], [cr[0],cr[1]])
qc.measure([4,5], [2,3])
qc.draw('mpl')
#Program 1.4 Transpile and execute quantum circuit on simulator
from qiskit import QuantumCircuit, transpile, execute
from qiskit.providers.aer import AerSimulator
sim = AerSimulator()
qc = QuantumCircuit(1, 1)
qc.measure([0], [0])
print(qc)
cqc = transpile(qc, sim)
job=execute(cqc, backend=sim, shots=1000)
result = job.result()
counts = result.get_counts(qc)
print("Total counts for qubit states are:",counts)
#Program 1.5 Execute quantum circuit (program) on simulator
from qiskit import QuantumCircuit, execute
from qiskit.providers.aer import AerSimulator
sim = AerSimulator()
qc = QuantumCircuit(1, 1)
qc.measure([0], [0])
print(qc)
job=execute(qc, backend=sim, shots=1000)
result = job.result()
counts = result.get_counts(qc)
print("Total counts for qubit states are:",counts)
#Program 1.6 Execute quantum circuit (program) on least busy quantum computer
from qiskit import QuantumCircuit, IBMQ, execute
from qiskit.providers.ibmq import least_busy
from qiskit.tools.monitor import job_monitor
qc = QuantumCircuit(1, 1)
qc.measure([0], [0])
print(qc)
IBMQ.save_account('your_token',overwrite=True)
IBMQ.load_account()
provider=IBMQ.get_provider(group='open')
print(provider)
qcomp = least_busy(provider.backends(simulator=False))
print("The least busy quantum computer is:",qcomp)
job=execute(qc, backend=qcomp, shots=1000)
job_monitor(job)
result = job.result()
counts = result.get_counts(qc)
print("Total counts for qubit states are:",counts)
#Program 1.7 Execute quantum circuit (program) on proper quantum computer
from qiskit import QuantumCircuit, IBMQ, execute
from qiskit.tools.monitor import job_monitor
qc = QuantumCircuit(1, 1)
qc.measure([0], [0])
print(qc)
#IBMQ.save_account('......',overwrite=True)
#IBMQ.load_account()
provider = IBMQ.get_provider(group='open')
qcomp = provider.get_backend('ibmq_lima')
job=execute(qc, backend=qcomp, shots=1000)
job_monitor(job)
result = job.result()
counts = result.get_counts(qc)
print("Total counts for qubit states are:",counts)
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.draw("mpl")
|
https://github.com/carstenblank/dc-qiskit-algorithms
|
carstenblank
|
# Copyright 2018 Carsten Blank
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import unittest
from typing import List
import numpy as np
import qiskit
from ddt import ddt, data as test_data, unpack
from qiskit import QuantumRegister, QuantumCircuit, ClassicalRegister
from qiskit.result import Result
from qiskit_aer import StatevectorSimulator, QasmSimulator
from dc_qiskit_algorithms.FlipFlopQuantumRam import FFQramDb, add_vector
@ddt
class FlipFlopQuantumRamnStatePrepTests(unittest.TestCase):
def execute_test(self, vector: List[float]):
probability_vector = [np.absolute(e)**2 for e in vector]
print("Input Vector (state) & its measurement probability:")
print(["{0:.3f}".format(e) for e in vector])
print(["{0:.3f}".format(e) for e in probability_vector])
db = FFQramDb()
add_vector(db, vector)
bus = QuantumRegister(db.bus_size(), "bus")
reg = QuantumRegister(1, "reg")
c_bus = ClassicalRegister(db.bus_size(), "c_bus")
c_reg = ClassicalRegister(1, "c_reg")
qc = QuantumCircuit(bus, reg, c_bus, c_reg, name='state prep')
qc.h(bus)
db.add_to_circuit(qc, bus, reg[0])
local_backend: StatevectorSimulator = qiskit.Aer.get_backend('statevector_simulator')
job = qiskit.execute(qc, backend=local_backend, shots=1)
result = job.result() # type: Result
# State vector
result_state_vector = result.get_statevector('state prep')
print("Full simulated state vector (n+1!)")
print(["{0:.2f}".format(e) for e in result_state_vector])
correct_branch_state = np.asarray(result_state_vector)[8:]
correct_branch_state = correct_branch_state / np.linalg.norm(correct_branch_state)
print("State vector on the correct (1) branch:")
print(["{0:.2f}".format(e) for e in correct_branch_state])
positive_global_phase_all_almost_equal = all(abs(a - e) < 0.02 for a, e in zip(vector, correct_branch_state))
negative_global_phase_all_almost_equal = all(abs(a + e) < 0.02 for a, e in zip(vector, correct_branch_state))
self.assertTrue(positive_global_phase_all_almost_equal or negative_global_phase_all_almost_equal)
# Probability Vector by Measurement
qc.measure(bus, c_bus)
qc.measure(reg, c_reg)
local_qasm_backend: QasmSimulator = qiskit.Aer.get_backend('qasm_simulator')
shots = 2**16
job = qiskit.execute(qc, backend=local_qasm_backend, shots=shots)
result = job.result() # type: Result
counts = result.get_counts('state prep')
measurement_probability_vector = [0.0 for e in probability_vector]
shot_post_measurement = sum(c for b, c in counts.items() if b.startswith("1 "))
print("Probability to be on the correct (1) branch: %.4f" % (shot_post_measurement / shots))
for binary, count in sorted(counts.items()):
[reg, bus] = binary.split(' ')
if reg == '1':
index = int(bus, 2)
probability = float(count) / float(shot_post_measurement)
# print("%s (%d): %.3f" % (bus, index, probability))
measurement_probability_vector[index] = probability
print("Measurement Probability on the correct (1) branch:")
print(["{0:.3f}".format(e) for e in measurement_probability_vector])
for expected, actual in zip(probability_vector, measurement_probability_vector):
self.assertAlmostEqual(expected, actual, delta=0.05)
@unpack
@test_data(
{'vector': [-0.1, 0.2, -0.3, 0.4, -0.5, 0.6, -0.7, 0.8]},
{'vector': [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]},
{'vector': [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]},
{'vector': [0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0]},
{'vector': [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0]},
{'vector': [0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0]},
{'vector': [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0]},
{'vector': [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0]},
{'vector': [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0]}
)
def test_state_preparation(self, vector):
self.check_add_vector(vector)
vector = np.asarray(vector)
vector = (1 / np.linalg.norm(vector)) * vector
self.execute_test(list(vector))
def check_add_vector(self, vector):
unit_vector = np.asarray(vector)
l2_norm = np.linalg.norm(unit_vector)
unit_vector = unit_vector / l2_norm
labels = [i for i, v in enumerate(unit_vector) if abs(v) > 1e-6]
db = FFQramDb()
add_vector(db, vector)
check_labels = [int.from_bytes(e.label, byteorder='big') for e in db]
self.assertListEqual(labels, check_labels)
if __name__ == '__main__':
unittest.main(verbosity=2)
|
https://github.com/cjsproject/qiskit_learning
|
cjsproject
|
%matplotlib inline
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, execute, Aer, IBMQ, assemble
from qiskit.visualization import *
from os import environ
#local environment variable to store the access token :)
token = environ.get('ibmq_token')
# Loading your IBM Q account(s)
account = IBMQ.save_account(token, overwrite=True)
provider = IBMQ.load_account()
# quasm_sim not necessary
simulator = Aer.get_backend('qasm_simulator')
import numpy as np
data = [0.1, 0.2, 0.3, 0.4]
angles = []
"""# normalize the datapoints if datapoints >= 1
max_val = max(digit_data[0])
norm_data = []
for i in A:
temp_row = []
for j in i:
temp_row.append(j/max_val)
norm_data.append(temp_row)
print(norm_data)
"""
# encode data as angular rotations on bloch sphere
for i in data:
angles.append(2*np.arcsin(np.sqrt(i)))
print(data, angles, sep='\n')
# circuit with 2 qubits, 2 cbits
qc = QuantumCircuit(4, 4)
# apply RY gate using theta
for i in range(4):
qc.ry(angles[i], i)
# measure each qubit's output
for i in range(4):
qc.measure(i, i)
qc.draw()
# run simulation 100000 times, stores results in counts
job = execute(qc, simulator, shots=100000)
results = job.result()
counts = results.get_counts(qc)
plot_histogram(counts)
# retrieving original data as the
# expected value of each set of bits i.e
# add probabilities of all outputs with their 4th bit set on
bit4 = []
bit3 = []
bit2 = []
bit1 = []
# creating an array to access E(psi) more easily
for i in counts:
prob = counts[i]/100000
bit4.append([i[0], prob])
bit3.append([i[1], prob])
bit2.append([i[2], prob])
bit1.append([i[3], prob])
# array of bit's arrays...
bits = [bit4, bit3, bit2, bit1]
q_data = []
# finding the expected value of each bit, appending to array
for nth_bit in bits:
e_val = 0.0
for bit in nth_bit:
# print(bit[0], bit[1])
if int(bit[0]) == 1:
e_val += bit[1]
# print('added')
q_data.append(round(e_val, 2))
print(q_data, '\nData Retrieved, just backwards')
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
"""
Test Script
"""
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
qrx = QuantumRegister(1, 'q0')
qry = QuantumRegister(1, 'q1')
cr = ClassicalRegister(1, 'c')
qc = QuantumCircuit(qrx, qry, cr)
qc.h(qrx)
qc.x(qry)
qc.h(qry)
qc.barrier()
qc.x(qry)
qc.barrier()
qc.h(qrx)
qc.h(qry)
qc.measure(qrx, cr)
qc.draw("mpl")
from qiskit import execute
from qiskit.providers.aer import AerSimulator
from qiskit.visualization import plot_histogram
sim = AerSimulator()
job = execute(qc, backend = sim, shots = 1000)
result = job.result()
counts = result.get_counts(qc)
print("Counts: ", counts)
plot_histogram(counts)
|
https://github.com/shantomborah/Quantum-Algorithms
|
shantomborah
|
import numpy as np
from math import pi
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import Aer, execute
from qiskit.circuit import Gate
from qiskit.visualization import plot_histogram
from qiskit.circuit.library.standard_gates import ZGate, XGate
# Define circuit parameters
a = '10x01xx'
n = len(a)
k = 7
circ = QuantumCircuit(k+n, k)
circ.reset(range(k+n))
circ.h(range(k+n))
circ.barrier()
for i in range(k):
name = '$G_' + str(i) + '$'
circ.append(QuantumCircuit(n, name=name).to_gate().control(1), [n+i]+list(range(n)))
circ.barrier()
circ.append(Gate(name="$QFT^{-1}$", num_qubits=k, params=[]), range(n, k+n))
circ.barrier()
circ.measure(range(n, k+n), range(k))
circ.draw('mpl', reverse_bits=True, scale=0.5)
def Gop(j):
p = 2 ** j
ctrl_bits = []
ctrl_state = ''
for i in range(n):
if a[n-i-1] != 'x':
ctrl_bits.append(i+1)
ctrl_state += a[n-i-1]
G = QuantumCircuit(n+1, name='G'+str(j))
for i in range(p):
G.append(XGate().control(len(ctrl_bits), ctrl_state=ctrl_state[::-1]), ctrl_bits + [0])
G.h(range(1, n+1))
G.x(range(1, n+1))
G.append(ZGate().control(n-1), reversed(range(1, n+1)))
G.x(range(1, n+1))
G.h(range(1, n+1))
return G
Gop(3).draw('mpl', reverse_bits=True, scale=0.5)
QFT_inv = QuantumCircuit(k, name='QFT^{-1}')
for i in reversed(range(k)):
if i != k-1:
QFT_inv.barrier()
for j in reversed(range(i+1,k)):
QFT_inv.cu1(-pi/(2 ** (j-i)), i, j)
QFT_inv.h(i)
QFT_inv.draw('mpl', reverse_bits=True)
circ = QuantumCircuit(k+n+1, k)
circ.reset(range(k+n+1))
circ.x(0)
circ.h(range(k+n+1))
circ.z(n+1)
circ.barrier()
for i in range(k):
circ.append(Gop(i).to_gate().control(1), [n+i+1]+list(range(n+1)))
circ.barrier()
circ.append(QFT_inv, range(n+1, k+n+1))
circ.barrier()
circ.measure(range(n+1, k+n+1), range(k))
circ.draw(reverse_bits=True, scale=0.5)
delta = 64
simulator = Aer.get_backend('qasm_simulator')
result = execute(circ, simulator, shots=delta).result()
counts = result.get_counts(circ)
plot_histogram(counts)
x = list(counts.keys())
x = [pi*int(i[::-1], 2)/(2 ** k) for i in x]
p = list(counts.values())
p = p.index(max(p))
theta = min(x[p], pi-x[p])
m_estimate = (2 ** n) * (theta ** 2)
m = 2 ** a.count('x')
print('Estimated Count:')
print(m_estimate)
print('Actual Count:')
print(m)
|
https://github.com/2lambda123/Qiskit-qiskit
|
2lambda123
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2023, 2024.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
""" Test of GenericBackendV2 backend"""
import math
from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister, transpile
from qiskit.providers.fake_provider import GenericBackendV2
from qiskit.transpiler import CouplingMap
from qiskit.exceptions import QiskitError
from test import QiskitTestCase # pylint: disable=wrong-import-order
class TestGenericBackendV2(QiskitTestCase):
"""Test class for GenericBackendV2 backend"""
def setUp(self):
super().setUp()
self.cmap = CouplingMap(
[(0, 2), (0, 1), (1, 3), (2, 4), (2, 3), (3, 5), (4, 6), (4, 5), (5, 7), (6, 7)]
)
def test_supported_basis_gates(self):
"""Test that target raises error if basis_gate not in ``supported_names``."""
with self.assertRaises(QiskitError):
GenericBackendV2(num_qubits=8, basis_gates=["cx", "id", "rz", "sx", "zz"])
def test_operation_names(self):
"""Test that target basis gates include "delay", "measure" and "reset" even
if not provided by user."""
target = GenericBackendV2(num_qubits=8)
op_names = list(target.operation_names)
op_names.sort()
self.assertEqual(op_names, ["cx", "delay", "id", "measure", "reset", "rz", "sx", "x"])
target = GenericBackendV2(num_qubits=8, basis_gates=["ecr", "id", "rz", "sx", "x"])
op_names = list(target.operation_names)
op_names.sort()
self.assertEqual(op_names, ["delay", "ecr", "id", "measure", "reset", "rz", "sx", "x"])
def test_incompatible_coupling_map(self):
"""Test that the size of the coupling map must match num_qubits."""
with self.assertRaises(QiskitError):
GenericBackendV2(num_qubits=5, coupling_map=self.cmap)
def test_control_flow_operation_names(self):
"""Test that control flow instructions are added to the target if control_flow is True."""
target = GenericBackendV2(
num_qubits=8,
basis_gates=["ecr", "id", "rz", "sx", "x"],
coupling_map=self.cmap,
control_flow=True,
).target
op_names = list(target.operation_names)
op_names.sort()
reference = [
"break",
"continue",
"delay",
"ecr",
"for_loop",
"id",
"if_else",
"measure",
"reset",
"rz",
"switch_case",
"sx",
"while_loop",
"x",
]
self.assertEqual(op_names, reference)
def test_default_coupling_map(self):
"""Test that fully-connected coupling map is generated correctly."""
# fmt: off
reference_cmap = [(0, 1), (1, 0), (0, 2), (2, 0), (0, 3), (3, 0), (0, 4), (4, 0), (1, 2), (2, 1),
(1, 3), (3, 1), (1, 4), (4, 1), (2, 3), (3, 2), (2, 4), (4, 2), (3, 4), (4, 3)]
# fmt: on
self.assertEqual(
list(GenericBackendV2(num_qubits=5).coupling_map.get_edges()),
reference_cmap,
)
def test_run(self):
"""Test run method, confirm correct noisy simulation if Aer is installed."""
qr = QuantumRegister(5)
cr = ClassicalRegister(5)
qc = QuantumCircuit(qr, cr)
qc.h(qr[0])
for k in range(1, 4):
qc.cx(qr[0], qr[k])
qc.measure(qr, cr)
backend = GenericBackendV2(num_qubits=5, basis_gates=["cx", "id", "rz", "sx", "x"])
tqc = transpile(qc, backend=backend, optimization_level=3, seed_transpiler=42)
result = backend.run(tqc, seed_simulator=42, shots=1000).result()
counts = result.get_counts()
self.assertTrue(math.isclose(counts["00000"], 500, rel_tol=0.1))
self.assertTrue(math.isclose(counts["01111"], 500, rel_tol=0.1))
def test_duration_defaults(self):
"""Test that the basis gates are assigned duration defaults within expected ranges."""
basis_gates = ["cx", "id", "rz", "sx", "x", "sdg", "rxx"]
expected_durations = {
"cx": (7.992e-08, 8.99988e-07),
"id": (2.997e-08, 5.994e-08),
"rz": (0.0, 0.0),
"sx": (2.997e-08, 5.994e-08),
"x": (2.997e-08, 5.994e-08),
"measure": (6.99966e-07, 1.500054e-06),
"sdg": (2.997e-08, 5.994e-08),
"rxx": (7.992e-08, 8.99988e-07),
}
for _ in range(20):
target = GenericBackendV2(num_qubits=2, basis_gates=basis_gates).target
for inst in target:
for qargs in target.qargs_for_operation_name(inst):
duration = target[inst][qargs].duration
if inst not in ["delay", "reset"]:
self.assertGreaterEqual(duration, expected_durations[inst][0])
self.assertLessEqual(duration, expected_durations[inst][1])
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# pylint: disable=wrong-import-order
"""Main Qiskit public functionality."""
import pkgutil
# First, check for required Python and API version
from . import util
# qiskit errors operator
from .exceptions import QiskitError
# The main qiskit operators
from qiskit.circuit import ClassicalRegister
from qiskit.circuit import QuantumRegister
from qiskit.circuit import QuantumCircuit
# pylint: disable=redefined-builtin
from qiskit.tools.compiler import compile # TODO remove after 0.8
from qiskit.execute import execute
# The qiskit.extensions.x imports needs to be placed here due to the
# mechanism for adding gates dynamically.
import qiskit.extensions
import qiskit.circuit.measure
import qiskit.circuit.reset
# Allow extending this namespace. Please note that currently this line needs
# to be placed *before* the wrapper imports or any non-import code AND *before*
# importing the package you want to allow extensions for (in this case `backends`).
__path__ = pkgutil.extend_path(__path__, __name__)
# Please note these are global instances, not modules.
from qiskit.providers.basicaer import BasicAer
# Try to import the Aer provider if installed.
try:
from qiskit.providers.aer import Aer
except ImportError:
pass
# Try to import the IBMQ provider if installed.
try:
from qiskit.providers.ibmq import IBMQ
except ImportError:
pass
from .version import __version__
from .version import __qiskit_version__
|
https://github.com/esquivelgor/Quantum-Route-Minimizer
|
esquivelgor
|
from qiskit import *
import numpy as np
from numpy import linalg as la
from qiskit.tools.monitor import job_monitor
import qiskit.tools.jupyter
qc = QuantumCircuit(1)
#### your code goes here
# z measurement of qubit 0
measure_z = QuantumCircuit(1,1)
measure_z.measure(0,0)
# x measurement of qubit 0
measure_x = QuantumCircuit(1,1)
# your code goes here
# y measurement of qubit 0
measure_y = QuantumCircuit(1,1)
# your code goes here
shots = 2**14 # number of samples used for statistics
sim = Aer.get_backend('qasm_simulator')
bloch_vector_measure = []
for measure_circuit in [measure_x, measure_y, measure_z]:
# run the circuit with a the selected measurement and get the number of samples that output each bit value
counts = execute(qc+measure_circuit, sim, shots=shots).result().get_counts()
# calculate the probabilities for each bit value
probs = {}
for output in ['0','1']:
if output in counts:
probs[output] = counts[output]/shots
else:
probs[output] = 0
bloch_vector_measure.append( probs['0'] - probs['1'] )
# normalizing the bloch sphere vector
bloch_vector = bloch_vector_measure/la.norm(bloch_vector_measure)
print('The bloch sphere coordinates are [{0:4.3f}, {1:4.3f}, {2:4.3f}]'
.format(*bloch_vector))
from kaleidoscope.interactive import bloch_sphere
bloch_sphere(bloch_vector, vectors_annotation=True)
from qiskit.visualization import plot_bloch_vector
plot_bloch_vector( bloch_vector )
# circuit for the state Tri1
Tri1 = QuantumCircuit(2)
# your code goes here
# circuit for the state Tri2
Tri2 = QuantumCircuit(2)
# your code goes here
# circuit for the state Tri3
Tri3 = QuantumCircuit(2)
# your code goes here
# circuit for the state Sing
Sing = QuantumCircuit(2)
# your code goes here
# <ZZ>
measure_ZZ = QuantumCircuit(2)
measure_ZZ.measure_all()
# <XX>
measure_XX = QuantumCircuit(2)
# your code goes here
# <YY>
measure_YY = QuantumCircuit(2)
# your code goes here
shots = 2**14 # number of samples used for statistics
A = 1.47e-6 #unit of A is eV
E_sim = []
for state_init in [Tri1,Tri2,Tri3,Sing]:
Energy_meas = []
for measure_circuit in [measure_XX, measure_YY, measure_ZZ]:
# run the circuit with a the selected measurement and get the number of samples that output each bit value
qc = state_init+measure_circuit
counts = execute(qc, sim, shots=shots).result().get_counts()
# calculate the probabilities for each computational basis
probs = {}
for output in ['00','01', '10', '11']:
if output in counts:
probs[output] = counts[output]/shots
else:
probs[output] = 0
Energy_meas.append( probs['00'] - probs['01'] - probs['10'] + probs['11'] )
E_sim.append(A * np.sum(np.array(Energy_meas)))
# Run this cell to print out your results
print('Energy expection value of the state Tri1 : {:.3e} eV'.format(E_sim[0]))
print('Energy expection value of the state Tri2 : {:.3e} eV'.format(E_sim[1]))
print('Energy expection value of the state Tri3 : {:.3e} eV'.format(E_sim[2]))
print('Energy expection value of the state Sing : {:.3e} eV'.format(E_sim[3]))
# reduced plank constant in (eV) and the speed of light(cgs units)
hbar, c = 4.1357e-15, 3e10
# energy difference between the triplets and singlet
E_del = abs(E_sim[0] - E_sim[3])
# frequency associated with the energy difference
f = E_del/hbar
# convert frequency to wavelength in (cm)
wavelength = c/f
print('The wavelength of the radiation from the transition\
in the hyperfine structure is : {:.1f} cm'.format(wavelength))
provider = IBMQ.load_account()
backend = provider.get_backend('ibmq_athens')
# run this cell to get the backend information through the widget
backend
# assign your choice for the initial layout to the list variable `initial_layout`.
initial_layout =
qc_all = [state_init+measure_circuit for state_init in [Tri1,Tri2,Tri3,Sing]
for measure_circuit in [measure_XX, measure_YY, measure_ZZ] ]
shots = 8192
job = execute(qc_all, backend, initial_layout=initial_layout, optimization_level=3, shots=shots)
print(job.job_id())
job_monitor(job)
# getting the results of your job
results = job.result()
## To access the results of the completed job
#results = backend.retrieve_job('job_id').result()
def Energy(results, shots):
"""Compute the energy levels of the hydrogen ground state.
Parameters:
results (obj): results, results from executing the circuits for measuring a hamiltonian.
shots (int): shots, number of shots used for the circuit execution.
Returns:
Energy (list): energy values of the four different hydrogen ground states
"""
E = []
A = 1.47e-6
for ind_state in range(4):
Energy_meas = []
for ind_comp in range(3):
counts = results.get_counts(ind_state*3+ind_comp)
# calculate the probabilities for each computational basis
probs = {}
for output in ['00','01', '10', '11']:
if output in counts:
probs[output] = counts[output]/shots
else:
probs[output] = 0
Energy_meas.append( probs['00'] - probs['01'] - probs['10'] + probs['11'] )
E.append(A * np.sum(np.array(Energy_meas)))
return E
E = Energy(results, shots)
print('Energy expection value of the state Tri1 : {:.3e} eV'.format(E[0]))
print('Energy expection value of the state Tri2 : {:.3e} eV'.format(E[1]))
print('Energy expection value of the state Tri3 : {:.3e} eV'.format(E[2]))
print('Energy expection value of the state Sing : {:.3e} eV'.format(E[3]))
from qiskit.ignis.mitigation.measurement import *
# your code to create the circuits, meas_calibs, goes here
meas_calibs, state_labels =
# execute meas_calibs on your choice of the backend
job = execute(meas_calibs, backend, shots = shots)
print(job.job_id())
job_monitor(job)
cal_results = job.result()
## To access the results of the completed job
#cal_results = backend.retrieve_job('job_id').result()
# your code to obtain the measurement filter object, 'meas_filter', goes here
results_new = meas_filter.apply(results)
E_new = Energy(results_new, shots)
print('Energy expection value of the state Tri1 : {:.3e} eV'.format(E_new[0]))
print('Energy expection value of the state Tri2 : {:.3e} eV'.format(E_new[1]))
print('Energy expection value of the state Tri3 : {:.3e} eV'.format(E_new[2]))
print('Energy expection value of the state Sing : {:.3e} eV'.format(E_new[3]))
# results for the energy estimation from the simulation,
# execution on a quantum system without error mitigation and
# with error mitigation in numpy array format
Energy_exact, Energy_exp_orig, Energy_exp_new = np.array(E_sim), np.array(E), np.array(E_new)
# Calculate the relative errors of the energy values without error mitigation
# and assign to the numpy array variable `Err_rel_orig` of size 4
Err_rel_orig =
# Calculate the relative errors of the energy values with error mitigation
# and assign to the numpy array variable `Err_rel_new` of size 4
Err_rel_new =
np.set_printoptions(precision=3)
print('The relative errors of the energy values for four bell basis\
without measurement error mitigation : {}'.format(Err_rel_orig))
np.set_printoptions(precision=3)
print('The relative errors of the energy values for four bell basis\
with measurement error mitigation : {}'.format(Err_rel_new))
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_nature.drivers.second_quantization import GaussianForcesDriver
from qiskit_nature.problems.second_quantization import VibrationalStructureProblem
from qiskit_nature.settings import settings
settings.dict_aux_operators = True
driver = GaussianForcesDriver(logfile="aux_files/CO2_freq_B3LYP_631g.log")
problem = VibrationalStructureProblem(driver, num_modals=[2, 2, 3, 4], truncation_order=2)
# Note: at this point, `driver.run()` has NOT been called yet. We can trigger this indirectly like so:
second_q_ops = problem.second_q_ops()
hamiltonian = second_q_ops["VibrationalEnergy"]
print("\n".join(str(hamiltonian).splitlines()[:10] + ["..."]))
from qiskit_nature.second_q.drivers import GaussianForcesDriver
from qiskit_nature.second_q.problems import HarmonicBasis
driver = GaussianForcesDriver(logfile="aux_files/CO2_freq_B3LYP_631g.log")
basis = HarmonicBasis(num_modals=[2, 2, 3, 4])
# this is now done explicitly and already requires the basis
problem = driver.run(basis=basis)
problem.hamiltonian.truncation_order = 2
hamiltonian = problem.hamiltonian.second_q_op()
print("\n".join(str(hamiltonian).splitlines()[:10] + ["..."]))
from qiskit_nature.drivers.second_quantization import GaussianLogResult
from qiskit_nature.properties.second_quantization.vibrational.bases import HarmonicBasis
from qiskit_nature.settings import settings
settings.dict_aux_operators = True
log_result = GaussianLogResult("aux_files/CO2_freq_B3LYP_631g.log")
hamiltonian = log_result.get_vibrational_energy()
print(hamiltonian)
hamiltonian.basis = HarmonicBasis([2, 2, 3, 4])
op = hamiltonian.second_q_ops()["VibrationalEnergy"]
print("\n".join(str(op).splitlines()[:10] + ["..."]))
from qiskit_nature.second_q.drivers import GaussianLogResult
from qiskit_nature.second_q.formats import watson_to_problem
from qiskit_nature.second_q.problems import HarmonicBasis
log_result = GaussianLogResult("aux_files/CO2_freq_B3LYP_631g.log")
watson = log_result.get_watson_hamiltonian()
print(watson)
basis = HarmonicBasis(num_modals=[2, 2, 3, 4])
problem = watson_to_problem(watson, basis)
hamiltonian = problem.hamiltonian.second_q_op()
print("\n".join(str(hamiltonian).splitlines()[:10] + ["..."]))
from qiskit_nature.drivers.second_quantization import GaussianForcesDriver
from qiskit_nature.problems.second_quantization import VibrationalStructureProblem
driver = GaussianForcesDriver(logfile="aux_files/CO2_freq_B3LYP_631g.log")
problem = VibrationalStructureProblem(driver, num_modals=[2, 2, 3, 4], truncation_order=2)
# we trigger driver.run() implicitly like so:
second_q_ops = problem.second_q_ops()
hamiltonian_op = second_q_ops.pop("VibrationalEnergy")
aux_ops = second_q_ops
from qiskit_nature.second_q.drivers import GaussianForcesDriver
from qiskit_nature.second_q.problems import HarmonicBasis
driver = GaussianForcesDriver(logfile="aux_files/CO2_freq_B3LYP_631g.log")
basis = HarmonicBasis(num_modals=[2, 2, 3, 4])
problem = driver.run(basis=basis)
problem.hamiltonian.truncation_order = 2
hamiltonian_op, aux_ops = problem.second_q_ops()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/PabloMartinezAngerosa/QAOA-uniform-convergence
|
PabloMartinezAngerosa
|
import json
import csv
import numpy as np
import networkx as nx
import qiskit
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, assemble
from qiskit.quantum_info import Statevector
from qiskit.aqua.algorithms import NumPyEigensolver
from qiskit.quantum_info import Pauli
from qiskit.aqua.operators import op_converter
from qiskit.aqua.operators import WeightedPauliOperator
from qiskit.visualization import plot_histogram
from qiskit.providers.aer.extensions.snapshot_statevector import *
from thirdParty.classical import rand_graph, classical, bitstring_to_path, calc_cost
from utils import mapeo_grafo
from collections import defaultdict
from operator import itemgetter
from scipy.optimize import minimize
import matplotlib.pyplot as plt
LAMBDA = 10
SHOTS = 10000
UNIFORM_CONVERGENCE_SAMPLE = []
# returns the bit index for an alpha and j
def bit(i_city, l_time, num_cities):
return i_city * num_cities + l_time
# e^(cZZ)
def append_zz_term(qc, q_i, q_j, gamma, constant_term):
qc.cx(q_i, q_j)
qc.rz(2*gamma*constant_term,q_j)
qc.cx(q_i, q_j)
# e^(cZ)
def append_z_term(qc, q_i, gamma, constant_term):
qc.rz(2*gamma*constant_term, q_i)
# e^(cX)
def append_x_term(qc,qi,beta):
qc.rx(-2*beta, qi)
def get_not_edge_in(G):
N = G.number_of_nodes()
not_edge = []
for i in range(N):
for j in range(N):
if i != j:
buffer_tupla = (i,j)
in_edges = False
for edge_i, edge_j in G.edges():
if ( buffer_tupla == (edge_i, edge_j) or buffer_tupla == (edge_j, edge_i)):
in_edges = True
if in_edges == False:
not_edge.append((i, j))
return not_edge
def get_classical_simplified_z_term(G, _lambda):
# recorrer la formula Z con datos grafo se va guardando en diccionario que acumula si coinciden los terminos
N = G.number_of_nodes()
E = G.edges()
# z term #
z_classic_term = [0] * N**2
# first term
for l in range(N):
for i in range(N):
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += -1 * _lambda
# second term
for l in range(N):
for j in range(N):
for i in range(N):
if i < j:
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 2
# z_jl
z_jl_index = bit(j, l, N)
z_classic_term[z_jl_index] += _lambda / 2
# third term
for i in range(N):
for l in range(N):
for j in range(N):
if l < j:
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 2
# z_ij
z_ij_index = bit(i, j, N)
z_classic_term[z_ij_index] += _lambda / 2
# fourth term
not_edge = get_not_edge_in(G) # include order tuples ej = (1,0), (0,1)
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 4
# z_j(l+1)
l_plus = (l+1) % N
z_jlplus_index = bit(j, l_plus, N)
z_classic_term[z_jlplus_index] += _lambda / 4
# fifthy term
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# z_il
z_il_index = bit(edge_i, l, N)
z_classic_term[z_il_index] += weight_ij / 4
# z_jlplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_j, l_plus, N)
z_classic_term[z_jlplus_index] += weight_ij / 4
# add order term because G.edges() do not include order tuples #
# z_i'l
z_il_index = bit(edge_j, l, N)
z_classic_term[z_il_index] += weight_ji / 4
# z_j'lplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_i, l_plus, N)
z_classic_term[z_jlplus_index] += weight_ji / 4
return z_classic_term
def get_classical_simplified_zz_term(G, _lambda):
# recorrer la formula Z con datos grafo se va guardando en diccionario que acumula si coinciden los terminos
N = G.number_of_nodes()
E = G.edges()
# zz term #
zz_classic_term = [[0] * N**2 for i in range(N**2) ]
# first term
for l in range(N):
for j in range(N):
for i in range(N):
if i < j:
# z_il
z_il_index = bit(i, l, N)
# z_jl
z_jl_index = bit(j, l, N)
zz_classic_term[z_il_index][z_jl_index] += _lambda / 2
# second term
for i in range(N):
for l in range(N):
for j in range(N):
if l < j:
# z_il
z_il_index = bit(i, l, N)
# z_ij
z_ij_index = bit(i, j, N)
zz_classic_term[z_il_index][z_ij_index] += _lambda / 2
# third term
not_edge = get_not_edge_in(G)
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# z_il
z_il_index = bit(i, l, N)
# z_j(l+1)
l_plus = (l+1) % N
z_jlplus_index = bit(j, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += _lambda / 4
# fourth term
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# z_il
z_il_index = bit(edge_i, l, N)
# z_jlplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_j, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += weight_ij / 4
# add order term because G.edges() do not include order tuples #
# z_i'l
z_il_index = bit(edge_j, l, N)
# z_j'lplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_i, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += weight_ji / 4
return zz_classic_term
def get_classical_simplified_hamiltonian(G, _lambda):
# z term #
z_classic_term = get_classical_simplified_z_term(G, _lambda)
# zz term #
zz_classic_term = get_classical_simplified_zz_term(G, _lambda)
return z_classic_term, zz_classic_term
def get_cost_circuit(G, gamma, _lambda):
N = G.number_of_nodes()
N_square = N**2
qc = QuantumCircuit(N_square,N_square)
z_classic_term, zz_classic_term = get_classical_simplified_hamiltonian(G, _lambda)
# z term
for i in range(N_square):
if z_classic_term[i] != 0:
append_z_term(qc, i, gamma, z_classic_term[i])
# zz term
for i in range(N_square):
for j in range(N_square):
if zz_classic_term[i][j] != 0:
append_zz_term(qc, i, j, gamma, zz_classic_term[i][j])
return qc
def get_mixer_operator(G,beta):
N = G.number_of_nodes()
qc = QuantumCircuit(N**2,N**2)
for n in range(N**2):
append_x_term(qc, n, beta)
return qc
def invert_counts(counts):
return {k[::-1] :v for k,v in counts.items()}
def get_QAOA_circuit(G, beta, gamma, _lambda):
assert(len(beta)==len(gamma))
N = G.number_of_nodes()
qc = QuantumCircuit(N**2,N**2)
# init min mix state
qc.h(range(N**2))
p = len(beta)
for i in range(p):
qc = qc.compose(get_cost_circuit(G, gamma[i], _lambda))
qc = qc.compose(get_mixer_operator(G, beta[i]))
qc.barrier(range(N**2))
qc.snapshot_statevector("final_state")
qc.measure(range(N**2),range(N**2))
return qc
def tsp_obj(x, G):
# obtenemos el valor evaluado en f(x_1, x_2,... x_n)
z_classic_term, zz_classic_term = get_classical_simplified_hamiltonian(G, LAMBDA)
cost = 0
# z term
for index in range(len(x)):
z = (int(x[index]) * 2 ) -1
cost += z_classic_term[index] * z
## zz term
for i in range(len(x)):
z_1 = (int(x[i]) * 2 ) -1
for j in range(len(x)):
z_2 = (int(x[j]) * 2 ) -1
cost += zz_classic_term[i][j] * z_1 * z_1
return cost
# Sample expectation value
def compute_tsp_energy(counts, G):
energy = 0
get_counts = 0
total_counts = 0
for meas, meas_count in counts.items():
obj_for_meas = tsp_obj(meas, G)
energy += obj_for_meas*meas_count
total_counts += meas_count
return energy/total_counts
# Sample expectation value
def compute_tsp_energy_2(counts, G):
energy = 0
get_counts = 0
total_counts = 0
for meas, meas_count in counts.items():
obj_for_meas = tsp_obj_2(meas, G, LAMBDA)
energy += obj_for_meas*meas_count
total_counts += meas_count
mean = energy/total_counts
return mean
def tsp_obj_2(x, G,_lambda):
# obtenemos el valor evaluado en f(x_1, x_2,... x_n)
not_edge = get_not_edge_in(G)
N = G.number_of_nodes()
tsp_cost=0
#Distancia
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# x_il
x_il_index = bit(edge_i, l, N)
# x_jlplus
l_plus = (l+1) % N
x_jlplus_index = bit(edge_j, l_plus, N)
tsp_cost+= int(x[x_il_index]) * int(x[x_jlplus_index]) * weight_ij
# add order term because G.edges() do not include order tuples #
# x_i'l
x_il_index = bit(edge_j, l, N)
# x_j'lplus
x_jlplus_index = bit(edge_i, l_plus, N)
tsp_cost += int(x[x_il_index]) * int(x[x_jlplus_index]) * weight_ji
#Constraint 1
for l in range(N):
penal1 = 1
for i in range(N):
x_il_index = bit(i, l, N)
penal1 -= int(x[x_il_index])
tsp_cost += _lambda * penal1**2
#Contstraint 2
for i in range(N):
penal2 = 1
for l in range(N):
x_il_index = bit(i, l, N)
penal2 -= int(x[x_il_index])
tsp_cost += _lambda*penal2**2
#Constraint 3
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# x_il
x_il_index = bit(i, l, N)
# x_j(l+1)
l_plus = (l+1) % N
x_jlplus_index = bit(j, l_plus, N)
tsp_cost += int(x[x_il_index]) * int(x[x_jlplus_index]) * _lambda
return tsp_cost
def get_black_box_objective(G,p):
backend = Aer.get_backend('qasm_simulator')
def f(theta):
beta = theta[:p]
gamma = theta[p:]
qc = get_QAOA_circuit(G, beta, gamma, LAMBDA)
counts = execute(qc, backend, seed_simulator=10, shots=SHOTS).result().get_counts()
return compute_tsp_energy(invert_counts(counts),G)
return f
def get_black_box_objective_2(G,p):
backend = Aer.get_backend('qasm_simulator')
sim = Aer.get_backend('aer_simulator')
def f(theta):
beta = theta[:p]
gamma = theta[p:]
qc = get_QAOA_circuit(G, beta, gamma, LAMBDA)
result = execute(qc, backend, seed_simulator=10, shots= SHOTS).result()
final_state_vector = result.data()["snapshots"]["statevector"]["final_state"][0]
state_vector = Statevector(final_state_vector)
probabilities = state_vector.probabilities()
probabilities_states = invert_counts(state_vector.probabilities_dict())
expected_value = 0
for state,probability in probabilities_states.items():
cost = tsp_obj_2(state, G, LAMBDA)
expected_value += cost*probability
counts = result.get_counts()
mean = compute_tsp_energy_2(invert_counts(counts),G)
global UNIFORM_CONVERGENCE_SAMPLE
UNIFORM_CONVERGENCE_SAMPLE.append({
"beta" : beta,
"gamma" : gamma,
"counts" : counts,
"mean" : mean,
"probabilities" : probabilities,
"expected_value" : expected_value
})
return mean
return f
def compute_tsp_min_energy_2(counts, G):
energy = 0
get_counts = 0
total_counts = 0
min = 1000000000000000000000
index = 0
min_meas = ""
for meas, meas_count in counts.items():
index = index + 1
obj_for_meas = tsp_obj_2(meas, G, LAMBDA)
if obj_for_meas < min:
min = obj_for_meas
min_meas = meas
return index, min, min_meas
def compute_tsp_min_energy_1(counts, G):
energy = 0
get_counts = 0
total_counts = 0
min = 1000000000000000000000
index = 0
min_meas = ""
for meas, meas_count in counts.items():
index = index + 1
obj_for_meas = tsp_obj(meas, G)
if obj_for_meas < min:
min = obj_for_meas
min_meas = meas
return index, min, min_meas
def test_counts_2(counts, G):
mean_energy2 = compute_tsp_energy_2(invert_counts(counts),G)
cantidad, min, min_meas = compute_tsp_min_energy_2(invert_counts(counts),G)
print("*************************")
print("En el algoritmo 2 (Marina) el valor esperado como resultado es " + str(mean_energy2))
print("El valor minimo de todos los evaluados es " + str(min) + " se evaluaron un total de " + str(cantidad))
print("El vector minimo es " + min_meas)
def test_counts_1(counts, G):
mean_energy1 = compute_tsp_energy(invert_counts(counts),G)
cantidad, min, min_meas = compute_tsp_min_energy_1(invert_counts(counts),G)
print("*************************")
print("En el algoritmo 1 (Pablo) el valor esperado como resultado es " + str(mean_energy1))
print("El valor minimo de todos los evaluados es " + str(min) + " se evaluaron un total de " + str(cantidad))
print("El vector minimo es " + min_meas)
def test_solution(grafo=None, p=7):
global UNIFORM_CONVERGENCE_SAMPLE
UNIFORM_CONVERGENCE_SAMPLE = []
if grafo == None:
cantidad_ciudades = 2
pesos, conexiones = None, None
mejor_camino = None
while not mejor_camino:
pesos, conexiones = rand_graph(cantidad_ciudades)
mejor_costo, mejor_camino = classical(pesos, conexiones, loop=False)
G = mapeo_grafo(conexiones, pesos)
print(mejor_costo)
print(mejor_camino)
print(G.edges())
print(G.nodes())
else:
G = grafo
bounds = []
intial_random = []
for i in range(p):
bounds.append((0, np.pi))
intial_random.append(np.random.uniform(0,np.pi))
for i in range(p):
bounds.append((0, np.pi * 2))
intial_random.append(np.random.uniform(0,2*np.pi))
init_point = np.array(intial_random)
# Marina Solutions
obj = get_black_box_objective_2(G,p)
res_sample_2 = minimize(obj, init_point, method="COBYLA", options={"maxiter":2500,"disp":True})
theta_2 = res_sample_2.x
beta = theta_2[:p]
gamma = theta_2[p:]
_lambda = LAMBDA
qc = get_QAOA_circuit(G, beta, gamma, LAMBDA)
backend = Aer.get_backend('qasm_simulator')
job_2 = execute(qc, backend, shots = SHOTS)
resutls_2 = job_2.result().get_counts()
test_counts_2(resutls_2, G)
return job_2, G, UNIFORM_CONVERGENCE_SAMPLE
def create_multiple_p_mismo_grafo():
header = ['p', 'state', 'probability', 'mean']
length_p = 10
with open('qaoa_multiple_p.csv', 'w', encoding='UTF8') as f:
writer = csv.writer(f)
writer.writerow(header)
first_p = False
uniform_convergence_sample = []
for p in range(length_p):
p = p+1
if first_p == False:
job_2, G, uniform_convergence_sample = test_solution(p=p)
first_p = True
else:
job_2, G, uniform_convergence_sample = test_solution(grafo=G, p=p)
# Sort the JSON data based on the value of the brand key
uniform_convergence_sample.sort(key=lambda x: x["mean"])
mean = uniform_convergence_sample[0]["mean"]
print(mean)
state = 0
for probability in uniform_convergence_sample[0]["probabilities"]:
state += 1
writer.writerow([p,state, probability,mean])
def create_multiple_p_mismo_grafo_multiples_instanncias():
header = ['instance','p','distance', 'mean']
length_p = 4
length_instances = 10
with open('qaoa_multiple_p_distance.csv', 'w', encoding='UTF8') as f:
writer = csv.writer(f)
writer.writerow(header)
instance_index = 0
for instance in range(length_instances):
instance_index += 1
first_p = False
UNIFORM_CONVERGENCE_P = []
uniform_convergence_sample = []
for p in range(length_p):
p = p+1
print("p es igual " + str(p))
if first_p == False:
print("Vuelve a llamar a test_solution")
job_2, G, uniform_convergence_sample = test_solution(p=p)
first_p = True
else:
job_2, G, uniform_convergence_sample = test_solution(grafo=G, p=p)
# Sort the JSON data based on the value of the brand key
uniform_convergence_sample.sort(key=lambda x: x["expected_value"])
convergence_min = uniform_convergence_sample[0]
UNIFORM_CONVERGENCE_P.append({
"mean":convergence_min["expected_value"],
"probabilities": convergence_min["probabilities"]
})
cauchy_function_nk = UNIFORM_CONVERGENCE_P[len(UNIFORM_CONVERGENCE_P) - 1]
p_index = 0
for p_state in UNIFORM_CONVERGENCE_P:
p_index += 1
print(p_index)
mean = p_state["mean"]
distance_p_cauchy_function_nk = np.max(np.abs(cauchy_function_nk["probabilities"] - p_state["probabilities"]))
writer.writerow([instance_index, p_index, distance_p_cauchy_function_nk, mean])
if __name__ == '__main__':
create_multiple_p_mismo_grafo_multiples_instanncias()
def defult_init():
cantidad_ciudades = 2
pesos, conexiones = None, None
mejor_camino = None
while not mejor_camino:
pesos, conexiones = rand_graph(cantidad_ciudades)
mejor_costo, mejor_camino = classical(pesos, conexiones, loop=False)
G = mapeo_grafo(conexiones, pesos)
print(mejor_costo)
print(mejor_camino)
print(G.edges())
print(G.nodes())
print("labels")
labels = nx.get_edge_attributes(G,'weight')
p = 5
obj = get_black_box_objective(G,p)
init_point = np.array([0.8,2.2,0.83,2.15,0.37,2.4,6.1,2.2,3.8,6.1])
# Marina Solutions
obj = get_black_box_objective_2(G,p)
res_sample = minimize(obj, init_point,method="COBYLA",options={"maxiter":2500,"disp":True})
print(res_sample)
theta_2 = [0.72685401, 2.15678239, 0.86389827, 2.19403121, 0.26916675, 2.19832144, 7.06651453, 3.20333137, 3.81301611, 6.08893568]
theta_1 = [0.90644898, 2.15994212, 1.8609325 , 2.14042604, 1.49126214, 2.4127999, 6.10529434, 2.18238732, 3.84056674, 6.07097744]
beta = theta_1[:p]
gamma = theta_1[p:]
qc = get_QAOA_circuit(G, beta, gamma, LAMBDA)
backend = Aer.get_backend('qasm_simulator')
job = execute(qc, backend)
beta = theta_2[:p]
gamma = theta_2[p:]
qc = get_QAOA_circuit(G, beta, gamma, LAMBDA)
backend = Aer.get_backend('qasm_simulator')
job = execute(qc, backend)
|
https://github.com/avkhadiev/schwinger-vqe
|
avkhadiev
| |
https://github.com/quantumjim/Qiskit-PyConDE
|
quantumjim
|
%matplotlib notebook
import pew # setting up tools for the pewpew
from microqiskit import QuantumCircuit, simulate # setting up tools for quantum
pew.init() # initialize the game engine...
screen = pew.Pix() # ...and the screen
qc = QuantumCircuit(2,2) # create an empty circuit with two qubits and two output bits
# create a circuit with the required measurements, so we can add them in easily
meas = QuantumCircuit(2,2)
meas.measure(0,0)
meas.measure(1,1)
# loop over the squares centered on (1,2) and (6,2) and make all dim
for (X,Y) in [(1,2),(6,2)]:
for dX in [+1,0,-1]:
for dY in [+1,0,-1]:
screen.pixel(X+dX,Y+dY,2)
for (X,Y) in [(1,2),(6,2)]:
screen.pixel(X,Y,0) # turn off the center pixels of the squares
old_keys = 0
while True: # loop which checks for user input and responds
# look for and act upon key presses
keys = pew.keys() # get current key presses
if keys!=0 and keys!=old_keys:
if keys&pew.K_UP:
qc.x(0) # x for qubit 0 when UP is pressed
if keys&pew.K_LEFT:
qc.x(1) # x for qubit 1 when LEFT is pressed
old_keys = keys
# execute the circuit and get a single sample of memory
m = simulate(qc+meas,shots=1,get='memory')
# turn the pixel (1,2) on or off depending on whether the first bit value is 1 or 0
if m[0][0]=='1':
screen.pixel(1,2,3)
else:
screen.pixel(1,2,0)
# do the same for pixel (6,2)
if m[0][1]=='1':
screen.pixel(6,2,3)
else:
screen.pixel(6,2,0)
pew.show(screen) # update screen to display the above changes
pew.tick(1/6) # pause for a sixth of a second
import pew # setting up tools for the pewpew
from microqiskit import QuantumCircuit, simulate # setting up tools for quantum
pew.init() # initialize the game engine...
screen = pew.Pix() # ...and the screen
# create an empty circuit with two qubits and two output bits
qc = QuantumCircuit(2,2)
cnot = QuantumCircuit(2,2)
cnot.cx(0,1)
# create a circuit with the required measurements, so we can add them in easily
meas = QuantumCircuit(2,2)
meas.measure(0,0)
meas.measure(1,1)
# loop over the square centered on (1,2) and make all dim
for (X,Y) in [(1,2),(6,2)]:
for dX in [+1,0,-1]:
for dY in [+1,0,-1]:
screen.pixel(X+dX,Y+dY,2)
for (X,Y) in [(1,2),(6,2)]:
screen.pixel(X,Y,0) # turn off the center pixels of the squares
old_keys = 0
while True: # loop which checks for user input and responds
# look for and act upon key presses
keys = pew.keys() # get current key presses
if keys!=0 and keys!=old_keys:
if keys&pew.K_UP:
qc.x(0) # x for qubit 0 when UP is pressed
if keys&pew.K_LEFT:
qc.x(1) # x for qubit 1 when LEFT is pressed
old_keys = keys
# execute the circuit and get a single sample of memory
m = simulate(qc+meas,shots=1,get='memory')
# turn the pixel (1,2) on or off depending on whether the first bit value is 1 or 0
if m[0][0]=='1':
screen.pixel(1,2,3)
else:
screen.pixel(1,2,0)
# do the same for pixel (6,2)
if m[0][1]=='1':
screen.pixel(6,2,3)
else:
screen.pixel(6,2,0)
m = simulate(qc+cnot+meas,shots=1,get='memory')
xor = m[0][0]
if xor=='0':
for (X,Y) in [(3,2),(4,2)]:
screen.pixel(X,Y,0)
else:
for (X,Y) in [(3,2),(4,2)]:
screen.pixel(X,Y,3)
pew.show(screen) # update screen to display any changes
pew.tick(1/6) # pause for a sixth of a second
|
https://github.com/LeDernier/qiskit-HHL
|
LeDernier
|
#Imports non Qiskit
import numpy as np
from numpy import pi
#Imports Qiskit
#Généraux
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ
#Aqua
from qiskit.aqua.algorithms import HHL, NumPyLSsolver
from qiskit.aqua.components.eigs import EigsQPE
from qiskit.aqua.components.reciprocals import LookupRotation
from qiskit.aqua.operators import MatrixOperator
from qiskit.aqua.components.initial_states import Custom
#Plot tools
from qiskit.visualization import plot_histogram, plot_bloch_multivector
from qiskit_textbook.tools import array_to_latex
#Autres
from qiskit.circuit import Gate
from qiskit.circuit.library import QFT
from qiskit.quantum_info import state_fidelity
from qiskit.providers.ibmq import least_busy #QFT
from qiskit_textbook.tools import random_state
from qiskit.tools.monitor import job_monitor #QFTe
from typing import Optional, List
import numpy as np
from qiskit import Aer, execute, QuantumRegister, QuantumCircuit, ClassicalRegister
from qiskit.circuit.library import HGate, RYGate, ZGate, XGate, CSwapGate, SwapGate
from qiskit.quantum_info import Operator
from qiskit.aqua.components.initial_states import InitialState
from qiskit.aqua.utils.validation import validate_min
from qiskit.aqua.components.initial_states import Custom
from qiskit.visualization import plot_histogram
%config InlineBackend.figure_format = 'svg' # Makes the images look nice
'''
import sys
sys.setrecursionlimit(1000)
'''
# memory structure B_x proposed by (Prakash, 2014) to store the information of the classical vector b.
# structured slightly modified for complex vectors
class BinaryTree:
def __init__(self, value, level=0,branch=0):
self.value = value
self.child_left = None
self.child_right = None
self.level = level
self.branch = branch
def insert_left(self, value, branch):
if self.child_left == None:
self.child_left = BinaryTree(value, self.get_level()+1, branch)
else:
new_node = BinaryTree(value, self.get_level()+1, branch)
self.child_left.set_level(self.child_left.get_level()+1)
self.child_left.set_branch(self.child_left.get_branch()*2)
new_node.child_left = self.child_left
self.child_left = new_node
def insert_right(self, value, branch):
if self.child_right == None:
self.child_right = BinaryTree(value, self.get_level()+1, branch)
else:
new_node = BinaryTree(value, self.get_level()+1, branch)
self.child_right.set_level(self.child_right.get_level()+1)
self.child_right.set_branch(self.child_right.get_branch()*2+1)
new_node.child_right = self.child_right
self.child_right = new_node
def get_value(self):
return self.value
def get_left(self):
return self.child_left
def get_right(self):
return self.child_right
def get_level(self):
return self.level
def get_branch(self):
return self.branch
def set_level(self, level):
self.level = level
def set_branch(self, branch):
self.branch = branch
def show_tree(T):
if T != None:
return ([T.get_value(),T.get_level(),T.get_branch()],show_tree(T.get_left()),show_tree(T.get_right()))
def create_tree_from_vector(x: list):
norm = np.linalg.norm(x)
u_x = [x_i/norm for x_i in x]
if(len(u_x)<1):
print("Please enter a non-null vector")
elif(len(u_x)==1):
s = 1
phase = np.angle(u_x[0])
tree = BinaryTree([s, phase])
else:
tree = BinaryTree(1)
u_x_left=u_x[0:(len(x)+1)//2]
u_x_right=u_x[(len(x)+1)//2:len(x)]
create_tree_recursively(u_x_left, tree, "left", tree.get_branch())
create_tree_recursively(u_x_right, tree, "right", tree.get_branch())
return norm, tree
def create_tree_recursively(x: list, tree: BinaryTree, side: str, branch: int):
# adding the new node to the tree
s = 0
for i in range(len(x)):
s += x[i].real**2+x[i].imag**2
if(len(x) == 1):
phase = np.angle(x[0])
s=[s,phase]
if(side == "left"):
tree.insert_left(s, branch*2)
elif(side == "right"):
tree.insert_right(s, branch*2+1)
else:
print("problem in a switch case, create tree recursively")
# calling recursively the fonction
if(len(x) > 1):
x_left=x[0:(len(x)+1)//2]
x_right=x[(len(x)+1)//2:len(x)]
# creating a perfect binary tree (all interior nodes have two children and all leaves have the same depth or same level)
if(len(x_left) == 1 and len(x_right) > 1):
x_left = [x_left[0], 0]
elif(len(x_right) == 1 and len(x_left) > 1):
x_right = [x_right[0], 0]
if(side == "left"):
create_tree_recursively(x_left, tree.get_left(), "left", tree.get_left().get_branch())
create_tree_recursively(x_right, tree.get_left(), "right", tree.get_left().get_branch())
elif(side == "right"):
create_tree_recursively(x_left, tree.get_right(), "left", tree.get_right().get_branch())
create_tree_recursively(x_right, tree.get_right(), "right", tree.get_right().get_branch())
else:
print("Error: a branch of the tree has not been considered")
else:
return
# state preparation procedure of (Grover & Rudolph, 2002) to get |psi>=|b> from b
# procedure slightly modified for complex vectors
def load_vector_from_qRAM(x: list,
qc: Optional[QuantumCircuit]=None,
pos_init: int=0,
normIntegerPrecision: int=0,
normDecimalPrecision: int=0,
Qiskit_reading_direction: bool=False):
norm, B_x = create_tree_from_vector(x)
n = int(np.ceil(np.log(len(x))))
if(n == 0):
n = 1
# Code if there is not a quantum circuit as an input
if(qc is None):
cr3 = ClassicalRegister(n)
qr3 = QuantumRegister(n, 'tree')
if(normIntegerPrecision > 0):
cr1 = ClassicalRegister(normIntegerPrecision)
qr1 = QuantumRegister(normIntegerPrecision, 'n_int')
if(normDecimalPrecision > 0):
cr2 = ClassicalRegister(normDecimalPrecision)
qr2 = QuantumRegister(normDecimalPrecision, 'n_dec')
qc = QuantumCircuit(qr1,qr2,qr3,cr1,cr2,cr3)
else:
qc = QuantumCircuit(qr1,qr3,cr1,cr3)
else:
if(normDecimalPrecision > 0):
cr2 = ClassicalRegister(normDecimalPrecision)
qr2 = QuantumRegister(normDecimalPrecision, 'n_dec')
qc = QuantumCircuit(qr2,qr3,cr2,cr3)
else:
qc = QuantumCircuit(qr3,cr3)
## loading norm_l2(x)
if(normIntegerPrecision + normDecimalPrecision > 0):
norm_binary = getBinary(norm)
# integer part of the norm
if(len(norm_binary[0]) > normIntegerPrecision):
for i in range(normIntegerPrecision):
qc.x(pos_init+i)
else:
for i in range(len(norm_binary[0])):
if(norm_binary[0][i] == '1'):
qc.x(pos_init+normIntegerPrecision-len(norm_binary[0])+i)
# decimal part of the norm
if(len(norm_binary[1]) > normDecimalPrecision):
for i in range(normDecimalPrecision):
if(norm_binary[1][i] == '1'):
qc.x(pos_init+normIntegerPrecision+i)
else:
for i in range(len(norm_binary[1])):
if(norm_binary[1][i] == '1'):
qc.x(pos_init+normIntegerPrecision+i)
## loading u=x/norm_l2(x)
if(n > 0):
## rotation level 1
# getting the left and right child nodes
B_l = B_x.get_left()
B_r = B_x.get_right()
# calculating the angle of rotation 'theta': cos('theta') = sqrt(value(u_l)/value(u))
B_lIsALeave = False
if(B_l.get_left() is None):
B_lIsALeave = True
if(B_lIsALeave):
node_value = B_l.get_value()[0]
else:
node_value = B_l.get_value()
theta_0 = 2*np.arccos(np.sqrt(node_value))
qc.ry(theta_0, pos_init+normIntegerPrecision+normDecimalPrecision)
# processPhase if the nodes u_l and u_r are leaves (personal approach)
isAComplexPair = False
if(B_lIsALeave == True):
if(B_l.get_value()[1] == 0.0 and B_r.get_value()[1] == 0.0):
pass
elif(B_l.get_value()[1] == 0.0 and B_r.get_value()[1] == np.pi):
theta_0 = -theta_0
elif(B_l.get_value()[1] == np.pi and B_r.get_value()[1] == 0.0):
theta_0 = np.pi-theta_0
elif(B_l.get_value()[1] == np.pi and B_r.get_value()[1] == np.pi):
theta_0 = np.pi+theta_0
else:
isAComplexPair = True
# changing the local phase if necessary using the quantum gate diag(e^{i*angle_l},e^{i*angle_r}) = X*U_1(angle_l)*X*U_1(angle_r)
if(isAComplexPair == True):
qc.u1(B_r.get_value()[1]-B_l.get_value()[1],0)
if(n > 1):
processNode(qc, pos_init+normIntegerPrecision+normDecimalPrecision, n, B_l)
processNode(qc, pos_init+normIntegerPrecision+normDecimalPrecision, n, B_r)
# swap the qubits in the quantum register if demanded (Qiskit_reading_direction == False).
if(Qiskit_reading_direction == False):
for qubit in range(pos_init, pos_init+normIntegerPrecision//2):
qc.swap(qubit, normIntegerPrecision-qubit-1)
for qubit in range(pos_init+normIntegerPrecision, (pos_init+normIntegerPrecision+normDecimalPrecision)//2):
qc.swap(qubit, normDecimalPrecision-qubit-1)
for qubit in range(pos_init+normIntegerPrecision+normDecimalPrecision, (pos_init+normIntegerPrecision+normDecimalPrecision+n)//2):
qc.swap(qubit, n-qubit-1)
qc.barrier()
return qc
def processNode(q_circuit: QuantumCircuit, first_qubit: int, sizeRegisterTree: int, u_x: BinaryTree):
## rotation level k > 1
# getting the left and right child nodes
u_l = u_x.get_left()
u_r = u_x.get_right()
# if value(u) = 0 then value(u_c) = 0 for all the child nodes in the subtree whose parent is u. Therefore, no calculation is performed.
if(u_x.get_value() != 0):
# calculating the angle of rotation 'theta': cos('theta') = sqrt(value(u_l)/value(u))
u_lIsALeave = False
if(u_l.get_left() is None):
u_lIsALeave = True
if(u_l is not None):
if(u_lIsALeave):
node_value = u_l.get_value()[0]
else:
node_value = u_l.get_value()
theta = 2*np.arccos(np.sqrt(node_value/u_x.get_value()))
else:
print("Error: processNode() to a node without childs")
# processPhase if the nodes u_l and u_r are leaves (personal approach)
isAComplexPair = False
if(u_lIsALeave):
if(u_l.get_value()[1] == 0.0 and u_r.get_value()[1] == 0.0):
pass
elif(u_l.get_value()[1] == 0.0 and u_r.get_value()[1] == np.pi):
theta = -theta
elif(u_l.get_value()[1] == np.pi and u_r.get_value()[1] == 0.0):
theta = np.pi-theta
elif(u_l.get_value()[1] == np.pi and u_r.get_value()[1] == np.pi):
theta = np.pi+theta
else:
isAComplexPair = True
# choosing the quantum eigenstate associated to the parent node (the control eigenstate q_1q_2...q_{k-1})
list_binary = getBinary(u_x.get_branch(), u_l.get_level()-1)[0]
for i in range(len(list_binary)):
if(list_binary[i] == '0'):
#q_circuit.x(first_qubit+len(list_binary)-(i+1))
q_circuit.x(first_qubit+i)
## Multi-controlled Rotation gate around the y-axis (*)
qc_custom = QuantumCircuit(1)
qc_custom.ry(theta,0)
# changing the local phase if necessary using the quantum gate diag(e^{i*angle_l},e^{i*angle_r}) = X*U_1(angle_l)*X*U_1(angle_r)
if(isAComplexPair == True):
qc_custom.u1(u_r.get_value()[1]-u_l.get_value()[1],0)
#MC_Ry = RYGate(theta).control(u_l.get_level()-1)
MC_Ry = qc_custom.to_gate(label="Ry(\u03B8)*U1(\u03B2 - \u03B1)").control(u_l.get_level()-1)
q_circuit.append(MC_Ry, [first_qubit+x_i for x_i in range(u_l.get_level())])
# uncomputing the quantum eigenstate associated to the parent node
list_binary = getBinary(u_x.get_branch(), u_l.get_level()-1)[0]
for i in range(len(list_binary)):
if(list_binary[i] == '0'):
#q_circuit.x(first_qubit++len(list_binary)-(i+1))
q_circuit.x(first_qubit+i)
## recursive call
if(u_lIsALeave == False):
q_circuit.barrier()
processNode(q_circuit, first_qubit, sizeRegisterTree, u_l)
processNode(q_circuit, first_qubit, sizeRegisterTree, u_r)
else:
return
def getBinary(number: float, integerPrecision: int=1):
# integer part
int_part = int(number)
binary_int = format(int_part, '#0'+str(int(2+integerPrecision))+'b')[2:]
# decimal part
dec_part = number - float(int_part)
binary_dec = ''
while(dec_part > 0):
dec_part = 2*dec_part
if(dec_part >= 1):
binary_dec += '1'
dec_part = dec_part-1
else:
binary_dec += '0'
return binary_int, binary_dec
def hamiltonian_simulation(H,t,r = 1):
"""Prends un observable H (matrice numpy) et un temps t en entrée et renvoie opérateur d'évolution exp(-itH)"""
def taylor(H,t,n=100):
"""Première implémentation naïve avec le developpement de taylor de l'exponentielle"""
U = np.eye(len(H))
for k in range(n):
U = np.dot(U,(-1j)*t*H)/(n-k)
U += np.eye(len(H))
return U
def trotter_suzuki(H,t,r):
"""Ici H doit être de la forme [A,B] où A[i] est la liste des termes non nuls dans la colonne i et B[i][A[i]]
leur valeurs"""
def separate(H, L = []):
S1 = [[i for i in range(len(H[0]))],[[0 for i in range(len(H[0]))] for j in range(len(H[0]))]]
if L == []:
for i in range(len(H[0])):
for j in range(len(H[0][i])):
if H[0][i][j] == i:
S1[0][i] = i
S1[1][i][i] = H[1][i][i]
del H[0][i][j]
break
L += [S1]
return separate(H,L)
Hvide = True
for k in range(len(H[0])):
if H[0][k] != []:
Hvide = False
if Hvide:
return L
Colored = len(H[0])*[0]
for i in range(len(H[0])):
for j in range(len(H[0][i])):
if not(Colored[H[0][i][j]]):
Colored[H[0][i][j]] = 1
Colored[i] = 1
S1[0][i] = H[0][i][j]
S1[0][H[0][i][j]] = i
S1[1][i][H[0][i][j]] = H[1][i][H[0][i][j]]
S1[1][H[0][i][j]][i] = H[1][H[0][i][j]][i]
temp = 0
for k in range(len(H[0][H[0][i][j]])):
if H[0][H[0][i][j]][k]==i:
temp = k
del H[0][H[0][i][j]][temp]
del H[0][i][j]
break
L += [S1]
return separate(H,L)
def fastexp(M,t):
done = len(M[0])*[0]
for k in range(len(done)):
if not(done[k]):
if M[0][k] == k:
M[1][k][k] = np.exp(1j*t*M[1][k][k])
done[k] = 1
else:
if M[1][k][M[0][k]].imag == 0:
M[1][k][k] = np.cos(t*M[1][k][M[0][k]])
M[1][M[0][k]][M[0][k]] = np.cos(t*M[1][k][M[0][k]])
M[1][M[0][k]][k] = 1j*np.sin(t*M[1][k][M[0][k]])
M[1][k][M[0][k]] = 1j*np.sin(t*M[1][k][M[0][k]])
else:
M[1][k][k] = np.cos(t*M[1][k][M[0][k]])
M[1][M[0][k]][M[0][k]] = np.cos(t*M[1][k][M[0][k]])
M[1][M[0][k]][k] = np.sin(t*M[1][k][M[0][k]])
M[1][k][M[0][k]] = -np.sin(t*M[1][k][M[0][k]])
done[k] = 1
done[M[0][k]] = 1
return M
L1 = separate(H)
L = []
for k in range(len(L1)):
Sr = [[i for i in range(len(H[0]))],[[0 for i in range(len(H[0]))] for j in range(len(H[0]))]]
Sc = [[i for i in range(len(H[0]))],[[0 for i in range(len(H[0]))] for j in range(len(H[0]))]]
for i in range(len(L1[k][0])):
Sr[0][i] = L1[k][0][i]
Sc[0][i] = L1[k][0][i]
Sr[1][i][Sr[0][i]] = L1[k][1][i][L1[k][0][i]].real
Sc[1][i][Sc[0][i]] = L1[k][1][i][L1[k][0][i]].imag
L += [Sr]+[Sc]
for k in range(len(L)):
L[k] = fastexp(L[k],t/r)
L1 = []
for k in range(len(L)):
L1 += [L[k][1]]
return L1,r
return trotter_suzuki(H,t,r)
def qft_rotations(circuit,position_initial,nombre_qubits):
"""Performs qft on the first n qubits ("nombre_qubits") in circuit (without swaps)"""
if nombre_qubits == 0:
return circuit
nombre_qubits -= 1
circuit.h(position_initial+nombre_qubits)
for qubit in range(nombre_qubits):
circuit.cu1(pi/2**(nombre_qubits-qubit), position_initial+qubit, position_initial+nombre_qubits)
# At the end of our function, we call the same function again on
# the next qubits (we reduced "nombre_qubits" by one earlier in the function)
qft_rotations(circuit,position_initial,nombre_qubits)
def swap_registers(circuit,position_initial,nombre_qubits):
for qubit in range(nombre_qubits//2):
circuit.swap(position_initial+qubit,position_initial+nombre_qubits-qubit-1)
return circuit
def qft(circuit: QuantumCircuit,position_initial: int,nombre_qubits: int):
"""QFT on the first n qubits ("nombre_qubits") in circuit"""
qft_rotations(circuit,position_initial,nombre_qubits)
swap_registers(circuit,position_initial,nombre_qubits)
return circuit
# Let's see how it looks for a circuit with 4 qubits (intial state |0000>):
qc = QuantumCircuit(6)
circ_=qc
position_initial=1
n_qubits=4
qft(circ_,position_initial,n_qubits)
#qc.measure_all()
qc.draw('mpl')
def inverse_qft(circuit: QuantumCircuit, position_initial: int=0, nombre_qubits: int=2, nombre_total_qubits: int=2):
"""Does the inverse QFT on the first n qubits ("nombre_qubits") in circuit"""
# First we create a QFT circuit of the correct size:
qft_circ = qft(QuantumCircuit(nombre_total_qubits), position_initial, nombre_qubits)
# Then we take the inverse of this circuit
invqft_circ = qft_circ.inverse()
# And add it to the first n qubits (nombre_qubits) in our existing circuit
circuit.append(invqft_circ, circuit.qubits)
return circuit.decompose() # .decompose() allows us to see the individual gates
nqubits = 4
n_total_qubits = 6
position_initial=1
number = 5
qc = QuantumCircuit(n_total_qubits)
'''
for qubit in range(nqubits):
qc.h(qubit)
qc.u1(number*pi/4,0)
qc.u1(number*pi/2,1)
qc.u1(number*pi,2)
'''
qc.draw('mpl')
qc = inverse_qft(qc,position_initial,nqubits,n_total_qubits)
#qc.measure_all()
qc.draw('mpl')
def qft_dagger(circ_,position_initial,n_qubits):
"""n-qubit QFTdagger the first n qubits in circ"""
for qubit in range(int(n_qubits/2)):
circ_.swap(position_initial+qubit,position_initial+n_qubits-1-qubit)
for j in range(0,n_qubits):
for m in range(j):
circ_.cp(-np.pi/float(2**(j-m)), position_initial+m, position_initial+j)
circ_.h(position_initial+j)
qc = QuantumCircuit(6)
qc.draw('mpl')
circ_=qc
position_initial=1
n_qubits=4
qft_dagger(circ_,position_initial,n_qubits)
#qc.measure_all()
qc.draw('mpl')
# a: clock register (HHL+) or phase register (rapport intermédiaire) or ancillae register (Qiskit textbook chapter 3.6)
# q: input register (HHL+, rapport intermédiaire)
# s: ancilla register (HHL+) or auxiliary register (rapport intermédiaire, Qiskit textbook Chapter 3.6)
# global variables to test the second call to the Hamiltonian Simulation module
list_CU_operators = None
exponent_r = None
flag_get_CU_gate = False # variable to modify list_CU_operators each repetition of HHL
def get_CU_gate(num_qubits_a: int=1,
num_qubits_q: int=1,
t: int=50,
unitary_matrix: Optional[List]=None, # parameter to test the validity of the model
matrix: Optional[List]=None,
nonzero_entries: Optional[List]=None,
inverse_gate: bool=False):
global list_CU_operators, exponent_r, flag_get_CU_gate
# if qpe_hhl has called this function
if(list_CU_operators is None or flag_get_CU_gate == False):
## get the matrices U_1,...,U_n and and the scalar r so that U=(U1*...*Un)*...*(U1*...*Un): r times "(U1*...*Un)".
if(matrix is not None and nonzero_entries is not None):
list_U_matrices, exponent_r = hamiltonian_simulation([nonzero_entries, matrix],t)
dim_U_matrix = len(matrix)
elif(unitary_matrix is not None):
list_U_matrices = [unitary_matrix]
exponent_r = 1
dim_U_matrix = len(unitary_matrix)
else:
print("list_U_operators cannot be properly implemented. Provide a matrix or a valid operator (or see the Hamiltonien Simulation module).")
## construct the operators controlled-(Uj) to be applied in reverse order of qiskit convention
list_CU_operators = []
for k in range(len(list_U_matrices)):
matrix_CU = np.identity(dim_U_matrix*2, dtype = 'complex_')
for i in range(dim_U_matrix):
for j in range(dim_U_matrix):
matrix_CU[dim_U_matrix+i][dim_U_matrix+j] = list_U_matrices[k][i][j]
operator_CU = Operator(matrix_CU)
list_CU_operators.append(operator_CU)
flag_get_CU_gate = True
else:
flag_get_CU_gate = False
## convert the unitary operators into a quantum gates controlled-(U1*...*Un) to be applied r times
qc_temp = QuantumCircuit(1+num_qubits_q)
prefix_gate_name = "C-U"
for i in range(len(list_CU_operators)):
suffix_gate_name = str(i)
if(inverse_gate):
suffix_gate_name += "^dagger"
qc_temp.append(list_CU_operators[i].to_instruction().copy(prefix_gate_name+suffix_gate_name),
[x for x in range(num_qubits_q,-1,-1)]) # the order of qubits is reversed taking into account the Qiskit convention of ordering qubits
## deciding if returning the CU_gate or its inverse
CU_gate = qc_temp.to_gate()
if(inverse_gate == False):
return CU_gate, exponent_r
else:
CU_gate_inv = CU_gate.inverse()
CU_gate_inv.name = "C-U^dagger"
return CU_gate_inv, exponent_r
def qpe_hhl(circuit,
pos_init_qreg_a: int,
num_qubits_a: int,
pos_init_qreg_q: int,
num_qubits_q: int=1,
unitary_matrix: Optional[List]=None, # parameter to test the validity of the model
matrix: Optional[List]=None,
nonzero_entries: Optional[List]=None,
t: int=45,
measurement: bool=False,
Qiskit_reading_direction: bool=True):
## apply the Hadamard gate
for qubit in range(pos_init_qreg_a, pos_init_qreg_a+num_qubits_a):
circuit.h(qubit)
## create the controlled-U operator and turn it into a gate
if (unitary_matrix != None) :
CU_gate, exponent_r = get_CU_gate(num_qubits_a, num_qubits_q, t, unitary_matrix, matrix, nonzero_entries)
else :
CU_gate, exponent_r = get_CU_gate(num_qubits_a, num_qubits_q, t,None, matrix, nonzero_entries)
## apply the controlled-U^{2^j} gates
repetitions = 1
for qubit_qreg_a in range(pos_init_qreg_a, pos_init_qreg_a+num_qubits_a):
for i in range(repetitions):
# apply the Controlled-U gate (or the approximation: C-U=C-((U1*...*Un)^r) to the main circuit
qubits_control = [qubit_qreg_a]
qubits_controlled = [x for x in range(pos_init_qreg_q, pos_init_qreg_q+num_qubits_q)]
for j in range(exponent_r):
circuit.append(CU_gate.copy("controlled-U"), qubits_control+qubits_controlled)
repetitions *= 2
## apply inverse QFT
qft_dagger(circuit, pos_init_qreg_a, num_qubits_a)
# swap the qubits in the quantum register "a" if demanded (Qiskit_reading_direction == False).
if(Qiskit_reading_direction == False):
for qubit_qreg_a in range(pos_init_qreg_a, pos_init_qreg_a+num_qubits_a//2):
circuit.swap(qubit_qreg_a, num_qubits_a-qubit_qreg_a-1)
# add a measurement section at the end of the circuit if necessary (measurement == True).
if measurement:
c_a = ClassicalRegister(num_qubits_a, name='ca')
circuit.add_register(c_a)
circuit.barrier() # the safeguard-barrier
for qubit_qreg_a in range(pos_init_qreg_a, pos_init_qreg_a+num_qubits_a):
circuit.measure(qubit_qreg_a, c_a[qubit_qreg_a-pos_init_qreg_a])
def qpedagger_hhl(circuit,
pos_init_qreg_a: int,
num_qubits_a: int,
pos_init_qreg_q: int,
num_qubits_q: int=1,
unitar_matrix: Optional[List]=None,
matrix: Optional[List]=None,
nonzero_entries: Optional[List]=None,
t: int=45,
measurement: bool=False,
Qiskit_reading_direction: bool=True): # parameter to test the validity of the model
# swap the qubits in the quantum register "a" if demanded (Qiskit_reading_direction == False).
if(Qiskit_reading_direction == False):
for qubit_qreg_a in range(pos_init_qreg_a, pos_init_qreg_a+num_qubits_a//2):
circuit.swap(qubit_qreg_a, num_qubits_a-qubit_qreg_a-1)
## apply QFT
qft(circuit, pos_init_qreg_a, num_qubits_a)
## create the controlled-U^dagger operator and turn it into a gate
if (unitar_matrix != None) :
CU_gate, exponent_r = get_CU_gate(num_qubits_a, num_qubits_q, t, unitary_matrix, matrix, nonzero_entries, inverse_gate=True)
else :
CU_gate, exponent_r = get_CU_gate(num_qubits_a, num_qubits_q, t,None, matrix, nonzero_entries, inverse_gate=True)
## apply the controlled-U^{2^j} gates
repetitions = 2**(num_qubits_a-1)
for qubit_qreg_a in range(pos_init_qreg_a+num_qubits_a-1, pos_init_qreg_a-1, -1):
for i in range(repetitions):
# apply the Controlled-U gate (or the approximation: C-U=C-((U1*...*Un)^r) to the main circuit
qubits_control = [qubit_qreg_a]
qubits_controlled = [x for x in range(pos_init_qreg_q, pos_init_qreg_q+num_qubits_q)]
for j in range(exponent_r):
circuit.append(CU_gate.copy("controlled-U^dagger"), qubits_control+qubits_controlled)
repetitions //= 2
## apply the Hadamard gate
for qubit in range(pos_init_qreg_a, num_qubits_a):
circuit.h(qubit)
# add a measurement section at the end of the circuit if necessary (measurement == True).
if measurement:
c_a = ClassicalRegister(num_qubits_a, name='ca')
circuit.add_register(c_a)
circuit.barrier() # the safeguard-barrier
for qubit_qreg_a in range(pos_init_qreg_a, pos_init_qreg_a+num_qubits_a):
circuit.measure(qubit_qreg_a, c_a[qubit_qreg_a-pos_init_qreg_a])
num_ancillae = 2 #n_l
num_state = 2 #n_b
t = 6*np.pi/8
qr_a = QuantumRegister(num_ancillae, name='theta')
qr_q = QuantumRegister(num_state, name='b')
c = ClassicalRegister(num_ancillae+num_state, name='cr')
# matrix A
#matrix = [[1, -1/3],
# [-1/3, 1]]
matrix = [[1, -1/3,0,0],
[-1/3, 1,0,0],
[0,0,1, -1/3],
[0,0,-1/3, 1]]
#nonzero_entries = [[0, 1],
# [0, 1]]
nonzero_entries = [[0, 1, 2, 3],
[0, 1, 2, 3],
[0, 1, 2, 3],
[0, 1, 2, 3]]
initial_state = [1, 1, 1, 1]
#initial_state = [1, 1, 1, 1]
qc = QuantumCircuit(qr_q,qr_a,c)
# set the initial state using qiskit
state_in = Custom(num_qubits=num_state, state_vector = np.array(initial_state))
qc.data += state_in.construct_circuit('circuit', qr_q).data #qc.data : Return the circuit data (instructions and context).
# call the modules hamiltonian simulation (classical) + QPE + QFT
qpe_hhl(circuit=qc, pos_init_qreg_a=2, num_qubits_a=num_ancillae, pos_init_qreg_q=0, num_qubits_q=2,
matrix=matrix, nonzero_entries=nonzero_entries, t=t, measurement=False, Qiskit_reading_direction=True)
#qpedagger_hhl(circuit=qc, pos_init_qreg_a=0, num_qubits_a=num_ancillae, pos_init_qreg_q=num_ancillae, unitar_matrix=None, matrix=matrix, nonzero_entries=nonzero_entries, t=t, measurement=False, Qiskit_reading_direction=True)
qc.data += state_in.construct_circuit('circuit', qr_q).inverse().data
qc.draw(scale=0.8) #use "qc.decompose().draw(scale=0.8)" to see all the black-boxes (decomposed in the set of universal gates of Open-QASM: {u1, u2, u3, CNOT})
for i in range(num_ancillae+num_state):
qc.measure(i,i)
backend = Aer.get_backend('qasm_simulator')
shots = 2048
results = execute(qc, backend=backend, shots=shots).result()
answer = results.get_counts()
plot_histogram(answer)
###########
####QFT####
###########
def qca_qft(qc,r):
#Adds QFT operations on circuit qc, on the register indexed by r
#cf. Qiskit textbook, 3.5, for explanation of the algorithm
n=len(r)
for i in range(n):
qc.h(r[n-1-i])
for j in range(n-i-1):
qc.cp(pi/2**(n-1-i-j),r[j],r[n-1-i])
for i in range(n//2):
qc.swap(r[i],r[n-1-i])
def qca_qftdagger(qc,r):
#Adds QFTdagger operations on circuit qc, on the register indexed by r
n=len(r)
for i in range(n//2):
qc.swap(r[i],r[n-1-i])
for i in reversed(range(n)):
for j in reversed(range(n-i-1)):
qc.cp(-pi/2**(n-1-i-j),r[j],r[n-1-i])
qc.h(r[n-1-i])
def qca_c_qft(qc,r,pos_ctrl):
#Does the same thing as qca_qft, but with all the gates controlled by qubit in position qctrl
n=len(r)
for i in range(n):
qc.ch(pos_ctrl,r[n-1-i])
for j in range(n-i-1):
qc.mcp(pi/2**(n-1-i-j),[pos_ctrl,r[j]],r[n-1-i])
for i in range(n//2):
qc.cswap(pos_ctrl,r[i],r[n-1-i])
def qca_c_qftdagger(qc,r,pos_ctrl):
#Does the same thing as qca_qftdagger, but with all the gates controlled by qubit in position qctrl
n=len(r)
for i in range(n//2):
qc.cswap(pos_ctrl,r[i],r[n-1-i])
for i in reversed(range(n)):
for j in reversed(range(n-i-1)):
qc.mcp(-pi/2**(n-1-i-j),[pos_ctrl,r[j]],r[n-1-i])
qc.ch(pos_ctrl,r[n-1-i])
################
##Arithmétique##
################
#Addition
#########
def qca_adder(qc,a,b):
#Input:
#n+1 qubits of register indexed by a : (binary represantion in the computational basis of) a and |0\rangle on the last qubit
#n+1 qubits of register indexed by b : |b\rangle on the first n qubits, |0\rangle on the last qubit (last qubit used to store last carry)
#Output:
#n qubits of register indexed by a : |a\rangle
#n+1 qubits of register indexed by b : |a+b\rangle
n=len(a)-1
qca_qft(qc,b)
qc.barrier()
for i in range(n+1,0,-1):
for j in range(i,0,-1):
if j<=n:
qc.cp(pi/2**(i-j),a[j-1],b[n+1-i])
qc.barrier()
qca_qftdagger(qc,b)
def qca_ccp(qc,theta,ctrl1,ctrl2,target):
#Double controlled phase gate
qc.cp(theta/2,ctrl2,target)
qc.cx(ctrl1,ctrl2)
qc.cp(-theta/2,ctrl2,target)
qc.cx(ctrl1,ctrl2)
qc.cp(theta/2,ctrl1,target)
def qca_c_adder(qc,a,b,pos_ctrl):
#ctrl version of qca_adder
n=len(a)-1
qca_c_qft(qc,b,pos_ctrl)
qc.barrier()
for i in range(n+1,0,-1):
for j in range(i,0,-1):
if j<=n:
qca_ccp(qc,pi/2**(i-j),pos_ctrl,a[j-1],b[n+1-i])
qc.barrier()
qca_c_qftdagger(qc,b,pos_ctrl)
#Pseudo-soustraction
####################
def qca_subber(qc,a,b):
#Input:
#n+1 qubits of register indexed by a : (binary represantion in the computational basis of) a and |0\rangle on the last qubit
#n+1 qubits of register indexed by b : |b\rangle on the first n qubits, |0\rangle on the last qubit (last qubit used to store last carry)
#Output:
#n qubits of register indexed by a : |a\rangle
#n+1 qubits of register indexed by b : |a-b\rangle
n=len(a)-1
qca_qft(qc,b)
qc.barrier()
for i in range(n+1,0,-1):
for j in range(i,0,-1):
if j<=n:
qc.cp(-pi/2**(i-j),a[j-1],b[n+1-i])
qc.barrier()
qca_qftdagger(qc,b)
def qca_subber_swap(qc,a,b):
#Input:
#n+1 qubits of register indexed by a : (binary represantion in the computational basis of) a and |0\rangle on the last qubit
#n+1 qubits of register indexed by b : |b\rangle on the first n qubits, |0\rangle on the last qubit (last qubit used to store last carry)
#Output:
#n qubits of register indexed by a : |a-b\rangle
#n+1 qubits of register indexed by b : |b\rangle
n=len(a)-1
qca_qft(qc,a)
qc.barrier()
for i in range(n+1,0,-1):
for j in range(i,0,-1):
if j<=n:
qc.cp(-pi/2**(i-j),b[j-1],a[n+1-i])
qc.barrier()
qca_qftdagger(qc,a)
#Division
#########
def qca_ls(qc,a,n):
#left shifts register indexed by a n times.
if(n==1):
for i in range(len(a)-1):
qc.swap(a[len(a)-1-i],a[len(a)-2-i])
elif(n>1):
for i in range(len(a)-1):
qc.swap(a[len(a)-1-i],a[len(a)-2-i])
qca_ls(qc,a,n-1)
def listrs(L):
#Returns list obtained by right-shifting 1 time L
return([L[-1]]+L[:-1])
def listls(L):
#Returns list obtained by left-shifting 1 time L
return(L[1:]+[L[0]])
def qca_divider_V2(qc,p,d,q):
n=len(q)
for i in range(n-1,-1,-1):
# Multipliying |p\rangle by 2 : is equivalent to shifting it to the left by one unit
qca_ls(qc,p,1)
# Subtracting |d\rangle to |p\rangle, forcing rightmost qubit to be the subbing pad
qca_subber_swap(qc,listls(p),listls(d))
# If the result is positive, indicated by |p\rangle rightmost qubit being |0\rangle, then the i-th bit of the quotient is 1
qc.x(p[0])
qc.cx(p[0],q[i])
qc.x(p[0])
# Else, the result is negative and we add back |d\rangle to |p\rangle
# This operation is controlled by the fact that the i-th qubit of the quotient is still |0\rangle
qc.x(q[i])
qca_c_adder(qc,listls(d),listls(p),q[i])
qc.x(q[i])
def div(qc,p,d,q,n):
qca_divider_V2(qc,p,d,q)
def qc_rotation (qc, n, control_qubit, target_qubit):
# qc : object quantum circuit
# n : number of qubits on which we control our rotation
# control_qubit : first position of controlled qubits
# target_qubit : position of target qubit
for i in range (n) :
qc.ry(1/2**(i+1), target_qubit)
qc.cx(n+control_qubit-i-1 , target_qubit)
qc.ry(-1/2**(i+1), target_qubit)
qc.cx(n+control_qubit-i-1, target_qubit)
# for specific reasons, we would like to divide the controlled register in two parts
# this is motivated by the fact that our implementation of division gives a quotient and rest
# and concerned qubits are located in two different regiters
def qc_rotation_bis (qc, n, control_qubit_1, control_qubit_2, target_qubit):
# qc : object quantum circuit
# n : number of qubits divided by two on which we control our rotation
# control_qubit_1 : first position of first register of controlled qubits
# control_qubit_2 : first position of second register of controlled qubits
# target_qubit : position of target qubit
for i in range (n) :
qc.ry(1/2**(i+1), target_qubit)
qc.cx(n+control_qubit_1-i-1 , target_qubit)
qc.ry(-1/2**(i+1), target_qubit)
qc.cx(n+control_qubit_1-i-1, target_qubit)
for i in range (n) :
qc.ry(1/2**(n+i+1), target_qubit)
qc.cx(n+control_qubit_2-i-1 , target_qubit)
qc.ry(-1/2**(n+i+1), target_qubit)
qc.cx(n+control_qubit_2-i-1, target_qubit)
qc = QuantumCircuit (4)
# init theta = |111>
qc.x(0)
qc.x(1)
qc.x(2)
#qc.barrier()
qc_rotation (qc, 3, 0, 3)
qc.measure_all()
qc.draw()
backend = Aer.get_backend('qasm_simulator')
shots = 2048
results = execute(qc, backend=backend, shots=shots).result()
answer = results.get_counts()
plot_histogram(answer)
def HHL (num_ancille, num_state, t, matrix, initial_state, C=0) :
print(t)
# num_ancillae is the number of qubits used in QPE for phase estimation (n_l)
# num_state is the number of qubits used for |b> (n_b)
# matrix is the matrix of the system
# initial state is the value of vector b
# C parameter, if set 0 then C=|11...1> (biggest value possible but not a good ida, see remark)
# 5*num_ancillae + num_state + 1
qr_theta = QuantumRegister(num_ancillae, name='theta')
qr_b = QuantumRegister(num_state, name='b')
qr_aux = QuantumRegister(num_ancillae, name='aux')
qr_r = QuantumRegister(num_ancillae, name='r')
qr_d = QuantumRegister(num_ancillae, name='d')
qr_q = QuantumRegister(num_ancillae, name='q')
qr_S = QuantumRegister(1, name='s')
qc = QuantumCircuit (qr_theta, qr_b, qr_aux, qr_r, qr_d, qr_q, qr_S)
# set the initial state using qiskit
state_in = Custom(num_qubits=num_state, state_vector = np.array(initial_state))
qc = qc.compose (state_in.construct_circuit('circuit', qr_b), [2]) #qc.data : Return the circuit data (instructions and context).
# call the modules hamiltonian simulation (classical) + QPE + QFT
global list_CU_operators, exponent_r, flag_get_CU_gate
list_CU_operators = None
exponent_r = None
flag_get_CU_gate = None
qpe_hhl(circuit=qc, pos_init_qreg_a=0, num_qubits_a=num_ancillae, pos_init_qreg_q=num_ancillae, unitary_matrix=None, matrix=matrix, t=t, measurement=False, Qiskit_reading_direction=True, nonzero_entries=nonzero_entries)
qc.barrier()
# call eigenvalue rotation
# step 1 : ASNINV
for i in range (num_ancillae) :
qc.x(num_state+3*num_ancillae+i)
#qc.x(num_state+4*num_ancillae-1)
# Divider that takes |p>|d>|q>.
# |p> is length 2n and has n zeros on the left: 0 ... 0 p_n ... p_1.
# |d> has length 2n and has n zeros on the right: d_2n ... d_{n+1) 0 ... 0.
# |q> has length n and is initially all zeros.
# At the end of the algorithm, |q> will contain the quotient of p/d, and the
# left n qubits of |p> will contain the remainder of p/d.
#Qiskit order of qubits may be a little be confusing since qubits order are inverted meaning
# 0 ... 0 p_n ... p_1 will appear as |p_1 ... p_n 0 ... 0>
#
p_idx = list (range(num_state+3*num_ancillae, num_state+4*num_ancillae)) + list (range(num_state+2*num_ancillae, num_state+3*num_ancillae))
print("p_idx: ",p_idx)
d_idx = list(range(num_state+num_ancillae,num_state+2*num_ancillae)) + list (range(num_ancillae))
print("d_idx: ",d_idx)
q_idx = list (range (num_state+4*num_ancillae, num_state+5*num_ancillae))
print("q_idx: ",q_idx)
div (qc=qc,
p=p_idx,
d=d_idx,
q=q_idx,
n=num_ancillae)
qc.barrier()
# step 2 : controlled rotaiotn
qc_rotation_bis (qc, num_ancillae, num_state+4*num_ancillae, num_state+2*num_ancillae,num_state+5*num_ancillae)
qc.barrier()
# step 3 : ASNINV_dagger
qc_aux = QuantumCircuit (5*num_ancillae + num_state)
div (qc_aux, list (range(num_state+3*num_ancillae, num_state+4*num_ancillae)) + list (range(num_state+2*num_ancillae, num_state+3*num_ancillae)),
list(range(num_state+num_ancillae,num_state+2*num_ancillae)) + list (range(num_ancillae)),
list (range (num_state+4*num_ancillae, num_state+5*num_ancillae)), num_ancillae)
qc = qc.compose (qc_aux.inverse(), list(range(num_state+ 5*num_ancillae)))
for i in range (num_ancillae) :
qc.x(num_state+3*num_ancillae+i)
#qc.x(num_state+4*num_ancillae-1)
qc.barrier()
# QPE dagger
qpedagger_hhl(circuit=qc, pos_init_qreg_a=0, num_qubits_a=num_ancillae, pos_init_qreg_q=num_ancillae, unitar_matrix=None, matrix=matrix, t=t, measurement=False, Qiskit_reading_direction=True, nonzero_entries=nonzero_entries)
qc.barrier()
#qc.draw(filename="nouveau")
qc.measure_all()
return qc
def liste_state (n_b, n_l) :
def liste_ket (n_b) :
if (n_b == 1) :
return ['0', '1']
else :
L = liste_ket (n_b-1)
res = []
for x in L :
res.append (x+'1')
res.append (x+'0')
return res
L = liste_ket (n_b)
res = []
for x in L :
res.append ((x,'1'+'0'*(4*n_l)+x+ '0'*n_l))
return res
def analysis (num_state, num_ancillae, answer) :
nombre_1 = 0
nombre_tot = 0
for cle, valeur in answer.items():
nombre_tot += valeur
if (str(cle)[0] == '1') :
nombre_1 += valeur
print ("la probabilité de réussite de l'algorithme est d'environ", nombre_1*1.0/nombre_tot*100, "% de chance")
for x,y in liste_state (num_state, num_ancillae) :
try:
print ("la probabilité de mesurer l'état |"+ x +">", "est", answer[y]*1.0/nombre_1)
except:
pass
num_ancillae = 2 # n_l
num_state = 1 # n_b
t = 6*np.pi/8
matrix = [[1, -1/3],
[-1/3, 1]]
initial_state = [1, 1]
qc = HHL (num_ancillae, num_state, t, matrix, initial_state)
# pour visualiser le circuit
qc.draw (scale=0.55)
backend = Aer.get_backend('qasm_simulator')
shots = 2048*10
results = execute(qc, backend=backend, shots=shots).result()
answer = results.get_counts()
# calcul de la probabilité estimée de réussite de l'algorithme
analysis (num_state, num_ancillae, answer)
plot_histogram(answer)
num_ancillae = 2 # n_l
num_state = 1 # n_b
t = 6*np.pi/8 # t
matrix = [[1, -1/3],
[-1/3, 1]]
initial_state = [1, 0]
qc = HHL (num_ancillae, num_state, t, matrix, initial_state)
# pour visualiser le circuit
# qc.draw (scale=0.55)
backend = Aer.get_backend('qasm_simulator')
shots = 2048*10
results = execute(qc, backend=backend, shots=shots).result()
answer = results.get_counts()
# calcul de la probabilité estimée de réussite de l'algorithme
analysis (num_state, num_ancillae, answer)
plot_histogram(answer)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_nature.second_q.problems import BaseProblem
dummy_hamiltonian = None
base_problem = BaseProblem(dummy_hamiltonian)
print(base_problem.properties)
from qiskit_nature.second_q.properties import AngularMomentum
print("AngularMomentum is in problem.properties:", AngularMomentum in base_problem.properties)
print("Adding AngularMomentum to problem.properties...")
base_problem.properties.add(AngularMomentum(2))
print("AngularMomentum is in problem.properties:", AngularMomentum in base_problem.properties)
print("Discarding AngularMomentum from problem.properties...")
base_problem.properties.discard(AngularMomentum)
print("AngularMomentum is in problem.properties:", AngularMomentum in base_problem.properties)
from qiskit_nature.second_q.drivers import PySCFDriver
es_problem = PySCFDriver().run()
print(es_problem.properties.particle_number)
print(es_problem.properties.angular_momentum)
print(es_problem.properties.magnetization)
print(es_problem.properties.electronic_dipole_moment)
print(es_problem.properties.electronic_density)
from qiskit_nature.second_q.properties import ElectronicDensity
density = ElectronicDensity.from_orbital_occupation(
es_problem.orbital_occupations,
es_problem.orbital_occupations_b,
)
es_problem.properties.electronic_density = density
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/AbdulahAmer/PHYS-31415-Summer-2021
|
AbdulahAmer
|
# Do not forget to Import Qiskit
from qiskit.visualization import *
from qiskit import *
S_simulator=Aer.backends(name='statevector_simulator')[0]
M_simulator=Aer.backends(name='qasm_simulator')[0]
# new import allows us to use CircuitOP() and CircuitStateFn() as well as operators I,X,Y,Z etc.
from qiskit.aqua.operators import *
from qiskit.quantum_info import random_unitary
op=QuantumCircuit(1) # make an operator circuit, and turn it into an operator! DO NOT add a classical bit
op.h(0)
op =CircuitOp(op)
psi = QuantumCircuit(1) # make a wavefunction circuit.
psi=CircuitStateFn(psi)
# psi is our ket and we can use psi.adjoint() to get its complext conjugate, the bra
# so to do an expectation value of <psi| H |psi> we just do psi.adjoint() on H |psi> this can be done in the following way
print('expectation value: ', psi.adjoint().compose(op).compose(psi).eval().real)
op = (-1.0523732 * I^I) + (0.39793742 * I^Z) + (-0.3979374 * Z^I) \
+ (-0.0112801 * Z^Z) + (0.18093119 * X^X)
psi = QuantumCircuit(2)
psi.x(0)
psi.x(1)
psi=CircuitStateFn(psi)
print('expectation value: ', psi.adjoint().compose(op).compose(psi).eval().real)
# Try to follow along a problem from a paper [1]
# construct a circuit with 5 parameters.
from random import uniform
from math import pi
thetas = []
n=5
for i in range(n):
thetas.append(uniform(0,2*pi))
theta1 = thetas[0]
theta2 = thetas[1]
theta3 = thetas[2]
theta4 = thetas[3]
theta5 = thetas[4]
print('starting thetas: ', thetas)
# these random thetas are the starting values for our rotation operators
variational_circuit=QuantumCircuit(5)
#rotations that are dependent on theta
variational_circuit.rx(theta1, 0)
variational_circuit.rx(theta2, 1)
variational_circuit.rx(theta3, 2)
variational_circuit.rx(theta4, 3)
variational_circuit.rx(theta5, 4)
variational_circuit.barrier()
#entangling block (dont worry too much)
variational_circuit.cx(0,1)
variational_circuit.barrier()
variational_circuit.cx(2,1)
variational_circuit.barrier()
variational_circuit.cx(3,1)
variational_circuit.barrier()
variational_circuit.cx(4,3)
variational_circuit.barrier()
variational_circuit.draw(output='mpl')
U = CircuitOp(variational_circuit)
Z = QuantumCircuit(5)
Z.z(1)
Z = CircuitOp(Z)
# we can easily find the complex conjugate of the U
U_dag = U.adjoint()
psi = QuantumCircuit(5) # make a wavefunction circuit.
psi=CircuitStateFn(psi)
print('expectation value: ',
psi.adjoint().compose(U_dag).compose(Z).compose(U).compose(psi).eval().real)
def make_variational_circuit(thetas):
theta1 = thetas[0]
theta2 = thetas[1]
theta3 = thetas[2]
theta4 = thetas[3]
theta5 = thetas[4]
variational_circuit=QuantumCircuit(5)
#rotations that are dependent on theta
variational_circuit.rx(theta1, 0)
variational_circuit.rx(theta2, 1)
variational_circuit.rx(theta3, 2)
variational_circuit.rx(theta4, 3)
variational_circuit.rx(theta5, 4)
variational_circuit.barrier()
#entangling block (dont worry too much)
variational_circuit.cx(0,1)
variational_circuit.barrier()
variational_circuit.cx(2,1)
variational_circuit.barrier()
variational_circuit.cx(3,1)
variational_circuit.barrier()
variational_circuit.cx(4,3)
variational_circuit.barrier()
return variational_circuit
def get_U_and_U_dag(variational_circuit):
U = CircuitOp(variational_circuit)
U_dag = U.adjoint()
return U, U_dag
# We can hardcode Z in here but thats not great convention
# this is strictly for example and not practical
def expectation_value(U, U_dag):
psi = QuantumCircuit(5) # make a wavefunction circuit.
psi=CircuitStateFn(psi)
Z = QuantumCircuit(5)
Z.z(1)
Z = CircuitOp(Z)
return psi.adjoint().compose(U_dag.compose(Z.compose(U))).compose(psi).eval().real
# to shift our thetas it can be done a number of ways
thetas_plus = []
thetas_minus = []
for i in range(len(thetas)):
thetas_plus.append(thetas[i]+(0.5*pi))
thetas_minus.append(thetas[i]-(0.5*pi))
# our first gradient can be calculated now
def get_eval(thetas):
variational_circuit = make_variational_circuit(thetas)
U, U_dag = get_U_and_U_dag(variational_circuit)
return expectation_value(U,U_dag)
def get_gradient(thetas):
thetas_plus = []
thetas_minus = []
for i in range(len(thetas)):
thetas_plus.append(thetas[i]+(0.5*pi))
thetas_minus.append(thetas[i]-(0.5*pi))
f_plus = get_eval(thetas_plus)
f_minus = get_eval(thetas_minus)
return 0.5*(f_plus - f_minus)
get_gradient(thetas)
def update_thetas(thetas):
learning_rate=0.2
gradient = get_gradient(thetas)
updated_thetas=[]
for i in range(len(thetas)):
updated_thetas.append(thetas[i] - (learning_rate*gradient))
return updated_thetas
print('thetas before update: ', thetas)
thetas = update_thetas(thetas)
print('thetas after update: ', thetas)
from random import uniform
from math import pi
thetas = []
n=5
for i in range(n):
thetas.append(uniform(2*pi,2*pi))
print('thetas before update: ', thetas)
print('gradient: ', get_gradient(thetas))
thetas = update_thetas(thetas)
print('thetas after update: ', thetas)
thetas_plus = []
thetas_minus = []
for i in range(len(thetas)):
thetas_plus.append(thetas[i]+(0.5*pi))
thetas_minus.append(thetas[i]-(0.5*pi))
f_plus = get_eval(thetas_plus)
f_minus = get_eval(thetas_minus)
print(f_plus, f_minus)
var = QuantumCircuit()
|
https://github.com/ohadlev77/sat-circuits-engine
|
ohadlev77
|
# Copyright 2022-2023 Ohad Lev.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0,
# or in the root directory of this package("LICENSE.txt").
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
`SingleConstraintBlock` and `ArithmeticExprBlock` classes.
"""
from typing import Union, Optional, List, Dict, Any
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, transpile
from qiskit.circuit import Qubit
from qiskit.circuit.library import QFT
from sat_circuits_engine.constraints_parse import SingleConstraintParsed
from sat_circuits_engine.util.settings import TRANSPILE_KWARGS
class SingleConstraintBlock(QuantumCircuit):
"""
A quantum circuit implementation of a single constraint.
To be integrated as a block in a `GroverConstriantsOperator` object.
"""
def __init__(
self, parsed_data: SingleConstraintParsed, transpile_kwargs: Optional[Dict[str, Any]] = None
) -> None:
"""
Args:
parsed_data (SingleConstraintParsed): an object contains all necessary
information for a single constraint, in a specific API (see `help(SingleConstraintParsed)`
for API annotation).
transpile_kwargs (Optional[Dict[str, Any]] = None): keyword arguments for self-transpilation
that takes place in this class. If None (default) - `TRANSPILE_KWARGS` constant is used.
"""
self.parsed_data = parsed_data
self.constraint_index = self.parsed_data.constraint_index
if transpile_kwargs is None:
transpile_kwargs = TRANSPILE_KWARGS
self.transpile_kwargs = transpile_kwargs
# Handling arithmetic expressions and constructing the container - `self.regs`
self.handle_arithmetics()
# Creating a unified list of registers to unpack as args for `super().__init__`
regs_list = []
for item in self.regs.values():
regs_list.extend(item)
# Initializing circuit
super().__init__(*regs_list, name=self.parsed_data.string_to_show)
# Assembling a circuit implementation of the given constraint
self.assemble()
# Saving a transpiled version of `self`.
# Used by `GroverConstraintsOperator` to set the order of constraints.
self.transpiled = transpile(self, **self.transpile_kwargs)
def __repr__(self) -> str:
return f"{self.__class__.__name__}" f"('{self.parsed_data.string_to_show}')"
def handle_arithmetics(self) -> None:
"""
Handles arithmetic operations from both sides of the constraint's equation, if needed.
Initiates some of the quantum registers that compose the circuit (`self`).
The left side of the constraint's equation is indexed as 0, and the right side is inexed as 1.
Defines attributes:
self.regs (Dict[str, List[QuantumRegister]]): container for quantum registers.
self.arith_blocks (List[Optioanl[ArithmeticExprBlock] = None]): Indexed containter for
`ArithmeticExprBlock` objects. None (default) - if no artihmetics in a specific side.
self.integer_flags (List[bool]): Indexed container for boolean values. True for a side
that contains bare integer only, otherwise False.
"""
self.regs = {
# Initializing empty input registers
"inputs": [QuantumRegister(0, "input_left"), QuantumRegister(0, "input_right")],
# Initializing empty auxiliary register for performing arithmetics
"sides_aux": [
QuantumRegister(0, f"c{self.constraint_index}_aux_left"),
QuantumRegister(0, f"c{self.constraint_index}_aux_right"),
],
}
self.arith_blocks = [None, None]
self.integer_flags = [False, False]
# Iterating over the 2 sides of the constraint's equation and constructing the needed registers
for side, (bit_indexes, int_bitstring) in enumerate(
zip(self.parsed_data.sides_bit_indexes, self.parsed_data.sides_int_bitstrings)
):
# Case A - arithmetic expression
if (len(bit_indexes) > 1) or (len(bit_indexes) == 1 and int_bitstring is not None):
# Case A.1 -the other side of the equations is a bare integer
compared_value = None
if (
not self.parsed_data.sides_bit_indexes[side ^ 1]
and self.parsed_data.sides_int_bitstrings[side ^ 1]
):
compared_value = int(self.parsed_data.sides_int_bitstrings[side ^ 1], 2)
# Generating the arithmetic expression block
self.arith_blocks[side] = ArithmeticExprBlock(
bit_indexes, int_bitstring, compared_value=compared_value
)
# Creating an input register that fits with the arithmetic expression block
self.regs["inputs"][side] = QuantumRegister(
self.arith_blocks[side].total_operands_width, self.regs["inputs"][side].name
)
# Creating an auxiliary register for arithmetics
self.regs["sides_aux"][side] = QuantumRegister(
self.arith_blocks[side].result_reg_width, self.regs["sides_aux"][side].name
)
# Case B - single variable expression
elif len(bit_indexes) == 1 and int_bitstring is None:
self.regs["inputs"][side] = QuantumRegister(
len(bit_indexes[0]), self.regs["inputs"][side].name
)
# Case C - bare integer expression
else:
self.integer_flags[side] = True
def assemble(self) -> None:
"""
Assembles a complete circuit implementation of the given constraint.
"""
compare_operands = []
# Figuring the compared operand for each of the contraint's equation sides
for arith_block, input_reg, side_aux_reg, integer_flag, int_bitstring in zip(
self.arith_blocks,
self.regs["inputs"],
self.regs["sides_aux"],
self.integer_flags,
self.parsed_data.sides_int_bitstrings,
):
# Arithmetic block operand
if arith_block is not None:
# Appeding the arithmetic block to the `self`
self.append(arith_block, qargs=input_reg[:] + side_aux_reg[::-1])
compare_operands.append(side_aux_reg)
else:
# Integer bitstring operand
if integer_flag:
compare_operands.append(int_bitstring)
# A bundle of qubits (from the input register) operand
else:
compare_operands.append(input_reg)
# Applying the methods for the necessary comparison
if self.integer_flags[0]:
self.qubits_int_comparison(
qubits_bundle=compare_operands[1],
int_bitstring=compare_operands[0],
operator=self.parsed_data.operator,
)
elif self.integer_flags[1]:
self.qubits_int_comparison(
qubits_bundle=compare_operands[0],
int_bitstring=compare_operands[1],
operator=self.parsed_data.operator,
)
else:
self.unbalanced_qubits_comparison(
qubits_bundle_1=compare_operands[0],
qubits_bundle_2=compare_operands[1],
operator=self.parsed_data.operator,
)
def qubits_int_comparison(
self,
qubits_bundle: Union[List[Union[Qubit, int]], QuantumRegister],
int_bitstring: str,
*,
operator: Optional[str] = "==",
) -> None:
"""
Compares a bundle of qubits to an integer.
Args:
qubits_bundle (Union[List[Union[Qubit, int]], QuantumRegister]): compared qubits.
int_bitstring (str): compared integer (in a bitstring form).
operator (Optional[str] = "=="): comparison operator, default is "==",
and the other option is "!=".
Raises:
AssertionError: If `int_bitstring` is an integer larger than any integer
that can be possibly represented by `qubits_bundle`.
"""
# Adding an "out" qubit to write the result into
self.add_out_reg()
# Creating pointers for convenience
len_int = len(int_bitstring)
len_qubits_bundle = len(qubits_bundle)
# Catching non-logical input
assert len_int <= len_qubits_bundle, (
f"The integer ({int_bitstring}) length is longer than compared"
f"qubits ({qubits_bundle}), no solution."
)
# In the case the equation is unbalanced, filling the integer with zeros from the left
if len_int < len_qubits_bundle:
int_bitstring = int_bitstring.zfill(len_qubits_bundle)
# Setting `len_int` again after filling `int_bitstring` with zeros from the left
len_int = len(int_bitstring)
# Flipping bits in `qubits_bundle` in order to compare them to '0' digits in `int_bitstring`
flipping_zeros = QuantumCircuit(len_int, name=f"{int_bitstring}_encoding")
for digit, qubit in zip(int_bitstring, flipping_zeros.qubits):
if digit == "0":
flipping_zeros.x(qubit)
self.append(flipping_zeros, qargs=qubits_bundle)
# Writing results to the "out" qubit
# TODO need to generalize RCCX and RCCCX to the n-control qubits case
if len_qubits_bundle == 2:
self.rccx(qubits_bundle[0], qubits_bundle[1], self.regs["out"][0])
elif len_qubits_bundle == 3:
self.rcccx(qubits_bundle[0], qubits_bundle[1], qubits_bundle[2], self.regs["out"][0])
else:
self.mcx(qubits_bundle, self.regs["out"][0])
# Flipping outcome in the case the operator is "!="
if operator == "!=":
self.x(self.regs["out"][0])
# Uncomputing flipped bits
self.append(flipping_zeros, qargs=qubits_bundle)
def unbalanced_qubits_comparison(
self,
qubits_bundle_1: Union[List[Union[Qubit, int]], QuantumRegister],
qubits_bundle_2: Union[List[Union[Qubit, int]], QuantumRegister],
*,
operator: Optional[str] = "==",
) -> None:
"""
The most general case of comparing 2 bundles of qubits.
The bundles might be of the same length ("balanced") or not ("unbalanced").
Args:
qubits_bundle_1, qubits_bundle_2 (Union[List[Union[Qubit, int]], QuantumRegister]):
- Qubits of bundle_1 are compared to qubits of bundle_2.
operator (Optional[str] = "=="): comparison operator, default is "==",
and the other option is "!=".
"""
# Creating pointers for convenience
len_bundle_1 = len(qubits_bundle_1)
len_bundle_2 = len(qubits_bundle_2)
# The case where a comparison aux register is needed
if len_bundle_1 > 1 or len_bundle_2 > 1:
self.add_comparison_aux_reg(min(len_bundle_1, len_bundle_2))
# Adding an "out" qubit to write the result into
self.add_out_reg()
# In this case, only 2 qubits comparison is needed, and then the method's execution halts
if len_bundle_1 == 1 and len_bundle_2 == 1:
self.two_qubits_comparison(
qubits_bundle_1, qubits_bundle_2, self.regs["out"][0], operator=operator
)
return
# Setting short and long bundles and cutting the long bundle to 2 parts.
# The right part of the long bundle is comparble to the short bundle.
if len_bundle_1 > len_bundle_2:
long = qubits_bundle_1
short = qubits_bundle_2
long_right_cut = qubits_bundle_1[-len_bundle_2:]
else:
long = qubits_bundle_2
short = qubits_bundle_1
long_right_cut = qubits_bundle_2[-len_bundle_1:]
len_short = len(short)
len_long = len(long)
long_left_cut = long[: len_long - len_short]
# Comparing the rightmost bits in the longer bundle to the bits of the shorter bundle
self.balanced_qubits_comparison(
short, long_right_cut, self.regs["comparison_aux"][0][:len_short]
)
# Flipping the left bits in the longer bundle (in order to check whether they all zeros)
if long_left_cut:
self.x(long_left_cut)
# Writing results to the "out" qubit
# TODO need to generalize RCCX and RCCCX to the n-control qubits case
q = long_left_cut + self.regs["comparison_aux"][0][:]
if len(q) == 2:
self.rccx(q[0], q[1], self.regs["out"][0])
elif len(q) == 3:
self.rcccx(q[0], q[1], q[2], self.regs["out"][0])
else:
self.mcx(q, self.regs["out"][0])
# Flipping outcome in the case the operator is "!="
if operator == "!=":
self.x(self.regs["out"][0])
# Uncomputing flipping left bits in the longer bundle
if long_left_cut:
self.x(long_left_cut)
def balanced_qubits_comparison(
self,
qubits_bundle_1: Union[List[Union[Qubit, int]], QuantumRegister],
qubits_bundle_2: Union[List[Union[Qubit, int]], QuantumRegister],
aux_qubits: Union[List[Union[Qubit, int]], QuantumRegister],
out_qubit: Optional[Union[Qubit, QuantumRegister, int]] = None,
*,
operator: Optional[str] = "==",
) -> None:
"""
Comparing 2 bundles of qubits.
The bundles must be of the same length ("balanced").
Args:
qubits_bundle_1, qubits_bundle_2 (Union[List[Union[Qubit, int]], QuantumRegister]):
- Qubits of bundle_1 are compared to qubits of bundle_2.
aux_qubits (Union[List[Union[Qubit, int]], QuantumRegister]): auxiliary qubits for
comparing `qubits_bundle_1` with `qubits_bundle_2`.
out_qubit (Optional[Union[Qubit, QuantumRegister, int]] = None): A qubit
to write the result into. If None - not writing result, probably the method
is being used by another method and not intended to write results.
operator (Optional[str] = "=="): comparison operator, default is "==",
and the other option is "!=".
"""
# No auxilliary qubits = the case of comparing 1 single qubit from each side
if len(aux_qubits) == 0:
aux_qubits = out_qubit
# Implementation of: qubits_bundle_1 == qubits_bundle_2.
# Comparing each pair of qubits and writing results to auxilliary qubits.
for q1, q2, aux in zip(qubits_bundle_1, qubits_bundle_2, aux_qubits):
self.two_qubits_comparison(q1, q2, aux, operator="==")
if out_qubit is not None:
print("============ CHECK CHECK CHECK CHECK CHECK ======================")
# Writing overall outcome to the "out" qubit
# TODO need to generalize RCCX and RCCCX to the n-control qubits case
if len(aux) == 2:
self.rccx(aux[0], aux[1], out_qubit)
elif len(aux) == 3:
self.rcccx(aux[0], aux[1], aux[2], out_qubit)
else:
self.mcx(aux, out_qubit)
# Flipping outcome in the case the operator is "!="
if operator == "!=":
self.x(out_qubit)
def two_qubits_comparison(
self,
qubit_1: Union[Qubit, QuantumRegister, int],
qubit_2: Union[Qubit, QuantumRegister, int],
qubit_result: Union[Qubit, QuantumRegister, int],
*,
operator: Optional[str] = "==",
) -> None:
"""
Compares values of 2 qubits.
Args:
qubit_1 (Union[Qubit, QuantumRegister, int]): first qubit to compare.
qubit_2 (Union[Qubit, QuantumRegister, int]): second qubit to compare.
qubit_result (Union[Qubit, QuantumRegister, int]): qubit to write the results to.
operator (Optional[str] = "=="): comparison operator, default is "==",
and the other option is "!=".
"""
# XOR implementaion for qubit_1 != qubit_2
self.cx(qubit_1, qubit_result)
self.cx(qubit_2, qubit_result)
# Flipping the result for qubit_1 == qubit_2
if operator == "==":
self.x(qubit_result)
def add_comparison_aux_reg(self, width: int) -> None:
"""
Appends an auxilliary register for the comparison (between sides of equation) operations.
Adds it also to self.regs under the key "comparison_aux" (accessible
via `self.regs['comparison_aux'][0]).
Args:
width (int): number of qubits in the register.
"""
aux_reg = QuantumRegister(width, f"c{self.constraint_index}_aux_comparison")
self.add_register(aux_reg)
self.regs["comparison_aux"] = [aux_reg]
def add_out_reg(self) -> None:
"""
Appends a single-qubit "out" register to this object.
Adds it also to self.regs under the key "out" (accessible via `self.regs['out'][0]).
"""
out_reg = QuantumRegister(1, f"c{self.constraint_index}_out")
self.add_register(out_reg)
self.regs["out"] = [out_reg]
class ArithmeticExprBlock(QuantumCircuit):
"""
A quantum circuit implementation of an arithmetic expression.
To be integrated as a block in a `SingleConstraintBlock` object.
"""
def __init__(
self,
single_side_bits_indexes: List[List[int]],
single_side_integer_bitstring: Optional[str] = None,
compared_value: int = None,
block_name: Optional[str] = None,
) -> None:
"""
Args:
single_side_bits_indexes (List[List[int]]): A list of lists, each list contains bit
indexes that form a single bundle.
single_side_integer_bitstring (Optional[str] = None): If exists, the binary string
of the integer in an arithmetic expression.
compared_value (int = None):
- An integer value that the arithmetic expression is compared to (in the "other side"
of the constraint's equation).
- If defined - this class will try to reduce the width of its results
register using modular addition, after negating collisions possibilities.
block_name (Optional[str] = None): a name for this circuit block. If None, a meaningful
name is given by this class automatically.
"""
self.bits_indexes = single_side_bits_indexes
self.integer_bitstring = single_side_integer_bitstring
# Translating qubits bundles into a list of number of qubits in each bundle
self.operands_widths = list(map(lambda x: len(x), self.bits_indexes))
self.total_operands_width = sum(self.operands_widths)
# Computing the necessary width for the results aux register
self.result_reg_width = self.compute_addition_result_width(
self.operands_widths, self.integer_bitstring, compared_value
)
# Defining registers
self.bundles_regs = list(
map(lambda x: QuantumRegister(x[1], f"reg_bundle_{x[0]}"), enumerate(self.operands_widths))
)
self.result_reg = QuantumRegister(self.result_reg_width, "result_reg")
# Initiazling circuit
super().__init__(*self.bundles_regs, self.result_reg)
# Performing addition of all operands
self.add()
# Assigning name to this circuit block
if block_name is None:
block_name = f"Addition:{self.bits_indexes} + {self.integer_bitstring}"
self.name = block_name
def add(self) -> None:
"""
Performing addition of all operands.
NOTE: Supports only non-repeated values (VALID = [3][2] + [1] + 5, NOT VALID = [3][2] + [2][1]).
"""
# Assigning `default_bitstring` value to `results_qubits`
if self.integer_bitstring is None:
self.integer_bitstring = "".zfill(self.result_reg_width)
else:
self.integer_bitstring = self.integer_bitstring.zfill(self.result_reg_width)
for digit, result_qubit in zip(reversed(self.integer_bitstring), self.result_reg):
if digit == "1":
self.x(result_qubit)
# Performing "default addition" (= copying values of each bit with CNOTS) of one
# operand (the most suitable one) to `self.result_reg`, if possible (Before applying QFT).
default_added_operand_index = self.default_addition()
if default_added_operand_index is not None:
self.bundles_regs.pop(default_added_operand_index)
if self.bundles_regs:
# Transforming `results_qubits` to Fourier basis
self.append(QFT(self.result_reg_width), qargs=self.result_reg)
# Fourier addition of all bundles
for reg in self.bundles_regs:
self.fourier_add_single_bundle(reg, self.result_reg)
# Transforming `results_qubits` back to the computational basis
self.append(QFT(self.result_reg_width, inverse=True), qargs=self.result_reg)
def default_addition(self) -> int:
"""
Performs in bit-to-bit addition of one of the operands to `self.result_reg` if possible.
Returns:
(int): the index of the operand that has been added.
"""
# Counting the number of trailing zeros (i.e, number of available bits to copy values into)
try:
trailing_zeros_num = self.integer_bitstring[::-1].index("1")
except ValueError:
trailing_zeros_num = self.result_reg_width
# Finding the best operand to copy its value (the longest one that's shorter
# or equal in length to the number of trailing zeros).
operand_index = None
for num_zeros in reversed(range(1, trailing_zeros_num + 1)):
try:
operand_index = self.operands_widths.index(num_zeros)
trailing_zeros_num = num_zeros
break
except ValueError:
pass
# If possible, performing the optimal bit-to-bit addition
if operand_index is not None:
self.cx(self.bundles_regs[operand_index], self.result_reg[:trailing_zeros_num][::-1])
return operand_index
def fourier_add_single_bundle(
self,
qubits_to_add: Union[List[Union[Qubit, int]], QuantumRegister],
target_qubits: Union[List[Union[Qubit, int]], QuantumRegister],
) -> None:
"""
Perform an addition in Fourier basis.
Args:
qubits_to_add (Union[List[Union[Qubit, int]], QuantumRegister]): a bundle of qubits
to sum their values.
target_qubits (Union[List[Union[Qubit, int]], QuantumRegister]): qubits to write the result
into, must be already in Fourier basis.
"""
# `qubits_to_add` are reversed due to bits ordering issues (consistency with little-endian)
for control_index, control_q in enumerate(reversed(qubits_to_add)):
for target_index, target_q in enumerate(target_qubits):
k = len(target_qubits) - target_index
phase = (2 * np.pi * (2**control_index)) / (2**k)
# Phase shifts of 2pi multiples are indistinguishable = Breaking from the inner loop
if phase == 2 * np.pi:
break
self.cp(theta=phase, control_qubit=control_q, target_qubit=target_q)
@staticmethod
def compute_addition_result_width(
regs_widths: List[int],
default_bitstring: Optional[str] = None,
compared_value: Optional[int] = None,
) -> int:
"""
Calculates `width` - the (minimal) width of the register that should
contain the sum of values of the registers (whose widths are stored in `regs_width`)
with `default_bitstring`.
Args:
regs_widths (List[int]): number of bits in each of the summed registers.
default_bitstring (Optional[str] = None): integer bitstring operand.
compared_value (Optional[int] = None):
- An integer value that the arithmetic expression is compared to (in the "other side"
of the constraint's equation).
Returns:
(int) - `width`.
"""
if default_bitstring is None:
default_bitstring = "0"
# Just 1 operand = no addition
if len(regs_widths) == 1 and default_bitstring == "0":
return 0
# The maximum possible sum integer value
max_sum = sum(map(lambda x: (2**x) - 1, regs_widths)) + int(default_bitstring, 2)
# The bitstring length of the maximum possible sum
width = len(bin(max_sum)[2:])
# Trying to reduce width if modular addition can't cause collisions w.r.t to `compared_value`
if compared_value is not None:
if max_sum - compared_value < compared_value and width > len(bin(compared_value)[2:]):
width -= 1
return width
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.opflow import I, X, Y, Z
print(I, X, Y, Z)
print(1.5 * I)
print(2.5 * X)
print(X + 2.0 * Y)
print(X^Y^Z)
print(X @ Y @ Z)
print((X + Y) @ (Y + Z))
print((X + Y) ^ (Y + Z))
(I, X)
2.0 * X^Y^Z
print(1.1 * ((1.2 * X)^(Y + (1.3 * Z))))
from qiskit.opflow import (StateFn, Zero, One, Plus, Minus, H,
DictStateFn, VectorStateFn, CircuitStateFn, OperatorStateFn)
print(Zero, One)
print(Plus, Minus)
print(Zero.eval('0'))
print(Zero.eval('1'))
print(One.eval('1'))
print(Plus.eval('0'))
print(Minus.eval('1'))
One.adjoint()
~One
(2.0 + 3.0j) * Zero
print(Zero + One)
import math
v_zero_one = (Zero + One) / math.sqrt(2)
print(v_zero_one)
print(Plus + Minus)
print(~One @ One)
(~One @ One).eval()
(~v_zero_one @ v_zero_one).eval()
(~Minus @ One).eval()
print((~One).compose(One))
(~One).eval(One)
print(Zero^Plus)
print((Zero^Plus).to_circuit_op())
print(600 * ((One^5) + (Zero^5)))
print((One^Zero)^3)
print(((Plus^Minus)^2).to_matrix_op())
print(((Plus^One)^2).to_circuit_op())
print(((Plus^One)^2).to_matrix_op().sample())
print(StateFn({'0':1}))
print(StateFn({'0':1}) == Zero)
print(StateFn([0,1,1,0]))
from qiskit.circuit.library import RealAmplitudes
print(StateFn(RealAmplitudes(2)))
from qiskit.opflow import X, Y, Z, I, CX, T, H, S, PrimitiveOp
X
print(X.eval('0'))
X.eval('0').eval('1')
print(CX)
print(CX.to_matrix().real) # The imaginary part vanishes.
CX.eval('01') # 01 is the one in decimal. We get the first column.
CX.eval('01').eval('11') # This returns element with (zero-based) index (1, 3)
print(X @ One)
(X @ One).eval()
X.eval(One)
print(((~One^2) @ (CX.eval('01'))).eval())
print(((H^5) @ ((CX^2)^I) @ (I^(CX^2)))**2)
print((((H^5) @ ((CX^2)^I) @ (I^(CX^2)))**2) @ (Minus^5))
print(((H^I^I)@(X^I^I)@Zero))
print(~One @ Minus)
from qiskit.opflow import ListOp
print((~ListOp([One, Zero]) @ ListOp([One, Zero])))
print((~ListOp([One, Zero]) @ ListOp([One, Zero])).reduce())
print(StateFn(Z).adjoint())
StateFn(Z).adjoint()
print(StateFn(Z).adjoint().eval(Zero))
print(StateFn(Z).adjoint().eval(One))
print(StateFn(Z).adjoint().eval(Plus))
import numpy as np
from qiskit.opflow import I, X, Y, Z, H, CX, Zero, ListOp, PauliExpectation, PauliTrotterEvolution, CircuitSampler, MatrixEvolution, Suzuki
from qiskit.circuit import Parameter
from qiskit import Aer
two_qubit_H2 = (-1.0523732 * I^I) + \
(0.39793742 * I^Z) + \
(-0.3979374 * Z^I) + \
(-0.0112801 * Z^Z) + \
(0.18093119 * X^X)
print(two_qubit_H2)
evo_time = Parameter('θ')
evolution_op = (evo_time*two_qubit_H2).exp_i()
print(evolution_op) # Note, EvolvedOps print as exponentiations
print(repr(evolution_op))
h2_measurement = StateFn(two_qubit_H2).adjoint()
print(h2_measurement)
bell = CX @ (I ^ H) @ Zero
print(bell)
evo_and_meas = h2_measurement @ evolution_op @ bell
print(evo_and_meas)
trotterized_op = PauliTrotterEvolution(trotter_mode=Suzuki(order=2, reps=1)).convert(evo_and_meas)
# We can also set trotter_mode='suzuki' or leave it empty to default to first order Trotterization.
print(trotterized_op)
bound = trotterized_op.bind_parameters({evo_time: .5})
bound[1].to_circuit().draw()
# Note that XX was the only non-diagonal measurement in our H2 Observable
print(PauliExpectation(group_paulis=False).convert(h2_measurement))
print(PauliExpectation().convert(h2_measurement))
diagonalized_meas_op = PauliExpectation().convert(trotterized_op)
print(diagonalized_meas_op)
evo_time_points = list(range(8))
h2_trotter_expectations = diagonalized_meas_op.bind_parameters({evo_time: evo_time_points})
h2_trotter_expectations.eval()
sampler = CircuitSampler(backend=Aer.get_backend('aer_simulator'))
# sampler.quantum_instance.run_config.shots = 1000
sampled_trotter_exp_op = sampler.convert(h2_trotter_expectations)
sampled_trotter_energies = sampled_trotter_exp_op.eval()
print('Sampled Trotterized energies:\n {}'.format(np.real(sampled_trotter_energies)))
print('Before:\n')
print(h2_trotter_expectations.reduce()[0][0])
print('\nAfter:\n')
print(sampled_trotter_exp_op[0][0])
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/usamisaori/Grover
|
usamisaori
|
import qiskit
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
import numpy as np
from qiskit import execute, Aer
simulator = Aer.get_backend('qasm_simulator')
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')
from qiskit.quantum_info import DensityMatrix, Statevector, Operator
def getDensityMatrix(circuit):
return DensityMatrix(circuit).data
state_0 = np.array([1, 0])
state_1 = np.array([0, 1])
from functools import reduce
Dag = lambda matrix: matrix.conj().T
Kron = lambda *matrices: reduce(np.kron, matrices)
def pm(matrix):
for row in range(len(matrix)):
for col in range (len(matrix[row])):
print("{:.3f}".format(matrix[row][col]), end = " ")
print()
def getMeasurements(n):
psi_0 = np.array([1.0, 0.0])
psi_1 = np.array([0.0, 1.0])
I = np.eye(2)
M_0 = psi_0.reshape([2, 1]) @ psi_0.reshape([1, 2]).conj()
M_1 = psi_1.reshape([2, 1]) @ psi_1.reshape([1, 2]).conj()
M = [M_0, M_1]
measurements = []
for i in range(2 ** n):
binnum = bin(i)[2:].rjust(n, '0')
temp = []
indices = map(lambda x: int(x), list(binnum))
for index in indices:
temp.append(M[index])
measurements.append( Kron(*temp) )
return measurements
def measure(M, state):
return Dag(state) @ Dag(M) @ M @ state
# https://qiskit.org/textbook/ch-algorithms/grover.html
def initCircuit(n):
circuit = QuantumCircuit(n, n)
for i in range(n):
circuit.h(i)
circuit.barrier()
return circuit
inputCircuit_2q = initCircuit(2)
inputCircuit_2q.draw(output='mpl')
def createOracle_3():
circuit = QuantumCircuit(2, 2)
# Oracle for find 3
# U_f
circuit.cz(0, 1)
circuit.barrier()
return circuit
oracleCircuit_3 = createOracle_3()
oracleCircuit_3.draw(output='mpl')
O_3 = Operator(oracleCircuit_3).data
pm(O_3)
# all possible states
state_00 = Kron(state_0, state_0)
state_01 = Kron(state_0, state_1)
state_10 = Kron(state_1, state_0)
state_11 = Kron(state_1, state_1)
print("O|00>", O_3 @ state_00)
print("O|01>", O_3 @ state_01)
print("O|10>", O_3 @ state_10)
print("O|11>", O_3 @ state_11) # flip phase
# H R H, where R = 2|0><0| - I
def createR_2q():
circuit = QuantumCircuit(2, 2)
circuit.z(0)
circuit.z(1)
circuit.cz(0, 1)
return circuit
R_2q = createR_2q()
R_2q.draw(output='mpl')
R_2q = Operator(R_2q).data
pm(R_2q)
# flip phase(no work on zero states) => Conditional Phase Shift gate
print("RO|00>", R_2q @ O_3 @ state_00) # zero state => would not flip
print("RO|01>", R_2q @ O_3 @ state_01)
print("RO|10>", R_2q @ O_3 @ state_10)
print("RO|11>", R_2q @ O_3 @ state_11)
def createDiffuser_2q():
circuit = QuantumCircuit(2, 2)
circuit.h(0)
circuit.h(1)
circuit = circuit.compose(createR_2q())
circuit.h(0)
circuit.h(1)
circuit.barrier()
return circuit
diffuserCircuit_2q = createDiffuser_2q()
diffuserCircuit_2q.draw(output='mpl')
diff_2q = Operator(diffuserCircuit_2q).data
pm(diff_2q)
DB = 0.5 * state_00 + 0.5 * state_01 + 0.5 * state_10 + 0.5 * state_11
print("DO|DB>", diff_2q @ O_3 @ DB)
def createGroverIteration(oracle, diffuser):
return oracle.compose(diffuser)
groverIteration_2q = createGroverIteration(createOracle_3(), createDiffuser_2q())
groverIteration_2q.draw(output='mpl')
groverIteration_2q = createGroverIteration(createOracle_3(), createDiffuser_2q())
grover_2q_1 = initCircuit(2).compose(groverIteration_2q.copy())
grover_2q_1.draw(output='mpl')
grover_2q_1.measure([0, 1], [0, 1])
job = execute(grover_2q_1, simulator, shots = 10000)
results = job.result()
counts = results.get_counts(grover_2q_1)
print(counts)
plot_histogram(counts, figsize=(1, 5), color="#CC3333", title="one iteration - find 3")
grover_2q_2 = initCircuit(2).compose(groverIteration_2q.copy()).compose(groverIteration_2q.copy())
grover_2q_2.draw(output='mpl')
grover_2q_2.measure([0, 1], [0, 1])
job = execute(grover_2q_2, simulator, shots = 10000)
results = job.result()
counts = results.get_counts(grover_2q_2)
print(counts)
plot_histogram(counts, figsize=(7, 5), color="#FF9999", title="two iteration - find 3")
# https://www.quantum-inspire.com/kbase/grover-algorithm/
inputCircuit_3q = initCircuit(3)
inputCircuit_3q.draw(output='mpl')
def createOracle_6():
circuit = QuantumCircuit(3, 3)
# Oracle for find 6
# U_f
circuit.x(0)
circuit.h(2)
circuit.ccx(0, 1, 2)
circuit.h(2)
circuit.x(0)
circuit.barrier()
return circuit
oracleCircuit_6 = createOracle_6()
oracleCircuit_6.draw(output='mpl')
# where the entry that correspond to the marked item will have a negative phase
pm(Operator(oracleCircuit_6).data)
Operator(oracleCircuit_6).data
# H R H, where R = 2|0><0| - I
def createR_3q():
circuit = QuantumCircuit(3, 3)
circuit.x(2)
circuit.x(0)
circuit.x(1)
circuit.h(2)
circuit.ccx(0, 1, 2)
circuit.barrier(0)
circuit.barrier(1)
circuit.h(2)
circuit.x(2)
circuit.x(0)
circuit.x(1)
return circuit
R_3q = createR_3q()
R_3q.draw(output='mpl')
pm(Operator(R_3q).data)
print('|000>', Kron(state_0, state_0, state_0))
print('R|000>',Operator(R_3q).data @ Kron(state_0, state_0, state_0) )
print('|010>', Kron(state_0, state_1, state_0))
print('R|010>',Operator(R_3q).data @ Kron(state_0, state_1, state_0) )
print('|110>', Kron(state_1, state_1, state_0))
print('R|110>',Operator(R_3q).data @ Kron(state_1, state_1, state_0) )
def createDiffuser_3q():
circuit = QuantumCircuit(3, 3)
circuit.h(0)
circuit.h(1)
circuit.h(2)
circuit = circuit.compose(createR_3q())
circuit.h(0)
circuit.h(1)
circuit.h(2)
circuit.barrier()
return circuit
diffuserCircuit_3q = createDiffuser_3q()
diffuserCircuit_3q.draw(output='mpl')
pm(Operator(diffuserCircuit_3q).data)
groverIteration_3q = createGroverIteration(createOracle_6(), createDiffuser_3q())
groverIteration_3q.draw(output='mpl')
inputCircuit_3q = initCircuit(3)
inputCircuit_3q.draw(output='mpl')
inputCircuit_3q.measure([0, 1, 2], [0, 1, 2])
job = execute(inputCircuit_3q, simulator, shots = 10000)
results = job.result()
counts = results.get_counts(inputCircuit_3q)
print(counts)
plot_histogram(counts, figsize=(10, 5), color="#FFFFCC", title="superposition state - 3 qubits")
grover_3q_1 = initCircuit(3).compose(groverIteration_3q.copy())
grover_3q_1.draw(output='mpl')
grover_3q_1.measure([0, 1, 2], [0, 1, 2])
job = execute(grover_3q_1, simulator, shots = 10000)
results = job.result()
counts = results.get_counts(grover_3q_1)
print(counts)
plot_histogram(counts, figsize=(10, 5), color="#FFBB00", title="one iteration - find 6")
grover_3q_2 = initCircuit(3).compose(groverIteration_3q.copy()).compose(groverIteration_3q.copy())
# grover_3q_2.draw(output='mpl')
grover_3q_2.measure([0, 1, 2], [0, 1, 2])
job = execute(grover_3q_2, simulator, shots = 10000)
results = job.result()
counts = results.get_counts(grover_3q_2)
print(counts)
plot_histogram(counts, figsize=(10, 5), color="#FF8822", title="two iteration - find 6")
grover_3q_3 = initCircuit(3).compose(groverIteration_3q.copy()).compose(groverIteration_3q.copy()).compose(groverIteration_3q.copy())
# grover_3q_3.draw(output='mpl')
grover_3q_3.measure([0, 1, 2], [0, 1, 2])
job = execute(grover_3q_3, simulator, shots = 10000)
results = job.result()
counts = results.get_counts(grover_3q_3)
print(counts)
plot_histogram(counts, figsize=(10, 5), color="#FFFF3F", title="three iteration - find 6")
import math
theta = math.degrees( math.asin(1 / math.sqrt(8)) )
theta
k_tilde = 180 / (4 * theta) - 0.5
k_tilde
for k in range(1, 4):
print(f'k = {k}: { math.sin(math.radians( (2 * k+1) * theta) ) ** 2 }')
# H R H, where R = 2|0><0| - I
# A R A^(-1)
def initAACircuit(n):
circuit = QuantumCircuit(n, n)
circuit.x(0)
circuit.h(1)
circuit.z(1)
circuit.h(0)
circuit.barrier()
return circuit
inputAACircuit = initAACircuit(2)
inputAACircuit.draw(output='mpl')
A = Operator(initAACircuit(2))
np.allclose(A.data @ Dag(A.data), np.eye(4))
inputAACircuit.measure([0, 1], [0, 1])
job = execute(inputAACircuit, simulator, shots = 10000)
results = job.result()
counts = results.get_counts(inputAACircuit)
print(counts)
plot_histogram(counts, figsize=(7, 5), color="#CCCC66", title="measurements result of A")
oracleCircuit_3 = createOracle_3()
oracleCircuit_3.draw(output='mpl')
def createAADiffuser():
circuit = QuantumCircuit(2, 2)
circuit.append(A, [0, 1])
circuit = circuit.compose(createR_2q())
circuit.append(A.conjugate(), [0, 1])
circuit.barrier()
return circuit
diffuserAACircuit = createAADiffuser()
diffuserAACircuit.draw(output='mpl')
aaGroverIteration = createGroverIteration(createOracle_3(), createAADiffuser())
aaGroverIteration.draw(output='mpl')
incorrectGroverIteration = createGroverIteration(createOracle_3(), createDiffuser_2q())
grover_incorrect_diffuser = initAACircuit(2).compose(incorrectGroverIteration)
grover_incorrect_diffuser.draw(output='mpl')
grover_incorrect_diffuser.measure([0, 1], [0, 1])
job = execute(grover_incorrect_diffuser, simulator, shots = 10000)
results = job.result()
counts = results.get_counts(grover_incorrect_diffuser)
print(counts)
plot_histogram(counts, figsize=(1, 5), color="#99CC33", title="using incorrect diffuser - find 3")
grover_correct_diffuser = initAACircuit(2).compose(aaGroverIteration)
grover_correct_diffuser.draw(output='mpl')
grover_correct_diffuser.measure([0, 1], [0, 1])
job = execute(grover_correct_diffuser, simulator, shots = 10000)
results = job.result()
counts = results.get_counts(grover_correct_diffuser)
print(counts)
plot_histogram(counts, figsize=(1, 5), color="#339933", title="using correct diffuser - find 3")
inputCircuit_2q = initCircuit(2)
inputCircuit_2q.draw(output='mpl')
def createEvenOracle():
circuit = QuantumCircuit(2, 2)
circuit.x(0)
circuit.x(1)
circuit.cz(0, 1)
circuit.x(1)
circuit.cz(0, 1)
circuit.x(0)
circuit.barrier()
return circuit
evenOracle = createEvenOracle()
evenOracle.draw(output='mpl')
Operator(evenOracle).data # find 0 and 2
diffuserCircuit_2q = createDiffuser_2q()
diffuserCircuit_2q.draw(output='mpl')
grover_even = initCircuit(2).compose(createEvenOracle()).compose(createDiffuser_2q())
grover_even.draw(output='mpl')
grover_even.measure([0, 1], [0, 1])
job = execute(grover_even, simulator, shots = 10000)
results = job.result()
counts = results.get_counts(grover_even)
print(counts)
plot_histogram(counts, figsize=(5, 5), color="#66CCCC", title="origin grover - find evens")
initState = Kron(
state_0, state_0, state_0, state_0, state_0,
state_0, state_0, state_0, state_0, state_0
)
H = np.array([[1,1], [1,-1]]) / (np.sqrt(2))
H_9 = Kron(H, H, H, H, H, H, H, H, H)
H_10 = Kron(H, H, H, H, H, H, H, H, H, H)
def createTargetState(n):
states = []
s = bin(n)[2:].rjust(10, "0")
for i in list(s):
if i == '0':
states.append(state_0)
else:
states.append(state_1)
return Kron(*states)
def createTargetStates(p):
n = math.floor(p * 1024)
state = createTargetState(0)
for i in range(1, n):
state = state + createTargetState(i)
return state / (np.sqrt(n))
target_states = [
[createTargetStates(0.05), 0.05], # 0.05
[createTargetStates(0.1), 0.1], # 0.1
[createTargetStates(0.15), 0.15], # 0.15
[createTargetStates(0.2), 0.2], # 0.2
[createTargetStates(0.25), 0.25], # 0.25
[createTargetStates(0.3), 0.3], # 0.3
[createTargetStates(0.35), 0.35], # 0.35
[createTargetStates(0.4), 0.4], # 0.4
[createTargetStates(0.45), 0.45], # 0.45
[createTargetStates(0.5), 0.5], # 0.5
[createTargetStates(0.55), 0.55], # 0.55
[createTargetStates(0.6), 0.6], # 0.6
[createTargetStates(0.65), 0.65], # 0.65
[createTargetStates(0.7), 0.7], # 0.7
[createTargetStates(0.75), 0.75], # 0.75
[createTargetStates(0.8), 0.8], # 0.8
[createTargetStates(0.85), 0.85], # 0.85
[createTargetStates(0.9), 0.9], # 0.9
[createTargetStates(0.95), 0.95], # 0.95
[createTargetStates(1), 1] # 1
]
def createOriginalOracle(target_state):
N = 1024
O = np.eye(N) - 2 * ( Dag(target_state).reshape(N, 1) @ target_state.reshape(1, N) )
return O
def createOriginalDiffuser():
N = 1024
R = 2 * (
Dag(initState).reshape(N, 1) @
initState.reshape(1, N)
) - np.eye(N)
return H_10 @ R @ Dag(H_10)
def createHalfPIOracle(target_state):
N = 1024
alpha = np.pi / 2
alpha_phase = np.exp(alpha * 1j)
# Oracle = I - (1 - e^(αi))|target><target|
O = np.eye(N) - (1 - alpha_phase) * \
( Dag(target_state).reshape(N, 1) @ target_state.reshape(1, N) )
return O
def createHalfPIDiffuser():
N = 1024
beta = -np.pi / 2
beta_phase = np.exp(beta * 1j)
# R = (1 - e^(βi))|0><0| + e^(βi)I
R = (1 - beta_phase) * (
Dag(initState).reshape(N, 1) @
initState.reshape(1, N)
) + beta_phase * np.eye(N)
return H_10 @ R @ Dag(H_10)
def createOneTenthPIOracle(target_state):
N = 1024
alpha = np.pi / 10
alpha_phase = np.exp(alpha * 1j)
# Oracle = I - (1 - e^(αi))|target><target|
O = np.eye(N) - (1 - alpha_phase) * \
( Dag(target_state).reshape(N, 1) @ target_state.reshape(1, N) )
return O
def createOneTenthPIDiffuser():
N = 1024
beta = -np.pi / 10
beta_phase = np.exp(beta * 1j)
# R = (1 - e^(βi))|0><0| + e^(βi)I
R = (1 - beta_phase) * (
Dag(initState).reshape(N, 1) @
initState.reshape(1, N)
) + beta_phase * np.eye(N)
return H_10 @ R @ Dag(H_10)
def createYouneOracle(n):
O = np.eye(1024)
for i in range(n):
O[i][i] = 0
O[i][i + 512] = 1
O[i + 512][i + 512] = 0
O[i + 512][i] = 1
return O
def createYouneDiffuser():
N = 512
R = (2 * Dag(initState).reshape(N * 2, 1) @
initState.reshape(1, N * 2) - np.eye(N * 2))
return Kron(np.eye(2), H_9) @ R @ Dag(Kron(np.eye(2), H_9))
measurements = getMeasurements(10)
# test: one grover iteration
x_o = []
y_o = []
for target_state, p in target_states:
n = math.floor(p * 1024)
O = createOriginalOracle(target_state)
diff = createOriginalDiffuser()
final_state = diff @ O @ H_10 @ initState
probability = 0.0
for i in range(1024):
if i < n:
probability = probability + measure(measurements[i], final_state)
# print(f'p={p}, probability={probability}')
x_o.append(p)
y_o.append(probability)
plt.title("Original Grover - apply one iterator")
plt.scatter(x_o, y_o, color="#66CCCC")
# test: best probability
x_o_best = []
y_o_best = []
for target_state, p in target_states:
n = math.floor(p * 1024)
O = createOriginalOracle(target_state)
diff = createOriginalDiffuser()
final_state = H_10 @ initState
theta = math.degrees( math.asin(math.sqrt(p)) )
k_tilde = math.floor( 180 / (4 * theta) - 0.5 )
for i in range(k_tilde):
final_state = diff @ O @ final_state
probability = 0.0
for i in range(1024):
if i < n:
probability = probability + measure(measurements[i], final_state)
final_state = diff @ O @ final_state
probability2 = 0.0
for i in range(1024):
if i < n:
probability2 = probability2 + measure(measurements[i], final_state)
# print(f'p={p}, probability={probability}')
x_o_best.append(p)
y_o_best.append(max(probability, probability2))
plt.title("Original Grover - best Probability")
x = np.arange(-0,1,0.01)
y = 1 - x
plt.plot(x, y, ls='--', color="#FFCC00")
plt.ylim(0, 1.05)
plt.scatter(x_o_best, y_o_best, color="#66CCCC")
# test: one grover iteration
x_half_pi = []
y_half_pi= []
for target_state, p in target_states:
n = math.floor(p * 1024)
O = createHalfPIOracle(target_state)
diff = createHalfPIDiffuser()
final_state = diff @ O @ H_10 @ initState
probability = 0.0
for i in range(1024):
if i < n:
probability = probability + measure(measurements[i], final_state)
# print(f'p={p}, probability={probability}')
x_half_pi.append(p)
y_half_pi.append(probability)
plt.title("pi/2 Grover - apply one iterator")
plt.scatter(x_half_pi, y_half_pi, color="#66CCCC")
# one grover iteration - pi/2 vs origin
fig, ax = plt.subplots()
plt.title("Apply one iteration")
plt.axvline(1/3, linestyle='--', color="#FFCCCC", label="t/N = 1/3")
plt.axhline(0.925, linestyle='--', color="#FFCC00", label="P=0.925")
plt.scatter(x_o, y_o, color="#66CCCC", label="Original Grover")
plt.scatter(x_half_pi, y_half_pi, color="#FF6666", label="pi/2 phase based Grover")
ax.legend()
# test: one grover iteration
x_ot_pi = []
y_ot_pi= []
for target_state, p in target_states:
n = math.floor(p * 1024)
O = createOneTenthPIOracle(target_state)
diff = createOneTenthPIDiffuser()
final_state = diff @ O @ H_10 @ initState
probability = 0.0
for i in range(1024):
if i < n:
probability = probability + measure(measurements[i], final_state)
# print(f'p={p}, probability={probability}')
x_ot_pi.append(p)
y_ot_pi.append(probability)
plt.title("0.1pi Grover - apply one iteration")
plt.scatter(x_ot_pi, y_ot_pi, color="#66CCCC")
# test: best probability
x_ot_best = []
y_ot_best = []
for target_state, p in target_states:
n = math.floor(p * 1024)
O = createOneTenthPIOracle(target_state)
diff = createOneTenthPIDiffuser()
final_state = H_10 @ initState
p_best = 0.0
k_tilde = math.floor( 5 * np.sqrt(1024) )
for i in range(k_tilde):
final_state = diff @ O @ final_state
probability = 0.0
for i in range(1024):
if i < n:
probability = probability + measure(measurements[i], final_state)
p_best = max(p_best, probability)
# print(f'p={p}, probability={probability}')
x_ot_best.append(p)
y_ot_best.append(p_best)
plt.title("0.1pi Grover - best Probability")
plt.ylim(0, 1)
plt.scatter(x_ot_best, y_ot_best, color="#66CCCC")
# best probability - 0.1pi vs origin
fig, ax = plt.subplots()
plt.title("Best Probability")
x = np.arange(-0,1,0.01)
y = 1 - x
plt.plot(x, y, ls='--', color="#FFCC00")
plt.ylim(0, 1.05)
plt.scatter(x_o_best, y_o_best, color="#66CCCC", label="Original Grover")
plt.scatter(x_ot_best, y_ot_best, color="#FF6666", label="0.1pi phase based Grover")
ax.legend()
# test: best probability
x_y_best = []
y_y_best = []
for _, p in target_states:
n = math.floor(p * 512)
O = createYouneOracle(n)
diff = createYouneDiffuser()
final_state = Kron( np.eye(2), H_9) @ initState
p_best = 0.0
k_tilde = math.floor(np.pi / (2 * np.sqrt(2)) * np.sqrt(512 / n))
for i in range(k_tilde):
final_state = diff @ O @ final_state
probability = 0.0
for i in range(512):
if i < n:
probability = probability + measure(measurements[i], final_state) + measure(measurements[i + 512], final_state)
# print(f'p={p}, probability={probability}')
x_y_best.append(p)
y_y_best.append(probability)
fig, ax = plt.subplots()
plt.title("Best Probability")
x = np.arange(-0, 1, 0.01)
y = 1 - x
plt.plot(x, y, ls='--', color="#FFCC00")
plt.axhline(0.8472, linestyle='--', color="#99CCFF", label="P=0.8472")
plt.axvline(0.308, linestyle='--', color="#FFCCCC", label="P=0.308")
plt.ylim(0, 1.05)
plt.scatter(x_y_best, y_y_best, color="#FF6666", label="Youne")
plt.scatter(x_o_best, y_o_best, color="#66CCCC", label="Original Grover")
ax.legend()
def createYouneInitCircuit():
circuit = QuantumCircuit(3, 2)
circuit.h(0)
circuit.h(1)
circuit.barrier()
return circuit
youneInitCircuit = createYouneInitCircuit()
youneInitCircuit.draw(output='mpl')
def createYouneOracle():
circuit = QuantumCircuit(3, 2)
circuit.x(0)
circuit.x(1)
circuit.ccx(0, 1, 2)
circuit.x(0)
circuit.x(1)
circuit.barrier()
circuit.x(0)
circuit.ccx(0, 1, 2)
circuit.x(0)
circuit.barrier()
return circuit
youneOracle = createYouneOracle()
youneOracle.draw(output='mpl')
def createYouneDiffuser():
circuit = QuantumCircuit(3, 2)
circuit.h(0)
circuit.h(1)
circuit.barrier(2)
circuit.x(2)
circuit.x(0)
circuit.x(1)
circuit.h(2)
circuit.ccx(0, 1, 2)
circuit.barrier(0)
circuit.barrier(1)
circuit.h(2)
circuit.x(2)
circuit.x(0)
circuit.x(1)
circuit.h(0)
circuit.h(1)
# circuit.h(2)
circuit.barrier()
return circuit
youneDiffuser = createYouneDiffuser()
youneDiffuser.draw(output='mpl')
youneGroverIteration = createYouneOracle().compose(createYouneDiffuser())
grover_youne = createYouneInitCircuit().compose(youneGroverIteration.copy())
grover_youne.draw(output='mpl')
grover_youne.measure([0, 1], [0, 1])
job = execute(grover_youne, simulator, shots = 10000)
results = job.result()
counts = results.get_counts(grover_youne)
print(counts)
plot_histogram(counts, figsize=(4, 5), color="#0099CC", title="youne grover - find evens")
def createYouneOracle2():
circuit = QuantumCircuit(3, 2)
circuit.x(0)
circuit.cx(0, 2)
circuit.x(0)
circuit.barrier()
return circuit
youneOracle2 = createYouneOracle2()
youneOracle2.draw(output='mpl')
# 0 => 4 2 => 6
Operator(youneOracle2).data
youneGroverIteration2 = createYouneOracle2().compose(createYouneDiffuser())
grover_youne2 = createYouneInitCircuit().compose(youneGroverIteration2.copy())
grover_youne2.draw(output='mpl')
grover_youne2.measure([0, 1], [0, 1])
job = execute(grover_youne2, simulator, shots = 10000)
results = job.result()
counts = results.get_counts(grover_youne2)
print(counts)
plot_histogram(counts, figsize=(4, 5), color="#66CCFF", title="youne grover(using another Oracle) - find evens")
# https://towardsdatascience.com/behind-oracles-grovers-algorithm-amplitude-amplification-46b928b46f1e
def createSATInitCircuit(var, clause):
# input + workspace(clause) + checker(1)
circuit = QuantumCircuit(var + clause + 1, var)
for i in range(var):
circuit.h(i)
circuit.barrier()
return circuit
SATInitCircuit = createSATInitCircuit(4, 3)
SATInitCircuit.draw(output='mpl')
def createSATOracle(var, clause):
circuit = QuantumCircuit(var + clause + 1, var)
# (a ∧ b ∧ ¬c)
circuit.x(2)
circuit.mcx([0, 1, 2], 4)
circuit.x(2)
circuit.barrier()
# (¬b ∧d )
circuit.x(1)
circuit.mcx([1, 3], 5)
circuit.x(1)
circuit.barrier()
# ¬d
circuit.x(3)
circuit.cx(3, 6)
circuit.x(3)
circuit.barrier()
# (a ∧ b ∧ ¬c) ∧ ¬(¬b ∧d ) ∧ ¬d
circuit.x(5)
circuit.mcx([4, 5, 6], 7)
circuit.x(5)
circuit.barrier()
# uncomputation
# ¬d
circuit.x(3)
circuit.cx(3, 6)
circuit.x(3)
circuit.barrier()
# (¬b ∧d )
circuit.x(1)
circuit.mcx([1, 3], 5)
circuit.x(1)
circuit.barrier()
# (a ∧ b ∧ ¬c)
circuit.x(2)
circuit.mcx([0, 1, 2], 4)
circuit.x(2)
circuit.barrier()
return circuit
SATOracleCircuit = createSATOracle(4, 3)
SATOracleCircuit.draw(output='mpl')
def createSATDiffuser(var, clause):
circuit = QuantumCircuit(var + clause + 1, var)
circuit.h(0)
circuit.h(1)
circuit.h(2)
circuit.h(3)
circuit.x(0)
circuit.x(1)
circuit.x(2)
circuit.x(3)
circuit.mcx([0, 1, 2, 3], var + clause)
circuit.x(0)
circuit.x(1)
circuit.x(2)
circuit.x(3)
circuit.h(0)
circuit.h(1)
circuit.h(2)
circuit.h(3)
return circuit
SATDiffuserCircuit = createSATDiffuser(4, 3)
SATDiffuserCircuit.draw(output='mpl')
SATCircuit = createSATInitCircuit(4, 3).compose(createSATOracle(4, 3)).compose(createSATDiffuser(4, 3))
SATCircuit.draw(output='mpl')
SATCircuit.measure([0, 1, 2, 3], [0, 1, 2, 3])
job = execute(SATCircuit, simulator, shots = 10000)
results = job.result()
counts = results.get_counts(SATCircuit)
print(counts)
plot_histogram(counts, figsize=(12, 5), color="#CCCCFF", title="SAT - solving (a ∧ b ∧ ¬c) ∧ ¬(¬b ∧d ) ∧ ¬d, k = 1")
SATIteration = Operator(createSATOracle(4, 3).compose(createSATDiffuser(4, 3)))
SATCircuit2 = createSATInitCircuit(4, 3)
SATCircuit2.append(SATIteration, list(range(8)))
SATCircuit2.append(SATIteration, list(range(8)))
SATCircuit2.append(SATIteration, list(range(8)))
SATCircuit2.draw(output='mpl')
SATCircuit2.measure([0, 1, 2, 3], [0, 1, 2, 3])
job = execute(SATCircuit2, simulator, shots = 10000)
results = job.result()
counts = results.get_counts(SATCircuit2)
print(counts)
plot_histogram(counts, figsize=(12, 5), color="#6666FF", title="SAT - solving (a ∧ b ∧ ¬c) ∧ ¬(¬b ∧d ) ∧ ¬d, k = 3")
import math
math.degrees( math.asin(1 / 4))
for k in range(1, 5):
print(f'k = {k}: { math.sin(math.radians( (2 * k+1) * 14.47) ) ** 2 }')
# https://arxiv.org/pdf/quant-ph/9605034.pdf
inputCircuit_8q = initCircuit(8)
inputCircuit_8q.draw(output='mpl')
def createOracle_255():
circuit = QuantumCircuit(8, 8)
circuit.h(7)
circuit.mcx(list(range(7)), 7)
circuit.h(7)
circuit.barrier()
return circuit
oracleCircuit_255 = createOracle_255()
oracleCircuit_255.draw(output='mpl')
Operator(oracleCircuit_255).data
for index, row in enumerate(Operator(oracleCircuit_255).data):
if abs(row[index] - -1) < 1e-6:
print(index)
def createR_8q():
circuit = QuantumCircuit(8, 8)
circuit.x(7)
circuit.x(6)
circuit.x(5)
circuit.x(4)
circuit.x(3)
circuit.x(2)
circuit.x(0)
circuit.x(1)
circuit.h(7)
circuit.mcx(list(range(7)), 7)
circuit.barrier(0)
circuit.barrier(1)
circuit.barrier(2)
circuit.barrier(3)
circuit.barrier(4)
circuit.barrier(5)
circuit.barrier(6)
circuit.h(7)
circuit.x(2)
circuit.x(0)
circuit.x(1)
circuit.x(5)
circuit.x(4)
circuit.x(3)
circuit.x(7)
circuit.x(6)
return circuit
R_8q = createR_8q()
R_8q.draw(output='mpl')
def createDiffuser_8q():
circuit = QuantumCircuit(8, 8)
circuit.h(0)
circuit.h(1)
circuit.h(2)
circuit.h(3)
circuit.h(4)
circuit.h(5)
circuit.h(6)
circuit.h(7)
circuit = circuit.compose(createR_8q())
circuit.h(0)
circuit.h(1)
circuit.h(2)
circuit.h(3)
circuit.h(4)
circuit.h(5)
circuit.h(6)
circuit.h(7)
circuit.barrier()
return circuit
diffuserCircuit_8q = createDiffuser_8q()
diffuserCircuit_8q.draw(output='mpl')
groverIteration_8q = createGroverIteration(createOracle_255(), createDiffuser_8q())
groverIteration_8q.draw(output='mpl')
fullCircuit_8q = initCircuit(8).compose(groverIteration_8q)
fullCircuit_8q.draw(output='mpl')
degree = math.degrees( math.asin(1 / np.sqrt(256)) )
degree
for k in range(1, 15):
print(f'k = {k}: { math.sin(math.radians( (2 * k+1) * degree) ) ** 2 }')
def groverMeasurements(k):
circuit = initCircuit(8)
for i in range(k):
circuit = circuit.compose(groverIteration_8q.copy())
circuit.measure(list(range(8)), list(range(8)))
job = execute(circuit, simulator, shots = 1)
results = job.result()
counts = results.get_counts(circuit)
return list(counts)[0]
from random import randrange
def solutionFinding(limit):
m = 1
lam = 6 / 5
count = 0 # iteration times
while count <= limit * (9/4):
if m > 1:
j = randrange(0, math.floor(m))
if j != 0:
count += j
answer = groverMeasurements(j)
if answer == '11111111':
# print(f'Find! - total times: {count}')
return count, True
m = min(lam * m, limit)
# print(f'Not find! - total times: {count}')
return count, False
times = 0
best = 1000
worst = 0
success = 0
for i in range(1000):
time, flag = solutionFinding(np.sqrt(256)) # √N
times += time
best = min(best, time)
worst = max(worst, time)
if flag:
success += 1
print(f'total test times: {1000}')
print('--------------------------')
print(f'Average run times: {times / 1000}')
print(f'best run times: {best}')
print(f'worst run times: {worst}')
print(f'Success rate: {success / 1000 * 100:.2f}%')
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.algorithms.optimizers import SLSQP
from qiskit.circuit.library import TwoLocal
num_qubits = 2
ansatz = TwoLocal(num_qubits, "ry", "cz")
optimizer = SLSQP(maxiter=1000)
ansatz.decompose().draw("mpl", style="iqx")
from qiskit.primitives import Estimator
estimator = Estimator()
from qiskit.algorithms.minimum_eigensolvers import VQE
vqe = VQE(estimator, ansatz, optimizer)
from qiskit.quantum_info import SparsePauliOp
H2_op = SparsePauliOp.from_list([
("II", -1.052373245772859),
("IZ", 0.39793742484318045),
("ZI", -0.39793742484318045),
("ZZ", -0.01128010425623538),
("XX", 0.18093119978423156)
])
result = vqe.compute_minimum_eigenvalue(H2_op)
print(result)
from qiskit.algorithms.optimizers import SPSA
estimator = Estimator(options={"shots": 1000})
vqe.estimator = estimator
vqe.optimizer = SPSA(maxiter=100)
result = vqe.compute_minimum_eigenvalue(operator=H2_op)
print(result)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/zapatacomputing/qe-qiskit
|
zapatacomputing
|
################################################################################
# © Copyright 2020-2022 Zapata Computing Inc.
################################################################################
from typing import Dict, Optional, Tuple
import numpy as np
import qiskit.providers.aer.noise as AerNoise
from qiskit.providers.aer.noise import (
NoiseModel,
amplitude_damping_error,
pauli_error,
phase_amplitude_damping_error,
phase_damping_error,
)
from qiskit.quantum_info import Kraus
from qiskit.transpiler import CouplingMap
from .._get_provider import get_provider
def get_qiskit_noise_model(
device_name: str,
hub: str = "ibm-q",
group: str = "open",
project: str = "main",
api_token: Optional[str] = None,
) -> Tuple[NoiseModel, list]:
"""Get a qiskit noise model to use noisy simulations with a qiskit simulator
Args:
device_name: The name of the device trying to be emulated
hub: The ibmq hub (see qiskit documentation)
group: The ibmq group (see qiskit documentation)
project: The ibmq project (see qiskit documentation)
api_token: The ibmq api token (see qiskit documentation)
"""
# Get qiskit noise model from qiskit
provider = get_provider(api_token=api_token, hub=hub, group=group, project=project)
noisy_device = provider.get_backend(device_name)
noise_model = AerNoise.NoiseModel.from_backend(noisy_device)
return noise_model, noisy_device.configuration().coupling_map
def create_amplitude_damping_noise(T_1: float, t_step: float = 10e-9) -> NoiseModel:
"""Creates an amplitude damping noise model
Args:
T_1: Relaxation time (seconds)
t_step: Discretized time step over which the relaxation occurs over (seconds)
"""
gamma = 1 - pow(np.e, -1 / T_1 * t_step)
error = amplitude_damping_error(gamma)
gate_error = error.tensor(error)
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error, ["id", "u3"])
noise_model.add_all_qubit_quantum_error(gate_error, ["cx"])
return noise_model
def create_phase_damping_noise(T_2: float, t_step: float = 10e-9) -> NoiseModel:
"""Creates a dephasing noise model
Args:
T_2: dephasing time (seconds)
t_step: Discretized time step over which the relaxation occurs over (seconds)
"""
gamma = 1 - pow(np.e, -1 / T_2 * t_step)
error = phase_damping_error(gamma)
gate_error = error.tensor(error)
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error, ["id", "u3"])
noise_model.add_all_qubit_quantum_error(gate_error, ["cx"])
return noise_model
def create_phase_and_amplitude_damping_error(
T_1: float, T_2: float, t_step: float = 10e-9
) -> NoiseModel:
"""Creates a noise model that does both phase and amplitude damping
Args:
T_1: Relaxation time (seconds)
T_2: dephasing time (seonds)
t_step: Discretized time step over which the relaxation occurs over (seconds)
"""
param_amp = 1 - pow(np.e, -1 / T_1 * t_step)
param_phase = 1 - pow(np.e, -1 / T_2 * t_step)
error = phase_amplitude_damping_error(param_amp, param_phase)
gate_error = error.tensor(error)
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(error, ["id", "u3"])
noise_model.add_all_qubit_quantum_error(gate_error, ["cx"])
return noise_model
def create_pta_channel(T_1: float, T_2: float, t_step: float = 10e-9) -> NoiseModel:
"""Creates a noise model that does both phase and amplitude damping but in the
Pauli Twirling Approximation discussed the following reference
https://arxiv.org/pdf/1305.2021.pdf
Args:
T_1: Relaxation time (seconds)
T_2: dephasing time (seconds)
t_step: Discretized time step over which the relaxation occurs over (seconds)
"""
p_x = 0.25 * (1 - pow(np.e, -t_step / T_1))
p_y = 0.25 * (1 - pow(np.e, -t_step / T_1))
exp_1 = pow(np.e, -t_step / (2 * T_1))
exp_2 = pow(np.e, -t_step / T_2)
p_z = 0.5 - p_x - 0.5 * exp_1 * exp_2
p_i = 1 - p_x - p_y - p_z
errors = [("X", p_x), ("Y", p_y), ("Z", p_z), ("I", p_i)]
pta_error = pauli_error(errors)
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(pta_error, ["id", "u3"])
gate_error = pta_error.tensor(pta_error)
noise_model.add_all_qubit_quantum_error(gate_error, ["cx"])
return noise_model
def get_kraus_matrices_from_ibm_noise_model(noise_model: NoiseModel) -> Dict:
"""Gets the kraus operators from a pre defined noise model
Args:
noise_model: Noise model for circuit
Return
dict_of_kraus_operators: A dictionary labelled by keys which are
the basis gates and values are the list of kraus operators
"""
retrieved_quantum_error_dict = noise_model._default_quantum_errors
dict_of_kraus_operators = {
gate: Kraus(retrieved_quantum_error_dict[gate]).data
for gate in retrieved_quantum_error_dict
}
return dict_of_kraus_operators
|
https://github.com/drobiu/quantum-project
|
drobiu
|
from itertools import combinations
import numpy as np
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.circuit.library import QFT
from scipy.special import binom
from src.arithmetic.counter import count, mincount
from src.arithmetic.increment import control_increment, control_decrement
from src.logic.s_gate import s_gate
from src.util.util import run_qc
def oracle_a(circuit, q, a, s, do_inverse=False):
"""
circuit: the circuit to which to append the oracle.
q: quantum registers, color inputs.
a: quantum registers, count of correct colors at correct places.
s: array of integer. The input of s_gate, which represents the secret string.
"""
circuit = circuit.compose(s_gate(s).to_gate(label="s"), qubits=q)
if not do_inverse:
circuit = count(circuit, a, q, step=2)
if do_inverse:
circuit = mincount(circuit, a, q, step=2)
circuit = circuit.compose(s_gate(s).to_gate(label="s"), qubits=q)
return circuit
def c_gate(k, length=4):
s = np.ones(length) * k
return s_gate(s, length / 2)
def oracle_b(circuit, q, b, s, do_inverse=False):
q_l = len(q)
b_l = len(b)
n = len(s)
log_k = q_l / n
circuit = circuit.compose(QFT(num_qubits=b_l, approximation_degree=0, do_swaps=True,
inverse=True, insert_barriers=True, name='qft'), qubits=b)
# Hardcoded for now
n_colors = 4
color_count = [s.count(i) for i in range(n_colors)]
for color, c_n in enumerate(color_count):
if c_n == 0:
continue
contrib = [1] + (c_n - 1) * [0]
for i in range(c_n + 1, n_colors + 1):
curr_cont = c_n
for j in range(1, i):
curr_cont -= binom(i, j) * contrib[j - 1]
contrib.append(curr_cont)
circuit = circuit.compose(c_gate(color))
print(color, c_n, contrib)
if not do_inverse:
circuit = count(circuit, b, q, step=2, apply_QFT=False)
else:
circuit = mincount(circuit, b, q, step=2, apply_QFT=False)
for i in range(c_n, n):
comp = contrib[i]
if comp == 0:
continue
# Heavily inspired by
# https://github.com/TimVroomans/Quantum-Mastermind/blob/master/src/mastermind/game/algorithms/Mastermind_Oracle.py
for combination in list(combinations(range(n), i + 1)):
qubit_combinations = [q[int(log_k * color): int(log_k * (color + 1))] for color in combination]
temp_qubits = []
for qb in qubit_combinations:
temp_qubits += qb
print('gate')
if not do_inverse:
circuit = control_increment(circuit, b, temp_qubits, amount=comp, apply_QFT=False)
else:
circuit = control_decrement(circuit, b, temp_qubits, amount=comp, apply_QFT=False)
circuit = circuit.compose(c_gate(color))
circuit = circuit.compose(QFT(num_qubits=b_l, approximation_degree=0, do_swaps=True,
inverse=True, insert_barriers=True, name='iqft'), qubits=b)
return circuit
def test():
q = QuantumRegister(8)
b = QuantumRegister(3)
c = QuantumRegister(3)
d = QuantumRegister(1)
cr = ClassicalRegister(15)
qc = QuantumCircuit(q, b, c, d, cr)
# 01, 00, 00, 00
qc.x(q[1])
qc.barrier()
# [0, 0, 0, 1] = 11, 11, 11, 10
# qc = oracle_b(qc, q, b, [0, 0, 0, 1])
qc = build_mastermind_b_circuit_v2(qc, q, b, c, d, [0, 1, 1, 1])
# Should equal 110
qc.measure([*q, *b, *c, *d], cr[:])
run_qc(qc, with_QI=False)
qc.draw(output="text")
if __name__ == "__main__":
test()
|
https://github.com/qiskit-community/qiskit-cold-atom
|
qiskit-community
|
import qiskit_qasm3_import
project = 'Qiskit OpenQASM 3 Importer'
copyright = '2022, Jake Lishman'
author = 'Jake Lishman'
version = qiskit_qasm3_import.__version__
release = qiskit_qasm3_import.__version__
extensions = [
"sphinx.ext.autodoc",
"sphinx.ext.intersphinx",
"reno.sphinxext",
'qiskit_sphinx_theme',
]
exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
# Document the docstring for the class and the __init__ method together.
autoclass_content = "both"
html_theme = "qiskit-ecosystem"
html_title = f"{project} {release}"
intersphinx_mapping = {
"qiskit-terra": ("https://docs.quantum.ibm.com/api/qiskit/", None),
}
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import IBMQ, transpile
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit.tools.visualization import plot_histogram
from qiskit.providers.fake_provider import FakeVigo
device_backend = FakeVigo()
# Construct quantum circuit
circ = QuantumCircuit(3, 3)
circ.h(0)
circ.cx(0, 1)
circ.cx(1, 2)
circ.measure([0, 1, 2], [0, 1, 2])
sim_ideal = AerSimulator()
# Execute and get counts
result = sim_ideal.run(transpile(circ, sim_ideal)).result()
counts = result.get_counts(0)
plot_histogram(counts, title='Ideal counts for 3-qubit GHZ state')
sim_vigo = AerSimulator.from_backend(device_backend)
# Transpile the circuit for the noisy basis gates
tcirc = transpile(circ, sim_vigo)
# Execute noisy simulation and get counts
result_noise = sim_vigo.run(tcirc).result()
counts_noise = result_noise.get_counts(0)
plot_histogram(counts_noise,
title="Counts for 3-qubit GHZ state with device noise model")
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/usamisaori/Grover
|
usamisaori
|
import qiskit
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
import numpy as np
from qiskit import execute, Aer
simulator = Aer.get_backend('qasm_simulator')
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')
from qiskit.quantum_info import DensityMatrix, Statevector, Operator
def getDensityMatrix(circuit):
return DensityMatrix(circuit).data
from functools import reduce
Dag = lambda matrix: matrix.conj().T
Kron = lambda *matrices: reduce(np.kron, matrices)
def pm(matrix):
for row in range(len(matrix)):
for col in range (len(matrix[row])):
print("{:.3f}".format(matrix[row][col]), end = " ")
print()
def initCircuit(n):
circuit = QuantumCircuit(n, n)
for i in range(n):
circuit.h(i)
circuit.barrier()
return circuit
inputCircuit_2q = initCircuit(2)
inputCircuit_2q.draw(output='mpl')
def createEvenOracle():
circuit = QuantumCircuit(2, 2)
circuit.x(0)
circuit.x(1)
circuit.cz(0, 1)
circuit.x(1)
circuit.cz(0, 1)
circuit.x(0)
circuit.barrier()
return circuit
evenOracle = createEvenOracle()
evenOracle.draw(output='mpl')
Operator(evenOracle).data # find 0 and 2
def createR_2q():
circuit = QuantumCircuit(2, 2)
circuit.z(0)
circuit.z(1)
circuit.cz(0, 1)
return circuit
def createDiffuser_2q():
circuit = QuantumCircuit(2, 2)
circuit.h(0)
circuit.h(1)
circuit = circuit.compose(createR_2q())
circuit.h(0)
circuit.h(1)
circuit.barrier()
return circuit
diffuserCircuit_2q = createDiffuser_2q()
diffuserCircuit_2q.draw(output='mpl')
grover_even = initCircuit(2).compose(createEvenOracle()).compose(createDiffuser_2q())
grover_even.draw(output='mpl')
grover_even.measure([0, 1], [0, 1])
job = execute(grover_even, simulator, shots = 10000)
results = job.result()
counts = results.get_counts(grover_even)
print(counts)
plot_histogram(counts, figsize=(5, 5), color="#66CCCC", title="origin grover - find evens")
|
https://github.com/mathelatics/QGSS-2023-From-Theory-to-Implementations
|
mathelatics
|
from qiskit import QuantumCircuit
# Creating a quantum circuit with the 2 qubit and 2 bits to store
# the measurements of the qubits
3
qc = QuantumCircuit(2, 2)
# draw the quantum circuit
qc.draw()
# Measuring the qubits states and storing it into the classical bits
qc.measure([0,1], [0,1])
qc.draw()
|
https://github.com/Qiskit/feedback
|
Qiskit
|
import sys
sys.path.append('../../')
import numpy as np
from numpy import linalg as la
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit
from compilers.aqc_demo.cnot_structures import full_conn, spin
from compilers.aqc_demo.parametric_circuit import ParametricCircuit
from compilers.aqc_demo.test_sample_data import ORIGINAL_CIRCUIT, INITIAL_THETAS
from compilers.aqc_demo.aqc_optimizers import FISTAOptimizer, GDOptimizer
from compilers.aqc_demo.aqc import AQC
num_qubits = int(np.log2(ORIGINAL_CIRCUIT.shape[0]))
num_qubits
def cnots_to_qc(num_qubits: int, cnots) -> QuantumCircuit:
circuit = QuantumCircuit(num_qubits)
for ii, elements in enumerate(cnots[0]):
circuit.cx(elements - 1, cnots[1][ii] - 1)
return circuit
cnots = spin(num_qubits, full_conn(num_qubits))
cnots_qc = cnots_to_qc(num_qubits, cnots)
cnots_qc.draw(output="mpl")
cnots_qc.depth()
target_circuit = ParametricCircuit(num_qubits, cnots)
initial_thetas_qc = target_circuit.make_circuit(INITIAL_THETAS, reverse=True)
initial_thetas_qc.draw(output="mpl")
initial_thetas_qc.depth()
def approximation_error(expected, actual) -> float:
return .5 * (la.norm(expected - actual, 'fro') ** 2)
target_unitary = target_circuit.compute_unitary(INITIAL_THETAS)
error = approximation_error(ORIGINAL_CIRCUIT, target_unitary)
error
optimizer = FISTAOptimizer(method="nesterov", maxiter=5000, eta=0.1, tol=0.01, eps=0.0, reg=0.7, group=True)
thetas, objective, gradient, _ = optimizer.optimize(ORIGINAL_CIRCUIT, INITIAL_THETAS, target_circuit)
target_unitary = target_circuit.compute_unitary(thetas)
error = approximation_error(ORIGINAL_CIRCUIT, target_unitary)
error
compressed_cnots, compressed_thetas, spar = target_circuit.compress(thetas, synth=False)
compressed_target_circuit = ParametricCircuit(num_qubits, compressed_cnots)
compressed_qc_circuit = compressed_target_circuit.make_circuit(compressed_thetas, reverse=True)
compressed_qc_circuit.draw(output="mpl")
compressed_qc_circuit.depth()
optimizer = GDOptimizer(method="nesterov", maxiter=5000, eta=0.1, tol=0.01, eps=0.0)
thetas, objective, gradient, thetas_min = optimizer.optimize(ORIGINAL_CIRCUIT,
compressed_thetas,
compressed_target_circuit)
num_iterations = np.shape(objective)[0]
plt.loglog(range(num_iterations), objective)
plt.xlabel('Iteration')
plt.ylabel('Approximation error')
plt.show()
target_unitary = compressed_target_circuit.compute_unitary(thetas)
error = approximation_error(ORIGINAL_CIRCUIT, target_unitary)
error
aqc = AQC(method="nesterov", maxiter=5000, eta=0.1, tol=0.01, eps=0.0, reg=0.7, group=True)
parametric_circuit, thetas = aqc.compile_unitary(ORIGINAL_CIRCUIT, cnots, INITIAL_THETAS)
target_unitary = parametric_circuit.compute_unitary(thetas)
error = approximation_error(ORIGINAL_CIRCUIT, target_unitary)
error
|
https://github.com/SanNare/qiskit-notebooks
|
SanNare
|
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector, DensityMatrix
from qiskit.tools.visualization import plot_state_qsphere, plot_histogram
def init_message(circuit,n = 1,m = 0,hads = 0):
if isinstance(m,int):
m = bin(m)[2:]
m = m.zfill(n)
if isinstance(hads,int):
hads = bin(hads)[2:]
hads = hads.zfill(n)
for i in range(0,n):
if m[i] == '1':
circuit.x(i)
if hads[i] == '1':
circuit.h(i)
def encrypt(n,key1 = 0,key2 = 0):
circuit = QuantumCircuit(n)
if isinstance(key1,int):
k1 = bin(key1)[2:]
k1 = k1.zfill(n)
if isinstance(key2,int):
k2 = bin(key2)[2:]
k2 = k2.zfill(n)
for i in range(0,n):
if k1[i] == '1':
circuit.x(i)
if k2[i] == '1':
circuit.z(i)
return circuit.to_gate()
def decrypt(n,key1 = 0,key2 = 0):
return encrypt(n,key1,key2).inverse()
n = 2
k1,k2 = 3,3
m = 0
hads = 3
circuit = QuantumCircuit(n)
init_message(circuit,n,m,hads)
#encryption
enc = encrypt(n,k1,k2)
enc.label = 'Enc({},{},{})'.format(n,k1,k2)
circuit.append(enc,list(range(0,n)))
# #decryption: uncomment to apply
# dec = decrypt(n,k1,k2)
# dec.label = 'Dec({},{},{})'.format(n,k1,k2)
# circuit.append(dec,list(range(0,n)))
%matplotlib inline
circuit.draw(output = 'mpl')
#Uncomment to view contents of the encryption and/or decryption circuits
#circuit.decompose().draw(output = 'mpl')
sv = Statevector.from_label("00")
dm = DensityMatrix(sv)
nsv = sv.evolve(circuit)
ndm = dm.evolve(circuit)
print(nsv.data)
print(ndm.data)
|
https://github.com/Javihaus/Quantum-Machinel-Leaning
|
Javihaus
|
# MatplotlibDrawer needs pylatexenc. You need to install it:
#pip install pylatexenc
import numpy as np
import seaborn as sns
from qiskit import *
from qiskit.tools.jupyter import *
import matplotlib.pyplot as plt
import pylatexenc
from scipy.optimize import minimize
from sklearn.preprocessing import Normalizer, normalize, binarize, Binarizer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, MinMaxScaler
from sklearn.decomposition import PCA, KernelPCA, LatentDirichletAllocation
import pandas as pd
import gc as gc
backend = BasicAer.get_backend('qasm_simulator') # for using a quantum simulator
#Using other quantum processors from IBM
#from qiskit import IBMQ
#IBMQ.save_account('c42be77bc7bcc969263dd866c03b2a05fefd1d203ae6aedc6765543cae8ac3d862c8fcdff5aca2f486c0ba36f764393e76718d54bc679c1aeeec78ff32bab7dd')
#provider = IBMQ.load_account()
# You can check in IBM site the cues in different backend processors.
# You can choose processors with lower cues to speed up your work.
#backend = provider.backends.ibmq_london
#from qiskit.tools.monitor import job_monitor
#shots = 1024
#max_credits = 3
#job_exp = execute(qc, backend=backend, shots=shots, max_credits=max_credits)
#job_monitor(job_exp)
gc.collect()
data = pd.read_csv("General.csv")
data = data.drop(columns=['Unnamed: 0',
'reconocimiento medico', 'seguro medico', 'revision medica',
'cobertura medica' , 'fecha', 'BlobText_seguro'])
# Removing outliers for a better accuracy. As alterntive you can apply a
# RobustScaler algortihm.
Q1 = data.quantile(0.1)
Q3 = data.quantile(0.9)
IQR = Q3 - Q1
data = data[~((data < (Q1 - 1.5 * IQR)) |(data > (Q3 + 1.5 * IQR))).any(axis=1)]
# Using Random Forest to gain insights on Feature Importance
data['Vader_gimnasio'] =(data['Vader_gimnasio'] > -0.050).astype(int)
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
clf = RandomForestClassifier()
clf.fit(data.drop(columns='Vader_gimnasio'),data.Vader_gimnasio)
plt.style.use('seaborn-whitegrid')
importance = clf.feature_importances_
importance = pd.DataFrame(importance, index=data.drop(columns='Vader_gimnasio').columns, columns=["Importance"])
importance.sort_values(by='Importance', ascending=True).plot(kind='barh', figsize=(20,len(importance)/2));
importance.sort_values(by='Importance', ascending=False) > 0.07
class_labels = ['Interés bajo', 'Interés alto']
# We choose only the relevant features and remove the rest
X = data.drop(columns=['Vader_gimnasio', 'salud', 'Vader_trabajo', 'Vader_salbe', 'Vader_salbien',
'Afiliacion', 'consumo electrico', 'ICC', 'Tendencia prevista ICC', 'Vader_seguro',
'Situación económica de los hogares', 'DG ECFIN Business and Consumer Survey', 'Vader_recon1'])
Y = data.Vader_gimnasio
Y = np.array(Y)
#scale value from 0 to 1 (so we remove negative values)
scaler = MinMaxScaler().fit(X)
X = scaler.transform(X)
n_dim = 2
# I use linear Kernel PCA to reduce the number of dimensions of the dataset to n_dim = 2
pca = KernelPCA(n_components=n_dim).fit(X)
X = pca.transform(X)
scaler = MinMaxScaler().fit(X)
X = scaler.transform(X)
def get_angles(x):
beta0 = 2 * np.arcsin(np.sqrt(x[1]) ** 2 / np.sqrt(x[0] ** 2 + x[1] ** 2 + 1e-12))
beta1 = 2 * np.arcsin(np.sqrt(x[3]) ** 2 / np.sqrt(x[2] ** 2 + x[3] ** 2 + 1e-12))
beta2 = 2 * np.arcsin(
np.sqrt(x[2] ** 2 + x[3] ** 2) / np.sqrt(x[0] ** 2 + x[1] ** 2 + x[2] ** 2 + x[3] ** 2)
)
return np.array([beta2, -beta1 / 2, beta1 / 2, -beta0 / 2, beta0 / 2])
print("First X sample (original) :", X[0])
# pad the vectors to size 2^2 with constant values
padding = 0.3 * np.ones((len(X), 1))
X_pad = np.c_[np.c_[X, padding], np.zeros((len(X), 1))]
print("First X sample (padded) :", X_pad[0])
# normalize each input
normalization = np.sqrt(np.sum(X_pad ** 2, -1))
X_norm = (X_pad.T / normalization).T
print("First X sample (normalized):", X_norm[0])
# angles for state preparation are new features
features = np.array([get_angles(x) for x in X_norm])
print("First features sample :", features[0])
def statepreparation(a, circuit, target):
a = 2*a
circuit.ry(a[0], target[0])
circuit.cx(target[0], target[1])
circuit.ry(a[1], target[1])
circuit.cx(target[0], target[1])
circuit.ry(a[2], target[1])
circuit.x(target[0])
circuit.cx(target[0], target[1])
circuit.ry(a[3], target[1])
circuit.cx(target[0], target[1])
circuit.ry(a[4], target[1])
circuit.x(target[0])
return circuit
x = X_norm[0]
ang = get_angles(x)
q = QuantumRegister(2)
c = ClassicalRegister(1)
circuit = QuantumCircuit(q,c)
circuit = statepreparation(ang, circuit, [0,1])
circuit.draw(output='mpl')
def u_gate(param, circuit, target):
'''Return the quantum circuit with u3 gate applied on qubit target with param as an iterable'''
circuit.u3(param[0],param[1],param[2],target)
return circuit
def cu_gate(param, circuit, control, target):
'''Return the quantum circuit with cu3 gate applied on qubit target with param as an iterable wrt control'''
circuit.cu3(param[0],param[1],param[2], control, target)
return circuit
def circuit_block(param, circuit, target, same_order_x=True):
'''Return the block applied on qubits target from the circuit circuit
- param : array parameters for the two u gate
- target : array of integer the numero of qubits for the u gates to be applied
- if same_order_x == True : cx(target[0], target[1])
else: cx(target[1], target[0])'''
circuit = u_gate(param[0], circuit, target[0])
circuit = u_gate(param[1], circuit, target[1])
if same_order_x:
circuit.cx(target[0], target[1])
else:
circuit.cx(target[1], target[0])
return circuit
def c_circuit_block(param, circuit, control, target, same_order_x=True):
'''Return the controlled block applied on qubits target from the circuit circuit
- param : array parameters for the two u gate
- target : array of integer the numero of qubits for the u gates to be applied
- if same_order_x == True : cx(target[0], target[1])
else: cx(target[1], target[0])'''
circuit = cu_gate(param[0], circuit, control, target[0])
circuit = cu_gate(param[1], circuit, control, target[1])
if same_order_x:
circuit.ccx(control, target[0], target[1])
else:
circuit.ccx(control, target[1], target[0])
return circuit
def create_circuit(param, circuit, target):
order = True
for i in range(param.shape[0]):
circuit = circuit_block(param[i], circuit, target, order)
order = not order
return circuit
def create_c_circuit(param, circuit, control, target):
order = True
for i in range(param.shape[0]):
circuit = c_circuit_block(param[i], circuit, control, target, order)
order = not order
return circuit
x = np.array([0.53896774, 0.79503606, 0.27826503, 0.0])
ang = get_angles(x)
params = np.array([[[np.pi/3,np.pi/3,np.pi/4],
[np.pi/6,np.pi/4,np.pi/6]],
[[np.pi/6,np.pi/4,np.pi/4],
[np.pi/3,np.pi/7,np.pi/6]],
[[np.pi/3,np.pi/3,np.pi/4],
[np.pi/6,np.pi/4,np.pi/6]],
[[np.pi/6,np.pi/4,np.pi/4],
[np.pi/3,np.pi/7,np.pi/6]]])
q = QuantumRegister(2)
c = ClassicalRegister(1)
circuit = QuantumCircuit(q,c)
circuit = statepreparation(ang, circuit, [0,1])
circuit = create_circuit(params, circuit, [0,1])
circuit.measure(0,c)
circuit.draw(output='mpl')
def execute_circuit(params, angles=None, x=None, use_angles=True, bias=0, shots=1000):
if not use_angles:
angles = get_angles(x)
q = QuantumRegister(2)
c = ClassicalRegister(1)
circuit = QuantumCircuit(q,c)
circuit = statepreparation(angles, circuit, [0,1])
circuit = create_circuit(params, circuit, [0,1])
circuit.measure(0,c)
result = execute(circuit,backend,shots=shots).result()
counts = result.get_counts(circuit)
result=np.zeros(2)
for key in counts:
result[int(key,2)]=counts[key]
result/=shots
return result[1] + bias
execute_circuit(params, ang, bias=0.02)
def predict(probas):
return (probas>=0.5)*1
def binary_crossentropy(labels, predictions):
loss = 0
for l, p in zip(labels, predictions):
loss = loss - l * np.log(np.max([p,1e-8]))
loss = loss / len(labels)
return loss
def square_loss(labels, predictions):
loss = 0
for l, p in zip(labels, predictions):
loss = loss + (l - p) ** 2
loss = loss / len(labels)
return loss
def cost(params, features, labels):
predictions = [execute_circuit(params, angles=f) for f in features]
return binary_crossentropy(labels, predictions)
def accuracy(labels, predictions):
loss = 0
for l, p in zip(labels, predictions):
if abs(l - p) < 1e-5:
loss = loss + 1
loss = loss / len(labels)
return loss
def real(param1, param2, angles, shots=1000):
"""Returns Re{<circuit(param2)|sigma_z|circuit(param1)>}"""
q = QuantumRegister(3)
c = ClassicalRegister(1)
circuit = QuantumCircuit(q,c)
circuit.h(q[0])
circuit = statepreparation(angles, circuit, [1,2])
circuit = create_c_circuit(param1, circuit, 0, [1,2])
circuit.cz(q[0], q[1])
circuit.x(q[0])
circuit = create_c_circuit(param2, circuit, 0, [1,2])
circuit.x(q[0])
circuit.h(q[0])
circuit.measure(q[0],c)
result = execute(circuit,backend,shots=shots).result()
counts = result.get_counts(circuit)
result=np.zeros(2)
for key in counts:
result[int(key,2)]=counts[key]
result/=shots
return (2*result[0]-1)
def imaginary(param1, param2, angles, shots=1000):
"""Returns Im{<circuit(param2)|sigma_z|circuit(param1)>}"""
q = QuantumRegister(3)
c = ClassicalRegister(1)
circuit = QuantumCircuit(q,c)
circuit.h(q[0])
circuit = statepreparation(angles, circuit, [1,2])
circuit = create_c_circuit(param1, circuit, 0, [1,2])
circuit.cz(q[0], q[1])
circuit.x(q[0])
circuit = create_c_circuit(param2, circuit, 0, [1,2])
circuit.x(q[0])
circuit.u1(np.pi/2, q[0])
circuit.h(q[0])
circuit.measure(q[0],c)
result = execute(circuit,backend,shots=shots).result()
counts = result.get_counts(circuit)
result=np.zeros(2)
for key in counts:
result[int(key,2)]=counts[key]
result/=shots
return -(2*result[0]-1)
def gradients(params, angles, label, bias=0):
grads = np.zeros_like(params)
imag = imaginary(params, params, angles)
for i in range(params.shape[0]):
for j in range(params.shape[1]):
params_bis = np.copy(params)
params_bis[i,j,0]+=np.pi
grads[i,j,0] = -0.5 * real(params, params_bis, angles)
params_bis[i,j,0]-=np.pi
params_bis[i,j,1]+=np.pi
grads[i,j,1] = 0.5 * (imaginary(params, params_bis, angles) - imag)
params_bis[i,j,1]-=np.pi
params_bis[i,j,2]+=np.pi
grads[i,j,2] = 0.5 * (imaginary(params, params_bis, angles) - imag)
params_bis[i,j,2]-=np.pi
p = execute_circuit(params, angles, bias=bias)
grad_bias = (p - label) / (p * (1 - p))
grads *= grad_bias
return grads, grad_bias
np.random.seed(0)
num_data = len(Y)
num_train = int(0.75 * num_data)
index = np.random.permutation(range(num_data))
feats_train = features[index[:num_train]]
Y_train = Y[index[:num_train]]
feats_val = features[index[num_train:]]
Y_val = Y[index[num_train:]]
# We need these later for plotting
X_train = X[index[:num_train]]
X_val = X[index[num_train:]]
layers = 6
params_init = np.random.randn(layers,2,3) * 0.01
bias_init = 0.01
batch_size = 5
learning_rate = 0.01
momentum = 0.9
var = np.copy(params_init)
bias = bias_init
v = np.zeros_like(var)
v_bias = 0
for it in range(15):
# Update the weights by one optimizer step
batch_index = np.random.randint(0, num_train, (batch_size,))
feats_train_batch = feats_train[batch_index]
Y_train_batch = Y_train[batch_index]
grads = np.zeros_like(var)
grad_bias = 0
var_corrected = var + momentum * v
bias_corrected = bias + momentum * v_bias
for j in range(batch_size):
g, g_bias = gradients(var_corrected, feats_train_batch[j], Y_train_batch[j], bias)
grads += g / batch_size
grad_bias +=g_bias / batch_size
v = momentum * v - learning_rate * grads
v_bias = momentum * v_bias - learning_rate * grad_bias
var += v
bias += v_bias
# Compute predictions on train and validation set
probas_train = np.array([execute_circuit(var, angles=f, bias=bias) for f in feats_train])
probas_val = np.array([execute_circuit(var, angles=f, bias=bias) for f in feats_val])
predictions_train = predict(probas_train)
predictions_val = predict(probas_val)
# Compute accuracy on train and validation set
acc_train = accuracy(Y_train, predictions_train)
acc_val = accuracy(Y_val, predictions_val)
print(
"Iter: {:5d} | Loss: {:0.7f} | Acc train: {:0.7f} | Acc validation: {:0.7f} "
"".format(it + 1, cost(var, features, Y), acc_train, acc_val)
)
gc.collect()
plt.figure(figsize=(16,8))
cm = plt.cm.RdBu
# make data for decision regions
xx, yy = np.meshgrid(np.linspace(0.0, 1, 20), np.linspace(0.0, 1, 20))
X_grid = [np.array([x, y]) for x, y in zip(xx.flatten(), yy.flatten())]
# preprocess grid points like data inputs above
padding = 0.3 * np.ones((len(X_grid), 1))
X_grid = np.c_[np.c_[X_grid, padding], np.zeros((len(X_grid), 1))] # pad each input
normalization = np.sqrt(np.sum(X_grid ** 2, -1))
X_grid = (X_grid.T / normalization).T # normalize each input
features_grid = np.array(
[get_angles(x) for x in X_grid]
)
# angles for state preparation are new features
predictions_grid = [execute_circuit(var, angles=f, bias=bias, shots=10000) for f in features_grid]
Z = np.reshape(predictions_grid, xx.shape)
# plot decision regions
cnt = plt.contourf(xx, yy, Z, levels=np.arange(0, 1.1, 0.1), cmap=cm, alpha=0.8, extend="both")
plt.contour(xx, yy, Z, levels=[0.0], colors=("black",), linestyles=("--",), linewidths=(0.8,))
plt.colorbar(cnt, ticks=[0, 0, 1])
# plot data
ce = cost(var, features, Y)
plt.title("$p$, probability the model guesses for the correct class = {:0.7f}"
"".format(np.e**(-ce)))
plt.scatter(
X_val[:, 0][Y_val == 1],
X_val[:, 1][Y_val == 1],
c="b",
marker="o",
edgecolors="k",
label="Interés por el gimnasio alto",
)
plt.scatter(
X_train[:, 0][Y_train == 1],
X_train[:, 1][Y_train == 1],
c="b",
marker="o",
edgecolors="k",
alpha=0.5,
label="Interés por el gimnasio alto - train",
)
plt.scatter(
X_val[:, 0][Y_val == 0],
X_val[:, 1][Y_val == 0],
c="r",
marker="o",
edgecolors="k",
label="Interés por el gimansio bajo ",
)
plt.scatter(
X_train[:, 0][Y_train == 0],
X_train[:, 1][Y_train == 0],
c="r",
marker="o",
edgecolors="k",
alpha=0.5,
label="Interés por el gimnasio bajo -train",
)
plt.xlabel('Component 1')
plt.ylabel('Component 2')
plt.ylim(0,1)
plt.xlim(0,1)
plt.legend()
plt.savefig('/Users/javiermarin/desktop/Grafica4-o.png')
plt.show()
plt.figure(figsize=(16,6))
# Binnary cross-entropy loss
def cross_entropy(p):
return -np.log(p)
ps = np.linspace(0.005, 1, 100)
ces = [cross_entropy(p) for p in ps]
ce = cost(var, features, Y)
plt.plot(ps, ces, lw=3)
plt.title("$H$, Cross Entropy Loss = {:0.7f}"
"".format(ce))
plt.suptitle("$p$, Probability = {:0.7f}"
"".format(np.e**(-ce)))
plt.ylabel('$H$, Cross-Entropy Loss - binary')
plt.xlabel('$p$, probability the model guesses for the correct class')
plt.hlines((cost(var, features, Y)), 0, 1, colors='red', lw=2, linestyles='dotted')
plt.vlines(np.e**(-ce), 0, 5, colors='red', lw=2, linestyles='dotted')
plt.xlim(0,1)
plt.ylim(0,5)
plt.show()
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Test the RemoveBarriers pass"""
import unittest
from qiskit.transpiler.passes import RemoveBarriers
from qiskit.converters import circuit_to_dag
from qiskit import QuantumCircuit
from qiskit.test import QiskitTestCase
class TestMergeAdjacentBarriers(QiskitTestCase):
"""Test the MergeAdjacentBarriers pass"""
def test_remove_barriers(self):
"""Remove all barriers"""
circuit = QuantumCircuit(2)
circuit.barrier()
circuit.barrier()
pass_ = RemoveBarriers()
result_dag = pass_.run(circuit_to_dag(circuit))
self.assertEqual(result_dag.size(), 0)
def test_remove_barriers_other_gates(self):
"""Remove all barriers, leave other gates intact"""
circuit = QuantumCircuit(1)
circuit.barrier()
circuit.x(0)
circuit.barrier()
circuit.h(0)
pass_ = RemoveBarriers()
result_dag = pass_.run(circuit_to_dag(circuit))
op_nodes = result_dag.op_nodes()
self.assertEqual(result_dag.size(), 2)
for ii, name in enumerate(["x", "h"]):
self.assertEqual(op_nodes[ii].name, name)
def test_simple_if_else(self):
"""Test that the pass recurses into an if-else."""
pass_ = RemoveBarriers()
base_test = QuantumCircuit(1, 1)
base_test.barrier()
base_test.measure(0, 0)
base_expected = QuantumCircuit(1, 1)
base_expected.measure(0, 0)
test = QuantumCircuit(1, 1)
test.if_else(
(test.clbits[0], True), base_test.copy(), base_test.copy(), test.qubits, test.clbits
)
expected = QuantumCircuit(1, 1)
expected.if_else(
(expected.clbits[0], True),
base_expected.copy(),
base_expected.copy(),
expected.qubits,
expected.clbits,
)
self.assertEqual(pass_(test), expected)
def test_nested_control_flow(self):
"""Test that the pass recurses into nested control flow."""
pass_ = RemoveBarriers()
base_test = QuantumCircuit(1, 1)
base_test.barrier()
base_test.measure(0, 0)
base_expected = QuantumCircuit(1, 1)
base_expected.measure(0, 0)
body_test = QuantumCircuit(1, 1)
body_test.for_loop((0,), None, base_expected.copy(), body_test.qubits, body_test.clbits)
body_expected = QuantumCircuit(1, 1)
body_expected.for_loop(
(0,), None, base_expected.copy(), body_expected.qubits, body_expected.clbits
)
test = QuantumCircuit(1, 1)
test.while_loop((test.clbits[0], True), body_test, test.qubits, test.clbits)
expected = QuantumCircuit(1, 1)
expected.while_loop(
(expected.clbits[0], True), body_expected, expected.qubits, expected.clbits
)
self.assertEqual(pass_(test), expected)
if __name__ == "__main__":
unittest.main()
|
https://github.com/AmanSinghBhogal/NasaNEO_Classification
|
AmanSinghBhogal
|
import pandas as pd
from sklearn.model_selection import train_test_split
from qiskit import QuantumCircuit, execute, Aer
from qiskit import ClassicalRegister, QuantumRegister
from qiskit.visualization import plot_histogram
import matplotlib.pyplot as plt
from math import asin, sqrt, pi, log
from statistics import mean
import pandas as pd
from sklearn.metrics import confusion_matrix, precision_score, recall_score
# Loaded the Dataset
data = pd.read_csv('neo_v2.csv')
# Writing code for Pre-Procesing
cat_max_dia = []
cat_RV = []
cat_miss = []
max_dia_mean = mean(data['est_diameter_max'])
Rv_mean = mean(data['relative_velocity'])
miss_mean = mean(data['miss_distance'])
print("\n\nThe Mean Max Diameter is: ", max_dia_mean)
print("The Mean Relative Velocity is: ", Rv_mean)
print("The Mean Miss Distance is: ", miss_mean)
for i,j, z in zip(data['est_diameter_max'], data['relative_velocity'], data['miss_distance']):
if i>=max_dia_mean:
cat_max_dia.append("Large")
else :
cat_max_dia.append("Small")
if j>=Rv_mean:
cat_RV.append("Fast")
else:
cat_RV.append("Slow")
if z>=miss_mean:
cat_miss.append("More")
else:
cat_miss.append("Less")
processed_data = pd.DataFrame(list(zip(data['est_diameter_max'], data['relative_velocity'],data['miss_distance'], cat_max_dia, cat_RV,cat_miss, data['hazardous'])),columns=['Max_Diameter','Relative_Velocity','Miss_Distance', 'Categorized_Diameter', 'Categorized_Relative_Vel','Categorised_Miss_Distance','Hazardous'])
# Saving the Processed Data to get a better view
processed_data.to_csv('processedData.csv')
# Splitted the Dataset into Training and Testing
train_input, test_input = train_test_split(processed_data, test_size=0.3, random_state=0)
# Printing Number of records in training and testing
print("There are {} Training Records and {} Testing Records".format(train_input.shape[0], test_input.shape[0]))
# Printing the Number of True and False Records in Train and Test Dataset
print("Train Dataset: No of True: {}, No. False: {}".format(len(train_input[train_input['Hazardous'] == True]), len(train_input[train_input['Hazardous'] == False])))
print("Test Dataset: No of True: {}, No. False: {}".format(len(test_input[test_input['Hazardous'] == True]), len(test_input[test_input['Hazardous'] == False])))
# need to write preprocess function for calculating backward probability
# Function for Calculating Category Prob.
def prob_hazard_calc(df, category_name, category_val):
pop = df[df[category_name] == category_val]
hazard_pop = pop[pop['Hazardous'] == True]
p_pop = len(hazard_pop)/len(pop)
return p_pop, len(pop)
# For Max Diameter
# for small:
p_small, pop_small = prob_hazard_calc(train_input, "Categorized_Diameter", "Small")
# print(p_small, pop_small)
# for Large:
p_large, pop_large = prob_hazard_calc(train_input, "Categorized_Diameter", "Large")
# print(p_large, pop_large)
print("\n\nPrinting Chances of Max Diameter Objects given they are hazardous:\n")
print("{} Small Diameter objects had {} chances of being hazardous".format(pop_small, p_small))
print("{} Large Diameter objects had {} chances of being hazardous".format(pop_large, p_large))
# For Relative Velocity:
# for Slow:
p_slow, pop_slow = prob_hazard_calc(train_input, "Categorized_Relative_Vel", "Slow")
# print(p_slow, pop_slow)
# for Fast:
p_fast, pop_fast = prob_hazard_calc(train_input, "Categorized_Relative_Vel", "Fast")
# print(p_fast, pop_fast)
print("\n\nPrinting Chances of Relative Velocity Objects given they are hazardous:\n")
print("{} Slow Relative Velocity objects had {} chances of being hazardous".format(pop_slow, p_slow))
print("{} Fast Relative Velocity objects had {} chances of being hazardous".format(pop_fast, p_fast))
# For Miss Distance:
# For Less
p_less, pop_less = prob_hazard_calc(train_input, "Categorised_Miss_Distance", "Less")
# print(p_less, pop_less)
# For More:
p_more, pop_more = prob_hazard_calc(train_input, "Categorised_Miss_Distance", "More")
# print(p_more, pop_more)
print("\n\nPrinting Chances of Miss Distance Objects given they are hazardous:\n")
print("{} Less Miss Distance objects had {} chances of being hazardous".format(pop_less, p_less))
print("{} More Miss Distance objects had {} chances of being hazardous".format(pop_more, p_more))
# Implementing Quantum Naive Bayes Circuit:
# Specifying the marginal probability
def prob_to_angle(prob):
"""
Converts a given P(psi) value into an equivalent theta value.
"""
return 2*asin(sqrt(prob))
# Initialize the quantum circuit
qc = QuantumCircuit(3)
# Set qubit0 to p_small i.e for Max Diameter
qc.ry(prob_to_angle(p_large), 0)
# Set qubit1 to p_fast i.e for Relative Velocity
qc.ry(prob_to_angle(p_fast), 1)
# Defining the CCRY‐gate:
def ccry(qc, theta, control1, control2, controlled):
qc.cry(theta/2, control2, controlled)
qc.cx(control1, control2)
qc.cry(-theta/2, control2, controlled)
qc.cx(control1, control2)
qc.cry(theta/2, control1, controlled)
# Calculating the conditional probabilities
# fast Relative Velocity and large Diameter
population_fast=train_input[train_input.Categorized_Relative_Vel.eq("Fast")]
population_fast_large= population_fast[population_fast.Categorized_Diameter.eq("Large")]
hazardous_fast_large = population_fast_large[population_fast_large.Hazardous.eq(1)]
p_hazardous_fast_large=len(hazardous_fast_large)/len(population_fast_large)
# fast Relative Velocity and small Diameter
population_fast_small = population_fast[population_fast.Categorized_Diameter.eq("Small")]
hazardous_fast_small = population_fast_small[population_fast_small.Hazardous.eq(1)]
p_hazardous_fast_small=len(hazardous_fast_small)/len(population_fast_small)
# Slow Relative Velocity and Large Diameter
population_slow = train_input[train_input.Categorized_Relative_Vel.eq("Slow")]
population_slow_large = population_slow[population_slow.Categorized_Diameter.eq("Large")]
hazardous_slow_large=population_slow_large[population_slow_large.Hazardous.eq(1)]
p_hazardous_slow_large=len(hazardous_slow_large)/len(population_slow_large)
# Slow Relative Velocity and Small Diameter
population_slow_small = population_slow[population_slow.Categorized_Diameter.eq("Small")]
hazardous_slow_small = population_slow_small[population_slow_small.Hazardous.eq(1)]
p_hazardous_slow_small=len(hazardous_slow_small)/len(population_slow_small)
# Initializing the child node:
# set state |00> to conditional probability of slow RV and small Diameter
qc.x(0)
qc.x(1)
ccry(qc,prob_to_angle(p_hazardous_slow_small),0,1,2)
qc.x(0)
qc.x(1)
# set state |01> to conditional probability of slow RV and large Diameter
qc.x(0)
ccry(qc,prob_to_angle(p_hazardous_slow_large),0,1,2)
qc.x(0)
# set state |10> to conditional probability of fast RV and small Diameter
qc.x(1)
ccry(qc,prob_to_angle(p_hazardous_fast_small),0,1,2)
qc.x(1)
# set state |11> to conditional probability of fast RV and large Diameter
ccry(qc,prob_to_angle(p_hazardous_fast_large),0,1,2)
# Circuit execution
# execute the qc
results = execute(qc,Aer.get_backend('statevector_simulator')).result().get_counts()
plot_histogram(results)
# Quantum circuit with classical register
qr = QuantumRegister(3)
cr = ClassicalRegister(1)
qc = QuantumCircuit(qr, cr)
# Listing Run the circuit including a measurement
# -- INCLUDE ALL GATES HERE --
# Set qubit0 to p_small i.e for Max Diameter
qc.ry(prob_to_angle(p_large), 0)
# Set qubit1 to p_fast i.e for Relative Velocity
qc.ry(prob_to_angle(p_fast), 1)
# set state |00> to conditional probability of slow RV and small Diameter
qc.x(0)
qc.x(1)
ccry(qc,prob_to_angle(p_hazardous_slow_small),0,1,2)
qc.x(0)
qc.x(1)
# set state |01> to conditional probability of slow RV and large Diameter
qc.x(0)
ccry(qc,prob_to_angle(p_hazardous_slow_large),0,1,2)
qc.x(0)
# set state |10> to conditional probability of fast RV and small Diameter
qc.x(1)
ccry(qc,prob_to_angle(p_hazardous_fast_small),0,1,2)
qc.x(1)
# set state |11> to conditional probability of fast RV and large Diameter
ccry(qc,prob_to_angle(p_hazardous_fast_large),0,1,2)
qc.measure(qr[2], cr[0])
results = execute(qc,Aer.get_backend('qasm_simulator'), shots=1000).result().get_counts()
plot_histogram(results)
|
https://github.com/kuehnste/QiskitTutorial
|
kuehnste
|
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.visualization import *
from qiskit.quantum_info import state_fidelity
# Magic function to render plots in the notebook after the cell executing the plot command
%matplotlib inline
def run_on_qasm_simulator(quantum_circuit, num_shots):
"""Takes a circuit, the number of shots and a backend and returns the qasi-probabilities for running
the circuit on the qasm_simulator backend."""
qasm_simulator = Aer.get_backend('qasm_simulator')
job = execute(quantum_circuit, backend=qasm_simulator, shots=num_shots)
result = job.result()
counts = result.get_counts(quantum_circuit)
counts = {key: value / num_shots for key, value in counts.items()}
return counts
# Create a quantum circuit with a single qubit
qc1 = QuantumCircuit(1)
# Add the Hadamard gate
qc1.h(0)
# Add the final measurement
qc1.measure_all()
# Visualize the circuit
qc1.draw('mpl')
# Now we run the circuit various number of shots
num_shots = [100, 500, 1000, 10000]
res_qc1 = list()
for curr_shots in num_shots:
res_qc1.append(run_on_qasm_simulator(qc1, curr_shots))
# Visualize the results in form of a histogram
plot_histogram(res_qc1, title='Single Hadamard gate', legend=['number of shots ' + str(x) for x in num_shots])
# Create a quantum circuit with two qubits
qc2 = QuantumCircuit(2)
# Add the gates creating a Bell state
qc2.h(0)
qc2.cnot(0,1)
# Add the final measurement
qc2.measure_all()
# Visualize the circuit
qc2.draw('mpl')
# Now we run the circuit various number of shots
num_shots = [100, 500, 1000, 10000]
res_qc2 = list()
for curr_shots in num_shots:
res_qc2.append(run_on_qasm_simulator(qc2, curr_shots))
# Visualize the results in form of a histogram
plot_histogram(res_qc2, title='Bell state', legend=['number of shots ' + str(x) for x in num_shots])
# We prepare a similar function for running on the state vector simulator
def run_on_statevector_simulator(quantum_circuit, decimals=6):
"""Takes a circuit, and runs it on the state vector simulator backend."""
statevector_simulator = Aer.get_backend('statevector_simulator')
job = execute(quantum_circuit, backend=statevector_simulator)
result = job.result()
statevector = result.get_statevector(quantum_circuit, decimals=decimals)
return statevector
# Let us first prepare the Phi^- state
qc_phi_minus = QuantumCircuit(2)
qc_phi_minus.x(0)
qc_phi_minus.h(0)
qc_phi_minus.cnot(0,1)
qc_phi_minus.draw('mpl')
# To obtain the statevector, we run on Aer's state vector simulator. Note, that there is no measurement at the end
# when running on the state vector simulator, as otherwise the state would collapse onto one of the computational
# basis states and we do not get the actual state vector prepared by the circuit
phi_minus_state = run_on_statevector_simulator(qc_phi_minus)
print('|Phi^-> =', phi_minus_state)
#The Psi^+ state
qc_psi_plus = QuantumCircuit(2)
qc_psi_plus.x(1)
qc_psi_plus.h(0)
qc_psi_plus.cnot(0,1)
qc_psi_plus.draw('mpl')
psi_plus_state = run_on_statevector_simulator(qc_psi_plus)
print('|Psi^+> =', psi_plus_state)
# Let us first prepare the Psi^- state
qc_psi_minus = QuantumCircuit(2)
qc_psi_minus.x(0)
qc_psi_minus.x(1)
qc_psi_minus.h(0)
qc_psi_minus.cnot(0,1)
qc_psi_minus.draw('mpl')
psi_minus_state = run_on_statevector_simulator(qc_psi_minus)
print('|Psi^-> =', psi_minus_state)
# Let us first prepare the Phi^+ state
qc_phi_plus = QuantumCircuit(2)
qc_phi_plus.h(0)
qc_phi_plus.cnot(0,1)
qc_phi_plus.draw('mpl')
phi_plus_state = run_on_statevector_simulator(qc_phi_plus)
print('|Phi^+> =', phi_plus_state)
print('|<Phi^+|Phi^->|^2 =', state_fidelity(phi_plus_state, phi_minus_state))
print('|<Phi^+|Psi^+>|^2 =', state_fidelity(phi_plus_state, psi_plus_state))
print('|<Phi^+|Psi^->|^2 =', state_fidelity(phi_plus_state, psi_minus_state))
print('|<Psi^+|Psi^->|^2 =', state_fidelity(psi_plus_state, phi_minus_state))
print('|<Psi^+|Phi^->|^2 =', state_fidelity(psi_plus_state, phi_minus_state))
print('|<Phi^-|Psi^->|^2 =', state_fidelity(phi_minus_state, psi_minus_state))
|
https://github.com/harshagarine/QISKIT_INDIA_CHALLENGE
|
harshagarine
|
### WRITE YOUR CODE BETWEEN THESE LINES - START
# import libraries that are used in the function below.
from qiskit import QuantumCircuit
import numpy as np
### WRITE YOUR CODE BETWEEN THESE LINES - END
def build_state():
# create a quantum circuit on two qubits
circuit = QuantumCircuit(2)
qc = QuantumCircuit(2,2)
qc.h(0)
qc.x(1)
qc.cx(0, 1)
qc.z(0)
return qc
return circuit
|
https://github.com/Dpbm/scientific-research-1-quantum-oracles
|
Dpbm
|
%matplotlib inline
from qiskit import QuantumCircuit, QuantumRegister, AncillaRegister, ClassicalRegister
from qiskit.compiler import transpile
from qiskit.visualization import plot_distribution, plot_histogram, plot_bloch_multivector
from qiskit.primitives import Sampler
from qiskit.quantum_info import Statevector
from qiskit.circuit import Parameter
from qiskit_aer import AerSimulator
from qiskit.quantum_info.operators import Operator
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
from utils import get_image_path
from scipy.optimize import minimize_scalar, OptimizeResult, minimize
from qiskit.providers.fake_provider import Fake20QV1
player_strategy = lambda bullets, fakes: "himself" if(bullets == fakes or fakes > bullets) else "shoot"
dealer_strategy = lambda bullets, fakes: "himself" if np.random.randint(2) else "shoot"
def gun(bullets, fakes) -> bool:
v = bullets + fakes
r = np.random.randint(1, v+1)
return r <= bullets
def play(strategies:dict, players:list, total_bullets:int, total_fakes:int, debug:bool=False) -> pd.DataFrame:
lives = {
"player":0,
"dealer":0
}
actual_player = players[0]
oponent = players[1]
rounds = 0
while(total_bullets):
player = strategies[actual_player]
action = player(total_bullets, total_fakes)
shot = gun(total_bullets, total_fakes)
if(debug):
print(f"playing: {actual_player}")
print(f"oponent: {oponent}")
print(f"action: {action}")
print(f"shot: {shot}")
if(action == "shoot" and shot):
lives[oponent] -=1
total_bullets -=1
actual_player = players[0]
oponent = players[1]
elif(action == "shoot" and not shot):
total_fakes -=1
actual_player,oponent = oponent,actual_player
elif(action == "himself" and shot):
lives[actual_player] -=1
total_bullets -=1
actual_player = players[0]
oponent = players[1]
else:
total_fakes -=1
if(debug):
print(lives, end="\n\n")
rounds += 1
if(lives['player'] > lives['dealer']):
return 'player', rounds
elif(lives['dealer'] > lives['player']):
return 'dealer', rounds
else:
return 'draw', rounds
play({"player":player_strategy, "dealer":dealer_strategy}, ("player", "dealer"), total_bullets=1, total_fakes=2, debug=True)
def get_experiment_results(n:int, players_strategies:dict, players:list, total_bullets:int, total_fakes:int):
df = pd.DataFrame(columns=("total_player", "total_dealer"))
n_rounds = pd.Series()
j = 1000
for i in range(n):
results = {"player":0, "dealer":0}
for _ in range(j):
result, rounds = play(players_strategies, players, total_bullets, total_fakes)
results[result]+=1
n_rounds.loc[j*i + j] = rounds
df.loc[i] = {"total_player":results['player'], "total_dealer":results['dealer']}
return df, n_rounds
df,rounds = get_experiment_results(n=1000, players_strategies={"player":player_strategy, "dealer":dealer_strategy}, players=("player", "dealer"), total_bullets=1, total_fakes=2)
print(rounds.value_counts())
sns.lineplot(data=df)
plt.savefig(get_image_path("first_classical_player_strategy.png"))
plt.show()
df,rounds = get_experiment_results(n=1000, players_strategies={"player":dealer_strategy, "dealer":dealer_strategy}, players=("player", "dealer"), total_bullets=1, total_fakes=2)
print(rounds.value_counts())
sns.lineplot(data=df)
plt.savefig(get_image_path("two_players_same_strategy.png"))
plt.show()
df,rounds = get_experiment_results(n=1000, players_strategies={"player":player_strategy, "dealer":player_strategy}, players=("player", "dealer"), total_bullets=1, total_fakes=2)
print(rounds.value_counts())
sns.lineplot(data=df)
plt.show()
def player_start_himself_strategy(bullets, fakes):
if(bullets == 1 and fakes == 2):
return 'himself'
elif(bullets == fakes):
return 'shoot' if np.random.randint(2) else "himself"
return 'shoot'
df,rounds = get_experiment_results(n=1000, players_strategies={"player":player_start_himself_strategy, "dealer":dealer_strategy}, players=("player", "dealer"), total_bullets=1, total_fakes=2)
print(rounds.value_counts())
sns.lineplot(data=df)
plt.show()
def player_optimal_strategy(bullets, fakes):
if(bullets == 1 and fakes == 2):
return 'shoot'
elif(bullets == fakes):
return 'shoot' if np.random.randint(2) else "himself"
return 'shoot'
df,rounds = get_experiment_results(n=3000, players_strategies={"player":player_optimal_strategy, "dealer":dealer_strategy}, players=("player", "dealer"), total_bullets=1, total_fakes=2)
print(rounds.value_counts())
sns.lineplot(data=df)
plt.savefig(get_image_path("optimal_player_strategy.png"))
plt.show()
df,rounds = play({"player":player_strategy, "dealer":dealer_strategy}, players=("player", "dealer"), total_bullets=1, total_fakes=2, debug=True)
rounds
# in the first strategy, there're some possible ways to finish the game
# player shoot himself (first round)
# dealer shoot himself (second round)
# dealer shoot the player (second round)
# player shoot (third round)
# so the player loses most part of the time
df,rounds = play({"player":player_start_himself_strategy, "dealer":dealer_strategy}, players=("player", "dealer"), total_bullets=1, total_fakes=2, debug=True)
rounds
# in the second strategy, there're some possible ways to finish the game
# player shoot himself (first round)
# player shoot himself (second round)
# player shoot the dealer (second round)
# dealer shoot the player (third round)
# dealer shoot himself (third round)
# so the player loses most part of the time
df,rounds = play({"player":player_optimal_strategy, "dealer":dealer_strategy}, players=("player", "dealer"), total_bullets=1, total_fakes=2, debug=True)
rounds
# in the third strategy, there're some possible ways to finish the game
# player shoot the dealer (first round)
# dealer shoot himself (second round)
# dealer shoot the player (second round)
# dealer shoot himself (third round)
# dealer shoot the player (third round)
# player shoot the dealer(third round)
# so the dealer loses most part of the time
# as in the first play the player chooses to shoot the dealer, he has more chances to live, once he's removed one of the dying chances
player = QuantumCircuit(1, name="Player")
player.h(0)
player.draw('mpl', style="clifford")
dealer = QuantumCircuit(1, name="Dealer")
dealer.h(0)
player.draw('mpl', style="clifford")
gun = QuantumCircuit(1, name="shoot")
gun.h(0)
gun.draw('mpl', style='clifford')
def buckshot_roulette(player, dealer, gun):
player_gate = player.to_gate()
player_controlled_gate = player.to_gate().control(1)
player_two_controlled_gate = player.to_gate().control(2)
dealer_controlled_gate = dealer.to_gate().control(1)
dealer_two_controlled_gate = dealer.to_gate().control(2)
gun_controlled_gate = gun.to_gate().control(1)
gun_two_controlled_gate = gun.to_gate().control(2)
player_life = QuantumRegister(3, name="p")
dealer_life = QuantumRegister(3, name="d")
game = QuantumRegister(3, name="game")
player_life_out = ClassicalRegister(3, name="po")
dealer_life_out = ClassicalRegister(3, name="do")
aux = AncillaRegister(1, name="aux")
qc = QuantumCircuit(game, aux, player_life, dealer_life, player_life_out, dealer_life_out)
qc.append(player.copy(), [game[0]])
qc.x(game[0])
qc.append(gun_controlled_gate.copy(), [game[0], player_life[0]])
qc.x(game[0])
qc.append(gun_controlled_gate.copy(), [game[0], dealer_life[0]])
#next_player
# 0 = player, 1 = dealer
qc.barrier()
qc.append(dealer_controlled_gate, [game[0], game[1]])
qc.x(game[0])
qc.append(player_controlled_gate, [game[0], game[1]])
qc.x(game[0])
qc.barrier()
qc.x(game[1])
qc.append(gun_two_controlled_gate, [game[0], game[1], dealer_life[1]])
qc.x(game[0])
qc.append(gun_two_controlled_gate, [game[0], game[1], player_life[1]])
qc.x(game[0])
qc.x(game[1])
qc.append(gun_two_controlled_gate, [game[0], game[1], player_life[1]])
qc.x(game[0])
qc.append(gun_two_controlled_gate, [game[0], game[1], dealer_life[1]])
qc.x(game[0])
qc.barrier()
qc.append(player_two_controlled_gate, [game[0], game[1], game[2]])
qc.x(game[1])
qc.append(dealer_two_controlled_gate, [game[0], game[1], game[2]])
qc.ccx(game[0], game[1], aux)
qc.x(game[1])
qc.x(game[0])
qc.append(dealer_two_controlled_gate, [game[0], game[1], game[2]])
qc.ccx(game[0], game[1], aux)
qc.x(game[0])
qc.x([game[0], game[1]])
qc.append(player_two_controlled_gate, [game[0], game[1], game[2]])
qc.x([game[0], game[1]])
qc.barrier()
qc.append(gun_two_controlled_gate, [aux, game[2], player_life[2]])
qc.x(game[2])
qc.append(gun_two_controlled_gate, [aux, game[2], dealer_life[2]])
qc.x(game[2])
qc.x(aux)
qc.append(gun_two_controlled_gate, [aux, game[2], dealer_life[2]])
qc.x(game[2])
qc.append(gun_two_controlled_gate, [aux, game[2], player_life[2]])
qc.x(aux)
qc.barrier()
qc.measure(player_life, player_life_out)
qc.measure(dealer_life, dealer_life_out)
return qc
qc = buckshot_roulette(player, dealer, gun)
qc.draw('mpl', style="clifford", filename=get_image_path("quantum_buckshot_roulette.png"))
sim = AerSimulator()
transpiled_qc = transpile(buckshot_roulette(player, dealer, gun), sim)
result = sim.run(transpiled_qc, shots=1000).result().get_counts()
plot_histogram(result)
def parse_results(results):
wins = {'dealer':0, 'player':0}
for d,v in results.items():
#v_bin = f"{v:06b}"
if(d.count("1") > 3):
continue
bin_dealer, bin_player = d[:3], d[4:]
#first_match
first_dealer, first_player = bin_dealer[-1], bin_player[-1]
#second_match
second_dealer, second_player = bin_dealer[-2], bin_player[-2]
#third_match
third_dealer, third_player = bin_dealer[-3], bin_player[-3]
if(first_dealer != first_player):
winner = "dealer" if first_dealer == '0' else "player"
wins[winner]+=v
continue
if(second_dealer != second_player):
winner = "dealer" if second_dealer == '0' else "player"
wins[winner]+=v
continue
if(third_dealer != third_player):
winner = "dealer" if third_dealer == '0' else "player"
wins[winner]+= v
continue
return wins
parse_results(result)
player_2 = QuantumCircuit(1)
player_2.ry(np.pi/4, 0)
player_2.draw('mpl', style='clifford')
plot_bloch_multivector(player_2)
sim = AerSimulator()
transpiled_qc = transpile(buckshot_roulette(player_2, dealer, gun), sim)
result = sim.run(transpiled_qc, shots=1000).result().get_counts()
plot_histogram(result)
parse_results(result)
def obj(x, sim, shots):
player_var = QuantumCircuit(1)
theta = Parameter('theta')
phi = Parameter('phi')
lam = Parameter('lambda')
player_var.u(theta, phi, lam, 0)
player_var = player_var.assign_parameters({theta:x[0], phi:x[1], lam:x[2]})
qc = buckshot_roulette(player_var, dealer, gun)
transpiled_qc = transpile(qc, sim)
result = sim.run(transpiled_qc, shots=shots).result().get_counts()
parsed_result = parse_results(result)
print(parsed_result, x)
return parsed_result['dealer']
minimized = minimize(
x0=[0, 0, 0],
bounds=[(0, np.pi), (0, 2*np.pi), (0,None)],
fun=obj,
args=(AerSimulator(), 1000),
method="COBYLA")
minimized
player_optimal = QuantumCircuit(1)
player_optimal.u(minimized.x[0], minimized.x[1],0, 0)
display(player_optimal.draw('mpl', style='clifford'))
qc = buckshot_roulette(player_optimal, dealer, gun)
transpiled_qc = transpile(qc, sim)
result = sim.run(transpiled_qc, shots=1000).result().get_counts()
display(plot_bloch_multivector(player_optimal))
plot_histogram(parse_results(result))
def obj(x, sim, shots):
player_var = QuantumCircuit(1)
theta = Parameter('theta')
player_var.ry(theta, 0)
player_var = player_var.assign_parameters({theta:x})
qc = buckshot_roulette(player_var, dealer, gun)
transpiled_qc = transpile(qc, sim)
result = sim.run(transpiled_qc, shots=shots).result().get_counts()
parsed_result = parse_results(result)
print(parsed_result, x)
return parsed_result['dealer']
def custom_minimizer(fun, args, **kwargs):
bounds = kwargs['bounds']
best_x = 0
best_y = 100000
rounds = 0
for v in np.arange(bounds[0], bounds[1], 0.01):
y = fun(v,args[0], args[1])
if(y < best_y):
best_y = y
best_x = v
rounds+=1
print(best_x, best_y)
return OptimizeResult(fun=best_y, x=best_x, nit=0, nfev=rounds, success=True)
minimized = minimize_scalar(
fun=obj,
bounds=(0, 2*np.pi),
args=(AerSimulator(), 1000),
method=custom_minimizer)
minimized
player_optimal = QuantumCircuit(1)
player_optimal.ry(minimized.x, 0)
display(player_optimal.draw('mpl', style='clifford'))
qc = buckshot_roulette(player_optimal, dealer, gun)
transpiled_qc = transpile(qc, sim)
result = sim.run(transpiled_qc, shots=1000).result().get_counts()
plot_histogram(parse_results(result))
def obj(x, sim, shots):
player_var = QuantumCircuit(1)
theta = Parameter('theta')
phi = Parameter('phi')
player_var.u(theta, phi, 0, 0)
player_var = player_var.assign_parameters({theta:x[0], phi:x[1]})
qc = buckshot_roulette(player_var, dealer, gun)
transpiled_qc = transpile(qc, sim)
result = sim.run(transpiled_qc, shots=shots).result().get_counts()
parsed_result = parse_results(result)
print(parsed_result, x)
return parsed_result['dealer']
def custom_minimizer(fun, x0, args, **kwargs):
bounds = kwargs['bounds']
best_x = []
best_y = 100000
rounds = 0
for i in np.arange(bounds[0][0], bounds[0][1], 0.1):
for j in np.arange(bounds[1][0], bounds[1][1], 0.1):
y = fun([i, j], args[0], args[1])
if(y < best_y):
best_y = y
best_x = [i, j]
rounds+=1
print(best_x, best_y)
return OptimizeResult(fun=best_y, x=best_x, nit=0, nfev=rounds, success=True)
minimized = minimize(
x0=[0, 0],
bounds=[(np.pi/4, np.pi), (np.pi/4, 2*np.pi)],
fun=obj,
args=(AerSimulator(), 1000),
method=custom_minimizer)
minimized
player_optimal = QuantumCircuit(1)
#player_optimal.u(minimized.x[0], minimized.x[1],0, 0)
player_optimal.u(3.0853981633974477, 3.7853981633974474,0, 0)
display(player_optimal.draw('mpl', style='clifford'))
plot_bloch_multivector(player_optimal, filename=get_image_path("player_optimal_strategy_bloch.png"))
sim = AerSimulator()
qc = buckshot_roulette(player_optimal, dealer, gun)
transpiled_qc = transpile(qc, sim)
result = sim.run(transpiled_qc, shots=1000).result().get_counts()
parsed_results = parse_results(result)
plt.bar(x=['dealer', 'player'], height=list(parsed_results.values()))
plt.ylabel("counts")
plt.savefig(get_image_path("final_buckshot_roulette_quantum_optimal_strategy.png"))
plt.show()
plot_histogram(result, filename=get_image_path("final_buckshot_roulette_quantum_optimal_strategy_bit_strings.png"))
plot_histogram(result)
transpiled = transpile(buckshot_roulette(player_optimal, dealer, gun), backend=Fake20QV1(), optimization_level=3)
transpiled.depth()
exp_result = Fake20QV1().run(transpiled, shots=1000).result().get_counts()
exp_result
plot_histogram(exp_result, filename=get_image_path("final_buckshot_roulette_quantum_optimal_strategy_bit_strings_Fake20QV1.png"))
plot_histogram(exp_result)
parsed_results = parse_results(exp_result)
plt.bar(x=['dealer', 'player'], height=list(parsed_results.values()))
plt.ylabel("counts")
plt.savefig(get_image_path("final_buckshot_roulette_quantum_optimal_strategy_Fake20QV1.png"))
plt.show()
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
from qiskit.compiler import transpile
from qiskit.transpiler import PassManager
circ = QuantumCircuit(3)
circ.ccx(0, 1, 2)
circ.draw(output='mpl')
from qiskit.transpiler.passes import Unroller
pass_ = Unroller(['u1', 'u2', 'u3', 'cx'])
pm = PassManager(pass_)
new_circ = pm.run(circ)
new_circ.draw(output='mpl')
from qiskit.transpiler import passes
[pass_ for pass_ in dir(passes) if pass_[0].isupper()]
from qiskit.transpiler import CouplingMap, Layout
from qiskit.transpiler.passes import BasicSwap, LookaheadSwap, StochasticSwap
coupling = [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6]]
circuit = QuantumCircuit(7)
circuit.h(3)
circuit.cx(0, 6)
circuit.cx(6, 0)
circuit.cx(0, 1)
circuit.cx(3, 1)
circuit.cx(3, 0)
coupling_map = CouplingMap(couplinglist=coupling)
bs = BasicSwap(coupling_map=coupling_map)
pass_manager = PassManager(bs)
basic_circ = pass_manager.run(circuit)
ls = LookaheadSwap(coupling_map=coupling_map)
pass_manager = PassManager(ls)
lookahead_circ = pass_manager.run(circuit)
ss = StochasticSwap(coupling_map=coupling_map)
pass_manager = PassManager(ss)
stochastic_circ = pass_manager.run(circuit)
circuit.draw(output='mpl')
basic_circ.draw(output='mpl')
lookahead_circ.draw(output='mpl')
stochastic_circ.draw(output='mpl')
import math
from qiskit.providers.fake_provider import FakeTokyo
backend = FakeTokyo() # mimics the tokyo device in terms of coupling map and basis gates
qc = QuantumCircuit(10)
random_state = [
1 / math.sqrt(4) * complex(0, 1),
1 / math.sqrt(8) * complex(1, 0),
0,
0,
0,
0,
0,
0,
1 / math.sqrt(8) * complex(1, 0),
1 / math.sqrt(8) * complex(0, 1),
0,
0,
0,
0,
1 / math.sqrt(4) * complex(1, 0),
1 / math.sqrt(8) * complex(1, 0)]
qc.initialize(random_state, range(4))
qc.draw()
optimized_0 = transpile(qc, backend=backend, seed_transpiler=11, optimization_level=0)
print('gates = ', optimized_0.count_ops())
print('depth = ', optimized_0.depth())
optimized_1 = transpile(qc, backend=backend, seed_transpiler=11, optimization_level=1)
print('gates = ', optimized_1.count_ops())
print('depth = ', optimized_1.depth())
optimized_2 = transpile(qc, backend=backend, seed_transpiler=11, optimization_level=2)
print('gates = ', optimized_2.count_ops())
print('depth = ', optimized_2.depth())
optimized_3 = transpile(qc, backend=backend, seed_transpiler=11, optimization_level=3)
print('gates = ', optimized_3.count_ops())
print('depth = ', optimized_3.depth())
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.dagcircuit import DAGCircuit
q = QuantumRegister(3, 'q')
c = ClassicalRegister(3, 'c')
circ = QuantumCircuit(q, c)
circ.h(q[0])
circ.cx(q[0], q[1])
circ.measure(q[0], c[0])
circ.rz(0.5, q[1]).c_if(c, 2)
circ.draw(output='mpl')
from qiskit.converters import circuit_to_dag
from qiskit.tools.visualization import dag_drawer
dag = circuit_to_dag(circ)
dag_drawer(dag)
dag.op_nodes()
node = dag.op_nodes()[3]
print("node name: ", node.name)
print("node op: ", node.op)
print("node qargs: ", node.qargs)
print("node cargs: ", node.cargs)
print("node condition: ", node.op.condition)
from qiskit.circuit.library import HGate
dag.apply_operation_back(HGate(), qargs=[q[0]])
dag_drawer(dag)
from qiskit.circuit.library import CCXGate
dag.apply_operation_front(CCXGate(), qargs=[q[0], q[1], q[2]], cargs=[])
dag_drawer(dag)
from qiskit.circuit.library import CHGate, U2Gate, CXGate
mini_dag = DAGCircuit()
p = QuantumRegister(2, "p")
mini_dag.add_qreg(p)
mini_dag.apply_operation_back(CHGate(), qargs=[p[1], p[0]])
mini_dag.apply_operation_back(U2Gate(0.1, 0.2), qargs=[p[1]])
# substitute the cx node with the above mini-dag
cx_node = dag.op_nodes(op=CXGate).pop()
dag.substitute_node_with_dag(node=cx_node, input_dag=mini_dag, wires=[p[0], p[1]])
dag_drawer(dag)
from qiskit.converters import dag_to_circuit
circuit = dag_to_circuit(dag)
circuit.draw(output='mpl')
from copy import copy
from qiskit.transpiler.basepasses import TransformationPass
from qiskit.transpiler import Layout
from qiskit.circuit.library import SwapGate
class BasicSwap(TransformationPass):
"""Maps (with minimum effort) a DAGCircuit onto a `coupling_map` adding swap gates."""
def __init__(self,
coupling_map,
initial_layout=None):
"""Maps a DAGCircuit onto a `coupling_map` using swap gates.
Args:
coupling_map (CouplingMap): Directed graph represented a coupling map.
initial_layout (Layout): initial layout of qubits in mapping
"""
super().__init__()
self.coupling_map = coupling_map
self.initial_layout = initial_layout
def run(self, dag):
"""Runs the BasicSwap pass on `dag`.
Args:
dag (DAGCircuit): DAG to map.
Returns:
DAGCircuit: A mapped DAG.
Raises:
TranspilerError: if the coupling map or the layout are not
compatible with the DAG.
"""
new_dag = DAGCircuit()
for qreg in dag.qregs.values():
new_dag.add_qreg(qreg)
for creg in dag.cregs.values():
new_dag.add_creg(creg)
if self.initial_layout is None:
if self.property_set["layout"]:
self.initial_layout = self.property_set["layout"]
else:
self.initial_layout = Layout.generate_trivial_layout(*dag.qregs.values())
if len(dag.qubits) != len(self.initial_layout):
raise TranspilerError('The layout does not match the amount of qubits in the DAG')
if len(self.coupling_map.physical_qubits) != len(self.initial_layout):
raise TranspilerError(
"Mappers require to have the layout to be the same size as the coupling map")
canonical_register = dag.qregs['q']
trivial_layout = Layout.generate_trivial_layout(canonical_register)
current_layout = trivial_layout.copy()
for layer in dag.serial_layers():
subdag = layer['graph']
for gate in subdag.two_qubit_ops():
physical_q0 = current_layout[gate.qargs[0]]
physical_q1 = current_layout[gate.qargs[1]]
if self.coupling_map.distance(physical_q0, physical_q1) != 1:
# Insert a new layer with the SWAP(s).
swap_layer = DAGCircuit()
swap_layer.add_qreg(canonical_register)
path = self.coupling_map.shortest_undirected_path(physical_q0, physical_q1)
for swap in range(len(path) - 2):
connected_wire_1 = path[swap]
connected_wire_2 = path[swap + 1]
qubit_1 = current_layout[connected_wire_1]
qubit_2 = current_layout[connected_wire_2]
# create the swap operation
swap_layer.apply_operation_back(SwapGate(),
qargs=[qubit_1, qubit_2],
cargs=[])
# layer insertion
order = current_layout.reorder_bits(new_dag.qubits)
new_dag.compose(swap_layer, qubits=order)
# update current_layout
for swap in range(len(path) - 2):
current_layout.swap(path[swap], path[swap + 1])
order = current_layout.reorder_bits(new_dag.qubits)
new_dag.compose(subdag, qubits=order)
return new_dag
q = QuantumRegister(7, 'q')
in_circ = QuantumCircuit(q)
in_circ.h(q[0])
in_circ.cx(q[0], q[4])
in_circ.cx(q[2], q[3])
in_circ.cx(q[6], q[1])
in_circ.cx(q[5], q[0])
in_circ.rz(0.1, q[2])
in_circ.cx(q[5], q[0])
from qiskit.transpiler import PassManager
from qiskit.transpiler import CouplingMap
from qiskit import BasicAer
pm = PassManager()
coupling = [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6]]
coupling_map = CouplingMap(couplinglist=coupling)
pm.append([BasicSwap(coupling_map)])
out_circ = pm.run(in_circ)
in_circ.draw(output='mpl')
out_circ.draw(output='mpl')
import logging
logging.basicConfig(level='DEBUG')
from qiskit.providers.fake_provider import FakeTenerife
log_circ = QuantumCircuit(2, 2)
log_circ.h(0)
log_circ.h(1)
log_circ.h(1)
log_circ.x(1)
log_circ.cx(0, 1)
log_circ.measure([0,1], [0,1])
backend = FakeTenerife()
transpile(log_circ, backend);
logging.getLogger('qiskit.transpiler').setLevel('INFO')
transpile(log_circ, backend);
# Change log level back to DEBUG
logging.getLogger('qiskit.transpiler').setLevel('DEBUG')
# Transpile multiple circuits
circuits = [log_circ, log_circ]
transpile(circuits, backend);
formatter = logging.Formatter('%(name)s - %(processName)-10s - %(levelname)s: %(message)s')
handler = logging.getLogger().handlers[0]
handler.setFormatter(formatter)
transpile(circuits, backend);
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/zapata-engineering/orquestra-qiskit
|
zapata-engineering
|
import sys
import time
from typing import List, Optional
from qiskit import execute
from qiskit_aer.noise import NoiseModel
from qiskit_ibm_provider import IBMBackendApiError
from .._get_provider import get_provider
from ._qiskit_runner import QiskitRunner
def _execute_on_ibmq_with_retries(
retry_delay_seconds: int, retry_timeout_seconds: int = sys.maxsize
):
def _execute(*args, **kwargs):
start_time = time.time()
while (elapsed_seconds := (time.time() - start_time)) < retry_timeout_seconds:
try:
return execute(*args, **kwargs)
except IBMBackendApiError as e:
# 3458 is the error code for too many jobs
# https://docs.quantum-computing.ibm.com/errors
if '"code":3458' not in str(e):
raise RuntimeError(e) from e
print(f"Job limit reached. Retrying in {retry_delay_seconds}s.")
time.sleep(retry_delay_seconds)
raise RuntimeError(
f"Failed to submit job in {elapsed_seconds}s due to backend job " "limit."
)
return _execute
def create_ibmq_runner(
api_token: str,
backend_name: str,
hub: str = "ibm-q",
group: str = "open",
project: str = "main",
noise_model: Optional[NoiseModel] = None,
basis_gates: Optional[List[str]] = None,
optimization_level: int = 0,
seed: Optional[int] = None,
retry_delay_seconds: int = 60,
retry_timeout_seconds: int = 24 * 60 * 60, # default timeout of one day
discard_extra_measurements=False,
):
provider = get_provider(api_token=api_token, hub=hub, group=group, project=project)
backend = provider.get_backend(name=backend_name)
return QiskitRunner(
backend,
noise_model=noise_model,
basis_gates=basis_gates,
optimization_level=optimization_level,
seed=seed,
execute_function=_execute_on_ibmq_with_retries(
retry_delay_seconds, retry_timeout_seconds
),
discard_extra_measurements=discard_extra_measurements,
)
|
https://github.com/Simultonian/hamilutor-qiskit
|
Simultonian
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# pylint: disable=wrong-import-order
"""Main Qiskit public functionality."""
import pkgutil
# First, check for required Python and API version
from . import util
# qiskit errors operator
from .exceptions import QiskitError
# The main qiskit operators
from qiskit.circuit import ClassicalRegister
from qiskit.circuit import QuantumRegister
from qiskit.circuit import QuantumCircuit
# pylint: disable=redefined-builtin
from qiskit.tools.compiler import compile # TODO remove after 0.8
from qiskit.execute import execute
# The qiskit.extensions.x imports needs to be placed here due to the
# mechanism for adding gates dynamically.
import qiskit.extensions
import qiskit.circuit.measure
import qiskit.circuit.reset
# Allow extending this namespace. Please note that currently this line needs
# to be placed *before* the wrapper imports or any non-import code AND *before*
# importing the package you want to allow extensions for (in this case `backends`).
__path__ = pkgutil.extend_path(__path__, __name__)
# Please note these are global instances, not modules.
from qiskit.providers.basicaer import BasicAer
# Try to import the Aer provider if installed.
try:
from qiskit.providers.aer import Aer
except ImportError:
pass
# Try to import the IBMQ provider if installed.
try:
from qiskit.providers.ibmq import IBMQ
except ImportError:
pass
from .version import __version__
from .version import __qiskit_version__
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
# load necessary Runtime libraries
from qiskit_ibm_runtime import QiskitRuntimeService, Sampler, Session
backend = "ibmq_qasm_simulator" # use the simulator
from qiskit.circuit import Parameter
from qiskit.opflow import I, X, Z
mu = Parameter('$\\mu$')
ham_pauli = mu * X
cc = Parameter('$c$')
ww = Parameter('$\\omega$')
ham_res = -(1/2)*ww*(I^Z) + cc*(X^X) + (ham_pauli^I)
tt = Parameter('$t$')
U_ham = (tt*ham_res).exp_i()
from qiskit import transpile
from qiskit.circuit import ClassicalRegister
from qiskit.opflow import PauliTrotterEvolution, Suzuki
import numpy as np
num_trot_steps = 5
total_time = 10
cr = ClassicalRegister(1, 'c')
spec_op = PauliTrotterEvolution(trotter_mode=Suzuki(order=2, reps=num_trot_steps)).convert(U_ham)
spec_circ = spec_op.to_circuit()
spec_circ_t = transpile(spec_circ, basis_gates=['sx', 'rz', 'cx'])
spec_circ_t.add_register(cr)
spec_circ_t.measure(0, cr[0])
spec_circ_t.draw('mpl')
# fixed Parameters
fixed_params = {
cc: 0.3,
mu: 0.7,
tt: total_time
}
# Parameter value for single circuit
param_keys = list(spec_circ_t.parameters)
# run through all the ww values to create a List of Lists of Parameter value
num_pts = 101
wvals = np.linspace(-2, 2, num_pts)
param_vals = []
for wval in wvals:
all_params = {**fixed_params, **{ww: wval}}
param_vals.append([all_params[key] for key in param_keys])
with Session(backend=backend):
sampler = Sampler()
job = sampler.run(
circuits=[spec_circ_t]*num_pts,
parameter_values=param_vals,
shots=1e5
)
result = job.result()
Zexps = []
for dist in result.quasi_dists:
if 1 in dist:
Zexps.append(1 - 2*dist[1])
else:
Zexps.append(1)
from qiskit.opflow import PauliExpectation, Zero
param_bind = {
cc: 0.3,
mu: 0.7,
tt: total_time
}
init_state = Zero^2
obsv = I^Z
Zexp_exact = (U_ham @ init_state).adjoint() @ obsv @ (U_ham @ init_state)
diag_meas_op = PauliExpectation().convert(Zexp_exact)
Zexact_values = []
for w_set in wvals:
param_bind[ww] = w_set
Zexact_values.append(np.real(diag_meas_op.bind_parameters(param_bind).eval()))
import matplotlib.pyplot as plt
plt.style.use('dark_background')
fig, ax = plt.subplots(dpi=100)
ax.plot([-param_bind[mu], -param_bind[mu]], [0, 1], ls='--', color='purple')
ax.plot([param_bind[mu], param_bind[mu]], [0, 1], ls='--', color='purple')
ax.plot(wvals, Zexact_values, label='Exact')
ax.plot(wvals, Zexps, label=f"{backend}")
ax.set_xlabel(r'$\omega$ (arb)')
ax.set_ylabel(r'$\langle Z \rangle$ Expectation')
ax.legend()
import qiskit_ibm_runtime
qiskit_ibm_runtime.version.get_version_info()
from qiskit.tools.jupyter import *
%qiskit_version_table
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""
Tests for the CrosstalkAdaptiveSchedule transpiler pass.
"""
import unittest
from datetime import datetime
from qiskit import QuantumRegister, QuantumCircuit
from qiskit.transpiler import Layout
from qiskit.transpiler.passes.optimization import CrosstalkAdaptiveSchedule
from qiskit.converters import circuit_to_dag
from qiskit.test import QiskitTestCase
from qiskit.compiler import transpile
from qiskit.providers.models import BackendProperties
from qiskit.providers.models.backendproperties import Nduv, Gate
from qiskit.utils import optionals
def make_noisy_qubit(t_1=50.0, t_2=50.0):
"""Create a qubit for BackendProperties"""
calib_time = datetime(year=2019, month=2, day=1, hour=0, minute=0, second=0)
return [
Nduv(name="T1", date=calib_time, unit="µs", value=t_1),
Nduv(name="T2", date=calib_time, unit="µs", value=t_2),
Nduv(name="frequency", date=calib_time, unit="GHz", value=5.0),
Nduv(name="readout_error", date=calib_time, unit="", value=0.01),
]
def create_fake_machine():
"""Create a 6 qubit machine to test crosstalk adaptive schedules"""
calib_time = datetime(year=2019, month=2, day=1, hour=0, minute=0, second=0)
qubit_list = []
for _ in range(6):
qubit_list.append(make_noisy_qubit())
cx01 = [
Nduv(date=calib_time, name="gate_error", unit="", value=0.05),
Nduv(date=calib_time, name="gate_length", unit="ns", value=500.0),
]
cx12 = [
Nduv(date=calib_time, name="gate_error", unit="", value=0.05),
Nduv(date=calib_time, name="gate_length", unit="ns", value=501.0),
]
cx23 = [
Nduv(date=calib_time, name="gate_error", unit="", value=0.05),
Nduv(date=calib_time, name="gate_length", unit="ns", value=502.0),
]
cx34 = [
Nduv(date=calib_time, name="gate_error", unit="", value=0.05),
Nduv(date=calib_time, name="gate_length", unit="ns", value=503.0),
]
cx45 = [
Nduv(date=calib_time, name="gate_error", unit="", value=0.05),
Nduv(date=calib_time, name="gate_length", unit="ns", value=504.0),
]
gcx01 = Gate(name="CX0_1", gate="cx", parameters=cx01, qubits=[0, 1])
gcx12 = Gate(name="CX1_2", gate="cx", parameters=cx12, qubits=[1, 2])
gcx23 = Gate(name="CX2_3", gate="cx", parameters=cx23, qubits=[2, 3])
gcx34 = Gate(name="CX3_4", gate="cx", parameters=cx34, qubits=[3, 4])
gcx45 = Gate(name="CX4_5", gate="cx", parameters=cx45, qubits=[4, 5])
u_1 = [
Nduv(date=calib_time, name="gate_error", unit="", value=0.001),
Nduv(date=calib_time, name="gate_length", unit="ns", value=100.0),
]
gu10 = Gate(name="u1_0", gate="u1", parameters=u_1, qubits=[0])
gu11 = Gate(name="u1_1", gate="u1", parameters=u_1, qubits=[1])
gu12 = Gate(name="u1_2", gate="u1", parameters=u_1, qubits=[2])
gu13 = Gate(name="u1_3", gate="u1", parameters=u_1, qubits=[3])
gu14 = Gate(name="u1_4", gate="u1", parameters=u_1, qubits=[4])
gu15 = Gate(name="u1_4", gate="u1", parameters=u_1, qubits=[5])
u_2 = [
Nduv(date=calib_time, name="gate_error", unit="", value=0.001),
Nduv(date=calib_time, name="gate_length", unit="ns", value=100.0),
]
gu20 = Gate(name="u2_0", gate="u2", parameters=u_2, qubits=[0])
gu21 = Gate(name="u2_1", gate="u2", parameters=u_2, qubits=[1])
gu22 = Gate(name="u2_2", gate="u2", parameters=u_2, qubits=[2])
gu23 = Gate(name="u2_3", gate="u2", parameters=u_2, qubits=[3])
gu24 = Gate(name="u2_4", gate="u2", parameters=u_2, qubits=[4])
gu25 = Gate(name="u2_4", gate="u2", parameters=u_2, qubits=[5])
u_3 = [
Nduv(date=calib_time, name="gate_error", unit="", value=0.001),
Nduv(date=calib_time, name="gate_length", unit="ns", value=100.0),
]
gu30 = Gate(name="u3_0", gate="u3", parameters=u_3, qubits=[0])
gu31 = Gate(name="u3_1", gate="u3", parameters=u_3, qubits=[1])
gu32 = Gate(name="u3_2", gate="u3", parameters=u_3, qubits=[2])
gu33 = Gate(name="u3_3", gate="u3", parameters=u_3, qubits=[3])
gu34 = Gate(name="u3_4", gate="u3", parameters=u_3, qubits=[4])
gu35 = Gate(name="u3_5", gate="u3", parameters=u_3, qubits=[5])
gate_list = [
gcx01,
gcx12,
gcx23,
gcx34,
gcx45,
gu10,
gu11,
gu12,
gu13,
gu14,
gu15,
gu20,
gu21,
gu22,
gu23,
gu24,
gu25,
gu30,
gu31,
gu32,
gu33,
gu34,
gu35,
]
bprop = BackendProperties(
last_update_date=calib_time,
backend_name="test_backend",
qubits=qubit_list,
backend_version="1.0.0",
gates=gate_list,
general=[],
)
return bprop
@unittest.skipIf(not optionals.HAS_Z3, "z3-solver not installed.")
class TestCrosstalk(QiskitTestCase):
"""
Tests for crosstalk adaptivity
"""
def test_schedule_length1(self):
"""Testing with high crosstalk between CNOT 0,1 and CNOT 2,3"""
bprop = create_fake_machine()
crosstalk_prop = {}
crosstalk_prop[(0, 1)] = {(2, 3): 0.2}
crosstalk_prop[(2, 3)] = {(0, 1): 0.05, (4, 5): 0.05}
crosstalk_prop[(4, 5)] = {(2, 3): 0.05}
crosstalk_prop[(1, 2)] = {(3, 4): 0.05}
crosstalk_prop[(3, 4)] = {(1, 2): 0.05}
qr = QuantumRegister(6, "q")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.cx(qr[2], qr[3])
mapping = [0, 1, 2, 3, 4, 5]
layout = Layout({qr[i]: mapping[i] for i in range(6)})
new_circ = transpile(circuit, initial_layout=layout, basis_gates=["u1", "u2", "u3", "cx"])
dag = circuit_to_dag(new_circ)
pass_ = CrosstalkAdaptiveSchedule(bprop, crosstalk_prop)
scheduled_dag = pass_.run(dag)
self.assertEqual(scheduled_dag.depth(), 3)
def test_schedule_length2(self):
"""Testing with no crosstalk between CNOT 0,1 and CNOT 2,3"""
bprop = create_fake_machine()
crosstalk_prop = {}
crosstalk_prop[(0, 1)] = {(2, 3): 0.05}
crosstalk_prop[(2, 3)] = {(0, 1): 0.05, (4, 5): 0.05}
crosstalk_prop[(4, 5)] = {(2, 3): 0.05}
crosstalk_prop[(1, 2)] = {(3, 4): 0.05}
crosstalk_prop[(3, 4)] = {(1, 2): 0.05}
qr = QuantumRegister(6, "q")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.cx(qr[2], qr[3])
mapping = [0, 1, 2, 3, 4, 5]
layout = Layout({qr[i]: mapping[i] for i in range(6)})
new_circ = transpile(circuit, initial_layout=layout, basis_gates=["u1", "u2", "u3", "cx"])
dag = circuit_to_dag(new_circ)
pass_ = CrosstalkAdaptiveSchedule(bprop, crosstalk_prop)
scheduled_dag = pass_.run(dag)
self.assertEqual(scheduled_dag.depth(), 1)
def test_schedule_length3(self):
"""Testing with repeated calls to run"""
bprop = create_fake_machine()
crosstalk_prop = {}
crosstalk_prop[(0, 1)] = {(2, 3): 0.2}
crosstalk_prop[(2, 3)] = {(0, 1): 0.05, (4, 5): 0.05}
crosstalk_prop[(4, 5)] = {(2, 3): 0.05}
crosstalk_prop[(1, 2)] = {(3, 4): 0.05}
crosstalk_prop[(3, 4)] = {(1, 2): 0.05}
qr = QuantumRegister(6, "q")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.cx(qr[2], qr[3])
mapping = [0, 1, 2, 3, 4, 5]
layout = Layout({qr[i]: mapping[i] for i in range(6)})
new_circ = transpile(circuit, initial_layout=layout, basis_gates=["u1", "u2", "u3", "cx"])
dag = circuit_to_dag(new_circ)
pass_ = CrosstalkAdaptiveSchedule(bprop, crosstalk_prop)
scheduled_dag1 = pass_.run(dag)
scheduled_dag2 = pass_.run(dag)
self.assertEqual(scheduled_dag1.depth(), 3)
self.assertEqual(scheduled_dag2.depth(), 3)
if __name__ == "__main__":
unittest.main()
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
from qiskit import *
thc, phc, lbc = math.pi/2, 0, 0; tha, pha, lba = math.pi/2, math.pi/4, math.pi/8
qc = QuantumCircuit(2, 1); qc.u(thc, phc, lbc, 0); qc.u(tha, pha, lba, 1)
qc.cx(0, 1); qc.measure(0, 0); qc.draw()
|
https://github.com/msramalho/Teach-Me-Quantum
|
msramalho
|
# useful additional packages
import matplotlib.pyplot as plt
import matplotlib.axes as axes
%matplotlib inline
import numpy as np
import networkx as nx
from qiskit.tools.visualization import plot_histogram
from qiskit_aqua import Operator, run_algorithm, get_algorithm_instance
from qiskit_aqua.input import get_input_instance
from qiskit_aqua.translators.ising import maxcut, tsp
# setup aqua logging
import logging
from qiskit_aqua._logging import set_logging_config, build_logging_config
# set_logging_config(build_logging_config(logging.DEBUG)) # choose INFO, DEBUG to see the log
# ignoring deprecation errors on matplotlib
import warnings
import matplotlib.cbook
warnings.filterwarnings("ignore",category=matplotlib.cbook.mplDeprecation)
from qiskit import IBMQ
IBMQ.load_accounts()
# Generating a graph of 3 nodes
n = 3
num_qubits = n ** 2
ins = tsp.random_tsp(n)
G = nx.Graph()
G.add_nodes_from(np.arange(0, n, 1))
colors = ['r' for node in G.nodes()]
pos = {k: v for k, v in enumerate(ins.coord)}
default_axes = plt.axes(frameon=True)
nx.draw_networkx(G, node_color=colors, node_size=600, alpha=.8, ax=default_axes, pos=pos)
print('distance\n', ins.w)
from itertools import permutations
def brute_force_tsp(w, N):
a=list(permutations(range(1,N)))
last_best_distance = 1e10
for i in a:
distance = 0
pre_j = 0
for j in i:
distance = distance + w[j,pre_j]
pre_j = j
distance = distance + w[pre_j,0]
order = (0,) + i
if distance < last_best_distance:
best_order = order
last_best_distance = distance
print('order = ' + str(order) + ' Distance = ' + str(distance))
return last_best_distance, best_order
best_distance, best_order = brute_force_tsp(ins.w, ins.dim)
print('Best order from brute force = ' + str(best_order) + ' with total distance = ' + str(best_distance))
def draw_tsp_solution(G, order, colors, pos):
G2 = G.copy()
n = len(order)
for i in range(n):
j = (i + 1) % n
G2.add_edge(order[i], order[j])
default_axes = plt.axes(frameon=True)
nx.draw_networkx(G2, node_color=colors, node_size=600, alpha=.8, ax=default_axes, pos=pos)
draw_tsp_solution(G, best_order, colors, pos)
qubitOp, offset = tsp.get_tsp_qubitops(ins)
algo_input = get_input_instance('EnergyInput')
algo_input.qubit_op = qubitOp
#Making the Hamiltonian in its full form and getting the lowest eigenvalue and eigenvector
algorithm_cfg = {
'name': 'ExactEigensolver',
}
params = {
'problem': {'name': 'ising'},
'algorithm': algorithm_cfg
}
result = run_algorithm(params,algo_input)
print('energy:', result['energy'])
#print('tsp objective:', result['energy'] + offset)
x = tsp.sample_most_likely(result['eigvecs'][0])
print('feasible:', tsp.tsp_feasible(x))
z = tsp.get_tsp_solution(x)
print('solution:', z)
print('solution objective:', tsp.tsp_value(z, ins.w))
draw_tsp_solution(G, z, colors, pos)
algorithm_cfg = {
'name': 'VQE',
'operator_mode': 'matrix'
}
optimizer_cfg = {
'name': 'SPSA',
'max_trials': 300
}
var_form_cfg = {
'name': 'RY',
'depth': 5,
'entanglement': 'linear'
}
params = {
'problem': {'name': 'ising', 'random_seed': 10598},
'algorithm': algorithm_cfg,
'optimizer': optimizer_cfg,
'variational_form': var_form_cfg,
'backend': {'name': 'statevector_simulator'}
}
result = run_algorithm(params,algo_input)
print('energy:', result['energy'])
print('time:', result['eval_time'])
#print('tsp objective:', result['energy'] + offset)
x = tsp.sample_most_likely(result['eigvecs'][0])
print('feasible:', tsp.tsp_feasible(x))
z = tsp.get_tsp_solution(x)
print('solution:', z)
print('solution objective:', tsp.tsp_value(z, ins.w))
draw_tsp_solution(G, z, colors, pos)
# run quantum algorithm with shots
params['algorithm']['operator_mode'] = 'grouped_paulis'
params['backend']['name'] = 'qasm_simulator'
params['backend']['shots'] = 1024
result = run_algorithm(params,algo_input)
print('energy:', result['energy'])
print('time:', result['eval_time'])
#print('tsp objective:', result['energy'] + offset)
x = tsp.sample_most_likely(result['eigvecs'][0])
print('feasible:', tsp.tsp_feasible(x))
z = tsp.get_tsp_solution(x)
print('solution:', z)
print('solution objective:', tsp.tsp_value(z, ins.w))
plot_histogram(result['eigvecs'][0])
draw_tsp_solution(G, z, colors, pos)
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
from collections import OrderedDict
import time
import os
import logging
from qiskit.optimization.algorithms import CplexOptimizer
from qiskit.optimization.algorithms.optimization_algorithm import OptimizationResultStatus
from dwave.system import LeapHybridSampler
from random_lp.lp_random_gen import create_models
from utilities.helpers import create_dwave_meo
TEST_DIR = 'TEST_DATA' + "/" + time.strftime("%d_%m_%Y") + "/SPARSE/"
RES_DIR = 'RESULTS' + "/" + time.strftime("%d_%m_%Y") + "/SPARSE/"
os.makedirs(RES_DIR, exist_ok=True)
TEST_DIR
logger = logging.getLogger()
logger.setLevel(logging.INFO)
qps = create_models(TEST_DIR)
# init Optimizers
cplex = CplexOptimizer()
hybrid = create_dwave_meo(LeapHybridSampler())
dwave = create_dwave_meo(num_reads=1000)
results = OrderedDict()
count_fail_hybrid, count_fail_dwave = 0, 0
for qp_name, qp in qps.items() :
print(qp_name)
print("number of qubits: ", qp.qubo.get_num_vars())
output_file_handler = logging.FileHandler(filename=RES_DIR + qp.name + ".log")
logger.addHandler(output_file_handler)
with open(RES_DIR + qp.name + '.res', 'w') as file:
file.write(str("Start " + qp.name + "\n " + str(qp.qubo.get_num_vars()) + " qubits needed"))
file.write("\n Leap: \n")
logger.info("\n Leap: \n ")
res_classic = cplex.solve(qp)
res_hybrid = hybrid.solve(qp)
problem_id = str(res_hybrid.min_eigen_solver_result.sampleset.info['problem_id'])
logger.info("\n problem id " + problem_id)
file.write("\n problem id: " + problem_id)
if res_hybrid.status != OptimizationResultStatus.SUCCESS:
file.write("\n No solution found with DWave Hybrid Sampler Leap.\n")
file.write("\n CPLEX:\n")
file.write(str(res_classic))
count_fail_hybrid = count_fail_hybrid + 1
if count_fail_hybrid > 2 :
break
else:
print("Leap successful!")
count_fail_hybrid = 0
if res_hybrid.fval == res_classic.fval:
file.write("\n Leap found optimal solution\n")
else:
print("\n optimal value Leap "+str(res_hybrid.fval) + " , cplex:"+ str(res_classic.fval))
file.write("\n Leap: \n")
file.write(str(res_hybrid))
file.write("\n CPLEX:\n")
file.write(str(res_classic))
if count_fail_dwave <= 2:
file.write("\n DWave Quantum: \n")
logger.info("\n DWave Quantum: \n ")
try:
res_quantum = dwave.solve(qp)
problem_id = str(res_quantum.min_eigen_solver_result.sampleset.info['problem_id'])
logger.info("\n problem id " + problem_id)
file.write("\n problem id: " + problem_id)
if res_quantum.status != OptimizationResultStatus.SUCCESS:
print("Dwave quantum solver found no solution.")
file.write("\n No solution found with DWave Quantum Solver \n")
count_fail_dwave = count_fail_dwave + 1
if count_fail_dwave == 3:
file.write("\n Stop testing DWave Quantum Solver \n")
else:
print("Dwave Quantum successful!")
count_fail_dwave = 0
if res_quantum.fval == res_classic.fval:
file.write("\n DWave quantum solver found optimal solution\n")
else:
print("\n optimal value Dwave quantum "+str(res_quantum.fval) + " , cplex:"+ str(res_classic.fval))
file.write("\n DWave quantum solver:\n")
file.write(str(res_quantum))
file.write("\n CPLEX:\n")
file.write(str(res_classic))
except Exception as ex:
print(qp_name, " ", type(ex).__name__, " : ", ex)
file.write("\n DWave Solver produced an exception:\n")
file.write(str(ex))
logger.removeHandler(output_file_handler)
# see Class SubstituteVariables in https://qiskit.org/documentation/_modules/qiskit/optimization/problems/quadratic_program.html#QuadraticProgram
# for logger warning constraint A0_leb0 is infeasible due to substitution
# Afterwards a check for feasability of substituted solution is done to set OptimizationResultStatus
|
https://github.com/lynnlangit/learning-quantum
|
lynnlangit
|
## import qiskit.tools.jupyter
## %qiskit_version_table
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import numpy as np
from qiskit import pulse
d0 = pulse.DriveChannel(0)
x90 = pulse.Gaussian(10, 0.1, 3)
x180 = pulse.Gaussian(10, 0.2, 3)
def udd10_pos(j):
return np.sin(np.pi*j/(2*10 + 2))**2
with pulse.build() as udd_sched:
pulse.play(x90, d0)
with pulse.align_func(duration=300, func=udd10_pos):
for _ in range(10):
pulse.play(x180, d0)
pulse.play(x90, d0)
udd_sched.draw()
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import numpy as np
from qiskit import *
from qiskit.circuit import Gate
my_gate = Gate(name='my_gate', num_qubits=2, params=[])
qr = QuantumRegister(3, 'q')
circ = QuantumCircuit(qr)
circ.append(my_gate, [qr[0], qr[1]])
circ.append(my_gate, [qr[1], qr[2]])
circ.draw()
# Build a sub-circuit
sub_q = QuantumRegister(2)
sub_circ = QuantumCircuit(sub_q, name='sub_circ')
sub_circ.h(sub_q[0])
sub_circ.crz(1, sub_q[0], sub_q[1])
sub_circ.barrier()
sub_circ.id(sub_q[1])
sub_circ.u(1, 2, -2, sub_q[0])
# Convert to a gate and stick it into an arbitrary place in the bigger circuit
sub_inst = sub_circ.to_instruction()
qr = QuantumRegister(3, 'q')
circ = QuantumCircuit(qr)
circ.h(qr[0])
circ.cx(qr[0], qr[1])
circ.cx(qr[1], qr[2])
circ.append(sub_inst, [qr[1], qr[2]])
circ.draw()
decomposed_circ = circ.decompose() # Does not modify original circuit
decomposed_circ.draw()
from qiskit.circuit import Parameter
theta = Parameter('θ')
n = 5
qc = QuantumCircuit(5, 1)
qc.h(0)
for i in range(n-1):
qc.cx(i, i+1)
qc.barrier()
qc.rz(theta, range(5))
qc.barrier()
for i in reversed(range(n-1)):
qc.cx(i, i+1)
qc.h(0)
qc.measure(0, 0)
qc.draw('mpl')
print(qc.parameters)
import numpy as np
theta_range = np.linspace(0, 2 * np.pi, 128)
circuits = [qc.bind_parameters({theta: theta_val})
for theta_val in theta_range]
circuits[-1].draw()
backend = BasicAer.get_backend('qasm_simulator')
job = backend.run(transpile(circuits, backend))
counts = job.result().get_counts()
import matplotlib.pyplot as plt
fig = plt.figure(figsize=(8,6))
ax = fig.add_subplot(111)
ax.plot(theta_range, list(map(lambda c: c.get('0', 0), counts)), '.-', label='0')
ax.plot(theta_range, list(map(lambda c: c.get('1', 0), counts)), '.-', label='1')
ax.set_xticks([i * np.pi / 2 for i in range(5)])
ax.set_xticklabels(['0', r'$\frac{\pi}{2}$', r'$\pi$', r'$\frac{3\pi}{2}$', r'$2\pi$'], fontsize=14)
ax.set_xlabel('θ', fontsize=14)
ax.set_ylabel('Counts', fontsize=14)
ax.legend(fontsize=14)
import time
from itertools import combinations
from qiskit.compiler import assemble
from qiskit.test.mock import FakeVigo
start = time.time()
qcs = []
theta_range = np.linspace(0, 2*np.pi, 32)
for n in theta_range:
qc = QuantumCircuit(5)
for k in range(8):
for i,j in combinations(range(5), 2):
qc.cx(i,j)
qc.rz(n, range(5))
for i,j in combinations(range(5), 2):
qc.cx(i,j)
qcs.append(qc)
compiled_circuits = transpile(qcs, backend=FakeVigo())
qobj = assemble(compiled_circuits, backend=FakeVigo())
end = time.time()
print('Time compiling over set of bound circuits: ', end-start)
start = time.time()
qc = QuantumCircuit(5)
theta = Parameter('theta')
for k in range(8):
for i,j in combinations(range(5), 2):
qc.cx(i,j)
qc.rz(theta, range(5))
for i,j in combinations(range(5), 2):
qc.cx(i,j)
transpiled_qc = transpile(qc, backend=FakeVigo())
qobj = assemble([transpiled_qc.bind_parameters({theta: n})
for n in theta_range], backend=FakeVigo())
end = time.time()
print('Time compiling over parameterized circuit, then binding: ', end-start)
phi = Parameter('phi')
sub_circ1 = QuantumCircuit(2, name='sc_1')
sub_circ1.rz(phi, 0)
sub_circ1.rx(phi, 1)
sub_circ2 = QuantumCircuit(2, name='sc_2')
sub_circ2.rx(phi, 0)
sub_circ2.rz(phi, 1)
qc = QuantumCircuit(4)
qr = qc.qregs[0]
qc.append(sub_circ1.to_instruction(), [qr[0], qr[1]])
qc.append(sub_circ2.to_instruction(), [qr[0], qr[1]])
qc.append(sub_circ2.to_instruction(), [qr[2], qr[3]])
print(qc.draw())
# The following raises an error: "QiskitError: 'Name conflict on adding parameter: phi'"
# phi2 = Parameter('phi')
# qc.u3(0.1, phi2, 0.3, 0)
p = Parameter('p')
qc = QuantumCircuit(3, name='oracle')
qc.rz(p, 0)
qc.cx(0, 1)
qc.rz(p, 1)
qc.cx(1, 2)
qc.rz(p, 2)
theta = Parameter('theta')
phi = Parameter('phi')
gamma = Parameter('gamma')
qr = QuantumRegister(9)
larger_qc = QuantumCircuit(qr)
larger_qc.append(qc.to_instruction({p: theta}), qr[0:3])
larger_qc.append(qc.to_instruction({p: phi}), qr[3:6])
larger_qc.append(qc.to_instruction({p: gamma}), qr[6:9])
print(larger_qc.draw())
print(larger_qc.decompose().draw())
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/DaisukeIto-ynu/KosakaQ
|
DaisukeIto-ynu
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2018, 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""
Simulator command to snapshot internal simulator representation.
"""
from warnings import warn
import math
import numpy
from qiskit import QuantumCircuit
from qiskit.circuit import Instruction
from qiskit.extensions.exceptions import ExtensionError
from qiskit.qobj import QasmQobjInstruction
from qiskit.quantum_info.operators import Pauli, Operator
from .snapshot import Snapshot
class SnapshotExpectationValue(Snapshot):
"""Snapshot instruction for supported methods of Qasm simulator."""
def __init__(self, label, op, single_shot=False, variance=False):
"""Create an expectation value snapshot instruction.
Args:
label (str): the snapshot label.
op (Operator): operator to snapshot.
single_shot (bool): return list for each shot rather than average [Default: False]
variance (bool): compute variance of values [Default: False]
Raises:
ExtensionError: if snapshot is invalid.
.. deprecated:: 0.9.0
This instruction has been deprecated and will be removed no earlier
than 3 months from the 0.9.0 release date. It has been superseded by the
:class:`qiskit.providers.aer.library.SaveExpectationValue` and
:class:`qiskit.providers.aer.library.SaveExpectationValueVariance`
instructions.
"""
warn('The `SnapshotExpectationValue` instruction has been deprecated as of'
' qiskit-aer 0.9. It has been superseded by the `SaveExpectationValue` and'
' `SaveExpectationValueVariance` instructions.',
DeprecationWarning, stacklevel=2)
pauli_op = self._format_pauli_op(op)
if pauli_op:
# Pauli expectation value
snapshot_type = 'expectation_value_pauli'
params = pauli_op
num_qubits = len(params[0][1])
else:
snapshot_type = 'expectation_value_matrix'
mat = self._format_single_matrix(op)
if mat is not None:
num_qubits = int(math.log2(len(mat)))
if mat.shape != (2 ** num_qubits, 2 ** num_qubits):
raise ExtensionError("Snapshot Operator is invalid.")
qubits = list(range(num_qubits))
params = [[1., [[qubits, mat]]]]
else:
# If op doesn't match the previous cases we try passing
# in the op as raw params
params = op
num_qubits = 0
for _, pair in params:
num_qubits = max(num_qubits, *pair[0])
# HACK: we wrap param list in numpy array to make it validate
# in terra
params = [numpy.array(elt, dtype=object) for elt in params]
if single_shot:
snapshot_type += '_single_shot'
elif variance:
snapshot_type += '_with_variance'
super().__init__(label,
snapshot_type=snapshot_type,
num_qubits=num_qubits,
params=params)
@staticmethod
def _format_single_matrix(op):
"""Format op into Matrix op, return None if not Pauli op"""
# This can be specified as list [[coeff, Pauli], ... ]
if isinstance(op, numpy.ndarray):
return op
if isinstance(op, (Instruction, QuantumCircuit)):
return Operator(op).data
if hasattr(op, 'to_operator'):
return op.to_operator().data
return None
@staticmethod
def _format_pauli_op(op):
"""Format op into Pauli op, return None if not Pauli op"""
# This can be specified as list [[coeff, Pauli], ... ]
if isinstance(op, Pauli):
return [[1., op.to_label()]]
if not isinstance(op, (list, tuple)):
return None
pauli_op = []
for pair in op:
if len(pair) != 2:
return None
coeff = complex(pair[0])
pauli = pair[1]
if isinstance(pauli, Pauli):
pauli_op.append([coeff, pauli.to_label()])
elif isinstance(pair[1], str):
pauli_op.append([coeff, pauli])
else:
return None
return pauli_op
def assemble(self):
"""Assemble a QasmQobjInstruction for snapshot_expectation_value."""
return QasmQobjInstruction(name=self.name,
params=[x.tolist() for x in self.params],
snapshot_type=self.snapshot_type,
qubits=list(range(self.num_qubits)),
label=self.label)
def snapshot_expectation_value(self, label, op, qubits,
single_shot=False,
variance=False):
"""Take a snapshot of expectation value <O> of an Operator.
Args:
label (str): a snapshot label to report the result
op (Operator): operator to snapshot
qubits (list): the qubits to snapshot.
single_shot (bool): return list for each shot rather than average [Default: False]
variance (bool): compute variance of values [Default: False]
Returns:
QuantumCircuit: with attached instruction.
Raises:
ExtensionError: if snapshot is invalid.
.. deprecated:: 0.9.0
This instruction has been deprecated and will be removed no earlier
than 3 months from the 0.9.0 release date. It has been superseded by the
:func:`qiskit.providers.aer.library.save_expectation_value` and
:func:`qiskit.providers.aer.library.save_expectation_value_variance`
circuit methods.
"""
warn('The `snapshot_expectation_value` circuit method has been deprecated as of'
' qiskit-aer 0.9 and will be removed in a future release.'
' It has been superseded by the `save_expectation_value`'
' and `save_expectation_value_variance` circuit methods.',
DeprecationWarning, stacklevel=2)
snapshot_register = Snapshot.define_snapshot_register(self, qubits=qubits)
return self.append(
SnapshotExpectationValue(label, op,
single_shot=single_shot,
variance=variance),
snapshot_register)
QuantumCircuit.snapshot_expectation_value = snapshot_expectation_value
|
https://github.com/minnukota381/Quantum-Computing-Qiskit
|
minnukota381
|
import numpy as np
a = np.array([2, 6])
b = np.array([3, 10])
print("Vectors :")
print("a = ", a)
print("\nb = ", b)
print("\nOuter product of vectors a and b =")
print(np.outer(a, b))
print("------------------------------------")
x = np.array([[3, 6, 4], [9, 4, 6]])
y = np.array([[1, 15, 7], [3, 10, 8]])
print("\nMatrices :")
print("x =", x)
print("\ny =", y)
print("\nOuter product of matrices x and y =")
print(np.outer(x, y))
|
https://github.com/mentesniker/Quantum-error-mitigation
|
mentesniker
|
# Import libraries for use
from qiskit import *
import numpy as np
from random import random
from qiskit.extensions import Initialize
from qiskit.visualization import plot_histogram, plot_bloch_multivector
from qiskit_textbook.tools import random_state, array_to_latex
## SETUP
# Protocol uses 4 qubits and 1 classical bit in a register
qr = QuantumRegister(4, name="q") # Protocol uses 4 qubits
cr = ClassicalRegister(1, name="cr") # and 1 classical bit cr
sign_flip_circuit = QuantumCircuit(qr, cr)
def encoding(qc, q0, q1, q2):
"""Creates encoding process using qubits q0 & q1 & q2"""
qc.cx(q0,q1) # CNOT with q1 as control and q0 as target (Use q1 to control q0.)
qc.cx(q0,q2) # CNOT with q2 as control and q0 as target
# initialization instruction to create
# |ψ⟩ from the state |0⟩:
p = 1 # p stands for the probability of sign-fliping the state of the qubit
psi = [np.sqrt(1-p), np.sqrt(p)]
init_gate = Initialize(psi) # initialize the superposition state
init_gate.label = "init"
def error_simulation(qc, q0, q1, q2, q3):
"""Creates error simulation using qubits q0 & q1 & q2 & q3"""
qc.append(init_gate, [3]) # create the superposition state for |q3>
measure(qc, 3, 0) # measure the state on |q3>
qc.z(q0).c_if(cr, 1) # apply z gate on q0 if |1> was measured by |q3>
qc.append(init_gate, [3])
measure(qc, 3, 0)
qc.z(q1).c_if(cr, 1) # apply z gate on q1 if |1> was measured by |q3>
qc.append(init_gate, [3])
measure(qc, 3, 0)
qc.z(q2).c_if(cr, 1) # apply z gate on q2 if |1> was measured by |q3>
def measure(qc, q0, cr):
"""Measures qubit q0 """
qc.barrier()
qc.measure(q0,cr)
def decoding(qc, q0, q1, q2):
"""Creates decoding process using qubits q0 & q1 & q2"""
qc.cx(q0,q1) # CNOT with q1 as control and q0 as target
qc.cx(q0,q2) # CNOT with q2 as control and q0 as target
qc.ccx(q2,q1,q0) # Apply a Toffoli gate |011> <-> |111>
# Let's apply the process above to our circuit:
# step 0. input |0> -> |+>
sign_flip_circuit.h(0)
# step 1. encoding
encoding(sign_flip_circuit, 0, 1, 2)
sign_flip_circuit.h(0)
sign_flip_circuit.h(1)
sign_flip_circuit.h(2)
# step 2. error simulation
error_simulation(sign_flip_circuit, 0, 1, 2, p)
sign_flip_circuit.barrier()
# step 3. decoding
sign_flip_circuit.h(0)
sign_flip_circuit.h(1)
sign_flip_circuit.h(2)
decoding(sign_flip_circuit, 0, 1, 2)
# step 4. measurement
sign_flip_circuit.h(0)
measure(sign_flip_circuit, 0, 0)
# View the circuit:
%matplotlib inline
sign_flip_circuit.draw(output='mpl')
backend = BasicAer.get_backend('qasm_simulator')
counts = execute(sign_flip_circuit, backend, shots=1024).result().get_counts() # No. of measurement shots = 1024
plot_histogram(counts)
|
https://github.com/Qiskit/qiskit-transpiler-service
|
Qiskit
|
from qiskit.circuit.library import EfficientSU2
from qiskit_transpiler_service.transpiler_service import TranspilerService
circuit = EfficientSU2(101, entanglement="circular", reps=1).decompose()
cloud_transpiler_service = TranspilerService(
backend_name="ibm_sherbrooke",
ai="false",
optimization_level=3,
)
transpiled_circuit_no_ai = cloud_transpiler_service.run(circuit)
from qiskit.circuit.library import EfficientSU2
from qiskit_transpiler_service.transpiler_service import TranspilerService
circuit = EfficientSU2(101, entanglement="circular", reps=1).decompose()
cloud_transpiler_service = TranspilerService(
backend_name="ibm_sherbrooke",
ai="true",
optimization_level=1,
)
transpiled_circuit_ai = cloud_transpiler_service.run(circuit)
from qiskit.circuit.library import EfficientSU2
from qiskit_transpiler_service.transpiler_service import TranspilerService
circuit = EfficientSU2(101, entanglement="circular", reps=1).decompose()
cloud_transpiler_service = TranspilerService(
backend_name="ibm_sherbrooke",
ai="auto",
optimization_level=1,
)
transpiled_circuit_ai_auto = cloud_transpiler_service.run(circuit)
from qiskit.circuit.library import EfficientSU2
from qiskit_transpiler_service.transpiler_service import TranspilerService
circuit = EfficientSU2(101, entanglement="circular", reps=1).decompose()
cloud_transpiler_service = TranspilerService(
backend_name="ibm_sherbrooke",
ai="auto",
optimization_level=1,
)
transpiled_circuit = cloud_transpiler_service.run(circuit)
from qiskit.transpiler import PassManager
from qiskit_transpiler_service.ai.routing import AIRouting
from qiskit.circuit.library import EfficientSU2
ai_passmanager = PassManager(
[
AIRouting(
backend_name="ibm_sherbrooke", optimization_level=2, layout_mode="optimize"
)
]
)
circuit = EfficientSU2(101, entanglement="circular", reps=1).decompose()
transpiled_circuit_ai_lvl2 = ai_passmanager.run(circuit)
from qiskit.transpiler import PassManager
from qiskit_transpiler_service.ai.routing import AIRouting
from qiskit_transpiler_service.ai.synthesis import AILinearFunctionSynthesis
from qiskit_transpiler_service.ai.collection import CollectLinearFunctions
from qiskit.circuit.library import EfficientSU2
ai_passmanager = PassManager(
[
AIRouting(
backend_name="ibm_torino", optimization_level=3, layout_mode="optimize"
), # Route circuit
CollectLinearFunctions(), # Collect Linear Function blocks
AILinearFunctionSynthesis(
backend_name="ibm_torino"
), # Re-synthesize Linear Function blocks
]
)
circuit = EfficientSU2(10, entanglement="full", reps=1).decompose()
transpiled_circuit_synthesis = ai_passmanager.run(circuit)
print(
f"Depth: {transpiled_circuit_no_ai.decompose(reps=3).depth()}, Gates(2q): {transpiled_circuit_no_ai.decompose(reps=3).num_nonlocal_gates()}"
)
print(
f"Depth: {transpiled_circuit_ai.decompose(reps=3).depth()}, Gates(2q): {transpiled_circuit_ai.decompose(reps=3).num_nonlocal_gates()}"
)
print(
f"Depth: {transpiled_circuit_ai_auto.decompose(reps=3).depth()}, Gates(2q): {transpiled_circuit_ai_auto.decompose(reps=3).num_nonlocal_gates()}"
)
print(
f"Depth: {transpiled_circuit_ai_lvl2.decompose(reps=3).depth()}, Gates(2q): {transpiled_circuit_ai_lvl2.decompose(reps=3).num_nonlocal_gates()}"
)
print(
f"Depth: {transpiled_circuit_synthesis.decompose(reps=3).depth()}, Gates(2q): {transpiled_circuit_synthesis.decompose(reps=3).num_nonlocal_gates()}"
)
|
https://github.com/yaleqc/vqe-error-mitigation
|
yaleqc
|
# Imports needed for basic no noise VQE simulation
import numpy as np
import pylab
import copy
from qiskit import BasicAer
from qiskit.aqua import aqua_globals, QuantumInstance
from qiskit.aqua.algorithms import NumPyMinimumEigensolver, VQE
from qiskit.aqua.components.optimizers import SLSQP, SPSA
from qiskit.chemistry.components.initial_states import HartreeFock
from qiskit.chemistry.components.variational_forms import UCCSD
from qiskit.chemistry.drivers import PySCFDriver
from qiskit.chemistry.core import Hamiltonian, QubitMappingType
from qiskit.circuit.library import EfficientSU2
# Some deprecated package issue; one warning is enough.
import warnings
warnings.filterwarnings(action='once')
# Defining a noise model!
from qiskit import Aer
from qiskit.providers.aer.noise import NoiseModel
from qiskit.providers.aer import QasmSimulator
from qiskit.test.mock import FakeVigo
from qiskit.ignis.mitigation.measurement import CompleteMeasFitter
device_backend = FakeVigo()
# NOTE the key difference that the noisy simulations need to use
# 'qasm_simulator' rather than 'statevector_simulator'
backend = Aer.get_backend('qasm_simulator')
device = QasmSimulator.from_backend(device_backend)
coupling_map = device.configuration().coupling_map
noise_model = NoiseModel.from_backend(device)
basis_gates = noise_model.basis_gates
print(noise_model)
print()
molecule = 'H .0 .0 -{0}; Li .0 .0 {0}' # Define molecule; could be H2 or LiH, etc.
distances = np.arange(0.5, 3.75, 0.25) # Distances in Angstrom
vqe_energies = []
hf_energies = [] # Hartree-Fock energies
exact_energies = [] # Exact energies from numerical diagonalization
for i, d in enumerate(distances):
print('step', i)
# initialize driver
driver = PySCFDriver(molecule.format(d/2), basis='sto3g')
qmolecule = driver.run()
operator = Hamiltonian(qubit_mapping=QubitMappingType.PARITY,
two_qubit_reduction=True, freeze_core=True,
orbital_reduction=[-3, -2])
qubit_op, aux_ops = operator.run(qmolecule)
# exact diagonalization
exact_result = NumPyMinimumEigensolver(qubit_op, aux_operators=aux_ops).run()
exact_result = operator.process_algorithm_result(exact_result)
# VQE OPTION 1: SLSQP optimizer + UCCSD var_form; NO NOISE.
optimizer = SLSQP(maxiter=100)
initial_state = HartreeFock(operator.molecule_info['num_orbitals'],
operator.molecule_info['num_particles'],
qubit_mapping=operator._qubit_mapping,
two_qubit_reduction=operator._two_qubit_reduction)
# Chemical approxns to make this problem tractable.
var_form = UCCSD(num_orbitals=operator.molecule_info['num_orbitals'],
num_particles=operator.molecule_info['num_particles'],
initial_state=initial_state,
qubit_mapping=operator._qubit_mapping,
two_qubit_reduction=operator._two_qubit_reduction)
algo = VQE(qubit_op, var_form, optimizer, aux_operators=aux_ops)
quantum_instance = QuantumInstance(backend=backend,
shots=8192,
noise_model=None)
###########################################################################
# VQE OPTION 2: SLSA optimizer + SU(2) [i.e. RYRZ] var_form; w/ NOISE + Mitigation
# optimizer = SLSA(maxiter=100)
# initial_state = HartreeFock(operator.molecule_info['num_orbitals'],
# operator.molecule_info['num_particles'],
# qubit_mapping=operator._qubit_mapping,
# two_qubit_reduction=operator._two_qubit_reduction)
# # Chemical approxns to make this problem tractable.
# var_form = EfficientSU2(qubit_op.num_qubits, entanglement="linear")
# algo = VQE(qubit_op, var_form, optimizer, aux_operators=aux_ops)
# quantum_instance = QuantumInstance(backend=backend,
# shots=8192,
# noise_model=noise_model,
# coupling_map=coupling_map,
# measurement_error_mitigation_cls=CompleteMeasFitter,
# cals_matrix_refresh_period=30)
# Nb: The last two inputs incorporate mitigation. Remove to get unmitigated result.
###########################################################################
vqe_result = algo.run(quantum_instance)
vqe_result = operator.process_algorithm_result(vqe_result)
exact_energies.append(exact_result.energy)
vqe_energies.append(vqe_result.energy)
hf_energies.append(vqe_result.hartree_fock_energy)
pylab.plot(distances, hf_energies, label='Hartree Fock')
pylab.plot(distances, vqe_energies, 'o', label='VQE')
pylab.plot(distances, exact_energies, 'x', label='Exact')
pylab.xlabel('Interatomic distance')
pylab.ylabel('Energy')
pylab.title('LiH Ground State Energy')
pylab.legend(loc='upper right')
# Uncomment to save plot!
#pylab.savefig('vqe.png', dpi=300)
pylab.plot(distances, hf_energies, label='Hartree Fock')
pylab.plot(distances, vqe_energies, 'o', label='VQE')
pylab.plot(distances, exact_energies, 'x', label='Exact')
pylab.xlabel('Interatomic distance')
pylab.ylabel('Energy')
pylab.title('LiH Ground State Energy')
pylab.legend(loc='upper right')
# Uncomment to save plot!
#pylab.savefig('vqe.png', dpi=300)
from qiskit import execute, QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.quantum_info import Kraus, SuperOp
from qiskit.providers.aer import QasmSimulator
from qiskit.tools.visualization import plot_histogram
# Import from Qiskit Aer noise module
from qiskit.providers.aer.noise import NoiseModel
from qiskit.providers.aer.noise import QuantumError, ReadoutError
from qiskit.providers.aer.noise import pauli_error
from qiskit.providers.aer.noise import depolarizing_error
from qiskit.providers.aer.noise import thermal_relaxation_error
# T1 and T2 values for qubits 0-3
T1s = np.random.normal(50e3, 10e3, 4) # Sampled from normal distribution mean 50 microsec
T2s = np.random.normal(70e3, 10e3, 4) # Sampled from normal distribution mean 50 microsec
# Truncate random T2s <= T1s
T2s = np.array([min(T2s[j], 2 * T1s[j]) for j in range(4)])
# Instruction times (in nanoseconds)
time_u1 = 0 # virtual gate
time_u2 = 50 # (single X90 pulse)
time_u3 = 100 # (two X90 pulses)
time_cx = 300
time_reset = 1000 # 1 microsecond
time_measure = 1000 # 1 microsecond
# QuantumError objects
errors_reset = [thermal_relaxation_error(t1, t2, time_reset)
for t1, t2 in zip(T1s, T2s)]
errors_measure = [thermal_relaxation_error(t1, t2, time_measure)
for t1, t2 in zip(T1s, T2s)]
errors_u1 = [thermal_relaxation_error(t1, t2, time_u1)
for t1, t2 in zip(T1s, T2s)]
errors_u2 = [thermal_relaxation_error(t1, t2, time_u2)
for t1, t2 in zip(T1s, T2s)]
errors_u3 = [thermal_relaxation_error(t1, t2, time_u3)
for t1, t2 in zip(T1s, T2s)]
errors_cx = [[thermal_relaxation_error(t1a, t2a, time_cx).expand(
thermal_relaxation_error(t1b, t2b, time_cx))
for t1a, t2a in zip(T1s, T2s)]
for t1b, t2b in zip(T1s, T2s)]
# Add errors to noise model
noise_thermal = NoiseModel()
for j in range(4):
noise_thermal.add_quantum_error(errors_reset[j], "reset", [j])
noise_thermal.add_quantum_error(errors_measure[j], "measure", [j])
noise_thermal.add_quantum_error(errors_u1[j], "u1", [j])
noise_thermal.add_quantum_error(errors_u2[j], "u2", [j])
noise_thermal.add_quantum_error(errors_u3[j], "u3", [j])
for k in range(4):
noise_thermal.add_quantum_error(errors_cx[j][k], "cx", [j, k])
print(noise_thermal)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import numpy as np
from qiskit import QuantumCircuit
from qiskit.quantum_info import DensityMatrix
from qiskit.visualization import plot_state_hinton
qc = QuantumCircuit(2)
qc.h([0, 1])
qc.cz(0,1)
qc.ry(np.pi/3 , 0)
qc.rx(np.pi/5, 1)
state = DensityMatrix(qc)
plot_state_hinton(state, title="New Hinton Plot")
|
https://github.com/HypsoHypso/QuantumComputingScripts
|
HypsoHypso
|
%matplotlib inline
from qiskit import (
ClassicalRegister,
QuantumRegister,
QuantumCircuit,
execute,
IBMQ
)
import matplotlib.pyplot as plt
#provider = IBMQ.load_account()
backend = provider.get_backend('ibmq_qasm_simulator') # Simulated quantum computer
q = QuantumRegister(1) # Only 1 qubit
c = ClassicalRegister(1) # Only 1 qubit
circuit = QuantumCircuit(q, c)
circuit.h(q[0]) # Hadamard Gate
#circuit.h(q[1]) ## Second Qubit
#circuit.h(q[2]) ## Third Qubit ...
circuit.measure(q, c)
print(circuit)
job = execute(circuit, backend=backend, shots=1000) # Number of attempts = 1000 attemps - The more attempts there are, the more equal the probabilities are
result = job.result()
counts = result.get_counts(circuit)
print(counts)
plt.bar(counts.keys(), counts.values(), 1, color='b')
|
https://github.com/ShabaniLab/q-camp
|
ShabaniLab
|
import numpy as np
import matplotlib.pyplot as plt
def error_rate_3bit(p):
return p**3 + 3*p**2*(1-p)
p_vals = np.linspace(0, 1, num=100)
plt.plot(p_vals, 1 - error_rate_3bit(p_vals), label='3bit no error')
# plt.plot(p_vals, error_rate_3bit(p_vals), label='3bit error')
plt.plot(p_vals, 1 - p_vals, label='1bit no error')
# plt.plot(p_vals, p_vals, label='1bit error')
plt.xlabel("single bit error p")
plt.legend()
from qiskit import *
def bit_flip_correction(num_qubits):
circ = QuantumCircuit(num_qubits, num_qubits)
circ.h(0)
for i in range(num_qubits - 1):
circ.cx(i, i+1)
return circ
circuit = bit_flip_correction(3)
circuit.draw()
backend = Aer.get_backend('statevector_simulator')
job = execute(circuit, backend)
results = job.result()
psi = results.get_statevector(circuit)
print(psi)
def bit_flip_correction_noisy(num_qubits, p):
apply_error = np.random.binomial(1, p)
circ = QuantumCircuit(num_qubits, num_qubits)
circ.h(0)
for i in range(num_qubits - 1):
circ.cx(i, i+1)
if apply_error == 1:
circ.x(0)
return circ
circuit = bit_flip_correction_noisy(3, 0.25)
circuit.draw()
def phase_flip_circuit(num_qubits):
circ = QuantumCircuit(num_qubits, num_qubits)
for i in range(num_qubits - 1):
circ.cx(i, i+1)
circ.barrier()
for i in range(num_qubits):
circ.h(i)
return circ
circ = phase_flip_circuit(3)
circ.draw()
import numpy as np
Cx = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]])
I = np.array([[1, 0], [0, 1]])
M = np.kron(Cx, I)
print(M)
W = np.array([[1, 0, 0, 0, 0, 0, 0, 0],
[0, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 1, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 1],
[0, 0, 0, 0, 0, 0, 1, 0]])
print(W)
U = np.matmul(W, M)
print(U)
psi = np.array([0.3, 0.9])
zero = np.array([1.0, 0.0])
v = np.kron(psi, zero)
v = np.kron(v, zero)
def print_state(v):
for i in range(len(v)):
print(f"{bin(i)}: " + str(v[i]))
print_state(v)
v_final = np.matmul(U, v)
print_state(v_final)
from qiskit import *
n = 5
qc = QuantumCircuit(n, n)
# initialize an equal superposition on the first qubit
qc.h(0)
# entangle the first three qubits
qc.cx(0, 1)
qc.cx(0, 2)
# apply noise/error
qc.barrier()
idx = np.random.randint(0, 3)
qc.x(idx)
qc.barrier()
# prepare syndrome qubits
qc.cx(0, 3)
qc.cx(1, 3)
qc.cx(0, 4)
qc.cx(2, 4)
# add measurement to the syndrome qubits
qc.measure(3, 3)
qc.measure(4, 4)
qc.draw()
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, execute
from qiskit.providers.fake_provider import FakeVigoV2
from qiskit.visualization import plot_gate_map
backend = FakeVigoV2()
plot_gate_map(backend)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, execute
from qiskit.visualization import plot_error_map
from qiskit.providers.fake_provider import FakeVigoV2
backend = FakeVigoV2()
plot_error_map(backend)
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Test circuits with variable parameters."""
import unittest
import cmath
import math
import copy
import pickle
from operator import add, mul, sub, truediv
from test import combine
import numpy
from ddt import data, ddt, named_data
import qiskit
import qiskit.circuit.library as circlib
from qiskit.circuit.library.standard_gates.rz import RZGate
from qiskit import BasicAer, ClassicalRegister, QuantumCircuit, QuantumRegister
from qiskit.circuit import Gate, Instruction, Parameter, ParameterExpression, ParameterVector
from qiskit.circuit.parametertable import ParameterReferences, ParameterTable, ParameterView
from qiskit.circuit.exceptions import CircuitError
from qiskit.compiler import assemble, transpile
from qiskit.execute_function import execute
from qiskit import pulse
from qiskit.quantum_info import Operator
from qiskit.test import QiskitTestCase
from qiskit.providers.fake_provider import FakeOurense
from qiskit.tools import parallel_map
def raise_if_parameter_table_invalid(circuit):
"""Validates the internal consistency of a ParameterTable and its
containing QuantumCircuit. Intended for use in testing.
Raises:
CircuitError: if QuantumCircuit and ParameterTable are inconsistent.
"""
table = circuit._parameter_table
# Assert parameters present in circuit match those in table.
circuit_parameters = {
parameter
for instruction in circuit._data
for param in instruction.operation.params
for parameter in param.parameters
if isinstance(param, ParameterExpression)
}
table_parameters = set(table._table.keys())
if circuit_parameters != table_parameters:
raise CircuitError(
"Circuit/ParameterTable Parameter mismatch. "
"Circuit parameters: {}. "
"Table parameters: {}.".format(circuit_parameters, table_parameters)
)
# Assert parameter locations in table are present in circuit.
circuit_instructions = [instr.operation for instr in circuit._data]
for parameter, instr_list in table.items():
for instr, param_index in instr_list:
if instr not in circuit_instructions:
raise CircuitError(f"ParameterTable instruction not present in circuit: {instr}.")
if not isinstance(instr.params[param_index], ParameterExpression):
raise CircuitError(
"ParameterTable instruction does not have a "
"ParameterExpression at param_index {}: {}."
"".format(param_index, instr)
)
if parameter not in instr.params[param_index].parameters:
raise CircuitError(
"ParameterTable instruction parameters does "
"not match ParameterTable key. Instruction "
"parameters: {} ParameterTable key: {}."
"".format(instr.params[param_index].parameters, parameter)
)
# Assert circuit has no other parameter locations other than those in table.
for instruction in circuit._data:
for param_index, param in enumerate(instruction.operation.params):
if isinstance(param, ParameterExpression):
parameters = param.parameters
for parameter in parameters:
if (instruction.operation, param_index) not in table[parameter]:
raise CircuitError(
"Found parameterized instruction not "
"present in table. Instruction: {} "
"param_index: {}".format(instruction.operation, param_index)
)
@ddt
class TestParameters(QiskitTestCase):
"""Test Parameters."""
def test_gate(self):
"""Test instantiating gate with variable parameters"""
theta = Parameter("θ")
theta_gate = Gate("test", 1, params=[theta])
self.assertEqual(theta_gate.name, "test")
self.assertIsInstance(theta_gate.params[0], Parameter)
def test_compile_quantum_circuit(self):
"""Test instantiating gate with variable parameters"""
theta = Parameter("θ")
qr = QuantumRegister(1)
qc = QuantumCircuit(qr)
qc.rx(theta, qr)
backend = BasicAer.get_backend("qasm_simulator")
qc_aer = transpile(qc, backend)
self.assertIn(theta, qc_aer.parameters)
def test_duplicate_name_on_append(self):
"""Test adding a second parameter object with the same name fails."""
param_a = Parameter("a")
param_a_again = Parameter("a")
qc = QuantumCircuit(1)
qc.rx(param_a, 0)
self.assertRaises(CircuitError, qc.rx, param_a_again, 0)
def test_get_parameters(self):
"""Test instantiating gate with variable parameters"""
from qiskit.circuit.library.standard_gates.rx import RXGate
theta = Parameter("θ")
qr = QuantumRegister(1)
qc = QuantumCircuit(qr)
rxg = RXGate(theta)
qc.append(rxg, [qr[0]], [])
vparams = qc._parameter_table
self.assertEqual(len(vparams), 1)
self.assertIs(theta, next(iter(vparams)))
self.assertEqual(rxg, next(iter(vparams[theta]))[0])
def test_get_parameters_by_index(self):
"""Test getting parameters by index"""
x = Parameter("x")
y = Parameter("y")
z = Parameter("z")
v = ParameterVector("v", 3)
qc = QuantumCircuit(1)
qc.rx(x, 0)
qc.rz(z, 0)
qc.ry(y, 0)
qc.u(*v, 0)
self.assertEqual(x, qc.parameters[3])
self.assertEqual(y, qc.parameters[4])
self.assertEqual(z, qc.parameters[5])
for i, vi in enumerate(v):
self.assertEqual(vi, qc.parameters[i])
def test_bind_parameters_anonymously(self):
"""Test setting parameters by insertion order anonymously"""
phase = Parameter("phase")
x = Parameter("x")
y = Parameter("y")
z = Parameter("z")
v = ParameterVector("v", 3)
qc = QuantumCircuit(1, global_phase=phase)
qc.rx(x, 0)
qc.rz(z, 0)
qc.ry(y, 0)
qc.u(*v, 0)
params = [0.1 * i for i in range(len(qc.parameters))]
order = [phase] + v[:] + [x, y, z]
param_dict = dict(zip(order, params))
for assign_fun in ["bind_parameters", "assign_parameters"]:
with self.subTest(assign_fun=assign_fun):
bqc_anonymous = getattr(qc, assign_fun)(params)
bqc_list = getattr(qc, assign_fun)(param_dict)
self.assertEqual(bqc_anonymous, bqc_list)
def test_bind_parameters_allow_unknown(self):
"""Test binding parameters allowing unknown parameters."""
a = Parameter("a")
b = Parameter("b")
c = a.bind({a: 1, b: 1}, allow_unknown_parameters=True)
self.assertEqual(c, a.bind({a: 1}))
@data(QuantumCircuit.assign_parameters, QuantumCircuit.bind_parameters)
def test_bind_parameters_custom_definition_global_phase(self, assigner):
"""Test that a custom gate with a parametrised `global_phase` is assigned correctly."""
x = Parameter("x")
custom = QuantumCircuit(1, global_phase=x).to_gate()
base = QuantumCircuit(1)
base.append(custom, [0], [])
test = Operator(assigner(base, {x: math.pi}))
expected = Operator(numpy.array([[-1, 0], [0, -1]]))
self.assertEqual(test, expected)
def test_bind_half_single_precision(self):
"""Test binding with 16bit and 32bit floats."""
phase = Parameter("phase")
x = Parameter("x")
y = Parameter("y")
z = Parameter("z")
v = ParameterVector("v", 3)
for i in (numpy.float16, numpy.float32):
with self.subTest(float_type=i):
expr = (v[0] * (x + y + z) + phase) - (v[2] * v[1])
params = numpy.array([0.1 * j for j in range(8)], dtype=i)
order = [phase] + v[:] + [x, y, z]
param_dict = dict(zip(order, params))
bound_value = expr.bind(param_dict)
self.assertAlmostEqual(float(bound_value), 0.09, delta=1e-4)
def test_parameter_order(self):
"""Test the parameters are sorted by name but parameter vector order takes precedence.
This means that the following set of parameters
{a, z, x[0], x[1], x[2], x[3], x[10], x[11]}
will be sorted as
[a, x[0], x[1], x[2], x[3], x[10], x[11], z]
"""
a, b, some_name, z = (Parameter(name) for name in ["a", "b", "some_name", "z"])
x = ParameterVector("x", 12)
a_vector = ParameterVector("a_vector", 15)
qc = QuantumCircuit(2)
qc.p(z, 0)
for i, x_i in enumerate(reversed(x)):
qc.rx(x_i, i % 2)
qc.cry(a, 0, 1)
qc.crz(some_name, 1, 0)
for v_i in a_vector[::2]:
qc.p(v_i, 0)
for v_i in a_vector[1::2]:
qc.p(v_i, 1)
qc.p(b, 0)
expected_order = [a] + a_vector[:] + [b, some_name] + x[:] + [z]
actual_order = qc.parameters
self.assertListEqual(expected_order, list(actual_order))
@data(True, False)
def test_parameter_order_compose(self, front):
"""Test the parameter order is correctly maintained upon composing circuits."""
x = Parameter("x")
y = Parameter("y")
qc1 = QuantumCircuit(1)
qc1.p(x, 0)
qc2 = QuantumCircuit(1)
qc2.rz(y, 0)
order = [x, y]
composed = qc1.compose(qc2, front=front)
self.assertListEqual(list(composed.parameters), order)
def test_parameter_order_append(self):
"""Test the parameter order is correctly maintained upon appending circuits."""
x = Parameter("x")
y = Parameter("y")
qc1 = QuantumCircuit(1)
qc1.p(x, 0)
qc2 = QuantumCircuit(1)
qc2.rz(y, 0)
qc1.append(qc2, [0])
self.assertListEqual(list(qc1.parameters), [x, y])
def test_parameter_order_composing_nested_circuit(self):
"""Test the parameter order after nesting circuits and instructions."""
x = ParameterVector("x", 5)
inner = QuantumCircuit(1)
inner.rx(x[0], [0])
mid = QuantumCircuit(2)
mid.p(x[1], 1)
mid.append(inner, [0])
mid.p(x[2], 0)
mid.append(inner, [0])
outer = QuantumCircuit(2)
outer.compose(mid, inplace=True)
outer.ryy(x[3], 0, 1)
outer.compose(inner, inplace=True)
outer.rz(x[4], 0)
order = [x[0], x[1], x[2], x[3], x[4]]
self.assertListEqual(list(outer.parameters), order)
def test_is_parameterized(self):
"""Test checking if a gate is parameterized (bound/unbound)"""
from qiskit.circuit.library.standard_gates.h import HGate
from qiskit.circuit.library.standard_gates.rx import RXGate
theta = Parameter("θ")
rxg = RXGate(theta)
self.assertTrue(rxg.is_parameterized())
theta_bound = theta.bind({theta: 3.14})
rxg = RXGate(theta_bound)
self.assertFalse(rxg.is_parameterized())
h_gate = HGate()
self.assertFalse(h_gate.is_parameterized())
def test_fix_variable(self):
"""Test setting a variable to a constant value"""
theta = Parameter("θ")
qr = QuantumRegister(1)
qc = QuantumCircuit(qr)
qc.rx(theta, qr)
qc.u(0, theta, 0, qr)
# test for both `bind_parameters` and `assign_parameters`
for assign_fun in ["bind_parameters", "assign_parameters"]:
with self.subTest(assign_fun=assign_fun):
bqc = getattr(qc, assign_fun)({theta: 0.5})
self.assertEqual(float(bqc.data[0].operation.params[0]), 0.5)
self.assertEqual(float(bqc.data[1].operation.params[1]), 0.5)
bqc = getattr(qc, assign_fun)({theta: 0.6})
self.assertEqual(float(bqc.data[0].operation.params[0]), 0.6)
self.assertEqual(float(bqc.data[1].operation.params[1]), 0.6)
def test_multiple_parameters(self):
"""Test setting multiple parameters"""
theta = Parameter("θ")
x = Parameter("x")
qr = QuantumRegister(1)
qc = QuantumCircuit(qr)
qc.rx(theta, qr)
qc.u(0, theta, x, qr)
self.assertEqual(qc.parameters, {theta, x})
def test_multiple_named_parameters(self):
"""Test setting multiple named/keyword argument based parameters"""
theta = Parameter(name="θ")
x = Parameter(name="x")
qr = QuantumRegister(1)
qc = QuantumCircuit(qr)
qc.rx(theta, qr)
qc.u(0, theta, x, qr)
self.assertEqual(theta.name, "θ")
self.assertEqual(qc.parameters, {theta, x})
@named_data(
["int", 2, int],
["float", 2.5, float],
["float16", numpy.float16(2.5), float],
["float32", numpy.float32(2.5), float],
["float64", numpy.float64(2.5), float],
)
def test_circuit_assignment_to_numeric(self, value, type_):
"""Test binding a numeric value to a circuit instruction"""
x = Parameter("x")
qc = QuantumCircuit(1)
qc.append(Instruction("inst", 1, 0, [x]), (0,))
qc.assign_parameters({x: value}, inplace=True)
bound = qc.data[0].operation.params[0]
self.assertIsInstance(bound, type_)
self.assertEqual(bound, value)
def test_partial_binding(self):
"""Test that binding a subset of circuit parameters returns a new parameterized circuit."""
theta = Parameter("θ")
x = Parameter("x")
qr = QuantumRegister(1)
qc = QuantumCircuit(qr)
qc.rx(theta, qr)
qc.u(0, theta, x, qr)
# test for both `bind_parameters` and `assign_parameters`
for assign_fun in ["bind_parameters", "assign_parameters"]:
with self.subTest(assign_fun=assign_fun):
pqc = getattr(qc, assign_fun)({theta: 2})
self.assertEqual(pqc.parameters, {x})
self.assertEqual(float(pqc.data[0].operation.params[0]), 2)
self.assertEqual(float(pqc.data[1].operation.params[1]), 2)
@data(True, False)
def test_mixed_binding(self, inplace):
"""Test we can bind a mixed dict with Parameter objects and floats."""
theta = Parameter("θ")
x, new_x = Parameter("x"), Parameter("new_x")
qr = QuantumRegister(1)
qc = QuantumCircuit(qr)
qc.rx(theta, qr)
qc.u(0, theta, x, qr)
pqc = qc.assign_parameters({theta: 2, x: new_x}, inplace=inplace)
if inplace:
self.assertEqual(qc.parameters, {new_x})
else:
self.assertEqual(pqc.parameters, {new_x})
def test_expression_partial_binding(self):
"""Test that binding a subset of expression parameters returns a new
parameterized circuit."""
theta = Parameter("θ")
phi = Parameter("phi")
qr = QuantumRegister(1)
qc = QuantumCircuit(qr)
qc.rx(theta + phi, qr)
# test for both `bind_parameters` and `assign_parameters`
for assign_fun in ["bind_parameters", "assign_parameters"]:
with self.subTest(assign_fun=assign_fun):
pqc = getattr(qc, assign_fun)({theta: 2})
self.assertEqual(pqc.parameters, {phi})
self.assertTrue(isinstance(pqc.data[0].operation.params[0], ParameterExpression))
self.assertEqual(str(pqc.data[0].operation.params[0]), "phi + 2")
fbqc = getattr(pqc, assign_fun)({phi: 1.0})
self.assertEqual(fbqc.parameters, set())
self.assertIsInstance(fbqc.data[0].operation.params[0], float)
self.assertEqual(float(fbqc.data[0].operation.params[0]), 3)
def test_two_parameter_expression_binding(self):
"""Verify that for a circuit with parameters theta and phi that
we can correctly assign theta to -phi.
"""
theta = Parameter("theta")
phi = Parameter("phi")
qc = QuantumCircuit(1)
qc.rx(theta, 0)
qc.ry(phi, 0)
self.assertEqual(len(qc._parameter_table[theta]), 1)
self.assertEqual(len(qc._parameter_table[phi]), 1)
qc.assign_parameters({theta: -phi}, inplace=True)
self.assertEqual(len(qc._parameter_table[phi]), 2)
def test_expression_partial_binding_zero(self):
"""Verify that binding remains possible even if a previous partial bind
would reduce the expression to zero.
"""
theta = Parameter("theta")
phi = Parameter("phi")
qc = QuantumCircuit(1)
qc.p(theta * phi, 0)
# test for both `bind_parameters` and `assign_parameters`
for assign_fun in ["bind_parameters", "assign_parameters"]:
with self.subTest(assign_fun=assign_fun):
pqc = getattr(qc, assign_fun)({theta: 0})
self.assertEqual(pqc.parameters, {phi})
self.assertTrue(isinstance(pqc.data[0].operation.params[0], ParameterExpression))
self.assertEqual(str(pqc.data[0].operation.params[0]), "0")
fbqc = getattr(pqc, assign_fun)({phi: 1})
self.assertEqual(fbqc.parameters, set())
self.assertIsInstance(fbqc.data[0].operation.params[0], int)
self.assertEqual(float(fbqc.data[0].operation.params[0]), 0)
def test_raise_if_assigning_params_not_in_circuit(self):
"""Verify binding parameters which are not present in the circuit raises an error."""
x = Parameter("x")
y = Parameter("y")
z = ParameterVector("z", 3)
qr = QuantumRegister(1)
qc = QuantumCircuit(qr)
# test for both `bind_parameters` and `assign_parameters`
for assign_fun in ["bind_parameters", "assign_parameters"]:
qc = QuantumCircuit(qr)
with self.subTest(assign_fun=assign_fun):
qc.p(0.1, qr[0])
self.assertRaises(CircuitError, getattr(qc, assign_fun), {x: 1})
qc.p(x, qr[0])
self.assertRaises(CircuitError, getattr(qc, assign_fun), {x: 1, y: 2})
qc.p(z[1], qr[0])
self.assertRaises(CircuitError, getattr(qc, assign_fun), {z: [3, 4, 5]})
self.assertRaises(CircuitError, getattr(qc, assign_fun), {"a_str": 6})
self.assertRaises(CircuitError, getattr(qc, assign_fun), {None: 7})
def test_gate_multiplicity_binding(self):
"""Test binding when circuit contains multiple references to same gate"""
qc = QuantumCircuit(1)
theta = Parameter("theta")
gate = RZGate(theta)
qc.append(gate, [0], [])
qc.append(gate, [0], [])
# test for both `bind_parameters` and `assign_parameters`
for assign_fun in ["bind_parameters", "assign_parameters"]:
with self.subTest(assign_fun=assign_fun):
qc2 = getattr(qc, assign_fun)({theta: 1.0})
self.assertEqual(len(qc2._parameter_table), 0)
for instruction in qc2.data:
self.assertEqual(float(instruction.operation.params[0]), 1.0)
def test_calibration_assignment(self):
"""That that calibration mapping and the schedules they map are assigned together."""
theta = Parameter("theta")
circ = QuantumCircuit(3, 3)
circ.append(Gate("rxt", 1, [theta]), [0])
circ.measure(0, 0)
rxt_q0 = pulse.Schedule(
pulse.Play(
pulse.library.Gaussian(duration=128, sigma=16, amp=0.2 * theta / 3.14),
pulse.DriveChannel(0),
)
)
circ.add_calibration("rxt", [0], rxt_q0, [theta])
circ = circ.assign_parameters({theta: 3.14})
instruction = circ.data[0]
cal_key = (
tuple(circ.find_bit(q).index for q in instruction.qubits),
tuple(instruction.operation.params),
)
self.assertEqual(cal_key, ((0,), (3.14,)))
# Make sure that key from instruction data matches the calibrations dictionary
self.assertIn(cal_key, circ.calibrations["rxt"])
sched = circ.calibrations["rxt"][cal_key]
self.assertEqual(sched.instructions[0][1].pulse.amp, 0.2)
def test_calibration_assignment_doesnt_mutate(self):
"""That that assignment doesn't mutate the original circuit."""
theta = Parameter("theta")
circ = QuantumCircuit(3, 3)
circ.append(Gate("rxt", 1, [theta]), [0])
circ.measure(0, 0)
rxt_q0 = pulse.Schedule(
pulse.Play(
pulse.library.Gaussian(duration=128, sigma=16, amp=0.2 * theta / 3.14),
pulse.DriveChannel(0),
)
)
circ.add_calibration("rxt", [0], rxt_q0, [theta])
circ_copy = copy.deepcopy(circ)
assigned_circ = circ.assign_parameters({theta: 3.14})
self.assertEqual(circ.calibrations, circ_copy.calibrations)
self.assertNotEqual(assigned_circ.calibrations, circ.calibrations)
def test_calibration_assignment_w_expressions(self):
"""That calibrations with multiple parameters are assigned correctly"""
theta = Parameter("theta")
sigma = Parameter("sigma")
circ = QuantumCircuit(3, 3)
circ.append(Gate("rxt", 1, [theta / 2, sigma]), [0])
circ.measure(0, 0)
rxt_q0 = pulse.Schedule(
pulse.Play(
pulse.library.Gaussian(duration=128, sigma=4 * sigma, amp=0.2 * theta / 3.14),
pulse.DriveChannel(0),
)
)
circ.add_calibration("rxt", [0], rxt_q0, [theta / 2, sigma])
circ = circ.assign_parameters({theta: 3.14, sigma: 4})
instruction = circ.data[0]
cal_key = (
tuple(circ.find_bit(q).index for q in instruction.qubits),
tuple(instruction.operation.params),
)
self.assertEqual(cal_key, ((0,), (3.14 / 2, 4)))
# Make sure that key from instruction data matches the calibrations dictionary
self.assertIn(cal_key, circ.calibrations["rxt"])
sched = circ.calibrations["rxt"][cal_key]
self.assertEqual(sched.instructions[0][1].pulse.amp, 0.2)
self.assertEqual(sched.instructions[0][1].pulse.sigma, 16)
def test_substitution(self):
"""Test Parameter substitution (vs bind)."""
alpha = Parameter("⍺")
beta = Parameter("beta")
schedule = pulse.Schedule(pulse.ShiftPhase(alpha, pulse.DriveChannel(0)))
circ = QuantumCircuit(3, 3)
circ.append(Gate("my_rz", 1, [alpha]), [0])
circ.add_calibration("my_rz", [0], schedule, [alpha])
circ = circ.assign_parameters({alpha: 2 * beta})
circ = circ.assign_parameters({beta: 1.57})
cal_sched = circ.calibrations["my_rz"][((0,), (3.14,))]
self.assertEqual(float(cal_sched.instructions[0][1].phase), 3.14)
def test_partial_assignment(self):
"""Expressions of parameters with partial assignment."""
alpha = Parameter("⍺")
beta = Parameter("beta")
gamma = Parameter("γ")
phi = Parameter("ϕ")
with pulse.build() as my_cal:
pulse.set_frequency(alpha + beta, pulse.DriveChannel(0))
pulse.shift_frequency(gamma + beta, pulse.DriveChannel(0))
pulse.set_phase(phi, pulse.DriveChannel(1))
circ = QuantumCircuit(2, 2)
circ.append(Gate("custom", 2, [alpha, beta, gamma, phi]), [0, 1])
circ.add_calibration("custom", [0, 1], my_cal, [alpha, beta, gamma, phi])
# Partial bind
delta = 1e9
freq = 4.5e9
shift = 0.5e9
phase = 3.14 / 4
circ = circ.assign_parameters({alpha: freq - delta})
cal_sched = list(circ.calibrations["custom"].values())[0]
self.assertEqual(cal_sched.instructions[0][1].frequency, freq - delta + beta)
circ = circ.assign_parameters({beta: delta})
cal_sched = list(circ.calibrations["custom"].values())[0]
self.assertEqual(float(cal_sched.instructions[0][1].frequency), freq)
self.assertEqual(cal_sched.instructions[1][1].frequency, gamma + delta)
circ = circ.assign_parameters({gamma: shift - delta})
cal_sched = list(circ.calibrations["custom"].values())[0]
self.assertEqual(float(cal_sched.instructions[1][1].frequency), shift)
self.assertEqual(cal_sched.instructions[2][1].phase, phi)
circ = circ.assign_parameters({phi: phase})
cal_sched = list(circ.calibrations["custom"].values())[0]
self.assertEqual(float(cal_sched.instructions[2][1].phase), phase)
def test_circuit_generation(self):
"""Test creating a series of circuits parametrically"""
theta = Parameter("θ")
qr = QuantumRegister(1)
qc = QuantumCircuit(qr)
qc.rx(theta, qr)
backend = BasicAer.get_backend("qasm_simulator")
qc_aer = transpile(qc, backend)
# generate list of circuits
for assign_fun in ["bind_parameters", "assign_parameters"]:
with self.subTest(assign_fun=assign_fun):
circs = []
theta_list = numpy.linspace(0, numpy.pi, 20)
for theta_i in theta_list:
circs.append(getattr(qc_aer, assign_fun)({theta: theta_i}))
qobj = assemble(circs)
for index, theta_i in enumerate(theta_list):
res = float(qobj.experiments[index].instructions[0].params[0])
self.assertTrue(math.isclose(res, theta_i), f"{res} != {theta_i}")
def test_circuit_composition(self):
"""Test preservation of parameters when combining circuits."""
theta = Parameter("θ")
qr = QuantumRegister(1)
cr = ClassicalRegister(1)
qc1 = QuantumCircuit(qr, cr)
qc1.rx(theta, qr)
phi = Parameter("phi")
qc2 = QuantumCircuit(qr, cr)
qc2.ry(phi, qr)
qc2.h(qr)
qc2.measure(qr, cr)
qc3 = qc1.compose(qc2)
self.assertEqual(qc3.parameters, {theta, phi})
def test_composite_instruction(self):
"""Test preservation of parameters via parameterized instructions."""
theta = Parameter("θ")
qr1 = QuantumRegister(1, name="qr1")
qc1 = QuantumCircuit(qr1)
qc1.rx(theta, qr1)
qc1.rz(numpy.pi / 2, qr1)
qc1.ry(theta, qr1)
gate = qc1.to_instruction()
self.assertEqual(gate.params, [theta])
phi = Parameter("phi")
qr2 = QuantumRegister(3, name="qr2")
qc2 = QuantumCircuit(qr2)
qc2.ry(phi, qr2[0])
qc2.h(qr2)
qc2.append(gate, qargs=[qr2[1]])
self.assertEqual(qc2.parameters, {theta, phi})
def test_parameter_name_conflicts_raises(self):
"""Verify attempting to add different parameters with matching names raises an error."""
theta1 = Parameter("theta")
theta2 = Parameter("theta")
qr = QuantumRegister(1)
qc = QuantumCircuit(qr)
qc.p(theta1, 0)
self.assertRaises(CircuitError, qc.p, theta2, 0)
def test_bind_ryrz_vector(self):
"""Test binding a list of floats to a ParameterVector"""
qc = QuantumCircuit(4)
depth = 4
theta = ParameterVector("θ", length=len(qc.qubits) * depth * 2)
theta_iter = iter(theta)
for _ in range(depth):
for q in qc.qubits:
qc.ry(next(theta_iter), q)
qc.rz(next(theta_iter), q)
for i, q in enumerate(qc.qubits[:-1]):
qc.cx(qc.qubits[i], qc.qubits[i + 1])
qc.barrier()
theta_vals = numpy.linspace(0, 1, len(theta)) * numpy.pi
self.assertEqual(set(qc.parameters), set(theta.params))
for assign_fun in ["bind_parameters", "assign_parameters"]:
with self.subTest(assign_fun=assign_fun):
bqc = getattr(qc, assign_fun)({theta: theta_vals})
for instruction in bqc.data:
if hasattr(instruction.operation, "params") and instruction.operation.params:
self.assertIn(float(instruction.operation.params[0]), theta_vals)
def test_compile_vector(self):
"""Test compiling a circuit with an unbound ParameterVector"""
qc = QuantumCircuit(4)
depth = 4
theta = ParameterVector("θ", length=len(qc.qubits) * depth * 2)
theta_iter = iter(theta)
for _ in range(depth):
for q in qc.qubits:
qc.ry(next(theta_iter), q)
qc.rz(next(theta_iter), q)
for i, q in enumerate(qc.qubits[:-1]):
qc.cx(qc.qubits[i], qc.qubits[i + 1])
qc.barrier()
backend = BasicAer.get_backend("qasm_simulator")
qc_aer = transpile(qc, backend)
for param in theta:
self.assertIn(param, qc_aer.parameters)
def test_instruction_ryrz_vector(self):
"""Test constructing a circuit from instructions with remapped ParameterVectors"""
qubits = 5
depth = 4
ryrz = QuantumCircuit(qubits, name="ryrz")
theta = ParameterVector("θ0", length=len(ryrz.qubits) * 2)
theta_iter = iter(theta)
for q in ryrz.qubits:
ryrz.ry(next(theta_iter), q)
ryrz.rz(next(theta_iter), q)
cxs = QuantumCircuit(qubits - 1, name="cxs")
for i, _ in enumerate(cxs.qubits[:-1:2]):
cxs.cx(cxs.qubits[2 * i], cxs.qubits[2 * i + 1])
paramvecs = []
qc = QuantumCircuit(qubits)
for i in range(depth):
theta_l = ParameterVector(f"θ{i + 1}", length=len(ryrz.qubits) * 2)
ryrz_inst = ryrz.to_instruction(parameter_map={theta: theta_l})
paramvecs += [theta_l]
qc.append(ryrz_inst, qargs=qc.qubits)
qc.append(cxs, qargs=qc.qubits[1:])
qc.append(cxs, qargs=qc.qubits[:-1])
qc.barrier()
backend = BasicAer.get_backend("qasm_simulator")
qc_aer = transpile(qc, backend)
for vec in paramvecs:
for param in vec:
self.assertIn(param, qc_aer.parameters)
@data("single", "vector")
def test_parameter_equality_through_serialization(self, ptype):
"""Verify parameters maintain their equality after serialization."""
if ptype == "single":
x1 = Parameter("x")
x2 = Parameter("x")
else:
x1 = ParameterVector("x", 2)[0]
x2 = ParameterVector("x", 2)[0]
x1_p = pickle.loads(pickle.dumps(x1))
x2_p = pickle.loads(pickle.dumps(x2))
self.assertEqual(x1, x1_p)
self.assertEqual(x2, x2_p)
self.assertNotEqual(x1, x2_p)
self.assertNotEqual(x2, x1_p)
def test_binding_parameterized_circuits_built_in_multiproc(self):
"""Verify subcircuits built in a subprocess can still be bound."""
# ref: https://github.com/Qiskit/qiskit-terra/issues/2429
num_processes = 4
qr = QuantumRegister(3)
cr = ClassicalRegister(3)
circuit = QuantumCircuit(qr, cr)
parameters = [Parameter(f"x{i}") for i in range(num_processes)]
results = parallel_map(
_construct_circuit, parameters, task_args=(qr,), num_processes=num_processes
)
for qc in results:
circuit.compose(qc, inplace=True)
parameter_values = [{x: 1.0 for x in parameters}]
qobj = assemble(
circuit,
backend=BasicAer.get_backend("qasm_simulator"),
parameter_binds=parameter_values,
)
self.assertEqual(len(qobj.experiments), 1)
self.assertEqual(len(qobj.experiments[0].instructions), 4)
self.assertTrue(
all(
len(inst.params) == 1
and isinstance(inst.params[0], float)
and float(inst.params[0]) == 1
for inst in qobj.experiments[0].instructions
)
)
def test_transpiling_multiple_parameterized_circuits(self):
"""Verify several parameterized circuits can be transpiled at once."""
# ref: https://github.com/Qiskit/qiskit-terra/issues/2864
qr = QuantumRegister(1)
qc1 = QuantumCircuit(qr)
qc2 = QuantumCircuit(qr)
theta = Parameter("theta")
qc1.u(theta, 0, 0, qr[0])
qc2.u(theta, 3.14, 0, qr[0])
circuits = [qc1, qc2]
job = execute(
circuits,
BasicAer.get_backend("unitary_simulator"),
shots=512,
parameter_binds=[{theta: 1}],
)
self.assertTrue(len(job.result().results), 2)
@data(0, 1, 2, 3)
def test_transpile_across_optimization_levels(self, opt_level):
"""Verify parameterized circuits can be transpiled with all default pass managers."""
qc = QuantumCircuit(5, 5)
theta = Parameter("theta")
phi = Parameter("phi")
qc.rx(theta, 0)
qc.x(0)
for i in range(5 - 1):
qc.rxx(phi, i, i + 1)
qc.measure(range(5 - 1), range(5 - 1))
transpile(qc, FakeOurense(), optimization_level=opt_level)
def test_repeated_gates_to_dag_and_back(self):
"""Verify circuits with repeated parameterized gates can be converted
to DAG and back, maintaining consistency of circuit._parameter_table."""
from qiskit.converters import circuit_to_dag, dag_to_circuit
qr = QuantumRegister(1)
qc = QuantumCircuit(qr)
theta = Parameter("theta")
qc.p(theta, qr[0])
double_qc = qc.compose(qc)
test_qc = dag_to_circuit(circuit_to_dag(double_qc))
for assign_fun in ["bind_parameters", "assign_parameters"]:
with self.subTest(assign_fun=assign_fun):
bound_test_qc = getattr(test_qc, assign_fun)({theta: 1})
self.assertEqual(len(bound_test_qc.parameters), 0)
def test_rebinding_instruction_copy(self):
"""Test rebinding a copied instruction does not modify the original."""
theta = Parameter("th")
qc = QuantumCircuit(1)
qc.rx(theta, 0)
instr = qc.to_instruction()
qc1 = QuantumCircuit(1)
qc1.append(instr, [0])
for assign_fun in ["bind_parameters", "assign_parameters"]:
with self.subTest(assign_fun=assign_fun):
output1 = getattr(qc1, assign_fun)({theta: 0.1}).decompose()
output2 = getattr(qc1, assign_fun)({theta: 0.2}).decompose()
expected1 = QuantumCircuit(1)
expected1.rx(0.1, 0)
expected2 = QuantumCircuit(1)
expected2.rx(0.2, 0)
self.assertEqual(expected1, output1)
self.assertEqual(expected2, output2)
@combine(target_type=["gate", "instruction"], parameter_type=["numbers", "parameters"])
def test_decompose_propagates_bound_parameters(self, target_type, parameter_type):
"""Verify bind-before-decompose preserves bound values."""
# ref: https://github.com/Qiskit/qiskit-terra/issues/2482
theta = Parameter("th")
qc = QuantumCircuit(1)
qc.rx(theta, 0)
if target_type == "gate":
inst = qc.to_gate()
elif target_type == "instruction":
inst = qc.to_instruction()
qc2 = QuantumCircuit(1)
qc2.append(inst, [0])
if parameter_type == "numbers":
bound_qc2 = qc2.assign_parameters({theta: 0.5})
expected_parameters = set()
expected_qc2 = QuantumCircuit(1)
expected_qc2.rx(0.5, 0)
else:
phi = Parameter("ph")
bound_qc2 = qc2.assign_parameters({theta: phi})
expected_parameters = {phi}
expected_qc2 = QuantumCircuit(1)
expected_qc2.rx(phi, 0)
decomposed_qc2 = bound_qc2.decompose()
with self.subTest(msg="testing parameters of initial circuit"):
self.assertEqual(qc2.parameters, {theta})
with self.subTest(msg="testing parameters of bound circuit"):
self.assertEqual(bound_qc2.parameters, expected_parameters)
with self.subTest(msg="testing parameters of deep decomposed bound circuit"):
self.assertEqual(decomposed_qc2.parameters, expected_parameters)
with self.subTest(msg="testing deep decomposed circuit"):
self.assertEqual(decomposed_qc2, expected_qc2)
@combine(target_type=["gate", "instruction"], parameter_type=["numbers", "parameters"])
def test_decompose_propagates_deeply_bound_parameters(self, target_type, parameter_type):
"""Verify bind-before-decompose preserves deeply bound values."""
theta = Parameter("th")
qc1 = QuantumCircuit(1)
qc1.rx(theta, 0)
if target_type == "gate":
inst = qc1.to_gate()
elif target_type == "instruction":
inst = qc1.to_instruction()
qc2 = QuantumCircuit(1)
qc2.append(inst, [0])
if target_type == "gate":
inst = qc2.to_gate()
elif target_type == "instruction":
inst = qc2.to_instruction()
qc3 = QuantumCircuit(1)
qc3.append(inst, [0])
if parameter_type == "numbers":
bound_qc3 = qc3.assign_parameters({theta: 0.5})
expected_parameters = set()
expected_qc3 = QuantumCircuit(1)
expected_qc3.rx(0.5, 0)
else:
phi = Parameter("ph")
bound_qc3 = qc3.assign_parameters({theta: phi})
expected_parameters = {phi}
expected_qc3 = QuantumCircuit(1)
expected_qc3.rx(phi, 0)
deep_decomposed_qc3 = bound_qc3.decompose().decompose()
with self.subTest(msg="testing parameters of initial circuit"):
self.assertEqual(qc3.parameters, {theta})
with self.subTest(msg="testing parameters of bound circuit"):
self.assertEqual(bound_qc3.parameters, expected_parameters)
with self.subTest(msg="testing parameters of deep decomposed bound circuit"):
self.assertEqual(deep_decomposed_qc3.parameters, expected_parameters)
with self.subTest(msg="testing deep decomposed circuit"):
self.assertEqual(deep_decomposed_qc3, expected_qc3)
@data("gate", "instruction")
def test_executing_parameterized_instruction_bound_early(self, target_type):
"""Verify bind-before-execute preserves bound values."""
# ref: https://github.com/Qiskit/qiskit-terra/issues/2482
theta = Parameter("theta")
sub_qc = QuantumCircuit(2)
sub_qc.h(0)
sub_qc.cx(0, 1)
sub_qc.rz(theta, [0, 1])
sub_qc.cx(0, 1)
sub_qc.h(0)
if target_type == "gate":
sub_inst = sub_qc.to_gate()
elif target_type == "instruction":
sub_inst = sub_qc.to_instruction()
unbound_qc = QuantumCircuit(2, 1)
unbound_qc.append(sub_inst, [0, 1], [])
unbound_qc.measure(0, 0)
for assign_fun in ["bind_parameters", "assign_parameters"]:
with self.subTest(assign_fun=assign_fun):
bound_qc = getattr(unbound_qc, assign_fun)({theta: numpy.pi / 2})
shots = 1024
job = execute(bound_qc, backend=BasicAer.get_backend("qasm_simulator"), shots=shots)
self.assertDictAlmostEqual(job.result().get_counts(), {"1": shots}, 0.05 * shots)
def test_num_parameters(self):
"""Test the num_parameters property."""
with self.subTest(msg="standard case"):
theta = Parameter("θ")
x = Parameter("x")
qc = QuantumCircuit(1)
qc.rx(theta, 0)
qc.u(0, theta, x, 0)
self.assertEqual(qc.num_parameters, 2)
with self.subTest(msg="parameter vector"):
params = ParameterVector("x", length=3)
qc = QuantumCircuit(4)
qc.rx(params[0], 2)
qc.ry(params[1], 1)
qc.rz(params[2], 3)
self.assertEqual(qc.num_parameters, 3)
with self.subTest(msg="no params"):
qc = QuantumCircuit(1)
qc.x(0)
self.assertEqual(qc.num_parameters, 0)
def test_execute_result_names(self):
"""Test unique names for list of parameter binds."""
theta = Parameter("θ")
reps = 5
qc = QuantumCircuit(1, 1)
qc.rx(theta, 0)
qc.measure(0, 0)
plist = [{theta: i} for i in range(reps)]
simulator = BasicAer.get_backend("qasm_simulator")
result = execute(qc, backend=simulator, parameter_binds=plist).result()
result_names = {res.name for res in result.results}
self.assertEqual(reps, len(result_names))
def test_to_instruction_after_inverse(self):
"""Verify converting an inverse generates a valid ParameterTable"""
# ref: https://github.com/Qiskit/qiskit-terra/issues/4235
qc = QuantumCircuit(1)
theta = Parameter("theta")
qc.rz(theta, 0)
inv_instr = qc.inverse().to_instruction()
self.assertIsInstance(inv_instr, Instruction)
def test_repeated_circuit(self):
"""Test repeating a circuit maintains the parameters."""
qc = QuantumCircuit(1)
theta = Parameter("theta")
qc.rz(theta, 0)
rep = qc.repeat(3)
self.assertEqual(rep.parameters, {theta})
def test_copy_after_inverse(self):
"""Verify circuit.inverse generates a valid ParameterTable."""
qc = QuantumCircuit(1)
theta = Parameter("theta")
qc.rz(theta, 0)
inverse = qc.inverse()
self.assertIn(theta, inverse.parameters)
raise_if_parameter_table_invalid(inverse)
def test_copy_after_reverse(self):
"""Verify circuit.reverse generates a valid ParameterTable."""
qc = QuantumCircuit(1)
theta = Parameter("theta")
qc.rz(theta, 0)
reverse = qc.reverse_ops()
self.assertIn(theta, reverse.parameters)
raise_if_parameter_table_invalid(reverse)
def test_copy_after_dot_data_setter(self):
"""Verify setting circuit.data generates a valid ParameterTable."""
qc = QuantumCircuit(1)
theta = Parameter("theta")
qc.rz(theta, 0)
qc.data = []
self.assertEqual(qc.parameters, set())
raise_if_parameter_table_invalid(qc)
def test_circuit_with_ufunc(self):
"""Test construction of circuit and binding of parameters
after we apply universal functions."""
from math import pi
phi = Parameter(name="phi")
theta = Parameter(name="theta")
qc = QuantumCircuit(2)
qc.p(numpy.abs(-phi), 0)
qc.p(numpy.cos(phi), 0)
qc.p(numpy.sin(phi), 0)
qc.p(numpy.tan(phi), 0)
qc.rz(numpy.arccos(theta), 1)
qc.rz(numpy.arctan(theta), 1)
qc.rz(numpy.arcsin(theta), 1)
qc.assign_parameters({phi: pi, theta: 1}, inplace=True)
qc_ref = QuantumCircuit(2)
qc_ref.p(pi, 0)
qc_ref.p(-1, 0)
qc_ref.p(0, 0)
qc_ref.p(0, 0)
qc_ref.rz(0, 1)
qc_ref.rz(pi / 4, 1)
qc_ref.rz(pi / 2, 1)
self.assertEqual(qc, qc_ref)
def test_compile_with_ufunc(self):
"""Test compiling of circuit with unbound parameters
after we apply universal functions."""
from math import pi
theta = ParameterVector("theta", length=7)
qc = QuantumCircuit(7)
qc.rx(numpy.abs(theta[0]), 0)
qc.rx(numpy.cos(theta[1]), 1)
qc.rx(numpy.sin(theta[2]), 2)
qc.rx(numpy.tan(theta[3]), 3)
qc.rx(numpy.arccos(theta[4]), 4)
qc.rx(numpy.arctan(theta[5]), 5)
qc.rx(numpy.arcsin(theta[6]), 6)
# transpile to different basis
transpiled = transpile(qc, basis_gates=["rz", "sx", "x", "cx"], optimization_level=0)
for x in theta:
self.assertIn(x, transpiled.parameters)
bound = transpiled.bind_parameters({theta: [-1, pi, pi, pi, 1, 1, 1]})
expected = QuantumCircuit(7)
expected.rx(1.0, 0)
expected.rx(-1.0, 1)
expected.rx(0.0, 2)
expected.rx(0.0, 3)
expected.rx(0.0, 4)
expected.rx(pi / 4, 5)
expected.rx(pi / 2, 6)
expected = transpile(expected, basis_gates=["rz", "sx", "x", "cx"], optimization_level=0)
self.assertEqual(expected, bound)
def test_parametervector_resize(self):
"""Test the resize method of the parameter vector."""
vec = ParameterVector("x", 2)
element = vec[1] # store an entry for instancecheck later on
with self.subTest("shorten"):
vec.resize(1)
self.assertEqual(len(vec), 1)
self.assertListEqual([param.name for param in vec], _paramvec_names("x", 1))
with self.subTest("enlargen"):
vec.resize(3)
self.assertEqual(len(vec), 3)
# ensure we still have the same instance not a copy with the same name
# this is crucial for adding parameters to circuits since we cannot use the same
# name if the instance is not the same
self.assertIs(element, vec[1])
self.assertListEqual([param.name for param in vec], _paramvec_names("x", 3))
def test_raise_if_sub_unknown_parameters(self):
"""Verify we raise if asked to sub a parameter not in self."""
x = Parameter("x")
y = Parameter("y")
z = Parameter("z")
with self.assertRaisesRegex(CircuitError, "not present"):
x.subs({y: z})
def test_sub_allow_unknown_parameters(self):
"""Verify we raise if asked to sub a parameter not in self."""
x = Parameter("x")
y = Parameter("y")
z = Parameter("z")
subbed = x.subs({y: z}, allow_unknown_parameters=True)
self.assertEqual(subbed, x)
def _construct_circuit(param, qr):
qc = QuantumCircuit(qr)
qc.ry(param, qr[0])
return qc
def _paramvec_names(prefix, length):
return [f"{prefix}[{i}]" for i in range(length)]
@ddt
class TestParameterExpressions(QiskitTestCase):
"""Test expressions of Parameters."""
supported_operations = [add, sub, mul, truediv]
def test_compare_to_value_when_bound(self):
"""Verify expression can be compared to a fixed value
when fully bound."""
x = Parameter("x")
bound_expr = x.bind({x: 2.3})
self.assertEqual(bound_expr, 2.3)
def test_abs_function_when_bound(self):
"""Verify expression can be used with
abs functions when bound."""
x = Parameter("x")
xb_1 = x.bind({x: 2.0})
xb_2 = x.bind({x: 3.0 + 4.0j})
self.assertEqual(abs(xb_1), 2.0)
self.assertEqual(abs(-xb_1), 2.0)
self.assertEqual(abs(xb_2), 5.0)
def test_abs_function_when_not_bound(self):
"""Verify expression can be used with
abs functions when not bound."""
x = Parameter("x")
y = Parameter("y")
self.assertEqual(abs(x), abs(-x))
self.assertEqual(abs(x) * abs(y), abs(x * y))
self.assertEqual(abs(x) / abs(y), abs(x / y))
def test_cast_to_complex_when_bound(self):
"""Verify that the cast to complex works for bound objects."""
x = Parameter("x")
y = Parameter("y")
bound_expr = (x + y).bind({x: 1.0, y: 1j})
self.assertEqual(complex(bound_expr), 1 + 1j)
def test_raise_if_cast_to_complex_when_not_fully_bound(self):
"""Verify raises if casting to complex and not fully bound."""
x = Parameter("x")
y = Parameter("y")
bound_expr = (x + y).bind({x: 1j})
with self.assertRaisesRegex(TypeError, "unbound parameters"):
complex(bound_expr)
def test_cast_to_float_when_bound(self):
"""Verify expression can be cast to a float when fully bound."""
x = Parameter("x")
bound_expr = x.bind({x: 2.3})
self.assertEqual(float(bound_expr), 2.3)
def test_cast_to_float_when_underlying_expression_bound(self):
"""Verify expression can be cast to a float when it still contains unbound parameters, but
the underlying symbolic expression has a knowable value."""
x = Parameter("x")
expr = x - x + 2.3
self.assertEqual(float(expr), 2.3)
def test_cast_to_float_intermediate_complex_value(self):
"""Verify expression can be cast to a float when it is fully bound, but an intermediate part
of the expression evaluation involved complex types. Sympy is generally more permissive
than symengine here, and sympy's tends to be the expected behaviour for our users."""
x = Parameter("x")
bound_expr = (x + 1.0 + 1.0j).bind({x: -1.0j})
self.assertEqual(float(bound_expr), 1.0)
def test_cast_to_float_of_complex_fails(self):
"""Test that an attempt to produce a float from a complex value fails if there is an
imaginary part, with a sensible error message."""
x = Parameter("x")
bound_expr = (x + 1.0j).bind({x: 1.0})
with self.assertRaisesRegex(TypeError, "could not cast expression to float"):
float(bound_expr)
def test_raise_if_cast_to_float_when_not_fully_bound(self):
"""Verify raises if casting to float and not fully bound."""
x = Parameter("x")
y = Parameter("y")
bound_expr = (x + y).bind({x: 2.3})
with self.assertRaisesRegex(TypeError, "unbound parameters"):
float(bound_expr)
def test_cast_to_int_when_bound(self):
"""Verify expression can be cast to an int when fully bound."""
x = Parameter("x")
bound_expr = x.bind({x: 2.3})
self.assertEqual(int(bound_expr), 2)
def test_cast_to_int_when_bound_truncates_after_evaluation(self):
"""Verify expression can be cast to an int when fully bound, but
truncated only after evaluation."""
x = Parameter("x")
y = Parameter("y")
bound_expr = (x + y).bind({x: 2.3, y: 0.8})
self.assertEqual(int(bound_expr), 3)
def test_cast_to_int_when_underlying_expression_bound(self):
"""Verify expression can be cast to a int when it still contains unbound parameters, but the
underlying symbolic expression has a knowable value."""
x = Parameter("x")
expr = x - x + 2.3
self.assertEqual(int(expr), 2)
def test_raise_if_cast_to_int_when_not_fully_bound(self):
"""Verify raises if casting to int and not fully bound."""
x = Parameter("x")
y = Parameter("y")
bound_expr = (x + y).bind({x: 2.3})
with self.assertRaisesRegex(TypeError, "unbound parameters"):
int(bound_expr)
def test_raise_if_sub_unknown_parameters(self):
"""Verify we raise if asked to sub a parameter not in self."""
x = Parameter("x")
expr = x + 2
y = Parameter("y")
z = Parameter("z")
with self.assertRaisesRegex(CircuitError, "not present"):
expr.subs({y: z})
def test_sub_allow_unknown_parameters(self):
"""Verify we raise if asked to sub a parameter not in self."""
x = Parameter("x")
expr = x + 2
y = Parameter("y")
z = Parameter("z")
subbed = expr.subs({y: z}, allow_unknown_parameters=True)
self.assertEqual(subbed, expr)
def test_raise_if_subbing_in_parameter_name_conflict(self):
"""Verify we raise if substituting in conflicting parameter names."""
x = Parameter("x")
y_first = Parameter("y")
expr = x + y_first
y_second = Parameter("y")
# Replacing an existing name is okay.
expr.subs({y_first: y_second})
with self.assertRaisesRegex(CircuitError, "Name conflict"):
expr.subs({x: y_second})
def test_expressions_of_parameter_with_constant(self):
"""Verify operating on a Parameter with a constant."""
good_constants = [2, 1.3, 0, -1, -1.0, numpy.pi, 1j]
x = Parameter("x")
for op in self.supported_operations:
for const in good_constants:
expr = op(const, x)
bound_expr = expr.bind({x: 2.3})
self.assertEqual(complex(bound_expr), op(const, 2.3))
# Division by zero will raise. Tested elsewhere.
if const == 0 and op == truediv:
continue
# Repeat above, swapping position of Parameter and constant.
expr = op(x, const)
bound_expr = expr.bind({x: 2.3})
res = complex(bound_expr)
expected = op(2.3, const)
self.assertTrue(cmath.isclose(res, expected), f"{res} != {expected}")
def test_complex_parameter_bound_to_real(self):
"""Test a complex parameter expression can be real if bound correctly."""
x, y = Parameter("x"), Parameter("y")
with self.subTest("simple 1j * x"):
qc = QuantumCircuit(1)
qc.rx(1j * x, 0)
bound = qc.bind_parameters({x: 1j})
ref = QuantumCircuit(1)
ref.rx(-1, 0)
self.assertEqual(bound, ref)
with self.subTest("more complex expression"):
qc = QuantumCircuit(1)
qc.rx(0.5j * x - y * y + 2 * y, 0)
bound = qc.bind_parameters({x: -4, y: 1j})
ref = QuantumCircuit(1)
ref.rx(1, 0)
self.assertEqual(bound, ref)
def test_complex_angle_raises_when_not_supported(self):
"""Test parameters are validated when fully bound and errors are raised accordingly."""
x = Parameter("x")
qc = QuantumCircuit(1)
qc.r(x, 1j * x, 0)
with self.subTest("binding x to 0 yields real parameters"):
bound = qc.bind_parameters({x: 0})
ref = QuantumCircuit(1)
ref.r(0, 0, 0)
self.assertEqual(bound, ref)
with self.subTest("binding x to 1 yields complex parameters"):
# RGate does not support complex parameters
with self.assertRaises(CircuitError):
bound = qc.bind_parameters({x: 1})
def test_operating_on_a_parameter_with_a_non_float_will_raise(self):
"""Verify operations between a Parameter and a non-float will raise."""
bad_constants = ["1", numpy.Inf, numpy.NaN, None, {}, []]
x = Parameter("x")
for op in self.supported_operations:
for const in bad_constants:
with self.subTest(op=op, const=const):
with self.assertRaises(TypeError):
_ = op(const, x)
with self.assertRaises(TypeError):
_ = op(x, const)
def test_expressions_division_by_zero(self):
"""Verify dividing a Parameter by 0, or binding 0 as a denominator raises."""
x = Parameter("x")
with self.assertRaises(ZeroDivisionError):
_ = x / 0
with self.assertRaises(ZeroDivisionError):
_ = x / 0.0
expr = 2 / x
with self.assertRaises(ZeroDivisionError):
_ = expr.bind({x: 0})
with self.assertRaises(ZeroDivisionError):
_ = expr.bind({x: 0.0})
def test_expressions_of_parameter_with_parameter(self):
"""Verify operating on two Parameters."""
x = Parameter("x")
y = Parameter("y")
for op in self.supported_operations:
expr = op(x, y)
partially_bound_expr = expr.bind({x: 2.3})
self.assertEqual(partially_bound_expr.parameters, {y})
fully_bound_expr = partially_bound_expr.bind({y: -numpy.pi})
self.assertEqual(fully_bound_expr.parameters, set())
self.assertEqual(float(fully_bound_expr), op(2.3, -numpy.pi))
bound_expr = expr.bind({x: 2.3, y: -numpy.pi})
self.assertEqual(bound_expr.parameters, set())
self.assertEqual(float(bound_expr), op(2.3, -numpy.pi))
def test_expressions_operation_order(self):
"""Verify ParameterExpressions respect order of operations."""
x = Parameter("x")
y = Parameter("y")
z = Parameter("z")
# Parenthesis before multiplication/division
expr = (x + y) * z
bound_expr = expr.bind({x: 1, y: 2, z: 3})
self.assertEqual(float(bound_expr), 9)
expr = x * (y + z)
bound_expr = expr.bind({x: 1, y: 2, z: 3})
self.assertEqual(float(bound_expr), 5)
# Multiplication/division before addition/subtraction
expr = x + y * z
bound_expr = expr.bind({x: 1, y: 2, z: 3})
self.assertEqual(float(bound_expr), 7)
expr = x * y + z
bound_expr = expr.bind({x: 1, y: 2, z: 3})
self.assertEqual(float(bound_expr), 5)
def test_nested_expressions(self):
"""Verify ParameterExpressions can also be the target of operations."""
x = Parameter("x")
y = Parameter("y")
z = Parameter("z")
expr1 = x * y
expr2 = expr1 + z
bound_expr2 = expr2.bind({x: 1, y: 2, z: 3})
self.assertEqual(float(bound_expr2), 5)
def test_negated_expression(self):
"""Verify ParameterExpressions can be negated."""
x = Parameter("x")
y = Parameter("y")
z = Parameter("z")
expr1 = -x + y
expr2 = -expr1 * (-z)
bound_expr2 = expr2.bind({x: 1, y: 2, z: 3})
self.assertEqual(float(bound_expr2), 3)
def test_standard_cu3(self):
"""This tests parameter negation in standard extension gate cu3."""
from qiskit.circuit.library import CU3Gate
x = Parameter("x")
y = Parameter("y")
z = Parameter("z")
qc = qiskit.QuantumCircuit(2)
qc.append(CU3Gate(x, y, z), [0, 1])
try:
qc.decompose()
except TypeError:
self.fail("failed to decompose cu3 gate with negated parameter expression")
def test_name_collision(self):
"""Verify Expressions of distinct Parameters of shared name raises."""
x = Parameter("p")
y = Parameter("p")
# Expression of the same Parameter are valid.
_ = x + x
_ = x - x
_ = x * x
_ = x / x
with self.assertRaises(CircuitError):
_ = x + y
with self.assertRaises(CircuitError):
_ = x - y
with self.assertRaises(CircuitError):
_ = x * y
with self.assertRaises(CircuitError):
_ = x / y
@combine(target_type=["gate", "instruction"], order=["bind-decompose", "decompose-bind"])
def test_to_instruction_with_expression(self, target_type, order):
"""Test preservation of expressions via parameterized instructions.
┌───────┐┌──────────┐┌───────────┐
qr1_0: |0>┤ Rx(θ) ├┤ Rz(pi/2) ├┤ Ry(phi*θ) ├
└───────┘└──────────┘└───────────┘
┌───────────┐
qr2_0: |0>───┤ Ry(delta) ├───
┌──┴───────────┴──┐
qr2_1: |0>┤ Circuit0(phi,θ) ├
└─────────────────┘
qr2_2: |0>───────────────────
"""
theta = Parameter("θ")
phi = Parameter("phi")
qr1 = QuantumRegister(1, name="qr1")
qc1 = QuantumCircuit(qr1)
qc1.rx(theta, qr1)
qc1.rz(numpy.pi / 2, qr1)
qc1.ry(theta * phi, qr1)
if target_type == "gate":
gate = qc1.to_gate()
elif target_type == "instruction":
gate = qc1.to_instruction()
self.assertEqual(gate.params, [phi, theta])
delta = Parameter("delta")
qr2 = QuantumRegister(3, name="qr2")
qc2 = QuantumCircuit(qr2)
qc2.ry(delta, qr2[0])
qc2.append(gate, qargs=[qr2[1]])
self.assertEqual(qc2.parameters, {delta, theta, phi})
binds = {delta: 1, theta: 2, phi: 3}
expected_qc = QuantumCircuit(qr2)
expected_qc.rx(2, 1)
expected_qc.rz(numpy.pi / 2, 1)
expected_qc.ry(3 * 2, 1)
expected_qc.r(1, numpy.pi / 2, 0)
if order == "bind-decompose":
decomp_bound_qc = qc2.assign_parameters(binds).decompose()
elif order == "decompose-bind":
decomp_bound_qc = qc2.decompose().assign_parameters(binds)
self.assertEqual(decomp_bound_qc.parameters, set())
self.assertEqual(decomp_bound_qc, expected_qc)
@combine(target_type=["gate", "instruction"], order=["bind-decompose", "decompose-bind"])
def test_to_instruction_expression_parameter_map(self, target_type, order):
"""Test preservation of expressions via instruction parameter_map."""
theta = Parameter("θ")
phi = Parameter("phi")
qr1 = QuantumRegister(1, name="qr1")
qc1 = QuantumCircuit(qr1)
qc1.rx(theta, qr1)
qc1.rz(numpy.pi / 2, qr1)
qc1.ry(theta * phi, qr1)
theta_p = Parameter("theta")
phi_p = Parameter("phi")
if target_type == "gate":
gate = qc1.to_gate(parameter_map={theta: theta_p, phi: phi_p})
elif target_type == "instruction":
gate = qc1.to_instruction(parameter_map={theta: theta_p, phi: phi_p})
self.assertListEqual(gate.params, [theta_p, phi_p])
delta = Parameter("delta")
qr2 = QuantumRegister(3, name="qr2")
qc2 = QuantumCircuit(qr2)
qc2.ry(delta, qr2[0])
qc2.append(gate, qargs=[qr2[1]])
self.assertListEqual(list(qc2.parameters), [delta, phi_p, theta_p])
binds = {delta: 1, theta_p: 2, phi_p: 3}
expected_qc = QuantumCircuit(qr2)
expected_qc.rx(2, 1)
expected_qc.rz(numpy.pi / 2, 1)
expected_qc.ry(3 * 2, 1)
expected_qc.r(1, numpy.pi / 2, 0)
if order == "bind-decompose":
decomp_bound_qc = qc2.assign_parameters(binds).decompose()
elif order == "decompose-bind":
decomp_bound_qc = qc2.decompose().assign_parameters(binds)
self.assertEqual(decomp_bound_qc.parameters, set())
self.assertEqual(decomp_bound_qc, expected_qc)
def test_binding_across_broadcast_instruction(self):
"""Bind a parameter which was included via a broadcast instruction."""
# ref: https://github.com/Qiskit/qiskit-terra/issues/3008
theta = Parameter("θ")
n = 5
qc = QuantumCircuit(n, 1)
qc.h(0)
for i in range(n - 1):
qc.cx(i, i + 1)
qc.barrier()
qc.rz(theta, range(n))
qc.barrier()
for i in reversed(range(n - 1)):
qc.cx(i, i + 1)
qc.h(0)
qc.measure(0, 0)
theta_range = numpy.linspace(0, 2 * numpy.pi, 128)
circuits = [qc.assign_parameters({theta: theta_val}) for theta_val in theta_range]
self.assertEqual(len(circuits), len(theta_range))
for theta_val, bound_circ in zip(theta_range, circuits):
rz_gates = [
inst.operation for inst in bound_circ.data if isinstance(inst.operation, RZGate)
]
self.assertEqual(len(rz_gates), n)
self.assertTrue(all(float(gate.params[0]) == theta_val for gate in rz_gates))
def test_substituting_parameter_with_simple_expression(self):
"""Substitute a simple parameter expression for a parameter."""
x = Parameter("x")
y = Parameter("y")
sub_ = y / 2
updated_expr = x.subs({x: sub_})
expected = y / 2
self.assertEqual(updated_expr, expected)
def test_substituting_parameter_with_compound_expression(self):
"""Substitute a simple parameter expression for a parameter."""
x = Parameter("x")
y = Parameter("y")
z = Parameter("z")
sub_ = y * z
updated_expr = x.subs({x: sub_})
expected = y * z
self.assertEqual(updated_expr, expected)
def test_substituting_simple_with_simple_expression(self):
"""Substitute a simple parameter expression in a parameter expression."""
x = Parameter("x")
expr = x * x
y = Parameter("y")
sub_ = y / 2
updated_expr = expr.subs({x: sub_})
expected = y * y / 4
self.assertEqual(updated_expr, expected)
def test_substituting_compound_expression(self):
"""Substitute a compound parameter expression in a parameter expression."""
x = Parameter("x")
expr = x * x
y = Parameter("y")
z = Parameter("z")
sub_ = y + z
updated_expr = expr.subs({x: sub_})
expected = (y + z) * (y + z)
self.assertEqual(updated_expr, expected)
def test_conjugate(self):
"""Test calling conjugate on a ParameterExpression."""
x = Parameter("x")
self.assertEqual((x.conjugate() + 1j), (x - 1j).conjugate())
@data(
circlib.RGate,
circlib.RXGate,
circlib.RYGate,
circlib.RZGate,
circlib.RXXGate,
circlib.RYYGate,
circlib.RZXGate,
circlib.RZZGate,
circlib.CRXGate,
circlib.CRYGate,
circlib.CRZGate,
circlib.XXPlusYYGate,
)
def test_bound_gate_to_matrix(self, gate_class):
"""Test to_matrix works if previously free parameters are bound.
The conversion might fail, if trigonometric functions such as cos are called on the
parameters and the parameters are still of type ParameterExpression.
"""
num_parameters = 2 if gate_class == circlib.RGate else 1
params = list(range(1, 1 + num_parameters))
free_params = ParameterVector("th", num_parameters)
gate = gate_class(*params)
num_qubits = gate.num_qubits
circuit = QuantumCircuit(num_qubits)
circuit.append(gate_class(*free_params), list(range(num_qubits)))
bound_circuit = circuit.assign_parameters({free_params: params})
numpy.testing.assert_array_almost_equal(Operator(bound_circuit).data, gate.to_matrix())
def test_parameter_expression_grad(self):
"""Verify correctness of ParameterExpression gradients."""
x = Parameter("x")
y = Parameter("y")
z = Parameter("z")
with self.subTest(msg="first order gradient"):
expr = (x + y) * z
self.assertEqual(expr.gradient(x), z)
self.assertEqual(expr.gradient(z), (x + y))
with self.subTest(msg="second order gradient"):
expr = x * x
self.assertEqual(expr.gradient(x), 2 * x)
self.assertEqual(expr.gradient(x).gradient(x), 2)
def test_bound_expression_is_real(self):
"""Test is_real on bound parameters."""
x = Parameter("x")
self.assertEqual(x.is_real(), None)
self.assertEqual((1j * x).is_real(), None)
expr = 1j * x
bound = expr.bind({x: 2})
self.assertEqual(bound.is_real(), False)
bound = x.bind({x: 0 + 0j})
self.assertEqual(bound.is_real(), True)
bound = x.bind({x: 0 + 1j})
self.assertEqual(bound.is_real(), False)
bound = x.bind({x: 1 + 0j})
self.assertEqual(bound.is_real(), True)
bound = x.bind({x: 1 + 1j})
self.assertEqual(bound.is_real(), False)
class TestParameterEquality(QiskitTestCase):
"""Test equality of Parameters and ParameterExpressions."""
def test_parameter_equal_self(self):
"""Verify a parameter is equal to it self."""
theta = Parameter("theta")
self.assertEqual(theta, theta)
def test_parameter_not_equal_param_of_same_name(self):
"""Verify a parameter is not equal to a Parameter of the same name."""
theta1 = Parameter("theta")
theta2 = Parameter("theta")
self.assertNotEqual(theta1, theta2)
def test_parameter_expression_equal_to_self(self):
"""Verify an expression is equal to itself."""
theta = Parameter("theta")
expr = 2 * theta
self.assertEqual(expr, expr)
def test_parameter_expression_equal_to_identical(self):
"""Verify an expression is equal an identical expression."""
theta = Parameter("theta")
expr1 = 2 * theta
expr2 = 2 * theta
self.assertEqual(expr1, expr2)
def test_parameter_expression_equal_floats_to_ints(self):
"""Verify an expression with float and int is identical."""
theta = Parameter("theta")
expr1 = 2.0 * theta
expr2 = 2 * theta
self.assertEqual(expr1, expr2)
def test_parameter_expression_not_equal_if_params_differ(self):
"""Verify expressions not equal if parameters are different."""
theta1 = Parameter("theta")
theta2 = Parameter("theta")
expr1 = 2 * theta1
expr2 = 2 * theta2
self.assertNotEqual(expr1, expr2)
def test_parameter_equal_to_identical_expression(self):
"""Verify parameters and ParameterExpressions can be equal if identical."""
theta = Parameter("theta")
phi = Parameter("phi")
expr = (theta + phi).bind({phi: 0})
self.assertEqual(expr, theta)
self.assertEqual(theta, expr)
def test_parameter_symbol_equal_after_ufunc(self):
"""Verfiy ParameterExpression phi
and ParameterExpression cos(phi) have the same symbol map"""
phi = Parameter("phi")
cos_phi = numpy.cos(phi)
self.assertEqual(phi._parameter_symbols, cos_phi._parameter_symbols)
class TestParameterReferences(QiskitTestCase):
"""Test the ParameterReferences class."""
def test_equal_inst_diff_instance(self):
"""Different value equal instructions are treated as distinct."""
theta = Parameter("theta")
gate1 = RZGate(theta)
gate2 = RZGate(theta)
self.assertIsNot(gate1, gate2)
self.assertEqual(gate1, gate2)
refs = ParameterReferences(((gate1, 0), (gate2, 0)))
# test __contains__
self.assertIn((gate1, 0), refs)
self.assertIn((gate2, 0), refs)
gate_ids = {id(gate1), id(gate2)}
self.assertEqual(gate_ids, {id(gate) for gate, _ in refs})
self.assertTrue(all(idx == 0 for _, idx in refs))
def test_pickle_unpickle(self):
"""Membership testing after pickle/unpickle."""
theta = Parameter("theta")
gate1 = RZGate(theta)
gate2 = RZGate(theta)
self.assertIsNot(gate1, gate2)
self.assertEqual(gate1, gate2)
refs = ParameterReferences(((gate1, 0), (gate2, 0)))
to_pickle = (gate1, refs)
pickled = pickle.dumps(to_pickle)
(gate1_new, refs_new) = pickle.loads(pickled)
self.assertEqual(len(refs_new), len(refs))
self.assertNotIn((gate1, 0), refs_new)
self.assertIn((gate1_new, 0), refs_new)
def test_equal_inst_same_instance(self):
"""Referentially equal instructions are treated as same."""
theta = Parameter("theta")
gate = RZGate(theta)
refs = ParameterReferences(((gate, 0), (gate, 0)))
self.assertIn((gate, 0), refs)
self.assertEqual(len(refs), 1)
self.assertIs(next(iter(refs))[0], gate)
self.assertEqual(next(iter(refs))[1], 0)
def test_extend_refs(self):
"""Extending references handles duplicates."""
theta = Parameter("theta")
ref0 = (RZGate(theta), 0)
ref1 = (RZGate(theta), 0)
ref2 = (RZGate(theta), 0)
refs = ParameterReferences((ref0,))
refs |= ParameterReferences((ref0, ref1, ref2, ref1, ref0))
self.assertEqual(refs, ParameterReferences((ref0, ref1, ref2)))
def test_copy_param_refs(self):
"""Copy of parameter references is a shallow copy."""
theta = Parameter("theta")
ref0 = (RZGate(theta), 0)
ref1 = (RZGate(theta), 0)
ref2 = (RZGate(theta), 0)
ref3 = (RZGate(theta), 0)
refs = ParameterReferences((ref0, ref1))
refs_copy = refs.copy()
# Check same gate instances in copy
gate_ids = {id(ref0[0]), id(ref1[0])}
self.assertEqual({id(gate) for gate, _ in refs_copy}, gate_ids)
# add new ref to original and check copy not modified
refs.add(ref2)
self.assertNotIn(ref2, refs_copy)
self.assertEqual(refs_copy, ParameterReferences((ref0, ref1)))
# add new ref to copy and check original not modified
refs_copy.add(ref3)
self.assertNotIn(ref3, refs)
self.assertEqual(refs, ParameterReferences((ref0, ref1, ref2)))
class TestParameterTable(QiskitTestCase):
"""Test the ParameterTable class."""
def test_init_param_table(self):
"""Parameter table init from mapping."""
p1 = Parameter("theta")
p2 = Parameter("theta")
ref0 = (RZGate(p1), 0)
ref1 = (RZGate(p1), 0)
ref2 = (RZGate(p2), 0)
mapping = {p1: ParameterReferences((ref0, ref1)), p2: ParameterReferences((ref2,))}
table = ParameterTable(mapping)
# make sure editing mapping doesn't change `table`
del mapping[p1]
self.assertEqual(table[p1], ParameterReferences((ref0, ref1)))
self.assertEqual(table[p2], ParameterReferences((ref2,)))
def test_set_references(self):
"""References replacement by parameter key."""
p1 = Parameter("theta")
ref0 = (RZGate(p1), 0)
ref1 = (RZGate(p1), 0)
table = ParameterTable()
table[p1] = ParameterReferences((ref0, ref1))
self.assertEqual(table[p1], ParameterReferences((ref0, ref1)))
table[p1] = ParameterReferences((ref1,))
self.assertEqual(table[p1], ParameterReferences((ref1,)))
def test_set_references_from_iterable(self):
"""Parameter table init from iterable."""
p1 = Parameter("theta")
ref0 = (RZGate(p1), 0)
ref1 = (RZGate(p1), 0)
ref2 = (RZGate(p1), 0)
table = ParameterTable({p1: ParameterReferences((ref0, ref1))})
table[p1] = (ref2, ref1, ref0)
self.assertEqual(table[p1], ParameterReferences((ref2, ref1, ref0)))
class TestParameterView(QiskitTestCase):
"""Test the ParameterView object."""
def setUp(self):
super().setUp()
x, y, z = Parameter("x"), Parameter("y"), Parameter("z")
self.params = [x, y, z]
self.view1 = ParameterView([x, y])
self.view2 = ParameterView([y, z])
self.view3 = ParameterView([x])
def test_and(self):
"""Test __and__."""
self.assertEqual(self.view1 & self.view2, {self.params[1]})
def test_or(self):
"""Test __or__."""
self.assertEqual(self.view1 | self.view2, set(self.params))
def test_xor(self):
"""Test __xor__."""
self.assertEqual(self.view1 ^ self.view2, {self.params[0], self.params[2]})
def test_len(self):
"""Test __len__."""
self.assertEqual(len(self.view1), 2)
def test_le(self):
"""Test __le__."""
self.assertTrue(self.view1 <= self.view1)
self.assertFalse(self.view1 <= self.view3)
def test_lt(self):
"""Test __lt__."""
self.assertTrue(self.view3 < self.view1)
def test_ge(self):
"""Test __ge__."""
self.assertTrue(self.view1 >= self.view1)
self.assertFalse(self.view3 >= self.view1)
def test_gt(self):
"""Test __lt__."""
self.assertTrue(self.view1 > self.view3)
def test_eq(self):
"""Test __eq__."""
self.assertTrue(self.view1 == self.view1)
self.assertFalse(self.view3 == self.view1)
def test_ne(self):
"""Test __eq__."""
self.assertTrue(self.view1 != self.view2)
self.assertFalse(self.view3 != self.view3)
if __name__ == "__main__":
unittest.main()
|
https://github.com/swe-train/qiskit__qiskit
|
swe-train
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2024.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# pylint: disable=missing-function-docstring, missing-module-docstring
import unittest
from qiskit import QuantumCircuit
from qiskit.providers.basic_provider import BasicSimulator
import qiskit.circuit.library.standard_gates as lib
from test import QiskitTestCase # pylint: disable=wrong-import-order
class TestStandardGates(QiskitTestCase):
"""Standard gates support in BasicSimulator, up to 3 qubits"""
def setUp(self):
super().setUp()
self.seed = 43
self.shots = 1
self.circuit = QuantumCircuit(4)
def test_barrier(self):
self.circuit.barrier(0, 1)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_barrier_none(self):
self.circuit.barrier()
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_unitary(self):
matrix = [[0, 0, 0, 1], [0, 0, 1, 0], [1, 0, 0, 0], [0, 1, 0, 0]]
self.circuit.unitary(matrix, [0, 1])
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_u(self):
self.circuit.u(0.5, 1.5, 1.5, 0)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_u1(self):
self.circuit.append(lib.U1Gate(0.5), [1])
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_u2(self):
self.circuit.append(lib.U2Gate(0.5, 0.5), [1])
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_u3(self):
self.circuit.append(lib.U3Gate(0.5, 0.5, 0.5), [1])
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_ccx(self):
self.circuit.ccx(0, 1, 2)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_ccz(self):
self.circuit.ccz(0, 1, 2)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_ch(self):
self.circuit.ch(0, 1)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_cp(self):
self.circuit.cp(0, 0, 1)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_crx(self):
self.circuit.crx(1, 0, 1)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_cry(self):
self.circuit.cry(1, 0, 1)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_crz(self):
self.circuit.crz(1, 0, 1)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_cswap(self):
self.circuit.cswap(0, 1, 2)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_cu1(self):
self.circuit.append(lib.CU1Gate(1), [1, 2])
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_cu3(self):
self.circuit.append(lib.CU3Gate(1, 2, 3), [1, 2])
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_cx(self):
self.circuit.cx(1, 2)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_ecr(self):
self.circuit.ecr(1, 2)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_cy(self):
self.circuit.cy(1, 2)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_cz(self):
self.circuit.cz(1, 2)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_h(self):
self.circuit.h(1)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_id(self):
self.circuit.id(1)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_rx(self):
self.circuit.rx(1, 1)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_ry(self):
self.circuit.ry(1, 1)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_rz(self):
self.circuit.rz(1, 1)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_rxx(self):
self.circuit.rxx(1, 1, 0)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_rzx(self):
self.circuit.rzx(1, 1, 0)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_ryy(self):
self.circuit.ryy(1, 1, 0)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_rzz(self):
self.circuit.rzz(1, 1, 2)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_s(self):
self.circuit.s(1)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_sdg(self):
self.circuit.sdg(1)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_sx(self):
self.circuit.sx(1)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_sxdg(self):
self.circuit.sxdg(1)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_swap(self):
self.circuit.swap(1, 2)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_iswap(self):
self.circuit.iswap(1, 0)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_p(self):
self.circuit.p(1, 0)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_r(self):
self.circuit.r(0.5, 0, 1)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_t(self):
self.circuit.t(1)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_tdg(self):
self.circuit.tdg(1)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_x(self):
self.circuit.x(1)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_y(self):
self.circuit.y(1)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_z(self):
self.circuit.z(1)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_cs(self):
self.circuit.cs(0, 1)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_csdg(self):
self.circuit.csdg(0, 1)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_csx(self):
self.circuit.csx(0, 1)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_cu(self):
self.circuit.cu(0.5, 0.5, 0.5, 0.5, 0, 1)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_dcx(self):
self.circuit.dcx(0, 1)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_delay(self):
self.circuit.delay(0, 1)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_reset(self):
self.circuit.reset(1)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_rcx(self):
self.circuit.rccx(0, 1, 2)
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_global_phase(self):
qc = self.circuit
qc.append(lib.GlobalPhaseGate(0.1), [])
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_xx_minus_yy(self):
self.circuit.append(lib.XXMinusYYGate(0.1, 0.2), [0, 1])
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
def test_xx_plus_yy(self):
self.circuit.append(lib.XXPlusYYGate(0.1, 0.2), [0, 1])
self.circuit.measure_all()
result = (
BasicSimulator().run(self.circuit, shots=self.shots, seed_simulator=self.seed).result()
)
self.assertEqual(result.success, True)
class TestStandardGatesTarget(QiskitTestCase):
"""Standard gates, up to 3 qubits, as a target"""
def test_target(self):
target = BasicSimulator().target
expected = {
"cz",
"u3",
"p",
"cswap",
"z",
"cu1",
"ecr",
"reset",
"ch",
"cy",
"dcx",
"crx",
"sx",
"unitary",
"csdg",
"rzz",
"measure",
"swap",
"csx",
"y",
"s",
"xx_plus_yy",
"cs",
"h",
"t",
"u",
"rxx",
"cu",
"rzx",
"ry",
"rx",
"cu3",
"tdg",
"u2",
"xx_minus_yy",
"global_phase",
"u1",
"id",
"cx",
"cp",
"rz",
"sxdg",
"x",
"ryy",
"sdg",
"ccz",
"delay",
"crz",
"iswap",
"ccx",
"cry",
"rccx",
"r",
}
self.assertEqual(set(target.operation_names), expected)
if __name__ == "__main__":
unittest.main(verbosity=2)
|
https://github.com/2lambda123/Qiskit-qiskit
|
2lambda123
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2020.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""
Testing InverseCancellation
"""
import unittest
import numpy as np
from qiskit import QuantumCircuit
from qiskit.transpiler.exceptions import TranspilerError
from qiskit.transpiler.passes import InverseCancellation
from qiskit.transpiler import PassManager
from qiskit.test import QiskitTestCase
from qiskit.circuit.library import RXGate, HGate, CXGate, PhaseGate, XGate, TGate, TdgGate
class TestInverseCancellation(QiskitTestCase):
"""Test the InverseCancellation transpiler pass."""
def test_basic_self_inverse(self):
"""Test that a single self-inverse gate as input can be cancelled."""
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.h(0)
pass_ = InverseCancellation([HGate()])
pm = PassManager(pass_)
new_circ = pm.run(qc)
gates_after = new_circ.count_ops()
self.assertNotIn("h", gates_after)
def test_odd_number_self_inverse(self):
"""Test that an odd number of self-inverse gates leaves one gate remaining."""
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.h(0)
qc.h(0)
pass_ = InverseCancellation([HGate()])
pm = PassManager(pass_)
new_circ = pm.run(qc)
gates_after = new_circ.count_ops()
self.assertIn("h", gates_after)
self.assertEqual(gates_after["h"], 1)
def test_basic_cx_self_inverse(self):
"""Test that a single self-inverse cx gate as input can be cancelled."""
qc = QuantumCircuit(2, 2)
qc.cx(0, 1)
qc.cx(0, 1)
pass_ = InverseCancellation([CXGate()])
pm = PassManager(pass_)
new_circ = pm.run(qc)
gates_after = new_circ.count_ops()
self.assertNotIn("cx", gates_after)
def test_basic_gate_inverse(self):
"""Test that a basic pair of gate inverse can be cancelled."""
qc = QuantumCircuit(2, 2)
qc.rx(np.pi / 4, 0)
qc.rx(-np.pi / 4, 0)
pass_ = InverseCancellation([(RXGate(np.pi / 4), RXGate(-np.pi / 4))])
pm = PassManager(pass_)
new_circ = pm.run(qc)
gates_after = new_circ.count_ops()
self.assertNotIn("rx", gates_after)
def test_non_inverse_do_not_cancel(self):
"""Test that non-inverse gate pairs do not cancel."""
qc = QuantumCircuit(2, 2)
qc.rx(np.pi / 4, 0)
qc.rx(np.pi / 4, 0)
pass_ = InverseCancellation([(RXGate(np.pi / 4), RXGate(-np.pi / 4))])
pm = PassManager(pass_)
new_circ = pm.run(qc)
gates_after = new_circ.count_ops()
self.assertIn("rx", gates_after)
self.assertEqual(gates_after["rx"], 2)
def test_non_consecutive_gates(self):
"""Test that only consecutive gates cancel."""
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.h(0)
qc.h(0)
qc.cx(0, 1)
qc.cx(0, 1)
qc.h(0)
pass_ = InverseCancellation([HGate(), CXGate()])
pm = PassManager(pass_)
new_circ = pm.run(qc)
gates_after = new_circ.count_ops()
self.assertNotIn("cx", gates_after)
self.assertEqual(gates_after["h"], 2)
def test_gate_inverse_phase_gate(self):
"""Test that an inverse pair of a PhaseGate can be cancelled."""
qc = QuantumCircuit(2, 2)
qc.p(np.pi / 4, 0)
qc.p(-np.pi / 4, 0)
pass_ = InverseCancellation([(PhaseGate(np.pi / 4), PhaseGate(-np.pi / 4))])
pm = PassManager(pass_)
new_circ = pm.run(qc)
gates_after = new_circ.count_ops()
self.assertNotIn("p", gates_after)
def test_self_inverse_on_different_qubits(self):
"""Test that self_inverse gates cancel on the correct qubits."""
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.h(1)
qc.h(0)
qc.h(1)
pass_ = InverseCancellation([HGate()])
pm = PassManager(pass_)
new_circ = pm.run(qc)
gates_after = new_circ.count_ops()
self.assertNotIn("h", gates_after)
def test_non_inverse_raise_error(self):
"""Test that non-inverse gate inputs raise an error."""
qc = QuantumCircuit(2, 2)
qc.rx(np.pi / 2, 0)
qc.rx(np.pi / 4, 0)
with self.assertRaises(TranspilerError):
InverseCancellation([RXGate(0.5)])
def test_non_gate_inverse_raise_error(self):
"""Test that non-inverse gate inputs raise an error."""
qc = QuantumCircuit(2, 2)
qc.rx(np.pi / 4, 0)
qc.rx(np.pi / 4, 0)
with self.assertRaises(TranspilerError):
InverseCancellation([(RXGate(np.pi / 4))])
def test_string_gate_error(self):
"""Test that when gate is passed as a string an error is raised."""
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.h(0)
with self.assertRaises(TranspilerError):
InverseCancellation(["h"])
def test_consecutive_self_inverse_h_x_gate(self):
"""Test that only consecutive self-inverse gates cancel."""
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.h(0)
qc.h(0)
qc.x(0)
qc.x(0)
qc.h(0)
pass_ = InverseCancellation([HGate(), XGate()])
pm = PassManager(pass_)
new_circ = pm.run(qc)
gates_after = new_circ.count_ops()
self.assertNotIn("x", gates_after)
self.assertEqual(gates_after["h"], 2)
def test_inverse_with_different_names(self):
"""Test that inverse gates that have different names."""
qc = QuantumCircuit(2, 2)
qc.t(0)
qc.tdg(0)
pass_ = InverseCancellation([(TGate(), TdgGate())])
pm = PassManager(pass_)
new_circ = pm.run(qc)
gates_after = new_circ.count_ops()
self.assertNotIn("t", gates_after)
self.assertNotIn("tdg", gates_after)
def test_three_alternating_inverse_gates(self):
"""Test that inverse cancellation works correctly for alternating sequences
of inverse gates of odd-length."""
qc = QuantumCircuit(2, 2)
qc.p(np.pi / 4, 0)
qc.p(-np.pi / 4, 0)
qc.p(np.pi / 4, 0)
pass_ = InverseCancellation([(PhaseGate(np.pi / 4), PhaseGate(-np.pi / 4))])
pm = PassManager(pass_)
new_circ = pm.run(qc)
gates_after = new_circ.count_ops()
self.assertIn("p", gates_after)
self.assertEqual(gates_after["p"], 1)
def test_four_alternating_inverse_gates(self):
"""Test that inverse cancellation works correctly for alternating sequences
of inverse gates of even-length."""
qc = QuantumCircuit(2, 2)
qc.p(np.pi / 4, 0)
qc.p(-np.pi / 4, 0)
qc.p(np.pi / 4, 0)
qc.p(-np.pi / 4, 0)
pass_ = InverseCancellation([(PhaseGate(np.pi / 4), PhaseGate(-np.pi / 4))])
pm = PassManager(pass_)
new_circ = pm.run(qc)
gates_after = new_circ.count_ops()
self.assertNotIn("p", gates_after)
def test_five_alternating_inverse_gates(self):
"""Test that inverse cancellation works correctly for alternating sequences
of inverse gates of odd-length."""
qc = QuantumCircuit(2, 2)
qc.p(np.pi / 4, 0)
qc.p(-np.pi / 4, 0)
qc.p(np.pi / 4, 0)
qc.p(-np.pi / 4, 0)
qc.p(np.pi / 4, 0)
pass_ = InverseCancellation([(PhaseGate(np.pi / 4), PhaseGate(-np.pi / 4))])
pm = PassManager(pass_)
new_circ = pm.run(qc)
gates_after = new_circ.count_ops()
self.assertIn("p", gates_after)
self.assertEqual(gates_after["p"], 1)
def test_sequence_of_inverse_gates_1(self):
"""Test that inverse cancellation works correctly for more general sequences
of inverse gates. In this test two pairs of inverse gates are supposed to
cancel out."""
qc = QuantumCircuit(2, 2)
qc.p(np.pi / 4, 0)
qc.p(-np.pi / 4, 0)
qc.p(-np.pi / 4, 0)
qc.p(np.pi / 4, 0)
qc.p(np.pi / 4, 0)
pass_ = InverseCancellation([(PhaseGate(np.pi / 4), PhaseGate(-np.pi / 4))])
pm = PassManager(pass_)
new_circ = pm.run(qc)
gates_after = new_circ.count_ops()
self.assertIn("p", gates_after)
self.assertEqual(gates_after["p"], 1)
def test_sequence_of_inverse_gates_2(self):
"""Test that inverse cancellation works correctly for more general sequences
of inverse gates. In this test, in theory three pairs of inverse gates can
cancel out, but in practice only two pairs are back-to-back."""
qc = QuantumCircuit(2, 2)
qc.p(np.pi / 4, 0)
qc.p(np.pi / 4, 0)
qc.p(-np.pi / 4, 0)
qc.p(-np.pi / 4, 0)
qc.p(-np.pi / 4, 0)
qc.p(np.pi / 4, 0)
qc.p(np.pi / 4, 0)
pass_ = InverseCancellation([(PhaseGate(np.pi / 4), PhaseGate(-np.pi / 4))])
pm = PassManager(pass_)
new_circ = pm.run(qc)
gates_after = new_circ.count_ops()
self.assertIn("p", gates_after)
self.assertEqual(gates_after["p"] % 2, 1)
def test_cx_do_not_wrongly_cancel(self):
"""Test that CX(0,1) and CX(1, 0) do not cancel out, when (CX, CX) is passed
as an inverse pair."""
qc = QuantumCircuit(2, 0)
qc.cx(0, 1)
qc.cx(1, 0)
pass_ = InverseCancellation([(CXGate(), CXGate())])
pm = PassManager(pass_)
new_circ = pm.run(qc)
gates_after = new_circ.count_ops()
self.assertIn("cx", gates_after)
self.assertEqual(gates_after["cx"], 2)
if __name__ == "__main__":
unittest.main()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.