repo
stringclasses 900
values | file
stringclasses 754
values | content
stringlengths 4
215k
|
|---|---|---|
https://github.com/xtophe388/QISKIT
|
xtophe388
|
import qiskit
qiskit.__qiskit_version__
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
# importing Qiskit
from qiskit import BasicAer, IBMQ
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.compiler import transpile
from qiskit.tools.visualization import plot_histogram
q = QuantumRegister(6)
qc = QuantumCircuit(q)
qc.x(q[2])
qc.cx(q[1], q[5])
qc.cx(q[2], q[5])
qc.cx(q[3], q[5])
qc.ccx(q[1], q[2], q[4])
qc.ccx(q[3], q[4], q[5])
qc.ccx(q[1], q[2], q[4])
qc.x(q[2])
qc.draw(output='mpl')
def black_box_u_f(circuit, f_in, f_out, aux, n, exactly_1_3_sat_formula):
"""Circuit that computes the black-box function from f_in to f_out.
Create a circuit that verifies whether a given exactly-1 3-SAT
formula is satisfied by the input. The exactly-1 version
requires exactly one literal out of every clause to be satisfied.
"""
num_clauses = len(exactly_1_3_sat_formula)
for (k, clause) in enumerate(exactly_1_3_sat_formula):
# This loop ensures aux[k] is 1 if an odd number of literals
# are true
for literal in clause:
if literal > 0:
circuit.cx(f_in[literal-1], aux[k])
else:
circuit.x(f_in[-literal-1])
circuit.cx(f_in[-literal-1], aux[k])
# Flip aux[k] if all literals are true, using auxiliary qubit
# (ancilla) aux[num_clauses]
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
circuit.ccx(f_in[2], aux[num_clauses], aux[k])
# Flip back to reverse state of negative literals and ancilla
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
for literal in clause:
if literal < 0:
circuit.x(f_in[-literal-1])
# The formula is satisfied if and only if all auxiliary qubits
# except aux[num_clauses] are 1
if (num_clauses == 1):
circuit.cx(aux[0], f_out[0])
elif (num_clauses == 2):
circuit.ccx(aux[0], aux[1], f_out[0])
elif (num_clauses == 3):
circuit.ccx(aux[0], aux[1], aux[num_clauses])
circuit.ccx(aux[2], aux[num_clauses], f_out[0])
circuit.ccx(aux[0], aux[1], aux[num_clauses])
else:
raise ValueError('We only allow at most 3 clauses')
# Flip back any auxiliary qubits to make sure state is consistent
# for future executions of this routine; same loop as above.
for (k, clause) in enumerate(exactly_1_3_sat_formula):
for literal in clause:
if literal > 0:
circuit.cx(f_in[literal-1], aux[k])
else:
circuit.x(f_in[-literal-1])
circuit.cx(f_in[-literal-1], aux[k])
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
circuit.ccx(f_in[2], aux[num_clauses], aux[k])
circuit.ccx(f_in[0], f_in[1], aux[num_clauses])
for literal in clause:
if literal < 0:
circuit.x(f_in[-literal-1])
# -- end function
def n_controlled_Z(circuit, controls, target):
"""Implement a Z gate with multiple controls"""
if (len(controls) > 2):
raise ValueError('The controlled Z with more than 2 ' +
'controls is not implemented')
elif (len(controls) == 1):
circuit.h(target)
circuit.cx(controls[0], target)
circuit.h(target)
elif (len(controls) == 2):
circuit.h(target)
circuit.ccx(controls[0], controls[1], target)
circuit.h(target)
# -- end function
def inversion_about_average(circuit, f_in, n):
"""Apply inversion about the average step of Grover's algorithm."""
# Hadamards everywhere
for j in range(n):
circuit.h(f_in[j])
# D matrix: flips the sign of the state |000> only
for j in range(n):
circuit.x(f_in[j])
n_controlled_Z(circuit, [f_in[j] for j in range(n-1)], f_in[n-1])
for j in range(n):
circuit.x(f_in[j])
# Hadamards everywhere again
for j in range(n):
circuit.h(f_in[j])
# -- end function
qr = QuantumRegister(3)
qInvAvg = QuantumCircuit(qr)
inversion_about_average(qInvAvg, qr, 3)
qInvAvg.draw(output='mpl')
"""
Grover search implemented in Qiskit.
This module contains the code necessary to run Grover search on 3
qubits, both with a simulator and with a real quantum computing
device. This code is the companion for the paper
"An introduction to quantum computing, without the physics",
Giacomo Nannicini, https://arxiv.org/abs/1708.03684.
"""
def input_state(circuit, f_in, f_out, n):
"""(n+1)-qubit input state for Grover search."""
for j in range(n):
circuit.h(f_in[j])
circuit.x(f_out)
circuit.h(f_out)
# -- end function
# Make a quantum program for the n-bit Grover search.
n = 3
# Exactly-1 3-SAT formula to be satisfied, in conjunctive
# normal form. We represent literals with integers, positive or
# negative, to indicate a Boolean variable or its negation.
exactly_1_3_sat_formula = [[1, 2, -3], [-1, -2, -3], [-1, 2, 3]]
# Define three quantum registers: 'f_in' is the search space (input
# to the function f), 'f_out' is bit used for the output of function
# f, aux are the auxiliary bits used by f to perform its
# computation.
f_in = QuantumRegister(n)
f_out = QuantumRegister(1)
aux = QuantumRegister(len(exactly_1_3_sat_formula) + 1)
# Define classical register for algorithm result
ans = ClassicalRegister(n)
# Define quantum circuit with above registers
grover = QuantumCircuit()
grover.add_register(f_in)
grover.add_register(f_out)
grover.add_register(aux)
grover.add_register(ans)
input_state(grover, f_in, f_out, n)
T = 2
for t in range(T):
# Apply T full iterations
black_box_u_f(grover, f_in, f_out, aux, n, exactly_1_3_sat_formula)
inversion_about_average(grover, f_in, n)
# Measure the output register in the computational basis
for j in range(n):
grover.measure(f_in[j], ans[j])
# Execute circuit
backend = BasicAer.get_backend('qasm_simulator')
job = execute([grover], backend=backend, shots=1000)
result = job.result()
# Get counts and plot histogram
counts = result.get_counts(grover)
plot_histogram(counts)
IBMQ.load_account()
# get ibmq_16_melbourne configuration and coupling map
backend = IBMQ.get_backend('ibmq_16_melbourne')
# compile the circuit for ibmq_16_rueschlikon
grover_compiled = transpile(grover, backend=backend, seed_transpiler=1, optimization_level=3)
print('gates = ', grover_compiled.count_ops())
print('depth = ', grover_compiled.depth())
grover.draw(output='mpl', scale=0.5)
|
https://github.com/xtophe388/QISKIT
|
xtophe388
|
import qiskit
qiskit.__qiskit_version__
from math import pi
import numpy as np
import scipy as sp
import matplotlib.pyplot as plt
%matplotlib inline
# importing Qiskit
from qiskit import BasicAer, IBMQ
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute
from qiskit.tools.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor
# Load saved IBMQ accounts
IBMQ.load_account()
# 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)
# We then prepare quantum and classical registers and the circuit
qr = QuantumRegister(2)
cr = ClassicalRegister(4)
circuitName="IPEAonSimulator"
ipeaCircuit = QuantumCircuit(qr, cr)
# Apply IPEA
ipeaCircuit.h(qr[0])
for i in range(8):
cu5pi8(ipeaCircuit, qr[0], qr[1])
ipeaCircuit.h(qr[0])
ipeaCircuit.measure(qr[0], cr[0])
ipeaCircuit.reset(qr[0])
ipeaCircuit.h(qr[0])
for i in range(4):
cu5pi8(ipeaCircuit, qr[0], qr[1])
ipeaCircuit.u1(-pi/2, qr[0]).c_if(cr, 1)
ipeaCircuit.h(qr[0])
ipeaCircuit.measure(qr[0], cr[1])
ipeaCircuit.reset(qr[0])
ipeaCircuit.h(qr[0])
for i in range(2):
cu5pi8(ipeaCircuit, qr[0], qr[1])
ipeaCircuit.u1(-pi/4, qr[0]).c_if(cr, 1)
ipeaCircuit.u1(-pi/2, qr[0]).c_if(cr, 2)
ipeaCircuit.u1(-3*pi/4, qr[0]).c_if(cr, 3)
ipeaCircuit.h(qr[0])
ipeaCircuit.measure(qr[0], cr[2])
ipeaCircuit.reset(qr[0])
ipeaCircuit.h(qr[0])
cu5pi8(ipeaCircuit, qr[0], qr[1])
ipeaCircuit.u1(-pi/8, qr[0]).c_if(cr, 1)
ipeaCircuit.u1(-2*pi/8, qr[0]).c_if(cr, 2)
ipeaCircuit.u1(-3*pi/8, qr[0]).c_if(cr, 3)
ipeaCircuit.u1(-4*pi/8, qr[0]).c_if(cr, 4)
ipeaCircuit.u1(-5*pi/8, qr[0]).c_if(cr, 5)
ipeaCircuit.u1(-6*pi/8, qr[0]).c_if(cr, 6)
ipeaCircuit.u1(-7*pi/8, qr[0]).c_if(cr, 7)
ipeaCircuit.h(qr[0])
ipeaCircuit.measure(qr[0], cr[3])
backend = BasicAer.get_backend('qasm_simulator')
shots = 1000
results = execute(ipeaCircuit, backend=backend, shots=shots).result()
plot_histogram(results.get_counts())
# We then prepare quantum and classical registers and the circuit
qr = QuantumRegister(5)
cr = ClassicalRegister(5)
realStep1Circuit = QuantumCircuit(qr, cr)
# Apply IPEA
realStep1Circuit.h(qr[0])
for i in range(8):
cu5pi8(realStep1Circuit, qr[0], qr[1])
realStep1Circuit.h(qr[0])
realStep1Circuit.measure(qr[0], cr[0])
#connect to remote API to be able to use remote simulators and real devices
print("Available backends:", [BasicAer.backends(), IBMQ.backends()])
backend = IBMQ.get_backend("ibmq_5_yorktown")
shots = 1000
job_exp1 = execute(realStep1Circuit, backend=backend, shots=shots)
job_monitor(job_exp1)
results1 = job_exp1.result()
plot_histogram(results1.get_counts())
realStep2Circuit = QuantumCircuit(qr, cr)
# Apply IPEA
realStep2Circuit.h(qr[0])
for i in range(4):
cu5pi8(realStep2Circuit, qr[0], qr[1])
realStep2Circuit.u1(-pi/2, qr[0]) # Assuming the value of the measurement on Step 1
realStep2Circuit.h(qr[0])
realStep2Circuit.measure(qr[0], cr[0])
job_exp2 = execute(realStep2Circuit, backend=backend, shots=shots)
job_monitor(job_exp1)
results2 = job_exp2.result()
plot_histogram(results2.get_counts())
realStep3Circuit = QuantumCircuit(qr, cr)
# Apply IPEA
realStep3Circuit.h(qr[0])
for i in range(2):
cu5pi8(realStep3Circuit, qr[0], qr[1])
realStep3Circuit.u1(-3*pi/4, qr[0]) # Assuming the value of the measurement on Step 1 and Step 2
realStep3Circuit.h(qr[0])
realStep3Circuit.measure(qr[0], cr[0])
job_exp3 = execute(realStep3Circuit, backend=backend, shots=shots)
job_monitor(job_exp3)
results3 = job_exp3.result()
plot_histogram(results3.get_counts())
realStep4Circuit = QuantumCircuit(qr, cr)
# Apply IPEA
realStep4Circuit.h(qr[0])
cu5pi8(realStep4Circuit, qr[0], qr[1])
realStep4Circuit.u1(-3*pi/8, qr[0]) # Assuming the value of the measurement on Step 1, 2, and 3
realStep4Circuit.h(qr[0])
realStep4Circuit.measure(qr[0], cr[0])
job_exp4 = execute(realStep4Circuit, backend=backend, shots=shots)
job_monitor(job_exp4)
results4 = job_exp4.result()
plot_histogram(results4.get_counts())
|
https://github.com/xtophe388/QISKIT
|
xtophe388
|
import qiskit
qiskit.__qiskit_version__
#initialization
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
# importing Qiskit
from qiskit import BasicAer, IBMQ
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.compiler import transpile
from qiskit.tools.monitor import job_monitor
# import basic plot tools
from qiskit.tools.visualization import plot_histogram
# Load the saved IBMQ accounts
IBMQ.load_account()
s = "010101" # the hidden bitstring
assert 1 < len(s) < 20, "The length of s must be between 2 and 19"
for c in s:
assert c == "0" or c == "1", "s must be a bitstring of '0' and '1'"
n = len(s) #the length of the bitstring
# Step 1
# Creating registers
# qubits for querying the oracle and recording its output
qr = QuantumRegister(2*n)
# for recording the measurement on the first register of qr
cr = ClassicalRegister(n)
circuitName = "Simon"
simonCircuit = QuantumCircuit(qr, cr)
# Step 2
# Apply Hadamard gates before querying the oracle
for i in range(n):
simonCircuit.h(qr[i])
# Apply barrier to mark the beginning of the blackbox function
simonCircuit.barrier()
# Step 3 query the blackbox function
# copy the content of the first register to the second register
for i in range(n):
simonCircuit.cx(qr[i], qr[n+i])
# get the least index j such that s_j is "1"
j = -1
for i, c in enumerate(s):
if c == "1":
j = i
break
# Creating 1-to-1 or 2-to-1 mapping with the j-th qubit of x as control to XOR the second register with s
for i, c in enumerate(s):
if c == "1" and j >= 0:
simonCircuit.cx(qr[j], qr[n+i]) #the i-th qubit is flipped if s_i is 1
# get random permutation of n qubits
perm = list(np.random.permutation(n))
#initial position
init = list(range(n))
i = 0
while i < n:
if init[i] != perm[i]:
k = perm.index(init[i])
simonCircuit.swap(qr[n+i], qr[n+k]) #swap qubits
init[i], init[k] = init[k], init[i] #marked swapped qubits
else:
i += 1
# randomly flip the qubit
for i in range(n):
if np.random.random() > 0.5:
simonCircuit.x(qr[n+i])
# Apply the barrier to mark the end of the blackbox function
simonCircuit.barrier()
# Step 4 apply Hadamard gates to the first register
for i in range(n):
simonCircuit.h(qr[i])
# Step 5 perform measurement on the first register
for i in range(n):
simonCircuit.measure(qr[i], cr[i])
#draw the circuit
simonCircuit.draw(output='mpl')
# use local simulator
backend = BasicAer.get_backend("qasm_simulator")
# the number of shots is twice the length of the bitstring
shots = 2*n
job = execute(simonCircuit, backend=backend, shots=shots)
answer = job.result().get_counts()
plot_histogram(answer)
# Post-processing step
# Constructing the system of linear equations Y s = 0
# By k[::-1], we reverse the order of the bitstring
lAnswer = [ (k[::-1],v) for k,v in answer.items() if k != "0"*n ] #excluding the trivial all-zero
#Sort the basis by their probabilities
lAnswer.sort(key = lambda x: x[1], reverse=True)
Y = []
for k, v in lAnswer:
Y.append( [ int(c) for c in k ] )
#import tools from sympy
from sympy import Matrix, pprint, MatrixSymbol, expand, mod_inverse
Y = Matrix(Y)
#pprint(Y)
#Perform Gaussian elimination on Y
Y_transformed = Y.rref(iszerofunc=lambda x: x % 2==0) # linear algebra on GF(2)
#to convert rational and negatives in rref of linear algebra on GF(2)
def mod(x,modulus):
numer, denom = x.as_numer_denom()
return numer*mod_inverse(denom,modulus) % modulus
Y_new = Y_transformed[0].applyfunc(lambda x: mod(x,2)) #must takecare of negatives and fractional values
#pprint(Y_new)
print("The hidden bistring s[ 0 ], s[ 1 ]....s[",n-1,"] is the one satisfying the following system of linear equations:")
rows, cols = Y_new.shape
for r in range(rows):
Yr = [ "s[ "+str(i)+" ]" for i, v in enumerate(list(Y_new[r,:])) if v == 1 ]
if len(Yr) > 0:
tStr = " + ".join(Yr)
print(tStr, "= 0")
#Use one of the available backends
backend = IBMQ.get_backend("ibmq_16_melbourne")
# show the status of the backend
print("Status of", backend, "is", backend.status())
shots = 10*n #run more experiments to be certain
max_credits = 3 # Maximum number of credits to spend on executions.
simonCompiled = transpile(simonCircuit, backend=backend, optimization_level=1)
job_exp = execute(simonCompiled, backend=backend, shots=shots, max_credits=max_credits)
job_monitor(job_exp)
results = job_exp.result()
answer = results.get_counts(simonCircuit)
plot_histogram(answer)
# Post-processing step
# Constructing the system of linear equations Y s = 0
# By k[::-1], we reverse the order of the bitstring
lAnswer = [ (k[::-1][:n],v) for k,v in answer.items() ] #excluding the qubits that are not part of the inputs
#Sort the basis by their probabilities
lAnswer.sort(key = lambda x: x[1], reverse=True)
Y = []
for k, v in lAnswer:
Y.append( [ int(c) for c in k ] )
Y = Matrix(Y)
#Perform Gaussian elimination on Y
Y_transformed = Y.rref(iszerofunc=lambda x: x % 2==0) # linear algebra on GF(2)
Y_new = Y_transformed[0].applyfunc(lambda x: mod(x,2)) #must takecare of negatives and fractional values
#pprint(Y_new)
print("The hidden bistring s[ 0 ], s[ 1 ]....s[",n-1,"] is the one satisfying the following system of linear equations:")
rows, cols = Y_new.shape
for r in range(rows):
Yr = [ "s[ "+str(i)+" ]" for i, v in enumerate(list(Y_new[r,:])) if v == 1 ]
if len(Yr) > 0:
tStr = " + ".join(Yr)
print(tStr, "= 0")
|
https://github.com/xtophe388/QISKIT
|
xtophe388
|
from qiskit import ClassicalRegister, QuantumRegister
from qiskit import QuantumCircuit, execute
from qiskit import register
#import Qconfig and set APIToken and API url
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'])
from battleships_engine import *
title_screen()
device = ask_for_device()
from qiskit import get_backend
backend = get_backend(device)
shipPos = ask_for_ships()
# the game variable will be set to False once the game is over
game = True
# the variable bombs[X][Y] will hold the number of times position Y has been bombed by player X+1
bomb = [ [0]*5 for _ in range(2)] # all values are initialized to zero
# set the number of samples used for statistics
shots = 1024
# the variable grid[player] will hold the results for the grid of each player
grid = [{},{}]
while (game):
# ask both players where they want to bomb, and update the list of bombings so far
bomb = ask_for_bombs( bomb )
# now we create and run the quantum programs that implement this on the grid for each player
qc = []
for player in range(2):
# now to set up the quantum program to simulate the grid for this player
# set up registers and program
q = QuantumRegister(5)
c = ClassicalRegister(5)
qc.append( QuantumCircuit(q, c) )
# add the bombs (of the opposing player)
for position in range(5):
# add as many bombs as have been placed at this position
for n in range( bomb[(player+1)%2][position] ):
# the effectiveness of the bomb
# (which means the quantum operation we apply)
# depends on which ship it is
for ship in [0,1,2]:
if ( position == shipPos[player][ship] ):
frac = 1/(ship+1)
# add this fraction of a NOT to the QASM
qc[player].u3(frac * math.pi, 0.0, 0.0, q[position])
# Finally, measure them
for position in range(5):
qc[player].measure(q[position], c[position])
# compile and run the quantum program
job = execute(qc, backend, shots=shots)
if device=='ibmqx4':
print("\nWe've now get submitted the job to the quantum computer to see what happens to the ships of each player\n(it might take a while).\n")
else:
print("\nWe've now get submitted the job to the simulator to see what happens to the ships of each player.\n")
# and extract data
for player in range(2):
grid[player] = job.result().get_counts(qc[player])
game = display_grid ( grid, shipPos, shots )
|
https://github.com/xtophe388/QISKIT
|
xtophe388
|
# useful additional packages
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
# useful math functions
from math import pi, cos, acos, sqrt
# importing the QISKit
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import available_backends, execute, register, get_backend
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.')
# import basic plot tools
from qiskit.tools.visualization import plot_histogram
M = 16 # Maximum number of physical qubits available
numberOfCoins = 8 # This number should be up to M-1, where M is the number of qubits available
indexOfFalseCoin = 6 # This should be 0, 1, ..., numberOfCoins - 1, where we use Python indexing
if numberOfCoins < 4 or numberOfCoins >= M:
raise Exception("Please use numberOfCoins between 4 and ", M-1)
if indexOfFalseCoin < 0 or indexOfFalseCoin >= numberOfCoins:
raise Exception("indexOfFalseCoin must be between 0 and ", numberOfCoins-1)
# Creating registers
# numberOfCoins qubits for the binary query string and 1 qubit for working and recording the result of quantum balance
qr = QuantumRegister(numberOfCoins+1)
# for recording the measurement on qr
cr = ClassicalRegister(numberOfCoins+1)
circuitName = "QueryStateCircuit"
queryStateCircuit = QuantumCircuit(qr, cr)
N = numberOfCoins
# Create uniform superposition of all strings of length N
for i in range(N):
queryStateCircuit.h(qr[i])
# Perform XOR(x) by applying CNOT gates sequentially from qr[0] to qr[N-1] and storing the result to qr[N]
for i in range(N):
queryStateCircuit.cx(qr[i], qr[N])
# Measure qr[N] and store the result to cr[N]. We continue if cr[N] is zero, or repeat otherwise
queryStateCircuit.measure(qr[N], cr[N])
# we proceed to query the quantum beam balance if the value of cr[0]...cr[N] is all zero
# by preparing the Hadamard state of |1>, i.e., |0> - |1> at qr[N]
queryStateCircuit.x(qr[N]).c_if(cr, 0)
queryStateCircuit.h(qr[N]).c_if(cr, 0)
# we rewind the computation when cr[N] is not zero
for i in range(N):
queryStateCircuit.h(qr[i]).c_if(cr, 2**N)
k = indexOfFalseCoin
# Apply the quantum beam balance on the desired superposition state (marked by cr equal to zero)
queryStateCircuit.cx(qr[k], qr[N]).c_if(cr, 0)
# Apply Hadamard transform on qr[0] ... qr[N-1]
for i in range(N):
queryStateCircuit.h(qr[i]).c_if(cr, 0)
# Measure qr[0] ... qr[N-1]
for i in range(N):
queryStateCircuit.measure(qr[i], cr[i])
backend = "local_qasm_simulator"
shots = 1 # We perform a one-shot experiment
results = execute(queryStateCircuit, backend=backend, shots=shots).result()
answer = results.get_counts()
for key in answer.keys():
if key[0:1] == "1":
raise Exception("Fail to create desired superposition of balanced query string. Please try again")
plot_histogram(answer)
from collections import Counter
for key in answer.keys():
normalFlag, _ = Counter(key[1:]).most_common(1)[0] #get most common label
for i in range(2,len(key)):
if key[i] != normalFlag:
print("False coin index is: ", len(key) - i - 1)
|
https://github.com/xtophe388/QISKIT
|
xtophe388
|
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.')
import numpy as np
# importing the QISKit
import qiskit
from qiskit import QuantumCircuit, QuantumProgram
# import tomography libary
import qiskit.tools.qcvv.tomography as tomo
# useful additional packages
from qiskit.tools.visualization import plot_state
from qiskit.tools.qi.qi import *
Q_program = QuantumProgram()
# Creating registers
qr = Q_program.create_quantum_register("qr", 2)
cr = Q_program.create_classical_register("cr", 2)
# hadamard on qubit-1 only
had = Q_program.create_circuit("had", [qr], [cr])
had.h(qr[1])
# CNOT gate with qubit 1 control, qubit 0 target (target for ibmqx4)
cnot = Q_program.create_circuit("cnot", [qr], [cr])
cnot.cx(qr[1], qr[0])
U_had = np.array([[1,1],[1,-1]])/np.sqrt(2)
# compute Choi-matrix from unitary
had_choi = outer(vectorize(U_had))
plot_state(had_choi)
# process tomography set for a quantum operation on qubit 1
had_tomo_set = tomo.process_tomography_set([1])
# Generate process tomography preparation and measurement circuits
had_tomo_circuits = tomo.create_tomography_circuits(Q_program, 'had', qr, cr, had_tomo_set)
print('Tomography circuit labels for "had" circuit:')
for label in had_tomo_circuits:
print(label)
backend = 'local_qasm_simulator'
shots = 1000
had_tomo_results = Q_program.execute(had_tomo_circuits, shots=shots, backend=backend)
had_process_data = tomo.tomography_data(had_tomo_results, 'had', had_tomo_set)
had_choi_fit = tomo.fit_tomography_data(had_process_data, options={'trace':2})
print('Process Fidelity = ', state_fidelity(vectorize(U_had)/2, had_choi_fit))
plot_state(had_choi_fit)
# Register API token for online backends
qiskit.register(qx_config['APItoken'], qx_config['url'])
# Use the IBM Quantum Experience
backend = 'ibmqx4'
# Take 500 shots for each measurement basis
# Note: reduce this number for larger number of qubits
shots = 500
# set max credits
max_credits = 8
# Run the experiment
hadqx_tomo_results = Q_program.execute(had_tomo_circuits, backend=backend, shots=shots,
max_credits=max_credits, timeout=500)
print(hadqx_tomo_results)
hadqx_process_data = tomo.tomography_data(hadqx_tomo_results, 'had', had_tomo_set)
hadqx_choi_fit = tomo.fit_tomography_data(hadqx_process_data, options={'trace':2})
print('Process Fidelity = ', state_fidelity(vectorize(U_had)/2, hadqx_choi_fit))
plot_state(hadqx_choi_fit)
#unitary matrix for CNOT with qubit 1 as control and qubit 0 as target.
U_cnot = np.array([[1,0,0,0],[0,1,0,0],[0,0,0,1],[0,0,1,0]])
# compute Choi-matrix from unitary
cnot_choi = outer(vectorize(U_cnot))
plot_state(cnot_choi)
# process tomography set for quantum operation on qubits 0 and 1
cnot_tomo_set = tomo.process_tomography_set([1, 0])
# Generate process tomography circuits
cnot_tomo_circuits = tomo.create_tomography_circuits(Q_program, 'cnot', qr, cr, cnot_tomo_set)
backend = 'local_qasm_simulator'
shots = 1000
cnot_tomo_results = Q_program.execute(cnot_tomo_circuits, backend=backend, shots=shots, timeout=300)
cnot_process_data = tomo.tomography_data(cnot_tomo_results, 'cnot', cnot_tomo_set)
cnot_choi_fit = tomo.fit_tomography_data(cnot_process_data, options={'trace':4})
print('Process Fidelity = ', state_fidelity(vectorize(U_cnot)/2, cnot_choi_fit/4))
plot_state(cnot_choi_fit)
# Register API token for online backends
qiskit.register(qx_config['APItoken'], qx_config['url'])
# Use the IBM Quantum Experience
backend = 'ibmqx4'
# Take 500 shots for each measurement basis
# Note: reduce this number for larger number of qubits
shots = 500
# set max credits
max_credits = 8
# Set batch size and complete
batch_size = 18
status = qiskit.get_backend(backend).status
if status['operational'] == False or status['pending_jobs'] > 5:
print('Warning: the selected backend appears to be busy or unavailable at present; consider choosing a different one if possible.')
for j in range(8):
batch_circs = cnot_tomo_circuits[j*batch_size:(j+1)*batch_size]
if j == 0:
cnotqx_tomo_results = Q_program.execute(batch_circs, backend=backend, shots=shots,
max_credits=max_credits, timeout=500)
else:
cnotqx_tomo_results += Q_program.execute(batch_circs, backend=backend, shots=shots,
max_credits=max_credits, timeout=500)
msg = 'Batch %d/%d: %s' % (j+1, 8, cnotqx_tomo_results)
print(msg)
cnotqx_process_data = tomo.tomography_data(cnotqx_tomo_results, 'cnot', cnot_tomo_set)
cnotqx_choi_fit = tomo.fit_tomography_data(cnotqx_process_data, options={'trace':4})
print('Process Fidelity = ', state_fidelity(vectorize(U_cnot)/2, cnotqx_choi_fit/4))
plot_state(cnotqx_choi_fit)
|
https://github.com/xtophe388/QISKIT
|
xtophe388
|
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.')
import qiskit as qk
import numpy as np
from scipy.optimize import curve_fit
from qiskit.tools.qcvv.fitters import exp_fit_fun, osc_fit_fun, plot_coherence
# function for padding with QId gates
def pad_QId(circuit,N,qr):
# circuit to add to, N = number of QId gates to add, qr = qubit reg
for ii in range(N):
circuit.barrier(qr)
circuit.iden(qr)
return circuit
qk.register(qx_config['APItoken'], qx_config['url'])
# backend and token settings
backend = qk.get_backend('ibmqx4') # the device to run on
shots = 1024 # the number of shots in the experiment
# Select qubit whose T1 is to be measured
qubit=1
# Creating registers
qr = qk.QuantumRegister(5)
cr = qk.ClassicalRegister(5)
# the delay times are all set in terms of single-qubit gates
# so we need to calculate the time from these parameters
params = backend.parameters['qubits'][qubit]
pulse_length=params['gateTime']['value'] # single-qubit gate time
buffer_length=params['buffer']['value'] # spacing between pulses
unit = params['gateTime']['unit']
steps=10
gates_per_step=120
max_gates=(steps-1)*gates_per_step+1
tot_length=buffer_length+pulse_length
time_per_step=gates_per_step*tot_length
qc_dict={}
for ii in range(steps):
step_num='step_%s'%(str(ii))
qc_dict.update({step_num:qk.QuantumCircuit(qr, cr)})
qc_dict[step_num].x(qr[qubit])
qc_dict[step_num]=pad_QId(qc_dict[step_num],gates_per_step*ii,qr[qubit])
qc_dict[step_num].barrier(qr[qubit])
qc_dict[step_num].measure(qr[qubit], cr[qubit])
circuits=list(qc_dict.values())
# run the program
status = backend.status
if status['operational'] == False or status['pending_jobs'] > 10:
print('Warning: the selected backend appears to be busy or unavailable at present; consider choosing a different one if possible')
t1_job=qk.execute(circuits, backend, shots=shots)
# arrange the data from the run
result_t1 = t1_job.result()
keys_0_1=list(result_t1.get_counts(qc_dict['step_0']).keys())# get the key of the excited state '00001'
data=np.zeros(len(qc_dict.keys())) # numpy array for data
sigma_data = np.zeros(len(qc_dict.keys()))
# change unit from ns to microseconds
plot_factor=1
if unit.find('ns')>-1:
plot_factor=1000
punit='$\mu$s'
xvals=time_per_step*np.linspace(0,len(qc_dict.keys()),len(qc_dict.keys()))/plot_factor # calculate the time steps in microseconds
for ii,key in enumerate(qc_dict.keys()):
# get the data in terms of counts for the excited state normalized to the total number of counts
data[ii]=float(result_t1.get_counts(qc_dict[key])[keys_0_1[1]])/shots
sigma_data[ii] = np.sqrt(data[ii]*(1-data[ii]))/np.sqrt(shots)
# fit the data to an exponential
fitT1, fcov = curve_fit(exp_fit_fun, xvals, data, bounds=([-1,2,0], [1., 500, 1]))
ferr = np.sqrt(np.diag(fcov))
plot_coherence(xvals, data, sigma_data, fitT1, exp_fit_fun, punit, 'T$_1$ ', qubit)
print("a: " + str(round(fitT1[0],2)) + u" \u00B1 " + str(round(ferr[0],2)))
print("T1: " + str(round(fitT1[1],2))+ " µs" + u" \u00B1 " + str(round(ferr[1],2)) + ' µs')
print("c: " + str(round(fitT1[2],2)) + u" \u00B1 " + str(round(ferr[2],2)))
str(params['T1']['value']) +' ' + params['T1']['unit']
# Select qubit on which to measure T2*
qubit=1
# Creating registers
qr = qk.QuantumRegister(5)
cr = qk.ClassicalRegister(5)
params = backend.parameters['qubits'][qubit]
pulse_length=params['gateTime']['value'] # single-qubit gate time
buffer_length=params['buffer']['value'] # spacing between pulses
unit = params['gateTime']['unit']
steps=35
gates_per_step=20
max_gates=(steps-1)*gates_per_step+2
num_osc=5
tot_length=buffer_length+pulse_length
time_per_step=gates_per_step*tot_length
qc_dict={}
for ii in range(steps):
step_num='step_%s'%(str(ii))
qc_dict.update({step_num:qk.QuantumCircuit(qr, cr)})
qc_dict[step_num].h(qr[qubit])
qc_dict[step_num]=pad_QId(qc_dict[step_num],gates_per_step*ii,qr[qubit])
qc_dict[step_num].u1(2*np.pi*num_osc*ii/(steps-1),qr[qubit])
qc_dict[step_num].h(qr[qubit])
qc_dict[step_num].barrier(qr[qubit])
qc_dict[step_num].measure(qr[qubit], cr[qubit])
circuits=list(qc_dict.values())
# run the program
status = backend.status
if status['operational'] == False or status['pending_jobs'] > 10:
print('Warning: the selected backend appears to be busy or unavailable at present; consider choosing a different one if possible')
t2star_job=qk.execute(circuits, backend, shots=shots)
# arrange the data from the run
result_t2star = t2star_job.result()
keys_0_1=list(result_t2star.get_counts(qc_dict['step_0']).keys())# get the key of the excited state '00001'
# change unit from ns to microseconds
plot_factor=1
if unit.find('ns')>-1:
plot_factor=1000
punit='$\mu$s'
xvals=time_per_step*np.linspace(0,len(qc_dict.keys()),len(qc_dict.keys()))/plot_factor # calculate the time steps
data=np.zeros(len(qc_dict.keys())) # numpy array for data
sigma_data = np.zeros(len(qc_dict.keys()))
for ii,key in enumerate(qc_dict.keys()):
# get the data in terms of counts for the excited state normalized to the total number of counts
data[ii]=float(result_t2star.get_counts(qc_dict[key])[keys_0_1[1]])/shots
sigma_data[ii] = np.sqrt(data[ii]*(1-data[ii]))/np.sqrt(shots)
fitT2s, fcov = curve_fit(osc_fit_fun, xvals, data, p0=[0.5, 100, 1/10, np.pi, 0], bounds=([0.3,0,0,0,0], [0.5, 200, 1/2,2*np.pi,1]))
ferr = np.sqrt(np.diag(fcov))
plot_coherence(xvals, data, sigma_data, fitT2s, osc_fit_fun, punit, '$T_2^*$ ', qubit)
print("a: " + str(round(fitT2s[0],2)) + u" \u00B1 " + str(round(ferr[0],2)))
print("T2*: " + str(round(fitT2s[1],2))+ " µs"+ u" \u00B1 " + str(round(ferr[1],2)) + ' µs')
print("f: " + str(round(10**3*fitT2s[2],3)) + 'kHz' + u" \u00B1 " + str(round(10**6*ferr[2],3)) + 'kHz')
print("phi: " + str(round(fitT2s[3],2)) + u" \u00B1 " + str(round(ferr[3],2)))
print("c: " + str(round(fitT2s[4],2)) + u" \u00B1 " + str(round(ferr[4],2)))
# Select qubit to measure T2 echo on
qubit=1
# Creating registers
qr = qk.QuantumRegister(5)
cr = qk.ClassicalRegister(5)
params = backend.parameters['qubits'][qubit]
pulse_length=params['gateTime']['value'] # single-qubit gate time
buffer_length=params['buffer']['value'] # spacing between pulses
unit = params['gateTime']['unit']
steps=18
gates_per_step=28
tot_length=buffer_length+pulse_length
max_gates=(steps-1)*2*gates_per_step+3
time_per_step=(2*gates_per_step)*tot_length
qc_dict={}
for ii in range(steps):
step_num='step_%s'%(str(ii))
qc_dict.update({step_num:qk.QuantumCircuit(qr, cr)})
qc_dict[step_num].h(qr[qubit])
qc_dict[step_num]=pad_QId(qc_dict[step_num],gates_per_step*ii,qr[qubit])
qc_dict[step_num].x(qr[qubit])
qc_dict[step_num]=pad_QId(qc_dict[step_num],gates_per_step*ii,qr[qubit])
qc_dict[step_num].h(qr[qubit])
qc_dict[step_num].barrier(qr[qubit])
qc_dict[step_num].measure(qr[qubit], cr[qubit])
circuits=list(qc_dict.values())
# run the program
status = backend.status
if status['operational'] == False or status['pending_jobs'] > 10:
print('Warning: the selected backend appears to be busy or unavailable at present; consider choosing a different one if possible')
t2echo_job=qk.execute(circuits, backend, shots=shots)
# arrange the data from the run
result_t2echo = t2echo_job.result()
keys_0_1=list(result_t2echo.get_counts(qc_dict['step_0']).keys())# get the key of the excited state '00001'
# change unit from ns to microseconds
plot_factor=1
if unit.find('ns')>-1:
plot_factor=1000
punit='$\mu$s'
xvals=time_per_step*np.linspace(0,len(qc_dict.keys()),len(qc_dict.keys()))/plot_factor # calculate the time steps
data=np.zeros(len(qc_dict.keys())) # numpy array for data
sigma_data = np.zeros(len(qc_dict.keys()))
for ii,key in enumerate(qc_dict.keys()):
# get the data in terms of counts for the excited state normalized to the total number of counts
data[ii]=float(result_t2echo.get_counts(qc_dict[key])[keys_0_1[1]])/shots
sigma_data[ii] = np.sqrt(data[ii]*(1-data[ii]))/np.sqrt(shots)
fitT2e, fcov = curve_fit(exp_fit_fun, xvals, data, bounds=([-1,10,0], [1, 150, 1]))
ferr = np.sqrt(np.diag(fcov))
plot_coherence(xvals, data, sigma_data, fitT2e, exp_fit_fun, punit, '$T_{2echo}$ ', qubit)
print("a: " + str(round(fitT2e[0],2)) + u" \u00B1 " + str(round(ferr[0],2)))
print("T2: " + str(round(fitT2e[1],2))+ ' µs' + u" \u00B1 " + str(round(ferr[1],2)) + ' µs')
print("c: " + str(round(fitT2e[2],2)) + u" \u00B1 " + str(round(ferr[2],2)))
str(params['T2']['value']) +' ' + params['T2']['unit']
# Select qubit for CPMG measurement of T2
qubit=1
# Creating registers
qr = qk.QuantumRegister(5)
cr = qk.ClassicalRegister(5)
params = backend.parameters['qubits'][qubit]
pulse_length=params['gateTime']['value'] # single-qubit gate time
buffer_length=params['buffer']['value'] # spacing between pulses
unit = params['gateTime']['unit']
steps=10
gates_per_step=18
num_echo=5 # has to be odd number to end up in excited state at the end
tot_length=buffer_length+pulse_length
time_per_step=((num_echo+1)*gates_per_step+num_echo)*tot_length
max_gates=num_echo*(steps-1)*gates_per_step+num_echo+2
qc_dict={}
for ii in range(steps):
step_num='step_%s'%(str(ii))
qc_dict.update({step_num:qk.QuantumCircuit(qr, cr)})
qc_dict[step_num].h(qr[qubit])
for iii in range(num_echo):
qc_dict[step_num]=pad_QId(qc_dict[step_num], gates_per_step*ii, qr[qubit])
qc_dict[step_num].x(qr[qubit])
qc_dict[step_num]=pad_QId(qc_dict[step_num], gates_per_step*ii, qr[qubit])
qc_dict[step_num].h(qr[qubit])
qc_dict[step_num].barrier(qr[qubit])
qc_dict[step_num].measure(qr[qubit], cr[qubit])
circuits=list(qc_dict.values())
# run the program
status = backend.status
if status['operational'] == False or status['pending_jobs'] > 10:
print('Warning: the selected backend appears to be busy or unavailable at present; consider choosing a different one if possible')
t2cpmg_job=qk.execute(circuits, backend, shots=shots)
# arrange the data from the run
result_t2cpmg = t2cpmg_job.result()
keys_0_1=list(result_t2cpmg.get_counts(qc_dict['step_0']).keys())# get the key of the excited state '00001'
# change unit from ns to microseconds
plot_factor=1
if unit.find('ns')>-1:
plot_factor=1000
punit='$\mu$s'
xvals=time_per_step*np.linspace(0,len(qc_dict.keys()),len(qc_dict.keys()))/plot_factor # calculate the time steps
data=np.zeros(len(qc_dict.keys())) # numpy array for data
sigma_data = np.zeros(len(qc_dict.keys()))
for ii,key in enumerate(qc_dict.keys()):
# get the data in terms of counts for the excited state normalized to the total number of counts
data[ii]=float(result_t2cpmg.get_counts(qc_dict[key])[keys_0_1[1]])/shots
sigma_data[ii] = np.sqrt(data[ii]*(1-data[ii]))/np.sqrt(shots)
fitT2cpmg, fcov = curve_fit(exp_fit_fun, xvals, data, bounds=([-1,10,0], [1, 150, 1]))
ferr = np.sqrt(np.diag(fcov))
plot_coherence(xvals, data, sigma_data, fitT2cpmg, exp_fit_fun, punit, '$T_{2cpmg}$ ', qubit)
print("a: " + str(round(fitT2cpmg[0],2)) + u" \u00B1 " + str(round(ferr[0],2)))
print("T2: " + str(round(fitT2cpmg[1],2))+ ' µs' + u" \u00B1 " + str(round(ferr[1],2)) + ' µs')
print("c: " + str(round(fitT2cpmg[2],2)) + u" \u00B1 " + str(round(ferr[2],2)))
|
https://github.com/xtophe388/QISKIT
|
xtophe388
|
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.')
import numpy as np
from time import sleep # used for polling jobs
# importing the QISKit
import qiskit
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, QuantumProgram
# import tomography library
import qiskit.tools.qcvv.tomography as tomo
# useful additional packages
from qiskit.tools.visualization import plot_state, plot_histogram
from qiskit.tools.qi.qi import state_fidelity, concurrence, purity, outer
# Create a 2-qubit quantum register
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
# quantum circuit to make an entangled Bell state
bell = QuantumCircuit(qr, cr, name='bell')
bell.h(qr[1])
bell.cx(qr[1], qr[0])
job = qiskit.execute(bell, backend='local_statevector_simulator')
bell_psi = job.result().get_statevector(bell)
bell_rho = outer(bell_psi) # construct the density matrix from the state vector
# plot the state
plot_state(bell_rho,'paulivec')
rho_mixed = np.array([[1,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,1]])/2
plot_state(rho_mixed, 'paulivec')
# Construct state tomography set for measurement of qubits [0, 1] in the Pauli basis
bell_tomo_set = tomo.state_tomography_set([0, 1])
# Create a quantum program containing the state preparation circuit
Q_program = QuantumProgram()
Q_program.add_circuit('bell', bell)
# Add the state tomography measurement circuits to the Quantum Program
bell_tomo_circuit_names = tomo.create_tomography_circuits(Q_program, 'bell', qr, cr, bell_tomo_set)
print('Created State tomography circuits:')
for name in bell_tomo_circuit_names:
print(name)
# Use the local simulator
backend = 'local_qasm_simulator'
# Take 5000 shots for each measurement basis
shots = 5000
# Run the simulation
bell_tomo_result = Q_program.execute(bell_tomo_circuit_names, backend=backend, shots=shots)
print(bell_tomo_result)
bell_tomo_data = tomo.tomography_data(bell_tomo_result, 'bell', bell_tomo_set)
rho_fit = tomo.fit_tomography_data(bell_tomo_data)
# calculate fidelity, concurrence and purity of fitted state
F_fit = state_fidelity(rho_fit, bell_psi)
con = concurrence(rho_fit)
pur = purity(rho_fit)
# plot
plot_state(rho_fit, 'paulivec')
print('Fidelity =', F_fit)
print('concurrence = ', str(con))
print('purity = ', str(pur))
# Register API token for online backends
qiskit.register(qx_config['APItoken'], qx_config['url'])
# Use the IBM Quantum Experience
backend = 'ibmqx4'
# Take 1000 shots for each measurement basis
# Note: reduce this number for larger number of qubits
shots = 1000
# set max credits
max_credits = 8
# Run the experiment
status = qiskit.get_backend(backend).status
if status['operational'] == False or status['pending_jobs'] > 10:
print('Warning: the selected backend appears to be busy or unavailable at present; consider choosing a different one if possible')
bellqx_tomo_result = Q_program.execute(bell_tomo_circuit_names, backend=backend, shots=shots,
max_credits=max_credits, timeout=500)
print(bellqx_tomo_result)
bellqx_tomo_data = tomo.tomography_data(bellqx_tomo_result, 'bell', bell_tomo_set)
# Reconstruct experimentally measured density matrix
rho_fit_real = tomo.fit_tomography_data(bellqx_tomo_data)
F_fit_real = state_fidelity(rho_fit_real, bell_psi)
plot_state(rho_fit_real, 'paulivec')
print('Fidelity with ideal state')
print('F =', F_fit_real)
# calculate concurrence and purity
con = concurrence(rho_fit_real)
pur = purity(rho_fit_real)
print('concurrence = ', str(con))
print('purity = ', str(pur))
|
https://github.com/xtophe388/QISKIT
|
xtophe388
|
# Imports
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
from qiskit import QuantumProgram, QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import available_backends, get_backend, execute, register, least_busy
from qiskit.tools.visualization import plot_histogram, circuit_drawer
# 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))
# Creating registers
q = QuantumRegister(2)
c = ClassicalRegister(2)
# quantum circuit to make an entangled bell state
bell = QuantumCircuit(q, c)
bell.h(q[0])
bell.cx(q[0], q[1])
# quantum circuit to measure q in the standard basis
measureZZ = QuantumCircuit(q, c)
measureZZ.measure(q[0], c[0])
measureZZ.measure(q[1], c[1])
bellZZ = bell+measureZZ
# quantum circuit to measure q in the superposition basis
measureXX = QuantumCircuit(q, c)
measureXX.h(q[0])
measureXX.h(q[1])
measureXX.measure(q[0], c[0])
measureXX.measure(q[1], c[1])
bellXX = bell+measureXX
# quantum circuit to measure ZX
measureZX = QuantumCircuit(q, c)
measureZX.h(q[0])
measureZX.measure(q[0], c[0])
measureZX.measure(q[1], c[1])
bellZX = bell+measureZX
# quantum circuit to measure XZ
measureXZ = QuantumCircuit(q, c)
measureXZ.h(q[1])
measureXZ.measure(q[0], c[0])
measureXZ.measure(q[1], c[1])
bellXZ = bell+measureXZ
circuits = [bellZZ,bellXX,bellZX,bellXZ]
circuit_drawer(bellZZ)
circuit_drawer(bellXX)
circuit_drawer(bellZX)
circuit_drawer(bellXZ)
job = execute(circuits, backend=device_name, coupling_map=device_coupling, shots=device_shots)
result = job.result()
observable_first ={'00': 1, '01': -1, '10': 1, '11': -1}
observable_second ={'00': 1, '01': 1, '10': -1, '11': -1}
observable_correlated ={'00': 1, '01': -1, '10': -1, '11': 1}
print('IZ = ' + str(result.average_data(bellZZ,observable_first)))
print('ZI = ' + str(result.average_data(bellZZ,observable_second)))
print('ZZ = ' + str(result.average_data(bellZZ,observable_correlated)))
print('IX = ' + str(result.average_data(bellXX,observable_first)))
print('XI = ' + str(result.average_data(bellXX,observable_second)))
print('XX = ' + str(result.average_data(bellXX,observable_correlated)))
print('ZX = ' + str(result.average_data(bellZX,observable_correlated)))
print('XZ = ' + str(result.average_data(bellXZ,observable_correlated)))
CHSH = lambda x : x[0]+x[1]+x[2]-x[3]
measure = [measureZZ, measureZX, measureXX, measureXZ]
local_backend = 'local_qasm_simulator'
local_shots = 8192
sim_chsh_circuits = []
sim_x = []
sim_steps = 30
for step in range(sim_steps):
theta = 2.0*np.pi*step/30
bell_middle = QuantumCircuit(q,c)
bell_middle.ry(theta,q[0])
for m in measure:
sim_chsh_circuits.append(bell+bell_middle+m)
sim_x.append(theta)
job = execute(sim_chsh_circuits, backend=local_backend, shots=local_shots)
result = job.result()
sim_chsh = []
circ = 0
for x in range(len(sim_x)):
temp_chsh = []
for m in range(len(measure)):
temp_chsh.append(result.average_data(sim_chsh_circuits[circ].name,observable_correlated))
circ += 1
sim_chsh.append(CHSH(temp_chsh))
real_chsh_circuits = []
real_x = []
real_steps = 10
for step in range(real_steps):
theta = 2.0*np.pi*step/10
bell_middle = QuantumCircuit(q,c)
bell_middle.ry(theta,q[0])
for m in measure:
real_chsh_circuits.append(bell+bell_middle+m)
real_x.append(theta)
job = execute(real_chsh_circuits, backend=device_name, coupling_map=device_coupling, shots=device_shots)
result = job.result()
real_chsh = []
circ = 0
for x in range(len(real_x)):
temp_chsh = []
for m in range(len(measure)):
temp_chsh.append(result.average_data(real_chsh_circuits[circ].name,observable_correlated))
circ += 1
real_chsh.append(CHSH(temp_chsh))
plt.plot(sim_x, sim_chsh, 'r-', real_x, real_chsh, 'bo')
plt.plot([0, 2*np.pi], [2, 2], 'b-')
plt.plot([0, 2*np.pi], [-2, -2], 'b-')
plt.grid()
plt.ylabel('CHSH', fontsize=20)
plt.xlabel(r'$Y(\theta)$', fontsize=20)
plt.show()
print(real_chsh)
device_shots = 8192 # need more statistics for 3 and 4 qubit experiments
# 2 - qubits
# quantum circuit to make GHZ state
q2 = QuantumRegister(2)
c2 = ClassicalRegister(2)
ghz = QuantumCircuit(q2, c2)
ghz.h(q2[0])
ghz.cx(q2[0],q2[1])
# quantum circuit to measure q in standard basis
measureZZ = QuantumCircuit(q2, c2)
measureZZ.measure(q2[0], c2[0])
measureZZ.measure(q2[1], c2[1])
ghzZZ = ghz+measureZZ
measureXX = QuantumCircuit(q2, c2)
measureXX.h(q2[0])
measureXX.h(q2[1])
measureXX.measure(q2[0], c2[0])
measureXX.measure(q2[1], c2[1])
ghzXX = ghz+measureXX
circuits2 = [ghzZZ, ghzXX]
circuit_drawer(ghzZZ)
circuit_drawer(ghzXX)
job2 = execute(circuits2, backend=device_name, coupling_map=device_coupling, shots=device_shots)
result2 = job2.result()
plot_histogram(result2.get_counts(ghzZZ))
plot_histogram(result2.get_counts(ghzXX))
# 3 - qubits
# quantum circuit to make GHZ state
q3 = QuantumRegister(3)
c3 = ClassicalRegister(3)
ghz3 = QuantumCircuit(q3, c3)
ghz3.h(q3[0])
ghz3.cx(q3[0],q3[1])
ghz3.cx(q3[1],q3[2])
# quantum circuit to measure q in standard basis
measureZZZ = QuantumCircuit(q3, c3)
measureZZZ.measure(q3[0], c3[0])
measureZZZ.measure(q3[1], c3[1])
measureZZZ.measure(q3[2], c3[2])
ghzZZZ = ghz3+measureZZZ
measureXXX = QuantumCircuit(q3, c3)
measureXXX.h(q3[0])
measureXXX.h(q3[1])
measureXXX.h(q3[2])
measureXXX.measure(q3[0], c3[0])
measureXXX.measure(q3[1], c3[1])
measureXXX.measure(q3[2], c3[2])
ghzXXX = ghz3+measureXXX
circuits3 = [ghzZZZ, ghzXXX]
circuit_drawer(ghzZZZ)
circuit_drawer(ghzXXX)
job3 = execute(circuits3, backend=device_name, coupling_map=device_coupling, shots=device_shots)
result3 = job3.result()
plot_histogram(result3.get_counts(ghzZZZ))
plot_histogram(result3.get_counts(ghzXXX))
# 4 - qubits
# quantum circuit to make GHZ state
q4 = QuantumRegister(4)
c4 = ClassicalRegister(4)
ghz4 = QuantumCircuit(q4, c4)
ghz4.h(q4[0])
ghz4.cx(q4[0],q4[1])
ghz4.cx(q4[1],q4[2])
ghz4.h(q4[3])
ghz4.h(q4[2])
ghz4.cx(q4[3],q4[2])
ghz4.h(q4[3])
ghz4.h(q4[2])
# quantum circuit to measure q in standard basis
measureZZZZ = QuantumCircuit(q4, c4)
measureZZZZ.measure(q4[0], c4[0])
measureZZZZ.measure(q4[1], c4[1])
measureZZZZ.measure(q4[2], c4[2])
measureZZZZ.measure(q4[3], c4[3])
ghzZZZZ = ghz4+measureZZZZ
measureXXXX = QuantumCircuit(q4, c4)
measureXXXX.h(q4[0])
measureXXXX.h(q4[1])
measureXXXX.h(q4[2])
measureXXXX.h(q4[3])
measureXXXX.measure(q4[0], c4[0])
measureXXXX.measure(q4[1], c4[1])
measureXXXX.measure(q4[2], c4[2])
measureXXXX.measure(q4[3], c4[3])
ghzXXXX = ghz4+measureXXXX
circuits4 = [ghzZZZZ, ghzXXXX]
circuit_drawer(ghzZZZZ)
circuit_drawer(ghzXXXX)
job4 = execute(circuits4, backend=device_name, coupling_map=device_coupling, shots=device_shots)
result4 = job4.result()
plot_histogram(result4.get_counts(ghzZZZZ))
plot_histogram(result4.get_counts(ghzXXXX))
# quantum circuit to make GHZ state
q3 = QuantumRegister(3)
c3 = ClassicalRegister(3)
ghz3 = QuantumCircuit(q3, c3)
ghz3.h(q3[0])
ghz3.cx(q3[0],q3[1])
ghz3.cx(q3[0],q3[2])
# quantum circuit to measure q in standard basis
measureZZZ = QuantumCircuit(q3, c3)
measureZZZ.measure(q3[0], c3[0])
measureZZZ.measure(q3[1], c3[1])
measureZZZ.measure(q3[2], c3[2])
ghzZZZ = ghz3+measureZZZ
circuits5 = [ghzZZZ]
circuit_drawer(ghzZZZ)
job5 = execute(circuits5, backend=device_name, coupling_map=device_coupling, shots=device_shots)
result5 = job5.result()
plot_histogram(result5.get_counts(ghzZZZ))
MerminM = lambda x : x[0]*x[1]*x[2]*x[3]
observable ={'000': 1, '001': -1, '010': -1, '011': 1, '100': -1, '101': 1, '110': 1, '111': -1}
# quantum circuit to measure q XXX
measureXXX = QuantumCircuit(q3, c3)
measureXXX.h(q3[0])
measureXXX.h(q3[1])
measureXXX.h(q3[2])
measureXXX.measure(q3[0], c3[0])
measureXXX.measure(q3[1], c3[1])
measureXXX.measure(q3[2], c3[2])
ghzXXX = ghz3+measureXXX
# quantum circuit to measure q XYY
measureXYY = QuantumCircuit(q3, c3)
measureXYY.s(q3[1]).inverse()
measureXYY.s(q3[2]).inverse()
measureXYY.h(q3[0])
measureXYY.h(q3[1])
measureXYY.h(q3[2])
measureXYY.measure(q3[0], c3[0])
measureXYY.measure(q3[1], c3[1])
measureXYY.measure(q3[2], c3[2])
ghzXYY = ghz3+measureXYY
# quantum circuit to measure q YXY
measureYXY = QuantumCircuit(q3, c3)
measureYXY.s(q3[0]).inverse()
measureYXY.s(q3[2]).inverse()
measureYXY.h(q3[0])
measureYXY.h(q3[1])
measureYXY.h(q3[2])
measureYXY.measure(q3[0], c3[0])
measureYXY.measure(q3[1], c3[1])
measureYXY.measure(q3[2], c3[2])
ghzYXY = ghz3+measureYXY
# quantum circuit to measure q YYX
measureYYX = QuantumCircuit(q3, c3)
measureYYX.s(q3[0]).inverse()
measureYYX.s(q3[1]).inverse()
measureYYX.h(q3[0])
measureYYX.h(q3[1])
measureYYX.h(q3[2])
measureYYX.measure(q3[0], c3[0])
measureYYX.measure(q3[1], c3[1])
measureYYX.measure(q3[2], c3[2])
ghzYYX = ghz3+measureYYX
circuits6 = [ghzXXX, ghzYYX, ghzYXY, ghzXYY]
circuit_drawer(ghzXXX)
circuit_drawer(ghzYYX)
circuit_drawer(ghzYXY)
circuit_drawer(ghzXYY)
job6 = execute(circuits6, backend=device_name, coupling_map=device_coupling, shots=device_shots)
result6 = job6.result()
temp=[]
temp.append(result6.average_data(ghzXXX,observable))
temp.append(result6.average_data(ghzYYX,observable))
temp.append(result6.average_data(ghzYXY,observable))
temp.append(result6.average_data(ghzXYY,observable))
print(MerminM(temp))
|
https://github.com/xtophe388/QISKIT
|
xtophe388
|
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.')
# useful additional packages
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
from pprint import pprint
# importing QISKit
from qiskit import QuantumProgram, QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import available_backends, execute, register, least_busy
# import basic plot tools
from qiskit.tools.visualization import plot_histogram, circuit_drawer
backend = 'local_qasm_simulator' # run on local simulator by default
# Uncomment the following lines to run on a real device
# register(qx_config['APItoken'], qx_config['url'])
# backend = least_busy(available_backends({'simulator': False, 'local': False}))
# print("the best backend is " + backend)
zero = np.array([[1],[0]])
one = np.array([[0],[1]])
X = np.array([[0,1],[1,0]])
print(np.dot(X,zero))
print(np.dot(X,one))
# Creating registers
qr = QuantumRegister(1)
cr = ClassicalRegister(1)
# Quantum circuit ground
qc_ground = QuantumCircuit(qr, cr)
qc_ground.measure(qr[0], cr[0])
# Quantum circuit excited
qc_excited = QuantumCircuit(qr, cr)
qc_excited.x(qr)
qc_excited.measure(qr[0], cr[0])
circuit_drawer(qc_ground)
circuit_drawer(qc_excited)
circuits = [qc_ground, qc_excited]
job = execute(circuits, backend)
result = job.result()
plot_histogram(result.get_counts(qc_ground))
plot_histogram(result.get_counts(qc_excited))
# Quantum circuit superposition
qc_superposition = QuantumCircuit(qr, cr)
qc_superposition.h(qr)
qc_superposition.measure(qr[0], cr[0])
circuit_drawer(qc_superposition)
job = execute(qc_superposition, backend)
result = job.result()
plot_histogram(result.get_counts(qc_superposition))
# Quantum circuit two Hadamards
qc_twohadamard = QuantumCircuit(qr, cr)
qc_twohadamard.h(qr)
qc_twohadamard.barrier()
qc_twohadamard.h(qr)
qc_twohadamard.measure(qr[0], cr[0])
circuit_drawer(qc_twohadamard)
job = execute(qc_twohadamard, backend)
result = job.result()
plot_histogram(result.get_counts(qc_twohadamard))
state_overlap = lambda state1, state2: np.absolute(np.dot(state1.conj().T,state2))**2
Hadamard = np.array([[1,1],[1,-1]],dtype=complex)/np.sqrt(2)
psi1 = np.dot(Hadamard,zero)
P0 = state_overlap(zero,psi1)
P1 = state_overlap(one,psi1)
plot_histogram({'0' : P0.item(0), '1' : P1.item(0)})
print(np.dot(Hadamard,zero))
print(np.dot(Hadamard,one))
# Creating registers
q2 = QuantumRegister(2)
c2 = ClassicalRegister(2)
# quantum circuit to make an entangled bell state
bell = QuantumCircuit(q2, c2)
bell.h(q2[0])
bell.cx(q2[0], q2[1])
# quantum circuit to measure q0 in the standard basis
measureIZ = QuantumCircuit(q2, c2)
measureIZ.measure(q2[0], c2[0])
bellIZ = bell+measureIZ
# quantum circuit to measure q0 in the superposition basis
measureIX = QuantumCircuit(q2, c2)
measureIX.h(q2[0])
measureIX.measure(q2[0], c2[0])
bellIX = bell+measureIX
# quantum circuit to measure q1 in the standard basis
measureZI = QuantumCircuit(q2, c2)
measureZI.measure(q2[1], c2[1])
bellZI = bell+measureZI
# quantum circuit to measure q1 in the superposition basis
measureXI = QuantumCircuit(q2, c2)
measureXI.h(q2[1])
measureXI.measure(q2[1], c2[1])
bellXI = bell+measureXI
# quantum circuit to measure q in the standard basis
measureZZ = QuantumCircuit(q2, c2)
measureZZ.measure(q2[0], c2[0])
measureZZ.measure(q2[1], c2[1])
bellZZ = bell+measureZZ
# quantum circuit to measure q in the superposition basis
measureXX = QuantumCircuit(q2, c2)
measureXX.h(q2[0])
measureXX.h(q2[1])
measureXX.measure(q2[0], c2[0])
measureXX.measure(q2[1], c2[1])
bellXX = bell+measureXX
circuit_drawer(bellIZ)
circuit_drawer(bellIX)
circuit_drawer(bellZI)
circuit_drawer(bellXI)
circuit_drawer(bellZZ)
circuit_drawer(bellXX)
circuits = [bellIZ,bellIX,bellZI,bellXI,bellZZ,bellXX]
job = execute(circuits, backend)
result = job.result()
plot_histogram(result.get_counts(bellIZ))
result.get_data(bellIZ)
plot_histogram(result.get_counts(bellIX))
plot_histogram(result.get_counts(bellZI))
plot_histogram(result.get_counts(bellXI))
plot_histogram(result.get_counts(bellZZ))
plot_histogram(result.get_counts(bellXX))
# quantum circuit to make a mixed state
mixed1 = QuantumCircuit(q2, c2)
mixed2 = QuantumCircuit(q2, c2)
mixed2.x(q2)
mixed1.measure(q2[0], c2[0])
mixed1.measure(q2[1], c2[1])
mixed2.measure(q2[0], c2[0])
mixed2.measure(q2[1], c2[1])
circuit_drawer(mixed1)
circuit_drawer(mixed2)
mixed_state = [mixed1,mixed2]
job = execute(mixed_state, backend)
result = job.result()
counts1 = result.get_counts(mixed_state[0])
counts2 = result.get_counts(mixed_state[1])
from collections import Counter
ground = Counter(counts1)
excited = Counter(counts2)
plot_histogram(ground+excited)
|
https://github.com/xtophe388/QISKIT
|
xtophe388
|
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.')
# useful additional packages
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
from pprint import pprint
# importing QISKit
from qiskit import QuantumProgram, QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import available_backends, execute, register, least_busy
# import basic plot tools
from qiskit.tools.visualization import plot_histogram, circuit_drawer
backend = 'local_qasm_simulator' # run on local simulator by default
# Uncomment the following lines to run on a real device
# register(qx_config['APItoken'], qx_config['url'])
# backend = least_busy(available_backends({'simulator': False, 'local': False}))
# print("the best backend is " + backend)
# Creating registers
tq = QuantumRegister(3)
tc0 = ClassicalRegister(1)
tc1 = ClassicalRegister(1)
tc2 = ClassicalRegister(1)
# Quantum circuit to make the shared entangled state
teleport = QuantumCircuit(tq, tc0,tc1,tc2)
teleport.h(tq[1])
teleport.cx(tq[1], tq[2])
teleport.ry(np.pi/4,tq[0])
teleport.cx(tq[0], tq[1])
teleport.h(tq[0])
teleport.barrier()
teleport.measure(tq[0], tc0[0])
teleport.measure(tq[1], tc1[0])
teleport.z(tq[2]).c_if(tc0, 1)
teleport.x(tq[2]).c_if(tc1, 1)
teleport.measure(tq[2], tc2[0])
circuit_drawer(teleport)
teleport_job = execute(teleport, 'local_qasm_simulator') # note that this circuit doesn't run on a real device
teleport_result = teleport_job.result()
data = teleport_result.get_counts(teleport)
alice = {}
alice['00'] = data['0 0 0'] + data['1 0 0']
alice['10'] = data['0 1 0'] + data['1 1 0']
alice['01'] = data['0 0 1'] + data['1 0 1']
alice['11'] = data['0 1 1'] + data['1 1 1']
plot_histogram(alice)
bob = {}
bob['0'] = data['0 0 0'] + data['0 1 0'] + data['0 0 1'] + data['0 1 1']
bob['1'] = data['1 0 0'] + data['1 1 0'] + data['1 0 1'] + data['1 1 1']
plot_histogram(bob)
# Creating registers
sdq = QuantumRegister(2)
sdc = ClassicalRegister(2)
# Quantum circuit to make the shared entangled state
superdense = QuantumCircuit(sdq, sdc)
superdense.h(sdq[0])
superdense.cx(sdq[0], sdq[1])
# For 00, do nothing
# For 01, apply $X$
#shared.x(q[0])
# For 01, apply $Z$
#shared.z(q[0])
# For 11, apply $XZ$
superdense.z(sdq[0])
superdense.x(sdq[0])
superdense.barrier()
superdense.cx(sdq[0], sdq[1])
superdense.h(sdq[0])
superdense.measure(sdq[0], sdc[0])
superdense.measure(sdq[1], sdc[1])
circuit_drawer(superdense)
superdense_job = execute(superdense, backend)
superdense_result = superdense_job.result()
plot_histogram(superdense_result.get_counts(superdense))
|
https://github.com/xtophe388/QISKIT
|
xtophe388
|
import sys, time, 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.')
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, QISKitError
from qiskit import available_backends, execute, register, least_busy
# Create a Quantum Register called "q" with 3 qubits
qr = QuantumRegister(3)
# Create a Classical Register called "c" with 3 bits
cr = ClassicalRegister(3)
# Create a Quantum Circuit called involving "qr" and "cr"
circuit = QuantumCircuit(qr, cr)
# Not gate on qubit 0
circuit.x(qr[0])
# Not gate on qubit 1
circuit.x(qr[1])
# Barrier to seperator the input from the circuit
circuit.barrier(qr[0])
circuit.barrier(qr[1])
circuit.barrier(qr[2])
# Toffoli gate from qubit 0,1 to qubit 2
circuit.ccx(qr[0], qr[1], qr[2])
# CNOT (Controlled-NOT) gate from qubit 0 to qubit 1
circuit.cx(qr[0], qr[1])
# measure gate from qr to cr
circuit.measure(qr, cr)
# QASM from a program
QASM_source = circuit.qasm()
print(QASM_source)
from qiskit.tools.visualization import circuit_drawer
circuit_drawer(circuit)
backend = 'local_qasm_simulator'
# Create a Quantum Program for execution
job = execute(circuit, backend)
job.status
result = job.result()
result.get_counts(circuit)
register(qx_config['APItoken'], qx_config['url'])
large_enough_devices = available_backends(lambda x: x.configuration['n_qubits'] > 3 and not x.configuration['simulator'])
backend = least_busy(large_enough_devices)
print("the best backend is " + backend)
shots = 1024 # Number of shots to run the program (experiment); maximum is 8192 shots.
max_credits = 3 # Maximum number of credits to spend on executions.
job_exp = execute(circuit, backend=backend, shots=shots, max_credits=max_credits)
lapse = 0
interval = 30
while not job_exp.done:
print('Status @ {} seconds'.format(interval * lapse))
print(job_exp.status)
time.sleep(interval)
lapse += 1
print(job_exp.status)
result_real = job_exp.result()
result_real.get_counts(circuit)
jobID = job_exp.id
print('JOB ID: {}'.format(jobID))
|
https://github.com/xtophe388/QISKIT
|
xtophe388
|
from math import pi
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.tools.visualization import matplotlib_circuit_drawer as drawer, qx_color_scheme
# We recommend the following options for Jupter notebook
%matplotlib inline
%config InlineBackend.figure_format = 'svg'
# Create a Quantum Register called "q" with 3 qubits
qr = QuantumRegister(3, 'q')
# Create a Classical Register called "c" with 3 bits
cr = ClassicalRegister(3, 'c')
# Create a Quantum Circuit called involving "qr" and "cr"
circuit = QuantumCircuit(qr, cr)
circuit.x(qr[0]).c_if(cr, 3)
circuit.z(qr[0])
circuit.u2(pi/2, 2*pi/3, qr[1])
circuit.cu1(pi, qr[0], qr[1])
# Barrier to seperator the input from the circuit
circuit.barrier(qr[0])
circuit.barrier(qr[1])
circuit.barrier(qr[2])
# Toffoli gate from qubit 0,1 to qubit 2
circuit.ccx(qr[0], qr[1], qr[2])
# CNOT (Controlled-NOT) gate from qubit 0 to qubit 1
circuit.cx(qr[0], qr[1])
circuit.swap(qr[0], qr[2])
# measure gate from qr to cr
circuit.measure(qr, cr)
QASM_source = circuit.qasm()
print(QASM_source)
drawer(circuit)
drawer(circuit, basis='u1,u2,u3,id,cx', scale=1.0)
my_style = {'plotbarrier': True}
drawer(circuit, style=my_style)
my_style = {'cregbundle': True}
drawer(circuit, style=my_style)
my_style = {'showindex': True}
drawer(circuit, style=my_style)
my_style = {'compress': True}
drawer(circuit, style=my_style)
my_style = {'fold': 6}
drawer(circuit, style=my_style)
my_style = {'usepiformat': True}
drawer(circuit, style=my_style)
qr = QuantumRegister(1, 'q')
circuit_xyz = QuantumCircuit(qr)
circuit_xyz.x(qr[0])
circuit_xyz.y(qr[0])
circuit_xyz.z(qr[0])
drawer(circuit_xyz)
my_style = {'displaytext': {'x': '😺', 'y': '\Sigma', 'z': '✈'}}
drawer(circuit_xyz, style=my_style)
qr = QuantumRegister(2, 'q')
circuit_cucz = QuantumCircuit(qr)
circuit_cucz.cz(qr[0], qr[1])
circuit_cucz.cu1(pi, qr[0], qr[1])
drawer(circuit_cucz)
my_style = {'latexdrawerstyle': False}
drawer(circuit_cucz, style=my_style)
qr = QuantumRegister(3, 'q')
cr = ClassicalRegister(3, 'c')
circuit_all = QuantumCircuit(qr, cr)
circuit_all.x(qr[0])
circuit_all.y(qr[0])
circuit_all.z(qr[0])
circuit_all.barrier(qr[0])
circuit_all.barrier(qr[1])
circuit_all.barrier(qr[2])
circuit_all.h(qr[0])
circuit_all.s(qr[0])
circuit_all.sdg(qr[0])
circuit_all.t(qr[0])
circuit_all.tdg(qr[0])
circuit_all.iden(qr[0])
circuit_all.reset(qr[0])
circuit_all.rx(pi, qr[0])
circuit_all.ry(pi, qr[0])
circuit_all.rz(pi, qr[0])
circuit_all.u0(pi, qr[0])
circuit_all.u1(pi, qr[0])
circuit_all.u2(pi, pi, qr[0])
circuit_all.u3(pi, pi, pi, qr[0])
circuit_all.swap(qr[0], qr[1])
circuit_all.cx(qr[0], qr[1])
circuit_all.cy(qr[0], qr[1])
circuit_all.cz(qr[0], qr[1])
circuit_all.ch(qr[0], qr[1])
circuit_all.cu1(pi, qr[0], qr[1])
circuit_all.cu3(pi, pi, pi, qr[0], qr[1])
circuit_all.crz(pi, qr[0], qr[1])
circuit_all.ccx(qr[0], qr[1], qr[2])
circuit_all.cswap(qr[0], qr[1], qr[2])
circuit_all.measure(qr, cr)
drawer(circuit_all)
cmp_style = qx_color_scheme()
cmp_style
drawer(circuit_all, style=cmp_style)
cmp_style.update({
'usepiformat': True,
'showindex': True,
'cregbundle': True,
'compress': True,
'fold': 17
})
drawer(circuit_all, filename='circuit.pdf', style=cmp_style)
|
https://github.com/xtophe388/QISKIT
|
xtophe388
|
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.')
# Useful additional packages
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
from math import pi
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, QISKitError
from qiskit import available_backends, execute, register, get_backend
from qiskit.tools.visualization import circuit_drawer
from qiskit.tools.qi.qi import state_fidelity
q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.u3(pi/2,pi/2,pi/2,q)
circuit_drawer(qc)
job = execute(qc, backend='local_unitary_simulator')
np.round(job.result().get_data(qc)['unitary'], 3)
qc = QuantumCircuit(q)
qc.u2(pi/2,pi/2,q)
circuit_drawer(qc)
job = execute(qc, backend='local_unitary_simulator')
np.round(job.result().get_data(qc)['unitary'], 3)
qc = QuantumCircuit(q)
qc.u1(pi/2,q)
circuit_drawer(qc)
job = execute(qc, backend='local_unitary_simulator')
np.round(job.result().get_data(qc)['unitary'], 3)
qc = QuantumCircuit(q)
qc.u0(pi/2,q)
circuit_drawer(qc)
job = execute(qc, backend='local_unitary_simulator')
np.round(job.result().get_data(qc)['unitary'], 3)
qc = QuantumCircuit(q)
qc.iden(q)
circuit_drawer(qc)
job = execute(qc, backend='local_unitary_simulator')
np.round(job.result().get_data(qc)['unitary'], 3)
qc = QuantumCircuit(q)
qc.x(q)
circuit_drawer(qc)
job = execute(qc, backend='local_unitary_simulator')
np.round(job.result().get_data(qc)['unitary'], 3)
qc = QuantumCircuit(q)
qc.y(q)
circuit_drawer(qc)
job = execute(qc, backend='local_unitary_simulator')
np.round(job.result().get_data(qc)['unitary'], 3)
qc = QuantumCircuit(q)
qc.z(q)
circuit_drawer(qc)
job = execute(qc, backend='local_unitary_simulator')
np.round(job.result().get_data(qc)['unitary'], 3)
qc = QuantumCircuit(q)
qc.h(q)
circuit_drawer(qc)
job = execute(qc, backend='local_unitary_simulator')
np.round(job.result().get_data(qc)['unitary'], 3)
qc = QuantumCircuit(q)
qc.s(q)
circuit_drawer(qc)
job = execute(qc, backend='local_unitary_simulator')
np.round(job.result().get_data(qc)['unitary'], 3)
qc = QuantumCircuit(q)
qc.sdg(q)
circuit_drawer(qc)
job = execute(qc, backend='local_unitary_simulator')
np.round(job.result().get_data(qc)['unitary'], 3)
qc = QuantumCircuit(q)
qc.t(q)
circuit_drawer(qc)
job = execute(qc, backend='local_unitary_simulator')
np.round(job.result().get_data(qc)['unitary'], 3)
qc = QuantumCircuit(q)
qc.tdg(q)
circuit_drawer(qc)
job = execute(qc, backend='local_unitary_simulator')
np.round(job.result().get_data(qc)['unitary'], 3)
qc = QuantumCircuit(q)
qc.rx(pi/2,q)
circuit_drawer(qc)
job = execute(qc, backend='local_unitary_simulator')
np.round(job.result().get_data(qc)['unitary'], 3)
qc = QuantumCircuit(q)
qc.ry(pi/2,q)
circuit_drawer(qc)
job = execute(qc, backend='local_unitary_simulator')
np.round(job.result().get_data(qc)['unitary'], 3)
qc = QuantumCircuit(q)
qc.rz(pi/2,q)
circuit_drawer(qc)
job = execute(qc, backend='local_unitary_simulator')
np.round(job.result().get_data(qc)['unitary'], 3)
q = QuantumRegister(2)
qc = QuantumCircuit(q)
qc.cx(q[0],q[1])
circuit_drawer(qc)
job = execute(qc, backend='local_unitary_simulator')
np.round(job.result().get_data(qc)['unitary'], 3)
qc = QuantumCircuit(q)
qc.cy(q[0],q[1])
circuit_drawer(qc)
job = execute(qc, backend='local_unitary_simulator')
np.round(job.result().get_data(qc)['unitary'], 3)
qc = QuantumCircuit(q)
qc.cz(q[0],q[1])
circuit_drawer(qc)
job = execute(qc, backend='local_unitary_simulator')
np.round(job.result().get_data(qc)['unitary'], 3)
qc = QuantumCircuit(q)
qc.ch(q[0],q[1])
circuit_drawer(qc)
job = execute(qc, backend='local_unitary_simulator')
np.round(job.result().get_data(qc)['unitary']/(0.707+0.707j), 3)
qc = QuantumCircuit(q)
qc.crz(pi/2,q[0],q[1])
circuit_drawer(qc)
job = execute(qc, backend='local_unitary_simulator')
np.round(job.result().get_data(qc)['unitary'], 3)
qc = QuantumCircuit(q)
qc.cu1(pi/2,q[0], q[1])
circuit_drawer(qc)
job = execute(qc, backend='local_unitary_simulator')
np.round(job.result().get_data(qc)['unitary'], 3)
qc = QuantumCircuit(q)
qc.cu3(pi/2, pi/2, pi/2, q[0], q[1])
circuit_drawer(qc)
job = execute(qc, backend='local_unitary_simulator')
np.round(job.result().get_data(qc)['unitary'], 3)
qc = QuantumCircuit(q)
qc.swap(q[0], q[1])
circuit_drawer(qc)
job = execute(qc, backend='local_unitary_simulator')
np.round(job.result().get_data(qc)['unitary'], 3)
q = QuantumRegister(3)
qc = QuantumCircuit(q)
qc.ccx(q[0], q[1], q[2])
circuit_drawer(qc)
job = execute(qc, backend='local_unitary_simulator')
np.round(job.result().get_data(qc)['unitary'], 3)
qc = QuantumCircuit(q)
qc.cswap(q[0], q[1], q[2])
circuit_drawer(qc)
job = execute(qc, backend='local_unitary_simulator')
np.round(job.result().get_data(qc)['unitary'], 3)
q = QuantumRegister(1)
c = ClassicalRegister(1)
qc = QuantumCircuit(q, c)
qc.measure(q, c)
circuit_drawer(qc)
job = execute(qc, backend='local_qasm_simulator', shots=1024)
job.result().get_counts(qc)
qc = QuantumCircuit(q, c)
qc.h(q)
qc.measure(q, c)
circuit_drawer(qc)
job = execute(qc, backend='local_qasm_simulator', shots=1024)
job.result().get_counts(qc)
qc = QuantumCircuit(q, c)
qc.reset(q[0])
qc.measure(q, c)
circuit_drawer(qc)
job = execute(qc, backend='local_qasm_simulator', shots=1024)
job.result().get_counts(qc)
qc = QuantumCircuit(q, c)
qc.h(q)
qc.reset(q[0])
qc.measure(q, c)
circuit_drawer(qc)
job = execute(qc, backend='local_qasm_simulator', shots=1024)
job.result().get_counts(qc)
qc = QuantumCircuit(q, c)
qc.x(q[0]).c_if(c, 0)
qc.measure(q,c)
circuit_drawer(qc)
job = execute(qc, backend='local_qasm_simulator', shots=1024)
job.result().get_counts(qc)
qc = QuantumCircuit(q, c)
qc.h(q)
qc.measure(q,c)
qc.x(q[0]).c_if(c, 0)
qc.measure(q,c)
circuit_drawer(qc)
job = execute(qc, backend='local_qasm_simulator', shots=1024)
job.result().get_counts(qc)
# Initializing a three-qubit quantum state
import math
desired_vector = [
1 / math.sqrt(16) * complex(0, 1),
1 / math.sqrt(8) * complex(1, 0),
1 / math.sqrt(16) * complex(1, 1),
0,
0,
1 / math.sqrt(8) * complex(1, 2),
1 / math.sqrt(16) * complex(1, 0),
0]
q = QuantumRegister(3)
qc = QuantumCircuit(q)
qc.initialize(desired_vector, [q[0],q[1],q[2]])
circuit_drawer(qc)
job = execute(qc, backend='local_statevector_simulator')
qc_state = job.result().get_statevector(qc)
qc_state
state_fidelity(desired_vector,qc_state)
|
https://github.com/xtophe388/QISKIT
|
xtophe388
|
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.')
# useful additional packages
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
from pprint import pprint
from scipy import linalg as la
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, QISKitError
from qiskit import available_backends, execute, register, get_backend
# import state tomography functions
from qiskit.tools.visualization import plot_histogram, plot_state
def ghz_state(q, c, n):
# Create a GHZ state
qc = QuantumCircuit(q, c)
qc.h(q[0])
for i in range(n-1):
qc.cx(q[i], q[i+1])
return qc
def superposition_state(q, c):
# Create a Superposition state
qc = QuantumCircuit(q, c)
qc.h(q)
return qc
# Build the quantum cirucit. We are going to build two circuits a GHZ over 3 qubits and a
# superpositon over all 3 qubits
n = 3 # number of qubits
q = QuantumRegister(n)
c = ClassicalRegister(n)
# quantum circuit to make a GHZ state
ghz = ghz_state(q, c, n)
# quantum circuit to make a superposition state
superposition = superposition_state(q, c)
measure_circuit = QuantumCircuit(q,c)
measure_circuit.measure(q, c)
# execute the quantum circuit
backend = 'local_qasm_simulator' # the device to run on
circuits = [ghz+measure_circuit, superposition+measure_circuit]
job = execute(circuits, backend=backend, shots=1000)
plot_histogram(job.result().get_counts(circuits[0]))
plot_histogram(job.result().get_counts(circuits[1]),15)
n = 2 # number of qubits
q = QuantumRegister(n)
c = ClassicalRegister(n)
qc = QuantumCircuit(q, c)
qc.h(q[1])
# execute the quantum circuit
job = execute(qc, backend='local_statevector_simulator')
state_superposition = job.result().get_statevector(qc)
state_superposition
def overlap(state1, state2):
return round(np.dot(state1.conj(), state2))
print(state_superposition)
overlap(state_superposition, state_superposition)
def expectation_value(state, Operator):
return round(np.dot(state.conj(), np.dot(Operator, state)).real)
X = np.array([[0, 1], [1, 0]])
Z = np.array([[1, 0], [0, -1]])
IZ = np.kron(np.eye(2), Z)
ZI = np.kron(Z, np.eye(2))
IX = np.kron(np.eye(2), X)
XI = np.kron(X, np.eye(2))
print("Operator Z on qubit 0 is " + str(expectation_value(state_superposition, IZ)))
print("Operator Z on qubit 1 is " + str(expectation_value(state_superposition, ZI)))
print("Operator X on qubit 0 is " + str(expectation_value(state_superposition, IX)))
print("Operator X on qubit 1 is " + str(expectation_value(state_superposition, XI)))
def state_2_rho(state):
return np.outer(state, state.conj())
rho_superposition=state_2_rho(state_superposition)
print(rho_superposition)
plot_state(rho_superposition,'city')
plot_state(rho_superposition,'paulivec')
plot_state(rho_superposition,'qsphere')
plot_state(rho_superposition,'bloch')
n = 2 # number of qubits
q = QuantumRegister(n)
c = ClassicalRegister(n)
qc2 = QuantumCircuit(q, c)
qc2.h(q[1])
qc2.z(q[1])
# execute the quantum circuit
job = execute(qc2, backend='local_statevector_simulator')
state_neg_superposition = job.result().get_statevector(qc2)
rho_neg_superposition=state_2_rho(state_neg_superposition)
plot_state(rho_neg_superposition, 'qsphere')
plot_state(0.5*rho_neg_superposition + 0.5* rho_superposition, 'qsphere')
|
https://github.com/xtophe388/QISKIT
|
xtophe388
|
import sys, time, 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.')
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, QISKitError
from qiskit import available_backends, execute, register, get_backend, compile
from qiskit.tools.visualization import plot_histogram
from pprint import pprint
available_backends()
available_backends(compact=False)
register(qx_config['APItoken'], qx_config['url'])
available_backends()
available_backends({'local': False})
available_backends({'local': True})
available_backends({'simulator': True})
available_backends({'simulator': False})
available_backends({'local': False, 'simulator': True})
available_backends({'operational': True, 'simulator': False})
available_backends(lambda x: x.configuration['n_qubits'] > 10 and not x.configuration['simulator'])
from qiskit import least_busy
least_busy(available_backends({'simulator': False}))
backends = []
for backend in available_backends():
backends.append(get_backend(backend))
backends
for backend in backends:
pprint(backend.status)
for backend in backends:
pprint(backend.configuration)
for backend in backends:
pprint(backend.parameters)
for backend in backends:
pprint(backend.calibration)
qr = QuantumRegister(3)
cr = ClassicalRegister(3)
circuit = QuantumCircuit(qr, cr)
circuit.x(qr[0])
circuit.x(qr[1])
circuit.ccx(qr[0], qr[1], qr[2])
circuit.cx(qr[0], qr[1])
circuit.measure(qr, cr)
my_backend = get_backend('local_qasm_simulator')
qobj = compile(circuit, backend=my_backend, shots=1024)
job = my_backend.run(qobj)
job.status
job.done
result = job.result()
counts = result.get_counts()
print(counts)
device_name = least_busy(available_backends({'simulator': False}))
my_backend = get_backend(device_name)
qobj = compile(circuit, backend=my_backend, shots=1024)
job = my_backend.run(qobj)
lapse = 0
interval = 10
while not job.done:
print('Status @ {} seconds'.format(interval * lapse))
print(job.status)
time.sleep(interval)
lapse += 1
print(job.status)
job.id
result = job.result()
counts = result.get_counts()
print(counts)
plot_histogram(counts)
|
https://github.com/sam-pf/pf-qiskit
|
sam-pf
|
def _initialize (): # <<<
import qiskit
from math import isclose, sqrt
from numpy import exp, pi
# pylint: disable=E0401,E0611
from qiskit.circuit.library.data_preparation import state_preparation
# pylint: enable=E0401,E0611
_EPS = state_preparation._EPS
_initialize_orig = qiskit.QuantumCircuit.initialize # pylint: disable=E1101
docstr = """
A patched version of :meth:`qiskit.QuantumCircuit.initialize` so
that ``params`` accepts probability-centric expressions (in % unit).
When ``params`` is an iterable of strings, and only strings, then the
string expressions are parsed by this method as probability expressions
(with optional probability amplitude phases) and then converted to the
probability amplitudes for internal use.
Additionally, ``params`` may be a string that includes all
probability-centric expressions, separated by ',' and enclosed by '[' and
']'.
Probability-centric string expression must be in the following format
.. parsed-literal::
'<probability> %'
'<probability> % <phase>'
where ``<probability>`` and ``<phase>`` must be expressions for real
numbers (non-negative for ``<probability>``) and any white space before
``%`` or after ``%`` is optional.
So, in addition to specifying the probability, the phase of the probability
amplitude can also be optionally specified. The phase here corresponds
to the angle in the complex plane (as probability amplitude is complex
number; see the conversion forma below), and so it may just be considered
angle. Its unit is (implicitly) fixed as degrees.
Here are some basic phase values. 360 degrees, or any integer
multiples of 360 degrees, is the same as 0 degrees (which means a
positive amplitude), 180 degrees means a negative amplitude, 90 degrees
means multiplying the amplitude by 1j, 270 degrees means multiplying the
amplitude by -1j, etc.
For instance, all the following examples are valid inputs for ``params``
for a single qubit. For refernece, corresponding numeric expressions for
the probably amplitude are also given.
.. code-block::
['100 %', '0 %'] : [1, 0]
'[100 % 360, 0 %]' : [1, 0]
'[100 % 720.0, 0 %]' : [1, 0]
['100 % -360', '0 %'] : [1, 0]
'[100 % 180, 0 %]' : [-1, 0]
'[50 % 90, 50 % 180]' : [sqrt(0.5)*1j, -sqrt(0.5)]
'[70 % 2, 30 % 270]' : [sqrt(0.7)*exp(2j*pi/180), -sqrt(0.3)*1j]
['70 % 2', '30 % 270'] : [sqrt(0.7)*exp(2j*pi/180), -sqrt(0.3)*1j]
As these examples demonstrate, the formula going from the `<probability>`
and `<phase>` to the probability amplitude is as follows:
``sqrt(<probability>) * exp(<phase> * 1j * pi/180)``.
In this way, the probabiliy-centric specification of ``params`` using
string is equal in terms of its expressive power as the probabiliy
amplitude specification using (generally complex) numbers.
For example the following two circuits ``c1`` and ``c2`` are initialized
exactly the same way.
.. code-block::
import numpy as np
from qiskit import QuantumCircuit
c1 = QuantumCircuit (1)
c1.initialize ([1/np.sqrt(2), -1/np.sqrt(2)])
c2 = QuantumCircuit (1)
c2.initialize (['50 %', '50 % 180'])
""".strip ()
if _initialize_orig.__doc__:
docstr += """
--- The documentation for the unpatched version of this method follows. ---
""" + _initialize_orig.__doc__
phase_arg_factor = 1j * pi / 180.
from collections.abc import Iterable
def initialize (self, params, qubits = None): # <<<
if isinstance (params, str):
s = params.strip ()
if s.startswith ('[') and s.endswith (']'):
s = s [1:-1]
params = s.split (',')
if isinstance (params, Iterable) and not isinstance (params, str):
params = list (params)
score = sum (1 if isinstance (v, str) else 0 for v in params)
if score == len (params):
params_new = []
pr_sum = 0.
for v in params:
if '%' not in v:
raise ValueError ("Any string iterated by params "
"must contain %.")
pr, pf = v.split ('%', 1)
pr = float (pr)
pf = (exp (float (pf) * phase_arg_factor)
if pf.strip () else 1.)
if pr < 0:
if isclose (pr, 0., abs_tol = _EPS):
pr = 0.
else:
raise ValueError (f"Probability in {v!r} is not "
"non-negative.")
params_new.append (sqrt (pr) * pf / 10.)
pr_sum += pr
if not isclose (pr_sum, 100., abs_tol = _EPS * 100.):
raise ValueError ("Sum of probabilities must be equal to "
"100 (%).")
params = params_new
elif score:
raise TypeError ("If a string is an element of params then "
"all elements must be strings.")
return _initialize_orig (self, params, qubits = qubits)
# >>>
initialize.__doc__ = docstr
return initialize
# >>>
_initialize = _initialize ()
def _ (): # <<<
import qiskit
if qiskit.QuantumCircuit.initialize is _initialize: # pylint: disable=E1101
return
qiskit.QuantumCircuit.initialize = _initialize # pylint: disable=E1101
# >>>
_ ()
|
https://github.com/sam-pf/pf-qiskit
|
sam-pf
|
# -*- 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/sam-pf/pf-qiskit
|
sam-pf
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2018, 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""
This module contains the definition of a base class for quantum fourier transforms.
"""
from abc import abstractmethod
from qiskit import QuantumRegister, QuantumCircuit
from qiskit.aqua import Pluggable, AquaError
class QFT(Pluggable):
"""Base class for QFT.
This method should initialize the module and its configuration, and
use an exception if a component of the module is
available.
Args:
configuration (dict): configuration dictionary
"""
@abstractmethod
def __init__(self, *args, **kwargs):
super().__init__()
@classmethod
def init_params(cls, params):
qft_params = params.get(Pluggable.SECTION_KEY_QFT)
kwargs = {k: v for k, v in qft_params.items() if k != 'name'}
return cls(**kwargs)
@abstractmethod
def _build_matrix(self):
raise NotImplementedError
@abstractmethod
def _build_circuit(self, qubits=None, circuit=None, do_swaps=True):
raise NotImplementedError
def construct_circuit(self, mode='circuit', qubits=None, circuit=None, do_swaps=True):
"""Construct the circuit.
Args:
mode (str): 'matrix' or 'circuit'
qubits (QuantumRegister or qubits): register or qubits to build the circuit on.
circuit (QuantumCircuit): circuit for construction.
do_swaps (bool): include the swaps.
Returns:
The matrix or circuit depending on the specified mode.
"""
if mode == 'circuit':
return self._build_circuit(qubits=qubits, circuit=circuit, do_swaps=do_swaps)
elif mode == 'matrix':
return self._build_matrix()
else:
raise AquaError('Unrecognized mode: {}.'.format(mode))
|
https://github.com/arian-code/nptel_quantum_assignments
|
arian-code
|
import numpy as np
#Option A
p1=np.matrix([[0, 1],[-1, 0]])
print (p1)
print (p1.getH())
if (p1==p1.getH()).all():
print ("It is hermitian")
else:
print ("It is not hermitian")
#Option B
p1=np.matrix([[0, 0+1j],[0-1j, 0]])
print (p1)
print (p1.getH())
if (p1==p1.getH()).all():
print ("It is hermitian")
else:
print ("It is not hermitian")
#Option C
p1=np.matrix([[1, 0],[0, 0-1j]])
print (p1)
print (p1.getH())
if (p1==p1.getH()).all():
print ("It is hermitian")
else:
print ("It is not hermitian")
#Option D
p1=np.matrix([[1, 0+1j],[0-1j, -1]])
print (p1)
print (p1.getH())
if (p1==p1.getH()).all():
print ("It is hermitian")
else:
print ("It is not hermitian")
|
https://github.com/arian-code/nptel_quantum_assignments
|
arian-code
|
from sympy import *
from sympy.physics.quantum.state import Ket, Bra
from sympy.physics.quantum import TensorProduct
import numpy as np
init_printing(use_unicode=True)
#One Q bit gates
H=Matrix([[1/sqrt(2), 1/sqrt(2)],[1/sqrt(2), -1/sqrt(2)]])
S=Matrix([[0, 1],[1, I]])
X=Matrix([[0, 1],[1, 0]])
Y=Matrix([[0, -I],[I, 0]])
Z=Matrix([[1, 0],[0, -1]])
Identity=Matrix([[1, 0],[0, 1]])
H, S, X, Y, Z, Identity
#Two Q bit gates
CNOT=Matrix([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]])
CNOT
HI=TensorProduct(H, Identity) #Example only
CNOT, HI
circuit=TensorProduct(X, Identity)*CNOT*TensorProduct(X, Identity)
circuit
#option A
in_1=Matrix([[1],[0],[0],[0]])
lhs=circuit*in_1
rhs=Matrix([[0],[1],[0],[0]])
print (lhs)
print (rhs)
if (lhs==rhs):
print ("It is true")
else:
print ("It is false")
#option B
in_1=Matrix([[0],[1],[0],[0]])
lhs=circuit*in_1
rhs=Matrix([[0],[1],[0],[0]])
print (lhs)
print (rhs)
if (lhs==rhs):
print ("It is true")
else:
print ("It is false")
#option C
in_1=Matrix([[0],[0],[1],[0]])
lhs=circuit*in_1
rhs=Matrix([[0],[0],[1],[0]])
print (lhs)
print (rhs)
if (lhs==rhs):
print ("It is true")
else:
print ("It is false")
#option D
in_1=Matrix([[0],[0],[1],[0]])
lhs=circuit*in_1
rhs=Matrix([[0],[0],[0],[1]])
print (lhs)
print (rhs)
if (lhs==rhs):
print ("It is true")
else:
print ("It is false")
|
https://github.com/arian-code/nptel_quantum_assignments
|
arian-code
|
from sympy import *
import numpy as np
from sympy.physics.quantum import TensorProduct
from sympy import Matrix, I
from sympy.physics.quantum.dagger import Dagger
init_printing(use_unicode=True)
H=Matrix([[1/sqrt(2), 1/sqrt(2)],[1/sqrt(2), -1/sqrt(2)]])
lhs=H
lhs
bra_0=Matrix([[1],[0]])
ket_0=Dagger(bra_0)
bra_1=Matrix([[0],[1]])
ket_1=Dagger(bra_1)
bra_plus=(1/sqrt(2))*Matrix([[1],[1]])
ket_plus=Dagger(bra_plus)
bra_minus=(1/sqrt(2))*Matrix([[1],[-1]])
ket_minus=Dagger(bra_minus)
bra_0, ket_0, bra_1, ket_1, bra_plus, bra_minus, ket_plus, ket_minus
#Test
1/sqrt(2)*(TensorProduct(bra_0, ket_0)+TensorProduct(bra_1, ket_1))
#option A
rhs=1/sqrt(2)*(TensorProduct(bra_0, ket_0)+TensorProduct(bra_1, ket_1))
print (lhs)
print (rhs)
if (lhs==rhs):
print ("It is true")
else:
print ("It is false")
#option B
rhs=(TensorProduct(bra_0, ket_plus)+TensorProduct(bra_1, ket_minus))
print (lhs)
print (rhs)
if (lhs==rhs):
print ("It is true")
else:
print ("It is false")
#option C
rhs=1/sqrt(2)*(TensorProduct(bra_0, ket_0)+
TensorProduct(bra_0, ket_1)+
TensorProduct(bra_1, ket_0)-
TensorProduct(bra_1, ket_1))
print (lhs)
print (rhs)
if (lhs==rhs):
print ("It is true")
else:
print ("It is false")
#option C
rhs=1/sqrt(2)*(TensorProduct(bra_plus, ket_0)+
TensorProduct(bra_minus, ket_1))
print (lhs)
print (rhs)
if (lhs==rhs):
print ("It is true")
else:
print ("It is false")
|
https://github.com/arian-code/nptel_quantum_assignments
|
arian-code
|
from sympy import *
import numpy as np
init_printing(use_unicode=True)
a, b, d, f = symbols('alpha beta theta phi')
a, b, d, f
p1=exp(I*f)
p2=Matrix([[exp(-I*a/2), 0],[0, exp(I*a/2)]])
p3=Matrix([[cos (d/2), -I*sin (d/2)],[-I*sin (d/2), cos (d/2)]])
p4=Matrix([[exp(-I*b/2), 0],[0, exp(I*b/2)]])
p1, p2, p3, p4
out=p1*p2*p3*p4
out
H=Matrix([[1/sqrt(2), 1/sqrt(2)],[1/sqrt(2), -1/sqrt(2)]])
lhs=H
lhs
#option A
rhs=out.subs([(f, 0), (a, 0), (b, 0), (d, pi/2)])
print (rhs)
if (lhs==rhs):
print ("It is true")
else:
print ("It is false")
#option B
lhs=out.subs([(f, pi/2), (a, pi/2), (b, pi/2), (d, pi/2)])
print (rhs)
if (lhs==rhs):
print ("It is true")
else:
print ("It is false")
#option C
lhs=out.subs([(f, 0), (a, pi/2), (b, pi/2), (d, pi/4)])
print (rhs)
if (lhs==rhs):
print ("It is true")
else:
print ("It is false")
#option D
lhs=out.subs([(f, pi/4), (a, pi/2), (b, pi/2), (d, pi/4)])
print (rhs)
if (lhs==rhs):
print ("It is true")
else:
print ("It is false")
|
https://github.com/arian-code/nptel_quantum_assignments
|
arian-code
|
from sympy import *
import numpy as np
init_printing(use_unicode=True)
a, b, d, f = symbols('alpha beta theta phi')
a, b, d, f
p1=exp(I*f)
H=Matrix([[1/sqrt(2), 1/sqrt(2)],[1/sqrt(2), -1/sqrt(2)]])
S=Matrix([[0, 1],[1, I]])
X=Matrix([[0, 1],[1, 0]])
Y=Matrix([[0, -I],[I, 0]])
Z=Matrix([[1, 0],[0, -1]])
H, S, X, Y, Z
#option A
lhs=H*X*H
rhs=-1*Z
print (lhs)
print (rhs)
if (lhs==rhs):
print ("It is true")
else:
print ("It is false")
#option B
lhs=H*Y*H
rhs=-1*Y
print (lhs)
print (rhs)
if (lhs==rhs):
print ("It is true")
else:
print ("It is false")
#option C
lhs=H
rhs=1/sqrt(2)*(X+Z)
print (lhs)
print (rhs)
if (lhs==rhs):
print ("It is true")
else:
print ("It is false")
#option D
lhs=H*Z*H
rhs=X
print (lhs)
print (rhs)
if (lhs==rhs):
print ("It is true")
else:
print ("It is false")
|
https://github.com/arian-code/nptel_quantum_assignments
|
arian-code
|
from sympy import *
from sympy.physics.quantum.state import Ket, Bra
import numpy as np
init_printing(use_unicode=True)
#in_1=Ket (0)
#in_1
in_1=Matrix([[1],[0],[0],[0]])
in_1
X_2 =Matrix([[0, 0, 1, 0], [0, 0, 0, 1], [1, 0, 0, 0], [0, 1, 0, 0]])
CNOT=Matrix([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]])
X_2, CNOT
#Apply to circuit
out=CNOT*X_2*CNOT*in_1
out
|
https://github.com/arian-code/nptel_quantum_assignments
|
arian-code
|
from sympy import *
from sympy.physics.quantum.state import Ket, Bra
from sympy.physics.quantum import TensorProduct
import numpy as np
init_printing(use_unicode=True)
#One Q bit gates
H=Matrix([[1/sqrt(2), 1/sqrt(2)],[1/sqrt(2), -1/sqrt(2)]])
S=Matrix([[0, 1],[1, I]])
X=Matrix([[0, 1],[1, 0]])
Y=Matrix([[0, -I],[I, 0]])
Z=Matrix([[1, 0],[0, -1]])
Identity=Matrix([[1, 0],[0, 1]])
H, S, X, Y, Z, Identity
#Two Q bit gates
CNOT=Matrix([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]])
CNOT
HI=TensorProduct(H, Identity) #Example only
CNOT, HI
#option A
lhs=CNOT*TensorProduct(Y, Identity)*CNOT
rhs=TensorProduct(Y, Y)
print (lhs)
print (rhs)
if (lhs==rhs):
print ("It is true")
else:
print ("It is false")
#option B
lhs=CNOT*TensorProduct(Y, Identity)*CNOT
rhs=TensorProduct(Y, X)
print (lhs)
print (rhs)
if (lhs==rhs):
print ("It is true")
else:
print ("It is false")
#option C
lhs=CNOT*TensorProduct(Identity, Y)*CNOT
rhs=TensorProduct(Y, Y)
print (lhs)
print (rhs)
if (lhs==rhs):
print ("It is true")
else:
print ("It is false")
#option D
lhs=CNOT*TensorProduct(Identity, Y)*CNOT
rhs=TensorProduct(Z, Y)
print (lhs)
print (rhs)
if (lhs==rhs):
print ("It is true")
else:
print ("It is false")
|
https://github.com/arian-code/nptel_quantum_assignments
|
arian-code
|
from sympy import *
from sympy.physics.quantum.state import Ket, Bra
from sympy.physics.quantum import TensorProduct
import numpy as np
init_printing(use_unicode=True)
#One Q bit gates
H=Matrix([[1/sqrt(2), 1/sqrt(2)],[1/sqrt(2), -1/sqrt(2)]])
S=Matrix([[1, 0],[0, I]])
X=Matrix([[0, 1],[1, 0]])
Y=Matrix([[0, -I],[I, 0]])
Z=Matrix([[1, 0],[0, -1]])
Identity=Matrix([[1, 0],[0, 1]])
H, S, X, Y, Z, Identity
#Two Q bit gates
CNOT=Matrix([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]])
CNOT
HI=TensorProduct(H, Identity) #Example only
CNOT, HI
circuit=CNOT*TensorProduct(S, Identity)*TensorProduct(H, Identity)
circuit
in_1=Matrix([[0],[0],[0],[1]])
in_1
lhs=circuit*in_1
lhs
#option A
rhs=Matrix([[0],[1/sqrt(2)],[1/sqrt(2)],[0]])
print (lhs)
print (rhs)
if (lhs==rhs):
print ("It is true")
else:
print ("It is false")
#option B
rhs=Matrix([[0],[1/sqrt(2)],[-I/sqrt(2)],[0]])
print (lhs)
print (rhs)
if (lhs==rhs):
print ("It is true")
else:
print ("It is false")
#option C
rhs=Matrix([[0],[1/sqrt(2)],[-1/sqrt(2)],[0]])
print (lhs)
print (rhs)
if (lhs==rhs):
print ("It is true")
else:
print ("It is false")
#option D
rhs=Matrix([[1/sqrt(2)],[0],[0],[1/sqrt(2)]])
print (lhs)
print (rhs)
if (lhs==rhs):
print ("It is true")
else:
print ("It is false")
|
https://github.com/arian-code/nptel_quantum_assignments
|
arian-code
|
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_state_qsphere
%matplotlib inline
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
state = Statevector.from_instruction(qc)
plot_state_qsphere(state)
|
https://github.com/arian-code/nptel_quantum_assignments
|
arian-code
|
import numpy as np
from qiskit import *
# Create a Quantum Circuit acting on a quantum register of three qubits
circ = QuantumCircuit(3)
# Add a H gate on qubit 0, putting this qubit in superposition.
circ.h(0)
# Add a CX (CNOT) gate on control qubit 0 and target qubit 1, putting
# the qubits in a Bell state.
circ.cx(0, 1)
# Add a CX (CNOT) gate on control qubit 0 and target qubit 2, putting
# the qubits in a GHZ state.
circ.cx(0, 2)
circ.draw('mpl')
# 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 = backend.run(circ)
result = job.result()
outputstate = result.get_statevector(circ, decimals=3)
print(outputstate)
from qiskit.visualization import plot_state_city
plot_state_city(outputstate)
from qiskit.visualization import plot_state_qsphere
%matplotlib inline
plot_state_qsphere(outputstate)
|
https://github.com/arian-code/nptel_quantum_assignments
|
arian-code
|
import numpy as np
from qiskit import *
# Create a Quantum Circuit acting on a quantum register of three qubits
qc = QuantumCircuit(1)
qc.x(0)
qc.h(0) #set qubit to superposition
qc.z(0) #add Z gate to rotate out of phase by pi/2
#write the next lines to execute circuit and capture results
qc.draw('mpl')
# 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 = backend.run(qc)
result = job.result()
outputstate = result.get_statevector(qc, decimals=3)
print(outputstate)
from qiskit.visualization import plot_state_city
plot_state_city(outputstate)
from qiskit.visualization import plot_state_qsphere
%matplotlib inline
plot_state_qsphere(outputstate)
|
https://github.com/arian-code/nptel_quantum_assignments
|
arian-code
|
from sympy import *
from sympy.physics.quantum.state import Ket, Bra
from sympy.physics.quantum import TensorProduct
import numpy as np
init_printing(use_unicode=True)
plus=Matrix([1/sqrt(2), 1/sqrt(2)])
zero=Matrix([1, 0])
minus=Matrix([1/sqrt(2), -1/sqrt(2)])
plus, zero, minus
TensorProduct(plus, zero, minus)
|
https://github.com/arian-code/nptel_quantum_assignments
|
arian-code
|
import numpy as np
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile, Aer, IBMQ
from qiskit.tools.jupyter import *
from qiskit.visualization import *
#from ibm_quantum_widgets import *
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
from qiskit import assemble
import numpy as np
import matplotlib.pyplot as plt
n=4
grover_ckt = QuantumCircuit(n+1, n)
marked = [1,0,1,1] # 1101 element is marked (lsb to msb)=>13
def apply_oracle(n,marked,ckt):
control0 = [i for i in range(n) if not marked[i]]
ckt.x(control0)
ckt.mct(list(range(n)),n)
ckt.x(control0)
ckt.draw()
#option A
def reflect_uniform(ckt,n):
ckt.h(list(range(n)))
ckt.x(list(range(n)))
ckt.mct(list(range(n)),n)
ckt.x(list(range(n)))
ckt.h(list(range(n)))
ckt.x(n)
#Test option A
qc=QuantumCircuit(5)
reflect_uniform(qc,4)
qc.draw()
|
https://github.com/arian-code/nptel_quantum_assignments
|
arian-code
|
from sympy import *
from sympy.physics.quantum.state import Ket, Bra
from sympy.physics.quantum import TensorProduct
import numpy as np
init_printing(use_unicode=True)
# Q bit gates
H=Matrix([[1/sqrt(2), 1/sqrt(2)],[1/sqrt(2), -1/sqrt(2)]])
S=Matrix([[1, 0],[0, I]])
X=Matrix([[0, 1],[1, 0]])
Y=Matrix([[0, -I],[I, 0]])
Z=Matrix([[1, 0],[0, -1]])
Identity=Matrix([[1, 0],[0, 1]])
H, S, X, Y, Z, Identity
#Q bit gates
CCX=Matrix([[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, 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]])
CNOT=Matrix([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 0, 1], [0, 0, 1, 0]])
SWAP=Matrix([[1, 0, 0, 0], [0, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 1]])
CIIX=(TensorProduct(Identity, Identity, SWAP) #4 qbit CNOT, Cqbit=0 and acted qbit=3
*TensorProduct(Identity, SWAP, Identity)
*TensorProduct(CNOT, Identity, Identity)
*TensorProduct(Identity, SWAP, Identity)
*TensorProduct(Identity, Identity, SWAP))
CCX, SWAP,CIIX, CNOT
zero=Matrix([[1],[0]])
one=Matrix([[0],[1]])
plus=Matrix([[1/sqrt(2)], [1/sqrt(2)]])
minus=Matrix([[1/sqrt(2)], [-1/sqrt(2)]])
zero, one, plus, minus
circuit=(TensorProduct(Identity, Identity, CNOT)
* TensorProduct(Identity, CCX)
* CIIX
* TensorProduct(H, Identity, H, H)
* TensorProduct(zero, one, zero, one))
circuit
lhs=circuit
lhs
#option A
rhs=TensorProduct(minus, one, plus, minus)
print (lhs)
print (rhs)
if (lhs==rhs):
print ("It is true")
else:
print ("It is false")
#option B
rhs=(1/sqrt(2))*(TensorProduct(minus, one, zero, minus)+TensorProduct(minus, one, one, minus))
print (lhs)
print (rhs)
if (lhs==rhs):
print ("It is true")
else:
print ("It is false")
#option C
rhs=(-1)*(TensorProduct(plus, one, plus, minus))
print (lhs)
print (rhs)
if (lhs==rhs):
print ("It is true")
else:
print ("It is false")
#option D
rhs=(TensorProduct(plus, one, plus, minus))
print (lhs)
print (rhs)
if (lhs==rhs):
print ("It is true")
else:
print ("It is false")
#option A and B
opt_b=(1/sqrt(2))*(TensorProduct(minus, one, zero, minus)+TensorProduct(minus, one, one, minus))
opt_b
opt_a=TensorProduct(minus, one, plus, minus)
opt_a
|
https://github.com/arian-code/nptel_quantum_assignments
|
arian-code
|
import numpy as np
# Import Qiskit
from qiskit import QuantumCircuit
from qiskit import Aer, transpile
from qiskit.tools.visualization import plot_histogram, plot_state_city
from qiskit import *
from qiskit.tools.monitor import job_monitor
import qiskit.quantum_info as qi
Aer.backends()
simulator = Aer.get_backend('aer_simulator')
# Set initial state to generated statevector
circ = QuantumCircuit(4, 3)
circ.x(3)
circ.barrier()
circ.h(0)
circ.h(1)
circ.h(2)
circ.h(3)
circ.cx(0,3)
circ.cx(2,3)
circ.h(0)
circ.h(1)
circ.h(2)
circ.barrier()
circ.measure([0,1,2], [0,1,2])
circ.draw()
# execute the quantum circuit
backend = BasicAer.get_backend('qasm_simulator') # the device to run on
result = backend.run(transpile(circ, backend), shots=1000).result()
counts = result.get_counts(circ)
print(counts)
plot_histogram(counts)
|
https://github.com/arian-code/nptel_quantum_assignments
|
arian-code
|
import numpy as np
# Import Qiskit
from qiskit import QuantumCircuit
from qiskit import Aer, transpile
from qiskit.tools.visualization import plot_histogram, plot_state_city
from qiskit import *
from qiskit.tools.monitor import job_monitor
import qiskit.quantum_info as qi
Aer.backends()
simulator = Aer.get_backend('aer_simulator')
# Set initial state to generated statevector
circ = QuantumCircuit(7, 6)
circ.x(6)
circ.barrier()
circ.h(0)
circ.h(1)
circ.h(2)
circ.h(3)
circ.h(4)
circ.h(5)
circ.h(6)
circ.barrier()
circ.x(0)
circ.x(2)
circ.x(3)
circ.barrier()
circ.h(0)
circ.h(1)
circ.h(2)
circ.h(3)
circ.h(4)
circ.h(5)
circ.h(6)
circ.barrier()
circ.measure(range(6), range(6))
circ.draw()
# execute the quantum circuit
backend = BasicAer.get_backend('qasm_simulator') # the device to run on
result = backend.run(transpile(circ, backend), shots=1000).result()
counts = result.get_counts(circ)
print(counts)
plot_histogram(counts)
|
https://github.com/arian-code/nptel_quantum_assignments
|
arian-code
|
import numpy as np
# Import Qiskit
from qiskit import QuantumCircuit
from qiskit import Aer, transpile
from qiskit.tools.visualization import plot_histogram, plot_state_city
from qiskit import *
from qiskit.tools.monitor import job_monitor
import qiskit.quantum_info as qi
Aer.backends()
simulator = Aer.get_backend('aer_simulator')
# Set initial state to generated statevector
circ = QuantumCircuit(7, 6)
circ.x(6)
circ.barrier()
circ.h(0)
circ.h(1)
circ.h(2)
circ.h(3)
circ.h(4)
circ.h(5)
circ.h(6)
circ.barrier()
circ.x(2)
circ.cx(3,6)
circ.cx(0,6)
circ.cx(5,6)
circ.x(3)
circ.cx(3,6)
circ.x(0)
circ.barrier()
circ.h(0)
circ.h(1)
circ.h(2)
circ.h(3)
circ.h(4)
circ.h(5)
circ.h(6)
circ.barrier()
circ.measure(range(6), range(6))
circ.draw()
# execute the quantum circuit
backend = BasicAer.get_backend('qasm_simulator') # the device to run on
result = backend.run(transpile(circ, backend), shots=1000).result()
counts = result.get_counts(circ)
print(counts)
plot_histogram(counts)
|
https://github.com/arian-code/nptel_quantum_assignments
|
arian-code
|
import numpy as np
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile, Aer, IBMQ
from qiskit.tools.jupyter import *
from qiskit.visualization import *
#from ibm_quantum_widgets import *
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
from qiskit import assemble
import numpy as np
import matplotlib.pyplot as plt
n=4
grover_ckt = QuantumCircuit(n+1, n)
marked = [1,0,1,1] # 1101 element is marked (lsb to msb)=>13
def apply_oracle(n,marked,ckt):
control0 = [i for i in range(n) if not marked[i]]
ckt.x(control0)
ckt.mct(list(range(n)),n)
ckt.x(control0)
ckt.draw()
def reflect_uniform(ckt,n):
ckt.h(list(range(n)))
ckt.x(list(range(n)))
ckt.mct(list(range(n)),n)
ckt.x(list(range(n)))
ckt.h(list(range(n)))
ckt.x(n)
grover_ckt.x(n)
grover_ckt.barrier()
grover_ckt.h(list(range(n+1)))
grover_ckt.draw()
svsim = Aer.get_backend('statevector_simulator') # Tell Qiskit how to simulate our circuit
qobj = assemble(grover_ckt) # Create a Qobj from the circuit for the simulator to run
result = svsim.run(qobj).result() # Do the simulation and return the result
statevector = result.data()['statevector']
statevector = statevector[:2**n]
marked = [1,0,1,1] # Corresponds to integer 1101 in binary => 13
ket_a = np.zeros(2**n)
ket_a[13] =1
ket_e = (np.ones(2**n) - ket_a)/np.sqrt(2**n -1)
print (ket_a)
print (ket_e)
def get_projection(psi,e,a ):
proj = [np.real(np.vdot(e,psi)), np.real(np.vdot(a,psi))]
return proj
def plt_vector(proj, axes =[0.0,1.0,0.0,1.0]):
x_pos = 0
y_pos = 0
x_direct = proj[0]
y_direct = proj[1]
# Creating plot
fig, ax = plt.subplots()
ax.quiver(x_pos, y_pos, x_direct, y_direct,scale=1.0)
ax.axis(axes)
# show plot
plt.show()
proj = get_projection(statevector, ket_e, ket_a)
plt_vector(proj)
print (proj)
#grover_ckt.append(oracle, list(range(n+1)))
apply_oracle(4,marked,grover_ckt)
grover_ckt.barrier()
grover_ckt.draw()
reflect_uniform(grover_ckt,n)
grover_ckt.barrier()
grover_ckt.draw()
svsim = Aer.get_backend('statevector_simulator') # Tell Qiskit how to simulate our circuit
qobj = assemble(grover_ckt) # Create a Qobj from the circuit for the simulator to run
result = svsim.run(qobj).result() # Do the simulation and return the result
statevector = result.data()['statevector']
statevector = statevector[:2**n]
proj = get_projection(statevector, ket_e, ket_a)
plt_vector(proj)
apply_oracle(4,marked,grover_ckt)
grover_ckt.barrier()
reflect_uniform(grover_ckt,n)
grover_ckt.barrier()
grover_ckt.draw()
svsim = Aer.get_backend('statevector_simulator') # Tell Qiskit how to simulate our circuit
qobj = assemble(grover_ckt) # Create a Qobj from the circuit for the simulator to run
result = svsim.run(qobj).result() # Do the simulation and return the result
statevector = result.data()['statevector']
statevector = statevector[:2**n]
proj = get_projection(statevector, ket_e, ket_a)
plt_vector(proj)
apply_oracle(4,marked,grover_ckt)
grover_ckt.barrier()
reflect_uniform(grover_ckt,n)
grover_ckt.barrier()
grover_ckt.draw()
svsim = Aer.get_backend('statevector_simulator') # Tell Qiskit how to simulate our circuit
qobj = assemble(grover_ckt) # Create a Qobj from the circuit for the simulator to run
result = svsim.run(qobj).result() # Do the simulation and return the result
statevector = result.data()['statevector']
statevector = statevector[:2**n]
proj = get_projection(statevector, ket_e, ket_a)
plt_vector(proj, axes = [-1.0,1.0,-1.0,1.0])
theta0 = 0.252
theta0
T = 0.5*((np.pi/(2*theta0))-1)
T
n=4
grover_ckt = QuantumCircuit(n+1, n)
marked = [1,0,1,1] # 1101 element is marked (lsb to msb)=>13
grover_ckt.x(n)
grover_ckt.barrier()
grover_ckt.h(list(range(n+1)))
grover_ckt.barrier()
for _ in range(int(np.floor(T))):
apply_oracle(4,marked,grover_ckt)
grover_ckt.barrier()
reflect_uniform(grover_ckt,n)
grover_ckt.barrier()
for j in range(n):
grover_ckt.measure(j,j)
grover_ckt.draw()
sim = Aer.get_backend('qasm_simulator') # Tell Qiskit how to simulate our circuit
qobj = assemble(grover_ckt) # Create a Qobj from the circuit for the simulator to run
result = sim.run(qobj).result() # Do the simulation and return the result
result
counts = result.get_counts(grover_ckt)
plot_histogram(counts)
|
https://github.com/Cryoris/gradient-reverse-mode
|
Cryoris
|
"""A classification example where we we only have asymptotically 1/4th of parameterized gates."""
import numpy as np
from qiskit import QuantumCircuit
from qiskit.circuit.library import ZFeatureMap, RealAmplitudes
from qiskit.circuit.parametertable import ParameterTable
from qiskit.opflow import H
from .benchmark import Benchmark
class Classification(QuantumCircuit):
"""UCCSD with the same API as Qiskit's circuit library."""
def __init__(self, num_qubits, reps=3):
self._reps = reps
super().__init__(num_qubits)
self._build()
@property
def reps(self):
"""Get the number of repetitions of the circuit."""
return self._reps
@reps.setter
def reps(self, value):
"""Set the number of repetitions. Rebuilds the circuit."""
self._reps = value
self._build() # rebuild
def assign_parameters(self, params, inplace=False):
"""Assign parameters."""
if isinstance(params, (list, np.ndarray)):
params = dict(zip(self._params[:], params))
return super().assign_parameters(params, inplace=inplace)
@property
def ordered_parameters(self):
return list(self._parameter_table.keys())
def _build(self):
# wipe current state
self._data = []
self._parameter_table = ParameterTable()
# get UCCSD circuit
featmap = ZFeatureMap(self.num_qubits, reps=self.reps)
ansatz = RealAmplitudes(self.num_qubits, reps=self.reps, entanglement='circular')
# store the parameters in a list for assigning them
self._params = ansatz.ordered_parameters
# set the data circuit with some input data
featmap.assign_parameters(np.random.random(featmap.num_parameters), inplace=True)
# combine the circuit
self.compose(featmap, inplace=True)
self.compose(ansatz, inplace=True)
def run_featuremap():
circuit = Classification(4)
benchmark = Benchmark(2 ** np.arange(2, 8), H, 24)
benchmark.run_benchmark(circuit, 'free')
benchmark.plot(show=True)
|
https://github.com/Cryoris/gradient-reverse-mode
|
Cryoris
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2018, 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""
This trial wavefunction is a Unitary Coupled-Cluster Single and Double excitations
variational form.
For more information, see https://arxiv.org/abs/1805.04340
"""
import logging
import sys
import numpy as np
from qiskit import QuantumRegister, QuantumCircuit
from qiskit.tools import parallel_map
from qiskit.tools.events import TextProgressBar
from qiskit.aqua import Operator, aqua_globals
from qiskit.aqua.components.variational_forms import VariationalForm
from qiskit.chemistry.fermionic_operator import FermionicOperator
from qiskit.chemistry import MP2Info
from qiskit.chemistry import QMolecule as qm
logger = logging.getLogger(__name__)
class UCCSD(VariationalForm):
"""
This trial wavefunction is a Unitary Coupled-Cluster Single and Double excitations
variational form.
For more information, see https://arxiv.org/abs/1805.04340
"""
CONFIGURATION = {
'name': 'UCCSD',
'description': 'UCCSD Variational Form',
'input_schema': {
'$schema': 'http://json-schema.org/schema#',
'id': 'uccsd_schema',
'type': 'object',
'properties': {
'depth': {
'type': 'integer',
'default': 1,
'minimum': 1
},
'num_orbitals': {
'type': 'integer',
'default': 4,
'minimum': 1
},
'num_particles': {
'type': 'integer',
'default': 2,
'minimum': 1
},
'active_occupied': {
'type': ['array', 'null'],
'default': None
},
'active_unoccupied': {
'type': ['array', 'null'],
'default': None
},
'qubit_mapping': {
'type': 'string',
'default': 'parity',
'oneOf': [
{'enum': ['jordan_wigner', 'parity', 'bravyi_kitaev']}
]
},
'two_qubit_reduction': {
'type': 'boolean',
'default': False
},
'mp2_reduction': {
'type': 'boolean',
'default': False
},
'num_time_slices': {
'type': 'integer',
'default': 1,
'minimum': 1
},
},
'additionalProperties': False
},
'depends': [
{
'pluggable_type': 'initial_state',
'default': {
'name': 'HartreeFock',
}
},
],
}
def __init__(self, num_qubits, depth, num_orbitals, num_particles,
active_occupied=None, active_unoccupied=None, initial_state=None,
qubit_mapping='parity', two_qubit_reduction=False, mp2_reduction=False, num_time_slices=1,
cliffords=None, sq_list=None, tapering_values=None, symmetries=None,
shallow_circuit_concat=True):
"""Constructor.
Args:
num_orbitals (int): number of spin orbitals
depth (int): number of replica of basic module
num_particles (int): number of particles
active_occupied (list): list of occupied orbitals to consider as active space
active_unoccupied (list): list of unoccupied orbitals to consider as active space
initial_state (InitialState): An initial state object.
qubit_mapping (str): qubit mapping type.
two_qubit_reduction (bool): two qubit reduction is applied or not.
num_time_slices (int): parameters for dynamics.
cliffords ([Operator]): list of unitary Clifford transformation
sq_list ([int]): position of the single-qubit operators that anticommute
with the cliffords
tapering_values ([int]): array of +/- 1 used to select the subspace. Length
has to be equal to the length of cliffords and sq_list
symmetries ([Pauli]): represent the Z2 symmetries
shallow_circuit_concat (bool): indicate whether to use shallow (cheap) mode for circuit concatenation
"""
self.validate(locals())
super().__init__()
self._cliffords = cliffords
self._sq_list = sq_list
self._tapering_values = tapering_values
self._symmetries = symmetries
if self._cliffords is not None and self._sq_list is not None and \
self._tapering_values is not None and self._symmetries is not None:
self._qubit_tapering = True
else:
self._qubit_tapering = False
self._num_qubits = num_orbitals if not two_qubit_reduction else num_orbitals - 2
self._num_qubits = self._num_qubits if not self._qubit_tapering else self._num_qubits - len(sq_list)
if self._num_qubits != num_qubits:
raise ValueError('Computed num qubits {} does not match actual {}'
.format(self._num_qubits, num_qubits))
self._depth = depth
self._num_orbitals = num_orbitals
self._num_particles = num_particles
if self._num_particles > self._num_orbitals:
raise ValueError('# of particles must be less than or equal to # of orbitals.')
self._initial_state = initial_state
self._qubit_mapping = qubit_mapping
self._two_qubit_reduction = two_qubit_reduction
self._num_time_slices = num_time_slices
self._shallow_circuit_concat = shallow_circuit_concat
self._single_excitations, self._double_excitations = \
UCCSD.compute_excitation_lists(num_particles, num_orbitals,
active_occupied, active_unoccupied)
self._single_excitations = []
print('{} are the old doubles'.format(self._double_excitations))
print(mp2_reduction)
if mp2_reduction:
print('Getting new doubles')
self._double_excitations = get_mp2_doubles(self._single_excitations,self._double_excitations)
print('{} are the new doubles'.format(self._double_excitations))
self._hopping_ops, self._num_parameters = self._build_hopping_operators()
self._bounds = [(-np.pi, np.pi) for _ in range(self._num_parameters)]
self._logging_construct_circuit = True
def _build_hopping_operators(self):
from .uccsd import UCCSD
hopping_ops = []
if logger.isEnabledFor(logging.DEBUG):
TextProgressBar(sys.stderr)
results = parallel_map(UCCSD._build_hopping_operator, self._single_excitations + self._double_excitations,
task_args=(self._num_orbitals, self._num_particles,
self._qubit_mapping, self._two_qubit_reduction, self._qubit_tapering,
self._symmetries, self._cliffords, self._sq_list, self._tapering_values),
num_processes=aqua_globals.num_processes)
hopping_ops = [qubit_op for qubit_op in results if qubit_op is not None]
num_parameters = len(hopping_ops) * self._depth
return hopping_ops, num_parameters
@staticmethod
def _build_hopping_operator(index, num_orbitals, num_particles, qubit_mapping,
two_qubit_reduction, qubit_tapering, symmetries,
cliffords, sq_list, tapering_values):
def check_commutativity(op_1, op_2):
com = op_1 * op_2 - op_2 * op_1
com.zeros_coeff_elimination()
return True if com.is_empty() else False
h1 = np.zeros((num_orbitals, num_orbitals))
h2 = np.zeros((num_orbitals, num_orbitals, num_orbitals, num_orbitals))
if len(index) == 2:
i, j = index
h1[i, j] = 1.0
h1[j, i] = -1.0
elif len(index) == 4:
i, j, k, m = index
h2[i, j, k, m] = 1.0
h2[m, k, j, i] = -1.0
dummpy_fer_op = FermionicOperator(h1=h1, h2=h2)
qubit_op = dummpy_fer_op.mapping(qubit_mapping)
qubit_op = qubit_op.two_qubit_reduced_operator(num_particles) \
if two_qubit_reduction else qubit_op
if qubit_tapering:
for symmetry in symmetries:
symmetry_op = Operator(paulis=[[1.0, symmetry]])
symm_commuting = check_commutativity(symmetry_op, qubit_op)
if not symm_commuting:
break
if qubit_tapering:
if symm_commuting:
qubit_op = Operator.qubit_tapering(qubit_op, cliffords,
sq_list, tapering_values)
else:
qubit_op = None
if qubit_op is None:
logger.debug('Excitation ({}) is skipped since it is not commuted '
'with symmetries'.format(','.join([str(x) for x in index])))
return qubit_op
def construct_circuit(self, parameters, q=None):
"""
Construct the variational form, given its parameters.
Args:
parameters (numpy.ndarray): circuit parameters
q (QuantumRegister): Quantum Register for the circuit.
Returns:
QuantumCircuit: a quantum circuit with given `parameters`
Raises:
ValueError: the number of parameters is incorrect.
"""
from .uccsd import UCCSD
if len(parameters) != self._num_parameters:
raise ValueError('The number of parameters has to be {}'.format(self._num_parameters))
if q is None:
q = QuantumRegister(self._num_qubits, name='q')
if self._initial_state is not None:
circuit = self._initial_state.construct_circuit('circuit', q)
else:
circuit = QuantumCircuit(q)
if logger.isEnabledFor(logging.DEBUG) and self._logging_construct_circuit:
logger.debug("Evolving hopping operators:")
TextProgressBar(sys.stderr)
self._logging_construct_circuit = False
num_excitations = len(self._hopping_ops)
results = parallel_map(UCCSD._construct_circuit_for_one_excited_operator,
[(self._hopping_ops[index % num_excitations], parameters[index])
for index in range(self._depth * num_excitations)],
task_args=(q, self._num_time_slices),
num_processes=aqua_globals.num_processes)
for qc in results:
if self._shallow_circuit_concat:
circuit.data += qc.data
else:
circuit += qc
return circuit
@staticmethod
def _construct_circuit_for_one_excited_operator(qubit_op_and_param, qr, num_time_slices):
qubit_op, param = qubit_op_and_param
qc = qubit_op.evolve(None, param * -1j, 'circuit', num_time_slices, qr)
return qc
@property
def preferred_init_points(self):
"""Getter of preferred initial points based on the given initial state."""
if self._initial_state is None:
return None
else:
bitstr = self._initial_state.bitstr
if bitstr is not None:
return np.zeros(self._num_parameters, dtype=np.float)
else:
return None
@staticmethod
def compute_excitation_lists(num_particles, num_orbitals, active_occ_list=None,
active_unocc_list=None, same_spin_doubles=True):
"""
Computes single and double excitation lists
Args:
num_particles: Total number of particles
num_orbitals: Total number of spin orbitals
active_occ_list: List of occupied orbitals to include, indices are
0 to n where n is num particles // 2
active_unocc_list: List of unoccupied orbitals to include, indices are
0 to m where m is (num_orbitals - num particles) // 2
same_spin_doubles: True to include alpha,alpha and beta,beta double excitations
as well as alpha,beta pairings. False includes only alpha,beta
Returns:
Single and double excitation lists
"""
if num_particles < 2 or num_particles % 2 != 0:
raise ValueError('Invalid number of particles {}'.format(num_particles))
if num_orbitals < 4 or num_orbitals % 2 != 0:
raise ValueError('Invalid number of orbitals {}'.format(num_orbitals))
if num_orbitals <= num_particles:
raise ValueError('No unoccupied orbitals')
if active_occ_list is not None:
active_occ_list = [i if i >= 0 else i + num_particles // 2 for i in active_occ_list]
for i in active_occ_list:
if i >= num_particles // 2:
raise ValueError('Invalid index {} in active active_occ_list {}'
.format(i, active_occ_list))
if active_unocc_list is not None:
active_unocc_list = [i + num_particles // 2 if i >=
0 else i + num_orbitals // 2 for i in active_unocc_list]
for i in active_unocc_list:
if i < 0 or i >= num_orbitals // 2:
raise ValueError('Invalid index {} in active active_unocc_list {}'
.format(i, active_unocc_list))
if active_occ_list is None or len(active_occ_list) <= 0:
active_occ_list = [i for i in range(0, num_particles // 2)]
if active_unocc_list is None or len(active_unocc_list) <= 0:
active_unocc_list = [i for i in range(num_particles // 2, num_orbitals // 2)]
single_excitations = []
double_excitations = []
logger.debug('active_occ_list {}'.format(active_occ_list))
logger.debug('active_unocc_list {}'.format(active_unocc_list))
beta_idx = num_orbitals // 2
for occ_alpha in active_occ_list:
for unocc_alpha in active_unocc_list:
single_excitations.append([occ_alpha, unocc_alpha])
for occ_beta in [i + beta_idx for i in active_occ_list]:
for unocc_beta in [i + beta_idx for i in active_unocc_list]:
single_excitations.append([occ_beta, unocc_beta])
for occ_alpha in active_occ_list:
for unocc_alpha in active_unocc_list:
for occ_beta in [i + beta_idx for i in active_occ_list]:
for unocc_beta in [i + beta_idx for i in active_unocc_list]:
double_excitations.append([occ_alpha, unocc_alpha, occ_beta, unocc_beta])
if same_spin_doubles and len(active_occ_list) > 1 and len(active_unocc_list) > 1:
for i, occ_alpha in enumerate(active_occ_list[:-1]):
for j, unocc_alpha in enumerate(active_unocc_list[:-1]):
for occ_alpha_1 in active_occ_list[i + 1:]:
for unocc_alpha_1 in active_unocc_list[j + 1:]:
double_excitations.append([occ_alpha, unocc_alpha,
occ_alpha_1, unocc_alpha_1])
up_active_occ_list = [i + beta_idx for i in active_occ_list]
up_active_unocc_list = [i + beta_idx for i in active_unocc_list]
for i, occ_beta in enumerate(up_active_occ_list[:-1]):
for j, unocc_beta in enumerate(up_active_unocc_list[:-1]):
for occ_beta_1 in up_active_occ_list[i + 1:]:
for unocc_beta_1 in up_active_unocc_list[j + 1:]:
double_excitations.append([occ_beta, unocc_beta,
occ_beta_1, unocc_beta_1])
logger.debug('single_excitations ({}) {}'.format(len(single_excitations), single_excitations))
logger.debug('double_excitations ({}) {}'.format(len(double_excitations), double_excitations))
return single_excitations, double_excitations
def get_mp2_doubles(single_excitations, double_excitations):
print('Is the class still populated with the correct info: ', qm.nuclear_repulsion_energy)
mp2 = MP2Info(qm, single_excitations, double_excitations, threshold=1e-3)
mp2_doubles = mp2._mp2_doubles
return mp2_doubles
|
https://github.com/asgunzi/QiskitCompReal
|
asgunzi
|
# -*- coding: utf-8 -*-
"""
Created on Tue Aug 19 12:24:57 2020
@author: asgunzi
"""
from qiskit import *
from qiskit.visualization import plot_histogram
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
#Cria um circuito quântico, composto de um qubit e um bit
circuit = QuantumCircuit(qr,cr)
circuit.h(0)
circuit.cx(0,1)
circuit.measure(qr,cr)
print(circuit)
#Vamos rodar num simulador de computador quântico. Qasm vem de “quantum assembly simulator”.
simulator = Aer.get_backend('qasm_simulator')
results = execute(circuit,simulator).result().get_counts()
plot_histogram(results)
# # #Vamos rodar num computador real
IBMQ.load_account() #È necessário ter uma conta no Qiskit da IBM
provider = IBMQ.get_provider(hub = 'ibm-q')
device = provider.get_backend('ibmqx2')
#Ou ibmq_16_melbourne, ibmqx2
job = execute(circuit,backend = device,shots = 1024)
print(job.job_id())
from qiskit.tools.monitor import job_monitor
job_monitor(job)
device_result = job.result()
plot_histogram(device_result.get_counts(circuit))
|
https://github.com/WhenTheyCry96/qiskitHackathon2022
|
WhenTheyCry96
|
%load_ext autoreload
%autoreload 2
import os
import warnings
import qiskit_metal as metal
from numpy import pi
from scipy.constants import c, h, pi, hbar, e, mu_0, epsilon_0
from qiskit_metal import Dict
from qiskit_metal.analyses.quantization.lumped_capacitive import load_q3d_capacitance_matrix
from qiskit_metal.analyses.quantization.lom_core_analysis import CompositeSystem, Cell, Subsystem, QuantumSystemRegistry
ws_path = os.getcwd()
warnings.filterwarnings("ignore")
#constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
#project parameters:
L_JJ = 10 # nH
C_JJ = 2 # fF
f_r = 8 # GHz
Z_r = 50 # Ohm
v_r = 0.404314 # relative velocity to c
#parameter extraction:
eps_eff = (1/v_r)**2 # effective eps_r
eps_r = 2*eps_eff-1 # approximation
I_JJ = varphi0/(L_JJ*1e-9)/1e-9 # nA
E_JJ = (varphi0)**2/(L_JJ*1e-9)/h/1e9 # GHz
#print
print(eps_r, I_JJ, E_JJ)
QuantumSystemRegistry.registry()
capfile = ws_path+"/Transmon_Readout_CapMatrix.txt"
t1_mat, _, _, _ = load_q3d_capacitance_matrix(capfile)
t1_mat
opt1 = dict(
cap_mat = t1_mat,
ind_dict = {('pad_top_Q1', 'pad_bot_Q1'): L_JJ}, # junction inductance in nH
jj_dict = {('pad_top_Q1', 'pad_bot_Q1'): 'j1'},
cj_dict = {('pad_top_Q1', 'pad_bot_Q1'): C_JJ}, # junction capacitance in fF
)
cell_1 = Cell(opt1)
transmon1 = Subsystem(name='transmon1', sys_type='TRANSMON', nodes=['j1'])
trans_read = Subsystem(name='readout1', sys_type='TL_RESONATOR', nodes=['readout_connector_pad_Q1'], q_opts=dict(f_res = f_r, Z0=Z_r, vp=v_r*c))
composite_sys = CompositeSystem(
subsystems=[transmon1, trans_read],
cells=[cell_1],
grd_node='ground_main_plane',
nodes_force_keep=['readout_connector_pad_Q1']
)
cg = composite_sys.circuitGraph()
print(cg)
hilbertspace = composite_sys.create_hilbertspace()
print(hilbertspace)
hilbertspace = composite_sys.add_interaction()
hilbertspace.hamiltonian()
hamiltonian_results = composite_sys.hamiltonian_results(hilbertspace, evals_count=30)
composite_sys.compute_gs()
|
https://github.com/WhenTheyCry96/qiskitHackathon2022
|
WhenTheyCry96
|
%load_ext autoreload
%autoreload 2
import os
import warnings
import qiskit_metal as metal
from numpy import pi
from scipy.constants import c, h, pi, hbar, e, mu_0, epsilon_0
from qiskit_metal import Dict
from qiskit_metal.analyses.quantization.lumped_capacitive import load_q3d_capacitance_matrix
from qiskit_metal.analyses.quantization.lom_core_analysis import CompositeSystem, Cell, Subsystem, QuantumSystemRegistry
ws_path = os.getcwd()
warnings.filterwarnings("ignore")
#constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
#project parameters:
L_JJ = 10 # nH
C_JJ = 2 # fF
f_r = 8 # GHz
Z_r = 50 # Ohm
v_r = 0.404314 # relative velocity to c
#parameter extraction:
eps_eff = (1/v_r)**2 # effective eps_r
eps_r = 2*eps_eff-1 # approximation
I_JJ = varphi0/(L_JJ*1e-9)/1e-9 # nA
E_JJ = (varphi0)**2/(L_JJ*1e-9)/h/1e9 # GHz
#print
print(eps_r, I_JJ, E_JJ)
QuantumSystemRegistry.registry()
capfile = ws_path+"/Transmon_Readout_CapMatrix.txt"
t1_mat, _, _, _ = load_q3d_capacitance_matrix(capfile)
t1_mat
opt1 = dict(
cap_mat = t1_mat,
ind_dict = {('pad_top_Q1', 'pad_bot_Q1'): L_JJ}, # junction inductance in nH
jj_dict = {('pad_top_Q1', 'pad_bot_Q1'): 'j1'},
cj_dict = {('pad_top_Q1', 'pad_bot_Q1'): C_JJ}, # junction capacitance in fF
)
cell_1 = Cell(opt1)
transmon1 = Subsystem(name='transmon1', sys_type='TRANSMON', nodes=['j1'])
trans_read = Subsystem(name='readout1', sys_type='TL_RESONATOR', nodes=['readout_connector_pad_Q1'], q_opts=dict(f_res = f_r, Z0=Z_r, vp=v_r*c))
composite_sys = CompositeSystem(
subsystems=[transmon1, trans_read],
cells=[cell_1],
grd_node='ground_main_plane',
nodes_force_keep=['readout_connector_pad_Q1']
)
cg = composite_sys.circuitGraph()
print(cg)
hilbertspace = composite_sys.create_hilbertspace()
print(hilbertspace)
hilbertspace = composite_sys.add_interaction()
hilbertspace.hamiltonian()
hamiltonian_results = composite_sys.hamiltonian_results(hilbertspace, evals_count=30)
composite_sys.compute_gs()
|
https://github.com/WhenTheyCry96/qiskitHackathon2022
|
WhenTheyCry96
|
import warnings
warnings.filterwarnings('ignore')
from qiskit_metal import designs, MetalGUI
design = designs.DesignPlanar()
design.overwrite_enabled = True
design.chips.main.size_x = '12mm'
design.chips.main.size_y = '10mm'
gui = MetalGUI(design)
from qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL
design.delete_all_components()
design_span_x = 5
design_span_y = 3
half_chip_width = design_span_x / 2
half_chip_height = design_span_y / 2
connection_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
b = dict(loc_W=1, loc_H=1),
c = dict(loc_W=-1, loc_H=-1)
)
connection23_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
c = dict(loc_W=-1, loc_H=-1)
)
transmons = []
transmons.append(TransmonPocketCL(design, 'Q1',
options=dict(pos_x=f'-{half_chip_width}mm',
pos_y=f'{-half_chip_height}mm',
connection_pads=dict(**connection_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q2',
options=dict(pos_x=f'0mm',
pos_y=f'{half_chip_height}mm',
orientation=-90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q3',
options=dict(pos_x=f'0mm',
pos_y=f'{-half_chip_height}mm',
orientation=90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q4',
options=dict(pos_x=f'{half_chip_width}mm',
pos_y=f'{half_chip_height}mm',
orientation=180,
connection_pads=dict(**connection_pads_options))))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.tlines.meandered import RouteMeander
from qiskit_metal import Dict
fillet='99.99um'
options = Dict(
meander=Dict(
lead_start='0.1mm',
lead_end='0.1mm',
asymmetry='0 um')
)
def connect(component_name: str, component1: str, pin1: str, component2: str, pin2: str,
length: str,
asymmetry='0 um', start_strght='0 um', end_strght='0 um', flip=False):
"""Connect two pins with a CPW."""
myoptions = Dict(
pin_inputs=Dict(
start_pin=Dict(
component=component1,
pin=pin1),
end_pin=Dict(
component=component2,
pin=pin2)),
lead=Dict(
start_straight=start_strght,
end_straight=end_strght
),
total_length=length,
fillet = '99.9um')
myoptions.update(options)
myoptions.meander.asymmetry = asymmetry
myoptions.meander.lead_direction_inverted = 'true' if flip else 'false'
return RouteMeander(design, component_name, myoptions)
asym_h = 100
asym_v = 100
cpw = []
cpw.append(connect('cpw1', 'Q1', 'b', 'Q2', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw3', 'Q4', 'b', 'Q3', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw4', 'Q3', 'd', 'Q1', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw5', 'Q2', 'd', 'Q4', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.terminations.launchpad_wb_coupled import LaunchpadWirebondCoupled
readouts_lwc = []
control_lwc = []
offset_x = 0
offset_y = 1
#Readouts
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R1',
options = dict(
pos_x = '-5mm',
pos_y = f'-{half_chip_height+offset_y}mm',
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R2',
options = dict(
pos_x = '-1mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R3',
options = dict(
pos_x = '1mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R4',
options = dict(
pos_x = '5mm',
pos_y = f'{half_chip_height+offset_y}mm',
orientation = 180,
lead_length = '30um')))
#Controls
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL1',
options = dict(
pos_x = '-5mm',
pos_y = '2mm',
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL2',
options = dict(
pos_x = '4mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL3',
options = dict(
pos_x = '-4mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL4',
options = dict(
pos_x = '5mm',
pos_y = '-2mm',
orientation = 180,
lead_length = '30um')))
gui.rebuild()
gui.autoscale()
readout_lines = []
asym_14 = 700
asym_23 = 700
options = Dict(
lead=Dict(
start_straight='330um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol1', 'Q1', 'c', 'R1', 'tie', '8 mm', f'{asym_14}um'))
options = Dict(
lead=Dict(
start_straight='430um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol2', 'Q2', 'c', 'R2', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol3', 'Q3', 'c', 'R3', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol4', 'Q4', 'c', 'R4', 'tie', '8 mm', f'{asym_14}um'))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.tlines.anchored_path import RouteAnchors
from collections import OrderedDict
import numpy as np
control_lines = []
def connectRouteAnchor(name: str,
component1: str, pin1: str, component2: str, pin2: str,
anchor_points: OrderedDict) -> RouteAnchors:
options_line_cl = dict(
pin_inputs = dict(start_pin = dict(component = component1, pin = pin1),
end_pin = dict(component = component2, pin = pin2)),
anchors = anchor_points,
lead = dict(start_straight = '200um',
end_straight = '225um'),
fillet = fillet
)
return RouteAnchors(design, name, options_line_cl)
anchors1c = OrderedDict()
anchors1c[0] = np.array([-4, -1.42])
anchors1c[1] = np.array([-4, 2])
control_lines.append(connectRouteAnchor('line_cl1', 'Q1', 'Charge_Line', 'CL1', 'tie', anchors1c))
anchors2c = OrderedDict()
anchors2c[0] = np.array([0.08, 3.25])
anchors2c[1] = np.array([4, 3.25])
control_lines.append(connectRouteAnchor('line_cl2', 'Q2', 'Charge_Line', 'CL2', 'tie', anchors2c))
anchors3c = OrderedDict()
anchors3c[0] = np.array([-0.08, -3.25])
anchors3c[1] = np.array([-4, -3.25])
control_lines.append(connectRouteAnchor('line_cl3', 'Q3', 'Charge_Line', 'CL3', 'tie', anchors3c))
anchors4c = OrderedDict()
anchors4c[0] = np.array([4, 1.42])
anchors4c[1] = np.array([4, -2])
control_lines.append(connectRouteAnchor('line_cl4', 'Q4', 'Charge_Line', 'CL4', 'tie', anchors4c))
gui.rebuild()
gui.autoscale()
gui.autoscale()
gui.screenshot(name="full_design")
import numpy as np
from scipy.constants import c, h, pi, hbar, e
from qiskit_metal.analyses.em.cpw_calculations import guided_wavelength
# constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
find_resonator_length(np.around(np.linspace(8, 9.2, 4), 2), 10, 6, 2)
transmons[0].options.pad_gap = '40um'
transmons[0].options.pad_width = '550um' # 405
transmons[0].options.pad_height = '120um'
transmons[1].options.pad_gap = '40um'
transmons[1].options.pad_width = '500um' # 405
transmons[1].options.pad_height = '120um'
transmons[2].options.pad_gap = '40um'
transmons[2].options.pad_width = '460um' # 405
transmons[2].options.pad_height = '120um'
transmons[3].options.pad_gap = '40um'
transmons[3].options.pad_width = '440um' # 405
transmons[3].options.pad_height = '120um'
readout_lines[0].options.total_length = '8.06mm'
readout_lines[1].options.total_length = '8.42mm'
readout_lines[2].options.total_length = '8.24mm'
readout_lines[3].options.total_length = '8.06mm'
cpw[0].options.total_length = '7.6mm'
cpw[1].options.total_length = '7.2mm'
cpw[2].options.total_length = '6.9mm'
cpw[3].options.total_length = '6.6mm'
gui.rebuild()
gui.autoscale()
qcomps = design.components # short handle (alias)
qcomps['Q1'].options['hfss_inductance'] = 'Lj1'
qcomps['Q1'].options['hfss_capacitance'] = 'Cj1'
qcomps['Q2'].options['hfss_inductance'] = 'Lj2'
qcomps['Q2'].options['hfss_capacitance'] = 'Cj2'
qcomps['Q3'].options['hfss_inductance'] = 'Lj3'
qcomps['Q3'].options['hfss_capacitance'] = 'Cj3'
qcomps['Q4'].options['hfss_inductance'] = 'Lj4'
qcomps['Q4'].options['hfss_capacitance'] = 'Cj4'
from qiskit_metal.analyses.quantization import EPRanalysis
eig_qb = EPRanalysis(design, "hfss")
eig_qb.sim.setup.n_modes = 2
eig_qb.sim.run(name="Qbit", components=['Q1', 'R1', 'ol1'], open_terminations=[('R1', ''), ('ol1', )], box_plus_buffer = True)
eig_qb.sim.plot_convergences()
eig_qb.setup.junctions.jj.rect = 'JJ_rect_Lj_Q1_rect_jj'
eig_qb.setup.junctions.jj.line = 'JJ_Lj_Q1_rect_jj_'
eig_qb.setup
eig_qb.run_epr()
transmons[1].options.pad_gap = '40um'
transmons[1].options.pad_width = '500um' # 405
transmons[1].options.pad_height = '120um'
gui.rebuild()
eig_qb = EPRanalysis(design, "hfss")
eig_qb.sim.setup.n_modes = 2
eig_qb.sim.run(name="Qbit2", components=['Q2'], open_terminations=[], box_plus_buffer = False)
eig_qb.sim.plot_convergences()
transmons[2].options.pad_gap = '40um'
transmons[2].options.pad_width = '460um' # 405
transmons[2].options.pad_height = '120um'
gui.rebuild()
eig_qb = EPRanalysis(design, "hfss")
eig_qb.sim.setup.n_modes = 2
eig_qb.sim.run(name="Qbit3", components=['Q3'], open_terminations=[], box_plus_buffer = False)
eig_qb.sim.plot_convergences()
transmons[3].options.pad_gap = '40um'
transmons[3].options.pad_width = '440um' # 405
transmons[3].options.pad_height = '120um'
gui.rebuild()
eig_qb = EPRanalysis(design, "hfss")
eig_qb.sim.setup.n_modes = 2
eig_qb.sim.run(name="Qbit4", components=['Q4'], open_terminations=[], box_plus_buffer = False)
eig_qb.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_rd = EPRanalysis(design, "hfss")
readout_lines[0].options.total_length = '11.7mm'
gui.rebuild()
eig_rd.sim.setup.n_modes = 2
eig_rd.sim.setup.max_passes = 10
eig_rd.sim.run(name="Readout",
components=['R1','ol1'])
eig_rd.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_rd = EPRanalysis(design, "hfss")
readout_lines[1].options.total_length = '11.2mm'
gui.rebuild()
eig_rd.sim.setup.n_modes = 2
eig_rd.sim.setup.max_passes = 10
eig_rd.sim.run(name="Readout",
components=['R2','ol2'])
eig_rd.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_rd = EPRanalysis(design, "hfss")
readout_lines[2].options.total_length = '10.6mm'
gui.rebuild()
eig_rd.sim.setup.n_modes = 2
eig_rd.sim.setup.max_passes = 10
eig_rd.sim.run(name="Readout",
components=['R3','ol3'])
eig_rd.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_rd = EPRanalysis(design, "hfss")
readout_lines[3].options.total_length = '10mm'
gui.rebuild()
eig_rd.sim.setup.n_modes = 2
eig_rd.sim.setup.max_passes = 10
eig_rd.sim.run(name="Readout",
components=['R4','ol4'])
eig_rd.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_c = EPRanalysis(design, "hfss")
cpw[0].options.total_length = '10mm'
gui.rebuild()
eig_c.sim.setup.n_modes = 2
eig_c.sim.setup.passes = 10
eig_c.sim.run(name="CPW1",
components=['cpw1'])
eig_c.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_c = EPRanalysis(design, "hfss")
cpw[1].options.total_length = '9.6mm'
gui.rebuild()
eig_c.sim.setup.n_modes = 2
eig_c.sim.setup.passes = 10
eig_c.sim.run(name="CPW2",
components=['cpw3'])
eig_c.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_c = EPRanalysis(design, "hfss")
cpw[2].options.total_length = '9.3mm'
gui.rebuild()
eig_c.sim.setup.n_modes = 2
eig_c.sim.setup.passes = 10
eig_c.sim.run(name="CPW4",
components=['cpw4'])
eig_c.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_c = EPRanalysis(design, "hfss")
cpw[3].options.total_length = '9mm'
gui.rebuild()
eig_c.sim.setup.n_modes = 2
eig_c.sim.setup.passes = 10
eig_c.sim.run(name="CPW5",
components=['cpw5'])
eig_c.sim.plot_convergences()
|
https://github.com/WhenTheyCry96/qiskitHackathon2022
|
WhenTheyCry96
|
import warnings
warnings.filterwarnings('ignore')
from qiskit_metal import designs, MetalGUI
design = designs.DesignPlanar()
design.overwrite_enabled = True
design.chips.main.size_x = '12mm'
design.chips.main.size_y = '10mm'
gui = MetalGUI(design)
from qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL
design.delete_all_components()
design_span_x = 5
design_span_y = 3
half_chip_width = design_span_x / 2
half_chip_height = design_span_y / 2
connection_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
b = dict(loc_W=1, loc_H=1),
c = dict(loc_W=-1, loc_H=-1)
)
connection23_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
c = dict(loc_W=-1, loc_H=-1)
)
transmons = []
transmons.append(TransmonPocketCL(design, 'Q1',
options=dict(pos_x=f'-{half_chip_width}mm',
pos_y=f'{-half_chip_height}mm',
connection_pads=dict(**connection_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q2',
options=dict(pos_x=f'0mm',
pos_y=f'{half_chip_height}mm',
orientation=-90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q3',
options=dict(pos_x=f'0mm',
pos_y=f'{-half_chip_height}mm',
orientation=90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q4',
options=dict(pos_x=f'{half_chip_width}mm',
pos_y=f'{half_chip_height}mm',
orientation=180,
connection_pads=dict(**connection_pads_options))))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.tlines.meandered import RouteMeander
from qiskit_metal import Dict
fillet='99.99um'
options = Dict(
meander=Dict(
lead_start='0.1mm',
lead_end='0.1mm',
asymmetry='0 um')
)
def connect(component_name: str, component1: str, pin1: str, component2: str, pin2: str,
length: str,
asymmetry='0 um', start_strght='0 um', end_strght='0 um', flip=False):
"""Connect two pins with a CPW."""
myoptions = Dict(
pin_inputs=Dict(
start_pin=Dict(
component=component1,
pin=pin1),
end_pin=Dict(
component=component2,
pin=pin2)),
lead=Dict(
start_straight=start_strght,
end_straight=end_strght
),
total_length=length,
fillet = '99.9um')
myoptions.update(options)
myoptions.meander.asymmetry = asymmetry
myoptions.meander.lead_direction_inverted = 'true' if flip else 'false'
return RouteMeander(design, component_name, myoptions)
asym_h = 100
asym_v = 100
cpw = []
cpw.append(connect('cpw1', 'Q1', 'b', 'Q2', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw3', 'Q4', 'b', 'Q3', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw4', 'Q3', 'd', 'Q1', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw5', 'Q2', 'd', 'Q4', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.terminations.launchpad_wb_coupled import LaunchpadWirebondCoupled
readouts_lwc = []
control_lwc = []
offset_x = 0
offset_y = 1
#Readouts
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R1',
options = dict(
pos_x = '-5mm',
pos_y = f'-{half_chip_height+offset_y}mm',
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R2',
options = dict(
pos_x = '-1mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R3',
options = dict(
pos_x = '1mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R4',
options = dict(
pos_x = '5mm',
pos_y = f'{half_chip_height+offset_y}mm',
orientation = 180,
lead_length = '30um')))
#Controls
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL1',
options = dict(
pos_x = '-5mm',
pos_y = '2mm',
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL2',
options = dict(
pos_x = '4mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL3',
options = dict(
pos_x = '-4mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL4',
options = dict(
pos_x = '5mm',
pos_y = '-2mm',
orientation = 180,
lead_length = '30um')))
gui.rebuild()
gui.autoscale()
readout_lines = []
asym_14 = 700
asym_23 = 700
options = Dict(
lead=Dict(
start_straight='330um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol1', 'Q1', 'c', 'R1', 'tie', '8 mm', f'{asym_14}um'))
options = Dict(
lead=Dict(
start_straight='430um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol2', 'Q2', 'c', 'R2', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol3', 'Q3', 'c', 'R3', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol4', 'Q4', 'c', 'R4', 'tie', '8 mm', f'{asym_14}um'))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.tlines.anchored_path import RouteAnchors
from collections import OrderedDict
import numpy as np
control_lines = []
def connectRouteAnchor(name: str,
component1: str, pin1: str, component2: str, pin2: str,
anchor_points: OrderedDict) -> RouteAnchors:
options_line_cl = dict(
pin_inputs = dict(start_pin = dict(component = component1, pin = pin1),
end_pin = dict(component = component2, pin = pin2)),
anchors = anchor_points,
lead = dict(start_straight = '200um',
end_straight = '225um'),
fillet = fillet
)
return RouteAnchors(design, name, options_line_cl)
anchors1c = OrderedDict()
anchors1c[0] = np.array([-4, -1.42])
anchors1c[1] = np.array([-4, 2])
control_lines.append(connectRouteAnchor('line_cl1', 'Q1', 'Charge_Line', 'CL1', 'tie', anchors1c))
anchors2c = OrderedDict()
anchors2c[0] = np.array([0.08, 3.25])
anchors2c[1] = np.array([4, 3.25])
control_lines.append(connectRouteAnchor('line_cl2', 'Q2', 'Charge_Line', 'CL2', 'tie', anchors2c))
anchors3c = OrderedDict()
anchors3c[0] = np.array([-0.08, -3.25])
anchors3c[1] = np.array([-4, -3.25])
control_lines.append(connectRouteAnchor('line_cl3', 'Q3', 'Charge_Line', 'CL3', 'tie', anchors3c))
anchors4c = OrderedDict()
anchors4c[0] = np.array([4, 1.42])
anchors4c[1] = np.array([4, -2])
control_lines.append(connectRouteAnchor('line_cl4', 'Q4', 'Charge_Line', 'CL4', 'tie', anchors4c))
gui.rebuild()
gui.autoscale()
gui.autoscale()
gui.screenshot(name="full_design")
import numpy as np
from scipy.constants import c, h, pi, hbar, e
from qiskit_metal.analyses.em.cpw_calculations import guided_wavelength
# constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
find_resonator_length(np.around(np.linspace(8, 9.2, 4), 2), 10, 6, 2)
transmons[0].options.pad_gap = '40um'
transmons[0].options.pad_width = '550um' # 405
transmons[0].options.pad_height = '120um'
transmons[1].options.pad_gap = '40um'
transmons[1].options.pad_width = '500um' # 405
transmons[1].options.pad_height = '120um'
transmons[2].options.pad_gap = '40um'
transmons[2].options.pad_width = '460um' # 405
transmons[2].options.pad_height = '120um'
transmons[3].options.pad_gap = '40um'
transmons[3].options.pad_width = '440um' # 405
transmons[3].options.pad_height = '120um'
readout_lines[0].options.total_length = '8.63mm'
readout_lines[1].options.total_length = '8.42mm'
readout_lines[2].options.total_length = '8.24mm'
readout_lines[3].options.total_length = '8.06mm'
cpw[0].options.total_length = '7.6mm'
cpw[1].options.total_length = '7.2mm'
cpw[2].options.total_length = '6.9mm'
cpw[3].options.total_length = '6.6mm'
gui.rebuild()
gui.autoscale()
qcomps = design.components # short handle (alias)
qcomps['Q1'].options['hfss_inductance'] = 'Lj1'
qcomps['Q1'].options['hfss_capacitance'] = 'Cj1'
qcomps['Q2'].options['hfss_inductance'] = 'Lj2'
qcomps['Q2'].options['hfss_capacitance'] = 'Cj2'
qcomps['Q3'].options['hfss_inductance'] = 'Lj3'
qcomps['Q3'].options['hfss_capacitance'] = 'Cj3'
qcomps['Q4'].options['hfss_inductance'] = 'Lj4'
qcomps['Q4'].options['hfss_capacitance'] = 'Cj4'
from qiskit_metal.analyses.quantization import EPRanalysis
eig_qb = EPRanalysis(design, "hfss")
eig_qb.sim.setup.n_modes = 12
eig_qb.sim.setup.max_passes = 12
eig_qb.sim.setup.vars = Dict(Lj1= '10 nH', Cj1= '2 fF',
Lj2= '10 nH', Cj2= '2 fF',
Lj3= '10 nH', Cj3= '2 fF',
Lj4= '10 nH', Cj4= '2 fF')
eig_qb.sim.run(name="4Qubits", components=[])
eig_qb.sim.plot_convergences()
del eig_qb.setup.junctions['jj']
eig_qb.setup.junctions.jj1 = Dict(rect='JJ_rect_Lj_Q1_rect_jj', line='JJ_Lj_Q1_rect_jj_',
Lj_variable='Lj1', Cj_variable='Cj1')
eig_qb.setup.junctions.jj2 = Dict(rect='JJ_rect_Lj_Q2_rect_jj', line='JJ_Lj_Q2_rect_jj_',
Lj_variable='Lj2', Cj_variable='Cj2')
eig_qb.setup.junctions.jj3 = Dict(rect='JJ_rect_Lj_Q3_rect_jj', line='JJ_Lj_Q3_rect_jj_',
Lj_variable='Lj3', Cj_variable='Cj3')
eig_qb.setup.junctions.jj4 = Dict(rect='JJ_rect_Lj_Q4_rect_jj', line='JJ_Lj_Q4_rect_jj_',
Lj_variable='Lj4', Cj_variable='Cj4')
eig_qb.setup.sweep_variable = 'Lj1'
eig_qb.setup
eig_qb.run_epr()
eig_qb.sim.plot_fields('main', eigenmode=8)
#eig_2qb.sim.save_screenshot("eigen1.png")
transmons[0].options.pad_gap = '40um'
transmons[0].options.pad_width = '550um' # 405
transmons[0].options.pad_height = '120um'
gui.rebuild()
eig_qb = EPRanalysis(design, "hfss")
eig_qb.sim.setup.n_modes = 2
eig_qb.sim.run(name="Qbit", components=['Q1'], open_terminations=[], box_plus_buffer = False)
eig_qb.sim.plot_convergences()
transmons[1].options.pad_gap = '40um'
transmons[1].options.pad_width = '500um' # 405
transmons[1].options.pad_height = '120um'
gui.rebuild()
eig_qb = EPRanalysis(design, "hfss")
eig_qb.sim.setup.n_modes = 2
eig_qb.sim.run(name="Qbit2", components=['Q2'], open_terminations=[], box_plus_buffer = False)
eig_qb.sim.plot_convergences()
transmons[2].options.pad_gap = '40um'
transmons[2].options.pad_width = '460um' # 405
transmons[2].options.pad_height = '120um'
gui.rebuild()
eig_qb = EPRanalysis(design, "hfss")
eig_qb.sim.setup.n_modes = 2
eig_qb.sim.run(name="Qbit3", components=['Q3'], open_terminations=[], box_plus_buffer = False)
eig_qb.sim.plot_convergences()
transmons[3].options.pad_gap = '40um'
transmons[3].options.pad_width = '440um' # 405
transmons[3].options.pad_height = '120um'
gui.rebuild()
eig_qb = EPRanalysis(design, "hfss")
eig_qb.sim.setup.n_modes = 2
eig_qb.sim.run(name="Qbit4", components=['Q4'], open_terminations=[], box_plus_buffer = False)
eig_qb.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_rd = EPRanalysis(design, "hfss")
readout_lines[0].options.total_length = '11.7mm'
gui.rebuild()
eig_rd.sim.setup.n_modes = 2
eig_rd.sim.setup.max_passes = 10
eig_rd.sim.run(name="Readout",
components=['R1','ol1'])
eig_rd.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_rd = EPRanalysis(design, "hfss")
readout_lines[1].options.total_length = '11.2mm'
gui.rebuild()
eig_rd.sim.setup.n_modes = 2
eig_rd.sim.setup.max_passes = 10
eig_rd.sim.run(name="Readout",
components=['R2','ol2'])
eig_rd.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_rd = EPRanalysis(design, "hfss")
readout_lines[2].options.total_length = '10.6mm'
gui.rebuild()
eig_rd.sim.setup.n_modes = 2
eig_rd.sim.setup.max_passes = 10
eig_rd.sim.run(name="Readout",
components=['R3','ol3'])
eig_rd.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_rd = EPRanalysis(design, "hfss")
readout_lines[3].options.total_length = '10mm'
gui.rebuild()
eig_rd.sim.setup.n_modes = 2
eig_rd.sim.setup.max_passes = 10
eig_rd.sim.run(name="Readout",
components=['R4','ol4'])
eig_rd.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_c = EPRanalysis(design, "hfss")
cpw[0].options.total_length = '10mm'
gui.rebuild()
eig_c.sim.setup.n_modes = 2
eig_c.sim.setup.passes = 10
eig_c.sim.run(name="CPW1",
components=['cpw1'])
eig_c.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_c = EPRanalysis(design, "hfss")
cpw[1].options.total_length = '9.6mm'
gui.rebuild()
eig_c.sim.setup.n_modes = 2
eig_c.sim.setup.passes = 10
eig_c.sim.run(name="CPW2",
components=['cpw3'])
eig_c.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_c = EPRanalysis(design, "hfss")
cpw[2].options.total_length = '9.3mm'
gui.rebuild()
eig_c.sim.setup.n_modes = 2
eig_c.sim.setup.passes = 10
eig_c.sim.run(name="CPW4",
components=['cpw4'])
eig_c.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_c = EPRanalysis(design, "hfss")
cpw[3].options.total_length = '9mm'
gui.rebuild()
eig_c.sim.setup.n_modes = 2
eig_c.sim.setup.passes = 10
eig_c.sim.run(name="CPW5",
components=['cpw5'])
eig_c.sim.plot_convergences()
|
https://github.com/WhenTheyCry96/qiskitHackathon2022
|
WhenTheyCry96
|
import warnings
warnings.filterwarnings('ignore')
from qiskit_metal import designs, MetalGUI
design = designs.DesignPlanar()
design.overwrite_enabled = True
design.chips.main.size_x = '12mm'
design.chips.main.size_y = '10mm'
gui = MetalGUI(design)
from qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL
design.delete_all_components()
design_span_x = 5
design_span_y = 3
half_chip_width = design_span_x / 2
half_chip_height = design_span_y / 2
connection_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
b = dict(loc_W=1, loc_H=1),
c = dict(loc_W=-1, loc_H=-1)
)
connection23_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
c = dict(loc_W=-1, loc_H=-1)
)
transmons = []
transmons.append(TransmonPocketCL(design, 'Q1',
options=dict(pos_x=f'-{half_chip_width}mm',
pos_y=f'{-half_chip_height}mm',
connection_pads=dict(**connection_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q2',
options=dict(pos_x=f'0mm',
pos_y=f'{half_chip_height}mm',
orientation=-90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q3',
options=dict(pos_x=f'0mm',
pos_y=f'{-half_chip_height}mm',
orientation=90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q4',
options=dict(pos_x=f'{half_chip_width}mm',
pos_y=f'{half_chip_height}mm',
orientation=180,
connection_pads=dict(**connection_pads_options))))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.tlines.meandered import RouteMeander
from qiskit_metal import Dict
fillet='99.99um'
options = Dict(
meander=Dict(
lead_start='0.1mm',
lead_end='0.1mm',
asymmetry='0 um')
)
def connect(component_name: str, component1: str, pin1: str, component2: str, pin2: str,
length: str,
asymmetry='0 um', start_strght='0 um', end_strght='0 um', flip=False):
"""Connect two pins with a CPW."""
myoptions = Dict(
pin_inputs=Dict(
start_pin=Dict(
component=component1,
pin=pin1),
end_pin=Dict(
component=component2,
pin=pin2)),
lead=Dict(
start_straight=start_strght,
end_straight=end_strght
),
total_length=length,
fillet = '99.9um')
myoptions.update(options)
myoptions.meander.asymmetry = asymmetry
myoptions.meander.lead_direction_inverted = 'true' if flip else 'false'
return RouteMeander(design, component_name, myoptions)
asym_h = 100
asym_v = 100
cpw = []
cpw.append(connect('cpw1', 'Q1', 'b', 'Q2', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw3', 'Q4', 'b', 'Q3', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw4', 'Q3', 'd', 'Q1', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw5', 'Q2', 'd', 'Q4', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.terminations.launchpad_wb_coupled import LaunchpadWirebondCoupled
readouts_lwc = []
control_lwc = []
offset_x = 0
offset_y = 1
#Readouts
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R1',
options = dict(
pos_x = '-5mm',
pos_y = f'-{half_chip_height+offset_y}mm',
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R2',
options = dict(
pos_x = '-1mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R3',
options = dict(
pos_x = '1mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R4',
options = dict(
pos_x = '5mm',
pos_y = f'{half_chip_height+offset_y}mm',
orientation = 180,
lead_length = '30um')))
#Controls
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL1',
options = dict(
pos_x = '-5mm',
pos_y = '2mm',
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL2',
options = dict(
pos_x = '4mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL3',
options = dict(
pos_x = '-4mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL4',
options = dict(
pos_x = '5mm',
pos_y = '-2mm',
orientation = 180,
lead_length = '30um')))
gui.rebuild()
gui.autoscale()
readout_lines = []
asym_14 = 700
asym_23 = 700
options = Dict(
lead=Dict(
start_straight='330um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol1', 'Q1', 'c', 'R1', 'tie', '8 mm', f'{asym_14}um'))
options = Dict(
lead=Dict(
start_straight='430um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol2', 'Q2', 'c', 'R2', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol3', 'Q3', 'c', 'R3', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol4', 'Q4', 'c', 'R4', 'tie', '8 mm', f'{asym_14}um'))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.tlines.anchored_path import RouteAnchors
from collections import OrderedDict
import numpy as np
control_lines = []
def connectRouteAnchor(name: str,
component1: str, pin1: str, component2: str, pin2: str,
anchor_points: OrderedDict) -> RouteAnchors:
options_line_cl = dict(
pin_inputs = dict(start_pin = dict(component = component1, pin = pin1),
end_pin = dict(component = component2, pin = pin2)),
anchors = anchor_points,
lead = dict(start_straight = '200um',
end_straight = '225um'),
fillet = fillet
)
return RouteAnchors(design, name, options_line_cl)
anchors1c = OrderedDict()
anchors1c[0] = np.array([-4, -1.42])
anchors1c[1] = np.array([-4, 2])
control_lines.append(connectRouteAnchor('line_cl1', 'Q1', 'Charge_Line', 'CL1', 'tie', anchors1c))
anchors2c = OrderedDict()
anchors2c[0] = np.array([0.08, 3.25])
anchors2c[1] = np.array([4, 3.25])
control_lines.append(connectRouteAnchor('line_cl2', 'Q2', 'Charge_Line', 'CL2', 'tie', anchors2c))
anchors3c = OrderedDict()
anchors3c[0] = np.array([-0.08, -3.25])
anchors3c[1] = np.array([-4, -3.25])
control_lines.append(connectRouteAnchor('line_cl3', 'Q3', 'Charge_Line', 'CL3', 'tie', anchors3c))
anchors4c = OrderedDict()
anchors4c[0] = np.array([4, 1.42])
anchors4c[1] = np.array([4, -2])
control_lines.append(connectRouteAnchor('line_cl4', 'Q4', 'Charge_Line', 'CL4', 'tie', anchors4c))
gui.rebuild()
gui.autoscale()
gui.autoscale()
gui.screenshot(name="full_design")
import numpy as np
from scipy.constants import c, h, pi, hbar, e
from qiskit_metal.analyses.em.cpw_calculations import guided_wavelength
# constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
find_resonator_length(np.around(np.linspace(8, 9.2, 4), 2), 10, 6, 2)
transmons[0].options.pad_gap = '40um'
transmons[0].options.pad_width = '550um' # 405
transmons[0].options.pad_height = '120um'
transmons[1].options.pad_gap = '40um'
transmons[1].options.pad_width = '500um' # 405
transmons[1].options.pad_height = '120um'
transmons[2].options.pad_gap = '40um'
transmons[2].options.pad_width = '460um' # 405
transmons[2].options.pad_height = '120um'
transmons[3].options.pad_gap = '40um'
transmons[3].options.pad_width = '440um' # 405
transmons[3].options.pad_height = '120um'
readout_lines[0].options.total_length = '8.63mm'
readout_lines[1].options.total_length = '8.42mm'
readout_lines[2].options.total_length = '8.24mm'
readout_lines[3].options.total_length = '8.06mm'
cpw[0].options.total_length = '7.6mm'
cpw[1].options.total_length = '7.2mm'
cpw[2].options.total_length = '6.9mm'
cpw[3].options.total_length = '6.6mm'
gui.rebuild()
gui.autoscale()
qcomps = design.components # short handle (alias)
qcomps['Q1'].options['hfss_inductance'] = 'Lj1'
qcomps['Q1'].options['hfss_capacitance'] = 'Cj1'
qcomps['Q2'].options['hfss_inductance'] = 'Lj2'
qcomps['Q2'].options['hfss_capacitance'] = 'Cj2'
qcomps['Q3'].options['hfss_inductance'] = 'Lj3'
qcomps['Q3'].options['hfss_capacitance'] = 'Cj3'
qcomps['Q4'].options['hfss_inductance'] = 'Lj4'
qcomps['Q4'].options['hfss_capacitance'] = 'Cj4'
from qiskit_metal.analyses.quantization import EPRanalysis, LOManalysis
c1 = LOManalysis(design, "q3d")
q3d1 = c1.sim.renderer
q3d1.start()
q3d1.activate_ansys_design("full_circuit", 'capacitive')
q3d1.render_design([], [])
q3d1.add_q3d_setup(name="Setup", max_passes=15, min_converged_passes=5,percent_error=0.05)
q3d1.analyze_setup("Setup")
c1.sim.capacitance_matrix, c1.sim.units = q3d1.get_capacitance_matrix()
c1.sim.capacitance_all_passes, _ = q3d1.get_capacitance_all_passes()
c1.sim.capacitance_matrix
Out[17].to_csv("full_original_design_C.txt")
c1 = LOManalysis(design, "q3d")
q3d1 = c1.sim.renderer
q3d1.start()
q3d1.activate_ansys_design("Q1only_busopen", 'capacitive')
q3d1.render_design(['Q1', 'R1', 'cpw1', 'cpw4', 'ol1', 'line_cl1', 'CL1'], [('cpw1', 'end'),('cpw4', 'start')])
q3d1.add_q3d_setup(name="Setup", max_passes=15, min_converged_passes=5,percent_error=0.05)
q3d1.analyze_setup("Setup")
c1.sim.capacitance_matrix, c1.sim.units = q3d1.get_capacitance_matrix()
c1.sim.capacitance_all_passes, _ = q3d1.get_capacitance_all_passes()
c1.sim.capacitance_matrix
|
https://github.com/WhenTheyCry96/qiskitHackathon2022
|
WhenTheyCry96
|
import warnings
warnings.filterwarnings('ignore')
from qiskit_metal import designs, MetalGUI
design = designs.DesignPlanar()
design.overwrite_enabled = True
design.chips.main.size_x = '12mm'
design.chips.main.size_y = '10mm'
gui = MetalGUI(design)
from qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL
design.delete_all_components()
design_span_x = 5
design_span_y = 3
half_chip_width = design_span_x / 2
half_chip_height = design_span_y / 2
connection_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
b = dict(loc_W=1, loc_H=1),
c = dict(loc_W=-1, loc_H=-1)
)
connection23_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
c = dict(loc_W=-1, loc_H=-1)
)
transmons = []
transmons.append(TransmonPocketCL(design, 'Q1',
options=dict(pos_x=f'-{half_chip_width}mm',
pos_y=f'{-half_chip_height}mm',
connection_pads=dict(**connection_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q2',
options=dict(pos_x=f'0mm',
pos_y=f'{half_chip_height}mm',
orientation=-90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q3',
options=dict(pos_x=f'0mm',
pos_y=f'{-half_chip_height}mm',
orientation=90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q4',
options=dict(pos_x=f'{half_chip_width}mm',
pos_y=f'{half_chip_height}mm',
orientation=180,
connection_pads=dict(**connection_pads_options))))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.tlines.meandered import RouteMeander
from qiskit_metal import Dict
fillet='99.99um'
options = Dict(
meander=Dict(
lead_start='0.1mm',
lead_end='0.1mm',
asymmetry='0 um')
)
def connect(component_name: str, component1: str, pin1: str, component2: str, pin2: str,
length: str,
asymmetry='0 um', start_strght='0 um', end_strght='0 um', flip=False):
"""Connect two pins with a CPW."""
myoptions = Dict(
pin_inputs=Dict(
start_pin=Dict(
component=component1,
pin=pin1),
end_pin=Dict(
component=component2,
pin=pin2)),
lead=Dict(
start_straight=start_strght,
end_straight=end_strght
),
total_length=length,
fillet = '99.9um')
myoptions.update(options)
myoptions.meander.asymmetry = asymmetry
myoptions.meander.lead_direction_inverted = 'true' if flip else 'false'
return RouteMeander(design, component_name, myoptions)
asym_h = 100
asym_v = 100
cpw = []
cpw.append(connect('cpw1', 'Q1', 'b', 'Q2', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw3', 'Q4', 'b', 'Q3', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw4', 'Q3', 'd', 'Q1', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw5', 'Q2', 'd', 'Q4', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.terminations.launchpad_wb_coupled import LaunchpadWirebondCoupled
readouts_lwc = []
control_lwc = []
offset_x = 0
offset_y = 1
#Readouts
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R1',
options = dict(
pos_x = '-5mm',
pos_y = f'-{half_chip_height+offset_y}mm',
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R2',
options = dict(
pos_x = '-1mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R3',
options = dict(
pos_x = '1mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R4',
options = dict(
pos_x = '5mm',
pos_y = f'{half_chip_height+offset_y}mm',
orientation = 180,
lead_length = '30um')))
#Controls
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL1',
options = dict(
pos_x = '-5mm',
pos_y = '2mm',
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL2',
options = dict(
pos_x = '4mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL3',
options = dict(
pos_x = '-4mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL4',
options = dict(
pos_x = '5mm',
pos_y = '-2mm',
orientation = 180,
lead_length = '30um')))
gui.rebuild()
gui.autoscale()
readout_lines = []
asym_14 = 700
asym_23 = 700
options = Dict(
lead=Dict(
start_straight='330um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol1', 'Q1', 'c', 'R1', 'tie', '8 mm', f'{asym_14}um'))
options = Dict(
lead=Dict(
start_straight='430um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol2', 'Q2', 'c', 'R2', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol3', 'Q3', 'c', 'R3', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol4', 'Q4', 'c', 'R4', 'tie', '8 mm', f'{asym_14}um'))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.tlines.anchored_path import RouteAnchors
from collections import OrderedDict
import numpy as np
control_lines = []
def connectRouteAnchor(name: str,
component1: str, pin1: str, component2: str, pin2: str,
anchor_points: OrderedDict) -> RouteAnchors:
options_line_cl = dict(
pin_inputs = dict(start_pin = dict(component = component1, pin = pin1),
end_pin = dict(component = component2, pin = pin2)),
anchors = anchor_points,
lead = dict(start_straight = '200um',
end_straight = '225um'),
fillet = fillet
)
return RouteAnchors(design, name, options_line_cl)
anchors1c = OrderedDict()
anchors1c[0] = np.array([-4, -1.42])
anchors1c[1] = np.array([-4, 2])
control_lines.append(connectRouteAnchor('line_cl1', 'Q1', 'Charge_Line', 'CL1', 'tie', anchors1c))
anchors2c = OrderedDict()
anchors2c[0] = np.array([0.08, 3.25])
anchors2c[1] = np.array([4, 3.25])
control_lines.append(connectRouteAnchor('line_cl2', 'Q2', 'Charge_Line', 'CL2', 'tie', anchors2c))
anchors3c = OrderedDict()
anchors3c[0] = np.array([-0.08, -3.25])
anchors3c[1] = np.array([-4, -3.25])
control_lines.append(connectRouteAnchor('line_cl3', 'Q3', 'Charge_Line', 'CL3', 'tie', anchors3c))
anchors4c = OrderedDict()
anchors4c[0] = np.array([4, 1.42])
anchors4c[1] = np.array([4, -2])
control_lines.append(connectRouteAnchor('line_cl4', 'Q4', 'Charge_Line', 'CL4', 'tie', anchors4c))
gui.rebuild()
gui.autoscale()
gui.autoscale()
gui.screenshot(name="full_design")
import numpy as np
from scipy.constants import c, h, pi, hbar, e
from qiskit_metal.analyses.em.cpw_calculations import guided_wavelength
# constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
find_resonator_length(np.around(np.linspace(8, 9.2, 4), 2), 10, 6, 2)
transmons[0].options.pad_gap = '40um'
transmons[0].options.pad_width = '550um' # 405
transmons[0].options.pad_height = '120um'
transmons[1].options.pad_gap = '40um'
transmons[1].options.pad_width = '540um' # 405
transmons[1].options.pad_height = '120um'
transmons[2].options.pad_gap = '40um'
transmons[2].options.pad_width = '530um' # 405
transmons[2].options.pad_height = '120um'
transmons[3].options.pad_gap = '40um'
transmons[3].options.pad_width = '520um' # 405
transmons[3].options.pad_height = '120um'
readout_lines[0].options.total_length = '8.63mm'
readout_lines[1].options.total_length = '8.42mm'
readout_lines[2].options.total_length = '8.24mm'
readout_lines[3].options.total_length = '8.06mm'
cpw[0].options.total_length = '7.6mm'
cpw[1].options.total_length = '7.2mm'
cpw[2].options.total_length = '6.9mm'
cpw[3].options.total_length = '6.6mm'
gui.rebuild()
gui.autoscale()
qcomps = design.components # short handle (alias)
qcomps['Q1'].options['hfss_inductance'] = 'Lj1'
qcomps['Q1'].options['hfss_capacitance'] = 'Cj1'
qcomps['Q2'].options['hfss_inductance'] = 'Lj2'
qcomps['Q2'].options['hfss_capacitance'] = 'Cj2'
qcomps['Q3'].options['hfss_inductance'] = 'Lj3'
qcomps['Q3'].options['hfss_capacitance'] = 'Cj3'
qcomps['Q4'].options['hfss_inductance'] = 'Lj4'
qcomps['Q4'].options['hfss_capacitance'] = 'Cj4'
from qiskit_metal.analyses.quantization import EPRanalysis, LOManalysis
c1 = LOManalysis(design, "q3d")
q3d1 = c1.sim.renderer
q3d1.start()
q3d1.activate_ansys_design("qubit_pad_w_550_520", 'capacitive')
q3d1.render_design([], [])
q3d1.add_q3d_setup(name="Setup", max_passes=15, min_converged_passes=5,percent_error=0.05)
q3d1.analyze_setup("Setup")
c1.sim.capacitance_matrix, c1.sim.units = q3d1.get_capacitance_matrix()
c1.sim.capacitance_all_passes, _ = q3d1.get_capacitance_all_passes()
c1.sim.capacitance_matrix
Out[14].to_csv("full_pad_width550_520_C.txt")
|
https://github.com/WhenTheyCry96/qiskitHackathon2022
|
WhenTheyCry96
|
%load_ext autoreload
%autoreload 2
import os
import warnings
import numpy as np
import pyEPR as epr
import qiskit_metal as metal
from collections import OrderedDict
import scqubits as scq
from scipy.constants import c, h, pi, hbar, e
from qiskit_metal import designs, draw, MetalGUI, Dict, Headings
from qiskit_metal.qlibrary.tlines.meandered import RouteMeander
from qiskit_metal.qlibrary.tlines.anchored_path import RouteAnchors
from qiskit_metal.analyses.quantization import LOManalysis, EPRanalysis
from qiskit_metal.analyses.em.cpw_calculations import guided_wavelength
from qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL
from qiskit_metal.qlibrary.lumped.cap_3_interdigital import Cap3Interdigital
from qiskit_metal.qlibrary.terminations.launchpad_wb_coupled import LaunchpadWirebondCoupled
from qiskit_metal.analyses.quantization.lumped_capacitive import load_q3d_capacitance_matrix
from qiskit_metal.analyses.quantization.lom_core_analysis import CompositeSystem, Cell, Subsystem, QuantumSystemRegistry
ws_path = os.getcwd()
warnings.filterwarnings("ignore")
design = designs.DesignPlanar()
design.overwrite_enabled = True
#constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
design.chips.main.size_x = '12mm'
design.chips.main.size_y = '10mm'
gui = MetalGUI(design)
design.delete_all_components()
design_span_x = 5
design_span_y = 3
half_chip_width = design_span_x / 2
half_chip_height = design_span_y / 2
connection_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
b = dict(loc_W=1, loc_H=1),
c = dict(loc_W=-1, loc_H=-1)
)
connection23_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
c = dict(loc_W=-1, loc_H=-1)
)
transmons = []
transmons.append(TransmonPocketCL(design, 'Q1',
options=dict(pos_x=f'-{half_chip_width}mm',
pos_y=f'{-half_chip_height}mm',
connection_pads=dict(**connection_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q2',
options=dict(pos_x=f'0mm',
pos_y=f'{half_chip_height}mm',
orientation=-90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q3',
options=dict(pos_x=f'0mm',
pos_y=f'{-half_chip_height}mm',
orientation=90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q4',
options=dict(pos_x=f'{half_chip_width}mm',
pos_y=f'{half_chip_height}mm',
orientation=180,
connection_pads=dict(**connection_pads_options))))
gui.rebuild()
gui.autoscale()
fillet='99.99um'
options = Dict(
meander=Dict(
lead_start='0.1mm',
lead_end='0.1mm',
asymmetry='0 um')
)
def connect(component_name: str, component1: str, pin1: str, component2: str, pin2: str,
length: str,
asymmetry='0 um', start_strght='0 um', end_strght='0 um', flip=False):
"""Connect two pins with a CPW."""
myoptions = Dict(
pin_inputs=Dict(
start_pin=Dict(
component=component1,
pin=pin1),
end_pin=Dict(
component=component2,
pin=pin2)),
lead=Dict(
start_straight=start_strght,
end_straight=end_strght
),
total_length=length,
fillet = '99.9um')
myoptions.update(options)
myoptions.meander.asymmetry = asymmetry
myoptions.meander.lead_direction_inverted = 'true' if flip else 'false'
return RouteMeander(design, component_name, myoptions)
asym_h = 100
asym_v = 100
cpw = []
cpw.append(connect('cpw1', 'Q1', 'b', 'Q2', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw3', 'Q4', 'b', 'Q3', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw4', 'Q3', 'd', 'Q1', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw5', 'Q2', 'd', 'Q4', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
gui.rebuild()
gui.autoscale()
readouts_lwc = []
control_lwc = []
offset_x = 0
offset_y = 1
#Readouts
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R1',
options = dict(
pos_x = '-5mm',
pos_y = f'-{half_chip_height+offset_y}mm',
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R2',
options = dict(
pos_x = '-1mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R3',
options = dict(
pos_x = '1mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R4',
options = dict(
pos_x = '5mm',
pos_y = f'{half_chip_height+offset_y}mm',
orientation = 180,
lead_length = '30um')))
#Controls
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL1',
options = dict(
pos_x = '-5mm',
pos_y = '2mm',
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL2',
options = dict(
pos_x = '4mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL3',
options = dict(
pos_x = '-4mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL4',
options = dict(
pos_x = '5mm',
pos_y = '-2mm',
orientation = 180,
lead_length = '30um')))
gui.rebuild()
gui.autoscale()
readout_lines = []
asym_14 = 700
asym_23 = 700
options = Dict(
lead=Dict(
start_straight='330um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol1', 'Q1', 'c', 'R1', 'tie', '8 mm', f'{asym_14}um'))
options = Dict(
lead=Dict(
start_straight='430um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol2', 'Q2', 'c', 'R2', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol3', 'Q3', 'c', 'R3', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol4', 'Q4', 'c', 'R4', 'tie', '8 mm', f'{asym_14}um'))
gui.rebuild()
gui.autoscale()
control_lines = []
def connectRouteAnchor(name: str,
component1: str, pin1: str, component2: str, pin2: str,
anchor_points: OrderedDict) -> RouteAnchors:
options_line_cl = dict(
pin_inputs = dict(start_pin = dict(component = component1, pin = pin1),
end_pin = dict(component = component2, pin = pin2)),
anchors = anchor_points,
lead = dict(start_straight = '200um',
end_straight = '225um'),
fillet = fillet
)
return RouteAnchors(design, name, options_line_cl)
anchors1c = OrderedDict()
anchors1c[0] = np.array([-4, -1.42])
anchors1c[1] = np.array([-4, 2])
control_lines.append(connectRouteAnchor('line_cl1', 'Q1', 'Charge_Line', 'CL1', 'tie', anchors1c))
anchors2c = OrderedDict()
anchors2c[0] = np.array([0.08, 3.25])
anchors2c[1] = np.array([4, 3.25])
control_lines.append(connectRouteAnchor('line_cl2', 'Q2', 'Charge_Line', 'CL2', 'tie', anchors2c))
anchors3c = OrderedDict()
anchors3c[0] = np.array([-0.08, -3.25])
anchors3c[1] = np.array([-4, -3.25])
control_lines.append(connectRouteAnchor('line_cl3', 'Q3', 'Charge_Line', 'CL3', 'tie', anchors3c))
anchors4c = OrderedDict()
anchors4c[0] = np.array([4, 1.42])
anchors4c[1] = np.array([4, -2])
control_lines.append(connectRouteAnchor('line_cl4', 'Q4', 'Charge_Line', 'CL4', 'tie', anchors4c))
gui.rebuild()
gui.autoscale()
gui.screenshot(name="full_design.png")
# constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
# CPW busline length is determined to be 7 mm
cpw[0].options.total_length = '7.0mm'
cpw[1].options.total_length = '7.0mm'
cpw[2].options.total_length = '7.0mm'
cpw[3].options.total_length = '7.0mm'
gui.rebuild()
gui.autoscale()
# qubit 1 design target f: 5.25 GHz
# readout resonator target f: 7.05 GHz
# qubit 2 design target f: 5.42 GHz
# readout resonator target f: 7.22 GHz
# qubit 3 design target f: 5.58 GHz
# readout resonator target f: 7.38 GHz
# qubit 4 design target f: 5.75 GHz
# readout resonator target f: 7.55 GHz
# tuning parameters
C_JJ4f = 2
L_JJ4f = 11.7
C_JJ4 = str(C_JJ4f)+' fF'
L_JJ4 = str(L_JJ4f)+' nH'
transmons[3].options.pad_gap = '35um'
transmons[3].options.pad_width = '500um'
transmons[3].options.pad_height = '125um'
transmons[3].options.connection_pads.c.pad_gap = '40um'
transmons[3].options.connection_pads.a.pad_gap = '60um' # cpw5
transmons[3].options.connection_pads.a.pad_width = '40um' # cpw5
transmons[3].options.connection_pads.b.pad_gap = '60um' # cpw3
transmons[3].options.connection_pads.b.pad_width = '30um' # cpw3
readout_lines[3].options.total_length = '7.5mm'
gui.rebuild()
gui.autoscale()
# EPR analysis
eig_q4 = EPRanalysis(design, "hfss")
hfss4 = eig_q4.sim.renderer
hfss4.start()
hfss4.activate_ansys_design("TransmonQ4", 'eigenmode')
hfss4.render_design(['Q4', 'ol4', 'cpw3', 'cpw5'], [('cpw3', 'end'), ('cpw5', 'start'), ('ol4', 'end')])
# Analysis properties
setup4 = hfss4.pinfo.setup
setup4.n_modes = 6
setup4.passes = 10
setup4.min_freq_ghz = 4
print(f"""
Number of eigenmodes to find = {setup4.n_modes}
Number of simulation passes = {setup4.passes}
Convergence freq max delta percent diff = {setup4.delta_f}
""")
pinfo4 = hfss4.pinfo
pinfo4.design.set_variable('Lj4', L_JJ4)
pinfo4.design.set_variable('Cj4', C_JJ4)
setup4.analyze()
eig_q4.sim.convergence_t, eig_q4.sim.convergence_f, _ = hfss4.get_convergences()
eig_q4.sim.plot_convergences()
pinfo4.junctions['jj'] = {'Lj_variable': 'Lj4', 'rect': 'JJ_rect_Lj_Q4_rect_jj',
'line': 'JJ_Lj_Q4_rect_jj_', 'Cj_variable': 'Cj4'}
pinfo4.validate_junction_info()
pinfo4.dissipative['dielectrics_bulk'] = ['main']
hfss4.set_mode(1, "Setup")
hfss4.modeler._modeler.ShowWindow()
hfss4.plot_fields('main')
eprd4 = epr.DistributedAnalysis(pinfo4)
ℰ_elec = eprd4.calc_energy_electric()
ℰ_elec_substrate = eprd4.calc_energy_electric(None, 'main')
ℰ_mag = eprd4.calc_energy_magnetic()
print(f"""
ℰ_elec_all = {ℰ_elec}
ℰ_elec_substrate = {ℰ_elec_substrate}
EPR of substrate = {ℰ_elec_substrate / ℰ_elec * 100 :.1f}%
ℰ_mag_all = {ℰ_mag}
ℰ_mag % of ℰ_elec_all = {ℰ_mag / ℰ_elec * 100 :.1f}%
""")
eprd4.do_EPR_analysis()
#epra4 = epr.QuantumAnalysis(eprd4.data_filename)
#epra4.analyze_all_variations(cos_trunc = 8, fock_trunc = 7)
c4 = LOManalysis(design, "q3d")
q3d4 = c4.sim.renderer
q3d4.start()
q3d4.activate_ansys_design("TransmonQ4_q3d", 'capacitive')
q3d4.render_design(['Q4'], [('Q4', 'a'),('Q4', 'b'),('Q4', 'c')])
q3d4.add_q3d_setup(name="Setup", max_passes=15, min_converged_passes=5, percent_error=0.1)
q3d4.analyze_setup("Setup")
c4.sim.capacitance_matrix, c4.sim.units = q3d4.get_capacitance_matrix()
c4.sim.capacitance_all_passes, _ = q3d4.get_capacitance_all_passes()
c4.sim.capacitance_matrix
c4.setup.junctions = Dict({'Lj':L_JJ4f, 'Cj':C_JJ4f})
c4.setup.freq_readout = 7.45
c4.setup.freq_bus = [8.25, 8.25, 15]
c4.run_lom()
c4.lumped_oscillator_all
QuantumSystemRegistry.registry()
# Q4
path4= ws_path+"/Project71_TransmonQ4_q3d.txt"
t4_mat, _, _, _ = load_q3d_capacitance_matrix(path4)
# Cell 4 Transmon-4
opt4 = dict(
node_rename = {'a_connector_pad_Q4': 'cpw5',
'b_connector_pad_Q4': 'cpw3',
'c_connector_pad_Q4': 'readout4'},
cap_mat = t4_mat,
ind_dict = {('pad_top_Q4', 'pad_bot_Q4'): 11.7}, # junction inductance in nH
jj_dict = {('pad_top_Q4', 'pad_bot_Q4'): 'j4'},
cj_dict = {('pad_top_Q4', 'pad_bot_Q4'): 2} # junction capacitance in fF
)
cell_4 = Cell(opt4)
# subsystem 1: Transmon-4
transmon4 = Subsystem(name='transmon4', sys_type='TRANSMON', nodes=['j4'])
# Resonator Subsystems
q_opts = dict(
Z0 = 50, # characteristic impedance in Ohm
vp = 0.404314 * 3e8 # phase velocity
)
# subsystem 3: Q2 readout resonator
ro4 = Subsystem(name='readout4', sys_type='TL_RESONATOR', nodes=['readout4'], q_opts=dict(f_res = 7.57, **q_opts))
# subsystem 4: bus3 resonator
cpw3 = Subsystem(name='cpw3', sys_type='TL_RESONATOR', nodes=['cpw3'], q_opts=dict(f_res = 8.2, **q_opts))
# subsystem 15: bus5 resonator
cpw5 = Subsystem(name='cpw5', sys_type='TL_RESONATOR', nodes=['cpw5'], q_opts=dict(f_res = 8.29, **q_opts))
composite_sys = CompositeSystem(
subsystems=[transmon4, ro4, cpw3, cpw5],
cells=[cell_4],
grd_node='ground_main_plane',
nodes_force_keep=['readout4', 'cpw3', 'cpw5']
)
cg = composite_sys.circuitGraph()
print(cg)
hilbertspace = composite_sys.create_hilbertspace()
print(hilbertspace)
# Convert the hilbert space into
# "Interaction Picture"
hilbertspace = composite_sys.add_interaction()
hilbertspace.hamiltonian()
hamiltonian_results = composite_sys.hamiltonian_results(hilbertspace, evals_count=30)
composite_sys.compute_gs()
|
https://github.com/WhenTheyCry96/qiskitHackathon2022
|
WhenTheyCry96
|
%load_ext autoreload
%autoreload 2
import os
import warnings
import numpy as np
import pyEPR as epr
import qiskit_metal as metal
from collections import OrderedDict
import scqubits as scq
from scipy.constants import c, h, pi, hbar, e
from qiskit_metal import designs, draw, MetalGUI, Dict, Headings
from qiskit_metal.qlibrary.tlines.meandered import RouteMeander
from qiskit_metal.qlibrary.tlines.anchored_path import RouteAnchors
from qiskit_metal.analyses.quantization import LOManalysis, EPRanalysis
from qiskit_metal.analyses.em.cpw_calculations import guided_wavelength
from qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL
from qiskit_metal.qlibrary.lumped.cap_3_interdigital import Cap3Interdigital
from qiskit_metal.qlibrary.terminations.launchpad_wb_coupled import LaunchpadWirebondCoupled
from qiskit_metal.analyses.quantization.lumped_capacitive import load_q3d_capacitance_matrix
from qiskit_metal.analyses.quantization.lom_core_analysis import CompositeSystem, Cell, Subsystem, QuantumSystemRegistry
ws_path = os.getcwd()
warnings.filterwarnings("ignore")
design = designs.DesignPlanar()
design.overwrite_enabled = True
#constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
design.chips.main.size_x = '12mm'
design.chips.main.size_y = '10mm'
gui = MetalGUI(design)
design.delete_all_components()
design_span_x = 5
design_span_y = 3
half_chip_width = design_span_x / 2
half_chip_height = design_span_y / 2
connection_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
b = dict(loc_W=1, loc_H=1),
c = dict(loc_W=-1, loc_H=-1)
)
connection23_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
c = dict(loc_W=-1, loc_H=-1)
)
transmons = []
transmons.append(TransmonPocketCL(design, 'Q1',
options=dict(pos_x=f'-{half_chip_width}mm',
pos_y=f'{-half_chip_height}mm',
connection_pads=dict(**connection_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q2',
options=dict(pos_x=f'0mm',
pos_y=f'{half_chip_height}mm',
orientation=-90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q3',
options=dict(pos_x=f'0mm',
pos_y=f'{-half_chip_height}mm',
orientation=90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q4',
options=dict(pos_x=f'{half_chip_width}mm',
pos_y=f'{half_chip_height}mm',
orientation=180,
connection_pads=dict(**connection_pads_options))))
gui.rebuild()
gui.autoscale()
fillet='99.99um'
options = Dict(
meander=Dict(
lead_start='0.1mm',
lead_end='0.1mm',
asymmetry='0 um')
)
def connect(component_name: str, component1: str, pin1: str, component2: str, pin2: str,
length: str,
asymmetry='0 um', start_strght='0 um', end_strght='0 um', flip=False):
"""Connect two pins with a CPW."""
myoptions = Dict(
pin_inputs=Dict(
start_pin=Dict(
component=component1,
pin=pin1),
end_pin=Dict(
component=component2,
pin=pin2)),
lead=Dict(
start_straight=start_strght,
end_straight=end_strght
),
total_length=length,
fillet = '99.9um')
myoptions.update(options)
myoptions.meander.asymmetry = asymmetry
myoptions.meander.lead_direction_inverted = 'true' if flip else 'false'
return RouteMeander(design, component_name, myoptions)
asym_h = 100
asym_v = 100
cpw = []
cpw.append(connect('cpw1', 'Q1', 'b', 'Q2', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw3', 'Q4', 'b', 'Q3', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw4', 'Q3', 'd', 'Q1', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw5', 'Q2', 'd', 'Q4', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
gui.rebuild()
gui.autoscale()
readouts_lwc = []
control_lwc = []
offset_x = 0
offset_y = 1
#Readouts
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R1',
options = dict(
pos_x = '-5mm',
pos_y = f'-{half_chip_height+offset_y}mm',
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R2',
options = dict(
pos_x = '-1mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R3',
options = dict(
pos_x = '1mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R4',
options = dict(
pos_x = '5mm',
pos_y = f'{half_chip_height+offset_y}mm',
orientation = 180,
lead_length = '30um')))
#Controls
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL1',
options = dict(
pos_x = '-5mm',
pos_y = '2mm',
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL2',
options = dict(
pos_x = '4mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL3',
options = dict(
pos_x = '-4mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL4',
options = dict(
pos_x = '5mm',
pos_y = '-2mm',
orientation = 180,
lead_length = '30um')))
gui.rebuild()
gui.autoscale()
readout_lines = []
asym_14 = 700
asym_23 = 700
options = Dict(
lead=Dict(
start_straight='330um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol1', 'Q1', 'c', 'R1', 'tie', '8 mm', f'{asym_14}um'))
options = Dict(
lead=Dict(
start_straight='430um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol2', 'Q2', 'c', 'R2', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol3', 'Q3', 'c', 'R3', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol4', 'Q4', 'c', 'R4', 'tie', '8 mm', f'{asym_14}um'))
gui.rebuild()
gui.autoscale()
control_lines = []
def connectRouteAnchor(name: str,
component1: str, pin1: str, component2: str, pin2: str,
anchor_points: OrderedDict) -> RouteAnchors:
options_line_cl = dict(
pin_inputs = dict(start_pin = dict(component = component1, pin = pin1),
end_pin = dict(component = component2, pin = pin2)),
anchors = anchor_points,
lead = dict(start_straight = '200um',
end_straight = '225um'),
fillet = fillet
)
return RouteAnchors(design, name, options_line_cl)
anchors1c = OrderedDict()
anchors1c[0] = np.array([-4, -1.42])
anchors1c[1] = np.array([-4, 2])
control_lines.append(connectRouteAnchor('line_cl1', 'Q1', 'Charge_Line', 'CL1', 'tie', anchors1c))
anchors2c = OrderedDict()
anchors2c[0] = np.array([0.08, 3.25])
anchors2c[1] = np.array([4, 3.25])
control_lines.append(connectRouteAnchor('line_cl2', 'Q2', 'Charge_Line', 'CL2', 'tie', anchors2c))
anchors3c = OrderedDict()
anchors3c[0] = np.array([-0.08, -3.25])
anchors3c[1] = np.array([-4, -3.25])
control_lines.append(connectRouteAnchor('line_cl3', 'Q3', 'Charge_Line', 'CL3', 'tie', anchors3c))
anchors4c = OrderedDict()
anchors4c[0] = np.array([4, 1.42])
anchors4c[1] = np.array([4, -2])
control_lines.append(connectRouteAnchor('line_cl4', 'Q4', 'Charge_Line', 'CL4', 'tie', anchors4c))
gui.rebuild()
gui.autoscale()
gui.screenshot(name="full_design.png")
# constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
# CPW busline length is determined to be 7 mm
cpw[0].options.total_length = '7.0mm'
cpw[1].options.total_length = '7.0mm'
cpw[2].options.total_length = '7.0mm'
cpw[3].options.total_length = '7.0mm'
gui.rebuild()
gui.autoscale()
# qubit 1 design target f: 5.25 GHz
# readout resonator target f: 7.05 GHz
# qubit 2 design target f: 5.42 GHz
# readout resonator target f: 7.22 GHz
# qubit 3 design target f: 5.58 GHz
# readout resonator target f: 7.38 GHz
# qubit 4 design target f: 5.75 GHz
# readout resonator target f: 7.55 GHz
# tuning parameters
C_JJ4f = 2
L_JJ4f = 9.8
C_JJ4 = str(C_JJ4f)+' fF'
L_JJ4 = str(L_JJ4f)+' nH'
transmons[3].options.pad_gap = '35um'
transmons[3].options.pad_width = '510um'
transmons[3].options.pad_height = '125um'
transmons[3].options.connection_pads.c.pad_gap = '30um'
transmons[3].options.connection_pads.a.pad_gap = '15um' # cpw5
transmons[3].options.connection_pads.a.pad_width = '40um' # cpw5
transmons[3].options.connection_pads.b.pad_gap = '15um' # cpw3
transmons[3].options.connection_pads.b.pad_width = '40um' # cpw3
readout_lines[3].options.total_length = '7.5mm'
gui.rebuild()
gui.autoscale()
# EPR analysis
eig_q4 = EPRanalysis(design, "hfss")
hfss4 = eig_q4.sim.renderer
hfss4.start()
hfss4.activate_ansys_design("TransmonQ4", 'eigenmode')
hfss4.render_design(['Q4', 'ol4', 'cpw3', 'cpw5'], [('cpw3', 'end'), ('cpw5', 'start'), ('ol4', 'end')])
# Analysis properties
setup4 = hfss4.pinfo.setup
setup4.n_modes = 6
setup4.passes = 10
setup4.min_freq_ghz = 4
print(f"""
Number of eigenmodes to find = {setup4.n_modes}
Number of simulation passes = {setup4.passes}
Convergence freq max delta percent diff = {setup4.delta_f}
""")
pinfo4 = hfss4.pinfo
pinfo4.design.set_variable('Lj4', L_JJ4)
pinfo4.design.set_variable('Cj4', C_JJ4)
setup4.analyze()
eig_q4.sim.convergence_t, eig_q4.sim.convergence_f, _ = hfss4.get_convergences()
eig_q4.sim.plot_convergences()
pinfo4.junctions['jj'] = {'Lj_variable': 'Lj4', 'rect': 'JJ_rect_Lj_Q4_rect_jj',
'line': 'JJ_Lj_Q4_rect_jj_', 'Cj_variable': 'Cj4'}
pinfo4.validate_junction_info()
pinfo4.dissipative['dielectrics_bulk'] = ['main']
hfss4.set_mode(1, "Setup")
hfss4.modeler._modeler.ShowWindow()
hfss4.plot_fields('main')
eprd4 = epr.DistributedAnalysis(pinfo4)
ℰ_elec = eprd4.calc_energy_electric()
ℰ_elec_substrate = eprd4.calc_energy_electric(None, 'main')
ℰ_mag = eprd4.calc_energy_magnetic()
print(f"""
ℰ_elec_all = {ℰ_elec}
ℰ_elec_substrate = {ℰ_elec_substrate}
EPR of substrate = {ℰ_elec_substrate / ℰ_elec * 100 :.1f}%
ℰ_mag_all = {ℰ_mag}
ℰ_mag % of ℰ_elec_all = {ℰ_mag / ℰ_elec * 100 :.1f}%
""")
eprd4.do_EPR_analysis()
#epra4 = epr.QuantumAnalysis(eprd4.data_filename)
#epra4.analyze_all_variations(cos_trunc = 8, fock_trunc = 7)
c4 = LOManalysis(design, "q3d")
q3d4 = c4.sim.renderer
q3d4.start()
q3d4.activate_ansys_design("TransmonQ4_q3d", 'capacitive')
q3d4.render_design(['Q4'], [('Q4', 'a'),('Q4', 'b'),('Q4', 'c')])
q3d4.add_q3d_setup(name="Setup", max_passes=15, min_converged_passes=5, percent_error=0.1)
q3d4.analyze_setup("Setup")
c4.sim.capacitance_matrix, c4.sim.units = q3d4.get_capacitance_matrix()
c4.sim.capacitance_all_passes, _ = q3d4.get_capacitance_all_passes()
c4.sim.capacitance_matrix
c4.setup.junctions = Dict({'Lj':L_JJ4f, 'Cj':C_JJ4f})
c4.setup.freq_readout = 7.45
c4.setup.freq_bus = [8.25, 8.25, 15]
c4.run_lom()
c4.lumped_oscillator_all
QuantumSystemRegistry.registry()
# Q4
path4= ws_path+"/Project71_TransmonQ4_q3d.txt"
t4_mat, _, _, _ = load_q3d_capacitance_matrix(path4)
# Cell 4 Transmon-4
opt4 = dict(
node_rename = {'a_connector_pad_Q4': 'cpw5',
'b_connector_pad_Q4': 'cpw3',
'c_connector_pad_Q4': 'readout4'},
cap_mat = t4_mat,
ind_dict = {('pad_top_Q4', 'pad_bot_Q4'): L_JJ4f}, # junction inductance in nH
jj_dict = {('pad_top_Q4', 'pad_bot_Q4'): 'j4'},
cj_dict = {('pad_top_Q4', 'pad_bot_Q4'): C_JJ4f} # junction capacitance in fF
)
cell_4 = Cell(opt4)
# subsystem 1: Transmon-4
transmon4 = Subsystem(name='transmon4', sys_type='TRANSMON', nodes=['j4'])
# Resonator Subsystems
q_opts = dict(
Z0 = 50, # characteristic impedance in Ohm
vp = 0.404314 * 3e8 # phase velocity
)
# subsystem 3: Q2 readout resonator
ro4 = Subsystem(name='readout4', sys_type='TL_RESONATOR', nodes=['readout4'], q_opts=dict(f_res = 7.57, **q_opts))
# subsystem 4: bus3 resonator
cpw3 = Subsystem(name='cpw3', sys_type='TL_RESONATOR', nodes=['cpw3'], q_opts=dict(f_res = 8.2, **q_opts))
# subsystem 15: bus5 resonator
cpw5 = Subsystem(name='cpw5', sys_type='TL_RESONATOR', nodes=['cpw5'], q_opts=dict(f_res = 8.29, **q_opts))
composite_sys = CompositeSystem(
subsystems=[transmon4, ro4, cpw3, cpw5],
cells=[cell_4],
grd_node='ground_main_plane',
nodes_force_keep=['readout4', 'cpw3', 'cpw5']
)
cg = composite_sys.circuitGraph()
print(cg)
hilbertspace = composite_sys.create_hilbertspace()
print(hilbertspace)
# Convert the hilbert space into
# "Interaction Picture"
hilbertspace = composite_sys.add_interaction()
hilbertspace.hamiltonian()
hamiltonian_results = composite_sys.hamiltonian_results(hilbertspace, evals_count=30)
composite_sys.compute_gs()
|
https://github.com/WhenTheyCry96/qiskitHackathon2022
|
WhenTheyCry96
|
%load_ext autoreload
%autoreload 2
import os
import warnings
import numpy as np
import pandas as pd
import qiskit_metal as metal
from numpy import pi
from scipy.constants import c, h, pi, hbar, e
from qiskit_metal import designs, draw, MetalGUI, Dict, Headings
from qiskit_metal.qlibrary.qubits.transmon_pocket_6 import TransmonPocket6
from qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL
from qiskit_metal.qlibrary.tlines.meandered import RouteMeander
from qiskit_metal.qlibrary.terminations.open_to_ground import OpenToGround
from qiskit_metal.qlibrary.lumped.cap_3_interdigital import Cap3Interdigital
from qiskit_metal.qlibrary.terminations.launchpad_wb_coupled import LaunchpadWirebondCoupled
from qiskit_metal.analyses.em.cpw_calculations import guided_wavelength
from qiskit_metal.analyses.quantization import LOManalysis, EPRanalysis
from qiskit_metal.analyses.quantization.lumped_capacitive import load_q3d_capacitance_matrix
from qiskit_metal.analyses.quantization.lom_core_analysis import CompositeSystem, Cell, Subsystem, QuantumSystemRegistry
ws_path = os.getcwd()
warnings.filterwarnings("ignore")
design = designs.DesignPlanar()
design.overwrite_enabled = True
#constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
find_resonator_length(np.around(np.linspace(8, 9, 4),2), 10, 6, 2)
chipX = 9
chipY = 9
design.chips.main.size_x = str(chipX)+"mm"
design.chips.main.size_y = str(chipY)+"mm"
gui = MetalGUI(design)
design.delete_all_components()
# basic parameters for inital cut
C_JJ = 2
pad_g = 30
pad_w = 450
pad_h = 150
readout_g = 30
buslineL_g = 30
buslineH_g = 30
C_JJU = str(C_JJ)+"fF"
pad_g = str(pad_g)+"um"
pad_w = str(pad_w)+"um"
pad_h = str(pad_h)+"um"
readout_g = str(readout_g)+"um"
buslineL_g = str(buslineL_g)+"um"
buslineH_g = str(buslineH_g)+"um"
connector1_pads_options = dict(
cR = dict(loc_W=0, loc_H=1, pad_width='80 um', pad_gap=readout_g, pad_height='30 um'), # readout resonator
cL = dict(loc_W=1, loc_H=-1, pad_width='80 um', pad_gap=buslineL_g, pad_height='30 um'), # bus line for lower frequency
cH = dict(loc_W=-1, loc_H=-1, pad_width='80 um', pad_gap=buslineH_g, pad_height='30 um') # bus line for higher frequency
)
connector2_pads_options = dict(
cR = dict(loc_W=0, loc_H=1, pad_width='80 um', pad_gap=readout_g, pad_height='30 um'), # readout resonator
cL = dict(loc_W=1, loc_H=-1, pad_width='80 um', pad_gap=buslineL_g, pad_height='30 um'), # bus line for lower frequency
cH = dict(loc_W=-1, loc_H=-1, pad_width='80 um', pad_gap=buslineH_g, pad_height='30 um') # bus line for higher frequency
)
connector3_pads_options = dict(
cR = dict(loc_W=0, loc_H=1, pad_width='80 um', pad_gap=readout_g, pad_height='30 um'), # readout resonator
cL = dict(loc_W=1, loc_H=-1, pad_width='80 um', pad_gap=buslineL_g, pad_height='30 um'), # bus line for lower frequency
cH = dict(loc_W=-1, loc_H=-1, pad_width='80 um', pad_gap=buslineH_g, pad_height='30 um') # bus line for higher frequency
)
connector4_pads_options = dict(
cR = dict(loc_W=0, loc_H=1, pad_width='80 um', pad_gap=readout_g, pad_height='30 um'), # readout resonator
cL = dict(loc_W=1, loc_H=-1, pad_width='80 um', pad_gap=buslineL_g, pad_height='30 um'), # bus line for lower frequency
cH = dict(loc_W=-1, loc_H=-1, pad_width='80 um', pad_gap=buslineH_g, pad_height='30 um') # bus line for higher frequency
)
# target f: 5.25
connection1_pads_options = dict(
B1 = dict(loc_W=1, loc_H=-1),
R= dict(loc_W=1, loc_H=1),
B2 = dict(loc_W=-1, loc_H=-1)
)
Q1 = TransmonPocketCL(design, 'Q1',
options=dict(pos_x=f'0mm',
pos_y=f'0mm',
pad_gap = pad_g,
pad_width = pad_w,
pad_height = pad_h,
orientation=0,
connection_pads=dict(**connection1_pads_options)))
gui.rebuild()
gui.autoscale()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_qres = EPRanalysis(design, "hfss")
hfss = eig_qres.sim.renderer
hfss.start()
hfss.activate_ansys_design("Q1Readout", 'eigenmode')
hfss.render_design(['Q1'], [])
# Analysis properties
setup = hfss.pinfo.setup
setup.n_modes = 1
setup.passes = 10
setup.box_plus_buffer =True
print(f"""
Number of eigenmodes to find = {setup.n_modes}
Number of simulation passes = {setup.passes}
Convergence freq max delta percent diff = {setup.delta_f}
""")
pinfo = hfss.pinfo
pinfo.design.set_variable('Lj', str(L_JJList[0])+'nH')
pinfo.design.set_variable('Cj', C_JJU)
setup.analyze()
eig_qres.sim.convergence_t, eig_qres.sim.convergence_f, _ = hfss.get_convergences()
eig_qres.sim.plot_convergences()
import pyEPR as epr
pinfo = hfss.pinfo
pinfo.junctions['jj'] = {'Lj_variable': 'Lj', 'rect': 'JJ_rect_Lj_Q1_rect_jj',
'line': 'JJ_Lj_Q1_rect_jj_', 'Cj_variable': 'Cj'}
pinfo.validate_junction_info() # Check that valid names of variables and objects have been supplied
pinfo.dissipative['dielectrics_bulk'] = ['main'] # Dissipative elements: specify
eprd = epr.DistributedAnalysis(pinfo)
print(eprd)
ℰ_elec = eprd.calc_energy_electric()
ℰ_elec_substrate = eprd.calc_energy_electric(None, 'main')
ℰ_mag = eprd.calc_energy_magnetic()
print(f"""
ℰ_elec_all = {ℰ_elec}
ℰ_elec_substrate = {ℰ_elec_substrate}
EPR of substrate = {ℰ_elec_substrate / ℰ_elec * 100 :.1f}%
ℰ_mag_all = {ℰ_mag}
ℰ_mag % of ℰ_elec_all = {ℰ_mag / ℰ_elec * 100 :.1f}%
""")
eprd.do_EPR_analysis()
# 4a. Perform Hamiltonian spectrum post-analysis, building on mw solutions using EPR
epra = epr.QuantumAnalysis(eprd.data_filename)
epra.analyze_all_variations(cos_trunc = 8, fock_trunc = 7)
hfss.modeler._modeler.ShowWindow()
hfss.plot_fields('main')
|
https://github.com/WhenTheyCry96/qiskitHackathon2022
|
WhenTheyCry96
|
import os
import warnings
warnings.filterwarnings('ignore')
ws_path = os.getcwd()
import numpy as np
from scipy.constants import c, h, pi, hbar, e
from qiskit_metal.analyses.em.cpw_calculations import guided_wavelength
# constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
find_resonator_length(np.around(np.linspace(8, 8.5, 4),2), 10, 6, 2)
from qiskit_metal import designs, MetalGUI
design = designs.DesignPlanar()
design.overwrite_enabled = True
design.chips.main.size_x = '12mm'
design.chips.main.size_y = '10mm'
gui = MetalGUI(design)
from qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL
design.delete_all_components()
design_span_x = 5
design_span_y = 3
half_chip_width = design_span_x / 2
half_chip_height = design_span_y / 2
connection_pads_options = dict(
B1 = dict(loc_W=1, loc_H=-1),
R= dict(loc_W=1, loc_H=1),
B2 = dict(loc_W=-1, loc_H=-1)
)
transmons = []
transmons.append(TransmonPocketCL(design, 'Q1',
options=dict(pos_x=f'0mm',
pos_y=f'{half_chip_height}mm',
orientation=0,
connection_pads=dict(**connection_pads_options))))
gui.rebuild()
gui.autoscale()
transmons.append(TransmonPocketCL(design, 'Q2',
options=dict(pos_x=f'{half_chip_width}mm',
pos_y=f'0mm',
orientation=-90,
connection_pads=dict(**connection_pads_options))))
gui.rebuild()
gui.autoscale()
transmons.append(TransmonPocketCL(design, 'Q3',
options=dict(pos_x=f'{-half_chip_width}mm',
pos_y=f'0mm',
orientation=90,
connection_pads=dict(**connection_pads_options))))
gui.rebuild()
gui.autoscale()
transmons.append(TransmonPocketCL(design, 'Q4',
options=dict(pos_x=f'0mm',
pos_y=f'{-half_chip_height}mm',
orientation=180,
connection_pads=dict(**connection_pads_options))))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.tlines.meandered import RouteMeander
from qiskit_metal import Dict
fillet='99.99um'
options = Dict(
meander=Dict(
lead_start='0.1mm',
lead_end='0.1mm',
asymmetry='0 um')
)
def connect(component_name: str, component1: str, pin1: str, component2: str, pin2: str,
length: str,
asymmetry='0 um', start_strght='0 um', end_strght='0 um', flip=False):
"""Connect two pins with a CPW."""
myoptions = Dict(
pin_inputs=Dict(
start_pin=Dict(
component=component1,
pin=pin1),
end_pin=Dict(
component=component2,
pin=pin2)),
lead=Dict(
start_straight=start_strght,
end_straight=end_strght
),
total_length=length,
fillet = '99.9um')
myoptions.update(options)
myoptions.meander.asymmetry = asymmetry
myoptions.meander.lead_direction_inverted = 'true' if flip else 'false'
return RouteMeander(design, component_name, myoptions)
cpw = []
asym_h = 200
cpw.append(connect('cpw1', 'Q1', 'B1', 'Q2', 'B2', '7.60 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
asym_h = 200
cpw.append(connect('cpw2', 'Q4', 'B2', 'Q2', 'B1', '7.45 mm', f'{asym_h}um', '0.1mm', '0.1mm'))
asym_h = 200
cpw.append(connect('cpw3', 'Q1', 'B2', 'Q3', 'B1', '7.30 mm', f'{asym_h}um', '0.1mm', '0.1mm'))
asym_h = 200
cpw.append(connect('cpw4', 'Q4', 'B1', 'Q3', 'B2', '7.15 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.terminations.launchpad_wb_coupled import LaunchpadWirebondCoupled
readouts_lwc = []
control_lwc = []
#Readouts
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R1',
options = dict(
pos_x=f'3mm',
pos_y=f'{half_chip_height+3}mm',
orientation = 180,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R2',
options = dict(
pos_x=f'{half_chip_width+3}mm',
pos_y=f'-3mm',
orientation = 90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R3',
options = dict(
pos_x=f'{-half_chip_width-3}mm',
pos_y=f'3mm',
orientation = 0,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R4',
options = dict(
pos_x = f'-3mm',
pos_y = f'{-half_chip_height-3}mm',
orientation = 0,
lead_length = '30um')))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.tlines.pathfinder import RoutePathfinder
from qiskit_metal.qlibrary.lumped.cap_3_interdigital import Cap3Interdigital
cap_Q1 = Cap3Interdigital(design, 'cap_Q1', options= dict(
pos_x='2mm', pos_y=f'{half_chip_height+2}mm', orientation='180', finger_length = '40um'))
readout_lines = []
options = Dict(
lead=Dict(
start_straight='400um',
end_straight='400um'),
fillet='99.99um')
asym = 800
readout_lines.append(connect('ol1_c', 'Q1', 'R', 'cap_Q1', 'a', '8.63 mm', f'-{asym}um'))
TL_Q1 = RoutePathfinder(design, 'TL_Q1', options = dict(
fillet='99um',
lead=dict(end_straight='150um'),
pin_inputs=Dict(
start_pin=Dict(
component='R1',
pin='tie'),
end_pin=Dict(
component='cap_Q1',
pin='b')
)))
cap_Q2 = Cap3Interdigital(design, 'cap_Q2', options= dict(
pos_x=f'{half_chip_width+2}mm', pos_y=f'-2mm', orientation='90', finger_length = '40um'))
readout_lines.append(connect('ol2', 'Q2', 'R', 'cap_Q2', 'a', '8.42 mm', f'-{asym}um'))
TL_Q2 = RoutePathfinder(design, 'TL_Q2', options = dict(
fillet='99um',
lead=dict(end_straight='150um'),
pin_inputs=Dict(
start_pin=Dict(
component='R2',
pin='tie'),
end_pin=Dict(
component='cap_Q2',
pin='b')
)))
cap_Q3 = Cap3Interdigital(design, 'cap_Q3', options= dict(
pos_x=f'{-half_chip_width-2}mm', pos_y=f'2mm', orientation='270', finger_length = '40um'))
readout_lines.append(connect('ol3', 'Q3', 'R', 'cap_Q3', 'a', '8.25 mm', f'-{asym}um'))
TL_Q3 = RoutePathfinder(design, 'TL_Q3', options = dict(
fillet='99um',
lead=dict(end_straight='150um'),
pin_inputs=Dict(
start_pin=Dict(
component='R3',
pin='tie'),
end_pin=Dict(
component='cap_Q3',
pin='b')
)))
options = Dict(
lead=Dict(
start_straight='400um',
end_straight='400um'),
fillet='99.99um')
cap_Q4 = Cap3Interdigital(design, 'cap_Q4', options= dict(
pos_x=f'-2mm', pos_y=f'{-half_chip_height-2}mm', orientation='0', finger_length = '40um'))
readout_lines.append(connect('ol4', 'Q4', 'R', 'cap_Q4', 'a', '8.05 mm', f'-{asym}um'))
TL_Q4 = RoutePathfinder(design, 'TL_Q4', options = dict(
fillet='99um',
lead=dict(end_straight='150um'),
pin_inputs=Dict(
start_pin=Dict(
component='R4',
pin='tie'),
end_pin=Dict(
component='cap_Q4',
pin='b')
)))
gui.rebuild()
gui.autoscale()
#Controls
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL1',
options = dict(
pos_x = f'-3mm',
pos_y = f'3mm',
orientation=0,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL2',
options = dict(
pos_x = f'3mm',
pos_y = f'3mm',
orientation = -90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL3',
options = dict(
pos_x = f'-3mm',
pos_y = f'-3mm',
orientation = 90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL4',
options = dict(
pos_x = f'2mm',
pos_y = f'-3mm',
orientation = 90,
lead_length = '30um')))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.tlines.anchored_path import RouteAnchors
from collections import OrderedDict
import numpy as np
control_lines = []
def connectRouteAnchor(name: str,
component1: str, pin1: str, component2: str, pin2: str,
anchor_points: OrderedDict) -> RouteAnchors:
options_line_cl = dict(
pin_inputs = dict(start_pin = dict(component = component1, pin = pin1),
end_pin = dict(component = component2, pin = pin2)),
anchors = anchor_points,
lead = dict(start_straight = '200um',
end_straight = '225um'),
fillet = fillet
)
return RouteAnchors(design, name, options_line_cl)
anchors1c = OrderedDict()
anchors1c[0] = np.array([-4, -1.42])
anchors1c[1] = np.array([-4, 2])
control_lines.append(connectRouteAnchor('line_cl1', 'Q1', 'Charge_Line', 'CL1', 'tie', anchors1c))
anchors2c = OrderedDict()
anchors2c[0] = np.array([0.08, 3.25])
anchors2c[1] = np.array([4, 3.25])
control_lines.append(connectRouteAnchor('line_cl2', 'Q2', 'Charge_Line', 'CL2', 'tie', anchors2c))
anchors3c = OrderedDict()
anchors3c[0] = np.array([-0.08, -3.25])
anchors3c[1] = np.array([-4, -3.25])
control_lines.append(connectRouteAnchor('line_cl3', 'Q3', 'Charge_Line', 'CL3', 'tie', anchors3c))
anchors4c = OrderedDict()
anchors4c[0] = np.array([4, 1.42])
anchors4c[1] = np.array([4, -2])
control_lines.append(connectRouteAnchor('line_cl4', 'Q4', 'Charge_Line', 'CL4', 'tie', anchors4c))
gui.rebuild()
gui.autoscale()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_res1 = EPRanalysis(design, "hfss")
hfss1 = eig_res1.sim.renderer
hfss1.start()
transmons[0].options.pad_gap = '40um'
transmons[0].options.pad_width = '405um'
transmons[0].options.pad_height = '90um'
gui.rebuild()
hfss1.activate_ansys_design("Tune_Q1", 'eigenmode')
hfss1.render_design(['Q1'], [('Q1', 'c'), ('Q1', 'a'),('Q1', 'b'),('Q1', 'Charge_Line')])
# Analysis properties
setup1 = hfss1.pinfo.setup
setup1.passes = 10
setup1.n_modes = 3
print(f"""
Number of eigenmodes to find = {setup1.n_modes}
Number of simulation passes = {setup1.passes}
Convergence freq max delta percent diff = {setup1.delta_f}
""")
# Next 2 lines are counterinuitive, since there is no junction in this resonator.
# However, these are necessary to make pyEPR work correctly. Please do note delete
hfss1.pinfo.design.set_variable('Lj', '12 nH')
hfss1.pinfo.design.set_variable('Cj', '1 fF')
setup1.analyze()
eig_res1.sim.convergence_t, eig_res1.sim.convergence_f, _ = hfss1.get_convergences()
eig_res1.sim.plot_convergences()
|
https://github.com/WhenTheyCry96/qiskitHackathon2022
|
WhenTheyCry96
|
import warnings
warnings.filterwarnings('ignore')
from qiskit_metal import designs, MetalGUI
design = designs.DesignPlanar()
design.overwrite_enabled = True
design.chips.main.size_x = '12mm'
design.chips.main.size_y = '10mm'
gui = MetalGUI(design)
from qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL
design.delete_all_components()
design_span_x = 5
design_span_y = 3
half_chip_width = design_span_x / 2
half_chip_height = design_span_y / 2
connection_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
b = dict(loc_W=1, loc_H=1),
c = dict(loc_W=-1, loc_H=-1)
)
connection23_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
c = dict(loc_W=-1, loc_H=-1)
)
transmons = []
transmons.append(TransmonPocketCL(design, 'Q1',
options=dict(pos_x=f'-{half_chip_width}mm',
pos_y=f'{-half_chip_height}mm',
connection_pads=dict(**connection_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q2',
options=dict(pos_x=f'0mm',
pos_y=f'{half_chip_height}mm',
orientation=-90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q3',
options=dict(pos_x=f'0mm',
pos_y=f'{-half_chip_height}mm',
orientation=90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q4',
options=dict(pos_x=f'{half_chip_width}mm',
pos_y=f'{half_chip_height}mm',
orientation=180,
connection_pads=dict(**connection_pads_options))))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.tlines.meandered import RouteMeander
from qiskit_metal import Dict
fillet='99.99um'
options = Dict(
meander=Dict(
lead_start='0.1mm',
lead_end='0.1mm',
asymmetry='0 um')
)
def connect(component_name: str, component1: str, pin1: str, component2: str, pin2: str,
length: str,
asymmetry='0 um', start_strght='0 um', end_strght='0 um', flip=False):
"""Connect two pins with a CPW."""
myoptions = Dict(
pin_inputs=Dict(
start_pin=Dict(
component=component1,
pin=pin1),
end_pin=Dict(
component=component2,
pin=pin2)),
lead=Dict(
start_straight=start_strght,
end_straight=end_strght
),
total_length=length,
fillet = '99.9um')
myoptions.update(options)
myoptions.meander.asymmetry = asymmetry
myoptions.meander.lead_direction_inverted = 'true' if flip else 'false'
return RouteMeander(design, component_name, myoptions)
asym_h = 100
asym_v = 100
cpw = []
cpw.append(connect('cpw1', 'Q1', 'b', 'Q2', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw3', 'Q4', 'b', 'Q3', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw4', 'Q3', 'd', 'Q1', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw5', 'Q2', 'd', 'Q4', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.terminations.launchpad_wb_coupled import LaunchpadWirebondCoupled
readouts_lwc = []
control_lwc = []
offset_x = 0
offset_y = 1
#Readouts
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R1',
options = dict(
pos_x = '-5mm',
pos_y = f'-{half_chip_height+offset_y}mm',
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R2',
options = dict(
pos_x = '-1mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R3',
options = dict(
pos_x = '1mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R4',
options = dict(
pos_x = '5mm',
pos_y = f'{half_chip_height+offset_y}mm',
orientation = 180,
lead_length = '30um')))
#Controls
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL1',
options = dict(
pos_x = '-5mm',
pos_y = '2mm',
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL2',
options = dict(
pos_x = '4mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL3',
options = dict(
pos_x = '-4mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL4',
options = dict(
pos_x = '5mm',
pos_y = '-2mm',
orientation = 180,
lead_length = '30um')))
gui.rebuild()
gui.autoscale()
readout_lines = []
asym_14 = 700
asym_23 = 700
options = Dict(
lead=Dict(
start_straight='330um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol1', 'Q1', 'c', 'R1', 'tie', '8 mm', f'{asym_14}um'))
options = Dict(
lead=Dict(
start_straight='430um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol2', 'Q2', 'c', 'R2', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol3', 'Q3', 'c', 'R3', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol4', 'Q4', 'c', 'R4', 'tie', '8 mm', f'{asym_14}um'))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.tlines.anchored_path import RouteAnchors
from collections import OrderedDict
import numpy as np
control_lines = []
def connectRouteAnchor(name: str,
component1: str, pin1: str, component2: str, pin2: str,
anchor_points: OrderedDict) -> RouteAnchors:
options_line_cl = dict(
pin_inputs = dict(start_pin = dict(component = component1, pin = pin1),
end_pin = dict(component = component2, pin = pin2)),
anchors = anchor_points,
lead = dict(start_straight = '200um',
end_straight = '225um'),
fillet = fillet
)
return RouteAnchors(design, name, options_line_cl)
anchors1c = OrderedDict()
anchors1c[0] = np.array([-4, -1.42])
anchors1c[1] = np.array([-4, 2])
control_lines.append(connectRouteAnchor('line_cl1', 'Q1', 'Charge_Line', 'CL1', 'tie', anchors1c))
anchors2c = OrderedDict()
anchors2c[0] = np.array([0.08, 3.25])
anchors2c[1] = np.array([4, 3.25])
control_lines.append(connectRouteAnchor('line_cl2', 'Q2', 'Charge_Line', 'CL2', 'tie', anchors2c))
anchors3c = OrderedDict()
anchors3c[0] = np.array([-0.08, -3.25])
anchors3c[1] = np.array([-4, -3.25])
control_lines.append(connectRouteAnchor('line_cl3', 'Q3', 'Charge_Line', 'CL3', 'tie', anchors3c))
anchors4c = OrderedDict()
anchors4c[0] = np.array([4, 1.42])
anchors4c[1] = np.array([4, -2])
control_lines.append(connectRouteAnchor('line_cl4', 'Q4', 'Charge_Line', 'CL4', 'tie', anchors4c))
gui.rebuild()
gui.autoscale()
gui.autoscale()
gui.screenshot(name="full_design")
import numpy as np
from scipy.constants import c, h, pi, hbar, e
from qiskit_metal.analyses.em.cpw_calculations import guided_wavelength
# constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
find_resonator_length(np.around(np.linspace(8, 9.2, 4), 2), 10, 6, 2)
transmons[0].options.pad_gap = '40um'
transmons[0].options.pad_width = '550um' # 405
transmons[0].options.pad_height = '120um'
transmons[1].options.pad_gap = '40um'
transmons[1].options.pad_width = '500um' # 405
transmons[1].options.pad_height = '120um'
transmons[2].options.pad_gap = '40um'
transmons[2].options.pad_width = '460um' # 405
transmons[2].options.pad_height = '120um'
transmons[3].options.pad_gap = '40um'
transmons[3].options.pad_width = '440um' # 405
transmons[3].options.pad_height = '120um'
readout_lines[0].options.total_length = '8.06mm'
readout_lines[1].options.total_length = '8.42mm'
readout_lines[2].options.total_length = '8.24mm'
readout_lines[3].options.total_length = '8.06mm'
cpw[0].options.total_length = '7.6mm'
cpw[1].options.total_length = '7.2mm'
cpw[2].options.total_length = '6.9mm'
cpw[3].options.total_length = '6.6mm'
gui.rebuild()
gui.autoscale()
qcomps = design.components # short handle (alias)
qcomps['Q1'].options['hfss_inductance'] = 'Lj1'
qcomps['Q1'].options['hfss_capacitance'] = 'Cj1'
qcomps['Q2'].options['hfss_inductance'] = 'Lj2'
qcomps['Q2'].options['hfss_capacitance'] = 'Cj2'
qcomps['Q3'].options['hfss_inductance'] = 'Lj3'
qcomps['Q3'].options['hfss_capacitance'] = 'Cj3'
qcomps['Q4'].options['hfss_inductance'] = 'Lj4'
qcomps['Q4'].options['hfss_capacitance'] = 'Cj4'
from qiskit_metal.analyses.quantization import EPRanalysis
eig_qb = EPRanalysis(design, "hfss")
eig_qb.sim.setup.n_modes = 2
eig_qb.sim.run(name="Qbit", components=['Q1', 'R1', 'ol1'], open_terminations=[], box_plus_buffer = True)
eig_qb.sim.plot_convergences()
eig_qb.setup.junctions.jj.rect = 'JJ_rect_Lj_Q1_rect_jj'
eig_qb.setup.junctions.jj.line = 'JJ_Lj_Q1_rect_jj_'
eig_qb.setup
eig_qb.run_epr()
transmons[1].options.pad_gap = '40um'
transmons[1].options.pad_width = '500um' # 405
transmons[1].options.pad_height = '120um'
gui.rebuild()
eig_qb = EPRanalysis(design, "hfss")
eig_qb.sim.setup.n_modes = 2
eig_qb.sim.run(name="Qbit2", components=['Q2'], open_terminations=[], box_plus_buffer = False)
eig_qb.sim.plot_convergences()
transmons[2].options.pad_gap = '40um'
transmons[2].options.pad_width = '460um' # 405
transmons[2].options.pad_height = '120um'
gui.rebuild()
eig_qb = EPRanalysis(design, "hfss")
eig_qb.sim.setup.n_modes = 2
eig_qb.sim.run(name="Qbit3", components=['Q3'], open_terminations=[], box_plus_buffer = False)
eig_qb.sim.plot_convergences()
transmons[3].options.pad_gap = '40um'
transmons[3].options.pad_width = '440um' # 405
transmons[3].options.pad_height = '120um'
gui.rebuild()
eig_qb = EPRanalysis(design, "hfss")
eig_qb.sim.setup.n_modes = 2
eig_qb.sim.run(name="Qbit4", components=['Q4'], open_terminations=[], box_plus_buffer = False)
eig_qb.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_rd = EPRanalysis(design, "hfss")
readout_lines[0].options.total_length = '11.7mm'
gui.rebuild()
eig_rd.sim.setup.n_modes = 2
eig_rd.sim.setup.max_passes = 10
eig_rd.sim.run(name="Readout",
components=['R1','ol1'])
eig_rd.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_rd = EPRanalysis(design, "hfss")
readout_lines[1].options.total_length = '11.2mm'
gui.rebuild()
eig_rd.sim.setup.n_modes = 2
eig_rd.sim.setup.max_passes = 10
eig_rd.sim.run(name="Readout",
components=['R2','ol2'])
eig_rd.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_rd = EPRanalysis(design, "hfss")
readout_lines[2].options.total_length = '10.6mm'
gui.rebuild()
eig_rd.sim.setup.n_modes = 2
eig_rd.sim.setup.max_passes = 10
eig_rd.sim.run(name="Readout",
components=['R3','ol3'])
eig_rd.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_rd = EPRanalysis(design, "hfss")
readout_lines[3].options.total_length = '10mm'
gui.rebuild()
eig_rd.sim.setup.n_modes = 2
eig_rd.sim.setup.max_passes = 10
eig_rd.sim.run(name="Readout",
components=['R4','ol4'])
eig_rd.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_c = EPRanalysis(design, "hfss")
cpw[0].options.total_length = '10mm'
gui.rebuild()
eig_c.sim.setup.n_modes = 2
eig_c.sim.setup.passes = 10
eig_c.sim.run(name="CPW1",
components=['cpw1'])
eig_c.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_c = EPRanalysis(design, "hfss")
cpw[1].options.total_length = '9.6mm'
gui.rebuild()
eig_c.sim.setup.n_modes = 2
eig_c.sim.setup.passes = 10
eig_c.sim.run(name="CPW2",
components=['cpw3'])
eig_c.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_c = EPRanalysis(design, "hfss")
cpw[2].options.total_length = '9.3mm'
gui.rebuild()
eig_c.sim.setup.n_modes = 2
eig_c.sim.setup.passes = 10
eig_c.sim.run(name="CPW4",
components=['cpw4'])
eig_c.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_c = EPRanalysis(design, "hfss")
cpw[3].options.total_length = '9mm'
gui.rebuild()
eig_c.sim.setup.n_modes = 2
eig_c.sim.setup.passes = 10
eig_c.sim.run(name="CPW5",
components=['cpw5'])
eig_c.sim.plot_convergences()
|
https://github.com/WhenTheyCry96/qiskitHackathon2022
|
WhenTheyCry96
|
import warnings
warnings.filterwarnings('ignore')
from qiskit_metal import designs, MetalGUI
design = designs.DesignPlanar()
design.overwrite_enabled = True
design.chips.main.size_x = '12mm'
design.chips.main.size_y = '10mm'
gui = MetalGUI(design)
from qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL
design.delete_all_components()
design_span_x = 5
design_span_y = 3
half_chip_width = design_span_x / 2
half_chip_height = design_span_y / 2
connection_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
b = dict(loc_W=1, loc_H=1),
c = dict(loc_W=-1, loc_H=-1)
)
connection23_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
c = dict(loc_W=-1, loc_H=-1)
)
transmons = []
transmons.append(TransmonPocketCL(design, 'Q1',
options=dict(pos_x=f'-{half_chip_width}mm',
pos_y=f'{-half_chip_height}mm',
connection_pads=dict(**connection_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q2',
options=dict(pos_x=f'0mm',
pos_y=f'{half_chip_height}mm',
orientation=-90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q3',
options=dict(pos_x=f'0mm',
pos_y=f'{-half_chip_height}mm',
orientation=90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q4',
options=dict(pos_x=f'{half_chip_width}mm',
pos_y=f'{half_chip_height}mm',
orientation=180,
connection_pads=dict(**connection_pads_options))))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.tlines.meandered import RouteMeander
from qiskit_metal import Dict
fillet='99.99um'
options = Dict(
meander=Dict(
lead_start='0.1mm',
lead_end='0.1mm',
asymmetry='0 um')
)
def connect(component_name: str, component1: str, pin1: str, component2: str, pin2: str,
length: str,
asymmetry='0 um', start_strght='0 um', end_strght='0 um', flip=False):
"""Connect two pins with a CPW."""
myoptions = Dict(
pin_inputs=Dict(
start_pin=Dict(
component=component1,
pin=pin1),
end_pin=Dict(
component=component2,
pin=pin2)),
lead=Dict(
start_straight=start_strght,
end_straight=end_strght
),
total_length=length,
fillet = '99.9um')
myoptions.update(options)
myoptions.meander.asymmetry = asymmetry
myoptions.meander.lead_direction_inverted = 'true' if flip else 'false'
return RouteMeander(design, component_name, myoptions)
asym_h = 100
asym_v = 100
cpw = []
cpw.append(connect('cpw1', 'Q1', 'b', 'Q2', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw3', 'Q4', 'b', 'Q3', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw4', 'Q3', 'd', 'Q1', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw5', 'Q2', 'd', 'Q4', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.terminations.launchpad_wb_coupled import LaunchpadWirebondCoupled
readouts_lwc = []
control_lwc = []
offset_x = 0
offset_y = 1
#Readouts
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R1',
options = dict(
pos_x = '-5mm',
pos_y = f'-{half_chip_height+offset_y}mm',
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R2',
options = dict(
pos_x = '-1mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R3',
options = dict(
pos_x = '1mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R4',
options = dict(
pos_x = '5mm',
pos_y = f'{half_chip_height+offset_y}mm',
orientation = 180,
lead_length = '30um')))
#Controls
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL1',
options = dict(
pos_x = '-5mm',
pos_y = '2mm',
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL2',
options = dict(
pos_x = '4mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL3',
options = dict(
pos_x = '-4mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL4',
options = dict(
pos_x = '5mm',
pos_y = '-2mm',
orientation = 180,
lead_length = '30um')))
gui.rebuild()
gui.autoscale()
readout_lines = []
asym_14 = 700
asym_23 = 700
options = Dict(
lead=Dict(
start_straight='330um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol1', 'Q1', 'c', 'R1', 'tie', '8 mm', f'{asym_14}um'))
options = Dict(
lead=Dict(
start_straight='430um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol2', 'Q2', 'c', 'R2', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol3', 'Q3', 'c', 'R3', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol4', 'Q4', 'c', 'R4', 'tie', '8 mm', f'{asym_14}um'))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.tlines.anchored_path import RouteAnchors
from collections import OrderedDict
import numpy as np
control_lines = []
def connectRouteAnchor(name: str,
component1: str, pin1: str, component2: str, pin2: str,
anchor_points: OrderedDict) -> RouteAnchors:
options_line_cl = dict(
pin_inputs = dict(start_pin = dict(component = component1, pin = pin1),
end_pin = dict(component = component2, pin = pin2)),
anchors = anchor_points,
lead = dict(start_straight = '200um',
end_straight = '225um'),
fillet = fillet
)
return RouteAnchors(design, name, options_line_cl)
anchors1c = OrderedDict()
anchors1c[0] = np.array([-4, -1.42])
anchors1c[1] = np.array([-4, 2])
control_lines.append(connectRouteAnchor('line_cl1', 'Q1', 'Charge_Line', 'CL1', 'tie', anchors1c))
anchors2c = OrderedDict()
anchors2c[0] = np.array([0.08, 3.25])
anchors2c[1] = np.array([4, 3.25])
control_lines.append(connectRouteAnchor('line_cl2', 'Q2', 'Charge_Line', 'CL2', 'tie', anchors2c))
anchors3c = OrderedDict()
anchors3c[0] = np.array([-0.08, -3.25])
anchors3c[1] = np.array([-4, -3.25])
control_lines.append(connectRouteAnchor('line_cl3', 'Q3', 'Charge_Line', 'CL3', 'tie', anchors3c))
anchors4c = OrderedDict()
anchors4c[0] = np.array([4, 1.42])
anchors4c[1] = np.array([4, -2])
control_lines.append(connectRouteAnchor('line_cl4', 'Q4', 'Charge_Line', 'CL4', 'tie', anchors4c))
gui.rebuild()
gui.autoscale()
gui.autoscale()
gui.screenshot(name="full_design")
import numpy as np
from scipy.constants import c, h, pi, hbar, e
from qiskit_metal.analyses.em.cpw_calculations import guided_wavelength
# constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
find_resonator_length(np.around(np.linspace(8, 9.2, 4), 2), 10, 6, 2)
transmons[0].options.pad_gap = '40um'
transmons[0].options.pad_width = '550um' # 405
transmons[0].options.pad_height = '120um'
transmons[1].options.pad_gap = '40um'
transmons[1].options.pad_width = '500um' # 405
transmons[1].options.pad_height = '120um'
transmons[2].options.pad_gap = '40um'
transmons[2].options.pad_width = '460um' # 405
transmons[2].options.pad_height = '120um'
transmons[3].options.pad_gap = '40um'
transmons[3].options.pad_width = '440um' # 405
transmons[3].options.pad_height = '120um'
readout_lines[0].options.total_length = '8.63mm'
readout_lines[1].options.total_length = '8.42mm'
readout_lines[2].options.total_length = '8.24mm'
readout_lines[3].options.total_length = '8.06mm'
cpw[0].options.total_length = '7.6mm'
cpw[1].options.total_length = '7.2mm'
cpw[2].options.total_length = '6.9mm'
cpw[3].options.total_length = '6.6mm'
gui.rebuild()
gui.autoscale()
qcomps = design.components # short handle (alias)
qcomps['Q1'].options['hfss_inductance'] = 'Lj1'
qcomps['Q1'].options['hfss_capacitance'] = 'Cj1'
qcomps['Q2'].options['hfss_inductance'] = 'Lj2'
qcomps['Q2'].options['hfss_capacitance'] = 'Cj2'
qcomps['Q3'].options['hfss_inductance'] = 'Lj3'
qcomps['Q3'].options['hfss_capacitance'] = 'Cj3'
qcomps['Q4'].options['hfss_inductance'] = 'Lj4'
qcomps['Q4'].options['hfss_capacitance'] = 'Cj4'
from qiskit_metal.analyses.quantization import EPRanalysis
eig_qb = EPRanalysis(design, "hfss")
eig_qb.sim.setup.n_modes = 12
eig_qb.sim.setup.max_passes = 12
eig_qb.sim.setup.vars = Dict(Lj1= '10 nH', Cj1= '2 fF',
Lj2= '10 nH', Cj2= '2 fF',
Lj3= '10 nH', Cj3= '2 fF',
Lj4= '10 nH', Cj4= '2 fF')
eig_qb.sim.run(name="4Qubits", components=[])
eig_qb.sim.plot_convergences()
del eig_qb.setup.junctions['jj']
eig_qb.setup.junctions.jj1 = Dict(rect='JJ_rect_Lj_Q1_rect_jj', line='JJ_Lj_Q1_rect_jj_',
Lj_variable='Lj1', Cj_variable='Cj1')
eig_qb.setup.junctions.jj2 = Dict(rect='JJ_rect_Lj_Q2_rect_jj', line='JJ_Lj_Q2_rect_jj_',
Lj_variable='Lj2', Cj_variable='Cj2')
eig_qb.setup.junctions.jj3 = Dict(rect='JJ_rect_Lj_Q3_rect_jj', line='JJ_Lj_Q3_rect_jj_',
Lj_variable='Lj3', Cj_variable='Cj3')
eig_qb.setup.junctions.jj4 = Dict(rect='JJ_rect_Lj_Q4_rect_jj', line='JJ_Lj_Q4_rect_jj_',
Lj_variable='Lj4', Cj_variable='Cj4')
eig_qb.setup.sweep_variable = 'Lj1'
eig_qb.setup
eig_qb.run_epr()
eig_qb.sim.plot_fields('main', eigenmode=8)
#eig_2qb.sim.save_screenshot("eigen1.png")
transmons[0].options.pad_gap = '40um'
transmons[0].options.pad_width = '550um' # 405
transmons[0].options.pad_height = '120um'
gui.rebuild()
eig_qb = EPRanalysis(design, "hfss")
eig_qb.sim.setup.n_modes = 2
eig_qb.sim.run(name="Qbit", components=['Q1'], open_terminations=[], box_plus_buffer = False)
eig_qb.sim.plot_convergences()
transmons[1].options.pad_gap = '40um'
transmons[1].options.pad_width = '500um' # 405
transmons[1].options.pad_height = '120um'
gui.rebuild()
eig_qb = EPRanalysis(design, "hfss")
eig_qb.sim.setup.n_modes = 2
eig_qb.sim.run(name="Qbit2", components=['Q2'], open_terminations=[], box_plus_buffer = False)
eig_qb.sim.plot_convergences()
transmons[2].options.pad_gap = '40um'
transmons[2].options.pad_width = '460um' # 405
transmons[2].options.pad_height = '120um'
gui.rebuild()
eig_qb = EPRanalysis(design, "hfss")
eig_qb.sim.setup.n_modes = 2
eig_qb.sim.run(name="Qbit3", components=['Q3'], open_terminations=[], box_plus_buffer = False)
eig_qb.sim.plot_convergences()
transmons[3].options.pad_gap = '40um'
transmons[3].options.pad_width = '440um' # 405
transmons[3].options.pad_height = '120um'
gui.rebuild()
eig_qb = EPRanalysis(design, "hfss")
eig_qb.sim.setup.n_modes = 2
eig_qb.sim.run(name="Qbit4", components=['Q4'], open_terminations=[], box_plus_buffer = False)
eig_qb.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_rd = EPRanalysis(design, "hfss")
readout_lines[0].options.total_length = '11.7mm'
gui.rebuild()
eig_rd.sim.setup.n_modes = 2
eig_rd.sim.setup.max_passes = 10
eig_rd.sim.run(name="Readout",
components=['R1','ol1'])
eig_rd.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_rd = EPRanalysis(design, "hfss")
readout_lines[1].options.total_length = '11.2mm'
gui.rebuild()
eig_rd.sim.setup.n_modes = 2
eig_rd.sim.setup.max_passes = 10
eig_rd.sim.run(name="Readout",
components=['R2','ol2'])
eig_rd.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_rd = EPRanalysis(design, "hfss")
readout_lines[2].options.total_length = '10.6mm'
gui.rebuild()
eig_rd.sim.setup.n_modes = 2
eig_rd.sim.setup.max_passes = 10
eig_rd.sim.run(name="Readout",
components=['R3','ol3'])
eig_rd.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_rd = EPRanalysis(design, "hfss")
readout_lines[3].options.total_length = '10mm'
gui.rebuild()
eig_rd.sim.setup.n_modes = 2
eig_rd.sim.setup.max_passes = 10
eig_rd.sim.run(name="Readout",
components=['R4','ol4'])
eig_rd.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_c = EPRanalysis(design, "hfss")
cpw[0].options.total_length = '10mm'
gui.rebuild()
eig_c.sim.setup.n_modes = 2
eig_c.sim.setup.passes = 10
eig_c.sim.run(name="CPW1",
components=['cpw1'])
eig_c.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_c = EPRanalysis(design, "hfss")
cpw[1].options.total_length = '9.6mm'
gui.rebuild()
eig_c.sim.setup.n_modes = 2
eig_c.sim.setup.passes = 10
eig_c.sim.run(name="CPW2",
components=['cpw3'])
eig_c.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_c = EPRanalysis(design, "hfss")
cpw[2].options.total_length = '9.3mm'
gui.rebuild()
eig_c.sim.setup.n_modes = 2
eig_c.sim.setup.passes = 10
eig_c.sim.run(name="CPW4",
components=['cpw4'])
eig_c.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_c = EPRanalysis(design, "hfss")
cpw[3].options.total_length = '9mm'
gui.rebuild()
eig_c.sim.setup.n_modes = 2
eig_c.sim.setup.passes = 10
eig_c.sim.run(name="CPW5",
components=['cpw5'])
eig_c.sim.plot_convergences()
|
https://github.com/WhenTheyCry96/qiskitHackathon2022
|
WhenTheyCry96
|
import warnings
warnings.filterwarnings('ignore')
from qiskit_metal import designs, MetalGUI
design = designs.DesignPlanar()
design.overwrite_enabled = True
design.chips.main.size_x = '12mm'
design.chips.main.size_y = '10mm'
gui = MetalGUI(design)
from qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL
design.delete_all_components()
design_span_x = 5
design_span_y = 3
half_chip_width = design_span_x / 2
half_chip_height = design_span_y / 2
connection_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
b = dict(loc_W=1, loc_H=1),
c = dict(loc_W=-1, loc_H=-1)
)
connection23_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
c = dict(loc_W=-1, loc_H=-1)
)
transmons = []
transmons.append(TransmonPocketCL(design, 'Q1',
options=dict(pos_x=f'-{half_chip_width}mm',
pos_y=f'{-half_chip_height}mm',
connection_pads=dict(**connection_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q2',
options=dict(pos_x=f'0mm',
pos_y=f'{half_chip_height}mm',
orientation=-90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q3',
options=dict(pos_x=f'0mm',
pos_y=f'{-half_chip_height}mm',
orientation=90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q4',
options=dict(pos_x=f'{half_chip_width}mm',
pos_y=f'{half_chip_height}mm',
orientation=180,
connection_pads=dict(**connection_pads_options))))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.tlines.meandered import RouteMeander
from qiskit_metal import Dict
fillet='99.99um'
options = Dict(
meander=Dict(
lead_start='0.1mm',
lead_end='0.1mm',
asymmetry='0 um')
)
def connect(component_name: str, component1: str, pin1: str, component2: str, pin2: str,
length: str,
asymmetry='0 um', start_strght='0 um', end_strght='0 um', flip=False):
"""Connect two pins with a CPW."""
myoptions = Dict(
pin_inputs=Dict(
start_pin=Dict(
component=component1,
pin=pin1),
end_pin=Dict(
component=component2,
pin=pin2)),
lead=Dict(
start_straight=start_strght,
end_straight=end_strght
),
total_length=length,
fillet = '99.9um')
myoptions.update(options)
myoptions.meander.asymmetry = asymmetry
myoptions.meander.lead_direction_inverted = 'true' if flip else 'false'
return RouteMeander(design, component_name, myoptions)
asym_h = 100
asym_v = 100
cpw = []
cpw.append(connect('cpw1', 'Q1', 'b', 'Q2', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw3', 'Q4', 'b', 'Q3', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw4', 'Q3', 'd', 'Q1', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw5', 'Q2', 'd', 'Q4', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.terminations.launchpad_wb_coupled import LaunchpadWirebondCoupled
readouts_lwc = []
control_lwc = []
offset_x = 0
offset_y = 1
#Readouts
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R1',
options = dict(
pos_x = '-5mm',
pos_y = f'-{half_chip_height+offset_y}mm',
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R2',
options = dict(
pos_x = '-1mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R3',
options = dict(
pos_x = '1mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R4',
options = dict(
pos_x = '5mm',
pos_y = f'{half_chip_height+offset_y}mm',
orientation = 180,
lead_length = '30um')))
#Controls
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL1',
options = dict(
pos_x = '-5mm',
pos_y = '2mm',
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL2',
options = dict(
pos_x = '4mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL3',
options = dict(
pos_x = '-4mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL4',
options = dict(
pos_x = '5mm',
pos_y = '-2mm',
orientation = 180,
lead_length = '30um')))
gui.rebuild()
gui.autoscale()
readout_lines = []
asym_14 = 700
asym_23 = 700
options = Dict(
lead=Dict(
start_straight='330um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol1', 'Q1', 'c', 'R1', 'tie', '8 mm', f'{asym_14}um'))
options = Dict(
lead=Dict(
start_straight='430um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol2', 'Q2', 'c', 'R2', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol3', 'Q3', 'c', 'R3', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol4', 'Q4', 'c', 'R4', 'tie', '8 mm', f'{asym_14}um'))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.tlines.anchored_path import RouteAnchors
from collections import OrderedDict
import numpy as np
control_lines = []
def connectRouteAnchor(name: str,
component1: str, pin1: str, component2: str, pin2: str,
anchor_points: OrderedDict) -> RouteAnchors:
options_line_cl = dict(
pin_inputs = dict(start_pin = dict(component = component1, pin = pin1),
end_pin = dict(component = component2, pin = pin2)),
anchors = anchor_points,
lead = dict(start_straight = '200um',
end_straight = '225um'),
fillet = fillet
)
return RouteAnchors(design, name, options_line_cl)
anchors1c = OrderedDict()
anchors1c[0] = np.array([-4, -1.42])
anchors1c[1] = np.array([-4, 2])
control_lines.append(connectRouteAnchor('line_cl1', 'Q1', 'Charge_Line', 'CL1', 'tie', anchors1c))
anchors2c = OrderedDict()
anchors2c[0] = np.array([0.08, 3.25])
anchors2c[1] = np.array([4, 3.25])
control_lines.append(connectRouteAnchor('line_cl2', 'Q2', 'Charge_Line', 'CL2', 'tie', anchors2c))
anchors3c = OrderedDict()
anchors3c[0] = np.array([-0.08, -3.25])
anchors3c[1] = np.array([-4, -3.25])
control_lines.append(connectRouteAnchor('line_cl3', 'Q3', 'Charge_Line', 'CL3', 'tie', anchors3c))
anchors4c = OrderedDict()
anchors4c[0] = np.array([4, 1.42])
anchors4c[1] = np.array([4, -2])
control_lines.append(connectRouteAnchor('line_cl4', 'Q4', 'Charge_Line', 'CL4', 'tie', anchors4c))
gui.rebuild()
gui.autoscale()
gui.autoscale()
gui.screenshot(name="full_design")
import numpy as np
from scipy.constants import c, h, pi, hbar, e
from qiskit_metal.analyses.em.cpw_calculations import guided_wavelength
# constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
find_resonator_length(np.around(np.linspace(8, 9.2, 4), 2), 10, 6, 2)
transmons[0].options.pad_gap = '40um'
transmons[0].options.pad_width = '550um' # 405
transmons[0].options.pad_height = '120um'
transmons[1].options.pad_gap = '40um'
transmons[1].options.pad_width = '500um' # 405
transmons[1].options.pad_height = '120um'
transmons[2].options.pad_gap = '40um'
transmons[2].options.pad_width = '460um' # 405
transmons[2].options.pad_height = '120um'
transmons[3].options.pad_gap = '40um'
transmons[3].options.pad_width = '440um' # 405
transmons[3].options.pad_height = '120um'
readout_lines[0].options.total_length = '8.63mm'
readout_lines[1].options.total_length = '8.42mm'
readout_lines[2].options.total_length = '8.24mm'
readout_lines[3].options.total_length = '8.06mm'
cpw[0].options.total_length = '7.6mm'
cpw[1].options.total_length = '7.2mm'
cpw[2].options.total_length = '6.9mm'
cpw[3].options.total_length = '6.6mm'
gui.rebuild()
gui.autoscale()
qcomps = design.components # short handle (alias)
qcomps['Q1'].options['hfss_inductance'] = 'Lj1'
qcomps['Q1'].options['hfss_capacitance'] = 'Cj1'
qcomps['Q2'].options['hfss_inductance'] = 'Lj2'
qcomps['Q2'].options['hfss_capacitance'] = 'Cj2'
qcomps['Q3'].options['hfss_inductance'] = 'Lj3'
qcomps['Q3'].options['hfss_capacitance'] = 'Cj3'
qcomps['Q4'].options['hfss_inductance'] = 'Lj4'
qcomps['Q4'].options['hfss_capacitance'] = 'Cj4'
from qiskit_metal.analyses.quantization import EPRanalysis, LOManalysis
c1 = LOManalysis(design, "q3d")
q3d1 = c1.sim.renderer
q3d1.start()
q3d1.activate_ansys_design("full_circuit", 'capacitive')
q3d1.render_design([], [])
q3d1.add_q3d_setup(name="Setup", max_passes=15, min_converged_passes=5,percent_error=0.05)
q3d1.analyze_setup("Setup")
c1.sim.capacitance_matrix, c1.sim.units = q3d1.get_capacitance_matrix()
c1.sim.capacitance_all_passes, _ = q3d1.get_capacitance_all_passes()
c1.sim.capacitance_matrix
Out[17].to_csv("full_original_design_C.txt")
c1 = LOManalysis(design, "q3d")
q3d1 = c1.sim.renderer
q3d1.start()
q3d1.activate_ansys_design("Q1only_busopen", 'capacitive')
q3d1.render_design(['Q1', 'R1', 'cpw1', 'cpw4', 'ol1', 'line_cl1', 'CL1'], [('cpw1', 'end'),('cpw4', 'start')])
q3d1.add_q3d_setup(name="Setup", max_passes=15, min_converged_passes=5,percent_error=0.05)
q3d1.analyze_setup("Setup")
c1.sim.capacitance_matrix, c1.sim.units = q3d1.get_capacitance_matrix()
c1.sim.capacitance_all_passes, _ = q3d1.get_capacitance_all_passes()
c1.sim.capacitance_matrix
|
https://github.com/WhenTheyCry96/qiskitHackathon2022
|
WhenTheyCry96
|
import warnings
warnings.filterwarnings('ignore')
from qiskit_metal import designs, MetalGUI
design = designs.DesignPlanar()
design.overwrite_enabled = True
design.chips.main.size_x = '12mm'
design.chips.main.size_y = '10mm'
gui = MetalGUI(design)
from qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL
design.delete_all_components()
design_span_x = 5
design_span_y = 3
half_chip_width = design_span_x / 2
half_chip_height = design_span_y / 2
connection_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
b = dict(loc_W=1, loc_H=1),
c = dict(loc_W=-1, loc_H=-1)
)
connection23_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
c = dict(loc_W=-1, loc_H=-1)
)
transmons = []
transmons.append(TransmonPocketCL(design, 'Q1',
options=dict(pos_x=f'-{half_chip_width}mm',
pos_y=f'{-half_chip_height}mm',
connection_pads=dict(**connection_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q2',
options=dict(pos_x=f'0mm',
pos_y=f'{half_chip_height}mm',
orientation=-90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q3',
options=dict(pos_x=f'0mm',
pos_y=f'{-half_chip_height}mm',
orientation=90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q4',
options=dict(pos_x=f'{half_chip_width}mm',
pos_y=f'{half_chip_height}mm',
orientation=180,
connection_pads=dict(**connection_pads_options))))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.tlines.meandered import RouteMeander
from qiskit_metal import Dict
fillet='99.99um'
options = Dict(
meander=Dict(
lead_start='0.1mm',
lead_end='0.1mm',
asymmetry='0 um')
)
def connect(component_name: str, component1: str, pin1: str, component2: str, pin2: str,
length: str,
asymmetry='0 um', start_strght='0 um', end_strght='0 um', flip=False):
"""Connect two pins with a CPW."""
myoptions = Dict(
pin_inputs=Dict(
start_pin=Dict(
component=component1,
pin=pin1),
end_pin=Dict(
component=component2,
pin=pin2)),
lead=Dict(
start_straight=start_strght,
end_straight=end_strght
),
total_length=length,
fillet = '99.9um')
myoptions.update(options)
myoptions.meander.asymmetry = asymmetry
myoptions.meander.lead_direction_inverted = 'true' if flip else 'false'
return RouteMeander(design, component_name, myoptions)
asym_h = 100
asym_v = 100
cpw = []
cpw.append(connect('cpw1', 'Q1', 'b', 'Q2', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw3', 'Q4', 'b', 'Q3', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw4', 'Q3', 'd', 'Q1', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw5', 'Q2', 'd', 'Q4', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.terminations.launchpad_wb_coupled import LaunchpadWirebondCoupled
readouts_lwc = []
control_lwc = []
offset_x = 0
offset_y = 1
#Readouts
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R1',
options = dict(
pos_x = '-5mm',
pos_y = f'-{half_chip_height+offset_y}mm',
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R2',
options = dict(
pos_x = '-1mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R3',
options = dict(
pos_x = '1mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R4',
options = dict(
pos_x = '5mm',
pos_y = f'{half_chip_height+offset_y}mm',
orientation = 180,
lead_length = '30um')))
#Controls
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL1',
options = dict(
pos_x = '-5mm',
pos_y = '2mm',
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL2',
options = dict(
pos_x = '4mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL3',
options = dict(
pos_x = '-4mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL4',
options = dict(
pos_x = '5mm',
pos_y = '-2mm',
orientation = 180,
lead_length = '30um')))
gui.rebuild()
gui.autoscale()
readout_lines = []
asym_14 = 700
asym_23 = 700
options = Dict(
lead=Dict(
start_straight='330um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol1', 'Q1', 'c', 'R1', 'tie', '8 mm', f'{asym_14}um'))
options = Dict(
lead=Dict(
start_straight='430um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol2', 'Q2', 'c', 'R2', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol3', 'Q3', 'c', 'R3', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol4', 'Q4', 'c', 'R4', 'tie', '8 mm', f'{asym_14}um'))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.tlines.anchored_path import RouteAnchors
from collections import OrderedDict
import numpy as np
control_lines = []
def connectRouteAnchor(name: str,
component1: str, pin1: str, component2: str, pin2: str,
anchor_points: OrderedDict) -> RouteAnchors:
options_line_cl = dict(
pin_inputs = dict(start_pin = dict(component = component1, pin = pin1),
end_pin = dict(component = component2, pin = pin2)),
anchors = anchor_points,
lead = dict(start_straight = '200um',
end_straight = '225um'),
fillet = fillet
)
return RouteAnchors(design, name, options_line_cl)
anchors1c = OrderedDict()
anchors1c[0] = np.array([-4, -1.42])
anchors1c[1] = np.array([-4, 2])
control_lines.append(connectRouteAnchor('line_cl1', 'Q1', 'Charge_Line', 'CL1', 'tie', anchors1c))
anchors2c = OrderedDict()
anchors2c[0] = np.array([0.08, 3.25])
anchors2c[1] = np.array([4, 3.25])
control_lines.append(connectRouteAnchor('line_cl2', 'Q2', 'Charge_Line', 'CL2', 'tie', anchors2c))
anchors3c = OrderedDict()
anchors3c[0] = np.array([-0.08, -3.25])
anchors3c[1] = np.array([-4, -3.25])
control_lines.append(connectRouteAnchor('line_cl3', 'Q3', 'Charge_Line', 'CL3', 'tie', anchors3c))
anchors4c = OrderedDict()
anchors4c[0] = np.array([4, 1.42])
anchors4c[1] = np.array([4, -2])
control_lines.append(connectRouteAnchor('line_cl4', 'Q4', 'Charge_Line', 'CL4', 'tie', anchors4c))
gui.rebuild()
gui.autoscale()
gui.autoscale()
gui.screenshot(name="full_design")
import numpy as np
from scipy.constants import c, h, pi, hbar, e
from qiskit_metal.analyses.em.cpw_calculations import guided_wavelength
# constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
find_resonator_length(np.around(np.linspace(8, 9.2, 4), 2), 10, 6, 2)
transmons[0].options.pad_gap = '40um'
transmons[0].options.pad_width = '550um' # 405
transmons[0].options.pad_height = '120um'
transmons[1].options.pad_gap = '40um'
transmons[1].options.pad_width = '540um' # 405
transmons[1].options.pad_height = '120um'
transmons[2].options.pad_gap = '40um'
transmons[2].options.pad_width = '530um' # 405
transmons[2].options.pad_height = '120um'
transmons[3].options.pad_gap = '40um'
transmons[3].options.pad_width = '520um' # 405
transmons[3].options.pad_height = '120um'
readout_lines[0].options.total_length = '8.63mm'
readout_lines[1].options.total_length = '8.42mm'
readout_lines[2].options.total_length = '8.24mm'
readout_lines[3].options.total_length = '8.06mm'
cpw[0].options.total_length = '7.6mm'
cpw[1].options.total_length = '7.2mm'
cpw[2].options.total_length = '6.9mm'
cpw[3].options.total_length = '6.6mm'
gui.rebuild()
gui.autoscale()
qcomps = design.components # short handle (alias)
qcomps['Q1'].options['hfss_inductance'] = 'Lj1'
qcomps['Q1'].options['hfss_capacitance'] = 'Cj1'
qcomps['Q2'].options['hfss_inductance'] = 'Lj2'
qcomps['Q2'].options['hfss_capacitance'] = 'Cj2'
qcomps['Q3'].options['hfss_inductance'] = 'Lj3'
qcomps['Q3'].options['hfss_capacitance'] = 'Cj3'
qcomps['Q4'].options['hfss_inductance'] = 'Lj4'
qcomps['Q4'].options['hfss_capacitance'] = 'Cj4'
from qiskit_metal.analyses.quantization import EPRanalysis, LOManalysis
c1 = LOManalysis(design, "q3d")
q3d1 = c1.sim.renderer
q3d1.start()
q3d1.activate_ansys_design("qubit_pad_w_550_520", 'capacitive')
q3d1.render_design([], [])
q3d1.add_q3d_setup(name="Setup", max_passes=15, min_converged_passes=5,percent_error=0.05)
q3d1.analyze_setup("Setup")
c1.sim.capacitance_matrix, c1.sim.units = q3d1.get_capacitance_matrix()
c1.sim.capacitance_all_passes, _ = q3d1.get_capacitance_all_passes()
c1.sim.capacitance_matrix
|
https://github.com/WhenTheyCry96/qiskitHackathon2022
|
WhenTheyCry96
|
%load_ext autoreload
%autoreload 2
import os
import warnings
import numpy as np
import pyEPR as epr
import qiskit_metal as metal
from collections import OrderedDict
import scqubits as scq
from scipy.constants import c, h, pi, hbar, e
from qiskit_metal import designs, draw, MetalGUI, Dict, Headings
from qiskit_metal.qlibrary.tlines.meandered import RouteMeander
from qiskit_metal.qlibrary.tlines.anchored_path import RouteAnchors
from qiskit_metal.analyses.quantization import LOManalysis, EPRanalysis
from qiskit_metal.analyses.em.cpw_calculations import guided_wavelength
from qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL
from qiskit_metal.qlibrary.lumped.cap_3_interdigital import Cap3Interdigital
from qiskit_metal.qlibrary.terminations.launchpad_wb_coupled import LaunchpadWirebondCoupled
from qiskit_metal.analyses.quantization.lumped_capacitive import load_q3d_capacitance_matrix
from qiskit_metal.analyses.quantization.lom_core_analysis import CompositeSystem, Cell, Subsystem, QuantumSystemRegistry
ws_path = os.getcwd()
warnings.filterwarnings("ignore")
design = designs.DesignPlanar()
design.overwrite_enabled = True
#constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
design.chips.main.size_x = '12mm'
design.chips.main.size_y = '10mm'
gui = MetalGUI(design)
design.delete_all_components()
design_span_x = 5
design_span_y = 3
half_chip_width = design_span_x / 2
half_chip_height = design_span_y / 2
connection_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
b = dict(loc_W=1, loc_H=1),
c = dict(loc_W=-1, loc_H=-1)
)
connection23_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
c = dict(loc_W=-1, loc_H=-1)
)
transmons = []
transmons.append(TransmonPocketCL(design, 'Q1',
options=dict(pos_x=f'-{half_chip_width}mm',
pos_y=f'{-half_chip_height}mm',
connection_pads=dict(**connection_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q2',
options=dict(pos_x=f'0mm',
pos_y=f'{half_chip_height}mm',
orientation=-90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q3',
options=dict(pos_x=f'0mm',
pos_y=f'{-half_chip_height}mm',
orientation=90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q4',
options=dict(pos_x=f'{half_chip_width}mm',
pos_y=f'{half_chip_height}mm',
orientation=180,
connection_pads=dict(**connection_pads_options))))
gui.rebuild()
gui.autoscale()
fillet='99.99um'
options = Dict(
meander=Dict(
lead_start='0.1mm',
lead_end='0.1mm',
asymmetry='0 um')
)
def connect(component_name: str, component1: str, pin1: str, component2: str, pin2: str,
length: str,
asymmetry='0 um', start_strght='0 um', end_strght='0 um', flip=False):
"""Connect two pins with a CPW."""
myoptions = Dict(
pin_inputs=Dict(
start_pin=Dict(
component=component1,
pin=pin1),
end_pin=Dict(
component=component2,
pin=pin2)),
lead=Dict(
start_straight=start_strght,
end_straight=end_strght
),
total_length=length,
fillet = '99.9um')
myoptions.update(options)
myoptions.meander.asymmetry = asymmetry
myoptions.meander.lead_direction_inverted = 'true' if flip else 'false'
return RouteMeander(design, component_name, myoptions)
asym_h = 100
asym_v = 100
cpw = []
cpw.append(connect('cpw1', 'Q1', 'b', 'Q2', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw3', 'Q4', 'b', 'Q3', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw4', 'Q3', 'd', 'Q1', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw5', 'Q2', 'd', 'Q4', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
gui.rebuild()
gui.autoscale()
readouts_lwc = []
control_lwc = []
offset_x = 0
offset_y = 1
#Readouts
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R1',
options = dict(
pos_x = '-5mm',
pos_y = f'-{half_chip_height+offset_y}mm',
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R2',
options = dict(
pos_x = '-1mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R3',
options = dict(
pos_x = '1mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R4',
options = dict(
pos_x = '5mm',
pos_y = f'{half_chip_height+offset_y}mm',
orientation = 180,
lead_length = '30um')))
#Controls
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL1',
options = dict(
pos_x = '-5mm',
pos_y = '2mm',
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL2',
options = dict(
pos_x = '4mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL3',
options = dict(
pos_x = '-4mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL4',
options = dict(
pos_x = '5mm',
pos_y = '-2mm',
orientation = 180,
lead_length = '30um')))
gui.rebuild()
gui.autoscale()
readout_lines = []
asym_14 = 700
asym_23 = 700
options = Dict(
lead=Dict(
start_straight='330um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol1', 'Q1', 'c', 'R1', 'tie', '8 mm', f'{asym_14}um'))
options = Dict(
lead=Dict(
start_straight='430um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol2', 'Q2', 'c', 'R2', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol3', 'Q3', 'c', 'R3', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol4', 'Q4', 'c', 'R4', 'tie', '8 mm', f'{asym_14}um'))
gui.rebuild()
gui.autoscale()
control_lines = []
def connectRouteAnchor(name: str,
component1: str, pin1: str, component2: str, pin2: str,
anchor_points: OrderedDict) -> RouteAnchors:
options_line_cl = dict(
pin_inputs = dict(start_pin = dict(component = component1, pin = pin1),
end_pin = dict(component = component2, pin = pin2)),
anchors = anchor_points,
lead = dict(start_straight = '200um',
end_straight = '225um'),
fillet = fillet
)
return RouteAnchors(design, name, options_line_cl)
anchors1c = OrderedDict()
anchors1c[0] = np.array([-4, -1.42])
anchors1c[1] = np.array([-4, 2])
control_lines.append(connectRouteAnchor('line_cl1', 'Q1', 'Charge_Line', 'CL1', 'tie', anchors1c))
anchors2c = OrderedDict()
anchors2c[0] = np.array([0.08, 3.25])
anchors2c[1] = np.array([4, 3.25])
control_lines.append(connectRouteAnchor('line_cl2', 'Q2', 'Charge_Line', 'CL2', 'tie', anchors2c))
anchors3c = OrderedDict()
anchors3c[0] = np.array([-0.08, -3.25])
anchors3c[1] = np.array([-4, -3.25])
control_lines.append(connectRouteAnchor('line_cl3', 'Q3', 'Charge_Line', 'CL3', 'tie', anchors3c))
anchors4c = OrderedDict()
anchors4c[0] = np.array([4, 1.42])
anchors4c[1] = np.array([4, -2])
control_lines.append(connectRouteAnchor('line_cl4', 'Q4', 'Charge_Line', 'CL4', 'tie', anchors4c))
gui.rebuild()
gui.autoscale()
gui.screenshot(name="full_design.png")
# constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
# CPW busline length is determined to be 7 mm
cpw[0].options.total_length = '7.0mm'
cpw[1].options.total_length = '7.0mm'
cpw[2].options.total_length = '7.0mm'
cpw[3].options.total_length = '7.0mm'
gui.rebuild()
gui.autoscale()
# qubit 1 design target f: 5.25 GHz
# readout resonator target f: 7.05 GHz
# qubit 2 design target f: 5.42 GHz
# readout resonator target f: 7.22 GHz
# qubit 3 design target f: 5.58 GHz
# readout resonator target f: 7.38 GHz
# qubit 4 design target f: 5.75 GHz
# readout resonator target f: 7.55 GHz
# tuning parameters
C_JJ4f = 2
L_JJ4f = 11.7
C_JJ4 = str(C_JJ4f)+' fF'
L_JJ4 = str(L_JJ4f)+' nH'
transmons[3].options.pad_gap = '35um'
transmons[3].options.pad_width = '500um'
transmons[3].options.pad_height = '125um'
transmons[3].options.connection_pads.c.pad_gap = '40um'
transmons[3].options.connection_pads.a.pad_gap = '60um' # cpw5
transmons[3].options.connection_pads.a.pad_width = '40um' # cpw5
transmons[3].options.connection_pads.b.pad_gap = '60um' # cpw3
transmons[3].options.connection_pads.b.pad_width = '30um' # cpw3
readout_lines[3].options.total_length = '7.5mm'
gui.rebuild()
gui.autoscale()
# EPR analysis
eig_q4 = EPRanalysis(design, "hfss")
hfss4 = eig_q4.sim.renderer
hfss4.start()
hfss4.activate_ansys_design("TransmonQ4", 'eigenmode')
hfss4.render_design(['Q4', 'ol4', 'cpw3', 'cpw5'], [('cpw3', 'end'), ('cpw5', 'start'), ('ol4', 'end')])
# Analysis properties
setup4 = hfss4.pinfo.setup
setup4.n_modes = 6
setup4.passes = 10
setup4.min_freq_ghz = 4
print(f"""
Number of eigenmodes to find = {setup4.n_modes}
Number of simulation passes = {setup4.passes}
Convergence freq max delta percent diff = {setup4.delta_f}
""")
pinfo4 = hfss4.pinfo
pinfo4.design.set_variable('Lj4', L_JJ4)
pinfo4.design.set_variable('Cj4', C_JJ4)
setup4.analyze()
eig_q4.sim.convergence_t, eig_q4.sim.convergence_f, _ = hfss4.get_convergences()
eig_q4.sim.plot_convergences()
pinfo4.junctions['jj'] = {'Lj_variable': 'Lj4', 'rect': 'JJ_rect_Lj_Q4_rect_jj',
'line': 'JJ_Lj_Q4_rect_jj_', 'Cj_variable': 'Cj4'}
pinfo4.validate_junction_info()
pinfo4.dissipative['dielectrics_bulk'] = ['main']
hfss4.set_mode(1, "Setup")
hfss4.modeler._modeler.ShowWindow()
hfss4.plot_fields('main')
eprd4 = epr.DistributedAnalysis(pinfo4)
ℰ_elec = eprd4.calc_energy_electric()
ℰ_elec_substrate = eprd4.calc_energy_electric(None, 'main')
ℰ_mag = eprd4.calc_energy_magnetic()
print(f"""
ℰ_elec_all = {ℰ_elec}
ℰ_elec_substrate = {ℰ_elec_substrate}
EPR of substrate = {ℰ_elec_substrate / ℰ_elec * 100 :.1f}%
ℰ_mag_all = {ℰ_mag}
ℰ_mag % of ℰ_elec_all = {ℰ_mag / ℰ_elec * 100 :.1f}%
""")
eprd4.do_EPR_analysis()
#epra4 = epr.QuantumAnalysis(eprd4.data_filename)
#epra4.analyze_all_variations(cos_trunc = 8, fock_trunc = 7)
c4 = LOManalysis(design, "q3d")
q3d4 = c4.sim.renderer
q3d4.start()
q3d4.activate_ansys_design("TransmonQ4_q3d", 'capacitive')
q3d4.render_design(['Q4'], [('Q4', 'a'),('Q4', 'b'),('Q4', 'c')])
q3d4.add_q3d_setup(name="Setup", max_passes=15, min_converged_passes=5, percent_error=0.1)
q3d4.analyze_setup("Setup")
c4.sim.capacitance_matrix, c4.sim.units = q3d4.get_capacitance_matrix()
c4.sim.capacitance_all_passes, _ = q3d4.get_capacitance_all_passes()
c4.sim.capacitance_matrix
c4.setup.junctions = Dict({'Lj':L_JJ4f, 'Cj':C_JJ4f})
c4.setup.freq_readout = 7.45
c4.setup.freq_bus = [8.25, 8.25, 15]
c4.run_lom()
c4.lumped_oscillator_all
QuantumSystemRegistry.registry()
# Q4
path4= ws_path+"/Project71_TransmonQ4_q3d.txt"
t4_mat, _, _, _ = load_q3d_capacitance_matrix(path4)
# Cell 4 Transmon-4
opt4 = dict(
node_rename = {'a_connector_pad_Q4': 'cpw5',
'b_connector_pad_Q4': 'cpw3',
'c_connector_pad_Q4': 'readout4'},
cap_mat = t4_mat,
ind_dict = {('pad_top_Q4', 'pad_bot_Q4'): 11.7}, # junction inductance in nH
jj_dict = {('pad_top_Q4', 'pad_bot_Q4'): 'j4'},
cj_dict = {('pad_top_Q4', 'pad_bot_Q4'): 2} # junction capacitance in fF
)
cell_4 = Cell(opt4)
# subsystem 1: Transmon-4
transmon4 = Subsystem(name='transmon4', sys_type='TRANSMON', nodes=['j4'])
# Resonator Subsystems
q_opts = dict(
Z0 = 50, # characteristic impedance in Ohm
vp = 0.404314 * 3e8 # phase velocity
)
# subsystem 3: Q2 readout resonator
ro4 = Subsystem(name='readout4', sys_type='TL_RESONATOR', nodes=['readout4'], q_opts=dict(f_res = 7.57, **q_opts))
# subsystem 4: bus3 resonator
cpw3 = Subsystem(name='cpw3', sys_type='TL_RESONATOR', nodes=['cpw3'], q_opts=dict(f_res = 8.2, **q_opts))
# subsystem 15: bus5 resonator
cpw5 = Subsystem(name='cpw5', sys_type='TL_RESONATOR', nodes=['cpw5'], q_opts=dict(f_res = 8.29, **q_opts))
composite_sys = CompositeSystem(
subsystems=[transmon4, ro4, cpw3, cpw5],
cells=[cell_4],
grd_node='ground_main_plane',
nodes_force_keep=['readout4', 'cpw3', 'cpw5']
)
cg = composite_sys.circuitGraph()
print(cg)
hilbertspace = composite_sys.create_hilbertspace()
print(hilbertspace)
# Convert the hilbert space into
# "Interaction Picture"
hilbertspace = composite_sys.add_interaction()
hilbertspace.hamiltonian()
hamiltonian_results = composite_sys.hamiltonian_results(hilbertspace, evals_count=30)
composite_sys.compute_gs()
|
https://github.com/WhenTheyCry96/qiskitHackathon2022
|
WhenTheyCry96
|
%load_ext autoreload
%autoreload 2
import os
import warnings
import numpy as np
import pyEPR as epr
import qiskit_metal as metal
from collections import OrderedDict
import scqubits as scq
from scipy.constants import c, h, pi, hbar, e
from qiskit_metal import designs, draw, MetalGUI, Dict, Headings
from qiskit_metal.qlibrary.tlines.meandered import RouteMeander
from qiskit_metal.qlibrary.tlines.anchored_path import RouteAnchors
from qiskit_metal.analyses.quantization import LOManalysis, EPRanalysis
from qiskit_metal.analyses.em.cpw_calculations import guided_wavelength
from qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL
from qiskit_metal.qlibrary.lumped.cap_3_interdigital import Cap3Interdigital
from qiskit_metal.qlibrary.terminations.launchpad_wb_coupled import LaunchpadWirebondCoupled
from qiskit_metal.analyses.quantization.lumped_capacitive import load_q3d_capacitance_matrix
from qiskit_metal.analyses.quantization.lom_core_analysis import CompositeSystem, Cell, Subsystem, QuantumSystemRegistry
ws_path = os.getcwd()
warnings.filterwarnings("ignore")
design = designs.DesignPlanar()
design.overwrite_enabled = True
#constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
design.chips.main.size_x = '12mm'
design.chips.main.size_y = '10mm'
gui = MetalGUI(design)
design.delete_all_components()
design_span_x = 5
design_span_y = 3
half_chip_width = design_span_x / 2
half_chip_height = design_span_y / 2
connection_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
b = dict(loc_W=1, loc_H=1),
c = dict(loc_W=-1, loc_H=-1)
)
connection23_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
c = dict(loc_W=-1, loc_H=-1)
)
transmons = []
transmons.append(TransmonPocketCL(design, 'Q1',
options=dict(pos_x=f'-{half_chip_width}mm',
pos_y=f'{-half_chip_height}mm',
connection_pads=dict(**connection_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q2',
options=dict(pos_x=f'0mm',
pos_y=f'{half_chip_height}mm',
orientation=-90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q3',
options=dict(pos_x=f'0mm',
pos_y=f'{-half_chip_height}mm',
orientation=90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q4',
options=dict(pos_x=f'{half_chip_width}mm',
pos_y=f'{half_chip_height}mm',
orientation=180,
connection_pads=dict(**connection_pads_options))))
gui.rebuild()
gui.autoscale()
fillet='99.99um'
options = Dict(
meander=Dict(
lead_start='0.1mm',
lead_end='0.1mm',
asymmetry='0 um')
)
def connect(component_name: str, component1: str, pin1: str, component2: str, pin2: str,
length: str,
asymmetry='0 um', start_strght='0 um', end_strght='0 um', flip=False):
"""Connect two pins with a CPW."""
myoptions = Dict(
pin_inputs=Dict(
start_pin=Dict(
component=component1,
pin=pin1),
end_pin=Dict(
component=component2,
pin=pin2)),
lead=Dict(
start_straight=start_strght,
end_straight=end_strght
),
total_length=length,
fillet = '99.9um')
myoptions.update(options)
myoptions.meander.asymmetry = asymmetry
myoptions.meander.lead_direction_inverted = 'true' if flip else 'false'
return RouteMeander(design, component_name, myoptions)
asym_h = 100
asym_v = 100
cpw = []
cpw.append(connect('cpw1', 'Q1', 'b', 'Q2', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw3', 'Q4', 'b', 'Q3', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw4', 'Q3', 'd', 'Q1', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw5', 'Q2', 'd', 'Q4', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
gui.rebuild()
gui.autoscale()
readouts_lwc = []
control_lwc = []
offset_x = 0
offset_y = 1
#Readouts
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R1',
options = dict(
pos_x = '-5mm',
pos_y = f'-{half_chip_height+offset_y}mm',
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R2',
options = dict(
pos_x = '-1mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R3',
options = dict(
pos_x = '1mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R4',
options = dict(
pos_x = '5mm',
pos_y = f'{half_chip_height+offset_y}mm',
orientation = 180,
lead_length = '30um')))
#Controls
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL1',
options = dict(
pos_x = '-5mm',
pos_y = '2mm',
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL2',
options = dict(
pos_x = '4mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL3',
options = dict(
pos_x = '-4mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL4',
options = dict(
pos_x = '5mm',
pos_y = '-2mm',
orientation = 180,
lead_length = '30um')))
gui.rebuild()
gui.autoscale()
readout_lines = []
asym_14 = 700
asym_23 = 700
options = Dict(
lead=Dict(
start_straight='330um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol1', 'Q1', 'c', 'R1', 'tie', '8 mm', f'{asym_14}um'))
options = Dict(
lead=Dict(
start_straight='430um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol2', 'Q2', 'c', 'R2', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol3', 'Q3', 'c', 'R3', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol4', 'Q4', 'c', 'R4', 'tie', '8 mm', f'{asym_14}um'))
gui.rebuild()
gui.autoscale()
control_lines = []
def connectRouteAnchor(name: str,
component1: str, pin1: str, component2: str, pin2: str,
anchor_points: OrderedDict) -> RouteAnchors:
options_line_cl = dict(
pin_inputs = dict(start_pin = dict(component = component1, pin = pin1),
end_pin = dict(component = component2, pin = pin2)),
anchors = anchor_points,
lead = dict(start_straight = '200um',
end_straight = '225um'),
fillet = fillet
)
return RouteAnchors(design, name, options_line_cl)
anchors1c = OrderedDict()
anchors1c[0] = np.array([-4, -1.42])
anchors1c[1] = np.array([-4, 2])
control_lines.append(connectRouteAnchor('line_cl1', 'Q1', 'Charge_Line', 'CL1', 'tie', anchors1c))
anchors2c = OrderedDict()
anchors2c[0] = np.array([0.08, 3.25])
anchors2c[1] = np.array([4, 3.25])
control_lines.append(connectRouteAnchor('line_cl2', 'Q2', 'Charge_Line', 'CL2', 'tie', anchors2c))
anchors3c = OrderedDict()
anchors3c[0] = np.array([-0.08, -3.25])
anchors3c[1] = np.array([-4, -3.25])
control_lines.append(connectRouteAnchor('line_cl3', 'Q3', 'Charge_Line', 'CL3', 'tie', anchors3c))
anchors4c = OrderedDict()
anchors4c[0] = np.array([4, 1.42])
anchors4c[1] = np.array([4, -2])
control_lines.append(connectRouteAnchor('line_cl4', 'Q4', 'Charge_Line', 'CL4', 'tie', anchors4c))
gui.rebuild()
gui.autoscale()
gui.screenshot(name="full_design.png")
# constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
# CPW busline length is determined to be 7 mm
cpw[0].options.total_length = '7.0mm'
cpw[1].options.total_length = '7.0mm'
cpw[2].options.total_length = '7.0mm'
cpw[3].options.total_length = '7.0mm'
gui.rebuild()
gui.autoscale()
# qubit 1 design target f: 5.25 GHz
# readout resonator target f: 7.05 GHz
# qubit 2 design target f: 5.42 GHz
# readout resonator target f: 7.22 GHz
# qubit 3 design target f: 5.58 GHz
# readout resonator target f: 7.38 GHz
# qubit 4 design target f: 5.75 GHz
# readout resonator target f: 7.55 GHz
# tuning parameters
C_JJ4f = 2
L_JJ4f = 9.8
C_JJ4 = str(C_JJ4f)+' fF'
L_JJ4 = str(L_JJ4f)+' nH'
transmons[3].options.pad_gap = '35um'
transmons[3].options.pad_width = '510um'
transmons[3].options.pad_height = '125um'
transmons[3].options.connection_pads.c.pad_gap = '30um'
transmons[3].options.connection_pads.a.pad_gap = '15um' # cpw5
transmons[3].options.connection_pads.a.pad_width = '40um' # cpw5
transmons[3].options.connection_pads.b.pad_gap = '15um' # cpw3
transmons[3].options.connection_pads.b.pad_width = '40um' # cpw3
readout_lines[3].options.total_length = '7.5mm'
gui.rebuild()
gui.autoscale()
# EPR analysis
eig_q4 = EPRanalysis(design, "hfss")
hfss4 = eig_q4.sim.renderer
hfss4.start()
hfss4.activate_ansys_design("TransmonQ4", 'eigenmode')
hfss4.render_design(['Q4', 'ol4', 'cpw3', 'cpw5'], [('cpw3', 'end'), ('cpw5', 'start'), ('ol4', 'end')])
# Analysis properties
setup4 = hfss4.pinfo.setup
setup4.n_modes = 6
setup4.passes = 10
setup4.min_freq_ghz = 4
print(f"""
Number of eigenmodes to find = {setup4.n_modes}
Number of simulation passes = {setup4.passes}
Convergence freq max delta percent diff = {setup4.delta_f}
""")
pinfo4 = hfss4.pinfo
pinfo4.design.set_variable('Lj4', L_JJ4)
pinfo4.design.set_variable('Cj4', C_JJ4)
setup4.analyze()
eig_q4.sim.convergence_t, eig_q4.sim.convergence_f, _ = hfss4.get_convergences()
eig_q4.sim.plot_convergences()
pinfo4.junctions['jj'] = {'Lj_variable': 'Lj4', 'rect': 'JJ_rect_Lj_Q4_rect_jj',
'line': 'JJ_Lj_Q4_rect_jj_', 'Cj_variable': 'Cj4'}
pinfo4.validate_junction_info()
pinfo4.dissipative['dielectrics_bulk'] = ['main']
hfss4.set_mode(1, "Setup")
hfss4.modeler._modeler.ShowWindow()
hfss4.plot_fields('main')
eprd4 = epr.DistributedAnalysis(pinfo4)
ℰ_elec = eprd4.calc_energy_electric()
ℰ_elec_substrate = eprd4.calc_energy_electric(None, 'main')
ℰ_mag = eprd4.calc_energy_magnetic()
print(f"""
ℰ_elec_all = {ℰ_elec}
ℰ_elec_substrate = {ℰ_elec_substrate}
EPR of substrate = {ℰ_elec_substrate / ℰ_elec * 100 :.1f}%
ℰ_mag_all = {ℰ_mag}
ℰ_mag % of ℰ_elec_all = {ℰ_mag / ℰ_elec * 100 :.1f}%
""")
eprd4.do_EPR_analysis()
#epra4 = epr.QuantumAnalysis(eprd4.data_filename)
#epra4.analyze_all_variations(cos_trunc = 8, fock_trunc = 7)
c4 = LOManalysis(design, "q3d")
q3d4 = c4.sim.renderer
q3d4.start()
q3d4.activate_ansys_design("TransmonQ4_q3d", 'capacitive')
q3d4.render_design(['Q4'], [('Q4', 'a'),('Q4', 'b'),('Q4', 'c')])
q3d4.add_q3d_setup(name="Setup", max_passes=15, min_converged_passes=5, percent_error=0.1)
q3d4.analyze_setup("Setup")
c4.sim.capacitance_matrix, c4.sim.units = q3d4.get_capacitance_matrix()
c4.sim.capacitance_all_passes, _ = q3d4.get_capacitance_all_passes()
c4.sim.capacitance_matrix
c4.setup.junctions = Dict({'Lj':L_JJ4f, 'Cj':C_JJ4f})
c4.setup.freq_readout = 7.45
c4.setup.freq_bus = [8.25, 8.25, 15]
c4.run_lom()
c4.lumped_oscillator_all
QuantumSystemRegistry.registry()
# Q4
path4= ws_path+"/Project71_TransmonQ4_q3d.txt"
t4_mat, _, _, _ = load_q3d_capacitance_matrix(path4)
# Cell 4 Transmon-4
opt4 = dict(
node_rename = {'a_connector_pad_Q4': 'cpw5',
'b_connector_pad_Q4': 'cpw3',
'c_connector_pad_Q4': 'readout4'},
cap_mat = t4_mat,
ind_dict = {('pad_top_Q4', 'pad_bot_Q4'): L_JJ4f}, # junction inductance in nH
jj_dict = {('pad_top_Q4', 'pad_bot_Q4'): 'j4'},
cj_dict = {('pad_top_Q4', 'pad_bot_Q4'): C_JJ4f} # junction capacitance in fF
)
cell_4 = Cell(opt4)
# subsystem 1: Transmon-4
transmon4 = Subsystem(name='transmon4', sys_type='TRANSMON', nodes=['j4'])
# Resonator Subsystems
q_opts = dict(
Z0 = 50, # characteristic impedance in Ohm
vp = 0.404314 * 3e8 # phase velocity
)
# subsystem 3: Q2 readout resonator
ro4 = Subsystem(name='readout4', sys_type='TL_RESONATOR', nodes=['readout4'], q_opts=dict(f_res = 7.57, **q_opts))
# subsystem 4: bus3 resonator
cpw3 = Subsystem(name='cpw3', sys_type='TL_RESONATOR', nodes=['cpw3'], q_opts=dict(f_res = 8.2, **q_opts))
# subsystem 15: bus5 resonator
cpw5 = Subsystem(name='cpw5', sys_type='TL_RESONATOR', nodes=['cpw5'], q_opts=dict(f_res = 8.29, **q_opts))
composite_sys = CompositeSystem(
subsystems=[transmon4, ro4, cpw3, cpw5],
cells=[cell_4],
grd_node='ground_main_plane',
nodes_force_keep=['readout4', 'cpw3', 'cpw5']
)
cg = composite_sys.circuitGraph()
print(cg)
hilbertspace = composite_sys.create_hilbertspace()
print(hilbertspace)
# Convert the hilbert space into
# "Interaction Picture"
hilbertspace = composite_sys.add_interaction()
hilbertspace.hamiltonian()
hamiltonian_results = composite_sys.hamiltonian_results(hilbertspace, evals_count=30)
composite_sys.compute_gs()
|
https://github.com/WhenTheyCry96/qiskitHackathon2022
|
WhenTheyCry96
|
%load_ext autoreload
%autoreload 2
import os
import warnings
import numpy as np
import pandas as pd
import qiskit_metal as metal
from numpy import pi
from scipy.constants import c, h, pi, hbar, e
from qiskit_metal import designs, draw, MetalGUI, Dict, Headings
from qiskit_metal.qlibrary.qubits.transmon_pocket_6 import TransmonPocket6
from qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL
from qiskit_metal.qlibrary.tlines.meandered import RouteMeander
from qiskit_metal.qlibrary.terminations.open_to_ground import OpenToGround
from qiskit_metal.qlibrary.lumped.cap_3_interdigital import Cap3Interdigital
from qiskit_metal.qlibrary.terminations.launchpad_wb_coupled import LaunchpadWirebondCoupled
from qiskit_metal.analyses.em.cpw_calculations import guided_wavelength
from qiskit_metal.analyses.quantization import LOManalysis, EPRanalysis
from qiskit_metal.analyses.quantization.lumped_capacitive import load_q3d_capacitance_matrix
from qiskit_metal.analyses.quantization.lom_core_analysis import CompositeSystem, Cell, Subsystem, QuantumSystemRegistry
ws_path = os.getcwd()
warnings.filterwarnings("ignore")
design = designs.DesignPlanar()
design.overwrite_enabled = True
#constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
find_resonator_length(np.around(np.linspace(8, 9, 4),2), 10, 6, 2)
chipX = 9
chipY = 9
design.chips.main.size_x = str(chipX)+"mm"
design.chips.main.size_y = str(chipY)+"mm"
gui = MetalGUI(design)
design.delete_all_components()
# basic parameters for inital cut
C_JJ = 2
pad_g = 30
pad_w = 450
pad_h = 150
readout_g = 30
buslineL_g = 30
buslineH_g = 30
C_JJU = str(C_JJ)+"fF"
pad_g = str(pad_g)+"um"
pad_w = str(pad_w)+"um"
pad_h = str(pad_h)+"um"
readout_g = str(readout_g)+"um"
buslineL_g = str(buslineL_g)+"um"
buslineH_g = str(buslineH_g)+"um"
connector1_pads_options = dict(
cR = dict(loc_W=0, loc_H=1, pad_width='80 um', pad_gap=readout_g, pad_height='30 um'), # readout resonator
cL = dict(loc_W=1, loc_H=-1, pad_width='80 um', pad_gap=buslineL_g, pad_height='30 um'), # bus line for lower frequency
cH = dict(loc_W=-1, loc_H=-1, pad_width='80 um', pad_gap=buslineH_g, pad_height='30 um') # bus line for higher frequency
)
connector2_pads_options = dict(
cR = dict(loc_W=0, loc_H=1, pad_width='80 um', pad_gap=readout_g, pad_height='30 um'), # readout resonator
cL = dict(loc_W=1, loc_H=-1, pad_width='80 um', pad_gap=buslineL_g, pad_height='30 um'), # bus line for lower frequency
cH = dict(loc_W=-1, loc_H=-1, pad_width='80 um', pad_gap=buslineH_g, pad_height='30 um') # bus line for higher frequency
)
connector3_pads_options = dict(
cR = dict(loc_W=0, loc_H=1, pad_width='80 um', pad_gap=readout_g, pad_height='30 um'), # readout resonator
cL = dict(loc_W=1, loc_H=-1, pad_width='80 um', pad_gap=buslineL_g, pad_height='30 um'), # bus line for lower frequency
cH = dict(loc_W=-1, loc_H=-1, pad_width='80 um', pad_gap=buslineH_g, pad_height='30 um') # bus line for higher frequency
)
connector4_pads_options = dict(
cR = dict(loc_W=0, loc_H=1, pad_width='80 um', pad_gap=readout_g, pad_height='30 um'), # readout resonator
cL = dict(loc_W=1, loc_H=-1, pad_width='80 um', pad_gap=buslineL_g, pad_height='30 um'), # bus line for lower frequency
cH = dict(loc_W=-1, loc_H=-1, pad_width='80 um', pad_gap=buslineH_g, pad_height='30 um') # bus line for higher frequency
)
# target f: 5.25
connection1_pads_options = dict(
B1 = dict(loc_W=1, loc_H=-1),
R= dict(loc_W=1, loc_H=1),
B2 = dict(loc_W=-1, loc_H=-1)
)
Q1 = TransmonPocketCL(design, 'Q1',
options=dict(pos_x=f'0mm',
pos_y=f'0mm',
pad_gap = pad_g,
pad_width = pad_w,
pad_height = pad_h,
orientation=0,
connection_pads=dict(**connection1_pads_options)))
gui.rebuild()
gui.autoscale()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_qres = EPRanalysis(design, "hfss")
hfss = eig_qres.sim.renderer
hfss.start()
hfss.activate_ansys_design("Q1Readout", 'eigenmode')
hfss.render_design(['Q1'], [])
# Analysis properties
setup = hfss.pinfo.setup
setup.n_modes = 1
setup.passes = 10
setup.box_plus_buffer =True
print(f"""
Number of eigenmodes to find = {setup.n_modes}
Number of simulation passes = {setup.passes}
Convergence freq max delta percent diff = {setup.delta_f}
""")
pinfo = hfss.pinfo
pinfo.design.set_variable('Lj', str(L_JJList[0])+'nH')
pinfo.design.set_variable('Cj', C_JJU)
setup.analyze()
eig_qres.sim.convergence_t, eig_qres.sim.convergence_f, _ = hfss.get_convergences()
eig_qres.sim.plot_convergences()
import pyEPR as epr
pinfo = hfss.pinfo
pinfo.junctions['jj'] = {'Lj_variable': 'Lj', 'rect': 'JJ_rect_Lj_Q1_rect_jj',
'line': 'JJ_Lj_Q1_rect_jj_', 'Cj_variable': 'Cj'}
pinfo.validate_junction_info() # Check that valid names of variables and objects have been supplied
pinfo.dissipative['dielectrics_bulk'] = ['main'] # Dissipative elements: specify
eprd = epr.DistributedAnalysis(pinfo)
print(eprd)
ℰ_elec = eprd.calc_energy_electric()
ℰ_elec_substrate = eprd.calc_energy_electric(None, 'main')
ℰ_mag = eprd.calc_energy_magnetic()
print(f"""
ℰ_elec_all = {ℰ_elec}
ℰ_elec_substrate = {ℰ_elec_substrate}
EPR of substrate = {ℰ_elec_substrate / ℰ_elec * 100 :.1f}%
ℰ_mag_all = {ℰ_mag}
ℰ_mag % of ℰ_elec_all = {ℰ_mag / ℰ_elec * 100 :.1f}%
""")
eprd.do_EPR_analysis()
# 4a. Perform Hamiltonian spectrum post-analysis, building on mw solutions using EPR
epra = epr.QuantumAnalysis(eprd.data_filename)
epra.analyze_all_variations(cos_trunc = 8, fock_trunc = 7)
hfss.modeler._modeler.ShowWindow()
hfss.plot_fields('main')
|
https://github.com/WhenTheyCry96/qiskitHackathon2022
|
WhenTheyCry96
|
import os
import warnings
warnings.filterwarnings('ignore')
ws_path = os.getcwd()
import numpy as np
from scipy.constants import c, h, pi, hbar, e
from qiskit_metal.analyses.em.cpw_calculations import guided_wavelength
# constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
find_resonator_length(np.around(np.linspace(8, 8.5, 4),2), 10, 6, 2)
from qiskit_metal import designs, MetalGUI
design = designs.DesignPlanar()
design.overwrite_enabled = True
design.chips.main.size_x = '12mm'
design.chips.main.size_y = '10mm'
gui = MetalGUI(design)
from qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL
design.delete_all_components()
design_span_x = 5
design_span_y = 3
half_chip_width = design_span_x / 2
half_chip_height = design_span_y / 2
connection_pads_options = dict(
B1 = dict(loc_W=1, loc_H=-1),
R= dict(loc_W=1, loc_H=1),
B2 = dict(loc_W=-1, loc_H=-1)
)
transmons = []
transmons.append(TransmonPocketCL(design, 'Q1',
options=dict(pos_x=f'0mm',
pos_y=f'{half_chip_height}mm',
orientation=0,
connection_pads=dict(**connection_pads_options))))
gui.rebuild()
gui.autoscale()
transmons.append(TransmonPocketCL(design, 'Q2',
options=dict(pos_x=f'{half_chip_width}mm',
pos_y=f'0mm',
orientation=-90,
connection_pads=dict(**connection_pads_options))))
gui.rebuild()
gui.autoscale()
transmons.append(TransmonPocketCL(design, 'Q3',
options=dict(pos_x=f'{-half_chip_width}mm',
pos_y=f'0mm',
orientation=90,
connection_pads=dict(**connection_pads_options))))
gui.rebuild()
gui.autoscale()
transmons.append(TransmonPocketCL(design, 'Q4',
options=dict(pos_x=f'0mm',
pos_y=f'{-half_chip_height}mm',
orientation=180,
connection_pads=dict(**connection_pads_options))))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.tlines.meandered import RouteMeander
from qiskit_metal import Dict
fillet='99.99um'
options = Dict(
meander=Dict(
lead_start='0.1mm',
lead_end='0.1mm',
asymmetry='0 um')
)
def connect(component_name: str, component1: str, pin1: str, component2: str, pin2: str,
length: str,
asymmetry='0 um', start_strght='0 um', end_strght='0 um', flip=False):
"""Connect two pins with a CPW."""
myoptions = Dict(
pin_inputs=Dict(
start_pin=Dict(
component=component1,
pin=pin1),
end_pin=Dict(
component=component2,
pin=pin2)),
lead=Dict(
start_straight=start_strght,
end_straight=end_strght
),
total_length=length,
fillet = '99.9um')
myoptions.update(options)
myoptions.meander.asymmetry = asymmetry
myoptions.meander.lead_direction_inverted = 'true' if flip else 'false'
return RouteMeander(design, component_name, myoptions)
cpw = []
asym_h = 200
cpw.append(connect('cpw1', 'Q1', 'B1', 'Q2', 'B2', '7.60 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
asym_h = 200
cpw.append(connect('cpw2', 'Q4', 'B2', 'Q2', 'B1', '7.45 mm', f'{asym_h}um', '0.1mm', '0.1mm'))
asym_h = 200
cpw.append(connect('cpw3', 'Q1', 'B2', 'Q3', 'B1', '7.30 mm', f'{asym_h}um', '0.1mm', '0.1mm'))
asym_h = 200
cpw.append(connect('cpw4', 'Q4', 'B1', 'Q3', 'B2', '7.15 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.terminations.launchpad_wb_coupled import LaunchpadWirebondCoupled
readouts_lwc = []
control_lwc = []
#Readouts
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R1',
options = dict(
pos_x=f'3mm',
pos_y=f'{half_chip_height+3}mm',
orientation = 180,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R2',
options = dict(
pos_x=f'{half_chip_width+3}mm',
pos_y=f'-3mm',
orientation = 90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R3',
options = dict(
pos_x=f'{-half_chip_width-3}mm',
pos_y=f'3mm',
orientation = 0,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R4',
options = dict(
pos_x = f'-3mm',
pos_y = f'{-half_chip_height-3}mm',
orientation = 0,
lead_length = '30um')))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.tlines.pathfinder import RoutePathfinder
from qiskit_metal.qlibrary.lumped.cap_3_interdigital import Cap3Interdigital
cap_Q1 = Cap3Interdigital(design, 'cap_Q1', options= dict(
pos_x='2mm', pos_y=f'{half_chip_height+2}mm', orientation='180', finger_length = '40um'))
readout_lines = []
options = Dict(
lead=Dict(
start_straight='400um',
end_straight='400um'),
fillet='99.99um')
asym = 800
readout_lines.append(connect('ol1_c', 'Q1', 'R', 'cap_Q1', 'a', '8.63 mm', f'-{asym}um'))
TL_Q1 = RoutePathfinder(design, 'TL_Q1', options = dict(
fillet='99um',
lead=dict(end_straight='150um'),
pin_inputs=Dict(
start_pin=Dict(
component='R1',
pin='tie'),
end_pin=Dict(
component='cap_Q1',
pin='b')
)))
cap_Q2 = Cap3Interdigital(design, 'cap_Q2', options= dict(
pos_x=f'{half_chip_width+2}mm', pos_y=f'-2mm', orientation='90', finger_length = '40um'))
readout_lines.append(connect('ol2', 'Q2', 'R', 'cap_Q2', 'a', '8.42 mm', f'-{asym}um'))
TL_Q2 = RoutePathfinder(design, 'TL_Q2', options = dict(
fillet='99um',
lead=dict(end_straight='150um'),
pin_inputs=Dict(
start_pin=Dict(
component='R2',
pin='tie'),
end_pin=Dict(
component='cap_Q2',
pin='b')
)))
cap_Q3 = Cap3Interdigital(design, 'cap_Q3', options= dict(
pos_x=f'{-half_chip_width-2}mm', pos_y=f'2mm', orientation='270', finger_length = '40um'))
readout_lines.append(connect('ol3', 'Q3', 'R', 'cap_Q3', 'a', '8.25 mm', f'-{asym}um'))
TL_Q3 = RoutePathfinder(design, 'TL_Q3', options = dict(
fillet='99um',
lead=dict(end_straight='150um'),
pin_inputs=Dict(
start_pin=Dict(
component='R3',
pin='tie'),
end_pin=Dict(
component='cap_Q3',
pin='b')
)))
options = Dict(
lead=Dict(
start_straight='400um',
end_straight='400um'),
fillet='99.99um')
cap_Q4 = Cap3Interdigital(design, 'cap_Q4', options= dict(
pos_x=f'-2mm', pos_y=f'{-half_chip_height-2}mm', orientation='0', finger_length = '40um'))
readout_lines.append(connect('ol4', 'Q4', 'R', 'cap_Q4', 'a', '8.05 mm', f'-{asym}um'))
TL_Q4 = RoutePathfinder(design, 'TL_Q4', options = dict(
fillet='99um',
lead=dict(end_straight='150um'),
pin_inputs=Dict(
start_pin=Dict(
component='R4',
pin='tie'),
end_pin=Dict(
component='cap_Q4',
pin='b')
)))
gui.rebuild()
gui.autoscale()
#Controls
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL1',
options = dict(
pos_x = f'-3mm',
pos_y = f'3mm',
orientation=0,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL2',
options = dict(
pos_x = f'3mm',
pos_y = f'3mm',
orientation = -90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL3',
options = dict(
pos_x = f'-3mm',
pos_y = f'-3mm',
orientation = 90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL4',
options = dict(
pos_x = f'2mm',
pos_y = f'-3mm',
orientation = 90,
lead_length = '30um')))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.tlines.anchored_path import RouteAnchors
from collections import OrderedDict
import numpy as np
control_lines = []
def connectRouteAnchor(name: str,
component1: str, pin1: str, component2: str, pin2: str,
anchor_points: OrderedDict) -> RouteAnchors:
options_line_cl = dict(
pin_inputs = dict(start_pin = dict(component = component1, pin = pin1),
end_pin = dict(component = component2, pin = pin2)),
anchors = anchor_points,
lead = dict(start_straight = '200um',
end_straight = '225um'),
fillet = fillet
)
return RouteAnchors(design, name, options_line_cl)
anchors1c = OrderedDict()
anchors1c[0] = np.array([-4, -1.42])
anchors1c[1] = np.array([-4, 2])
control_lines.append(connectRouteAnchor('line_cl1', 'Q1', 'Charge_Line', 'CL1', 'tie', anchors1c))
anchors2c = OrderedDict()
anchors2c[0] = np.array([0.08, 3.25])
anchors2c[1] = np.array([4, 3.25])
control_lines.append(connectRouteAnchor('line_cl2', 'Q2', 'Charge_Line', 'CL2', 'tie', anchors2c))
anchors3c = OrderedDict()
anchors3c[0] = np.array([-0.08, -3.25])
anchors3c[1] = np.array([-4, -3.25])
control_lines.append(connectRouteAnchor('line_cl3', 'Q3', 'Charge_Line', 'CL3', 'tie', anchors3c))
anchors4c = OrderedDict()
anchors4c[0] = np.array([4, 1.42])
anchors4c[1] = np.array([4, -2])
control_lines.append(connectRouteAnchor('line_cl4', 'Q4', 'Charge_Line', 'CL4', 'tie', anchors4c))
gui.rebuild()
gui.autoscale()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_res1 = EPRanalysis(design, "hfss")
hfss1 = eig_res1.sim.renderer
hfss1.start()
transmons[0].options.pad_gap = '40um'
transmons[0].options.pad_width = '405um'
transmons[0].options.pad_height = '90um'
gui.rebuild()
hfss1.activate_ansys_design("Tune_Q1", 'eigenmode')
hfss1.render_design(['Q1'], [('Q1', 'c'), ('Q1', 'a'),('Q1', 'b'),('Q1', 'Charge_Line')])
# Analysis properties
setup1 = hfss1.pinfo.setup
setup1.passes = 10
setup1.n_modes = 3
print(f"""
Number of eigenmodes to find = {setup1.n_modes}
Number of simulation passes = {setup1.passes}
Convergence freq max delta percent diff = {setup1.delta_f}
""")
# Next 2 lines are counterinuitive, since there is no junction in this resonator.
# However, these are necessary to make pyEPR work correctly. Please do note delete
hfss1.pinfo.design.set_variable('Lj', '12 nH')
hfss1.pinfo.design.set_variable('Cj', '1 fF')
setup1.analyze()
eig_res1.sim.convergence_t, eig_res1.sim.convergence_f, _ = hfss1.get_convergences()
eig_res1.sim.plot_convergences()
|
https://github.com/WhenTheyCry96/qiskitHackathon2022
|
WhenTheyCry96
|
import warnings
warnings.filterwarnings('ignore')
from qiskit_metal import designs, MetalGUI
design = designs.DesignPlanar()
design.overwrite_enabled = True
design.chips.main.size_x = '12mm'
design.chips.main.size_y = '10mm'
gui = MetalGUI(design)
from qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL
design.delete_all_components()
design_span_x = 5
design_span_y = 3
half_chip_width = design_span_x / 2
half_chip_height = design_span_y / 2
connection_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
b = dict(loc_W=1, loc_H=1),
c = dict(loc_W=-1, loc_H=-1)
)
connection23_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
c = dict(loc_W=-1, loc_H=-1)
)
transmons = []
transmons.append(TransmonPocketCL(design, 'Q1',
options=dict(pos_x=f'-{half_chip_width}mm',
pos_y=f'{-half_chip_height}mm',
connection_pads=dict(**connection_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q2',
options=dict(pos_x=f'0mm',
pos_y=f'{half_chip_height}mm',
orientation=-90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q3',
options=dict(pos_x=f'0mm',
pos_y=f'{-half_chip_height}mm',
orientation=90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q4',
options=dict(pos_x=f'{half_chip_width}mm',
pos_y=f'{half_chip_height}mm',
orientation=180,
connection_pads=dict(**connection_pads_options))))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.tlines.meandered import RouteMeander
from qiskit_metal import Dict
fillet='99.99um'
options = Dict(
meander=Dict(
lead_start='0.1mm',
lead_end='0.1mm',
asymmetry='0 um')
)
def connect(component_name: str, component1: str, pin1: str, component2: str, pin2: str,
length: str,
asymmetry='0 um', start_strght='0 um', end_strght='0 um', flip=False):
"""Connect two pins with a CPW."""
myoptions = Dict(
pin_inputs=Dict(
start_pin=Dict(
component=component1,
pin=pin1),
end_pin=Dict(
component=component2,
pin=pin2)),
lead=Dict(
start_straight=start_strght,
end_straight=end_strght
),
total_length=length,
fillet = '99.9um')
myoptions.update(options)
myoptions.meander.asymmetry = asymmetry
myoptions.meander.lead_direction_inverted = 'true' if flip else 'false'
return RouteMeander(design, component_name, myoptions)
asym_h = 100
asym_v = 100
cpw = []
cpw.append(connect('cpw1', 'Q1', 'b', 'Q2', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw3', 'Q4', 'b', 'Q3', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw4', 'Q3', 'd', 'Q1', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw5', 'Q2', 'd', 'Q4', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.terminations.launchpad_wb_coupled import LaunchpadWirebondCoupled
readouts_lwc = []
control_lwc = []
offset_x = 0
offset_y = 1
#Readouts
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R1',
options = dict(
pos_x = '-5mm',
pos_y = f'-{half_chip_height+offset_y}mm',
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R2',
options = dict(
pos_x = '-1mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R3',
options = dict(
pos_x = '1mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R4',
options = dict(
pos_x = '5mm',
pos_y = f'{half_chip_height+offset_y}mm',
orientation = 180,
lead_length = '30um')))
#Controls
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL1',
options = dict(
pos_x = '-5mm',
pos_y = '2mm',
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL2',
options = dict(
pos_x = '4mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL3',
options = dict(
pos_x = '-4mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL4',
options = dict(
pos_x = '5mm',
pos_y = '-2mm',
orientation = 180,
lead_length = '30um')))
gui.rebuild()
gui.autoscale()
readout_lines = []
asym_14 = 700
asym_23 = 700
options = Dict(
lead=Dict(
start_straight='330um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol1', 'Q1', 'c', 'R1', 'tie', '8 mm', f'{asym_14}um'))
options = Dict(
lead=Dict(
start_straight='430um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol2', 'Q2', 'c', 'R2', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol3', 'Q3', 'c', 'R3', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol4', 'Q4', 'c', 'R4', 'tie', '8 mm', f'{asym_14}um'))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.tlines.anchored_path import RouteAnchors
from collections import OrderedDict
import numpy as np
control_lines = []
def connectRouteAnchor(name: str,
component1: str, pin1: str, component2: str, pin2: str,
anchor_points: OrderedDict) -> RouteAnchors:
options_line_cl = dict(
pin_inputs = dict(start_pin = dict(component = component1, pin = pin1),
end_pin = dict(component = component2, pin = pin2)),
anchors = anchor_points,
lead = dict(start_straight = '200um',
end_straight = '225um'),
fillet = fillet
)
return RouteAnchors(design, name, options_line_cl)
anchors1c = OrderedDict()
anchors1c[0] = np.array([-4, -1.42])
anchors1c[1] = np.array([-4, 2])
control_lines.append(connectRouteAnchor('line_cl1', 'Q1', 'Charge_Line', 'CL1', 'tie', anchors1c))
anchors2c = OrderedDict()
anchors2c[0] = np.array([0.08, 3.25])
anchors2c[1] = np.array([4, 3.25])
control_lines.append(connectRouteAnchor('line_cl2', 'Q2', 'Charge_Line', 'CL2', 'tie', anchors2c))
anchors3c = OrderedDict()
anchors3c[0] = np.array([-0.08, -3.25])
anchors3c[1] = np.array([-4, -3.25])
control_lines.append(connectRouteAnchor('line_cl3', 'Q3', 'Charge_Line', 'CL3', 'tie', anchors3c))
anchors4c = OrderedDict()
anchors4c[0] = np.array([4, 1.42])
anchors4c[1] = np.array([4, -2])
control_lines.append(connectRouteAnchor('line_cl4', 'Q4', 'Charge_Line', 'CL4', 'tie', anchors4c))
gui.rebuild()
gui.autoscale()
gui.autoscale()
gui.screenshot(name="full_design")
import numpy as np
from scipy.constants import c, h, pi, hbar, e
from qiskit_metal.analyses.em.cpw_calculations import guided_wavelength
# constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
find_resonator_length(np.around(np.linspace(8, 9.2, 4), 2), 10, 6, 2)
transmons[0].options.pad_gap = '40um'
transmons[0].options.pad_width = '550um' # 405
transmons[0].options.pad_height = '120um'
transmons[1].options.pad_gap = '40um'
transmons[1].options.pad_width = '500um' # 405
transmons[1].options.pad_height = '120um'
transmons[2].options.pad_gap = '40um'
transmons[2].options.pad_width = '370um' # 405
transmons[2].options.pad_height = '120um'
transmons[2].options.connection_pads.d.pad_gap='10um'
transmons[2].options.connection_pads.a.pad_gap='10um'
transmons[2].options.connection_pads.c.pad_gap='10um'
transmons[3].options.pad_gap = '40um'
transmons[3].options.pad_width = '440um' # 405
transmons[3].options.pad_height = '120um'
readout_lines[0].options.total_length = '8.63mm'
readout_lines[1].options.total_length = '8.42mm'
readout_lines[2].options.total_length = '8.24mm'
readout_lines[3].options.total_length = '8.06mm'
cpw[0].options.total_length = '7mm'
cpw[1].options.total_length = '7mm'
cpw[2].options.total_length = '7mm'
cpw[3].options.total_length = '7mm'
gui.rebuild()
gui.autoscale()
qcomps = design.components # short handle (alias)
qcomps['Q1'].options['hfss_inductance'] = 'Lj1'
qcomps['Q1'].options['hfss_capacitance'] = 'Cj1'
qcomps['Q2'].options['hfss_inductance'] = 'Lj2'
qcomps['Q2'].options['hfss_capacitance'] = 'Cj2'
qcomps['Q3'].options['hfss_inductance'] = 'Lj3'
qcomps['Q3'].options['hfss_capacitance'] = 'Cj3'
qcomps['Q4'].options['hfss_inductance'] = 'Lj4'
qcomps['Q4'].options['hfss_capacitance'] = 'Cj4'
from qiskit_metal.analyses.quantization import EPRanalysis, LOManalysis
from qiskit_metal.analyses.quantization.lumped_capacitive import load_q3d_capacitance_matrix
from qiskit_metal.analyses.quantization.lom_core_analysis import CompositeSystem, Cell, Subsystem, QuantumSystemRegistry
c1 = LOManalysis(design, "q3d")
q3d1 = c1.sim.renderer
q3d1.start()
q3d1.activate_ansys_design("Q3only_busopen_370_gap_reduced", 'capacitive')
q3d1.render_design(['Q3', 'R3', 'cpw3', 'cpw4', 'ol3', 'line_cl3', 'CL3'], [('cpw3', 'start'),('cpw4', 'end')])
q3d1.add_q3d_setup(name="Setup", max_passes=15, min_converged_passes=5,percent_error=0.05)
q3d1.analyze_setup("Setup")
c1.sim.capacitance_matrix, c1.sim.units = q3d1.get_capacitance_matrix()
c1.sim.capacitance_all_passes, _ = q3d1.get_capacitance_all_passes()
c1.sim.capacitance_matrix
t3_mat = c1.sim.capacitance_matrix
path3 = "./capacitance_matrices/Project19_Q3only_busopen_460.txt"
t3_mat, _, _, _ = load_q3d_capacitance_matrix(path3)
t3_mat
opt3 = dict(
cap_mat = t3_mat,
ind_dict = {('pad_top_Q3', 'pad_bot_Q3'): 12}, # junction inductance in nH
jj_dict = {('pad_top_Q3', 'pad_bot_Q3'): 'j3'},
cj_dict = {('pad_top_Q3', 'pad_bot_Q3'): 1}, # junction capacitance in fF
)
cell_3 = Cell(opt3)
transmon3 = Subsystem(name='transmon3', sys_type='TRANSMON', nodes=['j3'])
# Resonator Subsystems
from scipy.constants import speed_of_light as c_light
q_opts = dict(
Z0 = 50, # characteristic impedance in Ohm
vp = 0.404314 * c_light # phase velocity
)
ro3 = Subsystem(name='c_connector_pad_Q3', sys_type='TL_RESONATOR', nodes=['c_connector_pad_Q3'], q_opts=dict(f_res = 7.38, **q_opts))
coup34 = Subsystem(name='a_connector_pad_Q3', sys_type='TL_RESONATOR', nodes=['a_connector_pad_Q3'], q_opts=dict(f_res = 7.5, **q_opts))
coup31 = Subsystem(name='d_connector_pad_Q3', sys_type='TL_RESONATOR', nodes=['d_connector_pad_Q3'], q_opts=dict(f_res = 7.5, **q_opts))
composite_sys = CompositeSystem(
subsystems=[transmon3, ro3, coup34, coup31],
cells=[cell_3],
grd_node='ground_main_plane',
nodes_force_keep=['c_connector_pad_Q3', 'a_connector_pad_Q3', 'd_connector_pad_Q3']
)
cg = composite_sys.circuitGraph()
print(cg)
hilbertspace = composite_sys.create_hilbertspace()
print(hilbertspace)
# Convert the hilbert space into
# "Interaction Picture"
hilbertspace = composite_sys.add_interaction()
hilbertspace.hamiltonian()
hamiltonian_results = composite_sys.hamiltonian_results(hilbertspace, evals_count=30)
composite_sys.compute_gs()
hamiltonian_results = composite_sys.hamiltonian_results(hilbertspace, evals_count=30)
composite_sys.compute_gs()
hamiltonian_results = composite_sys.hamiltonian_results(hilbertspace, evals_count=30)
composite_sys.compute_gs()
hamiltonian_results = composite_sys.hamiltonian_results(hilbertspace, evals_count=30)
composite_sys.compute_gs()
hamiltonian_results = composite_sys.hamiltonian_results(hilbertspace, evals_count=30)
composite_sys.compute_gs()
hamiltonian_results = composite_sys.hamiltonian_results(hilbertspace, evals_count=30)
composite_sys.compute_gs()
hamiltonian_results = composite_sys.hamiltonian_results(hilbertspace, evals_count=30)
composite_sys.compute_gs()
|
https://github.com/WhenTheyCry96/qiskitHackathon2022
|
WhenTheyCry96
|
import warnings
warnings.filterwarnings('ignore')
from qiskit_metal import designs, MetalGUI
design = designs.DesignPlanar()
design.overwrite_enabled = True
design.chips.main.size_x = '12mm'
design.chips.main.size_y = '10mm'
gui = MetalGUI(design)
from qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL
design.delete_all_components()
design_span_x = 5
design_span_y = 3
half_chip_width = design_span_x / 2
half_chip_height = design_span_y / 2
connection_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
b = dict(loc_W=1, loc_H=1),
c = dict(loc_W=-1, loc_H=-1)
)
connection23_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
c = dict(loc_W=-1, loc_H=-1)
)
transmons = []
transmons.append(TransmonPocketCL(design, 'Q1',
options=dict(pos_x=f'-{half_chip_width}mm',
pos_y=f'{-half_chip_height}mm',
connection_pads=dict(**connection_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q2',
options=dict(pos_x=f'0mm',
pos_y=f'{half_chip_height}mm',
orientation=-90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q3',
options=dict(pos_x=f'0mm',
pos_y=f'{-half_chip_height}mm',
orientation=90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q4',
options=dict(pos_x=f'{half_chip_width}mm',
pos_y=f'{half_chip_height}mm',
orientation=180,
connection_pads=dict(**connection_pads_options))))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.tlines.meandered import RouteMeander
from qiskit_metal import Dict
fillet='99.99um'
options = Dict(
meander=Dict(
lead_start='0.1mm',
lead_end='0.1mm',
asymmetry='0 um')
)
def connect(component_name: str, component1: str, pin1: str, component2: str, pin2: str,
length: str,
asymmetry='0 um', start_strght='0 um', end_strght='0 um', flip=False):
"""Connect two pins with a CPW."""
myoptions = Dict(
pin_inputs=Dict(
start_pin=Dict(
component=component1,
pin=pin1),
end_pin=Dict(
component=component2,
pin=pin2)),
lead=Dict(
start_straight=start_strght,
end_straight=end_strght
),
total_length=length,
fillet = '99.9um')
myoptions.update(options)
myoptions.meander.asymmetry = asymmetry
myoptions.meander.lead_direction_inverted = 'true' if flip else 'false'
return RouteMeander(design, component_name, myoptions)
asym_h = 100
asym_v = 100
cpw = []
cpw.append(connect('cpw1', 'Q1', 'b', 'Q2', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw3', 'Q4', 'b', 'Q3', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw4', 'Q3', 'd', 'Q1', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw5', 'Q2', 'd', 'Q4', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.terminations.launchpad_wb_coupled import LaunchpadWirebondCoupled
readouts_lwc = []
control_lwc = []
offset_x = 0
offset_y = 1
#Readouts
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R1',
options = dict(
pos_x = '-5mm',
pos_y = f'-{half_chip_height+offset_y}mm',
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R2',
options = dict(
pos_x = '-1mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R3',
options = dict(
pos_x = '1mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R4',
options = dict(
pos_x = '5mm',
pos_y = f'{half_chip_height+offset_y}mm',
orientation = 180,
lead_length = '30um')))
#Controls
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL1',
options = dict(
pos_x = '-5mm',
pos_y = '2mm',
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL2',
options = dict(
pos_x = '4mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL3',
options = dict(
pos_x = '-4mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL4',
options = dict(
pos_x = '5mm',
pos_y = '-2mm',
orientation = 180,
lead_length = '30um')))
gui.rebuild()
gui.autoscale()
readout_lines = []
asym_14 = 700
asym_23 = 700
options = Dict(
lead=Dict(
start_straight='330um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol1', 'Q1', 'c', 'R1', 'tie', '8 mm', f'{asym_14}um'))
options = Dict(
lead=Dict(
start_straight='430um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol2', 'Q2', 'c', 'R2', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol3', 'Q3', 'c', 'R3', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol4', 'Q4', 'c', 'R4', 'tie', '8 mm', f'{asym_14}um'))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.tlines.anchored_path import RouteAnchors
from collections import OrderedDict
import numpy as np
control_lines = []
def connectRouteAnchor(name: str,
component1: str, pin1: str, component2: str, pin2: str,
anchor_points: OrderedDict) -> RouteAnchors:
options_line_cl = dict(
pin_inputs = dict(start_pin = dict(component = component1, pin = pin1),
end_pin = dict(component = component2, pin = pin2)),
anchors = anchor_points,
lead = dict(start_straight = '200um',
end_straight = '225um'),
fillet = fillet
)
return RouteAnchors(design, name, options_line_cl)
anchors1c = OrderedDict()
anchors1c[0] = np.array([-4, -1.42])
anchors1c[1] = np.array([-4, 2])
control_lines.append(connectRouteAnchor('line_cl1', 'Q1', 'Charge_Line', 'CL1', 'tie', anchors1c))
anchors2c = OrderedDict()
anchors2c[0] = np.array([0.08, 3.25])
anchors2c[1] = np.array([4, 3.25])
control_lines.append(connectRouteAnchor('line_cl2', 'Q2', 'Charge_Line', 'CL2', 'tie', anchors2c))
anchors3c = OrderedDict()
anchors3c[0] = np.array([-0.08, -3.25])
anchors3c[1] = np.array([-4, -3.25])
control_lines.append(connectRouteAnchor('line_cl3', 'Q3', 'Charge_Line', 'CL3', 'tie', anchors3c))
anchors4c = OrderedDict()
anchors4c[0] = np.array([4, 1.42])
anchors4c[1] = np.array([4, -2])
control_lines.append(connectRouteAnchor('line_cl4', 'Q4', 'Charge_Line', 'CL4', 'tie', anchors4c))
gui.rebuild()
gui.autoscale()
gui.autoscale()
gui.screenshot(name="full_design")
import numpy as np
from scipy.constants import c, h, pi, hbar, e
from qiskit_metal.analyses.em.cpw_calculations import guided_wavelength
# constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
find_resonator_length(np.around(np.linspace(8, 9.2, 4), 2), 10, 6, 2)
transmons[0].options.pad_gap = '40um'
transmons[0].options.pad_width = '550um' # 405
transmons[0].options.pad_height = '120um'
transmons[1].options.pad_gap = '40um'
transmons[1].options.pad_width = '390um' # 405
transmons[1].options.pad_height = '120um'
transmons[1].options.connection_pads.d.pad_gap='8um'
transmons[1].options.connection_pads.a.pad_gap='8um'
transmons[1].options.connection_pads.c.pad_gap='8um'
transmons[1].options.connection_pads.d.pad_width='140um'
transmons[1].options.connection_pads.a.pad_width='140um'
transmons[1].options.connection_pads.c.pad_width='150um'
transmons[2].options.pad_gap = '40um'
transmons[2].options.pad_width = '460um' # 405
transmons[2].options.pad_height = '120um'
transmons[3].options.pad_gap = '40um'
transmons[3].options.pad_width = '440um' # 405
transmons[3].options.pad_height = '120um'
readout_lines[0].options.total_length = '8.63mm'
readout_lines[1].options.total_length = '8.42mm'
readout_lines[2].options.total_length = '8.24mm'
readout_lines[3].options.total_length = '8.06mm'
cpw[0].options.total_length = '7mm'
cpw[1].options.total_length = '7mm'
cpw[2].options.total_length = '7mm'
cpw[3].options.total_length = '7mm'
gui.rebuild()
gui.autoscale()
qcomps = design.components # short handle (alias)
qcomps['Q1'].options['hfss_inductance'] = 'Lj1'
qcomps['Q1'].options['hfss_capacitance'] = 'Cj1'
qcomps['Q2'].options['hfss_inductance'] = 'Lj2'
qcomps['Q2'].options['hfss_capacitance'] = 'Cj2'
qcomps['Q3'].options['hfss_inductance'] = 'Lj3'
qcomps['Q3'].options['hfss_capacitance'] = 'Cj3'
qcomps['Q4'].options['hfss_inductance'] = 'Lj4'
qcomps['Q4'].options['hfss_capacitance'] = 'Cj4'
from qiskit_metal.analyses.quantization import EPRanalysis, LOManalysis
c1 = LOManalysis(design, "q3d")
q3d1 = c1.sim.renderer
q3d1.start()
q3d1.activate_ansys_design("Q2only_busopen", 'capacitive')
q3d1.render_design(['Q2', 'R2', 'cpw1', 'cpw5', 'ol2', 'line_cl2', 'CL2'], [('cpw5', 'end'),('cpw1', 'start')])
q3d1.add_q3d_setup(name="Setup", max_passes=15, min_converged_passes=5,percent_error=0.05)
q3d1.analyze_setup("Setup")
c1.sim.capacitance_matrix, c1.sim.units = q3d1.get_capacitance_matrix()
c1.sim.capacitance_all_passes, _ = q3d1.get_capacitance_all_passes()
c1.sim.capacitance_matrix
import scqubits as scq
from qiskit_metal.analyses.quantization.lumped_capacitive import load_q3d_capacitance_matrix
from qiskit_metal.analyses.quantization.lom_core_analysis import CompositeSystem, Cell, Subsystem, QuantumSystemRegistry
from scipy.constants import speed_of_light as c_light
import matplotlib.pyplot as plt
%matplotlib inline
# Cell 2: Transmon-2
opt2 = dict(
cap_mat = c1.sim.capacitance_matrix,
ind_dict = {('pad_top_Q2', 'pad_bot_Q2'): 12}, # junction inductance in nH
jj_dict = {('pad_top_Q2', 'pad_bot_Q2'): 'j2'},
cj_dict = {('pad_top_Q2', 'pad_bot_Q2'): 1}, # junction capacitance in fF
)
cell_2 = Cell(opt2)
# subsystem 1: Transmon-2
transmon2 = Subsystem(name='transmon2', sys_type='TRANSMON', nodes=['j2'])
# Resonator Subsystems
q_opts = dict(
Z0 = 50, # characteristic impedance in Ohm
vp = 0.404314 * c_light # phase velocity
)
ro2 = Subsystem(name='c_connector_pad_Q2', sys_type='TL_RESONATOR', nodes=['c_connector_pad_Q2'], q_opts=dict(f_res = 7.22, **q_opts))
coup12 = Subsystem(name='a_connector_pad_Q2', sys_type='TL_RESONATOR', nodes=['a_connector_pad_Q2'], q_opts=dict(f_res = 7.5, **q_opts))
coup24 = Subsystem(name='d_connector_pad_Q2', sys_type='TL_RESONATOR', nodes=['d_connector_pad_Q2'], q_opts=dict(f_res = 7.5, **q_opts))
composite_sys = CompositeSystem(
subsystems=[transmon2, ro2, coup12, coup24],
cells=[cell_2],
grd_node='ground_main_plane',
nodes_force_keep=['c_connector_pad_Q2', 'a_connector_pad_Q2', 'd_connector_pad_Q2']
)
cg = composite_sys.circuitGraph()
print(cg)
hilbertspace = composite_sys.create_hilbertspace()
print(hilbertspace)
hilbertspace = composite_sys.add_interaction()
hilbertspace.hamiltonian()
hamiltonian_results = composite_sys.hamiltonian_results(hilbertspace, evals_count=30)
composite_sys.compute_gs()
transmons[1].options.connection_pads.d.pad_gap
|
https://github.com/WhenTheyCry96/qiskitHackathon2022
|
WhenTheyCry96
|
%load_ext autoreload
%autoreload 2
import os
import warnings
import numpy as np
import pyEPR as epr
import qiskit_metal as metal
from collections import OrderedDict
import scqubits as scq
from scipy.constants import c, h, pi, hbar, e
from qiskit_metal import designs, draw, MetalGUI, Dict, Headings
from qiskit_metal.qlibrary.tlines.meandered import RouteMeander
from qiskit_metal.qlibrary.tlines.anchored_path import RouteAnchors
from qiskit_metal.analyses.quantization import LOManalysis, EPRanalysis
from qiskit_metal.analyses.em.cpw_calculations import guided_wavelength
from qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL
from qiskit_metal.qlibrary.lumped.cap_3_interdigital import Cap3Interdigital
from qiskit_metal.qlibrary.terminations.launchpad_wb_coupled import LaunchpadWirebondCoupled
from qiskit_metal.analyses.quantization.lumped_capacitive import load_q3d_capacitance_matrix
from qiskit_metal.analyses.quantization.lom_core_analysis import CompositeSystem, Cell, Subsystem, QuantumSystemRegistry
ws_path = os.getcwd()
warnings.filterwarnings("ignore")
design = designs.DesignPlanar()
design.overwrite_enabled = True
#constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
design.chips.main.size_x = '12mm'
design.chips.main.size_y = '10mm'
gui = MetalGUI(design)
design.delete_all_components()
design_span_x = 5
design_span_y = 3
half_chip_width = design_span_x / 2
half_chip_height = design_span_y / 2
connection_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
b = dict(loc_W=1, loc_H=1),
c = dict(loc_W=-1, loc_H=-1)
)
connection23_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
c = dict(loc_W=-1, loc_H=-1)
)
transmons = []
transmons.append(TransmonPocketCL(design, 'Q1',
options=dict(pos_x=f'-{half_chip_width}mm',
pos_y=f'{-half_chip_height}mm',
connection_pads=dict(**connection_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q2',
options=dict(pos_x=f'0mm',
pos_y=f'{half_chip_height}mm',
orientation=-90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q3',
options=dict(pos_x=f'0mm',
pos_y=f'{-half_chip_height}mm',
orientation=90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q4',
options=dict(pos_x=f'{half_chip_width}mm',
pos_y=f'{half_chip_height}mm',
orientation=180,
connection_pads=dict(**connection_pads_options))))
gui.rebuild()
gui.autoscale()
fillet='99.99um'
options = Dict(
meander=Dict(
lead_start='0.1mm',
lead_end='0.1mm',
asymmetry='0 um')
)
def connect(component_name: str, component1: str, pin1: str, component2: str, pin2: str,
length: str,
asymmetry='0 um', start_strght='0 um', end_strght='0 um', flip=False):
"""Connect two pins with a CPW."""
myoptions = Dict(
pin_inputs=Dict(
start_pin=Dict(
component=component1,
pin=pin1),
end_pin=Dict(
component=component2,
pin=pin2)),
lead=Dict(
start_straight=start_strght,
end_straight=end_strght
),
total_length=length,
fillet = '99.9um')
myoptions.update(options)
myoptions.meander.asymmetry = asymmetry
myoptions.meander.lead_direction_inverted = 'true' if flip else 'false'
return RouteMeander(design, component_name, myoptions)
asym_h = 100
asym_v = 100
cpw = []
cpw.append(connect('cpw1', 'Q1', 'b', 'Q2', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw3', 'Q4', 'b', 'Q3', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw4', 'Q3', 'd', 'Q1', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw5', 'Q2', 'd', 'Q4', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
gui.rebuild()
gui.autoscale()
readouts_lwc = []
control_lwc = []
offset_x = 0
offset_y = 1
#Readouts
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R1',
options = dict(
pos_x = '-5mm',
pos_y = f'-{half_chip_height+offset_y}mm',
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R2',
options = dict(
pos_x = '-1mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R3',
options = dict(
pos_x = '1mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R4',
options = dict(
pos_x = '5mm',
pos_y = f'{half_chip_height+offset_y}mm',
orientation = 180,
lead_length = '30um')))
#Controls
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL1',
options = dict(
pos_x = '-5mm',
pos_y = '2mm',
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL2',
options = dict(
pos_x = '4mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL3',
options = dict(
pos_x = '-4mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL4',
options = dict(
pos_x = '5mm',
pos_y = '-2mm',
orientation = 180,
lead_length = '30um')))
gui.rebuild()
gui.autoscale()
readout_lines = []
asym_14 = 700
asym_23 = 700
options = Dict(
lead=Dict(
start_straight='330um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol1', 'Q1', 'c', 'R1', 'tie', '8 mm', f'{asym_14}um'))
options = Dict(
lead=Dict(
start_straight='430um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol2', 'Q2', 'c', 'R2', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol3', 'Q3', 'c', 'R3', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol4', 'Q4', 'c', 'R4', 'tie', '8 mm', f'{asym_14}um'))
gui.rebuild()
gui.autoscale()
control_lines = []
def connectRouteAnchor(name: str,
component1: str, pin1: str, component2: str, pin2: str,
anchor_points: OrderedDict) -> RouteAnchors:
options_line_cl = dict(
pin_inputs = dict(start_pin = dict(component = component1, pin = pin1),
end_pin = dict(component = component2, pin = pin2)),
anchors = anchor_points,
lead = dict(start_straight = '200um',
end_straight = '225um'),
fillet = fillet
)
return RouteAnchors(design, name, options_line_cl)
anchors1c = OrderedDict()
anchors1c[0] = np.array([-4, -1.42])
anchors1c[1] = np.array([-4, 2])
control_lines.append(connectRouteAnchor('line_cl1', 'Q1', 'Charge_Line', 'CL1', 'tie', anchors1c))
anchors2c = OrderedDict()
anchors2c[0] = np.array([0.08, 3.25])
anchors2c[1] = np.array([4, 3.25])
control_lines.append(connectRouteAnchor('line_cl2', 'Q2', 'Charge_Line', 'CL2', 'tie', anchors2c))
anchors3c = OrderedDict()
anchors3c[0] = np.array([-0.08, -3.25])
anchors3c[1] = np.array([-4, -3.25])
control_lines.append(connectRouteAnchor('line_cl3', 'Q3', 'Charge_Line', 'CL3', 'tie', anchors3c))
anchors4c = OrderedDict()
anchors4c[0] = np.array([4, 1.42])
anchors4c[1] = np.array([4, -2])
control_lines.append(connectRouteAnchor('line_cl4', 'Q4', 'Charge_Line', 'CL4', 'tie', anchors4c))
gui.rebuild()
gui.autoscale()
gui.screenshot(name="full_design.png")
# constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
# CPW busline length is determined to be 7 mm
cpw[0].options.total_length = '7.0mm'
cpw[1].options.total_length = '7.0mm'
cpw[2].options.total_length = '7.0mm'
cpw[3].options.total_length = '7.0mm'
gui.rebuild()
gui.autoscale()
# qubit 1 design target f: 5.25 GHz
# readout resonator target f: 7.05 GHz
# qubit 2 design target f: 5.42 GHz
# readout resonator target f: 7.22 GHz
# qubit 3 design target f: 5.58 GHz
# readout resonator target f: 7.38 GHz
# qubit 4 design target f: 5.75 GHz
# readout resonator target f: 7.55 GHz
# tuning parameters
C_JJ4f = 2
L_JJ4f = 9.8
C_JJ4 = str(C_JJ4f)+' fF'
L_JJ4 = str(L_JJ4f)+' nH'
transmons[3].options.pad_gap = '35um'
transmons[3].options.pad_width = '510um'
transmons[3].options.pad_height = '125um'
transmons[3].options.connection_pads.c.pad_gap = '30um'
transmons[3].options.connection_pads.a.pad_gap = '15um' # cpw5
transmons[3].options.connection_pads.a.pad_width = '40um' # cpw5
transmons[3].options.connection_pads.b.pad_gap = '15um' # cpw3
transmons[3].options.connection_pads.b.pad_width = '40um' # cpw3
readout_lines[3].options.total_length = '7.5mm'
gui.rebuild()
gui.autoscale()
# EPR analysis
eig_q4 = EPRanalysis(design, "hfss")
hfss4 = eig_q4.sim.renderer
hfss4.start()
hfss4.activate_ansys_design("TransmonQ4", 'eigenmode')
hfss4.render_design(['Q4', 'ol4', 'cpw3', 'cpw5'], [('cpw3', 'end'), ('cpw5', 'start'), ('ol4', 'end')])
# Analysis properties
setup4 = hfss4.pinfo.setup
setup4.n_modes = 6
setup4.passes = 10
setup4.min_freq_ghz = 4
print(f"""
Number of eigenmodes to find = {setup4.n_modes}
Number of simulation passes = {setup4.passes}
Convergence freq max delta percent diff = {setup4.delta_f}
""")
pinfo4 = hfss4.pinfo
pinfo4.design.set_variable('Lj4', L_JJ4)
pinfo4.design.set_variable('Cj4', C_JJ4)
setup4.analyze()
eig_q4.sim.convergence_t, eig_q4.sim.convergence_f, _ = hfss4.get_convergences()
eig_q4.sim.plot_convergences()
pinfo4.junctions['jj'] = {'Lj_variable': 'Lj4', 'rect': 'JJ_rect_Lj_Q4_rect_jj',
'line': 'JJ_Lj_Q4_rect_jj_', 'Cj_variable': 'Cj4'}
pinfo4.validate_junction_info()
pinfo4.dissipative['dielectrics_bulk'] = ['main']
hfss4.set_mode(1, "Setup")
hfss4.modeler._modeler.ShowWindow()
hfss4.plot_fields('main')
eprd4 = epr.DistributedAnalysis(pinfo4)
ℰ_elec = eprd4.calc_energy_electric()
ℰ_elec_substrate = eprd4.calc_energy_electric(None, 'main')
ℰ_mag = eprd4.calc_energy_magnetic()
print(f"""
ℰ_elec_all = {ℰ_elec}
ℰ_elec_substrate = {ℰ_elec_substrate}
EPR of substrate = {ℰ_elec_substrate / ℰ_elec * 100 :.1f}%
ℰ_mag_all = {ℰ_mag}
ℰ_mag % of ℰ_elec_all = {ℰ_mag / ℰ_elec * 100 :.1f}%
""")
eprd4.do_EPR_analysis()
#epra4 = epr.QuantumAnalysis(eprd4.data_filename)
#epra4.analyze_all_variations(cos_trunc = 8, fock_trunc = 7)
c4 = LOManalysis(design, "q3d")
q3d4 = c4.sim.renderer
q3d4.start()
q3d4.activate_ansys_design("TransmonQ4_q3d", 'capacitive')
q3d4.render_design(['Q4'], [('Q4', 'a'),('Q4', 'b'),('Q4', 'c')])
q3d4.add_q3d_setup(name="Setup", max_passes=15, min_converged_passes=5, percent_error=0.1)
q3d4.analyze_setup("Setup")
c4.sim.capacitance_matrix, c4.sim.units = q3d4.get_capacitance_matrix()
c4.sim.capacitance_all_passes, _ = q3d4.get_capacitance_all_passes()
c4.sim.capacitance_matrix
c4.setup.junctions = Dict({'Lj':L_JJ4f, 'Cj':C_JJ4f})
c4.setup.freq_readout = 7.45
c4.setup.freq_bus = [8.25, 8.25, 15]
c4.run_lom()
c4.lumped_oscillator_all
QuantumSystemRegistry.registry()
# Q4
path4= ws_path+"/Project71_TransmonQ4_q3d.txt"
t4_mat, _, _, _ = load_q3d_capacitance_matrix(path4)
# Cell 4 Transmon-4
opt4 = dict(
node_rename = {'a_connector_pad_Q4': 'cpw5',
'b_connector_pad_Q4': 'cpw3',
'c_connector_pad_Q4': 'readout4'},
cap_mat = t4_mat,
ind_dict = {('pad_top_Q4', 'pad_bot_Q4'): L_JJ4f}, # junction inductance in nH
jj_dict = {('pad_top_Q4', 'pad_bot_Q4'): 'j4'},
cj_dict = {('pad_top_Q4', 'pad_bot_Q4'): C_JJ4f} # junction capacitance in fF
)
cell_4 = Cell(opt4)
# subsystem 1: Transmon-4
transmon4 = Subsystem(name='transmon4', sys_type='TRANSMON', nodes=['j4'])
# Resonator Subsystems
q_opts = dict(
Z0 = 50, # characteristic impedance in Ohm
vp = 0.404314 * 3e8 # phase velocity
)
# subsystem 3: Q2 readout resonator
ro4 = Subsystem(name='readout4', sys_type='TL_RESONATOR', nodes=['readout4'], q_opts=dict(f_res = 7.57, **q_opts))
# subsystem 4: bus3 resonator
cpw3 = Subsystem(name='cpw3', sys_type='TL_RESONATOR', nodes=['cpw3'], q_opts=dict(f_res = 8.2, **q_opts))
# subsystem 15: bus5 resonator
cpw5 = Subsystem(name='cpw5', sys_type='TL_RESONATOR', nodes=['cpw5'], q_opts=dict(f_res = 8.29, **q_opts))
composite_sys = CompositeSystem(
subsystems=[transmon4, ro4, cpw3, cpw5],
cells=[cell_4],
grd_node='ground_main_plane',
nodes_force_keep=['readout4', 'cpw3', 'cpw5']
)
cg = composite_sys.circuitGraph()
print(cg)
hilbertspace = composite_sys.create_hilbertspace()
print(hilbertspace)
# Convert the hilbert space into
# "Interaction Picture"
hilbertspace = composite_sys.add_interaction()
hilbertspace.hamiltonian()
hamiltonian_results = composite_sys.hamiltonian_results(hilbertspace, evals_count=30)
composite_sys.compute_gs()
|
https://github.com/WhenTheyCry96/qiskitHackathon2022
|
WhenTheyCry96
|
%load_ext autoreload
%autoreload 2
import os
import warnings
import numpy as np
import pyEPR as epr
import qiskit_metal as metal
from collections import OrderedDict
import scqubits as scq
from scipy.constants import c, h, pi, hbar, e
from qiskit_metal import designs, draw, MetalGUI, Dict, Headings
from qiskit_metal.qlibrary.tlines.meandered import RouteMeander
from qiskit_metal.qlibrary.tlines.anchored_path import RouteAnchors
from qiskit_metal.analyses.quantization import LOManalysis, EPRanalysis
from qiskit_metal.analyses.em.cpw_calculations import guided_wavelength
from qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL
from qiskit_metal.qlibrary.lumped.cap_3_interdigital import Cap3Interdigital
from qiskit_metal.qlibrary.terminations.launchpad_wb_coupled import LaunchpadWirebondCoupled
from qiskit_metal.analyses.quantization.lumped_capacitive import load_q3d_capacitance_matrix
from qiskit_metal.analyses.quantization.lom_core_analysis import CompositeSystem, Cell, Subsystem, QuantumSystemRegistry
ws_path = os.getcwd()
warnings.filterwarnings("ignore")
design = designs.DesignPlanar()
design.overwrite_enabled = True
#constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
design.chips.main.size_x = '12mm'
design.chips.main.size_y = '10mm'
gui = MetalGUI(design)
design.delete_all_components()
design_span_x = 5
design_span_y = 3
half_chip_width = design_span_x / 2
half_chip_height = design_span_y / 2
connection_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
b = dict(loc_W=1, loc_H=1),
c = dict(loc_W=-1, loc_H=-1)
)
connection23_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
c = dict(loc_W=-1, loc_H=-1)
)
transmons = []
transmons.append(TransmonPocketCL(design, 'Q1',
options=dict(pos_x=f'-{half_chip_width}mm',
pos_y=f'{-half_chip_height}mm',
connection_pads=dict(**connection_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q2',
options=dict(pos_x=f'0mm',
pos_y=f'{half_chip_height}mm',
orientation=-90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q3',
options=dict(pos_x=f'0mm',
pos_y=f'{-half_chip_height}mm',
orientation=90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q4',
options=dict(pos_x=f'{half_chip_width}mm',
pos_y=f'{half_chip_height}mm',
orientation=180,
connection_pads=dict(**connection_pads_options))))
gui.rebuild()
gui.autoscale()
fillet='99.99um'
options = Dict(
meander=Dict(
lead_start='0.1mm',
lead_end='0.1mm',
asymmetry='0 um')
)
def connect(component_name: str, component1: str, pin1: str, component2: str, pin2: str,
length: str,
asymmetry='0 um', start_strght='0 um', end_strght='0 um', flip=False):
"""Connect two pins with a CPW."""
myoptions = Dict(
pin_inputs=Dict(
start_pin=Dict(
component=component1,
pin=pin1),
end_pin=Dict(
component=component2,
pin=pin2)),
lead=Dict(
start_straight=start_strght,
end_straight=end_strght
),
total_length=length,
fillet = '99.9um')
myoptions.update(options)
myoptions.meander.asymmetry = asymmetry
myoptions.meander.lead_direction_inverted = 'true' if flip else 'false'
return RouteMeander(design, component_name, myoptions)
asym_h = 100
asym_v = 100
cpw = []
cpw.append(connect('cpw1', 'Q1', 'b', 'Q2', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw3', 'Q4', 'b', 'Q3', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw4', 'Q3', 'd', 'Q1', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw5', 'Q2', 'd', 'Q4', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
gui.rebuild()
gui.autoscale()
readouts_lwc = []
control_lwc = []
offset_x = 0
offset_y = 1
#Readouts
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R1',
options = dict(
pos_x = '-5mm',
pos_y = f'-{half_chip_height+offset_y}mm',
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R2',
options = dict(
pos_x = '-1mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R3',
options = dict(
pos_x = '1mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R4',
options = dict(
pos_x = '5mm',
pos_y = f'{half_chip_height+offset_y}mm',
orientation = 180,
lead_length = '30um')))
#Controls
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL1',
options = dict(
pos_x = '-5mm',
pos_y = '2mm',
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL2',
options = dict(
pos_x = '4mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL3',
options = dict(
pos_x = '-4mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL4',
options = dict(
pos_x = '5mm',
pos_y = '-2mm',
orientation = 180,
lead_length = '30um')))
gui.rebuild()
gui.autoscale()
readout_lines = []
asym_14 = 700
asym_23 = 700
options = Dict(
lead=Dict(
start_straight='330um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol1', 'Q1', 'c', 'R1', 'tie', '8 mm', f'{asym_14}um'))
options = Dict(
lead=Dict(
start_straight='430um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol2', 'Q2', 'c', 'R2', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol3', 'Q3', 'c', 'R3', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol4', 'Q4', 'c', 'R4', 'tie', '8 mm', f'{asym_14}um'))
gui.rebuild()
gui.autoscale()
control_lines = []
def connectRouteAnchor(name: str,
component1: str, pin1: str, component2: str, pin2: str,
anchor_points: OrderedDict) -> RouteAnchors:
options_line_cl = dict(
pin_inputs = dict(start_pin = dict(component = component1, pin = pin1),
end_pin = dict(component = component2, pin = pin2)),
anchors = anchor_points,
lead = dict(start_straight = '200um',
end_straight = '225um'),
fillet = fillet
)
return RouteAnchors(design, name, options_line_cl)
anchors1c = OrderedDict()
anchors1c[0] = np.array([-4, -1.42])
anchors1c[1] = np.array([-4, 2])
control_lines.append(connectRouteAnchor('line_cl1', 'Q1', 'Charge_Line', 'CL1', 'tie', anchors1c))
anchors2c = OrderedDict()
anchors2c[0] = np.array([0.08, 3.25])
anchors2c[1] = np.array([4, 3.25])
control_lines.append(connectRouteAnchor('line_cl2', 'Q2', 'Charge_Line', 'CL2', 'tie', anchors2c))
anchors3c = OrderedDict()
anchors3c[0] = np.array([-0.08, -3.25])
anchors3c[1] = np.array([-4, -3.25])
control_lines.append(connectRouteAnchor('line_cl3', 'Q3', 'Charge_Line', 'CL3', 'tie', anchors3c))
anchors4c = OrderedDict()
anchors4c[0] = np.array([4, 1.42])
anchors4c[1] = np.array([4, -2])
control_lines.append(connectRouteAnchor('line_cl4', 'Q4', 'Charge_Line', 'CL4', 'tie', anchors4c))
gui.rebuild()
gui.autoscale()
gui.screenshot(name="full_design.png")
# constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
# CPW busline length is determined to be 7 mm
cpw[0].options.total_length = '7.0mm'
cpw[1].options.total_length = '7.0mm'
cpw[2].options.total_length = '7.0mm'
cpw[3].options.total_length = '7.0mm'
gui.rebuild()
gui.autoscale()
# qubit 1 design target f: 5.25 GHz
# readout resonator target f: 7.05 GHz
transmons[0].options.pad_gap = '40um'
transmons[0].options.pad_width = '550um' # 405
transmons[0].options.pad_height = '120um'
readout_lines[3].options.total_length = '11.2mm'
# qubit 2 design target f: 5.42 GHz
# readout resonator target f: 7.22 GHz
transmons[1].options.pad_gap = '40um'
transmons[1].options.pad_width = '390um' # 405
transmons[1].options.pad_height = '120um'
transmons[1].options.connection_pads.d.pad_gap='8um'
transmons[1].options.connection_pads.a.pad_gap='8um'
transmons[1].options.connection_pads.c.pad_gap='8um'
transmons[1].options.connection_pads.d.pad_width='140um'
transmons[1].options.connection_pads.a.pad_width='140um'
transmons[1].options.connection_pads.c.pad_width='150um'
from qiskit_metal.analyses.quantization import EPRanalysis, LOManalysis
c1 = LOManalysis(design, "q3d")
q3d1 = c1.sim.renderer
q3d1.start()
q3d1.activate_ansys_design("Q2only_busopen", 'capacitive')
q3d1.render_design(['Q2', 'R2', 'cpw1', 'cpw5', 'ol2', 'line_cl2', 'CL2'], [('cpw5', 'end'),('cpw1', 'start')])
q3d1.add_q3d_setup(name="Setup", max_passes=15, min_converged_passes=5,percent_error=0.05)
q3d1.analyze_setup("Setup")
c1.sim.capacitance_matrix, c1.sim.units = q3d1.get_capacitance_matrix()
c1.sim.capacitance_all_passes, _ = q3d1.get_capacitance_all_passes()
c1.sim.capacitance_matrix
import scqubits as scq
from qiskit_metal.analyses.quantization.lumped_capacitive import load_q3d_capacitance_matrix
from qiskit_metal.analyses.quantization.lom_core_analysis import CompositeSystem, Cell, Subsystem, QuantumSystemRegistry
from scipy.constants import speed_of_light as c_light
import matplotlib.pyplot as plt
%matplotlib inline
# Cell 2: Transmon-2
opt2 = dict(
cap_mat = c1.sim.capacitance_matrix,
ind_dict = {('pad_top_Q2', 'pad_bot_Q2'): 12}, # junction inductance in nH
jj_dict = {('pad_top_Q2', 'pad_bot_Q2'): 'j2'},
cj_dict = {('pad_top_Q2', 'pad_bot_Q2'): 1}, # junction capacitance in fF
)
cell_2 = Cell(opt2)
# subsystem 1: Transmon-2
transmon2 = Subsystem(name='transmon2', sys_type='TRANSMON', nodes=['j2'])
# Resonator Subsystems
q_opts = dict(
Z0 = 50, # characteristic impedance in Ohm
vp = 0.404314 * c_light # phase velocity
)
ro2 = Subsystem(name='c_connector_pad_Q2', sys_type='TL_RESONATOR', nodes=['c_connector_pad_Q2'], q_opts=dict(f_res = 7.22, **q_opts))
coup12 = Subsystem(name='a_connector_pad_Q2', sys_type='TL_RESONATOR', nodes=['a_connector_pad_Q2'], q_opts=dict(f_res = 7.5, **q_opts))
coup24 = Subsystem(name='d_connector_pad_Q2', sys_type='TL_RESONATOR', nodes=['d_connector_pad_Q2'], q_opts=dict(f_res = 7.5, **q_opts))
composite_sys = CompositeSystem(
subsystems=[transmon2, ro2, coup12, coup24],
cells=[cell_2],
grd_node='ground_main_plane',
nodes_force_keep=['c_connector_pad_Q2', 'a_connector_pad_Q2', 'd_connector_pad_Q2']
)
cg = composite_sys.circuitGraph()
print(cg)
hilbertspace = composite_sys.create_hilbertspace()
print(hilbertspace)
hilbertspace = composite_sys.add_interaction()
hilbertspace.hamiltonian()
hamiltonian_results = composite_sys.hamiltonian_results(hilbertspace, evals_count=30)
composite_sys.compute_gs()
transmons[1].options.connection_pads.d.pad_gap
# qubit 3 design target f: 5.58 GHz
# readout resonator target f: 7.38 GHz
transmons[2].options.pad_gap = '40um'
transmons[2].options.pad_width = '370um' # 405
transmons[2].options.pad_height = '120um'
transmons[2].options.connection_pads.d.pad_gap='10um'
transmons[2].options.connection_pads.a.pad_gap='10um'
transmons[2].options.connection_pads.c.pad_gap='10um'
from qiskit_metal.analyses.quantization import EPRanalysis, LOManalysis
from qiskit_metal.analyses.quantization.lumped_capacitive import load_q3d_capacitance_matrix
from qiskit_metal.analyses.quantization.lom_core_analysis import CompositeSystem, Cell, Subsystem, QuantumSystemRegistry
c1 = LOManalysis(design, "q3d")
q3d1 = c1.sim.renderer
q3d1.start()
q3d1.activate_ansys_design("Q3only_busopen_370_gap_reduced", 'capacitive')
q3d1.render_design(['Q3', 'R3', 'cpw3', 'cpw4', 'ol3', 'line_cl3', 'CL3'], [('cpw3', 'start'),('cpw4', 'end')])
q3d1.add_q3d_setup(name="Setup", max_passes=15, min_converged_passes=5,percent_error=0.05)
q3d1.analyze_setup("Setup")
c1.sim.capacitance_matrix, c1.sim.units = q3d1.get_capacitance_matrix()
c1.sim.capacitance_all_passes, _ = q3d1.get_capacitance_all_passes()
c1.sim.capacitance_matrix
path3 = "./capacitance_matrices/Project19_Q3only_busopen_460.txt"
t3_mat, _, _, _ = load_q3d_capacitance_matrix(path3)
t3_mat
opt3 = dict(
cap_mat = t3_mat,
ind_dict = {('pad_top_Q3', 'pad_bot_Q3'): 12}, # junction inductance in nH
jj_dict = {('pad_top_Q3', 'pad_bot_Q3'): 'j3'},
cj_dict = {('pad_top_Q3', 'pad_bot_Q3'): 1}, # junction capacitance in fF
)
cell_3 = Cell(opt3)
transmon3 = Subsystem(name='transmon3', sys_type='TRANSMON', nodes=['j3'])
# Resonator Subsystems
from scipy.constants import speed_of_light as c_light
q_opts = dict(
Z0 = 50, # characteristic impedance in Ohm
vp = 0.404314 * c_light # phase velocity
)
ro3 = Subsystem(name='c_connector_pad_Q3', sys_type='TL_RESONATOR', nodes=['c_connector_pad_Q3'], q_opts=dict(f_res = 7.38, **q_opts))
coup34 = Subsystem(name='a_connector_pad_Q3', sys_type='TL_RESONATOR', nodes=['a_connector_pad_Q3'], q_opts=dict(f_res = 7.5, **q_opts))
coup31 = Subsystem(name='d_connector_pad_Q3', sys_type='TL_RESONATOR', nodes=['d_connector_pad_Q3'], q_opts=dict(f_res = 7.5, **q_opts))
composite_sys = CompositeSystem(
subsystems=[transmon3, ro3, coup34, coup31],
cells=[cell_3],
grd_node='ground_main_plane',
nodes_force_keep=['c_connector_pad_Q3', 'a_connector_pad_Q3', 'd_connector_pad_Q3']
)
cg = composite_sys.circuitGraph()
print(cg)
hilbertspace = composite_sys.create_hilbertspace()
print(hilbertspace)
# Convert the hilbert space into
# "Interaction Picture"
hilbertspace = composite_sys.add_interaction()
hilbertspace.hamiltonian()
t3_mat = c1.sim.capacitance_matrix
# qubit 4 design target f: 5.75 GHz
# readout resonator target f: 7.55 GHz
# tuning parameters
C_JJ4f = 2
L_JJ4f = 9.8
C_JJ4 = str(C_JJ4f)+' fF'
L_JJ4 = str(L_JJ4f)+' nH'
transmons[3].options.pad_gap = '35um'
transmons[3].options.pad_width = '510um'
transmons[3].options.pad_height = '125um'
transmons[3].options.connection_pads.c.pad_gap = '30um'
transmons[3].options.connection_pads.a.pad_gap = '15um' # cpw5
transmons[3].options.connection_pads.a.pad_width = '40um' # cpw5
transmons[3].options.connection_pads.b.pad_gap = '15um' # cpw3
transmons[3].options.connection_pads.b.pad_width = '40um' # cpw3
readout_lines[3].options.total_length = '7.5mm'
gui.rebuild()
gui.autoscale()
# EPR analysis
eig_q4 = EPRanalysis(design, "hfss")
hfss4 = eig_q4.sim.renderer
hfss4.start()
hfss4.activate_ansys_design("TransmonQ4", 'eigenmode')
hfss4.render_design(['Q4', 'ol4', 'cpw3', 'cpw5'], [('cpw3', 'end'), ('cpw5', 'start'), ('ol4', 'end')])
# Analysis properties
setup4 = hfss4.pinfo.setup
setup4.n_modes = 6
setup4.passes = 10
setup4.min_freq_ghz = 4
print(f"""
Number of eigenmodes to find = {setup4.n_modes}
Number of simulation passes = {setup4.passes}
Convergence freq max delta percent diff = {setup4.delta_f}
""")
pinfo4 = hfss4.pinfo
pinfo4.design.set_variable('Lj4', L_JJ4)
pinfo4.design.set_variable('Cj4', C_JJ4)
setup4.analyze()
eig_q4.sim.convergence_t, eig_q4.sim.convergence_f, _ = hfss4.get_convergences()
eig_q4.sim.plot_convergences()
pinfo4.junctions['jj'] = {'Lj_variable': 'Lj4', 'rect': 'JJ_rect_Lj_Q4_rect_jj',
'line': 'JJ_Lj_Q4_rect_jj_', 'Cj_variable': 'Cj4'}
pinfo4.validate_junction_info()
pinfo4.dissipative['dielectrics_bulk'] = ['main']
hfss4.set_mode(1, "Setup")
hfss4.modeler._modeler.ShowWindow()
hfss4.plot_fields('main')
eprd4 = epr.DistributedAnalysis(pinfo4)
ℰ_elec = eprd4.calc_energy_electric()
ℰ_elec_substrate = eprd4.calc_energy_electric(None, 'main')
ℰ_mag = eprd4.calc_energy_magnetic()
print(f"""
ℰ_elec_all = {ℰ_elec}
ℰ_elec_substrate = {ℰ_elec_substrate}
EPR of substrate = {ℰ_elec_substrate / ℰ_elec * 100 :.1f}%
ℰ_mag_all = {ℰ_mag}
ℰ_mag % of ℰ_elec_all = {ℰ_mag / ℰ_elec * 100 :.1f}%
""")
eprd4.do_EPR_analysis()
#epra4 = epr.QuantumAnalysis(eprd4.data_filename)
#epra4.analyze_all_variations(cos_trunc = 8, fock_trunc = 7)
c4 = LOManalysis(design, "q3d")
q3d4 = c4.sim.renderer
q3d4.start()
q3d4.activate_ansys_design("TransmonQ4_q3d", 'capacitive')
q3d4.render_design(['Q4'], [('Q4', 'a'),('Q4', 'b'),('Q4', 'c')])
q3d4.add_q3d_setup(name="Setup", max_passes=15, min_converged_passes=5, percent_error=0.1)
q3d4.analyze_setup("Setup")
c4.sim.capacitance_matrix, c4.sim.units = q3d4.get_capacitance_matrix()
c4.sim.capacitance_all_passes, _ = q3d4.get_capacitance_all_passes()
c4.sim.capacitance_matrix
c4.setup.junctions = Dict({'Lj':L_JJ4f, 'Cj':C_JJ4f})
c4.setup.freq_readout = 7.45
c4.setup.freq_bus = [8.25, 8.25, 15]
c4.run_lom()
c4.lumped_oscillator_all
QuantumSystemRegistry.registry()
# Q4
path4= ws_path+"/Project71_TransmonQ4_q3d.txt"
t4_mat, _, _, _ = load_q3d_capacitance_matrix(path4)
# Cell 4 Transmon-4
opt4 = dict(
node_rename = {'a_connector_pad_Q4': 'cpw5',
'b_connector_pad_Q4': 'cpw3',
'c_connector_pad_Q4': 'readout4'},
cap_mat = t4_mat,
ind_dict = {('pad_top_Q4', 'pad_bot_Q4'): L_JJ4f}, # junction inductance in nH
jj_dict = {('pad_top_Q4', 'pad_bot_Q4'): 'j4'},
cj_dict = {('pad_top_Q4', 'pad_bot_Q4'): C_JJ4f} # junction capacitance in fF
)
cell_4 = Cell(opt4)
# subsystem 1: Transmon-4
transmon4 = Subsystem(name='transmon4', sys_type='TRANSMON', nodes=['j4'])
# Resonator Subsystems
q_opts = dict(
Z0 = 50, # characteristic impedance in Ohm
vp = 0.404314 * 3e8 # phase velocity
)
# subsystem 3: Q2 readout resonator
ro4 = Subsystem(name='readout4', sys_type='TL_RESONATOR', nodes=['readout4'], q_opts=dict(f_res = 7.57, **q_opts))
# subsystem 4: bus3 resonator
cpw3 = Subsystem(name='cpw3', sys_type='TL_RESONATOR', nodes=['cpw3'], q_opts=dict(f_res = 8.2, **q_opts))
# subsystem 15: bus5 resonator
cpw5 = Subsystem(name='cpw5', sys_type='TL_RESONATOR', nodes=['cpw5'], q_opts=dict(f_res = 8.29, **q_opts))
composite_sys = CompositeSystem(
subsystems=[transmon4, ro4, cpw3, cpw5],
cells=[cell_4],
grd_node='ground_main_plane',
nodes_force_keep=['readout4', 'cpw3', 'cpw5']
)
cg = composite_sys.circuitGraph()
print(cg)
hilbertspace = composite_sys.create_hilbertspace()
print(hilbertspace)
# Convert the hilbert space into
# "Interaction Picture"
hilbertspace = composite_sys.add_interaction()
hilbertspace.hamiltonian()
hamiltonian_results = composite_sys.hamiltonian_results(hilbertspace, evals_count=30)
composite_sys.compute_gs()
|
https://github.com/WhenTheyCry96/qiskitHackathon2022
|
WhenTheyCry96
|
%load_ext autoreload
%autoreload 2
import os
import warnings
import numpy as np
import pyEPR as epr
import qiskit_metal as metal
from collections import OrderedDict
import scqubits as scq
from scipy.constants import c, h, pi, hbar, e
from qiskit_metal import designs, draw, MetalGUI, Dict, Headings
from qiskit_metal.qlibrary.tlines.meandered import RouteMeander
from qiskit_metal.qlibrary.tlines.anchored_path import RouteAnchors
from qiskit_metal.analyses.quantization import LOManalysis, EPRanalysis
from qiskit_metal.analyses.em.cpw_calculations import guided_wavelength
from qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL
from qiskit_metal.qlibrary.lumped.cap_3_interdigital import Cap3Interdigital
from qiskit_metal.qlibrary.terminations.launchpad_wb_coupled import LaunchpadWirebondCoupled
from qiskit_metal.analyses.quantization.lumped_capacitive import load_q3d_capacitance_matrix
from qiskit_metal.analyses.quantization.lom_core_analysis import CompositeSystem, Cell, Subsystem, QuantumSystemRegistry
ws_path = os.getcwd()
warnings.filterwarnings("ignore")
design = designs.DesignPlanar()
design.overwrite_enabled = True
#constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
design.chips.main.size_x = '12mm'
design.chips.main.size_y = '10mm'
gui = MetalGUI(design)
design.delete_all_components()
design_span_x = 5
design_span_y = 3
half_chip_width = design_span_x / 2
half_chip_height = design_span_y / 2
connection_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
b = dict(loc_W=1, loc_H=1),
c = dict(loc_W=-1, loc_H=-1)
)
connection23_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
c = dict(loc_W=-1, loc_H=-1)
)
transmons = []
transmons.append(TransmonPocketCL(design, 'Q1',
options=dict(pos_x=f'-{half_chip_width}mm',
pos_y=f'{-half_chip_height}mm',
connection_pads=dict(**connection_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q2',
options=dict(pos_x=f'0mm',
pos_y=f'{half_chip_height}mm',
orientation=-90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q3',
options=dict(pos_x=f'0mm',
pos_y=f'{-half_chip_height}mm',
orientation=90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q4',
options=dict(pos_x=f'{half_chip_width}mm',
pos_y=f'{half_chip_height}mm',
orientation=180,
connection_pads=dict(**connection_pads_options))))
gui.rebuild()
gui.autoscale()
fillet='99.99um'
options = Dict(
meander=Dict(
lead_start='0.1mm',
lead_end='0.1mm',
asymmetry='0 um')
)
def connect(component_name: str, component1: str, pin1: str, component2: str, pin2: str,
length: str,
asymmetry='0 um', start_strght='0 um', end_strght='0 um', flip=False):
"""Connect two pins with a CPW."""
myoptions = Dict(
pin_inputs=Dict(
start_pin=Dict(
component=component1,
pin=pin1),
end_pin=Dict(
component=component2,
pin=pin2)),
lead=Dict(
start_straight=start_strght,
end_straight=end_strght
),
total_length=length,
fillet = '99.9um')
myoptions.update(options)
myoptions.meander.asymmetry = asymmetry
myoptions.meander.lead_direction_inverted = 'true' if flip else 'false'
return RouteMeander(design, component_name, myoptions)
asym_h = 100
asym_v = 100
cpw = []
cpw.append(connect('cpw1', 'Q1', 'b', 'Q2', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw3', 'Q4', 'b', 'Q3', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw4', 'Q3', 'd', 'Q1', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw5', 'Q2', 'd', 'Q4', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
gui.rebuild()
gui.autoscale()
readouts_lwc = []
control_lwc = []
offset_x = 0
offset_y = 1
#Readouts
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R1',
options = dict(
pos_x = '-5mm',
pos_y = f'-{half_chip_height+offset_y}mm',
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R2',
options = dict(
pos_x = '-1mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R3',
options = dict(
pos_x = '1mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R4',
options = dict(
pos_x = '5mm',
pos_y = f'{half_chip_height+offset_y}mm',
orientation = 180,
lead_length = '30um')))
#Controls
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL1',
options = dict(
pos_x = '-5mm',
pos_y = '2mm',
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL2',
options = dict(
pos_x = '4mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL3',
options = dict(
pos_x = '-4mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL4',
options = dict(
pos_x = '5mm',
pos_y = '-2mm',
orientation = 180,
lead_length = '30um')))
gui.rebuild()
gui.autoscale()
readout_lines = []
asym_14 = 700
asym_23 = 700
options = Dict(
lead=Dict(
start_straight='330um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol1', 'Q1', 'c', 'R1', 'tie', '8 mm', f'{asym_14}um'))
options = Dict(
lead=Dict(
start_straight='430um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol2', 'Q2', 'c', 'R2', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol3', 'Q3', 'c', 'R3', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol4', 'Q4', 'c', 'R4', 'tie', '8 mm', f'{asym_14}um'))
gui.rebuild()
gui.autoscale()
control_lines = []
def connectRouteAnchor(name: str,
component1: str, pin1: str, component2: str, pin2: str,
anchor_points: OrderedDict) -> RouteAnchors:
options_line_cl = dict(
pin_inputs = dict(start_pin = dict(component = component1, pin = pin1),
end_pin = dict(component = component2, pin = pin2)),
anchors = anchor_points,
lead = dict(start_straight = '200um',
end_straight = '225um'),
fillet = fillet
)
return RouteAnchors(design, name, options_line_cl)
anchors1c = OrderedDict()
anchors1c[0] = np.array([-4, -1.42])
anchors1c[1] = np.array([-4, 2])
control_lines.append(connectRouteAnchor('line_cl1', 'Q1', 'Charge_Line', 'CL1', 'tie', anchors1c))
anchors2c = OrderedDict()
anchors2c[0] = np.array([0.08, 3.25])
anchors2c[1] = np.array([4, 3.25])
control_lines.append(connectRouteAnchor('line_cl2', 'Q2', 'Charge_Line', 'CL2', 'tie', anchors2c))
anchors3c = OrderedDict()
anchors3c[0] = np.array([-0.08, -3.25])
anchors3c[1] = np.array([-4, -3.25])
control_lines.append(connectRouteAnchor('line_cl3', 'Q3', 'Charge_Line', 'CL3', 'tie', anchors3c))
anchors4c = OrderedDict()
anchors4c[0] = np.array([4, 1.42])
anchors4c[1] = np.array([4, -2])
control_lines.append(connectRouteAnchor('line_cl4', 'Q4', 'Charge_Line', 'CL4', 'tie', anchors4c))
gui.rebuild()
gui.autoscale()
gui.screenshot(name="full_design.png")
# constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
# CPW busline length is determined to be 7 mm
cpw[0].options.total_length = '7.0mm'
cpw[1].options.total_length = '7.0mm'
cpw[2].options.total_length = '7.0mm'
cpw[3].options.total_length = '7.0mm'
gui.rebuild()
gui.autoscale()
# qubit 1 design target f: 5.25 GHz
# readout resonator target f: 7.05 GHz
# qubit 2 design target f: 5.42 GHz
# readout resonator target f: 7.22 GHz
transmons[1].options.pad_gap = '40um'
transmons[1].options.pad_width = '390um' # 405
transmons[1].options.pad_height = '120um'
transmons[1].options.connection_pads.d.pad_gap='8um'
transmons[1].options.connection_pads.a.pad_gap='8um'
transmons[1].options.connection_pads.c.pad_gap='8um'
transmons[1].options.connection_pads.d.pad_width='140um'
transmons[1].options.connection_pads.a.pad_width='140um'
transmons[1].options.connection_pads.c.pad_width='150um'
transmons[1].options.connection_pads.d.pad_gap
# qubit 3 design target f: 5.58 GHz
# readout resonator target f: 7.38 GHz
transmons[2].options.pad_gap = '40um'
transmons[2].options.pad_width = '370um' # 405
transmons[2].options.pad_height = '120um'
transmons[2].options.connection_pads.d.pad_gap='10um'
transmons[2].options.connection_pads.a.pad_gap='10um'
transmons[2].options.connection_pads.c.pad_gap='10um'
# qubit 4 design target f: 5.75 GHz
# readout resonator target f: 7.55 GHz
# tuning parameters
C_JJ4f = 2
L_JJ4f = 9.8
C_JJ4 = str(C_JJ4f)+' fF'
L_JJ4 = str(L_JJ4f)+' nH'
transmons[3].options.pad_gap = '35um'
transmons[3].options.pad_width = '510um'
transmons[3].options.pad_height = '125um'
transmons[3].options.connection_pads.c.pad_gap = '30um'
transmons[3].options.connection_pads.a.pad_gap = '15um' # cpw5
transmons[3].options.connection_pads.a.pad_width = '40um' # cpw5
transmons[3].options.connection_pads.b.pad_gap = '15um' # cpw3
transmons[3].options.connection_pads.b.pad_width = '40um' # cpw3
readout_lines[3].options.total_length = '7.5mm'
gui.rebuild()
gui.autoscale()
|
https://github.com/jacobfeder/quantum_cadets
|
jacobfeder
|
import numpy as np
import matplotlib.pyplot as plt
from scipy import signal
from qiskit import *
from qiskit.circuit import ControlledGate, Gate, Instruction, Qubit, QuantumRegister, QuantumCircuit
from qiskit.visualization import plot_histogram
from qiskit.circuit.library.standard_gates import C4XGate, TGate, XGate, RZGate, RXGate
from qiskit.ignis.characterization.characterization_utils import pad_id_gates
from qiskit.circuit.library.generalized_gates import MCMT
from qiskit.providers.aer.noise import NoiseModel
from qiskit.providers.aer.noise.errors.standard_errors import phase_damping_error
from typing import Union, Callable, List, Tuple
def encode_X(num, qubits, register_size):
non_register = qubits - register_size
Xs = np.array([int(ch) for ch in np.binary_repr(num, width=register_size)], dtype=bool)
registers = np.arange(register_size)
return registers[Xs] + non_register, registers[np.invert(Xs)] +non_register
def build_encode_circuit(num, qubits, register_size):
""" Create the registery conversion circuit. Assume the last qubits are the register.
qubits [int]: Total number of qubits in the global circuit
register_size [int]: Total number of qubits allocated for the register.
num [int]: target encoding
"""
# generate the X-gate configuration
CGates, XGates = encode_X(num, qubits, register_size)
# create a quantum circuit acting on the registers
conv_register = MCMT(XGate(), len(CGates), len(XGates))
XRange = [*CGates, *XGates]
return conv_register, XRange
def quantum_cadets(n_qubits, noise_circuit, damping_error=0.02):
"""
n_qubits [int]: total number of qubits - 2^(n_qubits-1) is the number of qft points, plus one sensing qubit
noise_circuit [function]: function that takes one input (a time index between 0-1) and returns a quantum circuit with 1 qubit
damping_error [float]: T2 damping error
"""
register_size = n_qubits - 1
# Create a Quantum Circuit acting on the q register
qr = QuantumRegister(n_qubits, 'q')
cr = ClassicalRegister(register_size)
qc = QuantumCircuit(qr, cr)
# Add a H gate on qubit 1,2,3...N-1
for i in range(register_size):
qc.h(i+1)
# multi-qubit controlled-not (mcmt) gate
mcmt_gate = MCMT(XGate(), register_size, 1)
qr_range=[*range(1, n_qubits), 0]
for bit in range(2**register_size):
qc.append(mcmt_gate, [qr[i] for i in qr_range])
# external noise gates
qc.append(noise_circuit(bit / 2**register_size), [qr[0]])
qc.append(mcmt_gate, [qr[i] for i in qr_range])
if bit == 0:
for i in range(register_size):
qc.x(i + (n_qubits - register_size))
elif bit == 2**register_size - 1:
pass
else:
conv_register, XRange = build_encode_circuit(bit, n_qubits, register_size)
qc.append(conv_register, qr[XRange])
# run the QFT
qft = circuit.library.QFT(register_size)
qc.append(qft, qr[1:n_qubits])
# map the quantum measurement to classical bits
qc.measure(range(1, n_qubits), range(0, register_size))
# display the quantum circuit in text form
print(qc.draw('text'))
#qc.draw('mpl')
plt.show()
# noise model
t2_noise_model = NoiseModel()
t2_noise_model.add_quantum_error(phase_damping_error(damping_error), 'id', [0])
# run the quantum circuit on the statevector simulator backend
#backend = Aer.get_backend('statevector_simulator')
# run the quantum circuit on the qasm simulator backend
backend = Aer.get_backend('qasm_simulator')
# number of histogram samples
shots = 10000
# execute the quantum program
job = execute(qc, backend, noise_model=t2_noise_model, shots=shots)
# outputstate = result.get_statevector(qc, decimals=3)
# visualization.plot_state_city(outputstate)
result = job.result()
# collect the state histogram counts
counts = result.get_counts(qc)
#plot_histogram(counts)
qft_result = np.zeros(2**register_size)
for f in range(len(qft_result)):
# invert qubit order and convert to string
f_bin_str = ('{0:0' + str(register_size) + 'b}').format(f)[::-1]
if f_bin_str in counts:
if f:
# flip frequency axis and assign histogram counts
qft_result[2**register_size - f] = counts[f_bin_str] / shots
else:
# assign histogram counts, no flipping because of qft representation (due to nyquist sampling?)
qft_result[0] = counts[f_bin_str] / shots
freq = np.arange(2**register_size)
plt.plot(freq, qft_result, label='QFT')
plt.xlabel('Frequency (Hz)')
# print the final measurement results
print('QFT spectrum:')
print(qft_result)
# show the plots
plt.show()
if __name__ == "__main__":
def narrowband_noise(time):
"""
Apply a single-frequency noise source
"""
f = 13.1
qr = QuantumRegister(1)
qc = QuantumCircuit(qr, name='narrowband_noise')
qc.append(RZGate(2 * np.pi * f * time), [qr[0]])
return qc
def internal_t2_noise(time):
"""
Apply a large number of identity gates, which will
accumulate errors due to the inherent T2 noise
"""
n_ids = int(80*time) + 1
qr = QuantumRegister(1)
qc = QuantumCircuit(qr, name='t2_noise')
qc.h(qr[0])
qc = pad_id_gates(qc, qr, 0, n_ids)
return qc
# arg 1: number of qubits (QFT size + 1)
# arg 2: noise function
quantum_cadets(7, internal_t2_noise, damping_error=0.02)
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
import logging
import os
import pickle
from inspect import signature
from itertools import cycle
from typing import List
from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
from qiskit.circuit.library.standard_gates import *
from qiskit.quantum_info import Operator
from config import srcpath
from slam.basis_abc import VariationalTemplate
from slam.hamiltonian import Hamiltonian
from slam.utils.data_utils import filename_encode
from slam.utils.gates.custom_gates import *
from slam.utils.polytopes.polytope_wrap import (
gate_set_to_coverage,
monodromy_range_from_target,
)
class HamiltonianTemplate(VariationalTemplate):
def __init__(self, h: Hamiltonian):
self.filename = filename_encode(repr(h))
self.h = h
self.spanning_range = range(1)
self.using_bounds = False
self.using_constraints = False
self.bounds_list = None
self.constraint_func = None
super().__init__(preseed=False, use_polytopes=False)
def get_spanning_range(self, target_u):
return range(1, 2) # only need to build once, in lieu of a circuit template
def eval(self, Xk):
return self.h.construct_U(*Xk).full()
def parameter_guess(self, t=1):
parent = super().parameter_guess(t)
if parent is not None:
return parent
p_len = len(
signature(self.h.construct_U).parameters
) # getting number of parameters from Hamiltonian function definition
return np.random.random(p_len)
class CircuitTemplate(VariationalTemplate):
def __init__(
self,
n_qubits=2,
base_gates=[RiSwapGate(1 / 2)],
edge_params=[[(0, 1)]],
no_exterior_1q=False,
use_polytopes=False,
maximum_span_guess=5,
preseed=False,
):
"""Initalizes a qiskit.quantumCircuit object with unbound 1Q gate
parameters."""
hash = str(n_qubits) + str(base_gates) + str(edge_params) + str(no_exterior_1q)
self.filename = filename_encode(hash)
self.n_qubits = n_qubits
self.no_exterior_1q = no_exterior_1q
self.gate_2q_base = cycle(base_gates)
# each gate gets its on cycler
self.gate_2q_edges = cycle(
[cycle(edge_params_el) for edge_params_el in edge_params]
)
self.gen_1q_params = self._param_iter()
# compliant with basisv2 optimizer changes
self.using_bounds = False
self.bounds_list = None
self.using_constraints = False
self.constraint_func = None
# define a range to see how many times we should extend the circuit while in optimization search
self.spanning_range = None
if not use_polytopes:
self.spanning_range = range(1, maximum_span_guess + 1)
self.coverage = None # only precomputed in mixedbasis class
super().__init__(preseed=preseed, use_polytopes=use_polytopes)
self._reset()
# deprecated feature
self.trotter = False
def get_spanning_range(self, target_u):
if not self.use_polytopes:
return self.spanning_range
else:
# call monodromy polytope helper
return monodromy_range_from_target(self, target_u)
def eval(self, Xk):
"""Returns an Operator after binding parameter array to template."""
return Operator(self.assign_Xk(Xk)).data
def parameter_guess(self, t=0):
"""Returns a np array of random values for each parameter."""
parent = super().parameter_guess(t)
if parent is not None:
return parent
return np.random.random(len(self.circuit.parameters)) * 2 * np.pi
def assign_Xk(self, Xk):
return self.circuit.assign_parameters(
{parameter: i for parameter, i in zip(self.circuit.parameters, Xk)}
)
def _reset(self):
"""Return template to a 0 cycle."""
self.cycles = 0
self.circuit = QuantumCircuit(self.n_qubits)
self.gen_1q_params = self._param_iter() # reset p labels
def build(self, n_repetitions):
self._reset()
if n_repetitions <= 0:
raise ValueError()
if self.trotter:
pass
# n_repetitions = int(1 / next(self.gate_2q_params))
for i in range(n_repetitions):
self._build_cycle(initial=(i == 0), final=(i == n_repetitions - 1))
def _param_iter(self):
index = 0
while True:
# Check if Parameter already created, then return reference to that variable
def _filter_param(param):
return param.name == f"P{index}"
res = list(filter(_filter_param, self.circuit.parameters))
if len(res) == 0:
yield Parameter(f"P{index}")
else:
yield res[0]
index += 1
if self.trotter:
index %= 3 * self.n_qubits
def _build_cycle(self, initial=False, final=False):
"""Extends template by next nonlocal gate."""
if initial and not self.no_exterior_1q:
# before build by extend, add first pair of 1Qs
for qubit in range(self.n_qubits):
self.circuit.u(*[next(self.gen_1q_params) for _ in range(3)], qubit)
# self.circuit.ry(*[next(self.gen_1q_params) for _ in range(1)], qubit)
gate = next(self.gate_2q_base)
edge = next(
next(self.gate_2q_edges)
) # call cycle twice to increment gate index then edge
self.circuit.append(gate, edge)
if not (final and self.no_exterior_1q):
for qubit in edge:
# self.circuit.ry(*[next(self.gen_1q_params) for _ in range(1)], qubit)
self.circuit.u(*[next(self.gen_1q_params) for _ in range(3)], qubit)
self.cycles += 1
"""this might be deprecated, if I want to use gate costs, should be factored in with circuit polytopes already
for now, instead just use the mixedbasis instead"""
# class CustomCostCircuitTemplate(CircuitTemplate):
#
# #assigns a cost value to each repeated call to build()
# def __init__(self, base_gates=[CustomCostGate]) -> None:
# logging.warning("deprecated, use mixedorderbasis with cost assigned to cirucit polytopes")
# for gate in base_gates:
# if not isinstance(gate, CustomCostGate):
# raise ValueError("Gates must have a defined cost")
# self.cost = {0:0}
# super().__init__(n_qubits=2, base_gates=base_gates, edge_params=[(0,1)], no_exterior_1q=False,use_polytopes=True, preseed=True)
# def _build_cycle(self, initial=False, final=False):
# """Extends template by next nonlocal gate
# add modification which saves cost to dict"""
# if initial and not self.no_exterior_1q:
# # before build by extend, add first pair of 1Qs
# for qubit in range(self.n_qubits):
# self.circuit.u(*[next(self.gen_1q_params) for _ in range(3)], qubit)
# edge = next(self.gate_2q_edges)
# gate = next(self.gate_2q_base)
# self.circuit.append(gate, edge)
# if not (final and self.no_exterior_1q):
# for qubit in edge:
# self.circuit.u(*[next(self.gen_1q_params) for _ in range(3)], qubit)
# self.cycles += 1
# self.cost[self.cycles] = self.cost[self.cycles-1] + gate.cost
# def unit_cost(self, cycles):
# if not cycles in self.cost.keys():
# self.build(cycles)
# return self.cost[cycles]
"""if hetereogenous basis, build is always appending in a set order
we really want to be able to pick and choose freely
when we find monodromy spanning range, we actually need to be checking more combinations of gates
find the minimum cost polytope which contains target
now when we create basis it should precompute the coverage polytopes and order them based on cost"""
class MixedOrderBasisCircuitTemplate(CircuitTemplate):
# in previous circuit templates, everytime we call build it extends based on a predefined pattern
# now for mixed basis sets, polytope coverage informs a better way to mix and match
# this method needs to override the build method
# this means monodromy_range_from_target needs to return a circuit polytope
# we update template to match circuit polytope shape
# then tell optimizer range to be range(1) so it knows not to call build again
def __init__(
self,
base_gates: List[CustomCostGate],
chatty_build=True,
cost_1q=0,
bare_cost=True,
coverage_saved_memory=True,
use_smush_polytope=False,
**kwargs,
) -> None:
self.homogenous = len(base_gates) == 1
if cost_1q != 0 or bare_cost is False:
logging.warning(
"rather than setting cost_1q, use bare_cost=True and scale the cost afterwards - that way don't have misses in saved memory.\
(see bgatev2script.py for implementation)"
)
raise ValueError("just don't do this lol")
if not all([isinstance(gate, ConversionGainGate) for gate in base_gates]):
raise ValueError("all base gates must be ConversionGainGate")
# set gc < gg so that we can use the same polytope for both cases
# XXX note this means the gate_hash will refer to the wrong gate, but in speedlimit pass we override build() with scaled_gate param anyway
new_base_gates = []
for gate in base_gates:
if gate.params[2] < gate.params[3]:
new_base_gates.append(gate)
else:
new_params = gate.params
# swap gc and gg
new_params[2], new_params[3] = new_params[3], new_params[2]
temp_new_gate = ConversionGainGate(*new_params)
new_base_gates.append(temp_new_gate)
base_gates = new_base_gates
# assuming bare costs we should normalize the gate duration to 1
for gate in base_gates:
gate.normalize_duration(1)
super().__init__(
n_qubits=2,
base_gates=base_gates,
edge_params=[[(0, 1)]],
no_exterior_1q=False,
use_polytopes=True,
preseed=False,
)
if coverage_saved_memory:
# used list comprehension so each CG gate has its own str function called
file_hash = str([str(g) for g in base_gates])
if use_smush_polytope:
file_hash += "smush"
filepath = f"{srcpath}/data/polytopes/polytope_coverage_{file_hash}.pkl"
while True:
# try load from memory
if os.path.exists(filepath): # XXX hardcoded file path'
logging.debug("loading polytope coverage from memory")
with open(filepath, "rb") as f:
# NOTE this is hacky monkey patch, if we had more time we would transfer the old values to use this formatting
# non smushes use the h5 data loads, but we wanted to make variations of the gate so overriding that h5 data by storing an optional value in the class
if use_smush_polytope:
self.coverage, self.gate_hash, self.scores = pickle.load(f)
return
else:
self.coverage, self.gate_hash = pickle.load(f)
self.scores = None
return
elif use_smush_polytope:
raise ValueError(
"Smush Polytope not in memory, need to compute using parallel_drive_volume.py"
)
logging.warning("Failed to load smush, using non-smush instead")
file_hash = file_hash[:-5]
use_smush_polytope = False
filepath = (
f"{srcpath}/data/polytopes/polytope_coverage_{file_hash}.pkl"
)
else:
# if not in memory, compute and save
logging.warning(
f"No saved polytope! computing polytope coverage for {file_hash}"
)
self.coverage, self.gate_hash = gate_set_to_coverage(
*base_gates,
chatty=chatty_build,
cost_1q=cost_1q,
bare_cost=bare_cost,
)
with open(filepath, "wb") as f:
pickle.dump((self.coverage, self.gate_hash), f)
logging.debug("saved polytope coverage to file")
return
else:
self.coverage, self.gate_hash = gate_set_to_coverage(
*base_gates, chatty=chatty_build, cost_1q=cost_1q, bare_cost=bare_cost
)
def set_polytope(self, circuit_polytope):
self.circuit_polytope = circuit_polytope
self.cost = circuit_polytope.cost # ?
def unit_cost(self, n_):
return self.cost
def _reset(self):
self.circuit_polytope = None
super()._reset()
def build(self, n_repetitions, scaled_gate=None):
"""The reason the build method is being overriden is specifically for
mixed basis sets we want to be able to build circuits which have an
arbitrary order of basis gates so we have to use info from monodromy
monodromy communicates the order from a set polytope (which doesn't
have access to gate object proper) via a hash that lets override the
gate_2q_base generator."""
assert self.circuit_polytope is not None
# NOTE: overriding the 2Q gate if we want to use a speed limited gate
# used to manually set a duration attirbute
if scaled_gate is not None:
if not self.homogenous:
raise ValueError(
"Can't use this hacky substitute method for mixed basis sets"
)
gate_list = [scaled_gate] * n_repetitions
else:
# convert circuit polytope into a qiskit circuit with variation 1q params
gate_list = [
self.gate_hash[gate_key]
for gate_key in self.circuit_polytope.operations
]
self.gate_2q_base = cycle(gate_list)
assert n_repetitions == len(gate_list)
super().build(n_repetitions=len(gate_list))
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
from inspect import signature
from itertools import cycle
from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
from qiskit.circuit.library.standard_gates import *
from qiskit.quantum_info import Operator
from slam.utils.data_utils import filename_encode
from slam.utils.gates.custom_gates import *
"""
Defines the variational object passed to the optimizer
#TODO: this should extend Qiskit's NLocal class
"""
"""TemplateV2 working on implementing the continuous 2Q search
1. Change base_gate to be a class instead of already initialzied object
2. Eliminate monodromy things (I don't know how it could be used)
Wait actually, what if before we try decomp, we look at the shortest gates that make the monodromy span valid
I'll leave this as a TODO for now because it still breaks for 3Q+ and that's what I want working first
3. Define a cost of the circuit using the Q-params, should be the circuit fidelity which can be used with decomposition fidelity to find total f
"""
from slam.basis_abc import VariationalTemplate
class CircuitTemplateV2(VariationalTemplate):
def __init__(
self,
n_qubits=2,
base_gates=[RiSwapGate],
edge_params=[[(0, 1)]],
no_exterior_1q=False,
use_polytopes=False,
maximum_span_guess=5,
preseed=False,
vz_only=False,
param_vec_expand=None,
):
"""Initalizes a qiskit.quantumCircuit object with unbound 1Q gate
parameters."""
hash = str(n_qubits) + str(base_gates) + str(edge_params) + str(no_exterior_1q)
self.filename = filename_encode(hash)
self.n_qubits = n_qubits
self.no_exterior_1q = no_exterior_1q
# for smushing gate exps
self.param_vec_expand = param_vec_expand
if self.param_vec_expand is not None:
assert len(base_gates) == 1 # too complicated otherwise :)
self.vz_only = vz_only
self.gate_2q_base = cycle(base_gates)
# each gate gets its on cycler
self.gate_2q_edges = cycle(
[cycle(edge_params_el) for edge_params_el in edge_params]
)
self.gen_1q_params = self._param_iter()
# XXX
self.bounds = {} # dict key is each parameter
self.bounds_list = [] # list puts in order for scipy.optimze()
self.constraint_func = None # cost function constraint for optimize()
self.using_bounds = False
self.using_constraints = False # bound or constraint
# define a range to see how many times we should extend the circuit while in optimization search
self.spanning_range = None
if not use_polytopes:
self.spanning_range = range(1, maximum_span_guess + 1)
self.coverage = None # only precomputed in mixedbasis class
super().__init__(preseed=preseed, use_polytopes=use_polytopes)
self._reset()
# deprecated feature
self.trotter = False
def get_spanning_range(self, target_u):
if not self.use_polytopes:
return self.spanning_range
else:
# call monodromy polytope helper
# import put here so files that don't use monodromy can still import this file
from slam.utils.polytopes.polytope_wrap import monodromy_range_from_target
return monodromy_range_from_target(self, target_u)
def reconstruct(self, ret):
"""Reconstructs the circuit from the optimization result."""
self.build(ret.cycles)
print("Cost:", self.circuit_cost(Xk=ret.Xk))
return self.assign_Xk(ret.Xk)
def circuit_cost(self, Xk):
# NOTE: this doesn't necessarily correlate to a fidelity measure
# for now, consider to just be an abstract score used in constraint building
# fidelity = 1.0
cost = 0
qc = self.assign_Xk(Xk)
# assuming there is only 1 critical path, need to iterate through gates
# want to take the product of fidelities
# for now just hardcode this until we settle on a better way
for gate in qc:
c = 0.0
if gate[0].name == "riswap":
a = gate[0].params[0]
c = RiSwapGate(a).cost() # fidelity
elif gate[0].name in ["3QGate", "VSWAP", "ΔSWAP"]:
# cast ParameterExpression to list(float)
# XXX I believe the gate.params doesn't preserve the order so splatting is not correct
# raise ValueError("BROKEN!")
a = [float(el) for el in gate[0].params]
c = CirculatorSNAILGate(*a).cost()
# elif gate[0].name in ["2QSmushGate"]:
# # fidelity = fidelity * c:
# a = [float(el) for el in gate[0].params]
# c = ConversionGainSmushGate(*a).cost()
elif gate[0].name in ["2QGate", "2QSmushGate"]:
# fidelity = fidelity * c:
a = [float(el) for el in gate[0].params]
c = ConversionGainGate(a[0], a[1], a[2], a[3], a[-1]).cost()
# raise ValueError("BROKEN!")
cost += c
return cost
def circuit_fidelity(self, Xk):
fidelity = 1.0
qc = self.assign_Xk(Xk)
# assuming there is only 1 critical path, need to iterate through gates
# want to take the product of fidelities
# for now just hardcode this until we settle on a better way
for gate in qc:
c = 1.0
if gate[0].name == "riswap":
a = gate[0].params[0]
c = RiSwapGate(a).cost() # fidelity
fidelity = fidelity * c
return fidelity
def eval(self, Xk):
"""Returns an Operator after binding parameter array to template."""
return Operator(self.assign_Xk(Xk)).data
# TODO: modify this so the Q-params have a smaller range
def parameter_guess(self, t=0):
"""Returns a np array of random values for each parameter."""
# parent checking is to handle preseeding
parent = super().parameter_guess(t)
if parent is not None:
return parent
random_list = []
# set defaults
# default_bound = (-2*np.pi, 2*np.pi)
default_bound = (-4 * np.pi, 4 * np.pi)
dict_response_default = default_bound
self.bounds_list = (
[]
) # sequence of (min,max) for each element in X passed to scipy optimze
for parameter in self.circuit.parameters:
cbound = self.bounds.get(parameter.name, dict_response_default)
self.bounds_list.append(cbound)
if cbound is None:
cbound = default_bound
random_list.append(np.random.uniform(cbound[0], cbound[1], 1)[0])
if not self.using_bounds:
self.bounds_list = None # remove so optimizer can use BFGS
return random_list
# return np.random.random(len(self.circuit.parameters))* 2 * np.pi
def add_bound(self, parameter_name, max=None, min=None):
self.bounds[parameter_name] = (min, max)
# con_funs is passed to scipy optimizer
# quick iteration because I don't have a better way
p_index = -1
for index, p in enumerate(self.circuit.parameters):
if p.name == parameter_name:
p_index = index
break
if p_index == -1:
raise ValueError("Parameter Name not found")
# self.con_funs.append({'type:ineq', 'fun':lambda x: max-x[p_index]})
# self.con_funs.append({'type:ineq','fun':lambda x: x[p_index] - min})
# flag for safety, can't rebuilt or messes with ordering
self.using_bounds = True
return
def set_constraint(self, param_max_cost):
# set a constraint that the current basis can't have a cost more than param
# of the form C_j(x) >= 0
self.constraint_func = {
"type": "ineq",
"fun": lambda x: param_max_cost - self.circuit_cost(x),
}
self.using_constraints = True
def remove_constraint(self):
self.constraint_func = None
self.using_constraints = False
def assign_Xk(self, Xk):
return self.circuit.assign_parameters(
{parameter: i for parameter, i in zip(self.circuit.parameters, Xk)}
)
def _reset(self):
"""Return template to a 0 cycle."""
self.cycles = 0
self.circuit = QuantumCircuit(self.n_qubits)
self.gen_1q_params = self._param_iter() # reset p labels
self.gen_2q_params = self._param_iter2() # second counter for 2Q gates
def build(self, n_repetitions):
# if self.using_constraints:
# raise ValueError("Can't build after setting constraints")
self._reset()
if n_repetitions <= 0:
raise ValueError()
if self.trotter:
pass
# n_repetitions = int(1 / next(self.gate_2q_params))
for i in range(n_repetitions):
self._build_cycle(initial=(i == 0), final=(i == n_repetitions - 1))
def _param_iter(self):
index = 0
while True:
# Check if Parameter already created, then return reference to that variable
def _filter_param(param):
return param.name == f"P{index}"
res = list(filter(_filter_param, self.circuit.parameters))
if len(res) == 0:
yield Parameter(f"P{index}")
else:
yield res[0]
index += 1
if self.trotter:
index %= 3 * self.n_qubits
def _param_iter2(self):
index = 0
while True:
# Check if Parameter already created, then return reference to that variable
def _filter_param(param):
return param.name == f"Q{index}"
res = list(filter(_filter_param, self.circuit.parameters))
if len(res) == 0:
yield Parameter(f"Q{index}")
else:
yield res[0]
index += 1
def _build_cycle(self, initial=False, final=False):
"""Extends template by next nonlocal gate."""
if initial and not self.no_exterior_1q:
# before build by extend, add first pair of 1Qs
for qubit in range(self.n_qubits):
if self.vz_only:
self.circuit.rz(
*[next(self.gen_1q_params) for _ in range(1)], qubit
)
else:
self.circuit.u(*[next(self.gen_1q_params) for _ in range(3)], qubit)
#
gate = next(self.gate_2q_base)
edge = next(
next(self.gate_2q_edges)
) # call cycle twice to increment gate then edge
# inspect to find how many parameters our gate requires
# now using self.param_vec_expand to handle when parameter is a vector
num2qparams = len(
signature(gate).parameters
) # is +1 because of self, but goes away in range()
if self.param_vec_expand is not None:
num2qparams = sum(self.param_vec_expand)
gate_instance = gate(*[next(self.gen_2q_params) for _ in range(num2qparams)])
self.circuit.append(gate_instance, edge)
if not (final and self.no_exterior_1q):
for qubit in edge:
if self.vz_only:
self.circuit.rz(
*[next(self.gen_1q_params) for _ in range(1)], qubit
)
else:
self.circuit.u(*[next(self.gen_1q_params) for _ in range(3)], qubit)
self.cycles += 1
"""this might be deprecated, if I want to use gate costs, should be factored in with circuit polytopes already
for now, instead just use the mixedbasis instead"""
# class CustomCostCircuitTemplate(CircuitTemplate):
#
# #assigns a cost value to each repeated call to build()
# def __init__(self, base_gates=[CustomCostGate]) -> None:
# logging.warning("deprecated, use mixedorderbasis with cost assigned to cirucit polytopes")
# for gate in base_gates:
# if not isinstance(gate, CustomCostGate):
# raise ValueError("Gates must have a defined cost")
# self.cost = {0:0}
# super().__init__(n_qubits=2, base_gates=base_gates, edge_params=[(0,1)], no_exterior_1q=False,use_polytopes=True, preseed=True)
# def _build_cycle(self, initial=False, final=False):
# """Extends template by next nonlocal gate
# add modification which saves cost to dict"""
# if initial and not self.no_exterior_1q:
# # before build by extend, add first pair of 1Qs
# for qubit in range(self.n_qubits):
# self.circuit.u(*[next(self.gen_1q_params) for _ in range(3)], qubit)
# edge = next(self.gate_2q_edges)
# gate = next(self.gate_2q_base)
# self.circuit.append(gate, edge)
# if not (final and self.no_exterior_1q):
# for qubit in edge:
# self.circuit.u(*[next(self.gen_1q_params) for _ in range(3)], qubit)
# self.cycles += 1
# self.cost[self.cycles] = self.cost[self.cycles-1] + gate.cost
# def unit_cost(self, cycles):
# if not cycles in self.cost.keys():
# self.build(cycles)
# return self.cost[cycles]
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
from abc import ABC
import numpy as np
from qiskit import QuantumCircuit
from qiskit.circuit.library import SwapGate
from qiskit.quantum_info import *
from weylchamber import J_T_LI, bell_basis, c1c2c3, canonical_gate, g1g2g3
from slam.utils.gates.custom_gates import BerkeleyGate
"""
Defines functions that the optimizer attempts to minimize,
Each function is some metric of fidelity between unitaries, where 0 means best and 1 means worst
Experiment to find some metrics perform better/faster than others
"""
class LineSegmentDistanceCost(ABC):
# distance from current weyl chamber point to a line segment in the chamber
# for example, used to optimize gate which reaches the line of gates which build SWAP in k=2
def __init__(self, line_segment):
self.line_segment = line_segment
def distance(self, qc):
c = c1c2c3(Operator(qc).data)
# return distance from c to the line segment
return np.linalg.norm(
np.cross(
self.line_segment[1] - self.line_segment[0], self.line_segment[0] - c
)
) / np.linalg.norm(self.line_segment[1] - self.line_segment[0])
class BsqSwapCost(LineSegmentDistanceCost):
def __init__(self):
super().__init__(
line_segment=[
np.array(c1c2c3(BerkeleyGate().to_matrix())),
np.array(c1c2c3(SwapGate().power(1 / 2).to_matrix())),
]
) # B gate to sqswap
class EntanglementCostFunction(ABC):
# concurrence, mutual info, negativity, entanglement of formation, entropy of entanglement
def __init__(self, state="w"):
self.state_prep = QuantumCircuit(3)
if state == "w":
self.state_prep.ry(2 * np.arccos(1 / np.sqrt(3)), 0)
self.state_prep.ch(0, 1)
self.state_prep.cx(1, 2)
self.state_prep.cx(0, 1)
self.state_prep.x(0)
elif state == "ghz":
self.state_prep.h(0)
self.state_prep.cx(0, 1)
self.state_prep.cx(0, 2)
else:
raise NotImplementedError
self.state_prep.barrier()
def entanglement_monotone(self, qc):
self.full = self.state_prep.compose(qc)
self.statevector = Statevector(self.full)
class MutualInformation(EntanglementCostFunction):
# I could code this to be more flexible
# for now I am going to hardcode 3Q states in with partial tracing
def entanglement_monotone(self, qc):
# append on the entangled state circuit
# the goal of minimizing the cost means undoing the entangled state
super().entanglement_monotone(qc)
state1 = partial_trace(self.statevector, [0])
state2 = partial_trace(self.statevector, [1])
state3 = partial_trace(self.statevector, [2])
return sum(
[
mutual_information(state1),
mutual_information(state2),
mutual_information(state3),
]
)
class MutualInformationSquare(EntanglementCostFunction):
def entanglement_monotone(self, qc):
super().entanglement_monotone(qc)
state1 = partial_trace(self.statevector, [0])
state2 = partial_trace(self.statevector, [1])
state3 = partial_trace(self.statevector, [2])
return sum(
[
mutual_information(state1) ** 2,
mutual_information(state2) ** 2,
mutual_information(state3) ** 2,
]
)
class Negativity(EntanglementCostFunction):
def entanglement_monotone(self, qc):
return super().entanglement_monotone(qc)
class Formation(EntanglementCostFunction):
def entanglement_monotone(self, qc):
return super().entanglement_monotone(qc)
class EntropyofEntanglement(EntanglementCostFunction):
def entanglement_monotone(self, qc):
return super().entanglement_monotone(qc)
class UnitaryCostFunction(ABC):
def __init__(self):
# experimenting with this
# normalize cost using max_cost = c(swap, identity)
# swap = np.array([[1,0,0,0], [0,0,1,0], [0,1,0,0], [0,0,0,1]])
# id = np.array([[1,0,0,0], [0,1,0,0], [0,0,1,0],[0,0,0,1]])
self.normalization = 1 # self.unitary_fidelity(id, swap)
# logging.debug(self.normalization)
def unitary_fidelity(self, current_u, target_u):
raise NotImplementedError
# def fidelity_lambda(self, target_u):
# return lambda current_u: self.unitary_fidelity(current_u, target_u)
class BasicCostInverse(UnitaryCostFunction):
# don't subtract 1
def unitary_fidelity(self, current_u, target_u):
h = np.matrix(target_u).getH()
return np.abs(np.trace(np.matmul(h, current_u))) / np.array(current_u).shape[0]
class BasicCost(UnitaryCostFunction):
def unitary_fidelity(self, current_u, target_u):
h = np.matrix(target_u).getH()
return (
1 - np.abs(np.trace(np.matmul(h, current_u))) / np.array(current_u).shape[0]
)
class ContinuousUnitaryCostFunction(BasicCost):
"""Used to fit a template to a unitary behavior at all timesteps rather
than just the final state."""
def __init__(self, timesteps):
super().__init__()
self.timesteps = timesteps
def unitary_fidelity(self, current_u, target_u):
# combine the unitary and its square root
# used for fitting a continuous time evolution, at t=1 and t=1/2
from qiskit.extensions import UnitaryGate
cost = 0
for i in np.linspace(0, 1, self.timesteps + 1): # +1 because skip 0
current_u_frac = UnitaryGate(current_u).power(i).to_matrix()
target_u_frac = UnitaryGate(target_u).power(i).to_matrix()
cost += super().unitary_fidelity(current_u_frac, target_u_frac)
return cost
class SquareCost(UnitaryCostFunction):
def unitary_fidelity(self, current_u, target_u):
h = np.matrix(target_u).getH()
d = np.array(target_u).shape[0]
return 1 - (np.abs(np.trace(np.matmul(h, current_u))) ** 2 + d) / (d * (d + 1))
class BasicReducedCost(BasicCost):
# version that eliminates exterior 1Q gates by converting to can basis
# need to also convert the template to can basis for similarity
def unitary_fidelity(self, current_u, target_u):
can_target = np.matrix(canonical_gate(*c1c2c3(target_u)))
can_current = np.matrix(canonical_gate(*c1c2c3(current_u)))
return super().unitary_fidelity(can_current, can_target)
class SquareReducedCost(SquareCost):
def unitary_fidelity(self, current_u, target_u):
can_target = np.matrix(canonical_gate(*c1c2c3(target_u)))
can_current = np.matrix(canonical_gate(*c1c2c3(current_u)))
return super().unitary_fidelity(can_current, can_target)
class SquareReducedBellCost(SquareCost):
def unitary_fidelity(self, current_u, target_u):
bell_target = np.matrix(bell_basis(target_u))
bell_current = np.matrix(bell_basis(current_u))
return super().unitary_fidelity(bell_current, bell_target)
class WeylEuclideanCost(UnitaryCostFunction):
def unitary_fidelity(self, current_u, target_u):
if (4, 4) != current_u.shape:
raise ValueError("Weyl chamber only for 2Q gates")
c_target = c1c2c3(target_u)
c_current = c1c2c3(current_u)
return np.linalg.norm(np.array(c_target) - np.array(c_current))
class MakhlinEuclideanCost(UnitaryCostFunction):
def unitary_fidelity(self, current_u, target_u):
if (4, 4) != current_u.shape:
raise ValueError("Weyl chamber only for 2Q gates")
g_target = g1g2g3(target_u)
g_current = g1g2g3(current_u)
return np.linalg.norm(np.array(g_target) - np.array(g_current))
class MakhlinFunctionalCost(UnitaryCostFunction):
def unitary_fidelity(self, current_u, target_u):
return J_T_LI(target_u, current_u)
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
import logging
import random
from abc import ABC
from sys import maxsize
from qiskit import QuantumCircuit
from qiskit.circuit.gate import Gate
from qiskit.quantum_info import Operator, random_clifford, random_unitary
from qiskit.transpiler.passes import Collect2qBlocks, ConsolidateBlocks, CountOps
from qiskit.transpiler.passmanager import PassManager
from slam.utils.gates.custom_gates import RiSwapGate
from slam.utils.transpiler_pass.weyl_decompose import RootiSwapWeylDecomposition
logger = logging.getLogger()
"""Define functions which act as distributions for a template to train
against."""
class SampleFunction(ABC):
def __init__(self, n_qubits=2, n_samples=1):
self.n_qubits = n_qubits
self.n_samples = n_samples
def __iter__(self):
for _ in range(self.n_samples):
yield self._get_unitary()
def _get_unitary(self):
raise NotImplementedError
class GateSample(SampleFunction):
def __init__(self, gate: Gate, n_samples=1):
self.gate = gate
super().__init__(gate.num_qubits, n_samples)
def _get_unitary(self):
return Operator(self.gate).data
class CircuitSample(SampleFunction):
def __init__(self, circuit: QuantumCircuit):
pm = PassManager([Collect2qBlocks(), ConsolidateBlocks(force_consolidate=True)])
self.transpiled_circuit = pm.run(circuit)
super().__init__(n_qubits=2, n_samples=len(self.transpiled_circuit))
logging.info(f"Created sampler with {self.n_samples} 2Q gates")
def __iter__(self):
for instruction in self.transpiled_circuit:
yield self._get_unitary(instruction)
def _get_unitary(self, instruction):
return instruction[0].to_matrix()
class Clifford(SampleFunction):
def _get_unitary(self):
return Operator(random_clifford(num_qubits=self.n_qubits)).data
class HaarSample(SampleFunction):
def __init__(self, seed=None, n_samples=1, n_qubits=2):
self.seed = seed
super().__init__(n_samples=n_samples, n_qubits=n_qubits)
def _get_unitary(self):
random.seed(self.seed)
return random_unitary(
dims=2**self.n_qubits, seed=random.randint(0, maxsize)
).data
def _haar_ground_truth(self, haar_exact=2):
"""When using sqrt[2] iswap, we might want to do a haar sample where we
know ahead of time if it will take 2 or 3 uses this is used for
establishing the effectiveness of our optimizer, but won't work for any
other basis gate."""
logging.warning("This sampler only works for \sqrt[2]iSwap")
pm0 = PassManager()
pm0.append(RootiSwapWeylDecomposition(basis_gate=RiSwapGate(0.5)))
pm0.append(CountOps())
logger.setLevel(
logging.CRITICAL
) # turn off logging here so we don't see lots of irrelevant things
while True:
qc = QuantumCircuit(2)
qc.append(random_unitary(dims=4), [0, 1])
pm0.run(qc)
if haar_exact == pm0.property_set["count_ops"]["riswap"]:
logger.setLevel(logging.INFO)
return qc
class Haar2Sample(HaarSample):
def __init__(self, seed=None, n_samples=1):
super().__init__(seed=seed, n_samples=n_samples)
def _get_unitary(self):
return Operator(self._haar_ground_truth(2)).data
class Haar3Sample(HaarSample):
def __init__(self, seed=None, n_samples=1):
super().__init__(seed=seed, n_samples=n_samples)
def _get_unitary(self):
return Operator(self._haar_ground_truth(3)).data
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
import logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)
import numpy as np
%matplotlib widget
from slam.utils.gates.custom_gates import ConversionGainGate
from slam.utils.polytopes.polytope_wrap import (
monodromy_range_from_target,
coverage_to_haar_expectation,
)
from slam.basis import CircuitTemplate, MixedOrderBasisCircuitTemplate
from slam.utils.visualize import (
unitary_to_weyl,
unitary_2dlist_weyl,
coordinate_2dlist_weyl,
)
from slam.utils.gates.custom_gates import CustomCostGate
from qiskit.circuit.library import CXGate, SwapGate
from weylchamber import c1c2c3
from slam.utils.gates.snail_death_gate import SpeedLimitedGate
from tqdm import tqdm
import matplotlib.pyplot as plt
# # verifying that relative phase doesn't change 2Q gate location
# unitary = [ConversionGainGate(0, 0, p*0.5*np.pi, (1-p)*0.4*np.pi) for p in np.linspace(0,1,16)]
# print([u.cost() for u in unitary])
# unitary_to_weyl(*unitary);
# the first version of this file was exploring the conversion gain hamiltonian, let's also explore Heavy-Fluxonion, and Flux Qubit
from slam.utils.gates.duraton_scaling import cost_scaling
from slam.utils.gates.bare_candidates import (
build_gates,
get_group_name,
plot_eharr,
collect_data,
)
from slam.utils.gates.winner_selection import pick_winner
unitary_list, coordinate_list = build_gates()
coordinate_2dlist_weyl(*coordinate_list)
# # monkey patch, iterate through every gate and save its gc/gg mirror to base costs data set
# from slam.scripts.gate_exploration.bgatev2script import filename
# import h5py
# with h5py.File(filename, "a") as hf:
# g = hf.require_group("bare_cost")
# for gate, data in g.items():
# gc, gg = data[0][2], data[0][3]
# if gc == gg:
# continue
# # create mirror gate
# mirror = ConversionGainGate(0,0, gg, gc)
# #save a copy of the data with new gate
# mirror_data = [mirror.params, list(data[1])] # scores stay the same
# g.create_dataset(str(mirror), data=mirror_data)
# ## %%
# TODO put this in its own file
# """use 2 different 2Q gates and see minimum cost to build SWAP
# just see if a solution exists for 2Q gates only using 2 instances of each gate then stop (rather than using coverage set)"""
# from slam.utils.polytope_wrap import get_polytope_from_circuit, unitary_to_monodromy_coordinate
# from qiskit import QuantumCircuit
# from qiskit.circuit.library import SwapGate
# import itertools
# # interested in a hetero basis of 2 applications to build a SWAP target
# target_coords = unitary_to_monodromy_coordinate(SwapGate().to_matrix())
# #taking product over search space to build pairs of gates
# # a - might want to remove constraint of left side of x-axis only (I'm not sure if this makes a difference or not)
# # b - may need to increase density of gates to sample from
# unitary_pairs = list(itertools.product(unitary_list, repeat=2))
# #if find a solution, save it
# sol = []
# for gate1, gate2 in tqdm(unitary_pairs):
# #basis can just be a circuit with 2Q gates
# basis = QuantumCircuit(2)
# basis.append(gate1, [0,1])
# basis.append(gate2, [0,1])
# circuit_polytope = get_polytope_from_circuit(basis)
# if circuit_polytope.has_element(target_coords):
# sol.append((gate1, gate2))
# logging.info((gate1, gate2))
# print(sol)
# XXX
# template = MixedOrderBasisCircuitTemplate(base_gates=[CustomCostGate(CXGate(), "CX")], chatty_build=1)
# coverage_to_haar_expectation(template.coverage, chatty=1)
# set logger level to critical to suppress warnings
logger.setLevel(logging.CRITICAL)
# TODO I need to recompute everything, but to save time just do iswap family
filtered_unitary_list = list(filter(lambda x: x.params[2] == 0, unitary_list))
collect_data(filtered_unitary_list)
method = "linear"
duration_1q = 0.1
group_name = get_group_name(method, duration_1q)
cost_scaling(speed_method=method, duration_1q=duration_1q)
plot_eharr(group_name, metric=0)
pick_winner(group_name, metric=2)
method = "hardware"
duration_1q = 0.1
group_name = get_group_name(method, duration_1q)
cost_scaling(speed_method=method, duration_1q=duration_1q)
plot_eharr(group_name)
pick_winner(group_name)
method = "mid"
duration_1q = 0.1
group_name = get_group_name(method, duration_1q)
cost_scaling(speed_method=method, duration_1q=duration_1q)
# plot_eharr(group_name, metric=0)
pick_winner(group_name, metric=0)
method = "squared"
duration_1q = 0.1
group_name = get_group_name(method, duration_1q)
cost_scaling(speed_method=method, duration_1q=duration_1q)
plot_eharr(group_name, metric=0)
pick_winner(group_name, metric=0)
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
%matplotlib widget
import logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)
from slam.basis import CircuitTemplate
basis = CircuitTemplate()
basis.build(3)
basis.spanning_range = range(3, 4)
basis.circuit.draw()
from slam.cost_function import BasicCost, MakhlinFunctionalCost
objective1 = BasicCost()
objective2 = MakhlinFunctionalCost()
from slam.sampler import GateSample
from qiskit.circuit.library import SwapGate
sampler = GateSample(gate=SwapGate())
from slam.optimizer import TemplateOptimizer
# by default use BFGS
optimizer1 = TemplateOptimizer(
basis=basis, objective=objective1, override_fail=1, use_callback=True
)
optimizer2 = TemplateOptimizer(
basis=basis, objective=objective2, override_fail=1, use_callback=True
)
##
optimizer3 = TemplateOptimizer(
basis=basis,
objective=objective1,
override_fail=1,
use_callback=True,
override_method="Nelder-Mead",
)
optimizer4 = TemplateOptimizer(
basis=basis,
objective=objective2,
override_fail=1,
use_callback=True,
override_method="Nelder-Mead",
)
from slam.utils.visualize import optimizer_training_plot
_ret1 = optimizer1.approximate_from_distribution(sampler)
optimizer_training_plot(_ret1[0], _ret1[1]);
_ret2 = optimizer2.approximate_from_distribution(sampler)
optimizer_training_plot(_ret2[0], _ret2[1])
_ret3 = optimizer3.approximate_from_distribution(sampler)
optimizer_training_plot(_ret3[0], _ret3[1]);
_ret4 = optimizer4.approximate_from_distribution(sampler)
optimizer_training_plot(_ret4[0], _ret4[1]);
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
import logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)
import numpy as np
%matplotlib widget
from weylchamber import c1c2c3
from qiskit import QuantumCircuit
from slam.utils.gates.custom_gates import RiSwapGate
from qiskit.quantum_info import Operator
from slam.utils.visualize import coordinate_2dlist_weyl
# class pass_manager_basic(PassManager):
# def __init__(self, gate='iswap'):
# passes = []
# # collect 2Q blocks
# passes.extend([Unroll3qOrMore(), Collect2qBlocks(), ConsolidateBlocks(force_consolidate=True)])
# if gate == 'iswap':
# passes.extend([decomposer(basis_gate=RiSwapGate(1/2))])
# elif gate == 'cx':
# passes.extend([decomposer(basis_gate=CXGate())])
# #combine 1Q gates
# passes.extend([Optimize1qGates()])
# #passes.extend([CountOps(), fooAnalysis()])
# super().__init__(passes)
# #transp1 = transpile(qc, optimization_level=3, basis_gates=['u', 'id', 'cx'])
# pm = pass_manager_basic(gate='iswap')
# qc = QuantumCircuit(2)
# qc.swap(0,1)
# transp1 = pm.run(qc)
# transp1.draw(output='mpl');
from slam.basisv2 import CircuitTemplateV2
basis = CircuitTemplateV2(n_qubits=2, base_gates=[RiSwapGate], edge_params=[[(0, 1)]])
basis.build(3)
basis.spanning_range = range(3, 4)
# bound all Qs to be >0
for el in basis.circuit.parameters:
s_el = str(el)
if "Q" in s_el:
basis.add_bound(s_el, 0.5, 0.5)
from slam.sampler import HaarSample, GateSample
from qiskit.circuit.library import CXGate, CZGate, SwapGate
from slam.utils.gates.custom_gates import CanonicalGate
sampler = GateSample(gate=SwapGate())
# sampler = GateSample(gate = CanonicalGate(np.pi / 4, np.pi / 8, np.pi/8))
# sampler = GateSample(gate = CXGate())
s = [s for s in sampler][0]
from slam.optimizer import TemplateOptimizer
from slam.cost_function import BasicCostInverse, BasicCost, SquareCost
objective1 = SquareCost()
optimizer3 = TemplateOptimizer(
basis=basis,
objective=objective1,
use_callback=False,
override_fail=True,
success_threshold=1e-7,
training_restarts=25,
)
_ret3 = optimizer3.approximate_target_U(s)
basis.build(_ret3.cycles)
circuit = basis.assign_Xk(_ret3.Xk)
transp1 = circuit
circuit.draw()
c1c2c3(Operator(transp1).data)
circuit[:2]
left_qc = QuantumCircuit(2)
for instruction, qargs, cargs in circuit[:8]:
left_qc.append(instruction, qargs, cargs)
# left_qc.draw(output='mpl')
print(c1c2c3(Operator(left_qc).data))
right_qc = QuantumCircuit(2)
for instruction, qargs, cargs in circuit[3:]:
right_qc.append(instruction, qargs, cargs)
# right_qc.draw(output='mpl')
print(c1c2c3(Operator(right_qc).data))
from qiskit.circuit import Parameter
def unbind_parameters(qc):
i = 0
out = qc.copy()
for instr, qargs, cargs in out:
if instr.params and instr.name == "riswap":
# num_params = len(instr.params)
# pvec.resize(len(pvec) + num_params)
instr.params = [Parameter(f"t{i}")]
i += 1
return out
transp1 = unbind_parameters(transp1)
transp1.draw()
from weylchamber import c1c2c3
endpoints = [5, 8, 11]
coordinate_list = []
# 5:1 ratio of 2Q/1Q gate duration, plot 2Q as 25 poitns, 1Q as 5 points
for _ in range(5):
coordinate_list.append((0, 0, 0))
for end in endpoints:
qc = QuantumCircuit(2)
for gate in transp1[0:end]:
qc.append(gate[0], gate[1])
# 2, 5, 8
qc2 = qc.copy()
for i in [2, 5, 8]:
if i < end - 3:
qc2 = qc2.bind_parameters({qc2[i][0].params[0]: 0.5})
# add coordinate during 1Q gate
# eliminating x-axis symmetry
c = list(c1c2c3(Operator(qc3).data))
if c[0] > 0.5:
c[0] = -1 * c[0] + 1
for _ in range(5):
coordinate_list.append(c)
for t in np.linspace(0, 0.5, 25):
qc3 = qc2.bind_parameters({qc2[end - 3][0].params[0]: t})
# eliminating x-axis symmetry
c = list(c1c2c3(Operator(qc3).data))
if c[0] > 0.5:
c[0] = -1 * c[0] + 1
coordinate_list.append(c)
# qc2.draw(output='mpl')
# from slam.utils.visualize import coordinate_2dlist_weyl
coordinate_2dlist_weyl(
coordinate_list, c=np.linspace(0, 1.5 + 0.2 * 4, len(coordinate_list))
);
coordinate_list[-25:]
# coordinate_list = []
# from slam.utils.gates.custom_gates import FSim, BerkeleyGate, CanonicalGate
# r = np.linspace(0,3,250)
# for t in r:
# qc2 = QuantumCircuit(2)
# #add fsim as a function of time
# #qc2.append(FSim(1*np.pi/2, 1*np.pi/6).power(t), [0,1])
# #qc2.append(CanonicalGate(np.pi / 4, np.pi / 8, np.pi/25).power(t), [0,1])
# #eliminating x-axis symmetry
# c = list(c1c2c3(Operator(qc2).data))
# # if c[0] > 0.5:
# # c[0] = -1*c[0] + 1
# coordinate_list.append(c)
# coordinate_2dlist_weyl(coordinate_list, c=r, cmap='viridis')
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
from slam.hamiltonian import DeltaConversionGainHamiltonian
import numpy as np
# args = gphi_ab, gphi_ac, gphi_bc, g_ab, g_ac, g_bc, cphi_ab, cphi_ac, cphi_bc, c_ab, c_ac, c_bc
# 12 parameters to hamitlonain
# 10 constraints
# instantiate hamiltonian
ham = DeltaConversionGainHamiltonian()
# ham.construct_U() with random variables, real valued
args = np.random.rand(12)
U = ham.construct_U(*args)
from slam.utils.visualize import plotMatrix
plotMatrix(U);
# optimize the parameters
from slam.basis import HamiltonianTemplate
ht = HamiltonianTemplate(h=DeltaConversionGainHamiltonian())
ht.parameter_guess()
ht.n_qubits = 3
# unitary cost function
from slam.cost_function import SquareCost
cost = SquareCost()
# define target as a custom 8x8 matrix
target = np.array(
[
[1, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 1, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0],
[0, 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, 0, 0, 0, 0],
]
)
from slam.optimizer import TemplateOptimizer
to = TemplateOptimizer(ht, objective=cost, override_fail=1)
ret = to.approximate_target_U(target)
ret_u = ham.construct_U(*ret.Xk)
plotMatrix(ret_u);
from qiskit import QuantumCircuit
from qiskit.quantum_info import Operator
qc = QuantumCircuit(3)
qc.ccx(0, 1, 2)
plotMatrix(Operator(qc).data)
qc = QuantumCircuit(3)
qc.cx(0, 2)
qc.cx(1, 2)
plotMatrix(Operator(qc).data);
# gphi_ab, gphi_ac, gphi_bc, g_ab, g_ac, g_bc, cphi_ab, cphi_ac, cphi_bc, c_ab, c_ac, c_bc
# construct a data class with the parameters
from dataclasses import dataclass
@dataclass
class Params:
gphi_ab: float
gphi_ac: float
gphi_bc: float
g_ab: float
g_ac: float
g_bc: float
cphi_ab: float
cphi_ac: float
cphi_bc: float
c_ab: float
c_ac: float
c_bc: float
# define a get function to return the parameters as a tuple
def get(self):
return (
self.gphi_ab,
self.gphi_ac,
self.gphi_bc,
self.g_ab,
self.g_ac,
self.g_bc,
self.cphi_ab,
self.cphi_ac,
self.cphi_bc,
self.c_ab,
self.c_ac,
self.c_bc,
)
# define a set all phi terms to 0
a = 2 * np.pi / np.sqrt(3)
p = Params(a, a, a, 0, 0, 0, 0, 0, 0, 0, 0, 0)
# construct the unitary
U = ham.construct_U(*p.get())
plotMatrix(U);
! pip install python-constraint
from constraint import *
# # set up a constraint solver for the hamiltonian
# import constraint
# # set up the symbols
# gphi_ab = 'gphi_ab'
# gphi_ac = 'gphi_ac'
# gphi_bc = 'gphi_bc'
# g_ab = 'g_ab'
# g_ac = 'g_ac'
# g_bc = 'g_bc'
# cphi_ab = 'cphi_ab'
# cphi_ac = 'cphi_ac'
# cphi_bc = 'cphi_bc'
# c_ab = 'c_ab'
# c_ac = 'c_ac'
# c_bc = 'c_bc'
# args = [gphi_ab, gphi_ac, gphi_bc, g_ab, g_ac, g_bc, cphi_ab, cphi_ac, cphi_bc, c_ab, c_ac, c_bc]
# # put the symbols into Hamiltonian to build the U
# U = DeltaConversionGainHamiltonian().construct_U(*args)
# # set up the constraints on U
# # 10 total constraints
# # U is a 4x4 matrix
# prob = constraint.Problem()
# # U[0,0] = 1
# # U[3,3] = 1
# prob.addConstraint(lambda x: x == 1, [U[0,0]])
# prob.addConstraint(lambda x: x == 1, [U[3,3]])
# # elements between U[0:2, 0:3] are all zero
# # U[0,1] = 0
# # U[0,2] = 0
# # U[1,1] = 0
# # U[1,2] = 0
# # U[2,1] = 0
# # U[2,2] = 0
# # U[3,1] = 0
# # U[3,2] = 0
# prob.addConstraint(lambda x: x == 0, [U[0,1]])
# prob.addConstraint(lambda x: x == 0, [U[0,2]])
# prob.addConstraint(lambda x: x == 0, [U[1,1]])
# prob.addConstraint(lambda x: x == 0, [U[1,2]])
# prob.addConstraint(lambda x: x == 0, [U[2,1]])
# prob.addConstraint(lambda x: x == 0, [U[2,2]])
# prob.addConstraint(lambda x: x == 0, [U[3,1]])
# prob.addConstraint(lambda x: x == 0, [U[3,2]])
# # now solve
# prob.getSolutions()
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
# this notebook I was trying to understand the fsim hamiltonian
# I couldn't make sense of the parameter g, so I think I have to make sense
import logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)
%matplotlib widget
import numpy as np
import matplotlib.pyplot as plt
# %matplotlib widget
from qiskit import QuantumCircuit, BasicAer, execute
from qiskit.visualization import plot_histogram
from qiskit.quantum_info import (
mutual_information,
Statevector,
partial_trace,
concurrence,
entanglement_of_formation,
)
from slam.basisv2 import CircuitTemplateV2
from slam.utils.gates.custom_gates import CirculatorSNAILGate, ConversionGainSmushGate
from slam.cost_function import BasicCostInverse, BasicCost, BasicReducedCost
from slam.optimizer import TemplateOptimizer
import h5py
from slam.basisv2 import CircuitTemplateV2
from slam.utils.gates.custom_gates import ConversionGainSmushGate, FSimHamiltonianGate
gate_lambda = lambda g: FSimHamiltonianGate(g, -208e-3, t=12)
basis = CircuitTemplateV2(
n_qubits=2, base_gates=[gate_lambda], edge_params=[[(0, 1)]], no_exterior_1q=True
)
basis.spanning_range = range(1, 2)
# basis.build(1)
# basis.circuit.draw('mpl')
from slam.sampler import HaarSample, GateSample
from slam.utils.gates.custom_gates import FSim
sampler = GateSample(gate=FSim(1 * np.pi / 2, 1 * np.pi / 6))
s = [s for s in sampler][0]
from slam.optimizer import TemplateOptimizer
from slam.cost_function import BasicCost, ContinuousUnitaryCostFunction
objective1 = ContinuousUnitaryCostFunction(timesteps=100)
objective2 = BasicCost()
optimizer3 = TemplateOptimizer(
basis=basis,
objective=objective1,
use_callback=True,
override_fail=True,
success_threshold=1e-7,
training_restarts=25,
)
# from qiskit.circuit.library import iSwapGate, CZGate
# def fsim(theta, phi):
# gate = iSwapGate().power(-2 * theta/np.pi).to_matrix()
# gate2 = CZGate().power(-phi/np.pi).to_matrix()
# gate = np.matmul(gate, gate2)
# return UnitaryGate(gate)
# from slam.utils.visualize import unitary_to_weyl
# unitary_to_weyl(fsim(1*np.pi/2, 1*np.pi/6))
# c1c2c3(fsim(1*np.pi/2, 1*np.pi/6).to_matrix())
ret = optimizer3.approximate_target_U(s)
basis.reconstruct(ret).draw("mpl")
coordinate_list = []
from slam.utils.gates.custom_gates import FSim, BerkeleyGate, CanonicalGate
from slam.hamiltonian import FSimHamiltonian
from weylchamber import c1c2c3
from qiskit.quantum_info import Operator
from slam.utils.visualize import coordinate_2dlist_weyl
from qiskit.extensions import UnitaryGate
from tqdm import tqdm
coordinate_list = []
r = np.linspace(0, 12, 101)
for t in tqdm(r):
qc2 = QuantumCircuit(2)
# add fsim as a function of time
# qc2.append(FSim(1*np.pi/2, 1*np.pi/6).power(t), [0,1])
qc2.append(
UnitaryGate(
FSimHamiltonian.construct_U(
(-20e-3 * (2 * np.pi)), -208e-3 * (np.pi * 2), t=t
)
),
[0, 1],
)
# eliminating x-axis symmetry
c = list(c1c2c3(Operator(qc2).data))
# if c[0] > 0.5:
# c[0] = -1*c[0] + 1
coordinate_list.append(c)
coordinate_2dlist_weyl(coordinate_list, c=r, cmap="viridis")
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
from slam.basis import MixedOrderBasisCircuitTemplate
import numpy as np
from slam.utils.gates.duraton_scaling import atomic_cost_scaling
from slam.utils.gates.family_extend import recursive_sibling_check
from slam.utils.polytopes.polytope_wrap import monodromy_range_from_target
from slam.utils.gates.custom_gates import ConversionGainGate
params = [0, 0, 0, np.pi / 32, 1]
basis = ConversionGainGate(*params)
template = MixedOrderBasisCircuitTemplate(
base_gates=[basis], chatty_build=False, use_smush_polytope=0
)
from qiskit.circuit.library import CPhaseGate
target_list = []
fam_list = []
no_fam_list = []
# iterate over CPHASe targets
for t_phase in range(1, 16):
t_phase = np.pi / 2 * (1 / t_phase)
target_list.append(t_phase)
target = CPhaseGate(theta=t_phase).to_matrix()
duration = atomic_cost_scaling(params, 1, speed_method="linear", duration_1q=0)
ret = recursive_sibling_check(
template, target, cost_1q=0.1, basis_factor=duration[1]
)
decomp_cost = ret[1]
# print(f"Relative cost {ret[1]}")
# ret[0].circuit.draw()
fam_list.append(decomp_cost)
# compare to no family
template = MixedOrderBasisCircuitTemplate(
base_gates=[basis], chatty_build=False, use_smush_polytope=0
)
ki = monodromy_range_from_target(template, target)[0]
decomp_cost = ki * duration[1] + (ki + 1) * 0.1
no_fam_list.append(decomp_cost)
# plot results
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
ax.plot(target_list, fam_list, label="with family", marker="o")
ax.plot(target_list, no_fam_list, label="no family", marker="o")
# reverse axis
ax.invert_xaxis()
# unit axis in pi
ax.set_xticks([np.pi / 2, np.pi / 4, np.pi / 8, np.pi / 16])
ax.set_xticklabels(["$\pi/2$", "$\pi/4$", "$\pi/8$", "$\pi/16$"])
# legend
ax.legend()
from slam.utils.gates.custom_gates import ConversionGainGate
params = [0, 0, 0, np.pi / 32, 1]
basis = ConversionGainGate(*params)
template = MixedOrderBasisCircuitTemplate(
base_gates=[basis], chatty_build=False, use_smush_polytope=0
)
from qiskit.circuit.library import CPhaseGate
target_list = []
fam_list = []
no_fam_list = []
# iterate over CPHASe targets
for t_phase in range(1, 16):
t_phase = np.pi / 2 * (1 / t_phase)
target_list.append(t_phase)
target = CPhaseGate(theta=t_phase).to_matrix()
duration = atomic_cost_scaling(params, 1, speed_method="linear", duration_1q=0)
ret = recursive_sibling_check(
template, target, cost_1q=0.1, basis_factor=duration[1]
)
decomp_cost = ret[1]
# print(f"Relative cost {ret[1]}")
# ret[0].circuit.draw()
fam_list.append(decomp_cost)
# compare to no family
template = MixedOrderBasisCircuitTemplate(
base_gates=[basis], chatty_build=False, use_smush_polytope=0
)
ki = monodromy_range_from_target(template, target)[0]
decomp_cost = ki * duration[1] + (ki + 1) * 0.1
no_fam_list.append(decomp_cost)
# plot results
import matplotlib.pyplot as plt
fig, ax = plt.subplots()
ax.plot(target_list, fam_list, label="with family", marker="o")
ax.plot(target_list, no_fam_list, label="no family", marker="o")
# reverse axis
ax.invert_xaxis()
# unit axis in pi
ax.set_xticks([np.pi / 2, np.pi / 4, np.pi / 8, np.pi / 16])
ax.set_xticklabels(["$\pi/2$", "$\pi/4$", "$\pi/8$", "$\pi/16$"])
# legend
ax.legend()
# make a plot that shows E[haar] as a function of nth root of iswap for varying 1Q durations
from slam.scripts.gate_exploration.bgatev2script import build_gates
from slam.scripts.gate_exploration.bgatev2script import cost_scaling
unitary_list, coordinate_list = build_gates()
gates = unitary_list
import matplotlib.pyplot as plt
# use matplotlib scientific style
with plt.style.context(["science", "ieee"]):
plt.rcParams.update({"text.latex.preamble": r"\usepackage{amsfonts}"})
# create plot
h2_list = []
fig, ax = plt.subplots()
for duration_1q in [0, 0.1, 0.25]:
h_list = []
x_list = []
for gate in gates[1:]:
if gate.params[2] != 0: # only want to keep iswap gates
continue
h = cost_scaling(
speed_method="linear", duration_1q=duration_1q, query_params=gate.params
)[1][0]
x_list.append(gate.params[3] / (np.pi / 2))
h_list.append(h)
# tracking bare costs, but only need to do over a single 1Q duration
if duration_1q == 0:
h2 = cost_scaling(
speed_method="bare", duration_1q=0, query_params=gate.params
)[1][0]
h2_list.append(h2)
ax.plot(x_list, h_list, label=f"D[1Q]={duration_1q}", marker="o", markersize=3)
# plot h2 on a second y-axis
ax2 = ax.twinx()
ax2.plot(
x_list,
h2_list,
label=r"Gate count ($k$)",
marker="s",
markersize=3,
color="green",
)
# reverse x axis
ax.set_xlim(ax.get_xlim()[::-1])
# xaxis
ax.set_xlabel(r"\sqrt[1/x{\texttt{iSWAP}} Basis")
# yaxis
ax.set_ylabel("Expected Duration of Haar Gate")
# title
# ax.set_title(r"$\mathbb{E}$[D[Haar]]" + " vs. " + r"D[$\sqrt[1/x]{\texttt{iSwap}}]$")
# legend off plot to the right
ax.legend(loc="center left", bbox_to_anchor=(1.05, 0.63))
ax2.legend(loc="center left", bbox_to_anchor=(1.05, 0.8))
# figure size for column width of IEEE
fig.set_size_inches(3.5, 2.5)
# shrink plot to fit legend
plt.tight_layout()
plt.show()
from slam.utils.visualize import fpath_images
# save as png
fig.savefig(f"{fpath_images}/haar_vs_iswap.png", format="png")
# save matplotlib fig as pdf
fig.savefig(f"{fpath_images}/haar_vs_iswap.pdf", format="pdf")
# make a plot that shows E[haar] as a function of nth root of iswap for varying 1Q durations'
# Similar as above but we want to use family extended haar scores
from slam.utils.gates.custom_gates import ConversionGainGate
from slam.scripts.gate_exploration.bgatev2script import build_gates
from slam.scripts.gate_exploration.bgatev2script import cost_scaling
from qiskit.circuit.library import CXGate, SwapGate
from tqdm import tqdm
from qiskit.quantum_info.random import random_unitary
unitary_list, coordinate_list = build_gates()
gates = unitary_list
import matplotlib.pyplot as plt
# use matplotlib scientific style
x_list = []
fam_haar = []
no_fam_haar = []
fam_swap = []
no_fam_swap = []
fam_cx = []
no_fam_cx = []
params = [0, 0, 0, np.pi / 2]
for di, duration_1q in enumerate([0.25]):
fam_haar_inner = []
no_fam_haar_inner = []
swap_inner = []
swap_no_fam_inner = []
cnot_inner = []
cnot_no_fam_inner = []
for frac_gate in range(1, 16):
if di == 0:
x_list.append(1 / frac_gate)
basis = ConversionGainGate(*params, t_el=(1 / frac_gate))
template = MixedOrderBasisCircuitTemplate(
base_gates=[basis], chatty_build=False, use_smush_polytope=0
)
# compute the new haar score
haar_score = 0
no_fam_score = 0
duration = atomic_cost_scaling(
params + [1 / frac_gate], 1, speed_method="linear", duration_1q=0
)
target = CXGate().to_matrix()
ret = recursive_sibling_check(
template, target, cost_1q=0.1, basis_factor=duration[1]
)
cnot_inner.append(ret[1])
template = MixedOrderBasisCircuitTemplate(
base_gates=[basis], chatty_build=False, use_smush_polytope=0
)
ki = monodromy_range_from_target(template, target)[0]
decomp_cost = ki * duration[1] + (ki + 1) * 0.1
cnot_no_fam_inner.append(decomp_cost)
target = SwapGate().to_matrix()
ret = recursive_sibling_check(
template, target, cost_1q=0.1, basis_factor=duration[1]
)
swap_inner.append(ret[1])
template = MixedOrderBasisCircuitTemplate(
base_gates=[basis], chatty_build=False, use_smush_polytope=0
)
ki = monodromy_range_from_target(template, target)[0]
decomp_cost = ki * duration[1] + (ki + 1) * 0.1
swap_no_fam_inner.append(decomp_cost)
N = 2000
for target in tqdm(range(N)):
# score with family
target = random_unitary(dims=4, seed=42).data
#
ret = recursive_sibling_check(
template, target, cost_1q=0.1, basis_factor=duration[1]
)
haar_score += ret[1]
# compare to no family
template = MixedOrderBasisCircuitTemplate(
base_gates=[basis], chatty_build=False, use_smush_polytope=0
)
ki = monodromy_range_from_target(template, target)[0]
decomp_cost = ki * duration[1] + (ki + 1) * 0.1
no_fam_score += decomp_cost
fam_haar_inner.append(haar_score / N)
no_fam_haar_inner.append(no_fam_score / N)
fam_swap.append(swap_inner)
no_fam_swap.append(swap_no_fam_inner)
fam_cx.append(cnot_inner)
no_fam_cx.append(cnot_no_fam_inner)
fam_haar.append(fam_haar_inner)
no_fam_haar.append(no_fam_haar_inner)
# #tracking bare costs, but only need to do over a single 1Q duration
# if duration_1q == 0:
# h2 = cost_scaling(speed_method='bare', duration_1q=0, query_params=gate.params)[1][0]
# h2_list.append(h2)
# use ieee science style
with plt.style.context(["ieee", "science"]):
# plot the results
# make figure size smaller for column width
fig, ax = plt.subplots(figsize=(3.5, 2.5))
for di, duration_1q in enumerate([0.25]):
ax.plot(
x_list[1:],
no_fam_haar[di][1:],
label=f"E[Haar]",
marker="o",
markersize=1,
color="k",
linestyle="--",
)
ax.plot(
x_list[1:],
no_fam_swap[di][1:],
label=f"D[Swap]",
marker="o",
markersize=1,
color="b",
linestyle="--",
)
ax.plot(
x_list[1:],
no_fam_cx[di][1:],
label=f"D[CX]",
marker="o",
markersize=1,
color="r",
linestyle="--",
)
ax.plot(
x_list[1:],
fam_haar[di][1:],
label=f"E[Haar], Family-Extend",
marker="o",
markersize=1,
color="k",
linestyle="-",
)
ax.plot(
x_list[1:],
fam_swap[di][1:],
label=f"D[Swap], Family-Extend",
marker="o",
markersize=1,
color="b",
linestyle="-",
)
ax.plot(
x_list[1:],
fam_cx[di][1:],
label=f"D[CX], Family-Extend",
marker="o",
markersize=1,
color="r",
linestyle="-",
)
# legend on bottom
ax.legend(loc="upper center", bbox_to_anchor=(0.5, -0.125), ncol=2, frameon=False)
# make legend text smaller
# reverse x axis
plt.xlim(plt.xlim()[::-1])
# set x axis label
ax.set_xlabel(r"$\sqrt[1/x]{iSwap}$ Fractional Basis")
# set y axis label
ax.set_ylabel("Duration Cost")
plt.show();
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
import numpy as np
from slam.hamiltonian import ConversionGainSmush
U = ConversionGainSmush().construct_U(
0, 0, np.pi / 2, 0, [3, 3, 3, 3, 3, 3], [0, 0, 0, 0, 0, 0]
)
from qutip import mesolve
from qutip import tensor, basis, qeye, sigmax, sigmaz
# initial state: start with one of the qubits in its excited state
psi0 = tensor(basis(N, 0), basis(2, 1), basis(2, 0))
from weylchamber import *
WeylChamber().plot()
from slam.utils.visualize import unitary_to_weyl
unitary_to_weyl(U)
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
# this notebook is going to test for randomly sampled locally equivalent gate, whether the basis gate set is sufficient to reconstruct the unitary with smushed gates
# we are going to test sqiswap, cnot, and syc as the 3 basis gates realized from gainconversion, CR, and fsim hamiltonians
import logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)
# %matplotlib widget
import numpy as np
from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
from qiskit.quantum_info import random_unitary
from slam.basisv2 import CircuitTemplateV2
from slam.utils.gates.custom_gates import ConversionGainSmushGate, ConversionGainGate
from slam.sampler import GateSample
from qiskit.extensions import UnitaryGate
from qiskit.quantum_info import Operator
from slam.optimizer import TemplateOptimizer
from slam.cost_function import BasicCost, SquareCost, MakhlinFunctionalCost
t = 1
timesteps = 4
duration_1q = t / timesteps
bounds_1q = 2 * np.pi
vz_only = False
# fixing these to be iterated over
gc, gg = (1 * np.pi / 2, 0 * np.pi / 4)
varg_offset = (
0 # set to 4 if want to use phase, and change 0s to vargs in pp2 constructor below
)
pp2 = lambda *vargs: ConversionGainSmushGate(
0,
0,
gc,
gg,
vargs[varg_offset : varg_offset + round(t / duration_1q)],
vargs[varg_offset + round(t / duration_1q) :],
t_el=t,
)
basis = CircuitTemplateV2(
n_qubits=2,
base_gates=[pp2],
edge_params=[[(0, 1)]],
vz_only=vz_only,
param_vec_expand=[varg_offset, round(t / duration_1q), round(t / duration_1q)],
)
basis_str = "CG2Q"
# varg_offset = 2
# pp3 =lambda *vargs: ConversionGainSmushGate(vargs[0], vargs[1], gc, gg, vargs[varg_offset:varg_offset+round(t/duration_1q)], vargs[varg_offset+round(t/duration_1q):], t_el=t)
# basis = CircuitTemplateV2(n_qubits=2, base_gates = [pp3], edge_params=[[(0,1)]], vz_only=True, param_vec_expand=[varg_offset,round(t/duration_1q),round(t/duration_1q)])
# basis_str = "CG2Q+P"
basis.build(1)
basis.spanning_range = range(1, 2)
# for all smush gates make bounds
for el in basis.circuit.parameters:
s_el = str(el)
if "Q" in s_el:
basis.add_bound(s_el, bounds_1q, -1 * bounds_1q)
# # manually set the gc, gg bounds
# for el in basis.circuit.parameters:
# s_el = str(el)
# if s_el in ["Q0", "Q1", "Q22", "Q23", "Q44", "Q45"]:
# basis.add_bound(s_el, .5, 0)
# #basis.add_bound(s_el, 0.5*np.pi, 0) #XXX when using riswapgate should be 0.5, but when using ConversionGain should be np.pi/2 !!! BAD BAD BAD
# construct the locally variant target
qc = QuantumCircuit(2)
# qc.append(random_unitary(2), [0])
# qc.append(random_unitary(2), [1])
g = ConversionGainGate(0, 0, gc, gg, t_el=t)
qc.append(g, [0, 1])
# qc.append(random_unitary(2), [0])
# qc.append(random_unitary(2), [1])
# qc.rx(-np.pi/2, 0)
# qc.rx(-np.pi/2, 1)
# qc.draw('mpl');
gate_data = Operator(qc).data
from slam.utils.gates.custom_gates import CanonicalGate
sampler = GateSample(CanonicalGate(np.pi / 4, np.pi / 8, np.pi / 8))
from qiskit.circuit.library import CXGate, SwapGate, CPhaseGate
gate_data = CXGate()
# gate_data = SwapGate()
# gate_data = CPhaseGate(np.pi/2)
sampler = GateSample(UnitaryGate(gate_data))
s = [s for s in sampler][0]
# objective1 = SquareCost()
objective1 = MakhlinFunctionalCost()
optimizer3 = TemplateOptimizer(
basis=basis,
objective=objective1,
use_callback=True,
override_fail=True,
success_threshold=1e-7,
training_restarts=5,
override_method="Nelder-Mead",
)
basis.circuit.draw(output="mpl")
_ret3 = optimizer3.approximate_from_distribution(sampler)
from slam.utils.visualize import optimizer_training_plot
fig = optimizer_training_plot(_ret3[0], _ret3[1])
# save fig as svg
fig.savefig("local_smush_test.svg")
# _ret3 = optimizer3.approximate_target_U(s)
# ret3[2] gets the target_data list, [0] returns the first element over the sampler distribution (we only put one in)
transp1 = basis.reconstruct(_ret3[2][0])
transp1.draw()
# replace the smush gate with smaller gates
from slam.utils.gates.custom_gates import ConversionGainSmushGate
transp2 = QuantumCircuit(2)
# iterate gates in transp1
for gate in transp1:
# if the gate is a smush gate
if isinstance(gate[0], ConversionGainSmushGate):
# get the parameters of the smush gate
params = gate[0].params
# get the qubits of the smush gate
qubits = gate[1]
# replace the smush gate with the smaller set of gates
for i in range(timesteps):
d_gate = ConversionGainSmushGate(
params[0],
params[1],
params[2],
params[3],
[params[4 + i]],
[params[4 + timesteps + i]],
t_el=Parameter(f"t{i}"),
)
transp2.append(d_gate, qubits)
else:
# if the gate is not a smush gate, just append it
transp2.append(gate[0], gate[1])
transp2.draw()
from weylchamber import c1c2c3
endpoints = [2, 3, 4, 5, 6, 7, 9] # XXX hardcoded
# endpoints = [2,3,4,5,6,8]
coordinate_list = []
for end in endpoints:
qc = QuantumCircuit(2)
for gate in transp2[0:end]:
qc.append(gate[0], gate[1])
qc2 = qc.copy()
# if we stop on a 2Q gate
if end in endpoints[1:-1]: # XXX hardcoded
# for all prior 2Q gates, set time parameter to full length
for i in [el for el in endpoints[1:-1] if el < end]:
qc2 = qc2.bind_parameters({qc2[i - 1][0].params[-1]: duration_1q})
# for current 2Q gate, iterate over time and append coordinate
for t in np.linspace(0, duration_1q, 25):
qc3 = qc2.bind_parameters({qc2[end - 1][0].params[-1]: t})
# eliminating x-axis symmetry
c = list(c1c2c3(Operator(qc3).data))
if c[0] > 0.5:
c[0] = -1 * c[0] + 1
coordinate_list.append(c)
# if we stop on a 1Q gate
else:
# for all prior 2Q gates, set time parameter to full length
for i in [el for el in endpoints[1:-1] if el < end]:
qc2 = qc2.bind_parameters({qc2[i - 1][0].params[-1]: duration_1q})
# eliminating x-axis symmetry
c = list(c1c2c3(Operator(qc2).data))
if c[0] > 0.5:
c[0] = -1 * c[0] + 1
# append coordinate for duration of 1Q gate
for t in np.linspace(0, duration_1q, 25):
coordinate_list.append(c)
# qc2.draw(output='mpl');
from slam.utils.visualize import coordinate_2dlist_weyl
coordinate_2dlist_weyl(
*[coordinate_list[i : i + 25] for i in [0, 25, 50, 75, 100, 125]]
) # , c=np.linspace(0, 1+2*duration_1q, len(coordinate_list)));
from slam.utils.visualize import coordinate_2dlist_weyl
fig = coordinate_2dlist_weyl(
coordinate_list[:150]
) # , c=np.linspace(0, 1+2*duration_1q, len(coordinate_list)));
# save fig as pdf
fig.savefig("cnot_derived_traj.pdf")
# for sqiswap making SWAP, we append a normal sqiswap gate, borrowed from the basic decomposition after we reach this middle point
# XXX hardcoded from decomp_trajectory.ipynb
coordinate_list.extend(
[
[0.49997065, 0.24999824, 0.24997135],
[0.49997065, 0.26041491, 0.26038801],
[0.49997065, 0.27083157, 0.27080468],
[0.49997065, 0.28124824, 0.28122135],
[0.49997065, 0.29166491, 0.29163801],
[0.49997065, 0.30208157, 0.30205468],
[0.49997065, 0.31249824, 0.31247135],
[0.49997065, 0.32291491, 0.32288801],
[0.49997065, 0.33333157, 0.33330468],
[0.49997065, 0.34374824, 0.34372135],
[0.49997065, 0.35416491, 0.35413801],
[0.49997065, 0.36458157, 0.36455468],
[0.49997065, 0.37499824, 0.37497135],
[0.49997065, 0.38541491, 0.38538801],
[0.49997065, 0.39583157, 0.39580468],
[0.49997065, 0.40624824, 0.40622135],
[0.49997065, 0.41666491, 0.41663801],
[0.49997065, 0.42708157, 0.42705468],
[0.49997065, 0.43749824, 0.43747135],
[0.49997065, 0.44791491, 0.44788801],
[0.49997065, 0.45833157, 0.45830468],
[0.49997065, 0.46874824, 0.46872135],
[0.49997065, 0.47916491, 0.47913801],
[0.49997065, 0.48958157, 0.48955468],
[0.49999821, 0.49997201, 0.49996939],
]
)
for t in np.linspace(0, duration_1q, 25):
coordinate_list.append((0.5, 0.5, 0.5))
coordinate_2dlist_weyl(coordinate_list, c=np.linspace(0, 1.8, len(coordinate_list)));
import weylchamber
import numpy as np
from weylchamber import WeylChamber
w = WeylChamber()
# remove all labels
w.labels = {}
# w.labels["I"] = np.array([-0.025, 0. , 0.02 ])
# w.labels["CX"] = np.array([0.425, 0. , 0.01 ])
# w.labels[r"\sqrt{iSwap}"] = np.array([0.25, 0.26, 0.03])
w.plot()
len(coordinate_list)
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
# makes weyl plot of candidate gates with basic metrics
from slam.utils.gates.bare_candidates import build_gates
import numpy as np
from slam.utils.gates.duraton_scaling import atomic_cost_scaling
from matplotlib import colors
from slam.utils.visualize import coordinate_2dlist_weyl
unitary_list, coordinate_list = build_gates()
color_list = []
speed_method = "linear"
for u in unitary_list[1:]:
h, _ = atomic_cost_scaling(
params=u.params, scores=np.array([0]), speed_method=speed_method, duration_1q=0
)
color_list.append(h.duration)
fig = coordinate_2dlist_weyl(
np.array(coordinate_list[1:]).reshape(-1, 3),
c=color_list,
elev=90,
azim=-90,
cmap="viridis",
);
fig = coordinate_2dlist_weyl(
np.array(coordinate_list[1:]).reshape(-1, 3),
c=color_list,
elev=90,
azim=-90,
cmap="viridis",
);
# fig.tight_layout()
# save matplotlib fig as pdf
# fig.savefig(f'/home/evm9/decomposition_EM/images/weyl_plot_{speed_method}_haar.pdf', format='pdf')
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
import logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)
%matplotlib widget
import numpy as np
from slam.utils.polytopes.coverage_plot import plot_coverage_set
from slam.basis import MixedOrderBasisCircuitTemplate
from slam.utils.gates.custom_gates import ConversionGainGate
# #coverage of an arbitrary gate
# # will load coverage polytope from file in template constructor or create it if it doesn't exist
# base_gate = ConversionGainGate(0,0, np.pi/8, 3*np.pi/8, 1/2)
# template = MixedOrderBasisCircuitTemplate(base_gates=[base_gate], chatty_build=0, bare_cost=True)
# plot_coverage_set(template.coverage[:], save=0, filename=f"coverage_set_custom")
iswap = np.pi / 2, 0, 1, "iSwap", 3
sqiswap = np.pi / 2, 0, 1 / 2, "sqiSwap", 3
cnot = np.pi / 4, np.pi / 4, 1, "CNOT", 3
sqcnot = np.pi / 4, np.pi / 4, 1 / 2, "sqCNOT", 6
b = 3 * np.pi / 8, np.pi / 8, 1, "B", 2
sqb = 3 * np.pi / 8, np.pi / 8, 1 / 2, "sqB", 4
gate_list = [iswap, sqiswap, cnot, sqcnot, b, sqb]
use_smush = 0
for gate_prop in gate_list[1:2]:
base_gate = ConversionGainGate(0, 0, *gate_prop[:3])
template = MixedOrderBasisCircuitTemplate(
base_gates=[base_gate],
chatty_build=0,
bare_cost=True,
use_smush_polytope=use_smush,
)
fname = f"coverage_set_{gate_prop[3]}"
if use_smush:
fname += "_smush"
poly_list = template.coverage
fig = plot_coverage_set(poly_list[:], save=1, filename=fname)
# take 3d axis of fig, and turn into gif with small rotations, stereoscopic view
import matplotlib.pyplot as pltFigure 1
from matplotlib.animation import FuncAnimation
from mpl_toolkits.mplot3d import Axes3D
for i in range(len(fig.axes)):
ax = fig.axes[i]
ax.view_init(30, 45)
ax.set_xlabel("X")
ax.set_ylabel("Y")
ax.set_zlabel("Z")
ax.set_xlim(-1, 1)
ax.set_ylim(-1, 1)
ax.set_zlim(-1, 1)
ax.set_aspect("equal")
def update(i):
ax.view_init(30, 45 + i)
return fig,
anim = FuncAnimation(fig, update, frames=np.arange(0, 15, 1), interval=20)
anim.save(f"{fname}_3d.gif", dpi=80, writer="imagemagick")
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
import logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)
import numpy as np
# %matplotlib widget
from qiskit import transpile
from qiskit import QuantumCircuit
from qiskit.circuit.random import random_circuit
from slam.utils.transpiler_pass.weyl_decompose import (
RootiSwapWeylDecomposition as decomposer,
)
from qiskit.transpiler.passes import (
Collect2qBlocks,
ConsolidateBlocks,
Unroll3qOrMore,
Optimize1qGates,
)
from slam.utils.gates.custom_gates import RiSwapGate
from qiskit.circuit.library import CXGate
from qiskit.converters import circuit_to_dag
from qiskit.transpiler.basepasses import TransformationPass
from qiskit.quantum_info import Operator
from slam.basis import MixedOrderBasisCircuitTemplate
from slam.utils.polytopes.polytope_wrap import monodromy_range_from_target
from slam.utils.gates.family_extend import recursive_sibling_check
from slam.utils.gates.bare_candidates import get_group_name
from slam.utils.gates.duraton_scaling import cost_scaling, atomic_cost_scaling
from slam.utils.gates.winner_selection import pick_winner
from qiskit.transpiler.basepasses import AnalysisPass
from qiskit.transpiler.passes import CountOps
from qiskit.dagcircuit import DAGOpNode, DAGCircuit
from qiskit.transpiler import PassManager
from itertools import product
from slam.utils.circuit_suite import benchmark_lambdas
# load square-lattice coupling map or all-to-all
from qiskit.transpiler import CouplingMap
coupling_map = CouplingMap.from_grid(8, 8)
coupling_map = CouplingMap.from_grid(3, 3)
# coupling_map = CouplingMap.from_full(16)
# load qiskit transpiler with pass for coupling map
induce_swaps = lambda qc: transpile(qc, coupling_map=coupling_map, optimization_level=3)
qc = benchmark_lambdas[3](9)
# turn off logging
logger.setLevel(logging.ERROR)
qc = induce_swaps(qc)
# turn back on logging
logger.setLevel(logging.INFO)
duration_1q = 0.1
benchmark_lambdas[3](9).draw("mpl")
from slam.utils.transpiler_pass.speed_limit_pass import (
pass_manager_basic,
pass_manager_slam,
pass_manager_optimized_sqiswap,
)
qc.draw("mpl")
qc = QuantumCircuit(2)
qc.cx(0, 1)
qc.swap(0, 1)
qc.barrier()
qc.cx(1, 0)
# qc.swap(0,1)
# qc.h(1)
# qc.crz(np.pi/2, 0, 1)
# qc.h(0)
from weylchamber import c1c2c3
print(c1c2c3(Operator(qc).data))
qc.draw(output="mpl")
qc.draw("mpl")
pm = pass_manager_basic(gate="sqiswap", duration_1q=duration_1q)
transp1 = pm.run(qc)
# transp1.draw(output='mpl')
print(0.1 * 247 + 0.5 * 246)
print(0.1 * 5 + 1.9 * 45 + 1.3 * 56)
pm = pass_manager_optimized_sqiswap(duration_1q=duration_1q, speed_method="linear")
transp1 = pm.run(qc)
# transp1.draw(output='mpl')
method = ["linear", "mid", "squared", "hardware"][0]
strategy = ["basic_overall", "lambda_weight", "basic_smush", "lambda_smush"][3]
use_fam = 0
pm = pass_manager_slam(
strategy=strategy,
family_extension=use_fam,
speed_method=method,
duration_1q=duration_1q,
coupling_map=coupling_map,
)
transp0 = pm.run(qc)
transp0.draw(output="mpl")
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
import weylchamber
from qiskit.converters import circuit_to_dag
from qiskit import transpile
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import ConsolidateBlocks, Collect2qBlocks
from qiskit.quantum_info import Operator
from qiskit.circuit.library import SwapGate, CXGate
from tqdm import tqdm
from slam.utils.circuit_suite import benchmark_lambdas, benchmark_lambdas_no_qv
# benchmark_lambdas[9](6).draw(output="mpl")
from qiskit.transpiler import CouplingMap
map_option = ["a2a", "lattice"][1]
if map_option == "a2a":
coupling_map = CouplingMap.from_full(16)
elif map_option == "lattice":
coupling_map = CouplingMap.from_grid(4, 4)
coordinate_list = []
for lambda_item in tqdm(benchmark_lambdas[0:1]):
# load qiskit transpiler with pass for coupling map
induce_swaps = lambda qc: transpile(
qc, coupling_map=coupling_map, optimization_level=3
)
circuit = lambda_item(16)
circuit = induce_swaps(circuit)
# Proceed
pm = PassManager()
pm.append(Collect2qBlocks())
pm.append(ConsolidateBlocks(force_consolidate=True))
transp_circuit = pm.run(circuit)
dag = circuit_to_dag(transp_circuit)
for gate in dag.collect_2q_runs():
assert len(gate) == 1 # should be 1 bc of consolidation
d = Operator(gate[0].op).data
try:
coordinate_list.append(weylchamber.c1c2c3(d))
except ValueError:
# seems like some SWAPs were getting a rounding error and couldn't be converted to a Weyl chamber coordinate
# XXX manually add a SWAP - it only happens two or three times total anyway
coordinate_list.append(weylchamber.c1c2c3(SwapGate().to_matrix()))
coordinate_freq = {i: coordinate_list.count(i) for i in set(coordinate_list)}
# print(coordinate_freq[weylchamber.c1c2c3(SwapGate().to_matrix())])
# print(coordinate_freq[weylchamber.c1c2c3(CXGate().to_matrix())])
679 / (679 + 717)
import matplotlib.pyplot as plt
from slam.utils.visualize import fpath_images
plt.close()
fig = plt.figure()
ax = fig.add_subplot(111, projection="3d")
from weylchamber import WeylChamber
w = WeylChamber()
##
for k, v in coordinate_freq.items():
ax.scatter3D(*k, s=0.75 * v, c="k")
##
w.labels = {}
w.render(ax)
# save as pdf and svg
plt.savefig(f"{fpath_images}/shot_chart_{map_option}.pdf", format="pdf")
plt.savefig(f"{fpath_images}/shot_chart_{map_option}.svg", format="svg")
fig.show()
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
# Follow this tutorial
# https://qucontrol.github.io/krotov/v1.2.1/notebooks/07_example_PE.html#Optimization
# 1. we aren't considering virtual z-gates, we could use state-to-state functional but was getting errors
# 2. simulated annealing learning rate?
# 3. not every 1Q variance has a solution, find subset that do, particular for CX and SWAP decomp targets
# 4. we see that when the solution is 1Q gates are off, the optimizer still struggles to find that solution with high fidelity
# 5. getting errors when turning on local variance in objective function
# 6. !!!! we think cnot with phase =0 doesn't change its coordinate - maybe it works with smushing?
import logging
logger = logging.getLogger()
logger.setLevel(logging.ERROR)
%matplotlib widget
import numpy as np
import qutip
import numpy as np
import scipy
import matplotlib
import matplotlib.pylab as plt
import krotov
from IPython.display import display
import weylchamber as wc
from weylchamber.visualize import WeylChamber
from weylchamber.coordinates import from_magic
gc, gg = (np.pi / 2, 0 * np.pi / 4)
T = 1.0 # final time
nt = 100
u0 = 2 * np.pi
tlist = np.linspace(0, T, nt)
def eps0(t, args):
return u0 * krotov.shapes.flattop(
t, t_start=0, t_stop=T, t_rise=(T / 20), t_fall=(T / 20), func="sinsq"
)
def eps1(t, args):
return u0 * krotov.shapes.flattop(
t, t_start=0, t_stop=T, t_rise=(T / 20), t_fall=(T / 20), func="sinsq"
)
def plot_pulse(pulse, tlist):
fig, ax = plt.subplots()
if callable(pulse):
pulse = np.array([pulse(t, args=None) for t in tlist])
ax.plot(tlist, pulse)
ax.set_xlabel("time")
ax.set_ylabel("pulse amplitude")
plt.show(fig)
def hamiltonian(phi_c, phi_g, gc, gg, gx0, gy0):
"""Two qubit Hamiltonian"""
a = qutip.operators.create(N=2)
I2 = qutip.operators.identity(2)
A = qutip.tensor(a, I2)
B = qutip.tensor(I2, a)
# # local qubit Hamiltonians
# Hq1 = 0.5 * w1 * np.diag([-1, 1])
# Hq2 = 0.5 * w2 * np.diag([-1, 1])
# # lift Hamiltonians to joint system operators
# H0 = np.kron(Hq1, np.identity(2)) + np.kron(np.identity(2), Hq2)
# construct Hamiltonian
Ha = A + A.dag()
Hb = B + B.dag()
H_c = np.exp(1j * phi_c) * A * B.dag() + np.exp(-1j * phi_c) * A.dag() * B
H_g = np.exp(1j * phi_g) * A * B + np.exp(-1j * phi_g) * A.dag() * B.dag()
H1 = gc * H_c + gg * H_g
# convert Hamiltonians to QuTiP objects
# H0 = qutip.Qobj(H0)
H1 = qutip.Qobj(H1)
Ha = qutip.Qobj(Ha)
Hb = qutip.Qobj(Hb)
# H1 = qutip.Qobj(H1)
# H2 = qutip.Qobj(H2)
# return [H0, [H1, eps0]]
# reshaping from [[2],[2]] to [4,4]
H1 = qutip.Qobj(H1.data, dims=[[4], [4]])
Ha = qutip.Qobj(Ha.data, dims=[[4], [4]])
Hb = qutip.Qobj(Hb.data, dims=[[4], [4]])
return [H1, [Ha, eps0], [Hb, eps1]] # renamed to eps1 to avoid dictionary key clash
H = hamiltonian(phi_c=0, phi_g=0, gc=gc, gg=gg, gx0=0, gy0=0)
# H = qutip.Qobj(H[0].data,dims=[[4],[4]])
# def hamiltonian(w1=w1, w2=w2, J=J, la=la, u0=u0):
# """Two qubit Hamiltonian
# Args:
# w1 (float): energy separation of the first qubit levels
# w2 (float): energy separation of the second qubit levels
# J (float): effective coupling between both qubits
# la (float): factor that pulse coupling strength differs for second qubit
# u0 (float): constant amplitude of the driving field
# """
# # local qubit Hamiltonians
# Hq1 = 0.5 * w1 * np.diag([-1, 1])
# Hq2 = 0.5 * w2 * np.diag([-1, 1])
# # lift Hamiltonians to joint system operators
# H0 = np.kron(Hq1, np.identity(2)) + np.kron(np.identity(2), Hq2)
# # define the interaction Hamiltonian
# sig_x = np.array([[0, 1], [1, 0]])
# sig_y = np.array([[0, -1j], [1j, 0]])
# Hint = 2 * J * (np.kron(sig_x, sig_x) + np.kron(sig_y, sig_y))
# H0 = H0 + Hint
# # define the drive Hamiltonian
# H1 = np.kron(np.array([[0, 1], [1, 0]]), np.identity(2)) + la * np.kron(
# np.identity(2), np.array([[0, 1], [1, 0]])
# )
# # convert Hamiltonians to QuTiP objects
# H0 = qutip.Qobj(H0)
# H1 = qutip.Qobj(H1)
# return [H0, [H1, eps0]]
# H = hamiltonian(w1=w1, w2=w2, J=J, la=la, u0=u0)
psi_00 = qutip.Qobj(np.kron(np.array([1, 0]), np.array([1, 0])))
psi_01 = qutip.Qobj(np.kron(np.array([1, 0]), np.array([0, 1])))
psi_10 = qutip.Qobj(np.kron(np.array([0, 1]), np.array([1, 0])))
psi_11 = qutip.Qobj(np.kron(np.array([0, 1]), np.array([0, 1])))
basis_states = [psi_00, psi_01, psi_10, psi_11]
proj_00 = qutip.ket2dm(psi_00)
proj_01 = qutip.ket2dm(psi_01)
proj_10 = qutip.ket2dm(psi_10)
proj_11 = qutip.ket2dm(psi_11)
from qiskit import QuantumCircuit
from slam.utils.gates.custom_gates import (
ConversionGainGate,
CanonicalGate,
BerkeleyGate,
)
from qiskit.quantum_info import Operator, random_unitary
from qiskit.extensions import UnitaryGate
from qiskit.circuit.library import SwapGate, CPhaseGate
# from slam.sampler import GateSample
# qc = QuantumCircuit(2)
# # qc.append(random_unitary(2), [0])
# # qc.append(random_unitary(2), [1])
# g = ConversionGainGate(0, 0, gc, gg, t_el=1.0)
# qc.append(g, [0,1])
# qc.append(random_unitary(2), [0])
# qc.append(random_unitary(2), [1])
# # qc.rx(-np.pi/2, 0)
# # qc.rx(-np.pi/2, 1)
# qc.draw('mpl');
# gate_data = Operator(qc).data
# qc = QuantumCircuit(2)
# qc.append(BerkeleyGate(), [0,1])
# qc.append(random_unitary(2), [0])
# qc.append(random_unitary(2), [1])
# gate_data = Operator(qc).data
gate_data = CanonicalGate(np.pi / 4, np.pi / 8, np.pi / 8).to_matrix()
gate_data = CanonicalGate(6 * np.pi / 8, 0, 0).to_matrix()
gate_data = CPhaseGate(theta=1.5 * np.pi).inverse().to_matrix()
# from smush_sqiswap.ipynb
gate_data = np.array(
[
[
-9.46073893e-01 - 3.23950901e-01j,
7.52727300e-06 + 1.48322966e-05j,
2.94187599e-05 + 7.74408998e-06j,
4.19924316e-05 - 1.55821066e-05j,
],
[
-2.36262549e-05 - 3.80524888e-05j,
-1.76803539e-05 - 8.38430158e-06j,
9.31614726e-06 - 1.53352949e-05j,
-9.46063756e-01 - 3.23980505e-01j,
],
[
-2.79905333e-05 - 1.19149014e-05j,
-4.85744092e-05 - 3.82839177e-07j,
-9.46062499e-01 - 3.23984174e-01j,
2.04261036e-06 - 1.78273925e-05j,
],
[
-1.50375118e-05 + 7.10662866e-06j,
-9.46068103e-01 - 3.23967809e-01j,
3.86126018e-05 + 2.94739471e-05j,
1.91084645e-05 + 4.21392507e-06j,
],
]
)
# gate_data = SwapGate().to_matrix()
# sampler = GateSample(UnitaryGate(gate_data))
from slam.utils.visualize import unitary_to_weyl, c1c2c3
c1c2c3(gate_data)
unitary_to_weyl(gate_data);
objectives = krotov.gate_objectives(
basis_states=basis_states, gate=gate_data, H=H, local_invariants=0
) # XXX local_invariants flag just doesnt work!
class sigma(krotov.second_order.Sigma):
def __init__(self, A, epsA=0):
self.A = A
self.epsA = epsA
def __call__(self, t):
ϵ, A = self.epsA, self.A
return -max(ϵ, 2 * A + ϵ)
def refresh(
self,
forward_states,
forward_states0,
chi_states,
chi_norms,
optimized_pulses,
guess_pulses,
objectives,
result,
):
try:
Delta_J_T = result.info_vals[-1][0] - result.info_vals[-2][0]
except IndexError: # first iteration
Delta_J_T = 0
self.A = krotov.second_order.numerical_estimate_A(
forward_states, forward_states0, chi_states, chi_norms, Delta_J_T
)
def S(t):
"""Shape function for the field update"""
return krotov.shapes.flattop(
t, t_start=0, t_stop=T, t_rise=T / 20, t_fall=T / 20, func="sinsq"
)
# def check_PE(result):
# # extract F_PE from (F_PE, [c1, c2, c3])
# F_PE = result.info_vals[-1][0]
# if F_PE <= 0:
# return "achieved perfect entangler"
# else:
# return None
from krotov.functionals import chis_hs, J_T_hs, J_T_wc
# from krotov.functionals import chis_ss, J_T_ss
# from krotov.functionals import chis_re, J_T_re
from weylchamber import make_LI_krotov_chi_constructor, J_T_LI
from krotov.convergence import check_monotonic_error, value_below, Or
from krotov.info_hooks import print_table, chain
# learning_rate = .01 # (reversed rules) bigger is smaller learning rate
# pulse_options = {H[1][1]: dict(lambda_a=learning_rate, update_shape=S), H[2][1]: dict(lambda_a=learning_rate, update_shape=S)}
from weylchamber import make_PE_krotov_chi_constructor, make_PE_krotov_chi_constructor
class simulated_annealer:
def __init__(self):
self.prev_optimized = None
self.opt_result = None
self.save_optimized = None
self.coordinate_list = []
self.iters = 0
def train(self):
for i, learning_rate in enumerate(
[0.1, 0.25, 0.5, 0.75, 1, 2, 3]
): # (reversed rules) bigger is smaller learning rate
print("learning rate: ", learning_rate)
pulse_options = {
H[1][1]: dict(lambda_a=learning_rate, update_shape=S),
H[2][1]: dict(lambda_a=learning_rate, update_shape=S),
}
self.opt_result = krotov.optimize_pulses(
objectives,
pulse_options=pulse_options,
tlist=tlist,
propagator=krotov.propagators.expm,
# chi_constructor=make_PE_krotov_chi_constructor(basis_states),
chi_constructor=chis_hs,
# info_hook=chain(self.save_coordinate, print_table(J_T=J_T_wc), self.save_iteration),
info_hook=chain(
self.save_coordinate, print_table(J_T=J_T_hs), self.save_iteration
),
# info_hook=chain(self.save_coordinate, self.save_iteration),
# check_convergence=value_below(1e-10, name='J_T'),
check_convergence=Or(
value_below(1e-10, name="J_T"), check_monotonic_error
),
iter_stop=40 * i,
continue_from=self.opt_result,
sigma=sigma(A=0.0),
# modify_params_after_iter = {'lambda_a': 1} not sure how to use this exactly
# norm= lambda state: np.linalg.norm(state)
# skip_initial_forward_propagation=True,
)
# truncate opt_result, if convergence was reached because broke monotonicity
if "Loss of monotonic convergence" in self.opt_result.message:
# remove the faulty iteration
print("removing faulty iteration")
# self.delete_iteration()
def save_coordinate(self, **args):
basis = [objectives[i].initial_state for i in [0, 1, 2, 3]]
states = [args["fw_states_T"][i] for i in [0, 1, 2, 3]]
U = wc.gates.gate(basis, states)
O = gate_data
c1, c2, c3 = wc.coordinates.c1c2c3(U)
# print(f'c1: {c1}, c2: {c2}, c3: {c3}')
self.coordinate_list.append([c1, c2, c3])
dist = J_T_LI(O, U)
# print iters and dist
print(f"iters: {self.iters}, dist: {dist}")
# return dist
def delete_iteration(self):
self.opt_result.iters[-1] = self.opt_result.iters[-2]
self.opt_result.iter_seconds[-1] = self.opt_result.iter_seconds[-2]
self.opt_result.info_vals[-1] = self.opt_result.info_vals[-2]
self.opt_result.tau_vals[-1] = self.opt_result.tau_vals[-2]
if self.prev_optimized is None:
raise ValueError("No previous optimized pulses to revert to")
self.opt_result.optimized_controls = self.prev_optimized
pass
def save_iteration(self, **args):
# deepcopy to avoid overwriting
import copy
if self.save_optimized is not None:
self.prev_optimized = self.save_optimized
self.save_optimized = copy.deepcopy(args["optimized_pulses"])
self.iters += 1
sa = simulated_annealer()
sa.train()
opt_result = sa.opt_result
print(opt_result)
# w = WeylChamber()
# c1c2c3 = [sa.coordinate_list[i] for i in range(len(opt_result.iters))]
# for i in range(len(opt_result.iters)):
# w.add_point(c1c2c3[i][0], c1c2c3[i][1], c1c2c3[i][2])
# w.plot()
from slam.utils.visualize import coordinate_2dlist_weyl
coordinate_2dlist_weyl(sa.coordinate_list, c=range(len(sa.coordinate_list)));
plot_pulse(opt_result.optimized_controls[1], tlist)
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
# this notebook is for testing when we smush 1Q gates into a 2Q gate (and changing its weyl coordinates)
# whether the new coordinates it gets access to gives the overall 2Q+smush additional volume had it not had otherwise
import logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)
import numpy as np
%matplotlib widget
from slam.utils.visualize import unitary_2dlist_weyl, coordinate_2dlist_weyl
from qiskit.quantum_info import Operator
from weylchamber import c1c2c3
import h5py
# from tqdm.notebook import tqdm as tqdm
from tqdm import tqdm
from config import srcpath
filename = f"{srcpath}/data/smush_unitary.h5"
from slam.utils.visualize import fpath_images
from slam.hamiltonian import ConversionGainPhaseHamiltonian
from slam.basisv2 import CircuitTemplateV2
from slam.utils.gates.custom_gates import ConversionGainGate
pp = lambda p1, p2: ConversionGainGate(p1, p2, np.pi / 4, np.pi / 4)
basis = CircuitTemplateV2(n_qubits=2, base_gates=[pp], no_exterior_1q=0, vz_only=1)
basis.build(1)
# what is volume of 1.5 iswaps with smushed gates, vs 3 sqrts with out
# can we make 1.8 pulse to 1.5 for swap
t = 1.5
duration_1q = 0.25
gc = 1 * np.pi / 2
gg = 0 * np.pi / 4
bounds_1q = 2 * np.pi
# from slam.utils.gates.custom_gates import ConversionGainSmushGate
# # NOTE first variable is tracking an offset (basically set it to 2 if counting the phase variables)
# p_expand = [0, round(t/duration_1q), round(t/duration_1q)]
# # XXX turn p_expand into indices is tricky
# #pp2 =lambda *vargs: ConversionGainSmushGate(vargs[0], vargs[1], np.pi/2, 0, vargs[2:2+round(t/duration_1q)], vargs[2+round(t/duration_1q):], t_el=t)
# pp2 =lambda *vargs: ConversionGainSmushGate(0, 0, gc, gg, vargs[:round(t/duration_1q)], vargs[round(t/duration_1q):], t_el=t)
# # circuittemplate builds # of parameters by checking the number of parameters in the lambda function to build the gate
# # because the parametes for gx and gy are vectors they only get counted once and it messes up
# # we can add an extra parameter called param_vec_expand
# # we need to use this to tell it to expand the number of parameters we should include
# # however, this will get really messy because we don't know which parameters are the vectors or not
# # be careful, this is going to be a mess :(
# basis = CircuitTemplateV2(n_qubits=2, base_gates=[pp2], no_exterior_1q=1, vz_only=0, param_vec_expand = p_expand)
# basis.build(1)
# # #adding constraint of 1Q params need to be positive valued
# # #this could be optional let's compare what happens if include it or not
# # for el in basis.circuit.parameters:
# # s_el = str(el)
# # if 'Q' in s_el:
# # basis.add_bound(s_el, bounds_1q, 0)
# # #basis.add_bound("Q0", 4*np.pi, 0)
# basis.circuit.draw(output='mpl')
# from slam.utils.visualize import unitary_2dlist_weyl
# from qiskit.quantum_info import Operator
# from tqdm import tqdm
# unitary_list = []
# param_list = []
# for i in tqdm(range(3000)):
# params = basis.parameter_guess()
# qc_init = basis.assign_Xk(params)
# unitary_list.append(Operator(qc_init).data)
# param_list.append(params)
# unitary_2dlist_weyl(unitary_list)
# coordinate_list = list(map(lambda x: c1c2c3(x), unitary_list))
# # combine the two lists
# combined_list = list(zip(coordinate_list, unitary_list, param_list))
# # arg min coordinate closest to (.75, 0, 0)
# sorted(combined_list, key=lambda x: np.linalg.norm(np.array(x[0]) - np.array([.75, 0,0])))[0][1]
from slam.utils.gates.custom_gates import ConversionGainSmushGate
# NOTE first variable is tracking an offset (basically set it to 2 if counting the phase variables)
poffset = 0
p_expand = [poffset, round(t / duration_1q), round(t / duration_1q)]
# XXX turn p_expand into indices is tricky
if poffset == 0:
pp2 = lambda *vargs: ConversionGainSmushGate(
0,
0,
gc,
gg,
vargs[: round(t / duration_1q)],
vargs[round(t / duration_1q) :],
t_el=t,
)
else:
pp2 = lambda *vargs: ConversionGainSmushGate(
vargs[0],
vargs[1],
gc,
gg,
vargs[poffset : poffset + round(t / duration_1q)],
vargs[poffset + round(t / duration_1q) :],
t_el=t,
)
# pp2 =lambda *vargs: ConversionGainSmushGate(0, 0, np.pi/2, 0, vargs[:round(t/du}ration_1q)], vargs[round(t/duration_1q):], t_el=t)
# circuittemplate builds # of parameters by checking the number of parameters in the lambda function to build the gate
# because the parametes for gx and gy are vectors they only get counted once and it messes up
# we can add an extra parameter called param_vec_expand
# we need to use this to tell it to expand the number of parameters we should include
# however, this will get really messy because we don't know which parameters are the vectors or not
# be careful, this is going to be a mess :(
basis = CircuitTemplateV2(
n_qubits=2, base_gates=[pp2], no_exterior_1q=1, vz_only=0, param_vec_expand=p_expand
)
k = 1
basis.build(k)
# adding constraint of 1Q params need to be positive valued
# this could be optional let's compare what happens if include it or not
# for el in basis.circuit.parameters:
# s_el = str(el)
# if 'Q' in s_el:
# basis.add_bound(s_el, bounds_1q, -bounds_1q)
# basis.add_bound("Q0", 4*np.pi, 0)
basis.circuit.draw()
from slam.utils.visualize import unitary_2dlist_weyl
from qiskit.quantum_info import Operator
from tqdm import tqdm
# NOTE don't reset unitary list if want to stack between each K
unitary_list = []
# print(len(unitary_list))
# param_list = []
for i in tqdm(range(1000)):
params = basis.parameter_guess()
qc_init = basis.assign_Xk(params)
unitary_list.append(Operator(qc_init).data)
# param_list.append(params)
# get this case which should be the vanilla basis gate
params = np.array(basis.parameter_guess()) * 0
qc_init = basis.assign_Xk(params)
unitary_list.append(Operator(qc_init).data)
# param_list.append(params)
unitary_2dlist_weyl(unitary_list, c="red", no_bar=1)
coordinate_list = list(map(lambda x: c1c2c3(x), unitary_list))
# coordinate_2dlist_weyl(reduced_coordinate_list, no_bar=1);
# # combine the two lists
# combined_list = list(zip(coordinate_list, unitary_list, param_list))
# # arg min coordinate closest to (.5, .25, .25)
# sorted(combined_list, key=lambda x: np.linalg.norm(np.array(x[0]) - np.array([.5, .25, .25])))[0]
# # does same thing :)
# # idx = np.argmin(np.linalg.norm(np.array(coordinate_list) - np.array([.5, .25, .25])))
# # print (coordinate_list[idx], unitary_list[idx])
from slam.utils.gates.custom_gates import ConversionGainSmushGate
# NOTE first variable is tracking an offset (basically set it to 2 if counting the phase variables)
p_expand = [4, round(t / duration_1q), round(t / duration_1q)]
# XXX turn p_expand into indices is tricky
# pp2 =lambda *vargs: ConversionGainSmushGate(vargs[0], vargs[1], vargs[2], vargs[3], vargs[4:4+round(t/duration_1q)], vargs[4+round(t/duration_1q):], t_el=t)
# #pp2 =lambda *vargs: ConversionGainSmushGate(0, 0, np.pi/2, 0, vargs[:round(t/duration_1q)], vargs[round(t/duration_1q):], t_el=t)
varg_offset = 2
pp2 = lambda *vargs: ConversionGainSmushGate(
0,
0,
vargs[0],
vargs[1],
vargs[varg_offset : varg_offset + round(t / duration_1q)],
vargs[varg_offset + round(t / duration_1q) :],
t_el=t,
)
basis = CircuitTemplateV2(
n_qubits=2,
base_gates=[pp2],
edge_params=[[(0, 1)]],
vz_only=True,
no_exterior_1q=1,
param_vec_expand=[varg_offset, round(t / duration_1q), round(t / duration_1q)],
)
basis_str = "CG2Q"
# varg_offset = 4
# pp3 =lambda *vargs: ConversionGainSmushGate(vargs[0], vargs[1], vargs[2], vargs[3], vargs[varg_offset:varg_offset+round(t/duration_1q)], vargs[varg_offset+round(t/duration_1q):], t_el=t)
# basis = CircuitTemplateV2(n_qubits=2, base_gates = [pp3], edge_params=[[(0,1)]], vz_only=True, param_vec_expand=[varg_offset,round(t/duration_1q),round(t/duration_1q)])
# basis_str = "CG2Q+P"
# circuittemplate builds # of parameters by checking the number of parameters in the lambda function to build the gate
# because the parametes for gx and gy are vectors they only get counted once and it messes up
# we can add an extra parameter called param_vec_expand
# we need to use this to tell it to expand the number of parameters we should include
# however, this will get really messy because we don't know which parameters are the vectors or not
# be careful, this is going to be a mess :(
# basis = CircuitTemplateV2(n_qubits=2, base_gates=[pp2], no_exterior_1q=1, vz_only=0, param_vec_expand = p_expand)
basis.build(1)
# adding constraint of 1Q params need to be positive valued
# this could be optional let's compare what happens if include it or not
for el in basis.circuit.parameters:
s_el = str(el)
if "Q" in s_el:
basis.add_bound(s_el, bounds_1q, -bounds_1q)
basis.circuit.draw()
# #load from hdf5 file
# with h5py.File(filename, 'a') as f:
# data = f.require_group(f'{basis_str}_unitary_cost_data_t{t}')
# if 'unitary_list' in data and 'cost_list' in data:
# unitary_list = list(data['unitary_list'][:])
# cost_list = list(data['cost_list'][:])
# else:
# unitary_list = []
# cost_list = []
unitary_list = []
cost_list = []
# outer loop is sweeping over gc and gc
for m in tqdm(np.linspace(0, 0.5, 11)): # 17
if m == 0:
continue # identity is not interesting case
for n in np.linspace(0, 1, 9): # 21
for i in range(800):
gc = n * m * np.pi
gg = (1 - n) * m * np.pi
cost = ConversionGainGate(0, 0, gc, gg, t_el=t).cost()
# need to convert strings to Parameter objects
# the reason need to do this is because need to get reference to the exact parameter object via iteration
if basis_str == "CG2Q+P":
pstrs = ["Q2", "Q3"]
else:
pstrs = ["Q0", "Q1"]
pdict = {
str(pstr): [p for p in basis.circuit.parameters if p.name == pstr][0]
for pstr in pstrs
}
qc_init = basis.circuit.assign_parameters({pdict[pstrs[0]]: gc})
qc_init = qc_init.assign_parameters({pdict[pstrs[1]]: gg})
# randomize the remaining parameters
# NOTE there isn't a 1-1 mapping from p to remaining parameters bc have replaced q2 and q3 already but doesnt matter since is random
p = basis.parameter_guess()
# qc_init = qc_init.assign_Xk(p)
qc_init = qc_init.assign_parameters(
{k: v for k, v in zip(qc_init.parameters, p)}
)
# eliminating x-axis symmetry
c = list(c1c2c3(Operator(qc_init).data))
if c[0] > 0.5:
c[0] = -1 * c[0] + 1
# #when checking for duplicates, keep the lower cost one
# #instead of checking for duplicates, check if already a coordinate close by
# if any([np.linalg.norm(np.array(c)-np.array(c2)) < 0.025 for c2 in unitary_list]):
# c2 = unitary_list[np.argmin([np.linalg.norm(np.array(c)-np.array(c2)) for c2 in unitary_list])]
# ind = unitary_list.index(c2)
# if cost < cost_list[ind]:
# unitary_list[ind] = c
# cost_list[ind] = cost
# continue
else:
unitary_list.append(c)
cost_list.append(cost)
# do some preprocessing that takes the smaller cost value if their is a match of coordinates
# no not a good idea
# # save unitary list into a hdf5 file
# with h5py.File(filename, 'w') as f:
# f.create_dataset(f'{basis_str}_unitary_cost_data_t{t}/unitary_list', data=unitary_list)
# f.create_dataset(f'{basis_str}_unitary_cost_data_t{t}/cost_list', data=cost_list)
dub_unitary_list = []
dub_cost_list = []
for unitary, cost in zip(unitary_list, cost_list):
# want to add the conjugate
x, y, z = unitary
dub_cost_list.append(cost)
dub_unitary_list.append([x, y, z])
dub_cost_list.append(cost)
dub_unitary_list.append([1 - x, y, z])
fig = coordinate_2dlist_weyl(dub_unitary_list, c=dub_cost_list)
# save fig as pdf and svg
fig.savefig(f"{fpath_images}/smush_primative_sweep.svg", format="svg")
fig.savefig(f"{fpath_images}/smush_primative_sweep.pdf", format="pdf")
# fill points on the triangle, interpolate
# and reflect over the axis
# load from hdf5 file
import h5py
with h5py.File(filename, "r") as f:
data = f.require_group(f"{basis_str}_unitary_cost_data_t{t}")
if "unitary_list" in data and "cost_list" in data:
unitary_list = list(data["unitary_list"][:])
cost_list = list(data["cost_list"][:])
fig = coordinate_2dlist_weyl(unitary_list, c=cost_list);
# #save fig to file as svg and as pdf
# fig.savefig(f'{fpath_images}/{basis_str}_unitary_cost_data_t{t}.svg', format='svg')
# fig.savefig(f'{fpath_images}/{basis_str}_unitary_cost_data_t{t}.pdf', format='pdf')
# #load from hdf5 file
# with h5py.File(filename, 'r') as f:
# data = f.require_group('unitary_cost_data')
# if 'unitary_list' in data and 'cost_list' in data:
# unitary_list = list(data['unitary_list'][:])
# cost_list = list(data['cost_list'][:])
# #if a coordinate is within some threshold of another coordinate, remove the one with the higher cost
# for i, (cost, c) in enumerate(zip(cost_list, unitary_list)):
# #check if there is a coordinate within some threshold, not including itself
# if any([np.linalg.norm(np.array(c)-np.array(c2)) < 0.025 for c2 in unitary_list if (c2 != c).all()]):
# #if there is, find the index of the coordinate that is closest
# c2 = unitary_list[np.argmin([np.linalg.norm(np.array(c)-np.array(c2)) for c2 in unitary_list if (c2 != c).all()])]
# ind = np.where(np.all(unitary_list == c2, axis=1))[0][0]
# #if the cost of the coordinate we are checking is higher, remove it
# if cost > cost_list[ind]:
# unitary_list.pop(i)
# cost_list.pop(i)
# print(len(unitary_list))
# coordinate_2dlist_weyl(unitary_list, c=cost_list)
from slam.utils.gates.custom_gates import ConversionGainSmushGate
# NOTE first variable is tracking an offset (basically set it to 2 if counting the phase variables)
p_expand = [2, round(t / duration_1q), round(t / duration_1q)]
# XXX turn p_expand into indices is tricky
# pp2 =lambda *vargs: ConversionGainSmushGate(0, 0, vargs[0], vargs[1], vargs[4:4+round(t/duration_1q)], vargs[4+round(t/duration_1q):], t_el=t)
# #pp2 =lambda *vargs: ConversionGainSmushGate(0, 0, np.pi/2, 0, vargs[:round(t/duration_1q)], vargs[round(t/duration_1q):], t_el=t)
varg_offset = 2
pp2 = lambda *vargs: ConversionGainSmushGate(
0,
0,
vargs[0],
vargs[1],
vargs[varg_offset : varg_offset + round(t / duration_1q)],
vargs[varg_offset + round(t / duration_1q) :],
t_el=t,
)
basis = CircuitTemplateV2(
n_qubits=2,
base_gates=[pp2],
edge_params=[[(0, 1)]],
vz_only=True,
param_vec_expand=[varg_offset, round(t / duration_1q), round(t / duration_1q)],
)
basis_str = "CG2Q"
# varg_offset = 4
# pp3 =lambda *vargs: ConversionGainSmushGate(vargs[0], vargs[1], vargs[2], vargs[3], vargs[varg_offset:varg_offset+round(t/duration_1q)], vargs[varg_offset+round(t/duration_1q):], t_el=t)
# basis = CircuitTemplateV2(n_qubits=2, base_gates = [pp3], edge_params=[[(0,1)]], vz_only=True, param_vec_expand=[varg_offset,round(t/duration_1q),round(t/duration_1q)])
# basis_str = "CG2Q+P"
# circuittemplate builds # of parameters by checking the number of parameters in the lambda function to build the gate
# because the parametes for gx and gy are vectors they only get counted once and it messes up
# we can add an extra parameter called param_vec_expand
# we need to use this to tell it to expand the number of parameters we should include
# however, this will get really messy because we don't know which parameters are the vectors or not
# be careful, this is going to be a mess :(
basis = CircuitTemplateV2(
n_qubits=2, base_gates=[pp2], no_exterior_1q=1, vz_only=0, param_vec_expand=p_expand
)
basis.build(1)
# adding constraint of 1Q params need to be positive valued
# this could be optional let's compare what happens if include it or not
for el in basis.circuit.parameters:
s_el = str(el)
if "Q" in s_el:
basis.add_bound(s_el, bounds_1q, -bounds_1q)
# basis.add_bound("Q0", 4*np.pi, 0)
basis.circuit.draw()
from slam.utils.visualize import unitary_2dlist_weyl, coordinate_2dlist_weyl
from qiskit.quantum_info import Operator
from weylchamber import c1c2c3
from tqdm import tqdm
from random import random
unitary_list = []
cost_list = []
from slam.utils.visualize import unitary_2dlist_weyl
from qiskit.quantum_info import Operator
from tqdm import tqdm
unitary_list = []
cost_list = []
for i in tqdm(range(2500)):
gc = random() * np.pi
gg = random() * np.pi
cost = ConversionGainGate(0, 0, gc, gg, t_el=t).cost()
# need to convert strings to Parameter objects
# the reason need to do this is because need to get reference to the exact parameter object via iteration
pstrs = ["Q2", "Q3"]
pdict = {
str(pstr): [p for p in basis.circuit.parameters if p.name == pstr][0]
for pstr in pstrs
}
qc_init = basis.circuit.assign_parameters({pdict["Q2"]: gc})
qc_init = qc_init.assign_parameters({pdict["Q3"]: gg})
# randomize the remaining parameters
# NOTE there isn't a 1-1 mapping from p to remaining parameters bc have replaced q2 and q3 already but doesnt matter since is random
p = basis.parameter_guess()
# qc_init = qc_init.assign_Xk(p)
qc_init = qc_init.assign_parameters({k: v for k, v in zip(qc_init.parameters, p)})
c = list(c1c2c3(Operator(qc_init).data))
# eliminating x-axis symmetry
if c[0] > 0.5:
c[0] = -1 * c[0] + 1
if c in unitary_list:
continue
unitary_list.append(c)
cost_list.append(cost)
coordinate_2dlist_weyl(unitary_list, c=cost_list);
from slam.utils.gates.custom_gates import ConversionGainSmushGate, ConversionGainGate
# NOTE first variable is tracking an offset (basically set it to 2 if counting the phase variables)
p_expand = [2, 1, 1]
# XXX turn p_expand into indices is tricky
pp2 = lambda *vargs: ConversionGainGate(0, 0, vargs[0], vargs[1], t_el=1.0)
# pp2 =lambda *vargs: ConversionGainSmushGate(0, 0, np.pi/2, 0, vargs[:round(t/duration_1q)], vargs[round(t/duration_1q):], t_el=t)
# circuittemplate builds # of parameters by checking the number of parameters in the lambda function to build the gate
# because the parametes for gx and gy are vectors they only get counted once and it messes up
# we can add an extra parameter called param_vec_expand
# we need to use this to tell it to expand the number of parameters we should include
# however, this will get really messy because we don't know which parameters are the vectors or not
# be careful, this is going to be a mess :(
basis = CircuitTemplateV2(
n_qubits=2, base_gates=[pp2], no_exterior_1q=1, vz_only=0, param_vec_expand=p_expand
)
# adding constraint of 1Q params need to be positive valued
# this could be optional let's compare what happens if include it or not
basis.build(1)
for el in basis.circuit.parameters:
s_el = str(el)
if "Q" in s_el:
basis.add_bound(s_el, bounds_1q, -bounds_1q)
# basis.add_bound("Q0", 4*np.pi, 0)
basis.circuit.draw()
from slam.utils.visualize import unitary_2dlist_weyl, coordinate_2dlist_weyl
from qiskit.quantum_info import Operator
from weylchamber import c1c2c3
from tqdm import tqdm
unitary_list = []
cost_list = []
# outer loop is sweeping over gc and gc
for m in tqdm(np.linspace(0, 0.5, 47)): # 47
for n in np.linspace(0, 1, 41): # 41
for i in range(1):
gc = n * m * np.pi
gg = (1 - n) * m * np.pi
cost = ConversionGainGate(0, 0, gc, gg, t_el=t).cost()
# need to convert strings to Parameter objects
# the reason need to do this is because need to get reference to the exact parameter object via iteration
pstrs = ["Q0", "Q1"]
pdict = {
str(pstr): [p for p in basis.circuit.parameters if p.name == pstr][0]
for pstr in pstrs
}
qc_init = basis.circuit.assign_parameters({pdict["Q0"]: gc})
qc_init = qc_init.assign_parameters({pdict["Q1"]: gg})
# randomize the remaining parameters
# p = basis.parameter_guess()
# qc_init = qc_init.assign_Xk(p)
# eliminating x-axis symmetry
c = list(c1c2c3(Operator(qc_init).data))
unitary_list.append(c)
cost_list.append(cost)
# add the conjugate
c_copy = c.copy()
if c_copy[0] > 0.5:
c_copy[0] = -1 * c_copy[0] + 1
elif c_copy[0] < 0.5:
c_copy[0] = 1 - c_copy[0]
unitary_list.append(c_copy)
cost_list.append(cost)
# do some preprocessing that takes the smaller cost value if their is a match of coordinates
# no not a good idea
coordinate_2dlist_weyl(unitary_list, c=cost_list)
print(len(unitary_list))
fig = coordinate_2dlist_weyl(unitary_list, c=cost_list)
# save fig as pdfpath_images svg
from slam.utils.visualize import fpath_images
fig.savefig(f"{fpath_images}/candidate_costs.pdf", format="pdf", bbox_inches="tight")
fig.savefig(f"{fpath_images}/candidate_costs.svg", format="svg", bbox_inches="tight")
# if a coordinate is within some threshold of another coordinate, remove the one with the higher cost
for i, (cost, c) in enumerate(zip(cost_list, unitary_list)):
# check if there is a coordinate within some threshold, not including itself
if any(
[
np.linalg.norm(np.array(c) - np.array(c2)) < 0.1
for c2 in unitary_list
if (np.array(c2) != np.array(c)).all()
]
):
# if there is, find the index of the coordinate that is closest
c2 = unitary_list[
np.argmin(
[
np.linalg.norm(np.array(c) - np.array(c2))
for c2 in unitary_list
if (c2 != c).all()
]
)
]
ind = np.where(np.all(unitary_list == c2, axis=1))[0][0]
# if the cost of the coordinate we are checking is higher, remove it
if cost > cost_list[ind]:
unitary_list.pop(i)
cost_list.pop(i)
print(len(unitary_list))
coordinate_2dlist_weyl(unitary_list, c=cost_list);
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
"""
This file contains functions that are written utils/gates/snail_death_gate.py
Refactoring note, should call functions from there instead of writing them here
"""
import matplotlib.pyplot as plt
import numpy as np
c_ampArray = np.linspace(0, 0.8, 81)
g_ampArray = np.linspace(0, 0.8, 81)
from slam.utils.data_utils import h5py_load
glist = h5py_load("snail_death", "snail_death")["snail_death"]
def check_snail(gc, gg):
"""returns true if snail still alive"""
c_ampArray = np.linspace(0, 0.8, 81)
g_ampArray = np.linspace(0, 0.8, 81)
x = np.where(c_ampArray == gc)[0]
y = np.where(g_ampArray == gg)[0]
return glist.T[x,y] > 0.5
def get_speedlimit(gc, gg):
"""Find highest amps (preserving gate ratio) where snail still alive
TODO Make this way smarter by using parametric functions and finding intercepts!
Failing now because not all values are contained in glist linspace array"""
upper_bound_scale = np.min([0.8/gc, 0.8/gg])
scale = upper_bound_scale
y= lambda x: gg/gc
while (gc > 1e-6 and gg > 1e-6) and scale > 0:
sc, sg = gc*scale, gg*scale
scale -= .01 #shrink ratio until valid
if check_snail(sc, sg):
break
return sc, sg
plt.figure()
plt.pcolormesh(g_ampArray, c_ampArray, glist.T, cmap='RdBu', vmax=1, vmin=0)
plt.xlabel("gain amp(DAC)")
plt.ylabel('conv amp(DAC)')
cbar = plt.colorbar()
plt.ylim(0,.8)
plt.xlim(-0.01,.8)
cbar.set_label("g pct", rotation=90)
import json
from matplotlib import pyplot as plt
import numpy as np
from config import srcpath
datapath = f"{srcpath}/data/Q1_11.07mA_snailPump_length0.5_prepareE_False_freqG_9070_freqC_695-11_processed.json"
dd = json.load(open(datapath))
g2_conv = dd["g2_conv"]
g2_gain = dd["g2_gain"]
g_pct = np.array(dd["g_pct"])
plt.figure()
plt.pcolormesh(g2_conv, g2_gain, g_pct.T, shading='auto', cmap='RdBu', vmin=0, vmax=1)
plt.xlabel(f"g2eff_conv (MHz)")
plt.ylabel(f"g2eff_gain (MHz)")
# plt.xticks(np.linspace(0, 50, 6), map(str, np.linspace(0, 50, 6, dtype=int)))
# plt.yticks(np.linspace(0, 15, 4), map(str, np.linspace(0, 15, 4, dtype=int)))
cbar = plt.colorbar()
cbar.set_label("g pct", rotation=90)
cbar.set_ticks([0.0, 0.5, 1.0])
# namign variables to match old version
glist = g_pct
c_ampArray = g2_conv
g_ampArray = g2_gain
# step 1 data cleaning
glist_temp = glist.copy().T
# iterate through each column
for i in range(glist_temp.shape[1]):
# find the last value close to 0.5
idx = np.where(np.isclose(glist_temp[:,i], 0.5, atol=.05))[0]
if len(idx) > 0:
idx = idx[-1]
else:
# set all values to 0
glist_temp[:,i] = 0
continue
# set all values before that to 0
glist_temp[:idx,i] = 0
# set that value to 1
glist_temp[idx,i] = 1
# set every value after that to 0
glist_temp[idx+1:,i] = 0
# remove the obvious outlier
glist_temp[0, 68] = 0
plt.figure()
plt.pcolormesh(c_ampArray, g_ampArray, glist_temp, vmax=1, vmin=0)
plt.ylabel("gain amp(DAC)")
plt.xlabel('conv amp(DAC)')
cbar = plt.colorbar()
cbar.set_label("g pct", rotation=90)
#step 2 reduce dimensionality
coords = []
for i in range(glist_temp.shape[0]):
for j in range(glist_temp.shape[1]):
if glist_temp[i,j] == 1:
coords.append([c_ampArray[j], g_ampArray[i]])
coords.sort(key=lambda x: x[0])
# add in point (1,0) to make sure bounded
coords.append([coords[-1][0],0])
plt.figure()
plt.plot([x[0] for x in coords], [x[1] for x in coords], '-o')
plt.ylabel("gain amp(DAC)")
plt.xlabel('conv amp(DAC)')
cbar.set_label("g pct", rotation=90)
# # don't have to do because already scaled in new data
# # use conv_data and gain_data to see how voltage is related to the gc/gg terms in order to scale the axes properly
# # load from data conv_data and gain_data using h5py
# import h5py
# with h5py.File('data/conv_data.h5', 'r') as hf:
# plt.plot(hf['DAC_list'][:], hf['g2_fit'][:], '-o', label='conv')
# # save slope
# conv_slope = np.average(hf['g2_fit'][:]/hf['DAC_list'][:])
# with h5py.File('data/gain_data.h5', 'r') as hf:
# plt.plot(hf['DAC_list'][:], hf['g2_fit'][:], '-o', label='gain')
# # save slope
# gain_slope = np.average(hf['g2_fit'][:]/hf['DAC_list'][:])
# plt.legend()
# plt.xlabel('DAC')
# plt.ylabel('g2')
# #print slopes
# print(conv_slope, gain_slope)
#step 2.5 arbitrary scaling to convert DAC to Hamiltonian (rad/s) ?
real_scaling = 1
conv_slope =1
gain_slope = 1
# slopes are 1 because already scaled in new data
if real_scaling:
#decide to scale so x and y intercept are near pi/2
#scale x axis
x = [x[0]*conv_slope for x in coords] #0.64*np.pi
# scale y axis
y = [x[1]*gain_slope for x in coords] #1.7*np.pi
# step 2.6 normalization so the maximum intercept is pi/2
# find max between x- and y-axis intercept
max_intercept = np.max([np.abs(x[-1]), np.abs(y[0])])
# scale x and y
x = [x[i]/max_intercept*np.pi/2 for i in range(len(x))]
y = [y[i]/max_intercept*np.pi/2 for i in range(len(y))]
else:
#scale x axis
x = [x[0]*0.64*np.pi for x in coords] #
# scale y axis
y = [x[1]*1.7*np.pi for x in coords] #
# step 3 univariate spline
from scipy.interpolate import UnivariateSpline
N=800
s = UnivariateSpline(x, y, s=0.001)
xs = np.linspace(0, max(x), N)
plt.figure()
# plt.plot(x, y, 'o', xs, s(xs), '-', label="Characterized Speed Limit")
plt.plot(xs, s(xs), '-', label="Characterized Speed Limit")
plt.ylabel("Gain")
plt.xlabel('Conv')
plt.xlim(0,max(xs))
plt.ylim(0,max(s(xs)))
#also put linear fit on plot
s2 = lambda x: -x + np.pi/2
xs = np.linspace(0, np.pi/2, N)
plt.plot(xs, s2(xs), 'g-', label='Linear Speed Limit')
slf = lambda x: np.sqrt((np.pi/2)**2 - x**2)
plt.plot(xs, slf(xs), 'r-', label='Squared Speed Limit')
c = np.pi/4
slf = lambda x: 0.5 * (-2*c + np.sqrt(4*c**2 - 8*c*x + 4*c*np.pi - 4*x**2 + np.pi**2))
plt.plot(xs, slf(xs), 'b-', label='Mid Speed Limit')
#plot cnot gate
gate_c = 0.25*np.pi
gate_g = 0.25*np.pi
if gate_c == 0:
plt.plot([0, 0], [0, max(s(xs))], 'r--', label='CX gate')
else:
ratio = gate_g/gate_c * xs
plt.plot(xs, ratio, 'r--', label='CX gate', alpha=0.5)
# plot B gate
gate_c = 3*np.pi/8
gate_g = 1*np.pi/8
ratio = gate_g/gate_c * xs
plt.plot(xs, ratio, 'b--', label='B gate', alpha=0.5)
gate_c = 1*np.pi/8
gate_g = 3*np.pi/8
ratio = gate_g/gate_c * xs
plt.plot(xs, ratio, 'b--', alpha=0.5)
#plot intersections
if gate_c == 0:
idx = 0
print(xs[idx], s(xs[idx]))
else:
idx = max(np.argwhere(np.abs(ratio - s(xs)) < 0.01))
print(xs[idx], ratio[idx])
plt.plot(xs[idx], s(xs[idx]), 'b*', markersize=8)
idx = max(np.argwhere(np.abs(ratio - s2(xs)) < 0.01))
plt.plot(xs[idx], s2(xs[idx]), 'gP', markersize=8)
plt.title("Speed Limit Characterization")
#show legend underneath plot
plt.legend(loc='upper center', bbox_to_anchor=(0.5, -0.15), fancybox=True, shadow=True, ncol=2)
plt.show()
from slam.utils.gates.bare_candidates import build_gates, get_group_name
from slam.utils.gates.duraton_scaling import cost_scaling, atomic_cost_scaling
unitary_list, coordinate_list = build_gates()
#coordinate_2dlist_weyl(*coordinate_list);
# collect_data(unitary_list)
# step 3 univariate spline
from scipy.interpolate import UnivariateSpline
from weylchamber import WeylChamber, c1c2c3
from tqdm import tqdm
N=800
slf_hardware = UnivariateSpline(x, y, s=0.001)
xs = np.linspace(0, max(x), N)
# make a subfigure for each 1Q duration
durations_1q = [0, 0.1, 0.25]#, 0.5]
with plt.style.context(['science','ieee']):
fig = plt.figure(figsize=(12, 10))
fig.suptitle("Speed Limit Characterization")
for index, duration_1q in enumerate(durations_1q):
ax = fig.add_subplot(2, len(durations_1q), index+1)
# add second row of subfigures, set to be same size as first row
# ax2 = fig.add_subplot(2, len(durations_1q), 1+len(durations_1q)+index, projection="3d", figsize=(16,4))
ax2 = fig.add_subplot(2, len(durations_1q), 1+len(durations_1q)+index, projection="3d")
#set ax2 camera view to be top down
w = WeylChamber()
w.weyl_edge_bg_properties = {'color': 'k', 'linewidth': 0}
w.fig_height = 8
w.fig_width = 8
w.top_margin =0
w.bottom_margin = 0
w.left_margin = 0
w.right_margin = 0
w.elev = 90
w.azim = -90
#remove labels
w.labels = {}
w.render(ax2)
# scale subplots to be same height and width
ax.set_aspect('equal')
# ax2.set_aspect('auto')
# set the z axis to be invisible
ax2.w_zaxis.line.set_lw(0.)
ax2.set_zticks([])
ax2.set_zlabel('')
#ax2.get_zaxis().set_visible(False)
# REFERENCE GATES
#plot cnot gate
gate_c = 0.25*np.pi
gate_g = 0.25*np.pi
if gate_c == 0:
ax.plot([0, 0], [0, max(s(xs))], 'r--', label='CX gate')
else:
ratio = gate_g/gate_c * xs
ax.plot(xs, ratio, 'r--', label='CX gate', alpha=0.25)
# plot B gate
gate_c = 3*np.pi/8
gate_g = 1*np.pi/8
ratio = gate_g/gate_c * xs
ax.plot(xs, ratio, 'b--', label='B gate', alpha=0.25)
gate_c = 1*np.pi/8
gate_g = 3*np.pi/8
ratio = gate_g/gate_c * xs
ax.plot(xs, ratio, 'b--', alpha=0.25)
##############
method_list = ['linear', 'squared', 'hardware'] #'mid'
#color for each method
colors = ['g', 'r', 'b', 'k']
for method_i, method in tqdm(enumerate(method_list)):
if method == 'hardware':
# plt.plot(x, y, 'o', xs, s(xs), '-', label="Characterized Speed Limit")
ax.plot(xs, slf_hardware(xs), label="Characterized Speed Limit", color=colors[method_i], linestyle='-')
s_method = slf_hardware
elif method == 'linear':
#also put linear fit on plot
slf_linear = lambda x: -x + np.pi/2
xs = np.linspace(0, np.pi/2, N)
ax.plot(xs, slf_linear(xs), label='Linear Speed Limit',color=colors[method_i], linestyle='-')
s_method = slf_linear
elif method == 'squared':
slf_squared = lambda x: np.sqrt((np.pi/2)**2 - x**2)
ax.plot(xs, slf_squared(xs), label='Squared Speed Limit',color=colors[method_i], linestyle='-')
s_method = slf_squared
elif method == 'mid':
c = np.pi/4
slf_mid = lambda x: 0.5 * (-2*c + np.sqrt(4*c**2 - 8*c*x + 4*c*np.pi - 4*x**2 + np.pi**2))
ax.plot(xs, slf_mid(xs), label='Mid Speed Limit', color=colors[method_i], linestyle='-')
s_method = slf_mid
for m_i, metric in enumerate([0,1,2, (-1, .47)]):
# matplotlib marker and color unique to each metric
marker = ['o', 'P', '*', 's'][m_i]
label = ['Haar', 'CX', 'SWAP', 'W(.47)'][m_i]
color = colors[method_i]
# add a legend entry for each metric
# group_name = get_group_name(method, duration_1q)
# cost_scaling(speed_method=method, duration_1q=duration_1q)
# gate = pick_winner(group_name, metric=metric, plot=False, tqdm_bool=False)[0]
# gate_c ,gate_g = gate.params[2], gate.params[3]
# XXX rewrite using atomic cost function
raise NotImplementedError("This code is not updated to use the new atomic cost function")
for candidate_gate in unitary_list:
scaled_gate, _ = atomic_cost_scaling(candidate_gate.params, scores=
# plot intersections
if gate_c == 0:
idx = 0
#print(xs[idx], s_method(xs[idx]))
else:
ratio = gate_g/gate_c * xs
idx = max(np.argwhere(np.abs(ratio - s_method(xs)) < 0.02))
#print(xs[idx], ratio[idx])
# only label the last metric
if duration_1q == durations_1q[-1] and method == method_list[-1]:
ax.plot(xs[idx], s_method(xs[idx]), color+marker, markersize=10, label=label)
else:
ax.plot(xs[idx], s_method(xs[idx]), color+marker, markersize=10)
# plot weyl coordinates
ax2.scatter3D(*c1c2c3(gate.to_matrix()), color=color, marker=marker)
# idx = max(np.argwhere(np.abs(ratio - s2(xs)) < 0.01))
# plt.plot(xs[idx], s2(xs[idx]), 'gP', markersize=8)
#plot config
ax.set_ylabel(r"Gain ($\theta_g$)")
ax.set_xlabel(r'Conversion ($\theta_c$)')
ax.set_xlim(0,max(xs))
ax.set_ylim(0,max(slf_linear(xs)))
ax.set_title(f"D[1Q] = {duration_1q}")
# make axis in units of pi
ax.set_xticks(np.linspace(0, np.pi/2, 5))
ax.set_yticks(np.linspace(0, np.pi/2, 5))
ax.set_xticklabels([r'$0$', r'$\pi/8$', r'$\pi/4$', r'$3\pi/8$', r'$\pi/2$'])
ax.set_yticklabels([r'$0$', r'$\pi/8$', r'$\pi/4$', r'$3\pi/8$', r'$\pi/2$'])
#ax.show()
# only show legend once for all subplots
if duration_1q == durations_1q[-1]:
# # set legend to be outside of plot
# handles, labels = ax.get_legend_handles_labels()
# set marker color to black
# handles = [h[0] for h in handles]
# for i in handles:
# i.set_markerfacecolor('k')
# by_label = dict(zip(labels, handles))
# ax.legend(by_label.values(), by_label.keys(), loc='upper center', bbox_to_anchor=(0.5, -0.1), ncol=4, fancybox=True, shadow=True)
# ax.legend(bbox_to_anchor=(.5, .5), loc='upper left', ncols = 9, borderaxespad=0.)
# create legend off to the right
ax.legend(loc='center left', bbox_to_anchor=(1, 0.5))
# force x and y axis to be the same scale
#fig.tight_layout()
plt.show()
from itertools import combinations
coordinate_list = list(w.weyl_points.keys())
print (coordinate_list)
weyl_edges = []
for c1, c2 in combinations(coordinate_list, 2):
if set([c1, c2]) in [set(["A1", "O"]), set(["A1", "A1"]), set(["A1", "A2"])]:
weyl_edges.append([c1, c2, True])
else:
weyl_edges.append([c1, c2, False])
w.weyl_edges = weyl_edges
w.plot()
# save fig as pdf
from slam.utils.visualize import fpath_images
fig.savefig(f'{fpath_images}/speed_limit.pdf', bbox_inches='tight')
#save as svg
fig.savefig(f'{fpath_images}/speed_limit.svg', bbox_inches='tight')
#rewrite ConversionGainGate to have a cost function that is dynamic in the parameters
from slam.utils.gates.custom_gates import ConversionGainGate
class SpeedLimitedGate(ConversionGainGate):
def __init__(self, p1, p2, g1, g2, t_el, speed_limit_function):
self.g1 = g1 #conversion
self.g2 = g2 #gain
self.t_el = t_el
self.slf = speed_limit_function
super().__init__(p1, p2, g1, g2, t_el)
def cost(self):
assert not (self.g1 == 0 and self.g2 ==0)
#norm = np.pi/2 # TODO move norm from preprocessing into here
# get upper bound of g terms from speed limit data
xs = np.linspace(0, np.pi/2, N) #XXX, danger! assumes the max intercept was on the x-axis (assumes y-axis intercept is np.pi/2)
if self.g1 == 0: #avoid case when ratio is undefined by only scaling
idx = 0
scaled_g1, scaled_g2 = float(xs[idx]), float(s(xs[idx]))
else:
ratio = self.g2/self.g1 * xs
idx = max(np.argwhere(np.abs(ratio - self.slf(xs)) < 0.02))[0]
scaled_g1, scaled_g2 = float(xs[idx]), float(ratio[idx]) #conversion, gain
#inversely scale time for new g terms
# should be the same unless either g1 or g2 is 0
if self.g1 == 0:
scale = scaled_g2/self.g2
else:
scale = scaled_g1/self.g1
# if scale < 1 means we are decreasing strength, so increase time
scaled_t = self.t_el / scale
#cost is duration of gate
return scaled_t
c = ConversionGainGate(0, 0, .25*np.pi, .25*np.pi, 1) #using vanilla class same as linear speed limit
c.cost()
c = SpeedLimitedGate(0, 0, .25*np.pi, .25*np.pi, 1, speed_limit_function=s)
c.cost()
s2 = lambda x: -x + np.pi/2
d = SpeedLimitedGate(0, 0, .25*np.pi, .25*np.pi, 1, speed_limit_function=s2)
d.cost()
#rounding error when finding intersection?
e = SpeedLimitedGate(*[0, 0, 0.009817477042468103, 0.18653206380689397, 1], speed_limit_function=s)
e.cost()
# step 3 univariate spline
from scipy.interpolate import UnivariateSpline
N=400
plt.figure()
s2 = lambda x: -x + np.pi/2
xs = np.linspace(0, np.pi/2, N)
plt.plot(xs, s2(xs), 'o-', xs, s2(xs))
plt.ylabel("gain amp(DAC)")
plt.xlabel('conv amp(DAC)')
plt.xlim(0,max(xs))
plt.ylim(0,max(s(xs)))
#plot cnot gate
gate_c = 0.25*np.pi
gate_g = 0.25*np.pi
if gate_c == 0:
plt.plot([0, 0], [0, max(s(xs))], 'ro')
else:
ratio = gate_g/gate_c * xs
plt.plot(xs, ratio, 'r--')
if gate_c == 0:
idx = 0
print(xs[idx], s2(xs[idx]))
else:
idx = max(np.argwhere(np.abs(ratio - s2(xs)) < 0.01))
print(xs[idx], ratio[idx])
plt.plot(xs[idx], s2(xs[idx]), 'ro')
plt.show()
np.pi/2
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
"""Run this cell if in new enviroment without slam installed"""
# ! pip install git+https://github.com/Pitt-JonesLab/slam_decomposition
# #write to config file an empty directory (monkey patching for sake of portability)
# f = open("config.py", "w")
# f.write('srcpath = "content/"')
# f.close()
%matplotlib widget
from slam.utils.pd_playground import ParallelDrivenGateWidget
import numpy as np
from slam.utils.visualize import coordinate_2dlist_weyl
from ipywidgets import interact
# optimize parameter vectors to go to SWAP gate
from qiskit.circuit.library import SwapGate
from weylchamber import c1c2c3
target = SwapGate().to_matrix()
# target_coords = c1c2c3(target)
pdgw = ParallelDrivenGateWidget(
N=10,
gc=np.pi / 4,
gg=np.pi / 4,
gz1=0,
gz2=0,
phase_a=0,
phase_b=0,
phase_c=0,
phase_g=0,
)
# use widget to change parameters
bounds = (-2 * np.pi, 2 * np.pi)
interact(
pdgw.widget_wrap,
q0=bounds,
q1=bounds,
pa=bounds,
pb=bounds,
pc=bounds,
pg=bounds,
gz1=bounds,
gz2=bounds,
);
# # use widget to change parameters
pdgw = ParallelDrivenGateWidget(
N=10, gc=np.pi / 2, gg=0, phase_a=0, phase_b=0, phase_c=0, phase_g=0
)
pdgw2 = ParallelDrivenGateWidget(
N=5, gc=np.pi / 2, gg=0, phase_a=np.pi / 2, phase_b=-np.pi / 8, phase_c=0, phase_g=0
)
pdgw3 = pdgw + pdgw2
bounds = (-2 * np.pi, 2 * np.pi)
gx, gy = list(np.ones(10) * np.pi) + list(np.ones(5) * 2 * np.pi), list(
np.ones(10) * np.pi
) + list(np.ones(5) * np.pi / 2)
pdgw3.prepare_parameters_nonuniform(gx, gy)
pdgw3.iterate_time()
coordinate_2dlist_weyl(*pdgw3.coordinate_list);
# to optimize for SWAP
# # use widget to change parameters
from slam.cost_function import WeylEuclideanCost, MakhlinFunctionalCost
from scipy.optimize import minimize
# ansatz includes solution for midpoint, with 5 remaining parameters
pdgw = ParallelDrivenGateWidget(
N=10, gc=np.pi / 2, gg=0, phase_a=0, phase_b=0, phase_c=0, phase_g=0
)
pdgw2 = ParallelDrivenGateWidget(
N=5, gc=np.pi / 2, gg=0, phase_a=np.pi / 2, phase_b=0, phase_c=0, phase_g=0
)
pdgw3 = pdgw + pdgw2
bounds = (-2 * np.pi, 2 * np.pi)
gx, gy = list(np.ones(10) * np.pi) + list(np.ones(5) * np.pi), list(
np.ones(10) * -np.pi
) + list(np.ones(5) * 0)
cost_f = MakhlinFunctionalCost()
# cost_f = WeylEuclideanCost()
def cost_function(p):
pdgw2 = ParallelDrivenGateWidget(
N=5, gc=np.pi / 2, gg=0, phase_a=p[0], phase_b=p[1], phase_c=p[2], phase_g=p[3]
)
pdgw3 = pdgw + pdgw2
# gx = list(np.ones(10)*np.pi) + list(p[:len(p)//2])
# gy = list(np.ones(10)*np.pi) + list(p[len(p)//2:])
gx = list(np.ones(10) * np.pi) + list(p[4] * np.ones(5))
gy = list(np.ones(10) * np.pi) + list(p[5] * np.ones(5))
pdgw3.prepare_parameters_nonuniform(gx, gy)
# pdgw3.iterate_time()
f = pdgw.solve_end()
current_cost = cost_f.unitary_fidelity(target, f)
# print(current_cost)
return current_cost
# initial guess
# p0 = list(np.ones(5)*np.pi/2) + list(np.ones(5)*np.pi/2) # guess for every parameter
p0 = [np.pi / 2, 0, 0, 0, 2 * np.pi, 0] # one guess for every parameter
ret = minimize(cost_function, p0, method="Nelder-Mead", options={"disp": True})
# display results
# gx = list(np.ones(10)*np.pi) + list(res.x[:len(res.x)//2])
# gy = list(np.ones(10)*np.pi) + list(res.x[len(res.x)//2:])
gx = list(np.ones(10) * np.pi) + list(ret.x[4] * np.ones(5))
gy = list(np.ones(10) * np.pi) + list(ret.x[5] * np.ones(5))
pdgw2 = ParallelDrivenGateWidget(
N=5,
gc=np.pi / 2,
gg=0,
phase_a=ret.x[0],
phase_b=ret.x[1],
phase_c=ret.x[2],
phase_g=ret.x[3],
)
pdgw3 = pdgw + pdgw2
pdgw3.prepare_parameters_nonuniform(gx, gy)
pdgw3.iterate_time()
coordinate_2dlist_weyl(*pdgw3.coordinate_list);
from slam.utils.visualize import plotMatrix
plotMatrix(pdgw3.final_unitary);
from scipy.optimize import minimize
from slam.cost_function import SquareCost
from tqdm import tqdm
pdgw = ParallelDrivenGateWidget(N=15, gc=3 * np.pi / 4, gg=0, phase_c=0, phase_g=0)
pdgw.prepare_parameters_nonuniform(gx, gy)
# define cost function as the distance between the target and each of the end segement points
cost = SquareCost()
gx, gy = list(np.ones(10) * np.pi) + list(np.zeros(5)), list(
np.ones(10) * np.pi
) + list(np.zeros(5))
for n_iter in tqdm(range(1, 2)):
pdgw = ParallelDrivenGateWidget(N=15, gc=3 * np.pi / 4, gg=0, phase_c=0, phase_g=0)
def cost_function(p):
gx = list(np.ones(10) * np.pi) + list(p[: len(p) // 2])
gy = list(np.ones(10) * np.pi) + list(p[len(p) // 2 :])
pdgw.prepare_parameters_nonuniform(gx, gy)
# pdgw.iterate_time()
# f = cost.unitary_fidelity(target, pdgw.final_unitary)
f = cost.unitary_fidelity(target, pdgw.solve_end())
# print(f)
return f
# optimize
res = minimize(cost_function, list(np.zeros(10)), method="Nelder-Mead")
# print res final function value
print(res.fun)
# print(res.x)
gx = list(np.ones(10) * np.pi) + list(res.x[: len(res.x) // 2])
gy = list(np.ones(10) * np.pi) + list(res.x[len(res.x) // 2 :])
print(gx, gy)
pdgw.prepare_parameters_nonuniform(gx, gy)
pdgw.iterate_time()
coordinate_2dlist_weyl(*pdgw.coordinate_list);
# want to check for changing phase, can the final unitary ever be off bottom plane
# twirl phase variables 1000 iterations
# NOTE seems impossible
from tqdm import tqdm
from itertools import permutations
from slam.cost_function import (
WeylEuclideanCost,
SquareReducedCost,
MakhlinFunctionalCost,
SquareReducedBellCost,
)
from slam.utils.pd_playground import ParallelDrivenGateWidget
from qiskit.circuit.library import SwapGate
from weylchamber import c1c2c3
target = SwapGate().to_matrix()
# cost_f = WeylEuclideanCost()
cost_f = SquareReducedCost()
# cost_f = SquareReducedBellCost()
best_cost = None
pdgw = ParallelDrivenGateWidget(
N=10, gc=np.pi / 2, gg=0, phase_a=0, phase_b=0, phase_c=0, phase_g=0
)
# for a in tqdm(list(permutations(np.arange(-2*np.pi, 2*np.pi+np.pi/8, np.pi/2), r=6))):
def cost_function(a):
# # use widget to change parameters
pdgw2 = ParallelDrivenGateWidget(
N=3, gc=np.pi / 2, gg=0, phase_a=a[0], phase_b=a[1], phase_c=a[2], phase_g=a[3]
)
pdgw3 = ParallelDrivenGateWidget(
N=2, gc=np.pi / 2, gg=0, phase_a=a[4], phase_b=a[5], phase_c=a[6], phase_g=a[7]
)
pdgw4 = pdgw + pdgw2 + pdgw3
gx, gy = list(np.ones(10) * np.pi) + list(np.ones(3) * a[8]) + list(
np.ones(2) * a[9]
), list(np.ones(10) * np.pi) + list(np.ones(3) * a[10]) + list(np.ones(2) * a[11])
pdgw4.prepare_parameters_nonuniform(gx, gy)
# pdgw3.iterate_time()
f = pdgw4.solve_end()
# want to track minimum distance to target
current_cost = cost_f.unitary_fidelity(target, f)
return current_cost
# if best_cost is None or current_cost <= best_cost:
# best_cost = current_cost
# best_a = a
# print(best_cost, best_a)
# optimize
# try i times with random initial parameters
from scipy.optimize import minimize
i = 5
for _ in tqdm(range(i)):
res = minimize(
cost_function,
list(np.random.uniform(-2 * np.pi, 2 * np.pi, size=12)),
method="Nelder-Mead",
options={"disp": True},
)
if best_cost is None or res.fun < best_cost:
best_cost = res.fun
best_a = res.x
print(best_cost, best_a)
# 0.013629539844115302 [ 4.87911870e+00 -4.87814684e+00 -5.91729395e+00 4.54059294e+02
# -3.34409934e+00 2.00213460e-01 -5.69159762e+00 4.55756897e+02
# -3.33791862e+00 -3.28845361e+00 3.33429678e+00 -3.27741811e+00]
# #
# best_a = [ 1.40369633, -1.40379037, -6.64622192, 3.2541767, 3.34337449, -0.20441138,
# 5.68834068, 2.26490991, 3.3392069, 3.28468904, -3.34046558, 3.2873195 ]
# plot results
from slam.utils.visualize import coordinate_2dlist_weyl
a = best_a
pdgw = ParallelDrivenGateWidget(
N=10, gc=np.pi / 2, gg=0, phase_a=0, phase_b=0, phase_c=0, phase_g=0
)
pdgw2 = ParallelDrivenGateWidget(
N=3, gc=np.pi / 2, gg=0, phase_a=a[0], phase_b=a[1], phase_c=a[2], phase_g=a[3]
)
pdgw3 = ParallelDrivenGateWidget(
N=2, gc=np.pi / 2, gg=0, phase_a=a[4], phase_b=a[5], phase_c=a[6], phase_g=a[7]
)
pdgw4 = pdgw + pdgw2 + pdgw3
gx, gy = list(np.ones(10) * np.pi) + list(np.ones(3) * a[8]) + list(
np.ones(2) * a[9]
), list(np.ones(10) * np.pi) + list(np.ones(3) * a[10]) + list(np.ones(2) * a[11])
pdgw4.prepare_parameters_nonuniform(gx, gy)
pdgw4.iterate_time(R=5)
coordinate_2dlist_weyl(*pdgw4.coordinate_list);
# plot final unitary
from slam.utils.visualize import plotMatrix
from slam.cost_function import SquareCost
c = SquareCost()
print(c.unitary_fidelity(target, pdgw4.final_unitary))
c1c2c3(pdgw4.final_unitary)
plotMatrix(pdgw4.final_unitary);
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
# for linear, squared, hardware what are the speeds of the basis gates
from slam.utils.gates.custom_gates import ConversionGainGate
from slam.utils.gates.duraton_scaling import atomic_cost_scaling
import numpy as np
speed_method = ["linear", "squared", "hardware"][2]
duration_1q = 0
# first, we need to get a duration scaled iswap gate
iswap = ConversionGainGate(0, 0, np.pi / 2, 0, t_el=1)
scaled_iswap, _ = atomic_cost_scaling(
params=iswap.params,
scores=np.array([0]),
speed_method=speed_method,
duration_1q=duration_1q,
)
print(scaled_iswap.duration)
sqiswap = ConversionGainGate(0, 0, np.pi / 2, 0, t_el=0.5)
scaled_sqiswap, _ = atomic_cost_scaling(
params=sqiswap.params,
scores=np.array([0]),
speed_method=speed_method,
duration_1q=duration_1q,
)
print(scaled_sqiswap.duration)
cnot = ConversionGainGate(0, 0, np.pi / 4, np.pi / 4, t_el=1)
scaled_cnot, _ = atomic_cost_scaling(
params=cnot.params,
scores=np.array([0]),
speed_method=speed_method,
duration_1q=duration_1q,
)
print(scaled_cnot.duration)
sqcnot = ConversionGainGate(0, 0, np.pi / 4, np.pi / 4, t_el=0.5)
scaled_sqcnot, _ = atomic_cost_scaling(
params=sqcnot.params,
scores=np.array([0]),
speed_method=speed_method,
duration_1q=duration_1q,
)
print(scaled_sqcnot.duration)
bgate = ConversionGainGate(0, 0, 3 * np.pi / 8, np.pi / 8, t_el=1)
scaled_bgate, _ = atomic_cost_scaling(
params=bgate.params,
scores=np.array([0]),
speed_method=speed_method,
duration_1q=duration_1q,
)
print(scaled_bgate.duration)
sqbgate = ConversionGainGate(0, 0, 3 * np.pi / 8, np.pi / 8, t_el=0.5)
scaled_sqbgate, _ = atomic_cost_scaling(
params=sqbgate.params,
scores=np.array([0]),
speed_method=speed_method,
duration_1q=duration_1q,
)
print(scaled_sqbgate.duration)
# make plots over candidate gates for each speed limit
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
# need to make figure which shows curved path to build CX and SWAP
# ideally on the same weyl chamber plot
from slam.utils.pd_playground import ParallelDrivenGateWidget, ImprovedCX, ImprovedSWAP
import numpy as np
from slam.utils.visualize import coordinate_2dlist_weyl
from weylchamber import c1c2c3
cx = ImprovedCX()
fig = coordinate_2dlist_weyl(*cx.coordinate_list, c="cyan", no_bar=1);
%matplotlib widget
cx = ImprovedCX()
swap = ImprovedSWAP()
# unoptimized together
fig = coordinate_2dlist_weyl(*cx.baseline_coords, c="cyan", no_bar=1);
# fig = coordinate_2dlist_weyl(*swap.baseline_coords, c='magenta', no_bar=1, fig=fig);
from slam.utils.visualize import fpath_images
# save fig as pdf
cx.fig.savefig(f"{fpath_images}/optimimzed_cx.pdf")
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
%%capture
%pip install qiskit
%pip install qiskit_ibm_provider
%pip install qiskit-aer
# Importing standard Qiskit libraries
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, QuantumCircuit, transpile, Aer
from qiskit_ibm_provider import IBMProvider
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from qiskit.circuit.library import C3XGate
# Importing matplotlib
import matplotlib.pyplot as plt
# Importing Numpy, Cmath and math
import numpy as np
import os, math, cmath
from numpy import pi
# Other imports
from IPython.display import display, Math, Latex
# Specify the path to your env file
env_file_path = 'config.env'
# Load environment variables from the file
os.environ.update(line.strip().split('=', 1) for line in open(env_file_path) if '=' in line and not line.startswith('#'))
# Load IBM Provider API KEY
IBMP_API_KEY = os.environ.get('IBMP_API_KEY')
# Loading your IBM Quantum account(s)
IBMProvider.save_account(IBMP_API_KEY, overwrite=True)
# Run the quantum circuit on a statevector simulator backend
backend = Aer.get_backend('statevector_simulator')
qc_b1 = QuantumCircuit(2, 2)
qc_b1.h(0)
qc_b1.cx(0, 1)
qc_b1.draw(output='mpl', style="iqp")
sv = backend.run(qc_b1).result().get_statevector()
sv.draw(output='latex', prefix = "|\Phi^+\\rangle = ")
qc_b2 = QuantumCircuit(2, 2)
qc_b2.x(0)
qc_b2.h(0)
qc_b2.cx(0, 1)
qc_b2.draw(output='mpl', style="iqp")
sv = backend.run(qc_b2).result().get_statevector()
sv.draw(output='latex', prefix = "|\Phi^-\\rangle = ")
qc_b2 = QuantumCircuit(2, 2)
qc_b2.h(0)
qc_b2.cx(0, 1)
qc_b2.z(0)
qc_b2.draw(output='mpl', style="iqp")
sv = backend.run(qc_b2).result().get_statevector()
sv.draw(output='latex', prefix = "|\Phi^-\\rangle = ")
qc_b3 = QuantumCircuit(2, 2)
qc_b3.x(1)
qc_b3.h(0)
qc_b3.cx(0, 1)
qc_b3.draw(output='mpl', style="iqp")
sv = backend.run(qc_b3).result().get_statevector()
sv.draw(output='latex', prefix = "|\Psi^+\\rangle = ")
qc_b3 = QuantumCircuit(2, 2)
qc_b3.h(0)
qc_b3.cx(0, 1)
qc_b3.x(0)
qc_b3.draw(output='mpl', style="iqp")
sv = backend.run(qc_b3).result().get_statevector()
sv.draw(output='latex', prefix = "|\Psi^+\\rangle = ")
qc_b4 = QuantumCircuit(2, 2)
qc_b4.x(0)
qc_b4.h(0)
qc_b4.x(1)
qc_b4.cx(0, 1)
qc_b4.draw(output='mpl', style="iqp")
sv = backend.run(qc_b4).result().get_statevector()
sv.draw(output='latex', prefix = "|\Psi^-\\rangle = ")
qc_b4 = QuantumCircuit(2, 2)
qc_b4.h(0)
qc_b4.cx(0, 1)
qc_b4.x(0)
qc_b4.z(1)
qc_b4.draw(output='mpl', style="iqp")
sv = backend.run(qc_b4).result().get_statevector()
sv.draw(output='latex', prefix = "|\Psi^-\\rangle = ")
def sv_latex_from_qc(qc, backend):
sv = backend.run(qc).result().get_statevector()
return sv.draw(output='latex')
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(0)
sv_latex_from_qc(qc_ej2, backend)
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(1)
sv_latex_from_qc(qc_ej2, backend)
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(0)
qc_ej2.x(1)
sv_latex_from_qc(qc_ej2, backend)
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(2)
sv_latex_from_qc(qc_ej2, backend)
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(0)
qc_ej2.x(2)
sv_latex_from_qc(qc_ej2, backend)
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(0)
qc_ej2.x(2)
sv_latex_from_qc(qc_ej2, backend)
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(0)
qc_ej2.x(1)
qc_ej2.x(2)
sv_latex_from_qc(qc_ej2, backend)
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(3)
sv_latex_from_qc(qc_ej2, backend)
def circuit_adder (num):
if num<1 or num>8:
raise ValueError("Out of range") ## El enunciado limita el sumador a los valores entre 1 y 8. Quitar esta restricción sería directo.
# Definición del circuito base que vamos a construir
qreg_q = QuantumRegister(4, 'q')
creg_c = ClassicalRegister(1, 'c')
circuit = QuantumCircuit(qreg_q, creg_c)
qbit_position = 0
for element in reversed(np.binary_repr(num)):
if (element=='1'):
circuit.barrier()
match qbit_position:
case 0: # +1
circuit.append(C3XGate(), [qreg_q[0], qreg_q[1], qreg_q[2], qreg_q[3]])
circuit.ccx(qreg_q[0], qreg_q[1], qreg_q[2])
circuit.cx(qreg_q[0], qreg_q[1])
circuit.x(qreg_q[0])
case 1: # +2
circuit.ccx(qreg_q[1], qreg_q[2], qreg_q[3])
circuit.cx(qreg_q[1], qreg_q[2])
circuit.x(qreg_q[1])
case 2: # +4
circuit.cx(qreg_q[2], qreg_q[3])
circuit.x(qreg_q[2])
case 3: # +8
circuit.x(qreg_q[3])
qbit_position+=1
return circuit
add_3 = circuit_adder(3)
add_3.draw(output='mpl', style="iqp")
qc_test_2 = QuantumCircuit(4, 4)
qc_test_2.x(1)
qc_test_2_plus_3 = qc_test_2.compose(add_3)
qc_test_2_plus_3.draw(output='mpl', style="iqp")
sv_latex_from_qc(qc_test_2_plus_3, backend)
qc_test_7 = QuantumCircuit(4, 4)
qc_test_7.x(0)
qc_test_7.x(1)
qc_test_7.x(2)
qc_test_7_plus_8 = qc_test_7.compose(circuit_adder(8))
sv_latex_from_qc(qc_test_7_plus_8, backend)
#qc_test_7_plus_8.draw()
theta = 6.544985
phi = 2.338741
lmbda = 0
alice_1 = 0
alice_2 = 1
bob_1 = 2
qr_alice = QuantumRegister(2, 'Alice')
qr_bob = QuantumRegister(1, 'Bob')
cr = ClassicalRegister(3, 'c')
qc_ej3 = QuantumCircuit(qr_alice, qr_bob, cr)
qc_ej3.barrier(label='1')
qc_ej3.u(theta, phi, lmbda, alice_1);
qc_ej3.barrier(label='2')
qc_ej3.h(alice_2)
qc_ej3.cx(alice_2, bob_1);
qc_ej3.barrier(label='3')
qc_ej3.cx(alice_1, alice_2)
qc_ej3.h(alice_1);
qc_ej3.barrier(label='4')
qc_ej3.measure([alice_1, alice_2], [alice_1, alice_2]);
qc_ej3.barrier(label='5')
qc_ej3.x(bob_1).c_if(alice_2, 1)
qc_ej3.z(bob_1).c_if(alice_1, 1)
qc_ej3.measure(bob_1, bob_1);
qc_ej3.draw(output='mpl', style="iqp")
result = backend.run(qc_ej3, shots=1024).result()
counts = result.get_counts()
plot_histogram(counts)
sv_0 = np.array([1, 0])
sv_1 = np.array([0, 1])
def find_symbolic_representation(value, symbolic_constants={1/np.sqrt(2): '1/√2'}, tolerance=1e-10):
"""
Check if the given numerical value corresponds to a symbolic constant within a specified tolerance.
Parameters:
- value (float): The numerical value to check.
- symbolic_constants (dict): A dictionary mapping numerical values to their symbolic representations.
Defaults to {1/np.sqrt(2): '1/√2'}.
- tolerance (float): Tolerance for comparing values with symbolic constants. Defaults to 1e-10.
Returns:
str or float: If a match is found, returns the symbolic representation as a string
(prefixed with '-' if the value is negative); otherwise, returns the original value.
"""
for constant, symbol in symbolic_constants.items():
if np.isclose(abs(value), constant, atol=tolerance):
return symbol if value >= 0 else '-' + symbol
return value
def array_to_dirac_notation(array, tolerance=1e-10):
"""
Convert a complex-valued array representing a quantum state in superposition
to Dirac notation.
Parameters:
- array (numpy.ndarray): The complex-valued array representing
the quantum state in superposition.
- tolerance (float): Tolerance for considering amplitudes as negligible.
Returns:
str: The Dirac notation representation of the quantum state.
"""
# Ensure the statevector is normalized
array = array / np.linalg.norm(array)
# Get the number of qubits
num_qubits = int(np.log2(len(array)))
# Find indices where amplitude is not negligible
non_zero_indices = np.where(np.abs(array) > tolerance)[0]
# Generate Dirac notation terms
terms = [
(find_symbolic_representation(array[i]), format(i, f"0{num_qubits}b"))
for i in non_zero_indices
]
# Format Dirac notation
dirac_notation = " + ".join([f"{amplitude}|{binary_rep}⟩" for amplitude, binary_rep in terms])
return dirac_notation
def array_to_matrix_representation(array):
"""
Convert a one-dimensional array to a column matrix representation.
Parameters:
- array (numpy.ndarray): The one-dimensional array to be converted.
Returns:
numpy.ndarray: The column matrix representation of the input array.
"""
# Replace symbolic constants with their representations
matrix_representation = np.array([find_symbolic_representation(value) or value for value in array])
# Return the column matrix representation
return matrix_representation.reshape((len(matrix_representation), 1))
def array_to_dirac_and_matrix_latex(array):
"""
Generate LaTeX code for displaying both the matrix representation and Dirac notation
of a quantum state.
Parameters:
- array (numpy.ndarray): The complex-valued array representing the quantum state.
Returns:
Latex: A Latex object containing LaTeX code for displaying both representations.
"""
matrix_representation = array_to_matrix_representation(array)
latex = "Matrix representation\n\\begin{bmatrix}\n" + \
"\\\\\n".join(map(str, matrix_representation.flatten())) + \
"\n\\end{bmatrix}\n"
latex += f'Dirac Notation:\n{array_to_dirac_notation(array)}'
return Latex(latex)
sv_b1 = np.kron(sv_0, sv_0)
array_to_dirac_and_matrix_latex(sv_b1)
sv_b1 = (np.kron(sv_0, sv_0) + np.kron(sv_0, sv_1)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b1)
sv_b1 = (np.kron(sv_0, sv_0) + np.kron(sv_1, sv_1)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b1)
sv_b2 = np.kron(sv_0, sv_0)
array_to_dirac_and_matrix_latex(sv_b2)
sv_b2 = (np.kron(sv_0, sv_0) + np.kron(sv_0, sv_1)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b2)
sv_b2 = (np.kron(sv_0, sv_0) + np.kron(sv_1, sv_1)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b2)
sv_b2 = (np.kron(sv_0, sv_0) - np.kron(sv_1, sv_1)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b2)
sv_b3 = np.kron(sv_0, sv_0)
array_to_dirac_and_matrix_latex(sv_b3)
sv_b3 = np.kron(sv_0, sv_1)
array_to_dirac_and_matrix_latex(sv_b3)
sv_b3 = (np.kron(sv_0, sv_0) - np.kron(sv_0, sv_1)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b3)
sv_b3 = (np.kron(sv_0, sv_1) - np.kron(sv_1, sv_0)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b3)
sv_b3 = (np.kron(sv_0, sv_1) + np.kron(sv_1, sv_0)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b3)
sv_b4 = np.kron(sv_0, sv_0)
array_to_dirac_and_matrix_latex(sv_b4)
sv_b4 = np.kron(sv_0, sv_1)
array_to_dirac_and_matrix_latex(sv_b4)
sv_b4 = (np.kron(sv_0, sv_0) - np.kron(sv_0, sv_1)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b4)
sv_b4 = (np.kron(sv_0, sv_1) - np.kron(sv_1, sv_0)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b4)
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
"""Define circuits to test."""
from supermarq.benchmarks.ghz import GHZ
from supermarq.benchmarks.hamiltonian_simulation import HamiltonianSimulation
from supermarq.benchmarks.qaoa_vanilla_proxy import QAOAVanillaProxy
from supermarq.converters import cirq_to_qiskit
class CircuitTranspilerBenchmark:
# TODO: circuit_lambda could take multiple params if desired
def __init__(self, circuit_lambda, q_range, label):
self.circuit_lambda = circuit_lambda
# self.q_range = q_range
self.label = label
# FIXME should this be a class, q_range is a parameter, instead of dict use get methods
circuits = {}
depth = 10
q_range = None # deprecated, move to backendbenchmark object
# Random
# from qiskit.circuit.random import random_circuit
# random_lambda = lambda q: random_circuit(q, depth, measure=False, max_operands=2)
# label = "Randomized_QC"
# circuits[label] = CircuitTranspilerBenchmark(random_lambda, q_range, label=label)
# # Quantum Volume
from qiskit.circuit.library import QuantumVolume
def qv_lambda(q):
return QuantumVolume(num_qubits=q, depth=q)
label = "Quantum_Volume"
circuits[label] = CircuitTranspilerBenchmark(qv_lambda, q_range, label=label)
# QFT
from qiskit.circuit.library.basis_change import QFT
def qft_lambda(q):
return QFT(q)
label = "QFT"
circuits[label] = CircuitTranspilerBenchmark(qft_lambda, q_range, label=label)
# # Inverse QFT
# inverse_qft_lambda = lambda q: QFT(q, inverse=True)
# label = "IQFT"
# circuits[label] = CircuitTranspilerBenchmark(inverse_qft_lambda, q_range, label=label)
# QAOA, takes a long time to generate - consider capping max size before 20
# qaoa_lambda = lambda q: cirq_to_qiskit(QAOAFermionicSwapProxy(q).circuit())
# label = "QAOA_Fermionic_Swap"
# circuits[label] = CircuitTranspilerBenchmark(qaoa_lambda, q_range, label=label)
# # QAOA vanilla
def qaoa_vanilla_lambda(q):
return cirq_to_qiskit(QAOAVanillaProxy(q).circuit())
label = "QAOA_Vanilla"
circuits[label] = CircuitTranspilerBenchmark(qaoa_vanilla_lambda, q_range, label=label)
# VQE - very slow to generate
# vqe_lambda = lambda q: cirq_to_qiskit(VQEProxy(q, 4).circuit()[0])
# label = "VQE"
# circuits[label] = CircuitTranspilerBenchmark(vqe_lambda, q_range, label=label)
# Simulation
def hamiltonian_lambda(q):
return cirq_to_qiskit(HamiltonianSimulation(q, 1 / depth, 0.5).circuit())
label = "TIM_Hamiltonian"
circuits[label] = CircuitTranspilerBenchmark(hamiltonian_lambda, q_range, label=label)
from qiskit import QuantumCircuit
# weighted adder or ripple carry adder
from qiskit.circuit.library.arithmetic.adders.cdkm_ripple_carry_adder import (
CDKMRippleCarryAdder,
)
# using trick of composing into an empty circuit so that it builds everything into a single quantumregister
def adder_lambda(q):
return (
QuantumCircuit(q)
.compose(CDKMRippleCarryAdder(num_state_qubits=int((q - 1) / 2)), inplace=False)
.decompose()
.decompose()
.decompose()
)
label = "Adder"
circuits[label] = CircuitTranspilerBenchmark(adder_lambda, q_range, label=label)
# multiplier
# from qiskit.circuit.library.arithmetic.multipliers import RGQFTMultiplier
# multiplier_lambda = (
# lambda q: QuantumCircuit(q)
# .compose(RGQFTMultiplier(num_state_qubits=int(q / 4)), inplace=False)
# .decompose()
# .decompose()
# .decompose()
# )
# label = "Multiplier"
# circuits[label] = CircuitTranspilerBenchmark(multiplier_lambda, q_range, label=label)
# # GHZ
def ghz_lambda(q):
return cirq_to_qiskit(GHZ(q).circuit())
label = "GHZ"
circuits[label] = CircuitTranspilerBenchmark(ghz_lambda, q_range, label=label)
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
import logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)
import matplotlib.pyplot as plt
import numpy as np
from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
from qiskit.quantum_info import Operator
from weylchamber import c1c2c3
from slam.basisv2 import CircuitTemplateV2
from slam.utils.gates.custom_gates import ConversionGainSmush1QPhaseGate
from slam.utils.visualize import coordinate_2dlist_weyl, update_coordinate_2dlist_weyl
class ParallelDrivenGateWidget:
def __init__(
self,
N=10,
gc=np.pi / 2,
gg=0,
gz1=0,
gz2=0,
phase_a=0,
phase_b=0,
phase_c=0,
phase_g=0,
) -> None:
self.N = N
self.gc = gc
self.gg = gg
self.gz1 = gz1
self.gz2 = gz2
self.phase_a = phase_a
self.phase_b = phase_b
self.phase_c = phase_c
self.phase_g = phase_g
self.t = 0.1
self.timesteps = 1
self.duration_1q = self.t / self.timesteps
self.construct_basis()
self.prepare_parameters(0, 0)
self.fig = None
def __add__(self, other):
if self.qc is None:
self.construct_basis()
if other.qc is None:
other.construct_basis()
# need to rename the parameters to avoid conflicts
for p in self.qc.parameters:
self.qc = self.qc.assign_parameters({p: Parameter(str(p) + "_")})
ret = ParallelDrivenGateWidget()
ret.qc = self.qc.compose(other.qc)
ret.N = self.N + other.N
return ret
def construct_basis(self):
varg_offset = 0
# ConversionGainSmushGate
def pp2(*vargs):
return ConversionGainSmush1QPhaseGate(
self.phase_a,
self.phase_b,
self.phase_c,
self.phase_g,
self.gc,
self.gg,
self.gz1,
self.gz2,
vargs[varg_offset : varg_offset + round(self.t / self.duration_1q)],
vargs[varg_offset + round(self.t / self.duration_1q) :],
t_el=self.t,
)
self.basis = CircuitTemplateV2(
n_qubits=2,
base_gates=[pp2],
edge_params=[[(0, 1)]],
no_exterior_1q=True,
param_vec_expand=[
varg_offset,
round(self.t / self.duration_1q),
round(self.t / self.duration_1q),
],
)
self.basis.build(1)
# basis.circuit.draw(output='mpl');
# repeat the atomic pd gate multiple times
qc = QuantumCircuit(2)
for _ in range(self.N):
qc = qc.compose(self.basis.circuit)
self.qc = qc
def plot(self):
self.fig = coordinate_2dlist_weyl(*self.coordinate_list)
plt.show()
def widget_wrap(self, q0, q1, pa, pb, pc, pg, gz1, gz2):
self.gz1 = gz1
self.gz2 = gz2
self.phase_a = pa
self.phase_b = pb
self.phase_c = pc
self.phase_g = pg
self.construct_basis()
self.prepare_parameters(q0, q1)
self.iterate_time()
if self.fig is not None:
self.fig = update_coordinate_2dlist_weyl(self.fig, *self.coordinate_list)
# self.fig.show()
else:
self.fig = coordinate_2dlist_weyl(*self.coordinate_list)
plt.show()
def widget_wrap_different_start(self, q0, q1):
self.prepare_parameters(q0, q1)
self.iterate_time_different_start(R=25)
if self.fig is not None:
self.fig = update_coordinate_2dlist_weyl(self.fig, *self.coordinate_list)
# self.fig.show()
else:
self.fig = coordinate_2dlist_weyl(*self.coordinate_list)
plt.show()
def widget_wrap_nonuniform(self, g0_vector, g1_vector):
self.prepare_parameters_nonuniform(g0_vector, g1_vector)
self.iterate_time()
if self.fig is not None:
self.fig = update_coordinate_2dlist_weyl(self.fig, *self.coordinate_list)
# self.fig.show()
else:
self.fig = coordinate_2dlist_weyl(*self.coordinate_list)
plt.show()
def prepare_parameters(self, q0, q1):
i = 0
out = self.qc.copy()
for instr, qargs, cargs in out:
if instr.params and instr.name == "2QSmushGate":
instr.params[4:6] = [q0, q1]
instr.params[-1] = Parameter(f"t{i}")
i += 1
elif instr.params and instr.name == "2QSmushGate1QPhase":
instr.params[8:10] = [q0, q1]
instr.params[-1] = Parameter(f"t{i}")
i += 1
self.prep_qc = out
def prepare_parameters_nonuniform(self, g0_vector, g1_vector):
assert len(g0_vector) == len(g1_vector) == self.N
i = 0
out = self.qc.copy()
for instr, qargs, cargs in out:
if instr.params and instr.name == "2QSmushGate":
instr.params[4:6] = [g0_vector[i], g1_vector[i]]
instr.params[-1] = Parameter(f"t{i}")
i += 1
elif instr.params and instr.name == "2QSmushGate1QPhase":
instr.params[8:10] = [g0_vector[i], g1_vector[i]]
instr.params[-1] = Parameter(f"t{i}")
i += 1
self.prep_qc = out
def solve_end(self):
# bind each time to full duration and evalute
qc = QuantumCircuit(2)
# copying the circuit manually this way moves t parameters into the parameterview object
for gate in self.prep_qc:
qc.append(gate[0], gate[1])
for i in range(self.N):
qc = qc.bind_parameters({qc[i][0].params[-1]: self.duration_1q})
return Operator(qc).data
def iterate_time(self, R=5):
# R = 5 # resolution
endpoints = range(1, self.N + 1)
coordinate_list = []
end_segment_list = []
for end in endpoints:
temp_coords = []
qc = QuantumCircuit(2)
for gate in self.prep_qc[0:end]:
qc.append(gate[0], gate[1])
qc2 = qc.copy()
# for all prior 2Q gates, set time parameter to full length
for i in [el for el in endpoints if el < end]:
qc2 = qc2.bind_parameters({qc2[i - 1][0].params[-1]: self.duration_1q})
# for current 2Q gate, iterate over time and append coordinate
for t in np.linspace(0, self.duration_1q, R):
qc3 = qc2.bind_parameters({qc2[end - 1][0].params[-1]: t})
# eliminating x-axis symmetry
c = list(c1c2c3(Operator(qc3).data))
if c[0] > 0.5:
c[0] = -1 * c[0] + 1
temp_coords.append(c)
coordinate_list.append(temp_coords)
end_segment_list.append(c)
self.coordinate_list = coordinate_list
self.end_segment_list = end_segment_list
self.final_unitary = Operator(qc3).data
# qc2.draw(output='mpl');
def iterate_time_different_start(self, R=5):
# R = 5 # resolution
endpoints = range(1, self.N + 1)
coordinate_list = []
end_segment_list = []
for end_iter, end in enumerate(endpoints):
temp_coords = []
qc = QuantumCircuit(2)
# for gate in self.prep_qc[0:end]:
# qc.append(gate[0], gate[1])
qc.rzx(np.pi / 5 * end_iter, 0, 1)
# append the self.prep_qc
for gate in self.prep_qc[end_iter : end_iter + 1]:
qc.append(gate[0], gate[1])
qc2 = qc.copy()
# # for all prior 2Q gates, set time parameter to full length
# for i in [el for el in endpoints if el < end]:
# qc2 = qc2.bind_parameters({qc2[i-1][0].params[-1] : self.duration_1q})
# for current 2Q gate, iterate over time and append coordinate
for t in np.linspace(0, self.duration_1q, R):
qc3 = qc2.bind_parameters({qc2[1][0].params[-1]: t})
# eliminating x-axis symmetry
c = list(c1c2c3(Operator(qc3).data))
if c[0] > 0.5:
c[0] = -1 * c[0] + 1
temp_coords.append(c)
coordinate_list.append(temp_coords)
end_segment_list.append(c)
self.coordinate_list = coordinate_list
self.end_segment_list = end_segment_list
self.final_unitary = Operator(qc3).data
# qc2.draw(output='mpl');
class ImprovedCX(ParallelDrivenGateWidget):
def __init__(self):
super().__init__()
self.prepare_parameters_nonuniform([3] * self.N, [0] * self.N)
self.iterate_time()
R = 5
# append 1Q at (0,0,0) and (0.5, 0 ,0)
self.coordinate_list.append([[0, 0, 0]] * R)
self.coordinate_list.append([(0.5, 0, 0)] * R)
# want to plot comparing the nonoptimized version
# spline between (0,0,0), (.25, .25, 0), (.5, 0, 0)
baseline_coords = []
# interpolate endpoints inclusive
i_steps = 25 # hardcoded but this is R * t/duration_1q
baseline_coords.append(
[
[0.25 / (i_steps - 1) * i, 0.25 / (i_steps - 1) * i, 0]
for i in range(i_steps)
]
)
# interpolate 5 points between (.25 .25 0) and (.5, 0, 0)
baseline_coords.append(
[
[0.25 + 0.25 / (i_steps - 1) * i, 0.25 - 0.25 / (i_steps - 1) * i, 0]
for i in range(i_steps)
]
)
baseline_coords.append([[0, 0, 0]] * R)
baseline_coords.append([[0.25, 0.25, 0]] * R)
baseline_coords.append([[0.5, 0, 0]] * R)
self.baseline_coords = baseline_coords
# self.fig = coordinate_2dlist_weyl(*baseline_coords, c='cyan', no_bar=1, fig=self.fig);
# self.fig = coordinate_2dlist_weyl(*self.coordinate_list, c='red', no_bar=1);
# plt.show()
class ImprovedSWAP(ParallelDrivenGateWidget):
def __init__(self):
super().__init__()
self.prepare_parameters_nonuniform([np.pi] * self.N, [np.pi] * self.N)
self.iterate_time()
R = 5
# tack on the final sqiswap, found from decomp_trajectory.ipynb
# we tried to optimize this away but could not perfectly do so yet
# start with the previous circuit all binded
extended_qc = self.prep_qc.copy()
# for gate in extended_qc:
# gate[0].params[-1] = self.duration_1q
# XXX ugly hardcoding because we are messing with parameters in an unsafe way
# ie circuit parameter table is out of date
for gate in range(self.N):
extended_qc[gate][0].params[-1] = self.duration_1q
# next build the remaining gates
from qiskit.circuit.library import U3Gate
extended_qc.append(
U3Gate(7.84862563826406, 9.44285614361501, 2.30856826810552), [0]
)
extended_qc.append(
U3Gate(7.85928560541358, 9.44027709402712, -3.9923157086907), [0]
)
for _ in np.linspace(0, R):
c = list(c1c2c3(Operator(extended_qc).data))
if c[0] > 0.5:
c[0] = -1 * c[0] + 1
self.coordinate_list.append(c)
# for _ in range(self.N/2): # should be N=10, and N/2
# self.qc = self.qc.compose(self.basis.circuit)
# now need to compute final part of trajectory
# this is messy because in parent class, we assumed there were no interior 1Q gates
# hardcode, lets just go back 6 timesteps from the end
# finally
# append 1Q at (0,0,0) and (0.5, 0.5 ,0.5)
self.coordinate_list.append([[0, 0, 0]] * 5)
self.coordinate_list.append([(0.5, 0.5, 0.5)] * 5)
# self.coordinate_list = coordinate_list
# self.end_segment_list = end_segment_list
# self.final_unitary = Operator(qc3).data
# self.fig = coordinate_2dlist_weyl(*self.coordinate_list);
# plt.show()
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
from typing import List
import numpy as np
import weylchamber
from qiskit.circuit.gate import Gate
from qiskit.circuit.parameterexpression import ParameterValueType
from qiskit.extensions import UnitaryGate
from slam.hamiltonian import (
CirculatorHamiltonian,
ConversionGainPhaseHamiltonian,
ConversionGainSmush,
ConversionGainSmush1QPhase,
)
"""
Library of useful gates that aren't defined natively in qiskit
Example Usage:
from custom_gates import *
from qiskit import QuantumCircuit
qc = QuantumCircuit(2)
qc.append(RiSwapGate(1/4), [0,1])
qc.draw(output='mpl')
"""
class CustomCostGate(Gate):
# want to build a gate progamatically from a unitary
# cost value used in expected haar calcuation
def __init__(self, unitary, str, cost=1, duration=1, num_qubits=2):
self.unitary = unitary
self.str = str
self.c = cost
# self.global_phase = 0 #idk why the dag method requires this
super().__init__(str, num_qubits=num_qubits, params=[], label=str)
self.duration = duration # duration is attribution not duration
@classmethod
def from_gate(cls, gate: Gate, cost: float):
return cls(gate.to_matrix(), str(gate), cost=cost)
# we use this duration property in the speed limit pass sub
# we build a dummy gate that sets duration such that fooanalysis counts correctly
# the fam substitution messes up our custom scaled gates but this is a nice work around
# def duration(self):
# return self.d
def cost(self):
return self.c
def __str__(self):
return self.str
def __array__(self, dtype=None):
return np.array(self.unitary, dtype)
# class VSwap(Gate):
# def __init__(self, t_el: ParameterValueType = 1):
# super().__init__("vswap", 3, [t_el], "VSWAP")
# # v_nn = np.sqrt(2) * np.pi / np.arccos(1 / np.sqrt(3))
# # self.v_params = [np.pi / 2, np.pi / 2, 0, np.pi / v_nn, np.pi / v_nn, 0]
# #use a more standardized normalization
# v_nn = 4/np.sqrt(2) #1.5iswap
# self.v_params = [np.pi / 2, np.pi / 2, 0, np.pi / v_nn, np.pi / v_nn, 0] #V-swap
# #self._array = CirculatorHamiltonian.construct_U(*v_params,t=t_el)
# def __array__(self, dtype=None):
# # v_nn = np.sqrt(2)*np.pi/np.arccos(1/np.sqrt(3))
# # params = [np.pi/2,np.pi/2,0, np.pi/v_nn, np.pi/v_nn, 0]
# self._array = CirculatorHamiltonian.construct_U(*self.v_params,t=self.params[0])
# return self._array.full()
# def inverse(self):
# return UnitaryGate(np.matrix.getH(self.__array__()))
# class DeltaSwap(Gate):
# def __init__(self, t_el: ParameterValueType = 1):
# super().__init__("Δswap", 3, [t_el], "ΔSWAP")
# nn = 3 * np.sqrt(3) / 2
# self.v_params = [np.pi / 2, -np.pi / 2, np.pi / 2, np.pi / nn, np.pi / nn, np.pi / nn] #smiley
# def __array__(self, dtype=None):
# self._array = CirculatorHamiltonian.construct_U(*self.v_params,t=self.params[0])
# return self._array.full()
# def inverse(self):
# return UnitaryGate(np.matrix.getH(self.__array__()))
class CirculatorSNAILGate(Gate):
def __init__(
self,
p1: ParameterValueType,
p2: ParameterValueType,
p3: ParameterValueType,
g1: ParameterValueType,
g2: ParameterValueType,
g3: ParameterValueType,
t_el: ParameterValueType = 1,
):
super().__init__("3QGate", 3, [p1, p2, p3, g1, g2, g3, t_el], "3QGate")
# XXX can only assign duration after init with real values
if all([isinstance(p, (int, float)) for p in self.params]):
self.duration = self.cost()
# NOTE: we don't want this param in the constr ctor, it messes len(signature(gate).parameters) in template construction
def set_str(self, str):
self._label = str
self._name = str
def __array__(self, dtype=None):
self._array = CirculatorHamiltonian.construct_U(
*[float(el) for el in self.params[0:-1]], t=float(self.params[-1])
)
return self._array.full()
def cost(self):
# #something to prevent infinitely small/negative values
# if all([float(el) <= (1/20) for el in self.params[3:-1]]):
# return 0
norm = np.pi / 2
# abs because g can be negative, just consider its absolute strength
c = (sum(abs(np.array(self.params[3:-1]))) * self.params[-1]) / norm
return c
def fidelity(self):
c = self.cost()
base = 0.999
return np.max(1 - (1 - base) * float(c), 0)
def inverse(self):
return UnitaryGate(np.matrix.getH(self.__array__()))
class VSwap(CirculatorSNAILGate):
def __init__(
self,
t_el: ParameterValueType = 1,
) -> None:
v_nn = 4 / np.sqrt(2) # 1.5iswap
super().__init__(
*[np.pi / 2, np.pi / 2, 0, np.pi / v_nn, np.pi / v_nn, 0], t_el=t_el
)
self.set_str("VSWAP")
class DeltaSwap(CirculatorSNAILGate):
def __init__(self, t_el: ParameterValueType = 1) -> None:
nn = 3 * np.sqrt(3) / 2
super().__init__(
*[np.pi / 2, -np.pi / 2, np.pi / 2, np.pi / nn, np.pi / nn, np.pi / nn],
t_el=t_el,
)
self.set_str("Δ-iSWAP")
class ConversionGainGate(Gate):
def __init__(
self,
p1: ParameterValueType,
p2: ParameterValueType,
g1: ParameterValueType,
g2: ParameterValueType,
t_el: ParameterValueType = 1,
):
super().__init__("2QGate", 2, [p1, p2, g1, g2, t_el], "2QGate")
# XXX can only assign duration after init with real values
if all([isinstance(p, (int, float)) for p in self.params]):
self.duration = (
self.cost()
) # XXX not really duration since always normalized to norm=1
self.name = str(self)
def __array__(self, dtype=None):
self._array = ConversionGainPhaseHamiltonian.construct_U(
*[float(el) for el in self.params[0:-1]], t=float(self.params[-1])
)
return self._array.full()
# overwrite string representation
def __str__(self):
g1 = self.params[2]
g2 = self.params[3]
t = self.params[4]
# truncate to 8 decimal places
s = f"2QGate({g1:.8f}, {g2:.8f}, {t:.8f})"
return s
def normalize_duration(self, new_duration):
# scales g terms such that t is new_duration
# this is useful for loading gates from a file, matching file hashes
# save the old duration
old_duration = self.duration
t = self.params[-1]
self.params[2] = self.params[2] * t / new_duration
self.params[3] = self.params[3] * t / new_duration
self.params[-1] = new_duration
# assert the duration has not hcnaged
assert self.duration == old_duration
self = ConversionGainGate(*self.params)
def cost(self):
norm = np.pi / 2
# sum the g terms
c = (sum(abs(np.array(self.params[2:4]))) * self.params[-1]) / norm
return c
class ConversionGainSmushGate(Gate):
def __init__(
self,
pc: ParameterValueType,
pg: ParameterValueType,
gc: ParameterValueType,
gg: ParameterValueType,
gx: List[ParameterValueType],
gy: List[ParameterValueType],
t_el: ParameterValueType = 1,
):
self.xy_len = len(gx)
assert len(gx) == len(gy)
self.t_el = t_el
super().__init__(
"2QSmushGate", 2, [pc, pg, gc, gg, *gx, *gy, t_el], "2QSmushGate"
)
# XXX can only assign duration after init with real values
# XXX vectors will break this type checking
# XXX not checking if time is real valued!!
if all([isinstance(p, (int, float)) for p in self.params[0:4]]):
self.duration = self.cost()
def __array__(self, dtype=None):
self._array = ConversionGainSmush.construct_U(
float(self.params[0]),
float(self.params[1]),
float(self.params[2]),
float(self.params[3]),
[float(el) for el in self.params[4 : 4 + self.xy_len]],
[float(el) for el in self.params[4 + self.xy_len : -1]],
t=float(self.params[-1]),
)
return (
self._array
) # don't need full() since multiplication happens inside the construct_U function
def cost(self):
norm = np.pi / 2
# sum the g terms, ignore the x and y terms
# idea is that 1Q gates drive qubits not SNAIL so don't contribute to speed limit
c = (sum(abs(np.array(self.params[2:4]))) * self.params[-1]) / norm
return c
class ConversionGainSmush1QPhaseGate(Gate):
def __init__(
self,
pa: ParameterValueType,
pb: ParameterValueType,
pc: ParameterValueType,
pg: ParameterValueType,
gc: ParameterValueType,
gg: ParameterValueType,
gz1: ParameterValueType,
gz2: ParameterValueType,
gx: List[ParameterValueType],
gy: List[ParameterValueType],
t_el: ParameterValueType = 1,
):
self.xy_len = len(gx)
assert len(gx) == len(gy)
self.t_el = t_el
super().__init__(
"2QSmushGate1QPhase",
2,
[pa, pb, pc, pg, gc, gg, gz1, gz2, *gx, *gy, t_el],
"2QSmushGate1QPhase",
)
# XXX can only assign duration after init with real values
# XXX vectors will break this type checking
# XXX not checking if time is real valued!!
if all([isinstance(p, (int, float)) for p in self.params[:8]]):
self.duration = self.cost()
def __array__(self, dtype=None):
self._array = ConversionGainSmush1QPhase.construct_U(
float(self.params[0]),
float(self.params[1]),
float(self.params[2]),
float(self.params[3]),
float(self.params[4]),
float(self.params[5]),
float(self.params[6]),
float(self.params[7]),
[float(el) for el in self.params[8 : 8 + self.xy_len]],
[float(el) for el in self.params[8 + self.xy_len : -1]],
t=float(self.params[-1]),
)
return (
self._array
) # don't need full() since multiplication happens inside the construct_U function
def cost(self):
norm = np.pi / 2
# sum the g terms, ignore the x and y terms
# idea is that 1Q gates drive qubits not SNAIL so don't contribute to speed limit
c = (sum(abs(np.array(self.params[4:6]))) * self.params[-1]) / norm
return c
class CParitySwap(Gate):
def __init__(self, _: ParameterValueType = None):
super().__init__("cpswap", 3, [], "CParitySwap")
# an alternative defintion using hamiltonian
# we just have it hardcoded instead
# nn = 3 * np.sqrt(3) / 2
# params = [-np.pi / 2, np.pi / 2, -np.pi / 2, np.pi / nn, np.pi / nn, np.pi / nn] #frowny
# params = [np.pi / 2, -np.pi / 2, np.pi / 2, np.pi / nn, np.pi / nn, np.pi / nn] #smiley
# from hamiltonian import CirculatorHamiltonian
# self._array = CirculatorHamiltonian.construct_U(*params)
def __array__(self, dtype=None):
return np.array(
[
[1, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0],
[0, 1, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 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, 0, 0, 0, 1],
],
dtype=dtype,
)
def _define(self):
"""Gate ccx a,b,c { h c; cx b,c; tdg c; cx a,c; t c; cx b,c; tdg c; cx
a,c; t b; t c; h c; cx a,b; t a; tdg b; cx a,b;}"""
# pylint: disable=cyclic-import
from qiskit.circuit.quantumcircuit import QuantumCircuit
# q_0: ─X──X──X──X─
# │ │ │ │
# q_1: ─X──■──X──┼─
# │ │ │
# q_2: ─■──X─────X─
qc = QuantumCircuit(3, name=self.name)
qc.cswap(2, 0, 1)
qc.cswap(1, 0, 2)
qc.swap(0, 1)
qc.swap(0, 2)
self.definition = qc
class Margolus(Gate):
def __init__(self, _: ParameterValueType = None):
super().__init__("margolus", 3, [], "Margolus")
def __array__(Self, dtype=None):
return 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, 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],
],
dtype=dtype,
)
class CanonicalGate(Gate):
def __init__(self, alpha, beta, gamma, name="can"):
super().__init__(name, 2, [alpha, beta, gamma], name)
# normalize to convention
alpha, beta, gamma = [2 * x / np.pi for x in (alpha, beta, gamma)]
self.data = weylchamber.canonical_gate(alpha, beta, gamma).full()
def __array__(self, dtype=None):
return np.array(self.data, dtype=dtype)
class BerkeleyGate(CanonicalGate):
def __init__(self):
super().__init__(np.pi / 4, np.pi / 8, 0, name="B")
def __str__(self):
return "B"
# alternative definition
# def __init__(self):
# from hamiltonian import ConversionGainHamiltonian
# ConversionGainHamiltonian.construct_U(3*np.pi/8, np.pi/8)
# ...
class CCZGate(Gate):
def __init__(self, _: ParameterValueType = None):
super().__init__("ccz", 3, [], "CCZGate")
def __array__(self, dtype=None):
return 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, 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],
],
dtype=dtype,
)
class CCiXGate(Gate):
def __init__(self, _: ParameterValueType = None):
super().__init__("ccix", 3, [], "CCiXGate")
def __array__(Self, dtype=None):
return 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, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 1j],
[0, 0, 0, 0, 0, 0, 1j, 0],
],
dtype=dtype,
)
class CiSwap(Gate):
def __init__(self, _: ParameterValueType = None):
super().__init__("ciswap", 3, [], "CiSwap")
def __array__(Self, dtype=None):
return 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, 1, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 1j, 0],
[0, 0, 0, 0, 0, 1j, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 1],
],
dtype=dtype,
)
class Peres(Gate):
def __init__(self, _: ParameterValueType = None):
super().__init__("peres", 3, [], "PERES")
def __array__(Self, dtype=None):
return 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, 0, 0, 1],
[0, 0, 0, 0, 0, 0, 1, 0],
[0, 0, 0, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 1, 0, 0, 0],
],
dtype=dtype,
)
class FSim(Gate):
def __init__(self, theta: ParameterValueType, phi: ParameterValueType):
"""SYC: FSim(theta=np.pi/2, phi=np.pi/6)"""
super().__init__("fsim", 2, [theta, phi])
def __array__(self, dtype=None):
return np.array(
[
[1, 0, 0, 0],
[0, np.cos(self.params[0]), -1j * np.sin(self.params[0]), 0],
[0, -1j * np.sin(self.params[0]), np.cos(self.params[0]), 0],
[0, 0, 0, np.exp(1j * self.params[1])],
],
dtype=dtype,
)
from slam.hamiltonian import FSimHamiltonian
class FSimHamiltonianGate(Gate):
def __init__(
self, g: ParameterValueType, eta: ParameterValueType, t: ParameterValueType
):
super().__init__("fsim", 2, [g, eta, t])
def __array__(self, dtype=None):
self._array = FSimHamiltonian.construct_U(
*[float(el) for el in self.params[0:-1]], t=float(self.params[-1])
)
return self._array.full()
class SYC(FSim):
def __init__(self):
super().__init__(np.pi / 2, np.pi / 6)
def __str__(self):
return self.latex_string(self.params)
@staticmethod
def latex_string(gate_params):
return "SYC"
class RiSwapGate(Gate):
# turns out you can also do qiskit.iSwapGate().power(1/n)
# but I didnt know about the power fucntion until recently :(
r"""RiSWAP gate.
**Circuit Symbol:**
.. parsed-literal::
q_0: ─⨂─
R(alpha)
q_1: ─⨂─
"""
def __init__(self, alpha: ParameterValueType):
"""Create new iSwap gate."""
# super().__init__(
# "riswap", 2, [alpha], label=r"$\sqrt[" + str(int(1 / alpha)) + r"]{iSwap}$"
# )
super().__init__("riswap", 2, [alpha], label="riswap")
# XXX can only assign duration after init with real values
if all([isinstance(p, (int, float)) for p in self.params]):
self.duration = self.cost()
# including this seems to break the decompose method
# we don't want to define riswap in terms of other gates, leave it as riswap primitives
# def _define(self):
# from qiskit import QuantumCircuit
# qc = QuantumCircuit(2)
# from qiskit.circuit.library.standard_gates import iSwapGate
# qc.append(iSwapGate().power(1/self.params[0]), [0, 1])
# self.definition = qc
def cost(self):
# norm = np.pi/2
# I don't need to use nrom bc already considered in parameter definition
# e.g. sqisw has params[0] := 1/2
return float(self.params[0])
def fidelity(self):
if float(self.params[0]) <= (
1 / 20
): # something to prevent infinitely small/negative values
return 0
base = 0.999
return np.max(1 - (1 - base) * float(self.params[0]), 0)
def __array__(self, dtype=None):
"""Return a numpy.array for the RiSWAP gate."""
alpha = float(self.params[0]) / 2
cos = np.cos(np.pi * alpha)
isin = 1j * np.sin(np.pi * alpha)
return np.array(
[
[1, 0, 0, 0],
[0, cos, isin, 0],
[0, isin, cos, 0],
[0, 0, 0, 1],
],
dtype=dtype,
)
def __str__(self):
return RiSwapGate.latex_string(self.params)
@staticmethod
def latex_string(gate_params=None):
if gate_params is None:
return r"$\sqrt[n]{iSwap}$"
else:
n = 1 / gate_params[0]
return r"$\sqrt[" + str(int(n)) + r"]{iSwap}$"
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
import logging
logger = logging.getLogger()
import numpy as np
from qiskit import QuantumCircuit
from weylchamber import c1c2c3
from slam.basis import CircuitTemplate, MixedOrderBasisCircuitTemplate
from slam.basisv2 import CircuitTemplateV2
from slam.cost_function import SquareCost
from slam.optimizer import TemplateOptimizer
from slam.utils.gates.custom_gates import ConversionGainGate
from slam.utils.polytopes.polytope_wrap import monodromy_range_from_target
def recursive_sibling_check(
basis: CircuitTemplate,
target_u,
basis_factor=1,
rec_iter_factor=1,
cost_1q=0.1,
use_smush=False,
):
"""Function used to instantiate a circuit using 1Q gate simplification
rules basis_factor is duration of root basis gate."""
# get class of current recursion level gate
child_gate = next(basis.gate_2q_base)
# check if target_u is identity
if np.allclose(target_u, np.eye(4)):
qc = QuantumCircuit(2)
return qc, 0
# if child gate is locally equivalent to target gate, then we want to see if they can be equal using phase and VZ gates
# I'm not checking this for now because slow and only small benefit
if False and np.all(np.isclose(c1c2c3(child_gate.to_matrix()), c1c2c3(target_u))):
def phase_lambda(p1, p2):
return ConversionGainGate(
p1,
p2,
child_gate.params[2],
child_gate.params[3],
t_el=child_gate.params[-1],
)
template = CircuitTemplateV2(
base_gates=[phase_lambda], maximum_span_guess=1, vz_only=True
)
template.spanning_range = range(1, 2)
optimizer3 = TemplateOptimizer(
basis=template,
objective=SquareCost(),
override_fail=True,
success_threshold=1e-10,
training_restarts=1,
)
ret3 = optimizer3.approximate_target_U(target_U=target_u)
if ret3.success_label:
# basis.no_exterior_1q = True
basis.vz_only = True
basis.build(1)
return basis, basis_factor
# first get necessary range using basis
ki = monodromy_range_from_target(basis, target_u)[0]
# cost to beat
child_cost = (ki + 1) * cost_1q + ki * basis_factor
assert (
ki >= 1
), "Monodromy range must be at least 1, taget is identity gate case not implemented"
# if basis is locally equivalent to target, return k=1
if ki == 1:
basis.no_exterior_1q = False
basis.build(1)
return basis, 1.2
# construct the older sibling, based on parity of ki
if ki % 2 == 0:
rec_iter_factor = 2
else:
rec_iter_factor = 3
sib_basis_factor = rec_iter_factor * basis_factor
older_sibling = ConversionGainGate(
*child_gate.params[:-1], t_el=child_gate.params[-1] * rec_iter_factor
)
# TODO need to set a duration attribute here
older_sibling.normalize_duration(1)
# stop condition, if sibling is bigger than iswap
# TODO, what we can check is a mixed basis (e.g. rather than 3 sqiswaps becoming 1.5 iswap and fail, make it 1 iswap and 1 sqiswap)
if older_sibling.params[2] + older_sibling.params[3] <= np.pi / 2:
# new basis using older sibling
sibling_basis = MixedOrderBasisCircuitTemplate(
base_gates=[older_sibling], chatty_build=False, use_smush_polytope=use_smush
)
sibling_decomp, sib_score = recursive_sibling_check(
sibling_basis,
target_u,
use_smush=use_smush,
basis_factor=sib_basis_factor,
rec_iter_factor=rec_iter_factor,
cost_1q=cost_1q,
)
else:
sib_score = np.inf
# if length of qc is shorter using the siblings decomp template, else use self template
if sib_score < child_cost:
return sibling_decomp, sib_score
else:
basis.build(ki)
return basis, child_cost
if __name__ == "__main__":
from qiskit.circuit.library import CXGate
from slam.utils.gates.duraton_scaling import atomic_cost_scaling
target = CXGate().to_matrix()
params = [0, 0, 0, np.pi / 16, 1]
basis = ConversionGainGate(*params)
template = MixedOrderBasisCircuitTemplate(
base_gates=[basis], chatty_build=False, use_smush_polytope=0
)
duration = atomic_cost_scaling(params, 1, speed_method="linear", duration_1q=0)
ret = recursive_sibling_check(
template, target, cost_1q=0.1, basis_factor=duration[1]
)
decomp_cost = ret[1]
print(decomp_cost)
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
from __future__ import annotations
import logging
from typing import TYPE_CHECKING
# using this to avoid a circular import
if TYPE_CHECKING:
from slam.basis import CircuitTemplate
from fractions import Fraction
from sys import stdout
from typing import List
import numpy as np
from monodromy.coordinates import unitary_to_monodromy_coordinate
from monodromy.coverage import (
CircuitPolytope,
build_coverage_set,
deduce_qlr_consequences,
print_coverage_set,
)
from monodromy.haar import expected_cost
from monodromy.polytopes import ConvexPolytope
from monodromy.static.examples import everything_polytope, exactly, identity_polytope
from qiskit.converters import circuit_to_dag
from qiskit.quantum_info import Operator
from slam.utils.gates.custom_gates import CustomCostGate
MAX_ITERS = 10
"""Helper function for monodromy polytope package."""
# NOTE I'm not sure the best way to do this or if there is a more direct way already in the monodromy package somewhere
# references:
# https://github.com/Qiskit/qiskit-terra/blob/main/qiskit/quantum_info/synthesis/xx_decompose/decomposer.py
# https://github.com/evmckinney9/monodromy/blob/main/scripts/single_circuit.py
def monodromy_range_from_target(basis: CircuitTemplate, target_u) -> range:
# NOTE, depending on whether using precomputed coverages,
# both return a range element, because this is value is used by the optimizer to call build
# in order to bind the precomputed circuit polytope, we use a set method on basis
if basis.n_qubits != 2:
raise ValueError("monodromy only for 2Q templates")
target_coords = unitary_to_monodromy_coordinate(target_u)
# XXX if the code was working everywhere this extra case would not be needed
# for some reason in the custom built circuit polytope sets we built using parallel_drive_volume.py
# the base case identity polytope has some broken attributes
# e.g. basis.coverage[0].has_element(target_coords) throws error
# so we need to check for this case and return a range of 0 manually
if target_coords == [0.0, 0.0, 0.0, 0.0]:
return range(0, 1)
# old method when polytopes not precomputed
# NOTE possible deprecated not sure when this would ever be none
if basis.coverage is None:
raise ValueError("Deprecated method, use precomputed coverages")
iters = 0
while (
iters == 0 or not circuit_polytope.has_element(target_coords)
) and iters < MAX_ITERS:
iters += 1
basis.build(iters)
circuit_polytope = get_polytope_from_circuit(basis)
if iters == MAX_ITERS and not circuit_polytope.has_element(target_coords):
raise ValueError(
"Monodromy did not find a polytope containing U, may need better gate or adjust MAX_ITERS"
)
logging.info(f"Monodromy found needs {iters} basis applications")
return range(iters, iters + 1)
else:
# new method, now we can iterate over precomputed polytopes
# we want to find the first polytoped (when sorted by cost) that contains target
# this sorting might be redundant but we will do it just in case
found_cover = -1
sorted_polytopes = sorted(basis.coverage, key=lambda k: k.cost)
for i, circuit_polytope in enumerate(sorted_polytopes):
# XXX skip the identity polytope, see above
if circuit_polytope.cost == 0:
continue
if circuit_polytope.has_element(target_coords):
# set polytope
basis.set_polytope(circuit_polytope)
# return a default range
found_cover = i
break
if found_cover == -1:
raise ValueError("Monodromy did not find a polytope containing U")
return range(found_cover, found_cover + 1)
def get_polytope_from_circuit(basis: CircuitTemplate) -> ConvexPolytope:
from qiskit import QuantumCircuit
if isinstance(basis, QuantumCircuit):
if basis.num_qubits != 2:
raise ValueError("monodromy only for 2Q templates")
dag = circuit_to_dag(basis)
else: # if isinstance(basis, CircuitTemplate): #XXX not imported for preventing circular import
if basis.n_qubits != 2:
raise ValueError("monodromy only for 2Q templates")
dag = circuit_to_dag(basis.circuit)
circuit_polytope = identity_polytope
for gate in dag.two_qubit_ops():
gd = Operator(gate.op).data
b_polytope = exactly(
*(
Fraction(x).limit_denominator(10_000)
for x in unitary_to_monodromy_coordinate(gd)[:-1]
)
)
circuit_polytope = deduce_qlr_consequences(
target="c",
a_polytope=circuit_polytope,
b_polytope=b_polytope,
c_polytope=everything_polytope,
)
return circuit_polytope
# reference: monodromy/demo.py
def gate_set_to_haar_expectation(*basis_gates: List[CustomCostGate], chatty=True):
coverage_set, basis_gate_hash_dict = gate_set_to_coverage(
*basis_gates, chatty=chatty
)
return coverage_to_haar_expectation(coverage_set, chatty=chatty)
def gate_set_to_coverage(
*basis_gates: List[CustomCostGate], chatty=True, cost_1q=0, bare_cost=False
):
# first converts all individal gates to circuitpolytope objeect
operations = []
basis_gate_hash_dict = {}
for gate in basis_gates:
# this is an ugly solution, but not sure a more direct way
# when we see the circuit polytope later in the basis build method,
# we need to reconstruct it as a variational circuit, and need a reference to the gates
# the circuitpolytopes need a hashable object so we use string
# this dict looks up string->gate object
if str(gate) in basis_gate_hash_dict.keys():
raise ValueError("need unique gate strings for hashing to work")
basis_gate_hash_dict[str(gate)] = gate
circuit_polytope = identity_polytope
b_polytope = exactly(
*(
Fraction(x).limit_denominator(10_000)
for x in unitary_to_monodromy_coordinate(
np.matrix(gate, dtype=complex)
)[:-1]
)
)
circuit_polytope = deduce_qlr_consequences(
target="c",
a_polytope=circuit_polytope,
b_polytope=b_polytope,
c_polytope=everything_polytope,
)
# use bare_cost to get cost in terms of number of gates - will be scaled by costs later
# idea is we don't need to recompute everytime we change costs for speed limits or 2Q gates
# this idea can't be used if using mixed basis gate sets because we need to know relative costs
if bare_cost and len(basis_gates) != 1:
raise ValueError("bare_cost only works for single 2Q gate sets")
if hasattr(gate, "cost"):
op_cost = gate.cost() + cost_1q
elif bare_cost:
op_cost = 1
else:
op_cost = 1
operations.append(
CircuitPolytope(
operations=[str(gate)],
cost=op_cost,
convex_subpolytopes=circuit_polytope.convex_subpolytopes,
)
)
# second build coverage set which finds the necessary permutations to do a complete span
if chatty:
logging.info("==== Working to build a set of covering polytopes ====")
coverage_set = build_coverage_set(operations, chatty=chatty)
# TODO: add some warning or fail condition if the coverage set fails to coverage
# one way, (but there may be a more direct way) is to check if expected haar == 0
if chatty:
logging.info("==== Done. Here's what we found: ====")
logging.info(print_coverage_set(coverage_set))
# return circuit_polytope
# return operations
return coverage_set, basis_gate_hash_dict
def coverage_to_haar_expectation(coverage_set, chatty=True):
# finally, return the expected haar coverage
if chatty:
logging.info("==== Haar volumes ====")
cost = expected_cost(coverage_set, chatty=chatty)
stdout.flush() # fix out of order logging
if chatty:
logging.info(f"Haar-expectation cost: {cost}")
return cost
# In-house rendering, also see utils.visualize.py
"""
import matplotlib.pyplot as plt
plt.close()
fig = plt.figure()
ax = fig.add_subplot(111, projection="3d")
from weylchamber import WeylChamber
w = WeylChamber();
total_coord_list = []
for subpoly in reduced_vertices:
subpoly_coords = [[float(x) for x in coord] for coord in subpoly]
total_coord_list += subpoly_coords
w.scatter(*zip(*subpoly_coords))
from scipy.spatial import ConvexHull
pts = np.array(total_coord_list)
hull = ConvexHull(pts)
for s in hull.simplices:
s = np.append(s, s[0]) # Here we cycle back to the first coordinate
ax.plot(pts[s, 0], pts[s, 1], pts[s, 2], "r-")
w.render(ax)
"""
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
import logging
logger = logging.getLogger()
logger.setLevel(logging.ERROR)
import numpy as np
from qiskit import QuantumCircuit
from qiskit.circuit.library import CXGate, XGate
from qiskit.converters import circuit_to_dag
from qiskit.dagcircuit import DAGCircuit, DAGOpNode
from qiskit.quantum_info import Operator
from qiskit.transpiler import PassManager
from qiskit.transpiler.basepasses import AnalysisPass, TransformationPass
from qiskit.transpiler.passes import (
Collect2qBlocks,
ConsolidateBlocks,
CountOps,
Optimize1qGates,
Unroll3qOrMore,
)
from tqdm import tqdm
from weylchamber import c1c2c3
from slam.basis import MixedOrderBasisCircuitTemplate
from slam.utils.gates.bare_candidates import get_group_name
from slam.utils.gates.custom_gates import ConversionGainGate, CustomCostGate, RiSwapGate
from slam.utils.gates.duraton_scaling import atomic_cost_scaling
from slam.utils.gates.family_extend import recursive_sibling_check
from slam.utils.gates.winner_selection import pick_winner
from slam.utils.polytopes.polytope_wrap import monodromy_range_from_target
from slam.utils.transpiler_pass.weyl_decompose import (
RootiSwapWeylDecomposition as decomposer,
)
class fooAnalysis(AnalysisPass):
"""print duration of the circuit (iswap = 1 unit)"""
def __init__(self, duration_1q):
super().__init__()
self.duration_1q = duration_1q
def run(self, dag):
# XXX this probably didn't cause any issues, but problem in logic. The DAG longest path is not necessarily the duration longest path.
"""Start with overall longest path."""
freq = {} # tracking frequency of gates
d = 0 # tracking critical path duration
for gate in dag.longest_path():
if isinstance(gate, DAGOpNode):
if gate.op.duration is not None:
d += gate.op.duration
elif gate.op.name in ["u", "u1", "u2", "u3"]:
d += self.duration_1q
elif gate.op.name in ["cx"]:
d += 1
# longest path frequency tracking
freq[gate.op.name] = freq.get(gate.op.name, 0) + 1
self.property_set["duration"] = d
self.property_set["gate_counts"] = dag.count_ops()
self.property_set["longest_path_counts"] = freq
# XXX for now, just assume all measurements take place together at the end of the circuit
# """Next, look at longest path on each wire"""
# # to calculate duration over each wire, start by putting measurements at the end of each wire
# # then, use remove_nonancestors_of followed by longest_path, to find the critical path for each wire
# tempc = dag_to_circuit(dag)
# tempc.measure_all()
# msmtdag = circuit_to_dag(tempc)
# # now, we have a dag with measurements at the end of each wire
# msmtnodes = msmtdag.named_nodes('measure')
# for i in range(len(msmtnodes)):
# wire_d = []
# d = 0
# # make a working copy of the dag
# msmtdag = circuit_to_dag(tempc)
# node = msmtdag.named_nodes('measure')[i] # have to remake such that the node is in the copy of the dag, bad code :(
# msmtdag.remove_nonancestors_of(node)
# # now all paths lead to the measurement
# # find the longest path
# path = msmtdag.longest_path()
# for gate in path:
# if isinstance(gate, DAGOpNode):
# if gate.op.duration is not None:
# d += gate.op.duration
# elif gate.op.name in ['u', 'u1', 'u2', 'u3']:
# d += self.duration_1q
# elif gate.op.name in ['cx']:
# d += 1
# wire_d.append(d)
# self.property_set['wire_duration'] = wire_d
logging.info("\nTranspilation Results:")
logging.info(f"Gate Counts: {dag.count_ops()}")
logging.info(f"Longest Path Gate Counts: {freq}")
logging.info(f"Duration: {d}")
# logging.info(f"Wire Duration: {wire_d}")
return 1 # success
class SpeedGateSubstitute(TransformationPass):
def __init__(
self,
speed_method,
duration_1q,
strategy,
basic_metric,
coupling_map,
lambda_weight=0.47,
family_extension=False,
):
super().__init__()
self.speed_method = speed_method
self.duration_1q = duration_1q
self.strategy = strategy
self.basic_metric = basic_metric
self.coupling_map = coupling_map
self.lambda_weight = lambda_weight
self.family_extension = family_extension
# makes sure the data exists first # cost scaling is deprecated
# cost_scaling(speed_method=speed_method, duration_1q=duration_1q)
self.group_name = get_group_name(speed_method, duration_1q)
# NOTE force requires so that only 2Q ops exist in dag
# collect 2Q blocks
self.requires.extend(
[
Unroll3qOrMore(),
Collect2qBlocks(),
ConsolidateBlocks(force_consolidate=True),
]
)
def run(self, dag: DAGCircuit):
"""Run the pass on `dag`."""
if (
self.strategy == "basic_overall"
or self.strategy == "lambda_weight"
or self.strategy == "basic_smush"
or self.strategy == "lambda_smush"
):
"""Here, we define a single metric to pick a winner gate to be used
for all decompositions.
Metrics pick most efficient for either SWAP, CNOT, or Haar
OR using lambda * d[cnot] + (1-lambda) * d[swap] as winner metric
"""
metric = (
self.basic_metric
if ("basic" in self.strategy)
else (-1, self.lambda_weight)
)
smush_bool = True if ("smush" in self.strategy) else False
winner_gate, scaled_winner_gate = pick_winner(
self.group_name,
metric=metric,
plot=False,
smush_bool=smush_bool,
family_extension=self.family_extension,
)
# that way we only have to compute a single coverage set
# NOTE winner_gate goes to constructor so hits the saved polytope coverage set
template = MixedOrderBasisCircuitTemplate(
base_gates=[winner_gate], smush_bool=smush_bool
)
logging.info("Found winner, begin substitution")
# second, make substitutions
for node in dag.two_qubit_ops():
target = Operator(node.op).data
if self.family_extension:
ret = recursive_sibling_check(
template,
target,
cost_1q=self.duration_1q,
basis_factor=scaled_winner_gate.duration,
use_smush=smush_bool,
)
ret[0] # should already be built
# XXX template isn't using scaled gates will break the fooAnalysis
# print("here")
# idea is to substitute a dummy gate that contains the duration attribute
# note the actual unitary doesn't matter since we're just using the duration
# problem is that the 1Q gates are not used so don't get simplified away
# need to check if subtemplate has 1Q gates then subtract duration_1q from the dummy cost
# this is very hacky, don't like
# XXX lets just assume it always has 1Q gates
CustomCostGate(
str="dummy1q",
unitary=XGate(),
duration=self.duration_1q,
num_qubits=1,
)
dummy_gate = CustomCostGate(
unitary=target,
duration=ret[1] - (2 * self.duration_1q),
str="dummy",
)
sub_qc = QuantumCircuit(2)
# sub_qc.append(dummy_single, [0])
# sub_qc.append(dummy_single, [1])
sub_qc.append(dummy_gate, [0, 1])
# sub_qc.append(dummy_single, [0])
# sub_qc.append(dummy_single, [1])
sub_dag = circuit_to_dag(sub_qc)
dag.substitute_node_with_dag(node, sub_dag)
else:
reps = monodromy_range_from_target(template, target_u=target)[0]
# NOTE, when we build, actually use the scaled_winner_gate which has the proper duration attiriubte
template.build(reps, scaled_winner_gate)
# we should set all the U3 gates to be real valued - doesn't matter for sake of counting duration
sub_qc = template.assign_Xk(template.parameter_guess())
sub_dag = circuit_to_dag(sub_qc)
dag.substitute_node_with_dag(node, sub_dag)
elif self.strategy == "weighted_overall":
"""Here, we are counting gates that appear in the circuit in order
to define a winner metric."""
# first, need frqeuncy of each gate
# NOTE this feels unoptimized, because we are consolidating 1Q gates, so more misses (?)
target_ops = [g.op for g in dag.two_qubit_ops()]
winner_gate, scaled_winner_gate = pick_winner(
self.group_name,
metric=-1,
target_ops=target_ops,
plot=False,
family_extension=self.family_extension,
) # XXX unoptimized !
logging.info("Found winner, begin substitution")
template = MixedOrderBasisCircuitTemplate(base_gates=[winner_gate])
# second, make substitutions
for node in dag.two_qubit_ops():
target = Operator(node.op).data
reps = monodromy_range_from_target(template, target_u=target)[0]
template.build(reps, scaled_winner_gate)
# we should set all the U3 gates to be real valued - doesn't matter for sake of counting duration
sub_qc = template.assign_Xk(template.parameter_guess())
sub_dag = circuit_to_dag(sub_qc)
dag.substitute_node_with_dag(node, sub_dag)
elif self.strategy == "weighted_pairwise":
"""Here, we count gates that appear between each pair of qubits in
the circuit, define a winner for each pair."""
# get edges from coupling map
# turn off logging, too verbose with many winners
logging.info("Iterating over edges, finding winners")
logger.setLevel(logging.ERROR)
edges = self.coupling_map.get_edges()
# in order to remove duplicates, we need to sort the edges
# only keep edges if the first qubit is smaller than the second
edges = [e for e in edges if e[0] < e[1]]
for edge in tqdm(edges):
# target_ops = [g.op for g in dag.two_qubit_ops() if (g.qargs[0].index, g.qargs[1].index) == edge]
# target ops are the 2Q gates that are between the two qubits but the order of the qubits is not important
target_ops = [
g.op
for g in dag.two_qubit_ops()
if set(edge) == set((g.qargs[0].index, g.qargs[1].index))
]
if len(target_ops) == 0:
continue
winner_gate, scaled_winner_gate = pick_winner(
self.group_name,
metric=-1,
target_ops=target_ops,
tqdm_bool=False,
plot=False,
family_extension=self.family_extension,
)
logging.info(f"Found winner for {edge} edge, begin substitution")
template = MixedOrderBasisCircuitTemplate(base_gates=[winner_gate])
# second, make substitutions for the 2Q gates between the two qubits
for node in dag.two_qubit_ops():
if set(edge) == set((node.qargs[0].index, node.qargs[1].index)):
target = Operator(node.op).data
reps = monodromy_range_from_target(template, target_u=target)[0]
template.build(reps, scaled_winner_gate)
# we should set all the U3 gates to be real valued - doesn't matter for sake of counting duration
sub_qc = template.assign_Xk(template.parameter_guess())
sub_dag = circuit_to_dag(sub_qc)
dag.substitute_node_with_dag(node, sub_dag)
# turn logging back on
logger.setLevel(logging.INFO)
else:
raise ValueError("Strategy not recognized")
logging.warning(
"1Q gates are not being set to accurate values, just placeholders for fast counting"
)
return dag
class OptimizedSqiswapSub(TransformationPass):
"""
Unoptimized code :(
Replace CX-family gates with iSwap-fam identity, and SWAP gates with iSwap-fam identity
This TransformationPass takes advantage of 2 main optimized:
1. The CX-family gates reduce from a. 2 Sqiswaps build all CX gates to b. iswap^n builds cx^n gates
For a linear SLF, this changes CX from .1+.5+.1+.5+.1 = 1.3 to .1+1+.1 = 1.2
For a linear SLF, this changes sqCX from .1+.5+.1+.5+.1 = 1.3 to .1+.5+.1 = 0.7
...
2. The SWAP gates reduce from a. 3 sqiswaps to b. 1 iswap + 1 sqiswap
For a linear SLF, this changes SWAP from .1+.5+.1+.5+.1+.5+.1 = 1.9 to .1 + 1 + .1 + .5 + .1 = 1.8
We also believe it is possible to remove the last internal 1Q gate, which would give .1 + 1 +.5 + .1 = 1.7
3. It could be possible to remove the external gates if unitary equivalence >> local equivalence, but this is not implemented
This could have very large savings for SWAP gate, but for CX we expect in some cases the external gates to be simplified away
"""
def __init__(self, duration_1q=0, speed_method="linear"):
super().__init__()
self.duration_1q = duration_1q
self.speed_method = speed_method
def run(self, dag):
"""Run the OptimizedSqiswapSub pass on `dag`."""
# first, we need to get a duration scaled iswap gate
iswap = ConversionGainGate(0, 0, np.pi / 2, 0, t_el=1)
sqiswap = ConversionGainGate(0, 0, np.pi / 2, 0, t_el=0.5)
scaled_iswap, _ = atomic_cost_scaling(
params=iswap.params,
scores=np.array([0]),
speed_method=self.speed_method,
duration_1q=self.duration_1q,
)
scaled_sqiswap, _ = atomic_cost_scaling(
params=sqiswap.params,
scores=np.array([0]),
speed_method=self.speed_method,
duration_1q=self.duration_1q,
)
# second load pd coverage of sqiswap
# we will use this for QV, and any other edge cases (non CX/SWAP gates)
edge_iswap_template = MixedOrderBasisCircuitTemplate(
base_gates=[iswap], use_smush_polytope=True
)
template = MixedOrderBasisCircuitTemplate(
base_gates=[sqiswap], use_smush_polytope=True
)
# third, we iterate over the 2Q gates and replace them with the scaled iswap gate
for node in dag.two_qubit_ops():
# convert node to weyl coordinate
try:
target = Operator(node.op).data
target_coord = c1c2c3(target)
except:
# XXX I'm not confident this is always the right thing to do
logging.warning(
"ValueError in c1c2c3, setting target to real part, issue likely due to imaginary numerical error on SWAP gate"
)
target = target.real
sub_qc = QuantumCircuit(2)
# add random 1Q unitaries to the sub circuit with np.random.random()
sub_qc.u(np.random.random(), np.random.random(), np.random.random(), 0)
sub_qc.u(np.random.random(), np.random.random(), np.random.random(), 1)
# if target coord is a controlled unitary, use derivived 1-1 equivalency to iswap family (up to local equiv)
if target_coord[1] == 0 and target_coord[2] == 0:
# with parallel drive, CX==iSwap, sqCX==sqiswap, etc
scale_factor = (
target_coord[0] / 0.5
) # divide by .5 to get x-coord of CX
sub_iswap = ConversionGainGate(
*scaled_iswap.params[:-1],
t_el=scaled_iswap.params[-1] * scale_factor,
)
sub_iswap.normalize_duration(1)
sub_iswap.duration = scaled_iswap.duration * scale_factor
sub_qc.append(sub_iswap, [0, 1])
# if target coord is a swap, use derived equivalency to iswap family iswap_pd + 1Q + sqiswap (up to local equiv)
# NOTE the best we have found is
elif target_coord == (0.5, 0.5, 0.5):
# with parallel drive, SWAP is 1 parallel-driven iSwap followed by a sqiswap
sub_qc.append(scaled_iswap, [0, 1])
# XXX we think these can go away if have a perfect decomposition, but hard to find with our approx methods
PERFECTED_DECOMP_SWAP = 0
# add random 1Q gates
if not PERFECTED_DECOMP_SWAP:
sub_qc.u(
np.random.random(), np.random.random(), np.random.random(), 0
)
sub_qc.u(
np.random.random(), np.random.random(), np.random.random(), 1
)
# add sqiswap
scale_factor = 1 / 2
sub_iswap = ConversionGainGate(
*scaled_iswap.params[:-1],
t_el=scaled_iswap.params[-1] * scale_factor,
)
sub_iswap.normalize_duration(1)
sub_iswap.duration = scaled_iswap.duration * scale_factor
sub_qc.append(sub_iswap, [0, 1])
elif target_coord == (0.5, 0.5, 0): # iSwap may show up from CX+SWAP
# iswap is just iswap :)
sub_qc.append(scaled_iswap, [0, 1])
else:
# this is edge case
# for example, in QFT there are some [SWAP+CX] => pSwap
# pass this to standard monodromy template
# the idea is that we can still may get an improvement from the \
# parallel-drive extended coverage polytope
# XXX missing iSwap parallel driven, family-extension. This code is messy which is why it's not here yet
# hardcode the cases
# if its in extended iSwap in 1, do 2 sqiswaps no middle 1Q gate
reps = monodromy_range_from_target(
edge_iswap_template, target_u=target
)[0]
if reps == 1:
sub_qc.append(scaled_iswap, [0, 1])
else: # if its in extended iSwap in 2 more just use the regular extended sqiswap
reps = monodromy_range_from_target(template, target_u=target)[0]
template.build(reps, scaled_sqiswap)
sub_qc = template.assign_Xk(
template.parameter_guess()
) # radom real values
# this template is going to have an extra set of external 1Q gates,
# because cases nested in this for loop have pre-, post- fixed gates
# its not a problem to have doubles, as long as Optimized1QGates removes them
# we need to make sure that when we simplify that they get cancelled out
# add random 1Q unitaries to the sub circuit with np.random.random()
sub_qc.u(np.random.random(), np.random.random(), np.random.random(), 0)
sub_qc.u(np.random.random(), np.random.random(), np.random.random(), 1)
# make the substitution
sub_dag = circuit_to_dag(sub_qc)
dag.substitute_node_with_dag(node, sub_dag)
return dag
# optimized sqiswap pass manager (with dummy substitution)
class pass_manager_optimized_sqiswap(PassManager):
"""Note, the sqiswap basis gate is a bit of a misnomer, because the basis
gate we would calibrate is actually a smaller fraction of an iswap
(whatever smallest fraction preserves fidelity) For example, if we
calibrate 1/16 of an iswap, we would build sqiswap and iswap gates by
repeating the gate with no interleaving 1Q gates 8,16 times."""
def __init__(self, duration_1q=0, speed_method="linear"):
passes = []
passes.extend([CountOps()])
# collapse 2Q gates
passes.extend(
[
Unroll3qOrMore(),
Collect2qBlocks(),
ConsolidateBlocks(force_consolidate=True),
]
)
# every CX-family gate is replaced using iSwap-fam identity
# every SWAP gate is repalced using iSwap-fam identity
passes.extend(
[OptimizedSqiswapSub(duration_1q=duration_1q, speed_method=speed_method)]
)
# collapse 1Q gates
passes.extend([Optimize1qGates()])
passes.extend([CountOps(), fooAnalysis(duration_1q)])
super().__init__(passes)
logging.warning(
"1Q gates are not being set to accurate values, just placeholders for fast counting"
)
# speed-limit aware manager
class pass_manager_slam(PassManager):
def __init__(
self,
strategy="basic_overall",
speed_method="linear",
duration_1q=0,
basic_metric=0,
family_extension=0,
coupling_map=None,
):
passes = []
passes.extend([CountOps()])
passes.extend(
[
SpeedGateSubstitute(
strategy=strategy,
speed_method=speed_method,
duration_1q=duration_1q,
basic_metric=basic_metric,
coupling_map=coupling_map,
family_extension=family_extension,
)
]
)
# combine 1Q gates
passes.extend([Optimize1qGates()])
passes.extend([CountOps(), fooAnalysis(duration_1q)])
super().__init__(passes)
class pass_manager_basic(PassManager):
def __init__(self, gate="sqiswap", duration_1q=0):
passes = []
passes.extend([CountOps()])
# collect 2Q blocks
# FIXME, it is probably faster to not consolidate, and have some smarter means of duplicate target substitution
passes.extend(
[
Unroll3qOrMore(),
Collect2qBlocks(),
ConsolidateBlocks(force_consolidate=True),
]
)
if gate == "sqiswap":
passes.extend([decomposer(basis_gate=RiSwapGate(1 / 2))])
elif gate == "cx":
passes.extend([decomposer(basis_gate=CXGate())])
# combine 1Q gates
passes.extend([Optimize1qGates()])
passes.extend([CountOps(), fooAnalysis(duration_1q)])
super().__init__(passes)
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
# 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.
"""Weyl decomposition of two-qubit gates in terms of echoed cross-resonance
gates."""
import cmath
import numpy as np
import scipy.linalg as la
from qiskit import QuantumCircuit
from qiskit.circuit.library import IGate, RXGate, RYGate, RZGate
from qiskit.converters import circuit_to_dag
from qiskit.dagcircuit import DAGCircuit
from qiskit.extensions.unitary import UnitaryGate
from qiskit.quantum_info.synthesis.two_qubit_decompose import *
from qiskit.transpiler.basepasses import TransformationPass
from qiskit.transpiler.exceptions import TranspilerError
from clonk.utils.qiskit_patch.two_qubit_decompose import TwoQubitBasisDecomposer
from clonk.utils.riswap_gates.equivalence_library import SessionEquivalenceLibrary
# from qiskit.circuit.library.standard_gates import *
from clonk.utils.riswap_gates.riswap import RiSwapGate, fSim
_sel = SessionEquivalenceLibrary
class RootiSwapWeylDecomposition(TransformationPass):
"""Rewrite two-qubit gates using the Weyl decomposition.
This transpiler pass rewrites two-qubit gates in terms of root iswap
gates according to the Weyl decomposition. A two-qubit gate will be
replaced with at most 3 root i swap gates.
"""
def __init__(self, basis_gate=False):
"""RootiSwapWeylDecomposition pass.
Args:
instruction_schedule_map (InstructionScheduleMap): the mapping from circuit
:class:`~.circuit.Instruction` names and arguments to :class:`.Schedule`\\ s.
"""
super().__init__()
# self.requires = [
# BasisTranslator(_sel, ["u3", "cu3", "cp", "swap", "riswap", "id"])
# ]
# self.decompose_swaps = decompose_swaps
self.basis_gate = basis_gate
# @staticmethod
# def _improper_orthogonal_decomp(x, y, z):
# alpha = np.arccos(
# np.cos(2 * z) - np.cos(2 * y) + np.sqrt((np.cos(4 * z) + np.cos(4 * y)) / 2)
# )
# beta = np.arccos(
# np.cos(2 * z) - np.cos(2 * y) - np.sqrt((np.cos(4 * z) + np.cos(4 * y)) / 2)
# )
# gamma = 0
# psi = -np.arccos(np.sqrt((1 + np.tan(y - z)) / 2))
# phi = np.arccos(np.sqrt((1 + np.tan(y + z)) / 2))
# def_Lxyz = QuantumCircuit(2)
# # ISwap
# if np.isclose(x, y) and np.isclose(z, 0):
# def_Lxyz.append(RiSwapGate(0.5), [0, 1])
# def_Lxyz.rz(2 * x, 0)
# def_Lxyz.rz(-2 * x + np.pi, 1)
# def_Lxyz.append(RiSwapGate(0.5), [0, 1])
# def_Lxyz.rz(-np.pi, 1)
# return def_Lxyz
# # CPhase
# if np.isclose(y, 0) and np.isclose(z, 0):
# def_Lxyz.rz(np.arcsin(np.tan(x)), 1)
# def_Lxyz.rx(-np.pi / 2, 1)
# def_Lxyz.append(RiSwapGate(0.5), [0, 1])
# def_Lxyz.z(1)
# def_Lxyz.ry(2 * np.arcsin(np.sqrt(2) * np.sin(x)), 1)
# def_Lxyz.append(RiSwapGate(0.5), [0, 1])
# def_Lxyz.rx(-np.pi / 2, 1)
# def_Lxyz.rz(np.arcsin(np.tan(x)) - np.pi, 1)
# return def_Lxyz
# # Canonicalized SWAP
# elif np.isclose(x, np.pi / 4) and y + np.abs(z) <= np.pi / 4:
# def_Lxyz.rx(phi + psi, 0)
# def_Lxyz.rz(np.pi / 2, 1)
# def_Lxyz.rx(phi - psi, 1)
# def_Lxyz.append(RiSwapGate(0.5), [0, 1])
# def_Lxyz.rx(alpha, 0)
# def_Lxyz.rx(beta, 1)
# def_Lxyz.append(RiSwapGate(0.5), [0, 1])
# def_Lxyz.rx(phi + psi, 0)
# def_Lxyz.rx(phi - psi, 1)
# def_Lxyz.rz(-np.pi / 2, 1)
# return def_Lxyz
# else:
# raise NotImplementedError
# @staticmethod
# def cphase_decomp(unitary):
# # assuming unitary is a CPhase, is true per self.requires pass
# # TODO function structure needs to be reoganized to use canonicalize function
# x, y, z = weyl_coordinates(Operator(unitary).data)
# def_CPhase = RootiSwapWeylDecomposition._improper_orthogonal_decomp(x, y, z)
# return def_CPhase
# # Note this is the way suggested by alibaba paper, but google has a swap->riswap(1/2) decomp rule that uses less 1Q gates
# @staticmethod
# def swap_decomp(unitary):
# # FIXME: green, blue, maroon rules
# def_swap = QuantumCircuit(2)
# def_swap.z(0)
# def_swap.rx(np.pi / 2, 0)
# def_swap.z(0)
# def_swap.rx(-np.pi / 2, 1)
# x, y, z = weyl_coordinates(Operator(unitary).data)
# def_swap += RootiSwapWeylDecomposition._improper_orthogonal_decomp(
# x, y - np.pi / 4, z - np.pi / 4
# )
# def_swap.z(0)
# def_swap.rx(-np.pi / 2, 0)
# def_swap.rz(np.pi / 2, 0)
# def_swap.ry(-np.pi / 2, 0)
# def_swap.z(0)
# def_swap.rx(np.pi / 2, 1)
# def_swap.rz(-np.pi / 2, 1)
# def_swap.ry(np.pi / 2, 1)
# def_swap.append(RiSwapGate(0.5), [0, 1])
# def_swap.z(0)
# def_swap.ry(np.pi / 2, 0)
# def_swap.rz(-np.pi / 2, 0)
# def_swap.z(0)
# def_swap.ry(-np.pi / 2, 1)
# def_swap.rz(np.pi / 2, 1)
# return def_swap
# reference: https://arxiv.org/pdf/2105.06074.pdf
# from Qiskits two_qubit_decomp #FIXME moving functions around still this won't need to be copied once SQiSwap inside of that same pass
def KAKDecomp(self, unitary_matrix, *, fidelity=(1.0 - 1.0e-9)):
_ipx = np.array([[0, 1j], [1j, 0]], dtype=complex)
_ipy = np.array([[0, 1], [-1, 0]], dtype=complex)
_ipz = np.array([[1j, 0], [0, -1j]], dtype=complex)
_id = np.array([[1, 0], [0, 1]], dtype=complex)
"""Perform the Weyl chamber decomposition, and optionally choose a
specialized subclass.
The flip into the Weyl Chamber is described in B. Kraus and J. I. Cirac, Phys. Rev. A 63,
062309 (2001).
FIXME: There's a cleaner-seeming method based on choosing branch cuts carefully, in Andrew
M. Childs, Henry L. Haselgrove, and Michael A. Nielsen, Phys. Rev. A 68, 052311, but I
wasn't able to get that to work.
The overall decomposition scheme is taken from Drury and Love, arXiv:0806.4015 [quant-ph].
"""
pi = np.pi
pi2 = np.pi / 2
pi4 = np.pi / 4
# Make U be in SU(4)
U = np.array(unitary_matrix, dtype=complex, copy=True)
detU = la.det(U)
U *= detU ** (-0.25)
global_phase = cmath.phase(detU) / 4
Up = transform_to_magic_basis(U, reverse=True)
M2 = Up.T.dot(Up)
# M2 is a symmetric complex matrix. We need to decompose it as M2 = P D P^T where
# P ∈ SO(4), D is diagonal with unit-magnitude elements.
#
# We can't use raw `eig` directly because it isn't guaranteed to give us real or othogonal
# eigenvectors. Instead, since `M2` is complex-symmetric,
# M2 = A + iB
# for real-symmetric `A` and `B`, and as
# M2^+ @ M2 = A^2 + B^2 + i [A, B] = 1
# we must have `A` and `B` commute, and consequently they are simultaneously diagonalizable.
# Mixing them together _should_ account for any degeneracy problems, but it's not
# guaranteed, so we repeat it a little bit. The fixed seed is to make failures
# deterministic; the value is not important.
state = np.random.default_rng(2020)
for _ in range(100): # FIXME: this randomized algorithm is horrendous
M2real = state.normal() * M2.real + state.normal() * M2.imag
_, P = np.linalg.eigh(M2real)
D = P.T.dot(M2).dot(P).diagonal()
if np.allclose(P.dot(np.diag(D)).dot(P.T), M2, rtol=0, atol=1.0e-13):
break
else:
raise ValueError
d = -np.angle(D) / 2
d[3] = -d[0] - d[1] - d[2]
cs = np.mod((d[:3] + d[3]) / 2, 2 * np.pi)
# Reorder the eigenvalues to get in the Weyl chamber
cstemp = np.mod(cs, pi2)
np.minimum(cstemp, pi2 - cstemp, cstemp)
order = np.argsort(cstemp)[[1, 2, 0]]
cs = cs[order]
d[:3] = d[order]
P[:, :3] = P[:, order]
# Fix the sign of P to be in SO(4)
if np.real(la.det(P)) < 0:
P[:, -1] = -P[:, -1]
# Find K1, K2 so that U = K1.A.K2, with K being product of single-qubit unitaries
K1 = transform_to_magic_basis(Up @ P @ np.diag(np.exp(1j * d)))
K2 = transform_to_magic_basis(P.T)
K1l, K1r, phase_l = decompose_two_qubit_product_gate(K1)
K2l, K2r, phase_r = decompose_two_qubit_product_gate(K2)
global_phase += phase_l + phase_r
K1l = K1l.copy()
# Flip into Weyl chamber
if cs[0] > pi2:
cs[0] -= 3 * pi2
K1l = K1l.dot(_ipy)
K1r = K1r.dot(_ipy)
global_phase += pi2
if cs[1] > pi2:
cs[1] -= 3 * pi2
K1l = K1l.dot(_ipx)
K1r = K1r.dot(_ipx)
global_phase += pi2
conjs = 0
if cs[0] > pi4:
cs[0] = pi2 - cs[0]
K1l = K1l.dot(_ipy)
K2r = _ipy.dot(K2r)
conjs += 1
global_phase -= pi2
if cs[1] > pi4:
cs[1] = pi2 - cs[1]
K1l = K1l.dot(_ipx)
K2r = _ipx.dot(K2r)
conjs += 1
global_phase += pi2
if conjs == 1:
global_phase -= pi
if cs[2] > pi2:
cs[2] -= 3 * pi2
K1l = K1l.dot(_ipz)
K1r = K1r.dot(_ipz)
global_phase += pi2
if conjs == 1:
global_phase -= pi
if conjs == 1:
cs[2] = pi2 - cs[2]
K1l = K1l.dot(_ipz)
K2r = _ipz.dot(K2r)
global_phase += pi2
if cs[2] > pi4:
cs[2] -= pi2
K1l = K1l.dot(_ipz)
K1r = K1r.dot(_ipz)
global_phase -= pi2
a, b, c = cs[1], cs[0], cs[2]
return global_phase, (a, b, c), K1l, K1r, K2l, K2r
# Reference: https://quantumai.google/reference/python/cirq/transformers/decompose_two_qubit_interaction_into_four_fsim_gates
def SYCDecomposer(self, U):
qc = QuantumCircuit(2)
# totally ignorning 1Q gates because we are just using this method for counting 2Q gate durations
qc.append(fSim(np.pi / 2, np.pi / 6), [0, 1])
qc.append(fSim(np.pi / 2, np.pi / 6), [0, 1])
qc.append(fSim(np.pi / 2, np.pi / 6), [0, 1])
qc.append(fSim(np.pi / 2, np.pi / 6), [0, 1])
return qc
# Reference: https://arxiv.org/pdf/2105.06074.pdf
def riswapWeylDecomp(self, U):
"""Decompose U into single qubit gates and the SQiSW gates."""
qc = QuantumCircuit(2)
_, (x, y, z), A1, A2, B1, B2 = self.KAKDecomp(U)
if np.abs(z) <= x - y:
C1, C2 = self.interleavingSingleQubitRotations(x, y, z)
V = (
RiSwapGate(0.5).to_matrix()
@ np.kron(C1, C2)
@ RiSwapGate(0.5).to_matrix()
)
_, (x, y, z), D1, D2, E1, E2 = self.KAKDecomp(V)
qc.append(UnitaryGate(np.matrix(E1).H @ B1), [1])
qc.append(UnitaryGate(np.matrix(E2).H @ B2), [0])
qc.append(RiSwapGate(0.5), [0, 1])
qc.append(UnitaryGate(C1), [1])
qc.append(UnitaryGate(C2), [0])
qc.append(RiSwapGate(0.5), [0, 1])
qc.append(UnitaryGate(A1 @ np.matrix(D1).H), [1])
qc.append(UnitaryGate(A2 @ np.matrix(D2).H), [0])
else:
(x, y, z), F1, F2, G1, G2, H1, H2 = self.canonicalize(x, y, z)
C1, C2 = self.interleavingSingleQubitRotations(x, y, z)
V = (
RiSwapGate(0.5).to_matrix()
@ np.kron(C1, C2)
@ RiSwapGate(0.5).to_matrix()
)
_, (x, y, z), D1, D2, E1, E2 = self.KAKDecomp(V)
qc.append(UnitaryGate(H1 @ B1), [1])
qc.append(UnitaryGate(H2 @ B2), [0])
qc.append(RiSwapGate(0.5), [0, 1])
qc.append(UnitaryGate(np.matrix(E1).H @ G1), [1])
qc.append(UnitaryGate(np.matrix(E2).H @ G2), [0])
qc.append(RiSwapGate(0.5), [0, 1])
qc.append(UnitaryGate(C1), [1])
qc.append(UnitaryGate(C2), [0])
qc.append(RiSwapGate(0.5), [0, 1])
qc.append(UnitaryGate(A1 @ F1 @ np.matrix(D1).H), [1])
qc.append(UnitaryGate(A2 @ F2 @ np.matrix(D2).H), [0])
return qc.decompose()
def interleavingSingleQubitRotations(self, x, y, z):
"""Output the single qubit rotations given the interaction coefficients
(x,y,z) \in W' when sandiwched by two SQiSW gates."""
C = (
np.sin(x + y - z)
* np.sin(x - y + z)
* np.sin(-x - y - z)
* np.sin(-x + y + z)
)
alpha = np.arccos(
np.cos(2 * x) - np.cos(2 * y) + np.cos(2 * z) + 2 * np.sqrt(C)
)
beta = np.arccos(np.cos(2 * x) - np.cos(2 * y) + np.cos(2 * z) - 2 * np.sqrt(C))
_num = 4 * (np.cos(x) ** 2) * (np.cos(z) ** 2) * (np.cos(y) ** 2)
_den = _num + np.cos(2 * x) + np.cos(2 * y) * np.cos(2 * z)
gamma = np.arccos(np.sign(z) * np.sqrt(_num / _den))
return (
RZGate(gamma).to_matrix()
@ RXGate(alpha).to_matrix()
@ RZGate(gamma).to_matrix(),
RXGate(beta).to_matrix(),
)
def canonicalize(self, x, y, z):
"""Decompose an arbitrary gate into one SQISW and one L(x,y',z) where
(x',y',z') \in W' and output the coefficients (x',y',z') and the
interleaving single qubit rotations."""
A1 = IGate().to_matrix()
A2 = IGate().to_matrix()
B1 = RYGate(-np.pi / 2).to_matrix()
B2 = RYGate(np.pi / 2).to_matrix()
C1 = RYGate(np.pi / 2).to_matrix()
C2 = RYGate(-np.pi / 2).to_matrix()
s = np.sign(z)
z = np.abs(z)
if x > np.pi / 8:
y = y - np.pi / 8
z = z - np.pi / 8
B1 = RZGate(np.pi / 2).to_matrix() @ B1
B2 = RZGate(-np.pi / 2).to_matrix() @ B2
C1 = C1 @ RZGate(-np.pi / 2).to_matrix()
C2 = C2 @ RZGate(np.pi / 2).to_matrix()
else:
x = x + np.pi / 8
z = z - np.pi / 8
if np.abs(y) < np.abs(z):
# XXX typo in alibaba here (?)
z = -z
A1 = RXGate(np.pi / 2).to_matrix()
A2 = RXGate(-np.pi / 2).to_matrix()
B1 = RXGate(-np.pi / 2).to_matrix() @ B1
B2 = RXGate(np.pi / 2).to_matrix() @ B2
if s < 0:
z = -z
A1 = RZGate(np.pi).to_matrix() @ A1 @ RZGate(np.pi).to_matrix()
B1 = RZGate(np.pi).to_matrix() @ B1 @ RZGate(np.pi).to_matrix()
C1 = RZGate(np.pi).to_matrix() @ C1 @ RZGate(np.pi).to_matrix()
return (x, y, z), A1, A2, B1, B2, C1, C2
def run(self, dag: DAGCircuit):
"""Run the RootiSwapWeylDecomposition pass on `dag`.
Rewrites two-qubit gates in an arbitrary circuit in terms of echoed cross-resonance
gates by computing the Weyl decomposition of the corresponding unitary. Modifies the
input dag.
Args:
dag (DAGCircuit): DAG to rewrite.
Returns:
DAGCircuit: The modified dag.
Raises:
TranspilerError: If the circuit cannot be rewritten.
"""
# pylint: disable=cyclic-import
from qiskit.quantum_info import Operator
if len(dag.qregs) > 1:
raise TranspilerError(
"RootiSwapWeylDecomposition expects a single qreg input DAG,"
f"but input DAG had qregs: {dag.qregs}."
)
# trivial_layout = Layout.generate_trivial_layout(*dag.qregs.values())
if isinstance(self.basis_gate, RiSwapGate):
self.decomposer = self.riswapWeylDecomp
elif isinstance(self.basis_gate, fSim):
self.decomposer = self.SYCDecomposer
else:
self.decomposer = TwoQubitBasisDecomposer(self.basis_gate)
# add something which caches the result to SWAP so we don't have to do it every time
swap_sub = None
cnot_sub = None
for node in dag.two_qubit_ops():
# denote 2 different decomp rules, either for swap gates, or for U gates in CPhase basis
# if node.name == "riswap":
# continue
# FIXME need to convert unitary to a special unitary first to preserve 1Qs?
unitary = Operator(node.op).data
if node.name == "swap":
if swap_sub is None:
swap_sub = circuit_to_dag(self.decomposer(unitary))
dag.substitute_node_with_dag(node, swap_sub)
continue
if node.name == "cx":
if cnot_sub is None:
cnot_sub = circuit_to_dag(self.decomposer(unitary))
dag.substitute_node_with_dag(node, cnot_sub)
continue
# special_unitary = unitary
dag_sub = circuit_to_dag(self.decomposer(unitary))
dag.substitute_node_with_dag(node, dag_sub)
# if node.name == "swap":
# if self.decompose_swaps:
# dag_weyl = circuit_to_dag(self.swap_decomp(unitary))
# dag.substitute_node_with_dag(node, dag_weyl)
# elif node.name == "cp":
# dag_weyl = circuit_to_dag(self.cphase_decomp(unitary))
# dag.substitute_node_with_dag(node, dag_weyl)
# # FIXME
# # FIXME
# # FIXME
# # I need to double check the x,y,z coordinates -> why is CX and CPhase both (np.pi/4 ,0 ,0)
# # that tells me I need to write CX in CPhase basis first to preverse 1Q gates
# # but CU is 2 CPhase gates and yet still a (np.pi/4, 0, 0)- how do I preserve 1Q gates?
# elif node.name == "cu3":
# dag_weyl = circuit_to_dag(self.cphase_decomp(unitary))
# dag.substitute_node_with_dag(node, dag_weyl)
return dag
|
https://github.com/alejomonbar/Classification-Iris_using-Qutrits
|
alejomonbar
|
from qiskit import IBMQ
from qiskit import QuantumCircuit, transpile
from qiskit import schedule
from qiskit.pulse import DriveChannel, Waveform, Gaussian
from qiskit.circuit import Parameter, ParameterVector
from qiskit.tools import job_monitor
from qiskit import pulse
import numpy as np
import matplotlib.pyplot as plt
provider = IBMQ.load_account()
backend = provider.backend.ibmq_bogota
x_def = backend.defaults().instruction_schedule_map.get('x',qubits = [0]) # Default x gate from IBM
qubit = 0 # The qubit that we will use in Bogota
amp = 0.4 # Guessed amplitude of the transition between |1> and |2>
duration = 160 # Duration of the Gaussian pulse for the transition
spec_pulse = Gaussian(duration=duration, amp=amp, sigma=(duration//4)) # Pulse for the transition
measure = backend.defaults().instruction_schedule_map.get('measure',qubits = [qubit]) # Default mesurement gate
num_exp = 20# number of experiments which means the different frequencies
f01 = backend.defaults().qubit_freq_est[0] # Default frequency estimation of transition |0> to |1>
frequencies = f01 - np.linspace(0,0.4e9,num_exp) # Going from the f01 to f01 - 0.4GHz Guessing where the transition frequency is.
scheds = [] # variable to storage the different experiments
for f in frequencies: # iterating over the frequencies
with pulse.build() as Schedule:
with pulse.align_sequential():
pulse.call(x_def)
pulse.set_frequency(f, DriveChannel(qubit))
pulse.play(spec_pulse, DriveChannel(qubit))
pulse.call(measure)
scheds.append(Schedule)
shots = 1000 # Number of repetitions of the experiment (to obtain the probability)
job = backend.run(scheds, meas_level=1, meas_return="single", shots=shots) # What we send to ibmq_bogota
# meas_level = 1 means that we want to obtain the points in an I-Q diagram
job_monitor(job) # To visualize where in the queue is our experiment
cal_freq = job.result() # results from the job
output = []
for i in range(num_exp):
output.append(cal_freq.get_memory(i))# each memory contains one of the 20 experiments with complex numbers the real and imaginary components represent the I-Q diagram
output = np.array(output)
output = np.squeeze(output)[:,:,0]
mean = np.mean(output, axis=1) # taken the mean over the 1000 shots
f12 = frequencies[np.argmax(mean.imag)] # The frequency will be the maximum amplitude for the imaginary term IN THIS CASE
plt.figure()
plt.scatter(frequencies, mean.imag)
plt.axvline(f12, linestyle="--", color="red")
plt.xlabel("frequency", fontsize=14)
plt.ylabel("Amplitude [a.u]", fontsize=14)
plt.grid()
plt.title(f"Frequency calibrated: {np.round(f12/1e9,3)} GHz")
scheds = []
amplitudes = np.linspace(0,0.4,25) # Guessing the range of amplitudes that generates a transition between 1 and 2
for amp in amplitudes:
spec_pulse = Gaussian(duration=duration, amp=amp, sigma=(duration//4))
with pulse.build() as Schedule:
with pulse.align_sequential():
pulse.call(x_def)
pulse.set_frequency(f12, DriveChannel(qubit))
pulse.play(spec_pulse, DriveChannel(qubit))
pulse.call(measure)
scheds.append(Schedule)
scheds[-1].draw()
shots = 1000
job_amp = backend.run(scheds, meas_level=1, meas_return="single", shots=shots)
job_monitor(job_amp)
amp_cal = job_amp.result()
amps_12 = []
for i in range(len(amplitudes)):
amps_12.append(amp_cal.get_memory(i))
amps_12 = np.array(amps_12)
amps_12 = np.squeeze(amps_12)[:,:,0]
amps_12_mean = np.mean(amps_12, axis=1)
amp_12 = amplitudes[np.argmax(amps_12_mean.imag)]
plt.figure()
plt.plot(amplitudes,amps_12_mean.imag, "o", label = "Exp")
plt.axvline(amp_12, color="red", linestyle="--", label="Amp 12")
plt.title(f"The amplitude for the transition 1-2 is :{round(amp_12,3)}", fontsize=14)
plt.xlabel("Pulse Amplitude [a.u]")
plt.ylabel("Amplitude [a.u]")
x01 = backend.defaults().instruction_schedule_map.get('x', qubits = [0]) # Gate X to rotate in the |0> |1> basis
f01 = backend.defaults().qubit_freq_est[0]
spec_pulse = Gaussian(duration=duration, amp=amp_12, sigma=(duration//4))
with pulse.build() as pulse12:
with pulse.align_sequential():
pulse.set_frequency(f12, DriveChannel(qubit))
pulse.play(spec_pulse, DriveChannel(qubit))
pulse.set_frequency(f01, DriveChannel(qubit))
x12 = pulse12
x02 = pulse.Schedule()
x02 += x01
x02 += x12
# |0>
zero = pulse.Schedule()
zero += measure
# |1>
one = pulse.Schedule()
one += x01
one |= measure << one.duration
# |2>
two = pulse.Schedule()
two += x02
two |= measure << two.duration
x02.draw()
classExp = backend.run([zero, one, two], meas_level=1, meas_return="single", shots=shots)
job_monitor(classExp)
resClass = classExp.result()
result = []
for i in range(3):
result.append([resClass.get_memory(i).real, resClass.get_memory(i).imag])
result = np.squeeze(np.array(result)).T[0]
for i in range(3):
plt.scatter(result[:,0,i], result[:,1,i], label = f"{i}", alpha = 0.5)
plt.legend()
from sklearn.cluster import KMeans
X = np.concatenate((result[:,:,0], result[:,:,1],result[:,:,2]))
kmeans = KMeans(n_clusters=3).fit(X)
centers = kmeans.cluster_centers_
plt.figure()
for i in range(3):
plt.scatter(result[:,0,i], result[:,1,i], label = f"{i}", alpha = 0.5)
plt.text(centers[i][0], centers[i][1], f"{i}", fontsize=16)
plt.legend()
labels = [1,0,2]
fig, ax = plt.subplots(1,3, figsize=(18,5))
count = []
for j in range(3):
case = 2
pred0 = kmeans.predict(result[:,:,j])
for i in range(3):
pred = result[pred0==labels[i],:,j]
ax[j].scatter(pred[:,0],pred[:,1], label=f"{i}")
ax[j].set_xlabel("I", fontsize=16)
ax[j].set_ylabel("Q", fontsize=16)
ax[j].legend()
count.append([np.sum(pred0==labels[i])/len(pred0) for i in range(3)])
count
from sklearn import datasets
iris_dataset = datasets.load_iris(return_X_y=True)
data = iris_dataset[0]
minD = np.min(data, axis=0)
maxD = np.max(data, axis=0)
index = np.random.shuffle(np.arange(len(data)))
inputNorm = (1.8 * (data - minD) / (maxD - minD) - 0.9) * np.pi # for the inputs to be between 0.1π and 0.9π
inputNorm = inputNorm[index,:][0]
target = iris_dataset[1][index][0]
def gate_12(param):
with pulse.build() as sched:
with pulse.align_sequential():
pulse.set_frequency(f12, DriveChannel(qubit))
pulse.play(Gaussian(duration=duration, amp=param*amp_12/np.pi, sigma=(duration//4)), DriveChannel(qubit))
pulse.set_frequency(f01, DriveChannel(qubit))
return sched
def u3(theta, phi, lambda_):
qc = QuantumCircuit(1)
qc.u(theta,phi,lambda_, qubit)
return schedule(transpile(qc,backend), backend)
one1 = u3(np.pi,-np.pi/2,np.pi/2)
one = one1
one |= measure << one.duration
two = one1
two |= gate_12(np.pi) << two.duration
two |= measure << two.duration
one.draw()
two.draw()
job = backend.run([one, two], meas_level=1, meas_return="single", shots=shots)
job_monitor(job)
aa = job.result()
result = []
for i in range(2):
result.append([aa.get_memory(i).real, aa.get_memory(i).imag])
result = np.squeeze(np.array(result)).T[0]
for i in range(2):
plt.scatter(result[:,0,i], result[:,1,i], label = f"{i+1}", alpha = 0.5)
plt.legend()
from qiskit.pulse import Schedule
from qiskit import Schedule
num_gates = 10
num_params = 2
x = ParameterVector("x",4)
params = ParameterVector("params", num_params)
list_of_params = list(x) + list(params)
QNN_Circuit = Schedule()
for i in range(num_gates):
if np.random.rand() > 0.5:
variables = np.random.choice(list_of_params,3)
QNN_Circuit += u3(*variables)
else:
variables = np.random.choice(list_of_params,1)
QNN_Circuit += gate_12(*variables)
QNN_Circuit += measure
Circuit = QNN_Circuit.assign_parameters({key:val for key, val in zip(list_of_params, value)}, inplace=False)
def result_estrac(job_results, qubit=0, num_jobs=1):
result = []
for i in range(num_jobs):
result.append([job_results.get_memory(i).real, job_results.get_memory(i).imag])
return np.squeeze(np.array(result)).T[qubit]
def Class_fit(job_result):
result = result_estrac(job_result)
count = []
pred0 = kmeans.predict(result)
for i in range(3):
pred = result[pred0==labels[i],:]
count = [np.sum(pred0==labels[i])/len(pred0) for i in range(3)]
return count
def loss_function(prediction, target):
softmax = np.exp(prediction)/ np.sum(np.exp(prediction))
target_vec = np.zeros((3,))
target_vec[target] = 1
cross_entropy = -np.sum(target_vec * np.log(softmax))
return cross_entropy
def Cost(inputs, target, parameters):
Circuit = QNN_Circuit.assign_parameters({key:val for key, val in zip(x, inputs)}, inplace=False)
Circuit = Circuit.assign_parameters({key:val for key, val in zip(params, parameters)}, inplace=False)
job = backend.run(Circuit, meas_level=1, meas_return="single", shots=shots)
job_monitor(job)
expResult = job.result()
prediction = Class_fit(expResult)
print(f"loss: {np.round(loss_function(prediction, target),3)}")
return loss_function(prediction, target)
def total_cost(params, Xbatch, Ybatch):
cost = 0
for i, t in zip(Xbatch, Ybatch):
cost += Cost(i, t, params)
return cost
def iterate_minibatches(inputs, targets, batch_size):
"""
A generator for batches of the input data
Args:
inputs (array[float]): input data
targets (array[float]): targets
Returns:
inputs (array[float]): one batch of input data of length `batch_size`
targets (array[float]): one batch of targets of length `batch_size`
"""
for start_idx in range(0, inputs.shape[0] - batch_size + 1, batch_size):
idxs = slice(start_idx, start_idx + batch_size)
yield inputs[idxs], targets[idxs]
from qiskit.algorithms.optimizers import SPSA
spsa_loss = []
def spsa_callback(nfev, x, fx, stepsize, accepted):
spsa_loss.append(fx)
spsa = SPSA(maxiter=20, learning_rate=0.1, perturbation=0.1, callback=spsa_callback)
initial_point = np.random.rand(num_params)
num_batches = 80
for Xbatch, Ybatch in iterate_minibatches(inputNorm, target, num_batches):
cost_fun = lambda params: total_cost(params, Xbatch, Ybatch)
x_opt, fx_opt, nfevs = spsa.optimize(num_params,
cost_fun,
initial_point=initial_point)
initial_point = x_opt
print(f"Loss function: {fx_opt}, x_opt: {x_opt}")
|
https://github.com/mtreinish/bqskit-qiskit-synthesis-plugin
|
mtreinish
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# pylint: disable=missing-function-docstring
"""
Tests for the default UnitarySynthesis transpiler pass.
"""
from test import combine
import unittest
import numpy as np
from ddt import ddt, data
from qiskit import transpile
from qiskit.test import QiskitTestCase
from qiskit.providers.fake_provider import FakeVigo, FakeMumbaiFractionalCX, FakeBelemV2
from qiskit.providers.fake_provider.fake_backend_v2 import FakeBackendV2, FakeBackend5QV2
from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.circuit.library import QuantumVolume
from qiskit.converters import circuit_to_dag, dag_to_circuit
from qiskit.transpiler.passes import UnitarySynthesis
from qiskit.quantum_info.operators import Operator
from qiskit.quantum_info.random import random_unitary
from qiskit.transpiler import PassManager, CouplingMap, Target, InstructionProperties
from qiskit.transpiler.exceptions import TranspilerError
from qiskit.exceptions import QiskitError
from qiskit.transpiler.passes import (
Collect2qBlocks,
ConsolidateBlocks,
Optimize1qGates,
SabreLayout,
Unroll3qOrMore,
CheckMap,
BarrierBeforeFinalMeasurements,
SabreSwap,
TrivialLayout,
)
from qiskit.circuit.library import (
IGate,
CXGate,
RZGate,
RXGate,
SXGate,
XGate,
iSwapGate,
ECRGate,
UGate,
ZGate,
RYYGate,
RZZGate,
RXXGate,
)
from qiskit.circuit import Measure
from qiskit.circuit.controlflow import IfElseOp
from qiskit.circuit import Parameter, Gate
@ddt
class TestUnitarySynthesis(QiskitTestCase):
"""Test UnitarySynthesis pass."""
def test_empty_basis_gates(self):
"""Verify when basis_gates is None, we do not synthesize unitaries."""
qc = QuantumCircuit(3)
op_1q = random_unitary(2, seed=0)
op_2q = random_unitary(4, seed=0)
op_3q = random_unitary(8, seed=0)
qc.unitary(op_1q.data, [0])
qc.unitary(op_2q.data, [0, 1])
qc.unitary(op_3q.data, [0, 1, 2])
out = UnitarySynthesis(basis_gates=None, min_qubits=2)(qc)
self.assertEqual(out.count_ops(), {"unitary": 3})
@data(
["u3", "cx"],
["u1", "u2", "u3", "cx"],
["rx", "ry", "rxx"],
["rx", "rz", "iswap"],
["u3", "rx", "rz", "cz", "iswap"],
)
def test_two_qubit_synthesis_to_basis(self, basis_gates):
"""Verify two qubit unitaries are synthesized to match basis gates."""
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
bell_op = Operator(bell)
qc = QuantumCircuit(2)
qc.unitary(bell_op, [0, 1])
dag = circuit_to_dag(qc)
out = UnitarySynthesis(basis_gates).run(dag)
self.assertTrue(set(out.count_ops()).issubset(basis_gates))
def test_two_qubit_synthesis_to_directional_cx_from_gate_errors(self):
"""Verify two qubit unitaries are synthesized to match basis gates."""
# TODO: should make check more explicit e.g. explicitly set gate
# direction in test instead of using specific fake backend
backend = FakeVigo()
conf = backend.configuration()
qr = QuantumRegister(2)
coupling_map = CouplingMap(conf.coupling_map)
triv_layout_pass = TrivialLayout(coupling_map)
qc = QuantumCircuit(qr)
qc.unitary(random_unitary(4, seed=12), [0, 1])
unisynth_pass = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=None,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=False,
)
pm = PassManager([triv_layout_pass, unisynth_pass])
qc_out = pm.run(qc)
unisynth_pass_nat = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=None,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=True,
)
pm_nat = PassManager([triv_layout_pass, unisynth_pass_nat])
qc_out_nat = pm_nat.run(qc)
self.assertEqual(Operator(qc), Operator(qc_out))
self.assertEqual(Operator(qc), Operator(qc_out_nat))
def test_swap_synthesis_to_directional_cx(self):
"""Verify two qubit unitaries are synthesized to match basis gates."""
# TODO: should make check more explicit e.g. explicitly set gate
# direction in test instead of using specific fake backend
backend = FakeVigo()
conf = backend.configuration()
qr = QuantumRegister(2)
coupling_map = CouplingMap(conf.coupling_map)
triv_layout_pass = TrivialLayout(coupling_map)
qc = QuantumCircuit(qr)
qc.swap(qr[0], qr[1])
unisynth_pass = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=None,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=False,
)
pm = PassManager([triv_layout_pass, unisynth_pass])
qc_out = pm.run(qc)
unisynth_pass_nat = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=None,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=True,
)
pm_nat = PassManager([triv_layout_pass, unisynth_pass_nat])
qc_out_nat = pm_nat.run(qc)
self.assertEqual(Operator(qc), Operator(qc_out))
self.assertEqual(Operator(qc), Operator(qc_out_nat))
def test_two_qubit_synthesis_to_directional_cx_multiple_registers(self):
"""Verify two qubit unitaries are synthesized to match basis gates
across multiple registers."""
# TODO: should make check more explicit e.g. explicitly set gate
# direction in test instead of using specific fake backend
backend = FakeVigo()
conf = backend.configuration()
qr0 = QuantumRegister(1)
qr1 = QuantumRegister(1)
coupling_map = CouplingMap(conf.coupling_map)
triv_layout_pass = TrivialLayout(coupling_map)
qc = QuantumCircuit(qr0, qr1)
qc.unitary(random_unitary(4, seed=12), [qr0[0], qr1[0]])
unisynth_pass = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=None,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=False,
)
pm = PassManager([triv_layout_pass, unisynth_pass])
qc_out = pm.run(qc)
unisynth_pass_nat = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=None,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=True,
)
pm_nat = PassManager([triv_layout_pass, unisynth_pass_nat])
qc_out_nat = pm_nat.run(qc)
self.assertEqual(Operator(qc), Operator(qc_out))
self.assertEqual(Operator(qc), Operator(qc_out_nat))
def test_two_qubit_synthesis_to_directional_cx_from_coupling_map(self):
"""Verify natural cx direction is used when specified in coupling map."""
# TODO: should make check more explicit e.g. explicitly set gate
# direction in test instead of using specific fake backend
backend = FakeVigo()
conf = backend.configuration()
qr = QuantumRegister(2)
coupling_map = CouplingMap([[0, 1], [1, 2], [1, 3], [3, 4]])
triv_layout_pass = TrivialLayout(coupling_map)
qc = QuantumCircuit(qr)
qc.unitary(random_unitary(4, seed=12), [0, 1])
unisynth_pass = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=coupling_map,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=False,
)
pm = PassManager([triv_layout_pass, unisynth_pass])
qc_out = pm.run(qc)
unisynth_pass_nat = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=coupling_map,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=True,
)
pm_nat = PassManager([triv_layout_pass, unisynth_pass_nat])
qc_out_nat = pm_nat.run(qc)
# the decomposer defaults to the [1, 0] direction but the coupling
# map specifies a [0, 1] direction. Check that this is respected.
self.assertTrue(
all(((qr[1], qr[0]) == instr.qubits for instr in qc_out.get_instructions("cx")))
)
self.assertTrue(
all(((qr[0], qr[1]) == instr.qubits for instr in qc_out_nat.get_instructions("cx")))
)
self.assertEqual(Operator(qc), Operator(qc_out))
self.assertEqual(Operator(qc), Operator(qc_out_nat))
def test_two_qubit_synthesis_to_directional_cx_from_coupling_map_natural_none(self):
"""Verify natural cx direction is used when specified in coupling map
when natural_direction is None."""
# TODO: should make check more explicit e.g. explicitly set gate
# direction in test instead of using specific fake backend
backend = FakeVigo()
conf = backend.configuration()
qr = QuantumRegister(2)
coupling_map = CouplingMap([[0, 1], [1, 2], [1, 3], [3, 4]])
triv_layout_pass = TrivialLayout(coupling_map)
qc = QuantumCircuit(qr)
qc.unitary(random_unitary(4, seed=12), [0, 1])
unisynth_pass = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=coupling_map,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=False,
)
pm = PassManager([triv_layout_pass, unisynth_pass])
qc_out = pm.run(qc)
unisynth_pass_nat = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=coupling_map,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=None,
)
pm_nat = PassManager([triv_layout_pass, unisynth_pass_nat])
qc_out_nat = pm_nat.run(qc)
# the decomposer defaults to the [1, 0] direction but the coupling
# map specifies a [0, 1] direction. Check that this is respected.
self.assertTrue(
all(((qr[1], qr[0]) == instr.qubits for instr in qc_out.get_instructions("cx")))
)
self.assertTrue(
all(((qr[0], qr[1]) == instr.qubits for instr in qc_out_nat.get_instructions("cx")))
)
self.assertEqual(Operator(qc), Operator(qc_out))
self.assertEqual(Operator(qc), Operator(qc_out_nat))
def test_two_qubit_synthesis_to_directional_cx_from_coupling_map_natural_false(self):
"""Verify natural cx direction is used when specified in coupling map
when natural_direction is None."""
# TODO: should make check more explicit e.g. explicitly set gate
# direction in test instead of using specific fake backend
backend = FakeVigo()
conf = backend.configuration()
qr = QuantumRegister(2)
coupling_map = CouplingMap([[0, 1], [1, 2], [1, 3], [3, 4]])
triv_layout_pass = TrivialLayout(coupling_map)
qc = QuantumCircuit(qr)
qc.unitary(random_unitary(4, seed=12), [0, 1])
unisynth_pass = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=coupling_map,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=False,
)
pm = PassManager([triv_layout_pass, unisynth_pass])
qc_out = pm.run(qc)
unisynth_pass_nat = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=coupling_map,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=False,
)
pm_nat = PassManager([triv_layout_pass, unisynth_pass_nat])
qc_out_nat = pm_nat.run(qc)
# the decomposer defaults to the [1, 0] direction but the coupling
# map specifies a [0, 1] direction. Check that this is respected.
self.assertTrue(
all(((qr[1], qr[0]) == instr.qubits for instr in qc_out.get_instructions("cx")))
)
self.assertTrue(
all(((qr[1], qr[0]) == instr.qubits for instr in qc_out_nat.get_instructions("cx")))
)
self.assertEqual(Operator(qc), Operator(qc_out))
self.assertEqual(Operator(qc), Operator(qc_out_nat))
def test_two_qubit_synthesis_not_pulse_optimal(self):
"""Verify not attempting pulse optimal decomposition when pulse_optimize==False."""
backend = FakeVigo()
conf = backend.configuration()
qr = QuantumRegister(2)
coupling_map = CouplingMap([[0, 1], [1, 2], [1, 3], [3, 4]])
triv_layout_pass = TrivialLayout(coupling_map)
qc = QuantumCircuit(qr)
qc.unitary(random_unitary(4, seed=12), [0, 1])
unisynth_pass = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=coupling_map,
backend_props=backend.properties(),
pulse_optimize=False,
natural_direction=True,
)
pm = PassManager([triv_layout_pass, unisynth_pass])
qc_out = pm.run(qc)
if isinstance(qc_out, QuantumCircuit):
num_ops = qc_out.count_ops()
else:
num_ops = qc_out[0].count_ops()
self.assertIn("sx", num_ops)
self.assertGreaterEqual(num_ops["sx"], 16)
def test_two_qubit_pulse_optimal_true_raises(self):
"""Verify raises if pulse optimal==True but cx is not in the backend basis."""
backend = FakeVigo()
conf = backend.configuration()
# this assumes iswawp pulse optimal decomposition doesn't exist
conf.basis_gates = [gate if gate != "cx" else "iswap" for gate in conf.basis_gates]
qr = QuantumRegister(2)
coupling_map = CouplingMap([[0, 1], [1, 2], [1, 3], [3, 4]])
triv_layout_pass = TrivialLayout(coupling_map)
qc = QuantumCircuit(qr)
qc.unitary(random_unitary(4, seed=12), [0, 1])
unisynth_pass = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=coupling_map,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=True,
)
pm = PassManager([triv_layout_pass, unisynth_pass])
with self.assertRaises(QiskitError):
pm.run(qc)
def test_two_qubit_natural_direction_true_duration_fallback(self):
"""Verify not attempting pulse optimal decomposition when pulse_optimize==False."""
# this assumes iswawp pulse optimal decomposition doesn't exist
backend = FakeVigo()
conf = backend.configuration()
# conf.basis_gates = [gate if gate != "cx" else "iswap" for gate in conf.basis_gates]
qr = QuantumRegister(2)
coupling_map = CouplingMap([[0, 1], [1, 0], [1, 2], [1, 3], [3, 4]])
triv_layout_pass = TrivialLayout(coupling_map)
qc = QuantumCircuit(qr)
qc.unitary(random_unitary(4, seed=12), [0, 1])
unisynth_pass = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=coupling_map,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=True,
)
pm = PassManager([triv_layout_pass, unisynth_pass])
qc_out = pm.run(qc)
self.assertTrue(
all(((qr[0], qr[1]) == instr.qubits for instr in qc_out.get_instructions("cx")))
)
def test_two_qubit_natural_direction_true_gate_length_raises(self):
"""Verify not attempting pulse optimal decomposition when pulse_optimize==False."""
# this assumes iswawp pulse optimal decomposition doesn't exist
backend = FakeVigo()
conf = backend.configuration()
for _, nduv in backend.properties()._gates["cx"].items():
nduv["gate_length"] = (4e-7, nduv["gate_length"][1])
nduv["gate_error"] = (7e-3, nduv["gate_error"][1])
qr = QuantumRegister(2)
coupling_map = CouplingMap([[0, 1], [1, 0], [1, 2], [1, 3], [3, 4]])
triv_layout_pass = TrivialLayout(coupling_map)
qc = QuantumCircuit(qr)
qc.unitary(random_unitary(4, seed=12), [0, 1])
unisynth_pass = UnitarySynthesis(
basis_gates=conf.basis_gates,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=True,
)
pm = PassManager([triv_layout_pass, unisynth_pass])
with self.assertRaises(TranspilerError):
pm.run(qc)
def test_two_qubit_pulse_optimal_none_optimal(self):
"""Verify pulse optimal decomposition when pulse_optimize==None."""
# this assumes iswawp pulse optimal decomposition doesn't exist
backend = FakeVigo()
conf = backend.configuration()
qr = QuantumRegister(2)
coupling_map = CouplingMap([[0, 1], [1, 2], [1, 3], [3, 4]])
triv_layout_pass = TrivialLayout(coupling_map)
qc = QuantumCircuit(qr)
qc.unitary(random_unitary(4, seed=12), [0, 1])
unisynth_pass = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=coupling_map,
backend_props=backend.properties(),
pulse_optimize=None,
natural_direction=True,
)
pm = PassManager([triv_layout_pass, unisynth_pass])
qc_out = pm.run(qc)
if isinstance(qc_out, QuantumCircuit):
num_ops = qc_out.count_ops()
else:
num_ops = qc_out[0].count_ops()
self.assertIn("sx", num_ops)
self.assertLessEqual(num_ops["sx"], 12)
def test_two_qubit_pulse_optimal_none_no_raise(self):
"""Verify pulse optimal decomposition when pulse_optimize==None doesn't
raise when pulse optimal decomposition unknown."""
# this assumes iswawp pulse optimal decomposition doesn't exist
backend = FakeVigo()
conf = backend.configuration()
conf.basis_gates = [gate if gate != "cx" else "iswap" for gate in conf.basis_gates]
qr = QuantumRegister(2)
coupling_map = CouplingMap([[0, 1], [1, 2], [1, 3], [3, 4]])
triv_layout_pass = TrivialLayout(coupling_map)
qc = QuantumCircuit(qr)
qc.unitary(random_unitary(4, seed=12), [0, 1])
unisynth_pass = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=coupling_map,
backend_props=backend.properties(),
pulse_optimize=None,
natural_direction=True,
)
pm = PassManager([triv_layout_pass, unisynth_pass])
try:
qc_out = pm.run(qc)
except QiskitError:
self.fail("pulse_optimize=None raised exception unexpectedly")
if isinstance(qc_out, QuantumCircuit):
num_ops = qc_out.count_ops()
else:
num_ops = qc_out[0].count_ops()
self.assertIn("sx", num_ops)
self.assertLessEqual(num_ops["sx"], 14)
def test_qv_natural(self):
"""check that quantum volume circuit compiles for natural direction"""
qv64 = QuantumVolume(5, seed=15)
def construct_passmanager(basis_gates, coupling_map, synthesis_fidelity, pulse_optimize):
seed = 2
_map = [SabreLayout(coupling_map, max_iterations=2, seed=seed)]
_unroll3q = Unroll3qOrMore()
_swap_check = CheckMap(coupling_map)
_swap = [
BarrierBeforeFinalMeasurements(),
SabreSwap(coupling_map, heuristic="lookahead", seed=seed),
]
_optimize = [
Collect2qBlocks(),
ConsolidateBlocks(basis_gates=basis_gates),
UnitarySynthesis(
basis_gates,
synthesis_fidelity,
coupling_map,
pulse_optimize=pulse_optimize,
natural_direction=True,
),
Optimize1qGates(basis_gates),
]
pm = PassManager()
pm.append(_map) # map to hardware by inserting swaps
pm.append(_unroll3q)
pm.append(_swap_check)
pm.append(_swap)
pm.append(_optimize)
return pm
coupling_map = CouplingMap([[0, 1], [1, 2], [3, 2], [3, 4], [5, 4]])
basis_gates = ["rz", "sx", "cx"]
pm1 = construct_passmanager(
basis_gates=basis_gates,
coupling_map=coupling_map,
synthesis_fidelity=0.99,
pulse_optimize=True,
)
pm2 = construct_passmanager(
basis_gates=basis_gates,
coupling_map=coupling_map,
synthesis_fidelity=0.99,
pulse_optimize=False,
)
qv64_1 = pm1.run(qv64.decompose())
qv64_2 = pm2.run(qv64.decompose())
edges = [list(edge) for edge in coupling_map.get_edges()]
self.assertTrue(
all(
[qv64_1.qubits.index(qubit) for qubit in instr.qubits] in edges
for instr in qv64_1.get_instructions("cx")
)
)
self.assertEqual(Operator(qv64_1), Operator(qv64_2))
@data(1, 2, 3)
def test_coupling_map_transpile(self, opt):
"""test natural_direction works with transpile/execute"""
qr = QuantumRegister(2)
circ = QuantumCircuit(qr)
circ.append(random_unitary(4, seed=1), [0, 1])
circ_01 = transpile(
circ, basis_gates=["rz", "sx", "cx"], optimization_level=opt, coupling_map=[[0, 1]]
)
circ_10 = transpile(
circ, basis_gates=["rz", "sx", "cx"], optimization_level=opt, coupling_map=[[1, 0]]
)
circ_01_index = {qubit: index for index, qubit in enumerate(circ_01.qubits)}
circ_10_index = {qubit: index for index, qubit in enumerate(circ_10.qubits)}
self.assertTrue(
all(
(
(1, 0) == (circ_10_index[instr.qubits[0]], circ_10_index[instr.qubits[1]])
for instr in circ_10.get_instructions("cx")
)
)
)
self.assertTrue(
all(
(
(0, 1) == (circ_01_index[instr.qubits[0]], circ_01_index[instr.qubits[1]])
for instr in circ_01.get_instructions("cx")
)
)
)
@combine(
opt_level=[0, 1, 2, 3],
bidirectional=[True, False],
dsc=(
"test natural_direction works with transpile using opt_level {opt_level} on"
" target with multiple 2q gates with bidirectional={bidirectional}"
),
name="opt_level_{opt_level}_bidirectional_{bidirectional}",
)
def test_coupling_map_transpile_with_backendv2(self, opt_level, bidirectional):
backend = FakeBackend5QV2(bidirectional)
qr = QuantumRegister(2)
circ = QuantumCircuit(qr)
circ.append(random_unitary(4, seed=1), [0, 1])
circ_01 = transpile(
circ, backend=backend, optimization_level=opt_level, layout_method="trivial"
)
circ_01_index = {qubit: index for index, qubit in enumerate(circ_01.qubits)}
self.assertGreaterEqual(len(circ_01.get_instructions("cx")), 1)
for instr in circ_01.get_instructions("cx"):
self.assertEqual(
(0, 1), (circ_01_index[instr.qubits[0]], circ_01_index[instr.qubits[1]])
)
@data(1, 2, 3)
def test_coupling_map_unequal_durations(self, opt):
"""Test direction with transpile/execute with backend durations."""
qr = QuantumRegister(2)
circ = QuantumCircuit(qr)
circ.append(random_unitary(4, seed=1), [1, 0])
backend = FakeVigo()
tqc = transpile(
circ,
backend=backend,
optimization_level=opt,
translation_method="synthesis",
layout_method="trivial",
)
tqc_index = {qubit: index for index, qubit in enumerate(tqc.qubits)}
self.assertTrue(
all(
(
(0, 1) == (tqc_index[instr.qubits[0]], tqc_index[instr.qubits[1]])
for instr in tqc.get_instructions("cx")
)
)
)
@combine(
opt_level=[0, 1, 2, 3],
bidirectional=[True, False],
dsc=(
"Test direction with transpile using opt_level {opt_level} on"
" target with multiple 2q gates with bidirectional={bidirectional}"
"direction [0, 1] is lower error and should be picked."
),
name="opt_level_{opt_level}_bidirectional_{bidirectional}",
)
def test_coupling_unequal_duration_with_backendv2(self, opt_level, bidirectional):
qr = QuantumRegister(2)
circ = QuantumCircuit(qr)
circ.append(random_unitary(4, seed=1), [1, 0])
backend = FakeBackend5QV2(bidirectional)
tqc = transpile(
circ,
backend=backend,
optimization_level=opt_level,
translation_method="synthesis",
layout_method="trivial",
)
tqc_index = {qubit: index for index, qubit in enumerate(tqc.qubits)}
self.assertGreaterEqual(len(tqc.get_instructions("cx")), 1)
for instr in tqc.get_instructions("cx"):
self.assertEqual((0, 1), (tqc_index[instr.qubits[0]], tqc_index[instr.qubits[1]]))
@combine(
opt_level=[0, 1, 2, 3],
dsc=(
"Test direction with transpile using opt_level {opt_level} on"
" target with multiple 2q gates"
),
name="opt_level_{opt_level}",
)
def test_non_overlapping_kak_gates_with_backendv2(self, opt_level):
qr = QuantumRegister(2)
circ = QuantumCircuit(qr)
circ.append(random_unitary(4, seed=1), [1, 0])
backend = FakeBackendV2()
tqc = transpile(
circ,
backend=backend,
optimization_level=opt_level,
translation_method="synthesis",
layout_method="trivial",
)
tqc_index = {qubit: index for index, qubit in enumerate(tqc.qubits)}
self.assertGreaterEqual(len(tqc.get_instructions("ecr")), 1)
for instr in tqc.get_instructions("ecr"):
self.assertEqual((1, 0), (tqc_index[instr.qubits[0]], tqc_index[instr.qubits[1]]))
def test_fractional_cx_with_backendv2(self):
"""Test fractional CX gets used if present in target."""
qr = QuantumRegister(2)
circ = QuantumCircuit(qr)
circ.append(random_unitary(4, seed=1), [0, 1])
backend = FakeMumbaiFractionalCX()
synth_pass = UnitarySynthesis(target=backend.target)
tqc = synth_pass(circ)
tqc_index = {qubit: index for index, qubit in enumerate(tqc.qubits)}
self.assertGreaterEqual(len(tqc.get_instructions("rzx")), 1)
for instr in tqc.get_instructions("rzx"):
self.assertEqual((0, 1), (tqc_index[instr.qubits[0]], tqc_index[instr.qubits[1]]))
@combine(
opt_level=[0, 1, 2, 3],
dsc=(
"Test direction with transpile using opt_level {opt_level} on"
"target with multiple 2q gates available in reverse direction"
),
name="opt_level_{opt_level}",
)
def test_reverse_direction(self, opt_level):
target = Target(2)
target.add_instruction(CXGate(), {(0, 1): InstructionProperties(error=1.2e-6)})
target.add_instruction(ECRGate(), {(0, 1): InstructionProperties(error=1.2e-7)})
target.add_instruction(
UGate(Parameter("theta"), Parameter("phi"), Parameter("lam")), {(0,): None, (1,): None}
)
qr = QuantumRegister(2)
circ = QuantumCircuit(qr)
circ.append(random_unitary(4, seed=1), [1, 0])
tqc = transpile(
circ,
target=target,
optimization_level=opt_level,
translation_method="synthesis",
layout_method="trivial",
)
tqc_index = {qubit: index for index, qubit in enumerate(tqc.qubits)}
self.assertGreaterEqual(len(tqc.get_instructions("ecr")), 1)
for instr in tqc.get_instructions("ecr"):
self.assertEqual((0, 1), (tqc_index[instr.qubits[0]], tqc_index[instr.qubits[1]]))
@combine(
opt_level=[0, 1, 2, 3],
dsc=("Test controlled but not supercontrolled basis"),
name="opt_level_{opt_level}",
)
def test_controlled_basis(self, opt_level):
target = Target(2)
target.add_instruction(RYYGate(np.pi / 8), {(0, 1): InstructionProperties(error=1.2e-6)})
target.add_instruction(
UGate(Parameter("theta"), Parameter("phi"), Parameter("lam")), {(0,): None, (1,): None}
)
qr = QuantumRegister(2)
circ = QuantumCircuit(qr)
circ.append(random_unitary(4, seed=1), [1, 0])
tqc = transpile(
circ,
target=target,
optimization_level=opt_level,
translation_method="synthesis",
layout_method="trivial",
)
self.assertGreaterEqual(len(tqc.get_instructions("ryy")), 1)
self.assertEqual(Operator(tqc), Operator(circ))
def test_approximation_controlled(self):
target = Target(2)
target.add_instruction(RZZGate(np.pi / 10), {(0, 1): InstructionProperties(error=0.006)})
target.add_instruction(RXXGate(np.pi / 3), {(0, 1): InstructionProperties(error=0.01)})
target.add_instruction(
UGate(Parameter("theta"), Parameter("phi"), Parameter("lam")),
{(0,): InstructionProperties(error=0.001), (1,): InstructionProperties(error=0.002)},
)
circ = QuantumCircuit(2)
circ.append(random_unitary(4, seed=7), [1, 0])
dag = circuit_to_dag(circ)
dag_100 = UnitarySynthesis(target=target, approximation_degree=1.0).run(dag)
dag_99 = UnitarySynthesis(target=target, approximation_degree=0.99).run(dag)
self.assertGreaterEqual(dag_100.depth(), dag_99.depth())
self.assertEqual(Operator(dag_to_circuit(dag_100)), Operator(circ))
def test_if_simple(self):
"""Test a simple if statement."""
basis_gates = {"u", "cx"}
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
qc_uni = QuantumCircuit(2)
qc_uni.h(0)
qc_uni.cx(0, 1)
qc_uni_mat = Operator(qc_uni)
qc_true_body = QuantumCircuit(2)
qc_true_body.unitary(qc_uni_mat, [0, 1])
qc = QuantumCircuit(qr, cr)
qc.if_test((cr, 1), qc_true_body, [0, 1], [])
dag = circuit_to_dag(qc)
cdag = UnitarySynthesis(basis_gates=basis_gates).run(dag)
cqc = dag_to_circuit(cdag)
cbody = cqc.data[0].operation.params[0]
self.assertEqual(cbody.count_ops().keys(), basis_gates)
self.assertEqual(qc_uni_mat, Operator(cbody))
def test_nested_control_flow(self):
"""Test unrolling nested control flow blocks."""
qr = QuantumRegister(2)
cr = ClassicalRegister(1)
qc_uni1 = QuantumCircuit(2)
qc_uni1.swap(0, 1)
qc_uni1_mat = Operator(qc_uni1)
qc = QuantumCircuit(qr, cr)
with qc.for_loop(range(3)):
with qc.while_loop((cr, 0)):
qc.unitary(qc_uni1_mat, [0, 1])
dag = circuit_to_dag(qc)
cdag = UnitarySynthesis(basis_gates=["u", "cx"]).run(dag)
cqc = dag_to_circuit(cdag)
cbody = cqc.data[0].operation.params[2].data[0].operation.params[0]
self.assertEqual(cbody.count_ops().keys(), {"u", "cx"})
self.assertEqual(qc_uni1_mat, Operator(cbody))
def test_mapping_control_flow(self):
"""Test that inner dags use proper qubit mapping."""
qr = QuantumRegister(3, "q")
qc = QuantumCircuit(qr)
# Create target that supports CX only between 0 and 2.
fake_target = Target()
fake_target.add_instruction(CXGate(), {(0, 2): None})
fake_target.add_instruction(
UGate(Parameter("t"), Parameter("p"), Parameter("l")),
{
(0,): None,
(1,): None,
(2,): None,
},
)
qc_uni1 = QuantumCircuit(2)
qc_uni1.swap(0, 1)
qc_uni1_mat = Operator(qc_uni1)
loop_body = QuantumCircuit(2)
loop_body.unitary(qc_uni1_mat, [0, 1])
# Loop body uses qubits 0 and 2, mapped to 0 and 1 in the block.
# If synthesis doesn't handle recursive mapping, it'll incorrectly
# look for a CX on (0, 1) instead of on (0, 2).
qc.for_loop((0,), None, loop_body, [0, 2], [])
dag = circuit_to_dag(qc)
UnitarySynthesis(basis_gates=["u", "cx"], target=fake_target).run(dag)
def test_single_qubit_with_target(self):
"""Test input circuit with only 1q works with target."""
qc = QuantumCircuit(1)
qc.append(ZGate(), [qc.qubits[0]])
dag = circuit_to_dag(qc)
unitary_synth_pass = UnitarySynthesis(target=FakeBelemV2().target)
result_dag = unitary_synth_pass.run(dag)
result_qc = dag_to_circuit(result_dag)
self.assertEqual(qc, result_qc)
def test_single_qubit_identity_with_target(self):
"""Test input single qubit identity works with target."""
qc = QuantumCircuit(1)
qc.unitary([[1.0, 0.0], [0.0, 1.0]], 0)
dag = circuit_to_dag(qc)
unitary_synth_pass = UnitarySynthesis(target=FakeBelemV2().target)
result_dag = unitary_synth_pass.run(dag)
result_qc = dag_to_circuit(result_dag)
self.assertEqual(result_qc, QuantumCircuit(1))
def test_unitary_synthesis_with_ideal_and_variable_width_ops(self):
"""Test unitary synthesis works with a target that contains ideal and variadic ops."""
qc = QuantumCircuit(2)
qc.unitary(np.eye(4), [0, 1])
dag = circuit_to_dag(qc)
target = FakeBelemV2().target
target.add_instruction(IfElseOp, name="if_else")
target.add_instruction(ZGate())
target.add_instruction(ECRGate())
unitary_synth_pass = UnitarySynthesis(target=target)
result_dag = unitary_synth_pass.run(dag)
result_qc = dag_to_circuit(result_dag)
self.assertEqual(result_qc, QuantumCircuit(2))
def test_unitary_synthesis_custom_gate_target(self):
qc = QuantumCircuit(2)
qc.unitary(np.eye(4), [0, 1])
dag = circuit_to_dag(qc)
class CustomGate(Gate):
"""Custom Opaque Gate"""
def __init__(self):
super().__init__("custom", 2, [])
target = Target(num_qubits=2)
target.add_instruction(
UGate(Parameter("t"), Parameter("p"), Parameter("l")), {(0,): None, (1,): None}
)
target.add_instruction(CustomGate(), {(0, 1): None, (1, 0): None})
unitary_synth_pass = UnitarySynthesis(target=target)
result_dag = unitary_synth_pass.run(dag)
result_qc = dag_to_circuit(result_dag)
self.assertEqual(result_qc, qc)
def test_default_does_not_fail_on_no_syntheses(self):
qc = QuantumCircuit(1)
qc.unitary(np.eye(2), [0])
pass_ = UnitarySynthesis(["unknown", "gates"])
self.assertEqual(qc, pass_(qc))
def test_iswap_no_cx_synthesis_succeeds(self):
"""Test basis set with iswap but no cx can synthesize a circuit"""
target = Target()
theta = Parameter("theta")
i_props = {
(0,): InstructionProperties(duration=35.5e-9, error=0.000413),
(1,): InstructionProperties(duration=35.5e-9, error=0.000502),
}
target.add_instruction(IGate(), i_props)
rz_props = {
(0,): InstructionProperties(duration=0, error=0),
(1,): InstructionProperties(duration=0, error=0),
}
target.add_instruction(RZGate(theta), rz_props)
sx_props = {
(0,): InstructionProperties(duration=35.5e-9, error=0.000413),
(1,): InstructionProperties(duration=35.5e-9, error=0.000502),
}
target.add_instruction(SXGate(), sx_props)
x_props = {
(0,): InstructionProperties(duration=35.5e-9, error=0.000413),
(1,): InstructionProperties(duration=35.5e-9, error=0.000502),
}
target.add_instruction(XGate(), x_props)
iswap_props = {
(0, 1): InstructionProperties(duration=519.11e-9, error=0.01201),
(1, 0): InstructionProperties(duration=554.66e-9, error=0.01201),
}
target.add_instruction(iSwapGate(), iswap_props)
measure_props = {
(0,): InstructionProperties(duration=5.813e-6, error=0.0751),
(1,): InstructionProperties(duration=5.813e-6, error=0.0225),
}
target.add_instruction(Measure(), measure_props)
qc = QuantumCircuit(2)
cxmat = Operator(CXGate()).to_matrix()
qc.unitary(cxmat, [0, 1])
unitary_synth_pass = UnitarySynthesis(target=target)
dag = circuit_to_dag(qc)
result_dag = unitary_synth_pass.run(dag)
result_qc = dag_to_circuit(result_dag)
self.assertTrue(np.allclose(Operator(result_qc.to_gate()).to_matrix(), cxmat))
def test_parameterized_basis_gate_in_target(self):
"""Test synthesis with parameterized RXX gate."""
theta = Parameter("θ")
lam = Parameter("λ")
target = Target(num_qubits=2)
target.add_instruction(RZGate(lam))
target.add_instruction(RXGate(theta))
target.add_instruction(RXXGate(theta))
qc = QuantumCircuit(2)
qc.cp(np.pi / 2, 0, 1)
qc_transpiled = transpile(qc, target=target, optimization_level=3, seed_transpiler=42)
opcount = qc_transpiled.count_ops()
self.assertTrue(set(opcount).issubset({"rz", "rx", "rxx"}))
self.assertTrue(np.allclose(Operator(qc_transpiled), Operator(qc)))
if __name__ == "__main__":
unittest.main()
|
https://github.com/arthurfaria/QC_basic_agorithms_qiskit
|
arthurfaria
|
# imports:
import numpy as np
from qiskit import IBMQ, Aer
from qiskit import QuantumCircuit, assemble, transpile
n=2
dj_circuit = QuantumCircuit(n+1, n)
bits = []
for qubit in range(n+1):
dj_circuit.h(qubit)
# Put the n qubit in state |->
dj_circuit.x(n)
dj_circuit.draw(output = 'mpl')
def oracle(bits):
for i in bits:
return dj_circuit.x(i)
for qubit in range(n):
dj_circuit.h(qubit)
for i in range(n):
dj_circuit.measure(i, i)
# I: Create state |00>x|1>
n=2
dj_circuit = QuantumCircuit(n+1, n)
def full_circuit(bits):
# II: Apply Hadamard to all
for qubit in range(n+1):
dj_circuit.h(qubit)
# Put the n qubit in state |->
dj_circuit.x(n)
dj_circuit.h(n)
dj_circuit.draw()
# III: Call Oracle
oracle(bits)
# IV: Apply Hadamard to all qubits in the first register
for qubit in range(n):
dj_circuit.h(qubit)
# V: Measure first register
for i in range(n):
measurements = dj_circuit.measure(i, i)
# get results
aer_sim = Aer.get_backend('aer_simulator')
qobj = assemble(dj_circuit, aer_sim)
results = aer_sim.run(qobj).result()
answer = results.get_counts()
return list(answer)[0]
def oracle_type(bits):
sample = full_circuit(bits)
ans = ''
if sample[0]=='0' and sample[1]=='0':
ans = "constant"
elif sample[0]=='1' and sample[1]=='1':
ans = "constant"
elif sample[0]=='0' and sample[1]=='1':
ans = "balanced"
elif sample[0]=='1' and sample[1]=='0':
ans = "balanced"
else:
ans = "Neither constant nor balanced"
return print(ans)
bits1 = [1,1]
oracle_type(bits1)
|
https://github.com/arthurfaria/QC_basic_agorithms_qiskit
|
arthurfaria
|
import matplotlib as mpl
import numpy as np
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, Aer, transpile, assemble
from qiskit.visualization import plot_histogram, plot_bloch_multivector
qc = QuantumCircuit(1,1)
# Alice prepares qubit in state |+>
qc.h(0)
qc.barrier()
# Alice now sends the qubit to Bob
# who measures it in the X-basis
qc.h(0)
qc.measure(0,0)
# Draw and simulate circuit
display(qc.draw())
aer_sim = Aer.get_backend('aer_simulator')
job = aer_sim.run(assemble(qc))
plot_histogram(job.result().get_counts())
qc = QuantumCircuit(1,1)
# Alice prepares qubit in state |+>
qc.h(0)
# Alice now sends the qubit to Bob
# but Eve intercepts and tries to read it
qc.measure(0, 0)
qc.barrier()
# Eve then passes this on to Bob
# who measures it in the X-basis
qc.h(0)
qc.measure(0,0)
# Draw and simulate circuit
display(qc.draw())
aer_sim = Aer.get_backend('aer_simulator')
job = aer_sim.run(assemble(qc))
plot_histogram(job.result().get_counts())
n = 100
## Step 1
# Alice generates bits.
alice_bits = np.random.randint(0,2,n)
## Step 2
# Create an array to tell us which qubits
# are encoded in which bases
alice_bases = np.random.randint(0,2,n)
# Function to compare the bits & bases generated by alice, and then 'encode' the message. Basically determines the state of the qubit/photon to send.
def encode_message(bits, bases):
message = []
for i in range(n):
qc = QuantumCircuit(1,1)
if bases[i] == 0: # Prepare qubit in Z-basis
if bits[i] == 0:
pass
else:
qc.x(0)
else: # Prepare qubit in X-basis
if bits[i] == 0:
qc.h(0)
else:
qc.x(0)
qc.h(0)
qc.barrier()
message.append(qc)
return message
# Alice computes the encoded message using the function defined above.
message = encode_message(alice_bits, alice_bases)
## Step 3
# Decide which basis to measure in:
bob_bases = np.random.randint(0,2,n)
# Function to decode the message sent by alice by comparing qubit/photon states with Bob's generated bases.
def measure_message(message, bases):
backend = Aer.get_backend('aer_simulator')
measurements = []
for q in range(n):
if bases[q] == 0: # measuring in Z-basis
message[q].measure(0,0)
if bases[q] == 1: # measuring in X-basis
message[q].h(0)
message[q].measure(0,0)
aer_sim = Aer.get_backend('aer_simulator')
qobj = assemble(message[q], shots=1, memory=True)
result = aer_sim.run(qobj).result()
measured_bit = int(result.get_memory()[0])
measurements.append(measured_bit)
return measurements
# Decode the message according to his bases
bob_results = measure_message(message, bob_bases)
## Step 4
# Function to perform sifting i.e. disregard the bits for which Bob's & A;ice's bases didnot match.
def remove_garbage(a_bases, b_bases, bits):
good_bits = []
for q in range(n):
if a_bases[q] == b_bases[q]:
# If both used the same basis, add
# this to the list of 'good' bits
good_bits.append(bits[q])
return good_bits
# Performing sifting for Alice's and Bob's bits.
alice_key = remove_garbage(alice_bases, bob_bases, alice_bits)
bob_key = remove_garbage(alice_bases, bob_bases, bob_results)
print("Alice's key after sifting (without interception)", alice_key)
print("Bob's key after sifting (without interception) ", bob_key)
# # Step 5
# # Function for parameter estimation i.e. determining the error rate by comparing subsets taen from both Alice's key & Bob's key.
# def sample_bits(bits, selection):
# sample = []
# for i in selection:
# # use np.mod to make sure the
# # bit we sample is always in
# # the list range
# i = np.mod(i, len(bits))
# # pop(i) removes the element of the
# # list at index 'i'
# sample.append(bits.pop(i))
# return sample
# # Performing parameter estimation & disregarding the bits used for comparison from Alice's & Bob's key.
# sample_size = 15
# bit_selection = np.random.randint(0,n,size=sample_size)
# bob_sample = sample_bits(bob_key, bit_selection)
# alice_sample = sample_bits(alice_key, bit_selection)
num = 0
for i in range(0,len(bob_key)):
if alice_key[i] == bob_key[i]:
num = num + 1
matching_bits = (num/len(bob_key))*100
print(matching_bits,"% of the bits match.")
## Step 1
alice_bits = np.random.randint(2, size=n)
## Step 2
alice_bases = np.random.randint(2, size=n)
message = encode_message(alice_bits, alice_bases)
## Interception!!
eve_bases = np.random.randint(2, size=n)
intercepted_message = measure_message(message, eve_bases)
## Step 3
bob_bases = np.random.randint(2, size=n)
bob_results = measure_message(message, bob_bases)
## Step 4
bob_key = remove_garbage(alice_bases, bob_bases, bob_results)
alice_key = remove_garbage(alice_bases, bob_bases, alice_bits)
print("Alice's key after sifting (with interception)", alice_key)
print("Bob's key after sifting (with interception) ", bob_key)
# ## Step 5
# sample_size = 15
# bit_selection = np.random.randint(n, size=sample_size)
# bob_sample = sample_bits(bob_key, bit_selection)
# alice_sample = sample_bits(alice_key, bit_selection)
num = 0
for i in range(0,len(bob_key)):
if alice_key[i] == bob_key[i]:
num = num + 1
matching_bits = (num/len(bob_key))*100
print(matching_bits,"% of the bits match.")
plt.rcParams['axes.linewidth'] = 2
mpl.rcParams['font.family'] = ['Georgia']
plt.figure(figsize=(10.5,6))
ax=plt.axes()
ax.set_title('')
ax.set_xlabel('$n$ (Number of bits drawn from the sifted keys for determining error rate)',fontsize = 18,labelpad=10)
ax.set_ylabel(r'$P(Eve\ detected)$',fontsize = 18,labelpad=10)
ax.xaxis.set_tick_params(which='major', size=8, width=2, direction='in', top='on')
ax.yaxis.set_tick_params(which='major', size=8, width=2, direction='in', top='on')
ax.tick_params(axis='x', labelsize=20)
ax.tick_params(axis='y', labelsize=20)
ax. xaxis. label. set_size(20)
ax. yaxis. label. set_size(20)
n = 30
x = np.arange(n+1)
y = 1 - 0.75**x
ax.plot(x,y,color = plt.cm.rainbow(np.linspace(0, 1, 5))[0], marker = "s", markerfacecolor='r')
|
https://github.com/arthurfaria/QC_basic_agorithms_qiskit
|
arthurfaria
|
from qiskit import IBMQ, Aer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, execute, assemble, QuantumRegister, ClassicalRegister
from qiskit.tools.monitor import job_monitor
import matplotlib as mpl
# import basic plot tools
from qiskit.visualization import plot_histogram, plot_bloch_multivector
import numpy as np
from numpy import pi
# Initializing the Qubits
ql = QuantumRegister(3, name="ql") # logic qubits
qa = QuantumRegister(2, name="qa") # Ancilla qubits
mea = ClassicalRegister(3, name="mea")
syn = ClassicalRegister(2, name="syn")
qec_circuit = QuantumCircuit(ql,qa,mea,syn)
# Encoding
qec_circuit.clear()
qec_circuit.cx(0,1)
qec_circuit.cx(0,2)
qec_circuit.barrier()
# Bit flip error
n = np.random.randint(3)
qec_circuit.x(n)
qec_circuit.barrier()
# Syndrome Circuit
qec_circuit.cx(0,3)
qec_circuit.cx(1,3)
qec_circuit.cx(0,4)
qec_circuit.cx(2,4)
qec_circuit.barrier()
qec_circuit.measure(qa,syn)
# Recovery cirucit
qec_circuit.barrier()
qec_circuit.mct([3,4],0)
qec_circuit.x(4)
qec_circuit.mct([3,4],1)
qec_circuit.x(4)
qec_circuit.x(3)
qec_circuit.mct([3,4],2)
qec_circuit.x(3)
qec_circuit.barrier()
# Decoding circuit
qec_circuit.cx(0,2)
qec_circuit.cx(0,1)
qec_circuit.barrier()
# measurement
qec_circuit.measure(ql,mea)
qec_circuit.draw("mpl")
qec_circuit.draw('mpl')
aer_sim = Aer.get_backend('aer_simulator')
shots = 1024
t_qec = execute(qec_circuit, aer_sim, shots=shots).result()
counts = t_qec.get_counts()
plot_histogram(counts)
|
https://github.com/arthurfaria/QC_basic_agorithms_qiskit
|
arthurfaria
|
# Do the necessary imports
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import IBMQ, Aer, transpile, assemble
from qiskit.visualization import plot_histogram, plot_bloch_multivector, array_to_latex
from qiskit.extensions import Initialize
from qiskit.ignis.verification import marginal_counts
from qiskit.quantum_info import random_statevector
# Loading your IBM Quantum account(s)
provider = IBMQ.load_account()
## SETUP
# Protocol uses 3 qubits and 2 classical bits in 2 different registers
qr = QuantumRegister(3, name="q") # Protocol uses 3 qubits
crz = ClassicalRegister(1, name="crz") # and 2 classical bits
crx = ClassicalRegister(1, name="crx") # in 2 different registers
teleportation_circuit = QuantumCircuit(qr, crz, crx)
def create_bell_pair(qc, a, b):
qc.h(a)
qc.cx(a,b)
qr = QuantumRegister(3, name="q")
crz, crx = ClassicalRegister(1, name="crz"), ClassicalRegister(1, name="crx")
teleportation_circuit = QuantumCircuit(qr, crz, crx)
create_bell_pair(teleportation_circuit, 1, 2)
teleportation_circuit.draw()
def alice_gates(qc, psi, a):
qc.cx(psi, a)
qc.h(psi)
qr = QuantumRegister(3, name="q")
crz, crx = ClassicalRegister(1, name="crz"), ClassicalRegister(1, name="crx")
teleportation_circuit = QuantumCircuit(qr, crz, crx)
## STEP 1
create_bell_pair(teleportation_circuit, 1, 2)
## STEP 2
teleportation_circuit.barrier() # Use barrier to separate steps
alice_gates(teleportation_circuit, 0, 1)
teleportation_circuit.draw()
def measure_and_send(qc, a, b):
"""Measures qubits a & b and 'sends' the results to Bob"""
qc.barrier()
qc.measure(a,0)
qc.measure(b,1)
qr = QuantumRegister(3, name="q")
crz, crx = ClassicalRegister(1, name="crz"), ClassicalRegister(1, name="crx")
teleportation_circuit = QuantumCircuit(qr, crz, crx)
create_bell_pair(teleportation_circuit, 1, 2)
teleportation_circuit.barrier() # Use barrier to separate steps
alice_gates(teleportation_circuit, 0, 1)
measure_and_send(teleportation_circuit, 0 ,1)
teleportation_circuit.draw()
def bob_gates(qc, qubit, crz, crx):
qc.x(qubit).c_if(crx, 1) # Apply gates if the registers
qc.z(qubit).c_if(crz, 1) # are in the state '1'
qr = QuantumRegister(3, name="q")
crz, crx = ClassicalRegister(1, name="crz"), ClassicalRegister(1, name="crx")
teleportation_circuit = QuantumCircuit(qr, crz, crx)
## STEP 1
create_bell_pair(teleportation_circuit, 1, 2)
## STEP 2
teleportation_circuit.barrier() # Use barrier to separate steps
alice_gates(teleportation_circuit, 0, 1)
## STEP 3
measure_and_send(teleportation_circuit, 0, 1)
## STEP 4
teleportation_circuit.barrier() # Use barrier to separate steps
bob_gates(teleportation_circuit, 2, crz, crx)
teleportation_circuit.draw()
# Create random 1-qubit state
psi = random_statevector(2)
# Display it nicely
display(array_to_latex(psi, prefix="|\\psi\\rangle ="))
# Show it on a Bloch sphere
plot_bloch_multivector(psi)
init_gate = Initialize(psi)
init_gate.label = "init"
## SETUP
qr = QuantumRegister(3, name="q") # Protocol uses 3 qubits
crz = ClassicalRegister(1, name="crz") # and 2 classical registers
crx = ClassicalRegister(1, name="crx")
qc = QuantumCircuit(qr, crz, crx)
## STEP 0
# First, let's initialize Alice's q0
qc.append(init_gate, [0])
qc.barrier()
## STEP 1
# Now begins the teleportation protocol
create_bell_pair(qc, 1, 2)
qc.barrier()
## STEP 2
# Send q1 to Alice and q2 to Bob
alice_gates(qc, 0, 1)
## STEP 3
# Alice then sends her classical bits to Bob
measure_and_send(qc, 0, 1)
## STEP 4
# Bob decodes qubits
bob_gates(qc, 2, crz, crx)
# Display the circuit
qc.draw()
sim = Aer.get_backend('aer_simulator')
qc.save_statevector()
out_vector = sim.run(qc).result().get_statevector()
plot_bloch_multivector(out_vector)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.