repo
stringclasses 900
values | file
stringclasses 754
values | content
stringlengths 4
215k
|
|---|---|---|
https://github.com/maryrbarros2/QuantumAlgorithms_Qiskit
|
maryrbarros2
|
from qiskit import QuantumCircuit, Aer, assemble
from math import pi
import numpy as np
from qiskit.visualization import plot_bloch_multivector, plot_histogram, array_to_latex
qc = QuantumCircuit(2)
qc.h(0)
qc.h(1)
qc.cx(0,1)
qc.draw()
qc = QuantumCircuit(2)
qc.h(0)
qc.h(1)
qc.cx(0,1)
display(qc.draw()) # `display` is a command for Jupyter notebooks
# similar to `print`, but for rich content
# Let's see the result
svsim = Aer.get_backend('aer_simulator')
qc.save_statevector()
qobj = assemble(qc)
final_state = svsim.run(qobj).result().get_statevector()
display(array_to_latex(final_state, prefix="\\text{Statevector} = "))
plot_bloch_multivector(final_state)
qc = QuantumCircuit(2)
qc.h(0)
qc.x(1)
qc.h(1)
qc.draw()
qc = QuantumCircuit(2)
qc.h(0)
qc.x(1)
qc.h(1)
display(qc.draw())
# See the result
qc1 = qc.copy()
qc1.save_statevector()
final_state = svsim.run(qc1).result().get_statevector()
display(array_to_latex(final_state, prefix="\\text{Statevector} = "))
plot_bloch_multivector(final_state)
qc.cx(0,1)
display(qc.draw())
qc.save_statevector()
qobj = assemble(qc)
final_state = svsim.run(qobj).result().get_statevector()
display(array_to_latex(final_state, prefix="\\text{Statevector} = "))
plot_bloch_multivector(final_state)
qc = QuantumCircuit(2)
qc.h(0)
qc.h(1)
qc.cx(0,1)
qc.h(0)
qc.h(1)
display(qc.draw())
qc.save_unitary()
usim = Aer.get_backend('aer_simulator')
qobj = assemble(qc)
unitary = usim.run(qobj).result().get_unitary()
array_to_latex(unitary, prefix="\\text{Circuit = }\n")
qc = QuantumCircuit(2)
qc.cx(1,0)
display(qc.draw())
qc.save_unitary()
qobj = assemble(qc)
unitary = usim.run(qobj).result().get_unitary()
array_to_latex(unitary, prefix="\\text{Circuit = }\n")
qc = QuantumCircuit(2)
qc.cp(pi/4, 0, 1)
qc.draw()
qc = QuantumCircuit(2)
qc.cp(pi/4, 0, 1)
display(qc.draw())
# See Results:
qc.save_unitary()
qobj = assemble(qc)
unitary = usim.run(qobj).result().get_unitary()
array_to_latex(unitary, prefix="\\text{Controlled-T} = \n")
qc = QuantumCircuit(2)
qc.h(0)
qc.x(1)
display(qc.draw())
# See Results:
qc.save_statevector()
qobj = assemble(qc)
final_state = svsim.run(qobj).result().get_statevector()
plot_bloch_multivector(final_state)
qc = QuantumCircuit(2)
qc.h(0)
qc.x(1)
# Add Controlled-T
qc.cp(pi/4, 0, 1)
display(qc.draw())
# See Results:
qc.save_statevector()
qobj = assemble(qc)
final_state = svsim.run(qobj).result().get_statevector()
plot_bloch_multivector(final_state)
|
https://github.com/maryrbarros2/QuantumAlgorithms_Qiskit
|
maryrbarros2
|
# initialization
import numpy as np
import matplotlib
# importing Qiskit
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ, BasicAer, assemble, transpile
from qiskit.quantum_info import Statevector
# import basic plot tools
from qiskit.visualization import plot_bloch_multivector,plot_bloch_vector, plot_histogram
style = {'backgroundcolor': 'lightyellow'} # Style of the circuits
# set the length of the n-bit input string.
n = 3
# set the length of the n-bit input string.
n = 3
const_oracle = QuantumCircuit(n+1)
output = np.random.randint(2)
if output == 1:
const_oracle.x(n)
const_oracle.draw(output='mpl', style=style)
balanced_oracle = QuantumCircuit(n+1)
b_str = "101"
balanced_oracle = QuantumCircuit(n+1)
b_str = "101"
# Place X-gates
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
balanced_oracle.x(qubit)
balanced_oracle.draw(output='mpl', style=style)
balanced_oracle = QuantumCircuit(n+1)
b_str = "101"
# Place X-gates
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
balanced_oracle.x(qubit)
# Use barrier as divider
balanced_oracle.barrier()
# Controlled-NOT gates
for qubit in range(n):
balanced_oracle.cx(qubit, n)
balanced_oracle.barrier()
balanced_oracle.draw(output='mpl', style=style)
balanced_oracle = QuantumCircuit(n+1)
b_str = "101"
# Place X-gates
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
balanced_oracle.x(qubit)
# Use barrier as divider
balanced_oracle.barrier()
# Controlled-NOT gates
for qubit in range(n):
balanced_oracle.cx(qubit, n)
balanced_oracle.barrier()
# Place X-gates
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
balanced_oracle.x(qubit)
# Show oracle
balanced_oracle.draw(output='mpl', style=style)
dj_circuit = QuantumCircuit(n+1, n)
# Apply H-gates
for qubit in range(n):
dj_circuit.h(qubit)
# Put qubit in state |->
dj_circuit.x(n)
dj_circuit.h(n)
dj_circuit.draw(output='mpl', style=style)
dj_circuit = QuantumCircuit(n+1, n)
# Apply H-gates
for qubit in range(n):
dj_circuit.h(qubit)
# Put qubit in state |->
dj_circuit.x(n)
dj_circuit.h(n)
# Add oracle
dj_circuit += balanced_oracle
dj_circuit.draw(output='mpl', style=style)
dj_circuit = QuantumCircuit(n+1, n)
# Apply H-gates
for qubit in range(n):
dj_circuit.h(qubit)
# Put qubit in state |->
dj_circuit.x(n)
dj_circuit.h(n)
# Add oracle
dj_circuit += balanced_oracle
# Repeat H-gates
for qubit in range(n):
dj_circuit.h(qubit)
dj_circuit.barrier()
# Measure
for i in range(n):
dj_circuit.measure(i, i)
# Display circuit
dj_circuit.draw(output='mpl', style=style)
# use local simulator
aer_sim = Aer.get_backend('aer_simulator')
qobj = assemble(dj_circuit, aer_sim)
results = aer_sim.run(qobj).result()
answer = results.get_counts()
plot_histogram(answer)
def dj_oracle(case, n):
# We need to make a QuantumCircuit object to return
# This circuit has n+1 qubits: the size of the input,
# plus one output qubit
oracle_qc = QuantumCircuit(n+1)
# First, let's deal with the case in which oracle is balanced
if case == "balanced":
# First generate a random number that tells us which CNOTs to
# wrap in X-gates:
b = np.random.randint(1,2**n)
print(b)
print(str(n))
b=7
# Next, format 'b' as a binary string of length 'n', padded with zeros:
b_str = format(b, '0'+str(n)+'b')
print(b_str)
# Next, we place the first X-gates. Each digit in our binary string
# corresponds to a qubit, if the digit is 0, we do nothing, if it's 1
# we apply an X-gate to that qubit:
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
oracle_qc.x(qubit)
# Do the controlled-NOT gates for each qubit, using the output qubit
# as the target:
for qubit in range(n):
oracle_qc.cx(qubit, n)
# Next, place the final X-gates
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
oracle_qc.x(qubit)
# Case in which oracle is constant
if case == "constant":
# First decide what the fixed output of the oracle will be
# (either always 0 or always 1)
output = np.random.randint(2)
if output == 1:
oracle_qc.x(n)
oracle_gate = oracle_qc.to_gate()
oracle_gate.name = "Oracle" # To show when we display the circuit
return oracle_gate
def dj_algorithm(oracle, n):
dj_circuit = QuantumCircuit(n+1, n)
# Set up the output qubit:
dj_circuit.x(n)
dj_circuit.h(n)
# And set up the input register:
for qubit in range(n):
dj_circuit.h(qubit)
# Let's append the oracle gate to our circuit:
dj_circuit.append(oracle, range(n+1))
# Finally, perform the H-gates again and measure:
for qubit in range(n):
dj_circuit.h(qubit)
for i in range(n):
dj_circuit.measure(i, i)
return dj_circuit
n = 4
oracle_gate = dj_oracle('balanced', n)
dj_circuit = dj_algorithm(oracle_gate, n)
dj_circuit.draw(output='mpl', style=style)
transpiled_dj_circuit = transpile(dj_circuit, aer_sim)
qobj = assemble(transpiled_dj_circuit)
results = aer_sim.run(qobj).result()
answer = results.get_counts()
plot_histogram(answer)
|
https://github.com/maryrbarros2/QuantumAlgorithms_Qiskit
|
maryrbarros2
|
my_list = [1,3,5,2,4,2,5,8,0,7,6]
#classical computation method
def oracle(my_input):
winner =7
if my_input is winner:
response = True
else:
response = False
return response
for index, trial_number in enumerate(my_list):
if oracle(trial_number) is True:
print("Winner is found at index %i" %index)
print("%i calls to the oracle used " %(index +1))
break
#quantum implemenation
from qiskit import *
import matplotlib.pyplot as plt
import numpy as np
from qiskit.tools import job_monitor
# oracle circuit
oracle = QuantumCircuit(2, name='oracle')
oracle.cz(0,1)
oracle.to_gate()
oracle.draw(output='mpl')
backend = Aer.get_backend('statevector_simulator')
grover_circuit = QuantumCircuit(2,2)
grover_circuit.h([0,1])
grover_circuit.append(oracle,[0,1])
grover_circuit.draw(output='mpl')
job= execute(grover_circuit, backend=backend)
result= job.result()
sv= result.get_statevector()
np.around(sv,2)
#amplitude amplification
reflection = QuantumCircuit(2, name='reflection')
reflection.h([0,1])
reflection.z([0,1])
reflection.cz(0,1)
reflection.h([0,1])
reflection.to_gate()
reflection.draw(output='mpl')
#testing circuit on simulator
simulator = Aer.get_backend('qasm_simulator')
grover_circuit = QuantumCircuit(2,2)
grover_circuit.h([0,1])
grover_circuit.append(oracle,[0,1])
grover_circuit.append(reflection, [0,1])
grover_circuit.barrier()
grover_circuit.measure([0,1],[0,1])
grover_circuit.draw(output='mpl')
job= execute(grover_circuit,backend=simulator,shots=1)
result=job.result()
result.get_counts()
#testing on real backend system
IBMQ.load_account()
provider= IBMQ.get_provider('ibm-q')
qcomp= provider.get_backend('ibmq_manila')
job = execute(grover_circuit,backend=qcomp)
job_monitor(job)
result=job.result()
counts=result.get_counts(grover_circuit)
from qiskit.visualization import plot_histogram
plot_histogram(counts)
counts['11']
|
https://github.com/maryrbarros2/QuantumAlgorithms_Qiskit
|
maryrbarros2
|
import numpy as np
from qiskit import QuantumCircuit, transpile
from qiskit.providers.aer import QasmSimulator
from qiskit.visualization import plot_histogram
# Create a Quantum Circuit acting on a quantum register of three qubits
circ = QuantumCircuit(3)
#default, each qubit in the register is initialized to |0⟩
# 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
from qiskit import execute
# Run the quantum circuit on a statevector simulator backend
backend = Aer.get_backend('statevector_simulator')
# Create a Quantum Program for execution
job = execute(circ, backend)
job.status()
result = job.result() #results object contains the data
outputstate = result.get_statevector(circ, decimals=3)
print(outputstate)
from qiskit.visualization import plot_state_city
plot_state_city(outputstate)
# Run the quantum circuit on a unitary simulator backend
backend = Aer.get_backend('unitary_simulator')
job = execute(circ, backend)
result = job.result()
output = result.get_unitary(circ, decimals=3)
# Show the results
print(output)
plot_state_city(output)
# Create a Quantum Circuit
meas = QuantumCircuit(3, 3)
meas.barrier(range(3))
# map the quantum measurement to the classical bits
meas.measure(range(3), range(3))
# The Qiskit circuit object supports composition using
# the addition operator.
qc = circ + meas
#drawing the circuit
qc.draw()
# Use Aer's qasm_simulator
backend_sim = Aer.get_backend('qasm_simulator')
# Execute the circuit on the qasm simulator.
# We've set the number of repeats of the circuit
# to be 1024, which is the default.
job_sim = execute(qc, backend_sim, shots=1024)
# Grab the results from the job.
result_sim = job_sim.result()
counts = result_sim.get_counts(qc)
print(counts)
from qiskit.visualization import plot_histogram
plot_histogram(counts)
#Trying with different shots to compare:
job_sim2 = execute(qc, backend_sim, shots=3000)
# Grab the results from the job.
result_sim2 = job_sim2.result()
counts2 = result_sim2.get_counts(qc)
plot_histogram(counts2)
|
https://github.com/maryrbarros2/QuantumAlgorithms_Qiskit
|
maryrbarros2
|
# Do the necessary imports
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, BasicAer, IBMQ
from qiskit.visualization import plot_histogram, plot_bloch_multivector
### Creating 3 qubit and 2 classical bits in each separate register
qr = QuantumRegister(3)
crz = ClassicalRegister(1)
crx = ClassicalRegister(1)
teleportation_circuit = QuantumCircuit(qr, crz, crx)
### A third party eve helps to create an entangled state
def create_bell_pair(qc, a, b):
qc.h(a)
qc.cx(a, b)
create_bell_pair(teleportation_circuit, 1, 2)
teleportation_circuit.draw()
def alice_gates(qc, a, b):
qc.cx(a, b)
qc.h(a)
teleportation_circuit.barrier()
alice_gates(teleportation_circuit, 0, 1)
teleportation_circuit.draw()
def measure_and_send(qc, a, b):
qc.barrier()
qc.measure(a,0)
qc.measure(b,1)
teleportation_circuit.barrier()
measure_and_send(teleportation_circuit, 0, 1)
teleportation_circuit.draw()
def bob_gates(qc, qubit, crz, crx):
qc.x(qubit).c_if(crx, 1)
qc.z(qubit).c_if(crz, 1)
teleportation_circuit.barrier()
bob_gates(teleportation_circuit, 2, crz, crx)
teleportation_circuit.draw()
from qiskit.extensions import Initialize
import math
qc = QuantumCircuit(1)
initial_state = [0,1]
init_gate = Initialize(initial_state)
# qc.append(initialize_qubit, [0])
qr = QuantumRegister(3) # Protocol uses 3 qubits
crz = ClassicalRegister(1) # and 2 classical registers
crx = ClassicalRegister(1)
qc = QuantumCircuit(qr, crz, crx)
# First, let's initialise Alice's q0
qc.append(init_gate, [0])
qc.barrier()
# Now begins the teleportation protocol
create_bell_pair(qc, 1, 2)
qc.barrier()
# Send q1 to Alice and q2 to Bob
alice_gates(qc, 0, 1)
# Alice then sends her classical bits to Bob
measure_and_send(qc, 0, 1)
# Bob decodes qubits
bob_gates(qc, 2, crz, crx)
qc.draw()
backend = BasicAer.get_backend('statevector_simulator')
out_vector = execute(qc, backend).result().get_statevector()
plot_bloch_multivector(out_vector)
inverse_init_gate = init_gate.gates_to_uncompute()
qc.append(inverse_init_gate, [2])
qc.draw()
cr_result = ClassicalRegister(1)
qc.add_register(cr_result)
qc.measure(2,2)
qc.draw()
backend = BasicAer.get_backend('qasm_simulator')
counts = execute(qc, backend, shots=1024).result().get_counts()
plot_histogram(counts)
def bob_gates(qc, a, b, c):
qc.cz(a, c)
qc.cx(b, c)
qc = QuantumCircuit(3,1)
# First, let's initialise Alice's q0
qc.append(init_gate, [0])
qc.barrier()
# Now begins the teleportation protocol
create_bell_pair(qc, 1, 2)
qc.barrier()
# Send q1 to Alice and q2 to Bob
alice_gates(qc, 0, 1)
qc.barrier()
# Alice sends classical bits to Bob
bob_gates(qc, 0, 1, 2)
# We undo the initialisation process
qc.append(inverse_init_gate, [2])
# See the results, we only care about the state of qubit 2
qc.measure(2,0)
# View the results:
qc.draw()
from qiskit import IBMQ
IBMQ.save_account('### IMB TOKEN ')
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
provider.backends()
from qiskit.providers.ibmq import least_busy
backend = least_busy(provider.backends(filters=lambda b: b.configuration().n_qubits >= 3 and
not b.configuration().simulator and b.status().operational==True))
job_exp = execute(qc, backend=backend, shots=8192)
exp_result = job_exp.result()
exp_measurement_result = exp_result.get_counts(qc)
print(exp_measurement_result)
plot_histogram(exp_measurement_result)
error_rate_percent = sum([exp_measurement_result[result] for result in exp_measurement_result.keys() if result[0]=='1']) \
* 100./ sum(list(exp_measurement_result.values()))
print("The experimental error rate : ", error_rate_percent, "%")
|
https://github.com/Sinestro38/Generalized-Quantum-Fourier-Transform
|
Sinestro38
|
import numpy as np
from numpy import pi
from qiskit import QuantumCircuit, transpile, assemble, Aer, IBMQ
from qiskit.providers.ibmq import least_busy
from qiskit.tools.monitor import job_monitor
from qiskit.visualization import plot_histogram, plot_bloch_multivector
qc = QuantumCircuit(3)
#Qiskit's least significant bit has the lowest index (0), thus the circuit will be mirrored through the horizontal
qc.h(2)
#Next, we want to turn this an extra quarter turn if qubit 1 is in the state |1>
qc.cp(pi/2, 1, 2) # CROT from qubit 1 to qubit 2
#And another eighth turn if the least significant qubit (0) is |1>
qc.cp(pi/4, 0, 2) # CROT from qubit 2 to qubit 0
qc.h(1)
qc.cp(pi/2, 0, 1) # CROT from qubit 0 to qubit 1
qc.h(0)
qc.swap(0,2)
qc.draw()
def qft_rotations(circuit, n):
if n == 0: # Exit function if circuit is empty
return circuit
n -= 1 # Indexes start from 0
circuit.h(n) # Apply the H-gate to the most significant qubit
for qubit in range(n):
# For each less significant qubit, we need to do a
# smaller-angled controlled rotation:
circuit.cp(pi/2**(n-qubit), qubit, n)
# At the end of our function, we call the same function again on
# the next qubits (we reduced n by one earlier in the function)
qft_rotations(circuit, n)
def swap_registers(circuit, n):
for qubit in range(n//2):
circuit.swap(qubit, n-qubit-1)
return circuit
def qft(circuit, n):
"""QFT on the first n qubits in circuit"""
qft_rotations(circuit, n)
swap_registers(circuit, n)
return circuit
qc1 = QuantumCircuit(4)
qft(qc1,4)
qc1.draw()
# Create the circuit
qc = QuantumCircuit(3)
# Encode the state 5
qc.x(0) # since we need '1' at first qubit and at last qubit
qc.x(2)
qc.draw()
# And let's check the qubit's states using the aer simulator:
sim = Aer.get_backend("aer_simulator")
qc_init = qc.copy() # making a copy so that we can work on the original one
qc_init.save_statevector()
statevector = sim.run(qc_init).result().get_statevector()
plot_bloch_multivector(statevector)
# we can see the state below as '101'
qft(qc,3)
qc.draw()
qc.save_statevector()
statevector = sim.run(qc).result().get_statevector()
plot_bloch_multivector(statevector)
def inverse_qft(circuit, n):
"""Does the inverse QFT on the first n qubits in circuit"""
# First we create a QFT circuit of the correct size:
qft_circ = qft(QuantumCircuit(n), n)
# Then we take the inverse of this circuit
invqft_circ = qft_circ.inverse()
# And add it to the first n qubits in our existing circuit
circuit.append(invqft_circ, circuit.qubits[:n])
return circuit.decompose() # .decompose() allows us to see the individual gates
nqubits = 3
number = 5
qc = QuantumCircuit(nqubits)
for qubit in range(nqubits):
qc.h(qubit)
qc.p(number*pi/4,0)
qc.p(number*pi/2,1)
qc.p(number*pi,2)
qc.draw()
qc_init = qc.copy()
qc_init.save_statevector()
sim = Aer.get_backend("aer_simulator")
statevector = sim.run(qc_init).result().get_statevector()
plot_bloch_multivector(statevector)
qc = inverse_qft(qc, nqubits)
qc.measure_all()
qc.draw()
# Load our saved IBMQ accounts and get the least busy backend device with less than or equal to nqubits
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= nqubits
and not x.configuration().simulator
and x.status().operational==True))
print("least busy backend: ", backend)
shots = 2048
transpiled_qc = transpile(qc, backend, optimization_level=3)
job = backend.run(transpiled_qc, shots=shots)
job_monitor(job)
counts = job.result().get_counts()
plot_histogram(counts)
|
https://github.com/ace314/Quantum-Multi-collision-Problem
|
ace314
|
#initialization
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
# importing Qiskit
from qiskit import IBMQ, BasicAer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
# import basic plot tools
from qiskit.tools.visualization import plot_histogram
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)
def inversion_about_average(circuit, register, n, barriers):
"""Apply inversion about the average step of Grover's algorithm."""
circuit.h(register)
circuit.x(register)
if barriers:
circuit.barrier()
n_controlled_Z(circuit, [register[j] for j in range(n-1)], register[n-1])
if barriers:
circuit.barrier()
circuit.x(register)
circuit.h(register)
def phase_oracle(circuit, qindex, qr):
circuit.cx(qindex[1],qr[0])
circuit.cx(qindex[2],qr[1])
def phase_flipping2(circuit, qindex, qr, qanx, T):
phase_oracle(groverCircuit, qindex, qr)
for i in range(T[1] // 2):
circuit.x(qanx[1])
for i in range(T[1] % 2):
circuit.x(qanx[2])
groverCircuit.barrier()
circuit.cx(qr[0], qanx[1])
circuit.cx(qr[1], qanx[2])
circuit.barrier()
circuit.cx(qanx[1], qanx[0])
circuit.cx(qanx[2], qanx[0])
circuit.ccx(qanx[1],qanx[2],qanx[0])
circuit.barrier()
circuit.cx(qr[0], qanx[1])
circuit.cx(qr[1], qanx[2])
circuit.x(qanx[0])
groverCircuit.barrier()
#print(T[1])
for i in range(T[1] // 2):
circuit.x(qanx[1])
for i in range(T[1] % 2):
circuit.x(qanx[2])
phase_oracle(groverCircuit, qindex, qr)
def phase_flipping3(circuit, qindex, qanx, T):
phase_oracle(groverCircuit, qindex, qr)
for i in range((T[0] // 4) % 2):
circuit.x(qanx[1])
for i in range((T[0] // 2) % 2):
circuit.x(qanx[2])
for i in range((T[0] // 1) % 2):
circuit.x(qanx[3])
groverCircuit.barrier()
circuit.cx(qindex[0], qanx[1])
circuit.cx(qindex[1], qanx[2])
circuit.cx(qindex[2], qanx[3])
circuit.barrier()
circuit.cx(qanx[1], qanx[0])
circuit.cx(qanx[2], qanx[0])
circuit.cx(qanx[3], qanx[0])
circuit.ccx(qanx[1], qanx[2], qanx[0])
circuit.ccx(qanx[2], qanx[3], qanx[0])
circuit.ccx(qanx[3], qanx[1], qanx[0])
circuit.ccx(qanx[1], qanx[2], qanx[4])
circuit.ccx(qanx[3], qanx[4], qanx[0])
circuit.ccx(qanx[1], qanx[2], qanx[4])
circuit.barrier()
circuit.cx(qindex[0], qanx[1])
circuit.cx(qindex[1], qanx[2])
circuit.cx(qindex[2], qanx[3])
circuit.x(qanx[0])
groverCircuit.barrier()
for i in range((T[0] // 4) % 2):
circuit.x(qanx[1])
for i in range((T[0] // 2) % 2):
circuit.x(qanx[2])
for i in range((T[0] // 1) % 2):
circuit.x(qanx[3])
phase_oracle(groverCircuit, qindex, qr)
L = np.array([[2,2],[7,3]])
print(L)
K = L[:,0]
print(K)
barriers = True
m = 3
n = 2
qindex = QuantumRegister(m)
qr = QuantumRegister(n)
qanx = QuantumRegister(5)
cindex = ClassicalRegister(m)
cr = ClassicalRegister(n)
groverCircuit = QuantumCircuit(qindex, qr, qanx, cindex, cr)
groverCircuit.h(qindex)
groverCircuit.x(qanx[0])
groverCircuit.h(qanx[0])
groverCircuit.barrier()
#num_loop = int(np.ceil(np.cbrt(2 ** m)))
num_loop = int(np.cbrt(2 ** m))
num_loop = 6
print("num_loop = ", num_loop)
#phase_oracle(groverCircuit, qindex, qr)
for i in range(num_loop):
if barriers:
groverCircuit.barrier()
# the first stage of grover
phase_flipping2(groverCircuit, qindex, qr, qanx, L[0,:])
if barriers:
groverCircuit.barrier()
# the third stage of grover
phase_flipping3(groverCircuit, qindex, qanx, L[0,:])
if barriers:
groverCircuit.barrier()
#the second stage of grover
# phase_flipping2(groverCircuit, qindex, qr, qanx, L[1,:])
if barriers:
groverCircuit.barrier()
# phase_flipping3(groverCircuit, qindex, qanx, L[1,:])
if barriers:
groverCircuit.barrier()
groverCircuit.barrier()
inversion_about_average(groverCircuit, qindex, m, barriers)
if barriers:
groverCircuit.barrier()
groverCircuit.measure(qindex,cindex)
%matplotlib inline
groverCircuit.draw(output='mpl')
# groverCircuit.draw(output="mpl")
backend = BasicAer.get_backend('qasm_simulator')
shots = 8192
results = execute(groverCircuit, backend=backend, shots=shots).result()
answer = results.get_counts()
plot_histogram(answer)
print(answer)
index = np.argmax(answer)
index = 2
print(index)
ans = np.zeros(2)
flag = False
for [i, j] in L:
#print([i,j])
#print(index % 4)
if j == index % 4:
flag = True
ans[0] = i
ans[1] = index
break
if flag:
print("ans = ", ans)
else :
print("failed")
|
https://github.com/Ben-Foxman/Quantum-Exploration
|
Ben-Foxman
|
my_list = [1, 3, 5, 2, 4, 9, 5, 8, 0, 7, 6]
def the_oracle(my_input):
winner = 7
return my_input == winner
for index, trial_number in enumerate(my_list):
if the_oracle(trial_number):
print(f"Found the winner at index {index}!")
print(f"{index+1} calls made")
break
from qiskit import *
from qiskit.visualization import plot_histogram, array_to_latex
from qiskit.providers.ibmq import least_busy
import matplotlib.pyplot as plt
import numpy as np
grover_circuit = QuantumCircuit(2)
def init_state(qc, qubits):
for q in qubits:
qc.h(q)
return qc
grover_circuit = init_state(grover_circuit, [0, 1])
grover_circuit.draw("mpl")
#define the oracle circuit
def oracle(qc, qubits):
qc.cz(qubits[0], qubits[1])
qc = QuantumCircuit(2)
oracle(qc, [0, 1])
qc.draw("mpl")
usim = Aer.get_backend('aer_simulator')
qc.save_unitary()
qobj = assemble(qc)
unitary = usim.run(qobj).result().get_unitary()
array_to_latex(unitary, prefix="\\text{One can see that only the state }\ket{11}\\text{ has been flipped: }\n")
def diffusion(qc, qubits):
qc.h([0, 1])
qc.z([0, 1])
qc.cz(0, 1)
qc.h([0, 1])
grover_circuit.barrier()
oracle(grover_circuit, [0, 1])
grover_circuit.barrier()
diffusion(grover_circuit, [0, 1])
grover_circuit.measure_all()
grover_circuit.draw("mpl")
# Let's see if the final statevector matches our expectations
sv_sim = Aer.get_backend('statevector_simulator')
result = sv_sim.run(grover_circuit).result()
statevec = result.get_statevector()
statevec
aer_sim = Aer.get_backend('aer_simulator')
result = execute(grover_circuit, aer_sim, shots=1024).result()
result.get_counts()
# Load IBM Q account and get the least busy backend device
# Run the following line with your API token to use IBM's own quantum computers
#IBMQ.save_account('')
provider = IBMQ.load_account()
provider = IBMQ.get_provider("ibm-q")
device = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 3 and
not x.configuration().simulator and x.status().operational==True))
print("Running on current least busy device: ", device)
# Run our circuit on the least busy backend. Monitor the execution of the job in the queue
from qiskit.tools.monitor import job_monitor
transpiled_grover_circuit = transpile(grover_circuit, device, optimization_level=3)
job = device.run(transpiled_grover_circuit)
job_monitor(job, interval=2)
# Get the results from the computation
results = job.result()
answer = results.get_counts(grover_circuit)
plot_histogram(answer)
grover_circuit = QuantumCircuit(3)
grover_circuit = init_state(grover_circuit, [0, 1, 2])
grover_circuit.draw("mpl")
oracle_qc = QuantumCircuit(3)
oracle_qc.cz(0, 1)
oracle_qc.cz(0, 2)
oracle_gate = oracle_qc.to_gate()
oracle_gate.name = "U$_\omega$"
def diffuser(nqubits):
qc = QuantumCircuit(nqubits)
# Apply transformation |s> -> |00..0> -> |11..1>
for qubit in range(nqubits):
qc.h(qubit)
qc.x(qubit)
# When these are combined, they function as a multi-controlled Z gate
# A negative phase is added to |11..1> to flip the state
qc.h(nqubits-1)
qc.mct(list(range(nqubits-1)), nqubits-1) # multi-controlled-toffoli
qc.h(nqubits-1)
# Apply transformation |11..1> -> |00..0> -> |s>
for qubit in range(nqubits):
qc.x(qubit)
qc.h(qubit)
# We will return the diffuser as a gate
U_s = qc.to_gate()
U_s.name = "U$_s$"
return U_s
num_qubits = 3
grover_circuit = QuantumCircuit(num_qubits)
grover_circuit = init_state(grover_circuit, [0, 1, 2])
grover_circuit.barrier()
grover_circuit.append(oracle_gate, [0, 1, 2])
grover_circuit.barrier()
grover_circuit.append(diffuser(num_qubits), [0, 1, 2])
grover_circuit.measure_all()
grover_circuit.draw("mpl")
qasm_sim = Aer.get_backend('qasm_simulator')
transpiled_grover_circuit = transpile(grover_circuit, qasm_sim)
results = qasm_sim.run(transpiled_grover_circuit).result()
counts = results.get_counts()
plot_histogram(counts)
backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 3 and
not x.configuration().simulator and x.status().operational==True))
print("least busy backend: ", backend)
# Run our circuit on the least busy backend. Monitor the execution of the job in the queue
from qiskit.tools.monitor import job_monitor
transpiled_grover_circuit = transpile(grover_circuit, device, optimization_level=3)
job = device.run(transpiled_grover_circuit)
job_monitor(job, interval=2)
# Get the results from the computation
results = job.result()
answer = results.get_counts(grover_circuit)
plot_histogram(answer)
|
https://github.com/Ben-Foxman/Quantum-Exploration
|
Ben-Foxman
|
# Superdense Coding Implementation Ben Foxman
import matplotlib.pyplot as plt
import numpy as np
from qiskit import *
bits = input("Enter 2 bits.") # the 2 bits to encode/decode
assert bits in ['00', '01', '10', '11']
# p1 encodes by creating map from each of the 4 bell states to each of the 4 2-bit codes
def encode(target):
bell = QuantumCircuit(2, 2, name="bell")
bell.h([0, 1]) # this entangles p1 and p2's qubit (on measurement, they both evaluate to 0 or 1)
if target == '01':
bell.x([0, 1])
elif target == '10':
bell.z(0)
elif target == '11':
bell.z(0)
bell.x([0, 1])
# '00'= identity, keep the initial bell states bell state
return bell
# now, p2 decodes the circuit
def decode(circuit):
# step 1: cnot it
circuit.cx(0, 1)
#step 2: h-gate and measure
circuit.h(0)
circuit.measure([0, 1], [0, 1])
return circuit
backend = Aer.get_backend('statevector_simulator')
# encode bits
circ = encode(bits)
# decode bits
message = decode(circ)
job = execute(message, backend)
result = job.result()
# print out the statevector. There should be a 1 at index n, where n (base 10) is the code
print(np.round(result.get_statevector(), 2))
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
# !sudo apt install lrslib
# !pip install -e git+https://github.com/Pitt-JonesLab/mirror-gates#egg=mirror-gates[core]
# !pip install pylatexenc
from qiskit.transpiler import CouplingMap
coupling_map = CouplingMap.from_line(4)
from transpile_benchy.library import CircuitLibrary
lib = CircuitLibrary(circuit_list=[])
qc = lib.get_circuit("qft_n4")
qc = qc.decompose()
display(qc.draw("mpl"))
from mirror_gates.pass_managers import Mirage
mirage = Mirage(
coupling_map, # coupling map
name="Mirage-$\sqrt{\texttt{iSWAP}}$", # transpile_benchy and figure labels)
parallel=True, # run trials in parallel or serial
cx_basis=False, # turning on sets CNOT as the basis gate,
# (can take arbitrary basis but parameters are not configured that way yet)
cost_function="depth", # switch to "basic" for counting SWAPs
fixed_aggression=None, # force aggression level on all iterations
layout_trials=None, # how many independent layout trials to run (20)
fb_iters=None, # how many forward-backward iterations to run (4)
swap_trials=None, # how many independent routing trials to run (20)
no_vf2=False, # keep False to use VF2 for finding complete layouts
logger=None, # from logging moduel
)
mirage_qc = mirage.run(circuit=qc)
mirage_qc.draw("mpl")
# from qiskit import transpile
# from mirror_gates import sqiswap_equiv
# mirage_qc = transpile(
# qc,
# optimization_level=3,
# coupling_map=coupling_map,
# basis_gates=["u", "xx_plus_yy", "id"],
# routing_method="mirage",
# layout_method="sabre_layout_v2",
# )
# mirage_qc.draw("mpl")
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
from qiskit.transpiler import CouplingMap
t = CouplingMap.from_heavy_hex(5)
t.size()
from transpile_benchy.library import CircuitLibrary
from qiskit import transpile
from mirror_gates.sqiswap_equiv import sel
lib = CircuitLibrary.from_txt("medium_circuits.txt")
for circuit in lib:
# qc = transpile(circuit, basis_gates=["u", "xx_plus_yy"], optimization_level=0)
# print(qc.count_ops()["cx"])
# save the qasm file
circuit.qasm(filename=circuit.name + ".qasm")
# qc.draw("mpl")
# circuit.decompose().decompose().draw("mpl")
from transpile_benchy.library import CircuitLibrary
lib = CircuitLibrary(circuit_list=[])
for interface in lib.interfaces:
print(interface.__class__.__name__)
for circuit in interface.circuits:
print(circuit)
print()
lib = CircuitLibrary.from_txt("medium_circuits.txt")
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
"""CNS Transformations for mirror gates."""
import numpy as np
from qiskit import QuantumCircuit
from qiskit.circuit import Instruction
from qiskit.circuit.library import SwapGate
from qiskit.dagcircuit import DAGCircuit, DAGOpNode
from qiskit.extensions import UnitaryGate
from mirror_gates.fast_unitary import FastConsolidateBlocks, NoCheckUnitary
# Global CNS Transformations
# cx -> iswap
cx_replace = QuantumCircuit(2, 0, name="iswap_prime")
cx_replace.h(1)
cx_replace.rz(-np.pi / 2, 0)
cx_replace.rz(-np.pi / 2, 1)
cx_replace.iswap(0, 1)
# cx_replace.append(SiSwapGate(), [0, 1])
# cx_replace.append(SiSwapGate(), [0, 1])
cx_replace.h(0)
# iswap -> cx
iswap_replace = QuantumCircuit(2, 0, name="cx_prime")
iswap_replace.rz(np.pi / 2, 0)
iswap_replace.rz(np.pi / 2, 1)
iswap_replace.h(1)
iswap_replace.cx(0, 1)
iswap_replace.h(1)
def _get_node_cns(node: DAGOpNode, use_fast_settings: bool = True) -> Instruction:
"""Get the CNS transformation for a given node."""
if len(node.qargs) != 2:
raise ValueError("Only supports 2Q gates")
# NOTE, the UnitaryGate() constructor is a bit expensive
if use_fast_settings:
new_op = SwapGate().to_matrix() @ node.op.to_matrix()
new_unitary = NoCheckUnitary(new_op, label="u+swap")
# TODO: calculate mirror coordinate directly
# from monodromy.coordinates import mirror_monodromy_coordinate
# _monodromy_coord = mirror_monodromy_coordinate(node.op._monodromy_coord)
new_unitary._monodromy_coord = FastConsolidateBlocks.unitary_to_coordinate(
new_unitary
)
else:
new_op = SwapGate().to_matrix() @ node.op.to_matrix()
new_unitary = UnitaryGate(new_op, label="u+swap")
return DAGOpNode(op=new_unitary, qargs=node.qargs)
def cns_transform(dag: DAGCircuit, *h_nodes, preserve_layout=False) -> DAGCircuit:
"""Transform DAG by applying CNS transformations on multiple nodes.
Args:
dag (DAGCircuit): DAG to be transformed (will not be modified)
h_nodes (DAGOpNode): Nodes to be transformed.
preserve_layout (bool): If True, the layout of the original DAG is preserved.
Use this option if testing equivalence of original and transformed circuits.
"""
new_dag = dag.copy_empty_like()
if preserve_layout: # convert so can be modified
h_nodes = list(h_nodes)
# Initialize layout for each node
layout = {qarg: qarg for node in dag.topological_op_nodes() for qarg in node.qargs}
for node in dag.topological_op_nodes():
qargs = [layout.get(qarg, qarg) for qarg in node.qargs]
# check if node is in list of nodes to be transformed
# FIXME, this is true multiple times,
# semantic_eq checks if is a CX but not if the exact same CX
if any(node == h_node for h_node in h_nodes):
# if any(DAGNode.semantic_eq(node, h_node) for h_node in h_nodes):
try: # checks if has a defined CNS transformation
node_prime = _get_node_cns(node)
new_dag.apply_operation_back(node_prime.op, qargs)
# swap values in layout
layout[node.qargs[0]], layout[node.qargs[1]] = qargs[1], qargs[0]
except ValueError:
new_dag.apply_operation_back(node.op, qargs)
h_nodes.remove(node)
else:
new_dag.apply_operation_back(node.op, qargs)
if preserve_layout:
for h_node in reversed(h_nodes):
new_dag.apply_operation_back(SwapGate(), h_node.qargs)
return new_dag
# legacy code, only works for a single node
# def cns_transform(dag: DAGCircuit, h_node, preserve_layout=False):
# """Alternative implementation, adds nodes into blank copy of dag."""
# new_dag = dag.copy_empty_like()
# flip_flag = False
# swap_wires = {
# qarg1: qarg2 for qarg1, qarg2 in zip(h_node.qargs, h_node.qargs[::-1])
# }
# for node in dag.topological_op_nodes():
# # if node == h_node:
# if DAGNode.semantic_eq(node, h_node):
# # here we add the cns transformation, and use the flip flag
# # flip_flag tells us from this gate onwards, qargs will reverse
# # effectively, we are adding the virtual swap here
# new_dag.apply_operation_back(_get_node_cns(node).op, node.qargs)
# flip_flag = True
# else:
# if flip_flag:
# new_dag.apply_operation_back(
# node.op, [swap_wires.get(qarg, qarg) for qarg in node.qargs]
# )
# else:
# new_dag.apply_operation_back(node.op, node.qargs)
# # fix with a swap
# # if preserve_layout:
# # new_dag.apply_operation_back(SwapGate(), h_node.qargs)
# return new_dag
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
"""Noisy fidelity of a circuit."""
import numpy as np
from qiskit import transpile
from qiskit.circuit import Delay
from qiskit.converters import circuit_to_dag
from qiskit.quantum_info import state_fidelity
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import ASAPSchedule, Optimize1qGatesDecomposition
from qiskit_aer import AerSimulator, QasmSimulator
# Import from Qiskit Aer noise module
from qiskit_aer.noise import (
NoiseModel,
RelaxationNoisePass,
depolarizing_error,
thermal_relaxation_error,
)
from mirror_gates.logging import transpile_benchy_logger
from mirror_gates.sqiswap_decomposer import SiSwapDecomposePass
# 80 microsec (in nanoseconds)
T1 = 80e3
# 80 microsec
T2 = 80e3
# Instruction times (in nanoseconds)
time_u3 = 25
time_cx = 100
time_siswap = int(time_cx / 2.0)
# divide by 2 again since
# each sqrt(iSwap) is compiled to an RXX and RYY
time_rxx = int(time_siswap / 2.0)
p1 = 0.0
p2 = 0.00658
class NoiseModelBuilder:
"""A class to help build a custom NoiseModel from scratch.
Many of the functions are based on examples from
https://github.com/Qiskit/qiskit-presentations/blob/master/2019-02-26_QiskitCamp/QiskitCamp_Simulation.ipynb
"""
def __init__(self, basis_gates, coupling_map=None):
"""Initialize a NoiseModelBuilder."""
self.noise_model = NoiseModel(basis_gates=basis_gates)
self.coupling_map = coupling_map
def construct_basic_device_model(self, p_depol1, p_depol2, t1, t2):
"""Emulate qiskit.providers.aer.noise.device.models.basic_device_noise_model().
The noise model includes the following errors:
* Single qubit readout errors on measurements.
* Single-qubit gate errors consisting of a depolarizing error
followed by a thermal relaxation error for the qubit the gate
acts on.
* Two-qubit gate errors consisting of a 2-qubit depolarizing
error followed by single qubit thermal relaxation errors for
all qubits participating in the gate.
:param p_depol1: Probability of a depolarising error on single qubit gates
:param p_depol2: Probability of a depolarising error on two qubit gates
:param t1: Thermal relaxation time constant
:param t2: Dephasing time constant
"""
if t2 > 2 * t1:
raise ValueError("t2 cannot be greater than 2t1")
# Thermal relaxation error
# QuantumError objects
error_thermal_u3 = thermal_relaxation_error(t1, t2, time_u3)
error_thermal_cx = thermal_relaxation_error(t1, t2, time_cx).expand(
thermal_relaxation_error(t1, t2, time_cx)
)
error_thermal_rxx = thermal_relaxation_error(t1, t2, time_rxx).expand(
thermal_relaxation_error(t1, t2, time_rxx)
)
# Depolarizing error
error_depol1 = depolarizing_error(p_depol1, 1)
error_depol2 = depolarizing_error(p_depol2, 2)
self.noise_model.add_all_qubit_quantum_error(
error_depol1.compose(error_thermal_u3), "u"
)
for pair in self.coupling_map:
self.noise_model.add_quantum_error(
error_depol2.compose(error_thermal_cx), "cx", pair
)
self.noise_model.add_quantum_error(
error_depol2.compose(error_thermal_rxx), ["rxx", "ryy"], pair
)
def heuristic_fidelity(N, duration, T1=None, T2=None):
"""Get heuristic fidelity of a circuit."""
if T1 is None:
T1 = 80e3
if T2 is None:
T2 = 80e3
decay_factor = (1 / T1 + 1 / T2) * duration
single_qubit_fidelity = np.exp(-decay_factor)
total_fidelity = single_qubit_fidelity**N
return total_fidelity
def get_noisy_fidelity(qc, coupling_map, sqrt_iswap_basis=False):
"""Get noisy fidelity of a circuit.
NOTE: if qc is too big, will use heuristic fidelity function.
Args:
qc (QuantumCircuit): circuit to run, assumes all gates are consolidated
coupling_map (CouplingMap): coupling map of device
Returns:
fidelity (float): noisy fidelity of circuit
duration (int): duration of circuit
circ (QuantumCircuit): transpiled circuit
expected_fidelity (float): expected fidelity of circuit
"""
N = coupling_map.size()
num_active = len(list(circuit_to_dag(qc).idle_wires())) - qc.num_clbits
basis_gates = ["cx", "u", "rxx", "ryy", "id"]
# Step 0. Create Noise Model
# 0A. Set up Instruction Durations
# (inst, qubits, time)
instruction_durations = []
for j in range(N):
instruction_durations.append(("u", j, time_u3))
for j, k in coupling_map:
instruction_durations.append(("cx", (j, k), time_cx))
instruction_durations.append(("rxx", (j, k), time_rxx))
instruction_durations.append(("ryy", (j, k), time_rxx))
instruction_durations.append(("save_density_matrix", list(range(N)), 0.0))
# 0B. If circuit is too big, use heuristic fidelity function
# Use heuristic fidelity function
circ = transpile(
qc,
basis_gates=basis_gates,
instruction_durations=instruction_durations,
scheduling_method="asap",
coupling_map=coupling_map,
)
duration = circ.duration
expected_fidelity = heuristic_fidelity(num_active, duration)
if N > 10:
return 0, duration, circ, expected_fidelity
else:
transpile_benchy_logger.debug(f"Expected fidelity: {expected_fidelity:.4g}")
# 0C. Build noise model
builder = NoiseModelBuilder(basis_gates, coupling_map)
builder.construct_basic_device_model(p_depol1=p1, p_depol2=p2, t1=T1, t2=T2)
noise_model = builder.noise_model
# 0D. Create noisy simulator
noisy_simulator = AerSimulator(noise_model=noise_model)
# Step 1. Given consolidated circuit, decompose into basis gates
if sqrt_iswap_basis:
decomposer = PassManager()
decomposer.append(SiSwapDecomposePass())
decomposer.append(Optimize1qGatesDecomposition())
qc = decomposer.run(qc)
# Step 2. Convert into simulator basis gates
# simulator = Aer.get_backend("density_matrix_gpu")
simulator = QasmSimulator(method="density_matrix")
circ = transpile(
qc,
simulator,
basis_gates=basis_gates,
coupling_map=coupling_map,
)
# Step 3. transpile with scheduling and durations
circ = transpile(
qc,
noisy_simulator,
basis_gates=basis_gates + ["save_density_matrix"],
instruction_durations=instruction_durations,
scheduling_method="asap",
coupling_map=coupling_map,
)
# Step 4. Relaxation noise for idle qubits
pm = PassManager()
pm.append(ASAPSchedule())
pm.append(
RelaxationNoisePass(
t1s=[T1] * N,
t2s=[T2] * N,
dt=1e-9,
op_types=[Delay],
)
)
circ = pm.run(circ)
duration = circ.duration
# Step 5. Run perfect and noisy simulation and compare
circ.save_density_matrix(list(range(N)))
perfect_result = simulator.run(circ).result().data()["density_matrix"]
noisy_result = noisy_simulator.run(circ).result().data()["density_matrix"]
fidelity = state_fidelity(perfect_result, noisy_result)
return fidelity, duration, circ, expected_fidelity
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
"""Add custom gates to the session EquivalenceLibrary instance.
NOTE: sel is global, so just import this file before calling transpile.
"""
import numpy as np
from qiskit import QuantumCircuit
from qiskit.circuit.equivalence_library import SessionEquivalenceLibrary as sel
from qiskit.circuit.library.standard_gates import CXGate, SwapGate, XXPlusYYGate
# https://arxiv.org/pdf/2110.11537.pdf
cx_decomp = QuantumCircuit(2)
cx_decomp.u(np.pi / 2, -np.pi / 2, 0, 0)
cx_decomp.u(np.pi / 2, np.pi, -np.pi / 2, 1)
cx_decomp.append(XXPlusYYGate(-np.pi / 2), [0, 1])
cx_decomp.u(np.pi, -np.pi / 2, np.pi / 2, 0)
cx_decomp.u(0, 0, np.pi, 1)
cx_decomp.append(XXPlusYYGate(-np.pi / 2), [0, 1])
cx_decomp.u(np.pi / 2, -np.pi / 2, -3 * np.pi / 2, 0)
cx_decomp.u(0, -np.pi / 2, -np.pi, 1)
sel.add_equivalence(CXGate(), cx_decomp)
swap_decomp = QuantumCircuit(2)
swap_decomp.append(XXPlusYYGate(-np.pi / 2, 0), [0, 1])
swap_decomp.rx(-np.pi / 2, 0)
swap_decomp.rx(-np.pi / 2, 1)
swap_decomp.append(XXPlusYYGate(-np.pi / 2), [0, 1])
swap_decomp.rx(np.pi / 2, 0)
swap_decomp.rx(np.pi / 2, 1)
swap_decomp.ry(-np.pi / 2, 0)
swap_decomp.ry(-np.pi / 2, 1)
swap_decomp.append(XXPlusYYGate(-np.pi / 2), [0, 1])
swap_decomp.ry(np.pi / 2, 0)
swap_decomp.ry(np.pi / 2, 1)
sel.add_equivalence(SwapGate(), swap_decomp)
# bb = transpile(
# circ, basis_gates=["u", "xx_plus_yy"], coupling_map=topo, optimization_level=3
# )
# bb.draw(output="mpl")
#######################
# NOTE this is a hack :) #
# https://github.com/Qiskit/qiskit-terra/issues/9485
# add I = U(0, 0, 0) to the equivalence library
# from qiskit.circuit.equivalence_library import SessionEquivalenceLibrary as sel
# from qiskit import QuantumCircuit
# from qiskit.circuit.library import IGate
# qc = QuantumCircuit(1)
# qc.u(0, 0, 0, 0)
# sel.add_equivalence(IGate(), qc)
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
"""Define the Sycamore gate and its decompositions."""
from qiskit import QuantumCircuit
from qiskit.circuit.library import CZGate, iSwapGate
from qiskit.quantum_info import Operator
qc = QuantumCircuit(2)
qc.append(iSwapGate().power(-1), [0, 1])
qc.append(CZGate().power(1 / 6), [0, 1])
syc = Operator(qc)
syc.name = "syc"
syc.params = []
# # Get the directory of the current file
# current_directory = Path(__file__).parent
# # Compute the absolute paths to the .qasm files
# cx_decomp_path = current_directory / "../circuits/d02_syc_cnot.qasm"
# swap_decomp_path = current_directory / "../circuits/d02_syc_swap.qasm"
# cx_decomp = QuantumCircuit.from_qasm_file(cx_decomp_path)
# cx_decomp = cx_decomp.decompose()
# sel.add_equivalence(CXGate(), cx_decomp)
# swap_decomp = QuantumCircuit.from_qasm_file(swap_decomp_path)
# sel.add_equivalence(SwapGate(), swap_decomp)
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
from qiskit import transpile
from qiskit.circuit.library import CZGate, iSwapGate
from qiskit.quantum_info import Operator
from qiskit import QuantumCircuit
import numpy as np
qc = QuantumCircuit(2)
qc.cz(0, 1)
qc.swap(0, 1)
qc2 = QuantumCircuit(2)
qc2.rz(-np.pi / 2, 0)
qc2.rz(-np.pi / 2, 1)
qc2.iswap(0, 1)
Operator(qc).equiv(qc2)
qc2.draw("mpl")
from qiskit.circuit.library import QuantumVolume, EfficientSU2, TwoLocal, QFT
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import iSwapGate, CXGate
from qiskit import QuantumCircuit
from qiskit.providers.fake_provider import FakeQuitoV2
from qiskit.transpiler.coupling import CouplingMap
from qiskit.extensions import UnitaryGate
from weylchamber import canonical_gate
from mirror_gates.pass_managers import Mirage, QiskitLevel3
from transpile_benchy.metrics.gate_counts import (
DepthMetric,
TotalMetric,
TotalSwaps,
)
from transpile_benchy.metrics.timer import TimeMetric
from mirror_gates.fast_unitary import FastConsolidateBlocks
from qiskit.transpiler.passes import (
Collect2qBlocks,
Unroll3qOrMore,
ConsolidateBlocks,
)
from qiskit.transpiler import PassManager
import numpy as np
from mirror_gates.logging import transpile_benchy_logger
N = 8
# coupling_map = FakeQuitoV2().target.build_coupling_map()
# coupling_map = CouplingMap.from_grid(4,4)
coupling_map = CouplingMap.from_line(N)
# coupling_map = CouplingMap.from_heavy_hex(5)
# coupling_map.draw()
from transpile_benchy.interfaces.mqt_interface import MQTBench
from transpile_benchy.interfaces.qasm_interface import QASMBench
from transpile_benchy.library import CircuitLibrary
lib = CircuitLibrary(circuit_list=[])
qc = lib.get_circuit("qft_n4")
qc = qc.decompose()
display(qc.draw("mpl"))
# qc.remove_final_measurements()
# qc.save_density_matrix()
# qc.draw("mpl")
# # Create an empty noise model
# from qiskit_aer.noise import (
# NoiseModel,
# QuantumError,
# ReadoutError,
# pauli_error,
# depolarizing_error,
# thermal_relaxation_error,
# )
# # Error probabilities
# prob_1 = 0.001 # 1-qubit gate
# prob_2 = 0.01 # 2-qubit gate
# # Depolarizing quantum errors
# error_1 = depolarizing_error(prob_1, 1)
# error_2 = depolarizing_error(prob_2, 2)
# # Add errors to noise model
# noise_model = NoiseModel()
# noise_model.add_all_qubit_quantum_error(error_1, ["u1", "u2", "u3"])
# noise_model.add_all_qubit_quantum_error(error_2, ["cx"])
# print(noise_model)
runner = Mirage(
coupling_map,
cx_basis=0,
parallel=0,
logger=transpile_benchy_logger,
cost_function="depth",
# cost_function="basic",
anneal_routing=True,
layout_trials=20,
fb_iters=4,
# layout_trials=20,
# fb_iters=4,
# fixed_aggression=0
# cost_function="basic",
use_fast_settings=1,
)
runner.seed = 0
metric = DepthMetric(consolidate=False)
runner._append_metric_pass(metric)
metric = TotalMetric(consolidate=False)
runner._append_metric_pass(metric)
metric = TotalSwaps(consolidate=False)
runner._append_metric_pass(metric)
# metric = TimeMetric()
# runner._append_metric_pass(metric)
transp = runner.run(qc)
# print(runner.property_set["accepted_subs"])
print(runner.property_set["monodromy_depth"])
print(runner.property_set["monodromy_total"])
print(runner.property_set["total_swaps"])
display(runner.property_set["mid"].draw("mpl", fold=-1))
# display(runner.property_set["post0"].draw("mpl"))
# display(transp.draw(output="mpl", fold=-1))
transpile(transp, basis_gates=["cx", "u"]).draw("mpl")
from qiskit import transpile
mirage_qc = transpile(
qc,
optimization_level=3,
coupling_map=coupling_map,
# basis_gates=["u", "xx_plus_yy", "id"],
basis_gates=["u", "cx"],
routing_method="mirage",
layout_method="sabre_layout_v2",
)
mirage_qc.draw(output="mpl")
runner = QiskitLevel3(coupling_map, cx_basis=0)
metric = DepthMetric(consolidate=False)
runner._append_metric_pass(metric)
metric = TotalSwaps(consolidate=False)
runner._append_metric_pass(metric)
transp = runner.run(qc)
print(runner.property_set["monodromy_depth"])
print(runner.property_set["total_swaps"])
# print(runner.property_set["monodromy_total"])
display(transp.draw(output="mpl", fold=-1))
# display(runner.property_set["post0"].draw("mpl"))
# from qiskit import Aer, transpile
# from qiskit.quantum_info import state_fidelity
# from qiskit_aer import AerSimulator
# simulator = Aer.get_backend("aer_simulator")
# circ = transpile(qc, simulator)
# result = simulator.run(circ).result()
# perfect_density_matrix = result.data()["density_matrix"]
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
from qiskit import QuantumCircuit, QuantumRegister
import numpy as np
# load a dummy circuit
# generate network of random cnots
n, M = 2, 4
N = n**2
register = QuantumRegister(N)
qc = QuantumCircuit(register)
for _ in range(M):
qc.cx(*np.random.choice(N, 2, replace=False))
qc.name = "random cx circuit"
qc.decompose().draw("mpl")
from qiskit.transpiler.coupling import CouplingMap
qc = QuantumCircuit(3)
qc.ccx(0, 1, 2)
coupling = CouplingMap.from_line(3)
qc.decompose().draw("mpl")
from virtual_swap.pass_managers import BruteCNS
brute = BruteCNS(coupling)
transp = brute.run(qc)
transp.draw("mpl")
from qiskit.transpiler.passes import OptimizeSwapBeforeMeasure, Unroller
from qiskit.converters import dag_to_circuit
from qiskit.transpiler import PassManager
clean = PassManager()
clean.append(OptimizeSwapBeforeMeasure())
clean.append(Unroller(["u", "cx", "iswap", "swap"]))
property_set = brute.pm.property_set # Reference for brevity
dags, costs, perms = (
property_set["all_dags"],
property_set["all_costs"],
property_set["all_perms"],
)
for dag, cost, perm in zip(dags, costs, perms):
print(cost)
perm_str = ", ".join(
[f"{node.name}[{node.qargs[0].index},{node.qargs[1].index}]" for node in perm]
)
print("Permutation:", perm_str)
circuit = dag_to_circuit(dag)
print(clean.run(circuit).draw(fold=-1))
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
from qiskit import QuantumCircuit
qc1 = QuantumCircuit(3)
qc1.cx(1, 0)
qc1.cx(0, 1)
qc1.cz(1, 2)
qc1.cx(0, 1)
qc1.cx(1, 0)
qc1.draw("mpl")
iswap_sub = QuantumCircuit(2)
iswap_sub.h(0)
iswap_sub.sdg(0)
iswap_sub.sdg(1)
iswap_sub.iswap(0, 1)
iswap_sub.h(1)
iswap_sub.draw("mpl")
qc1 = QuantumCircuit(3)
qc1.cx(1, 0)
qc1.cx(0, 1)
qc1.cz(1, 2)
qc1.h(0)
qc1.sdg(0)
qc1.sdg(1)
qc1.iswap(0, 1)
qc1.h(1)
qc1.draw("mpl")
reverse_cx = QuantumCircuit(2)
reverse_cx.h(1)
reverse_cx.h(1)
reverse_cx.iswap(0, 1)
reverse_cx.s(0)
reverse_cx.s(1)
reverse_cx.h(0)
reverse_cx.h(0)
reverse_cx.sdg(0)
reverse_cx.sdg(1)
reverse_cx.draw("mpl")
qc0 = QuantumCircuit(2)
qc0.cx(1, 0)
qc0.cx(0, 1)
qc0.draw("mpl")
qc2 = QuantumCircuit(3)
# qc2.cx(1,0)
qc2.cx(0, 1)
qc2.cz(1, 2)
qc2.cx(0, 1)
# qc2.cx(1,0)
qc2.draw("mpl")
from qiskit.quantum_info import Operator
Operator(qc1).equiv(Operator(qc2))
qc3 = QuantumCircuit(2)
qc3.cx(0, 1)
qc3.cx(1, 0)
qc4 = QuantumCircuit(2)
qc4.cx(1, 0)
qc4.cx(0, 1)
Operator(qc3).equiv(Operator(qc4))
qc5 = QuantumCircuit(5)
qc5.iswap(0, 1)
print(Operator(qc3).equiv(Operator(qc5)))
print(Operator(qc4).equiv(Operator(qc5)))
from weylchamber import c1c2c3
print(c1c2c3(Operator(qc3).data))
print(c1c2c3(Operator(qc4).data))
# use for making some figures of QFT circuit dag for the paper
from qiskit.circuit.library import QFT, TwoLocal
qc = QFT(4).decompose()
# qc = TwoLocal(4, ['ry'], 'cx', reps=1, entanglement='full', insert_barriers=False)
qc.decompose().draw(output="mpl") # , filename="twolocal_base.svg")
from qiskit import QuantumCircuit
qc = QuantumCircuit(3)
qc.cx(0, 1)
qc.cx(1, 2)
qc.barrier()
qc.cx(0, 1)
qc.cx(2, 1)
qc.swap(0, 1)
qc.draw("mpl")
# line coupling_map
from qiskit.transpiler import CouplingMap
line = CouplingMap.from_line(3)
grid = CouplingMap.from_grid(2, 2)
topo = line
from qiskit import transpile
transp1 = transpile(
qc, coupling_map=topo, optimization_level=3 # , initial_layout=[0, 1, 2, 3]
)
transp1.draw(output="mpl") # , filename="twolocal_qiskit.svg")
from qiskit.converters import circuit_to_dag
dag = circuit_to_dag(transp1)
# dag only keep 2Q nodes
for node in dag.topological_op_nodes():
if node.op.num_qubits < 2:
dag.remove_op_node(node)
dag.draw()
from virtual_swap.pass_managers import SabreMS, SabreQiskit
from qiskit.circuit.library import iSwapGate
from virtual_swap.pass_managers import SabreMS, SabreQiskit
from transpile_benchy.metrics import DepthMetric
for _ in range(1):
runner = SabreMS(topo) # , cx_basis=True)
transp = runner.run(qc)
# mid0 = runner.pm.property_set["mid0"]
mid = runner.pm.property_set["circuit_progress"]
print(runner.pm.property_set["monodromy_depth"])
# if DepthMetric.calculate(transp) <= 22:
# break
mid.draw(output="mpl", fold=-1) # , filename="twolocal_cns.svg")
transp.decompose().draw(output="mpl")
# set original qc to use
from qiskit import transpile
# qc2 = transpile(qc, initial_layout=runner.pm.property_set["layout"], coupling_map=coupling_map)
# qc2 = transpile(qc, coupling_map=coupling_map, optimization_level=3)
for _ in range(5):
pm2 = SabreQiskit(topo) # , cx_basis=True)
qc2 = pm2.run(qc)
mid = pm2.pm.property_set["circuit_progress"]
print(DepthMetric.calculate(qc2))
mid.draw(output="mpl", fold=-1)
from qiskit.converters import circuit_to_dag
# remove 1Q nodes
dag = circuit_to_dag(mid_qc)
for node in dag.topological_op_nodes():
if node.op.num_qubits < 2:
dag.remove_op_node(node)
dag.draw()
pm.pm.property_set["layout"]
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
from virtual_swap.deprecated.cns_sa import VSwapPass
from qiskit import QuantumCircuit
from qiskit.quantum_info import Operator
qc = QuantumCircuit(3)
qc.cx(0, 1)
qc.h(1)
qc.iswap(1, 2)
qc.y(2)
original_op = Operator(qc)
qc.draw("mpl")
from qiskit.converters import circuit_to_dag
dag = circuit_to_dag(qc)
dag.draw()
# manually select the first cx node
from qiskit.circuit.library.standard_gates import CXGate, iSwapGate
h_node = dag.op_nodes(iSwapGate)[0]
import numpy as np
# cx -> iswap
cx_replace = QuantumCircuit(2, 0)
cx_replace.h(1)
cx_replace.rz(-np.pi / 2, 0)
cx_replace.rz(-np.pi / 2, 1)
cx_replace.iswap(0, 1)
cx_replace.h(0)
cx_replace.draw("mpl")
# iswap -> cx
iswap_replace = QuantumCircuit(2, 0)
iswap_replace.rz(np.pi / 2, 0)
iswap_replace.rz(np.pi / 2, 1)
iswap_replace.h(1)
iswap_replace.cx(0, 1)
iswap_replace.h(1)
from qiskit.dagcircuit import DAGOpNode, DAGInNode, DAGOutNode, DAGCircuit
from qiskit.circuit.library import iSwapGate, SwapGate
def cns_transform(dag: DAGCircuit, h_node):
"""Alternative implementation, adds nodes into blank copy of dag"""
new_dag = dag.copy_empty_like()
flip_flag = False
swap_wires = {
qarg1: qarg2 for qarg1, qarg2 in zip(h_node.qargs, h_node.qargs[::-1])
}
for node in dag.topological_op_nodes():
if node == h_node:
if node.name == "cx":
new_dag.apply_operation_back(cx_replace.to_instruction(), node.qargs)
elif node.name == "iswap":
new_dag.apply_operation_back(iswap_replace.to_instruction(), node.qargs)
else:
raise ValueError("Unsupported operation")
flip_flag = True
else:
if flip_flag:
new_dag.apply_operation_back(
node.op, [swap_wires.get(qarg, qarg) for qarg in node.qargs]
)
else:
new_dag.apply_operation_back(node.op, node.qargs)
# fix with a swap
new_dag.apply_operation_back(SwapGate(), h_node.qargs)
return new_dag
def cns_transform_old(dag, h_node):
swap_wires = {
qarg1: qarg2 for qarg1, qarg2 in zip(h_node.qargs, h_node.qargs[::-1])
}
# NOTE, include the node itself, because we want to reference set of all outgoing edges
node_list = list(dag.descendants(h_node))
node_list.insert(0, h_node)
for source in node_list:
# first, update edge arguments
for target in dag.successors(source):
edge = dag._multi_graph.get_edge_data(source._node_id, target._node_id)
dag._multi_graph.update_edge(
source._node_id, target._node_id, swap_wires.get(edge, edge)
)
# second, update the node's qargs
if source == h_node:
# here replace the operation...
if source.name == "cx":
dag.substitute_node(source, cx_replace.to_instruction())
elif source.name == "iswap":
dag.substitute_node(source, iswap_replace.to_instruction())
else:
raise ValueError("Unsupported operation")
# third, update output nodes
elif isinstance(source, DAGOpNode):
source.qargs = [swap_wires.get(qarg, qarg) for qarg in source.qargs]
elif isinstance(source, DAGOutNode):
source.wire = swap_wires.get(source.wire, source.wire)
# add a swap a swap at end of circuit
# NOTE, preserves unitary for equivalence checks
# final SWAP gates can be removed by the optimizer
dag.apply_operation_back(SwapGate(), h_node.qargs)
dag = cns_transform(dag, h_node)
# cns_transform_old(dag, h_node)
dag.draw()
from qiskit.converters import dag_to_circuit
qc = dag_to_circuit(dag)
# transpile into iswap, cx, u basis
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import Unroller
pm = PassManager([Unroller(["swap", "iswap", "cx", "u"])])
qc = pm.run(qc)
qc.draw("mpl")
# verify circuits are equivalent
from qiskit.quantum_info import Operator
original_op.equiv(Operator(qc))
# get first cx node from qc
dag = circuit_to_dag(qc)
cx_node = dag.op_nodes(CXGate)
from virtual_swap.cns_transform import cns_transform
new_dag = cns_transform(dag, *cx_node, preserve_layout=True)
new_qc = dag_to_circuit(new_dag)
new_qc.draw("mpl")
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
from qiskit.circuit.library import QuantumVolume, EfficientSU2, TwoLocal, QFT
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import iSwapGate, CXGate
from qiskit import QuantumCircuit
from qiskit.providers.fake_provider import FakeQuitoV2
from qiskit.transpiler.coupling import CouplingMap
from qiskit.extensions import UnitaryGate
from weylchamber import canonical_gate
from mirror_gates.pass_managers import Mirage, QiskitLevel3
from transpile_benchy.metrics.gate_counts import (
DepthMetric,
TotalMetric,
TotalSwaps,
)
from transpile_benchy.metrics.timer import TimeMetric
from mirror_gates.fast_unitary import FastConsolidateBlocks
from qiskit.transpiler.passes import (
Collect2qBlocks,
Unroll3qOrMore,
ConsolidateBlocks,
)
from qiskit.transpiler import PassManager
import numpy as np
from mirror_gates.logging import transpile_benchy_logger
from transpile_benchy.interfaces.mqt_interface import MQTBench
from transpile_benchy.interfaces.qasm_interface import QASMBench
from transpile_benchy.library import CircuitLibrary
lib = CircuitLibrary.from_txt("../circuits/medium_circuits.txt")
qc = lib.get_circuit("seca_n11")
# lib = CircuitLibrary(circuit_list=["qft_n4"])
# qc = lib.get_circuit("qft_n4")
qc = qc.decompose()
qc = qc.decompose()
qc = qc.decompose()
qc.remove_final_measurements()
display(qc.draw("mpl", fold=-1))
# from qiskit.quantum_info import Operator
# from qiskit import QuantumCircuit
# import numpy as np
# from qutip import Qobj
# circ = QuantumCircuit(2)
# circ.cx(1, 0)
# circ.u(0, 0, -np.pi / 4, 0)
# circ.cx(1, 0)
# from weylchamber import c1c2c3
# print(c1c2c3(Operator(circ).data))
# Qobj(Operator(circ).data)
from mirror_gates.fast_unitary import FastConsolidateBlocks
from qiskit.transpiler.passes import (
ConsolidateBlocks,
Collect2qBlocks,
RemoveBarriers,
RemoveFinalMeasurements,
)
from mirror_gates.utilities import RemoveAllMeasurements
from qiskit.transpiler import PassManager
from qiskit.quantum_info import Operator
from weylchamber import c1c2c3
for circuit_name in lib.circuit_list:
if circuit_name == "portfolioqaoa_n16":
continue
# if circuit_name != "qpeexact_16":
# continue
print("\n")
qc = lib.get_circuit(circuit_name)
qc = qc.decompose().decompose().decompose()
qc.remove_final_measurements()
list1 = []
pm0 = PassManager()
pm0.append(RemoveBarriers())
pm0.append(RemoveAllMeasurements())
pm0.append(Collect2qBlocks())
pm0.append(ConsolidateBlocks(force_consolidate=True))
qc0 = pm0.run(qc)
for gate in qc0:
if gate.operation.name not in ["barrier"]:
# print(gate.operation)\
corrd = c1c2c3(gate.operation.to_matrix())
list1.append(corrd)
# print(corrd)
print("\n")
list2 = []
pm1 = PassManager()
pm1.append(RemoveBarriers())
pm1.append(RemoveAllMeasurements())
pm1.append(FastConsolidateBlocks())
qc1 = pm1.run(qc)
for gate in qc1:
if gate.operation.name not in ["barrier"]:
# print(gate.operation)
corrd = c1c2c3(gate.operation.to_matrix())
list2.append(corrd)
# print(corrd)
# compare the two lists
print(circuit_name)
for x, y in zip(list1, list2):
print(x, y)
print("list1 == list2: ", list1 == list2)
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.transpiler import CouplingMap
from qiskit.converters import dag_to_circuit
from qiskit.transpiler.layout import Layout
import numpy as np
from qiskit.transpiler.passes import Unroller
from qiskit.transpiler.passes import (
TrivialLayout,
BasicSwap,
ApplyLayout,
SetLayout,
SabreLayout,
FullAncillaAllocation,
EnlargeWithAncilla,
)
from qiskit.transpiler.passmanager import PassManager
from virtual_swap.deprecated.cns_sabre import CNS_SabreSwap
# load a dummy circuit
# generate network of random cnots
n, M = 3, 8
N = n**2
register = QuantumRegister(N)
qc = QuantumCircuit(register)
for _ in range(M):
qc.cx(*np.random.choice(N, 2, replace=False))
qc.decompose().draw("mpl")
# load a dummy coupling map and layout
coupling = CouplingMap.from_line(N)
layout = Layout({q: i for q, i in zip(register, range(N))})
# print DAG
from qiskit.converters import circuit_to_dag
dag = circuit_to_dag(qc)
dag.draw("mpl")
set_pass = SetLayout(layout)
dag_p = set_pass.run(dag)
apply_pass = ApplyLayout()
apply_pass.property_set = set_pass.property_set
dag_p = apply_pass.run(dag_p)
dag_p.draw("mpl")
# get layers of the DAG
"""A layer is a circuit whose gates act on disjoint qubits, i.e., a layer has depth 1. The total number of layers equals the circuit depth d. The layers are indexed from 0 to d-1 with the earliest layer at index 0. The layers are constructed using a greedy algorithm. Each returned layer is a dict containing {“graph”: circuit graph, “partition”: list of qubit lists}.
The returned layer contains new (but semantically equivalent) DAGOpNodes, DAGInNodes, and DAGOutNodes. These are not the same as nodes of the original dag, but are equivalent via DAGNode.semantic_eq(node1, node2)."""
# convert generator to list
layers = list(dag_p.layers())
for layer in layers:
print(layer)
# # get serial layers
# """A serial layer is a circuit with one gate. The layers have the same structure as in layers()."""
# serial_layers = dag.serial_layers()
# for layer in serial_layers:
# print(layer)
# # get multigraph layers
# multi_layers = dag.multigraph_layers()
# for layer in multi_layers:
# print(layer)
# want to get topological distance from output F and inputs to F'
cns_sub = False
F = layers[0]["graph"]
F_prime = layers[1]["graph"]
F.draw()
# F.output_map
from virtual_swap.cns_transform import cns_transform
from qiskit.circuit.library.standard_gates import CXGate
# get cx from F
cns_sub = True
cns_cx = F.op_nodes(CXGate)[0]
F_cns = cns_transform(F, cns_cx)
F_cns.draw()
# def evaluate_layer(F, F_prime):
# # cost from F:output -> F':input
# work on getting output permutations from a single layer
# this includes virtual swaps + slack swaps that don't affect the depth
v_to_p = layout.get_virtual_bits()
# FIXME, SABRE does meet in middle to increase parallelism
# we need to implement our own here,
# tests both CNS subs and slack swaps
swapper = BasicSwap(coupling)
if cns_sub:
F_swapped = swapper.run(F_cns)
else:
F_swapped = swapper.run(F)
F_swapped.draw()
# swapper.property_set
# XXX this needs to be manually set following a swap pass
f_layout = swapper.property_set["final_layout"]
if cns_sub:
temp = f_layout[cns_cx.qargs[0]]
f_layout[cns_cx.qargs[0]] = f_layout[cns_cx.qargs[1]]
f_layout[cns_cx.qargs[1]] = temp
print(f_layout)
f_v_to_p = f_layout.get_virtual_bits()
print(f_v_to_p)
# for x in F_swapped.output_map.items():
# print(x)
F_prime.draw()
trial_cost = 0
for x in F_prime.two_qubit_ops():
print(f_v_to_p[x.qargs[0]], f_v_to_p[x.qargs[1]])
print(coupling.distance(f_v_to_p[x.qargs[0]], f_v_to_p[x.qargs[1]]))
trial_cost += coupling.distance(f_v_to_p[x.qargs[0]], f_v_to_p[x.qargs[1]])
# FIXME do we want to return sum or max?
print(f"Trial cost", trial_cost)
# we need to define a cost function, intermediate layer to front layer
# the intermediate layer are gates that are physical on the topology
# the intermediate layer considers CNS subs and placement of SWAP gates
# once a permutation of the intermediate layer is found that minimizes cost to the front layer
# move the intermediate layer to the mapped dag, and front layer to intermediate layer
# once the front layer is empty, we are done
# open question, do we resolve all dependencies between intermediate and front layer at once?
# maybe we find a route for one gate, then pop the next gate in
# if we have a dynamic layer, makes reasoning about cost and when to move gates harder
# but that is how SABRE works, just by iteratively checking what is physical
# repeat pushing things over until we can't push anymore
# idk, I think conceptually treating it as a set of layers that need to be resolved is easier
# we define the minimum about of gates that add to the depth of the circuit for data movement
# types of SWAP paths we could take
# if 2 qubits can meet, they can SWAP together to meet at midpoint between them
# however, we might prefer to meet biased towards one qubit (for sake of lookahead)
# then, we incur a higher depth cost on this layer, but hopefully reduces lookahead cost
# so define a depth cost on the layer,
# maybe we just do the thing that tells us which decomp to use first
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.transpiler import CouplingMap
from qiskit.converters import dag_to_circuit
from qiskit.transpiler.layout import Layout
import numpy as np
from qiskit.transpiler.passes import Unroller
from qiskit.quantum_info import Operator
from qiskit.transpiler.passes import (
TrivialLayout,
BasicSwap,
ApplyLayout,
SetLayout,
SabreLayout,
FullAncillaAllocation,
EnlargeWithAncilla,
)
from qiskit.transpiler.passmanager import PassManager
# from virtual_swap.cns_sabre import CNS_SabreSwap
# from virtual_swap.cns_sabre_v2 import CNS_SabreSwap_V2 as CNS_SabreSwap
from virtual_swap.cns_sabre_v3 import SabreMS as CNS_SabreSwap
# # load a dummy circuit
# # generate network of random cnots
# n, M = 2, 5
# N = n**2
# register = QuantumRegister(N)
# qc = QuantumCircuit(register)
# for _ in range(M):
# # choose 2 random qubits
# qargs = np.random.choice(N, 2, replace=False)
# qc.cx(*qargs)
# qc.u(np.random.rand(), np.random.rand(), np.random.rand(), qargs[0])
# qc.u(np.random.rand(), np.random.rand(), np.random.rand(), qargs[1])
# qc.decompose().draw("mpl")
N = 3
register = QuantumRegister(N)
qc = QuantumCircuit(register)
qc.ccx(0, 1, 2)
qc = qc.decompose()
qc.draw("mpl")
# load a dummy coupling map and layout
coupling = CouplingMap.from_line(N)
layout = Layout({q: i for q, i in zip(register, range(N))})
# print DAG
from qiskit.converters import circuit_to_dag
dag = circuit_to_dag(qc)
# dag.draw("mpl")
qc.draw("mpl")
from qiskit import transpile
qiskit_qc = transpile(
qc, coupling_map=coupling, initial_layout=layout, optimization_level=3
)
qiskit_qc.draw("mpl")
from qiskit import transpile
from virtual_swap.sqiswap_equiv import sel
qiskit_qc = transpile(
qc,
coupling_map=coupling,
initial_layout=layout,
optimization_level=3,
basis_gates=["u", "xx_plus_yy"],
)
qiskit_qc.draw("mpl")
# for every swap gate, append a swap gate to the end of the circuit
# this forces the qubit register ordering to be the same as the input
from qiskit.converters import circuit_to_dag
temp_dag = circuit_to_dag(qiskit_qc)
for node in list(temp_dag.topological_op_nodes())[::-1]:
if node.name == "swap":
qiskit_qc.append(node.op, node.qargs)
print(Operator(qiskit_qc).equiv(qc))
qiskit_qc.draw("mpl")
# make sure the old sabre python code works with our new qiskit version
from qiskit.transpiler.passes import Optimize1qGates
pm = PassManager()
routing = CNS_SabreSwap(coupling, heuristic="lookahead")
# pm.append(SabreLayout(coupling, routing_pass=routing))
# pm.append(TrivialLayout(coupling))
pm.append(SetLayout(layout))
pm.append([FullAncillaAllocation(coupling), EnlargeWithAncilla(), ApplyLayout()])
pm.append(routing)
pm.append(Unroller(["u", "cx", "iswap", "swap"]))
pm.append(Optimize1qGates(["u", "cx", "iswap", "swap"]))
# pm.append(Unroller(["u", "cx", "iswap", "swap"]))
qc_swapped = pm.run(qc)
print(pm.property_set["accepted_subs"])
qc_swapped.draw("mpl")
# for every swap gate, append a swap gate to the end of the circuit
# this forces the qubit register ordering to be the same as the input
from qiskit.converters import circuit_to_dag
from qiskit.circuit.library import SwapGate
temp_dag = circuit_to_dag(qc_swapped)
for node in list(temp_dag.topological_op_nodes())[::-1]:
if node.name == "swap" or node.name == "iswap":
qc_swapped.append(SwapGate(), node.qargs)
print(Operator(qc_swapped).equiv(qc))
qc_swapped.draw("mpl")
snapshots = pm.property_set["mapped_dag_snaps"]
for snap in snapshots:
display(snap)
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
from qiskit import QuantumCircuit
# from qiskit.test import QiskitTestCase
from qiskit.transpiler import CouplingMap, PassManager
from qiskit.transpiler.passes import (
Unroller,
TrivialLayout,
DenseLayout,
ApplyLayout,
SabreLayout,
CountOpsLongestPath,
Collect1qRuns,
Collect2qBlocks,
ConsolidateBlocks,
SabreSwap,
)
from qiskit.transpiler.passes import OptimizeSwapBeforeMeasure
import numpy as np
from qiskit.transpiler.passes import (
FullAncillaAllocation,
EnlargeWithAncilla,
)
from virtual_swap.sqiswap_equiv import sel
from qiskit.transpiler.basepasses import TransformationPass
from qiskit.converters import dag_to_circuit
# this code is buggy, see https://github.com/Qiskit/qiskit-terra/pull/9375
# I can't use this version bc qiskit version missing DAGCircuit functionality
from slam.utils.transpiler_pass.weyl_decompose import RootiSwapWeylDecomposition
# from virtual_swap.vswap_verbose import VirtualSwap as VirtualSwapVerbose
# from virtual_swap.vswap_simple import VirtualSwap as VirtualSwapSimple
from virtual_swap.deprecated.cns_sa import VSwapPass as VirtualSwap
# # build a toffoli
# qc = QuantumCircuit(8)
# qc.ccx(0, 1, 2)
# qc.cx(1, 7)
# qc.ccx(3, 4, 5)
# qc.ccx(2, 5, 6)
# # build a 2x2 square coupling map
# coupling = CouplingMap.from_line(8)
# # build a toffoli
qc = QuantumCircuit(3)
qc.ccx(0, 1, 2)
linear = CouplingMap.from_line(10)
a2a = CouplingMap.from_full(3)
coupling = linear
qc.decompose().draw("mpl")
# # generate a QFT circuit
# from qiskit.circuit.library import QFT
# # qc = QuantumCircuit(16)
# qc = QFT(8)
# coupling = CouplingMap.from_grid(4,4)
# generate network of random cnots
n, M = 4, 25
N = n**2
qc = QuantumCircuit(N)
for _ in range(M):
qc.cx(*np.random.choice(N, 2, replace=False))
coupling = CouplingMap.from_grid(n, n)
# coupling = CouplingMap.from_line(N + 1)
# a2a = CouplingMap.from_full(N)
qc.decompose().draw("mpl")
from qiskit import transpile
qc2 = transpile(
qc,
coupling_map=coupling,
basis_gates=["cx", "u3", "swap", "iswap"],
optimization_level=3,
)
# from virtual_swap.sqiswap_equiv import sel
# qc2 = transpile(
# qc, coupling_map=coupling, basis_gates=["xx_plus_yy", "u3"], optimization_level=3
# )
# t0_pm = PassManager([Collect2qBlocks(), ConsolidateBlocks(force_consolidate=True)])
# # , RootiSwapWeylDecomposition()])
# t0_pm.append(RootiSwapWeylDecomposition())
# qc3 = t0_pm.run(qc2)
# print(f"Total: {qc3.count_ops().get('riswap', 0)}")
# print(
# f"Depth: {qc3.depth(filter_function=lambda x: x.operation.name not in ['u3', 'u'])}"
# )
qc2.draw(output="mpl")
from qiskit import transpile
qc2 = transpile(
qc,
coupling_map=coupling,
basis_gates=["cx", "u3", "swap", "iswap"],
optimization_level=3,
)
# from virtual_swap.sqiswap_equiv import sel
# qc2 = transpile(
# qc, coupling_map=coupling, basis_gates=["xx_plus_yy", "u3"], optimization_level=3
# )
# t0_pm = PassManager([Collect2qBlocks(), ConsolidateBlocks(force_consolidate=True)])
# , RootiSwapWeylDecomposition()])
t0_pm = PassManager()
t0_pm.append(
SabreLayout(coupling, skip_routing=True), Unroller(["u", "cx", "iswap", "swap"])
)
qc3 = t0_pm.run(qc)
print(f"Total: {qc3.count_ops().get('riswap', 0)}")
print(
f"Depth: {qc3.depth(filter_function=lambda x: x.operation.name not in ['u3', 'u'])}"
)
qc3.draw(output="mpl")
# run the pass
pm = PassManager()
# trivial vs the previously computed layout
# pm.append([TrivialLayout(coupling)])
# pm.append([FullAncillaAllocation(coupling), EnlargeWithAncilla(), ApplyLayout()])
# # XXX
# from qiskit.transpiler.passes import SetLayout
# pm.append(SetLayout(layout=qc2._layout.initial_layout))
pm.property_set = t0_pm.property_set
pm.append(
VirtualSwap(
coupling,
visualize=True,
)
)
pm.append(SabreSwap(coupling))
pm.append([OptimizeSwapBeforeMeasure()])
pm2 = PassManager()
pm2.append(
[Collect1qRuns(), Collect2qBlocks(), ConsolidateBlocks(force_consolidate=True)]
)
pm2.append([RootiSwapWeylDecomposition()])
new_circ = pm.run(qc3)
new_circ_decomp = pm2.run(new_circ)
print(f"Total: {new_circ_decomp.count_ops().get('riswap', 0)}")
print(
f"Depth: {new_circ_decomp.depth(filter_function=lambda x: x.operation.name not in ['u3', 'u'])}"
)
print(new_circ.draw())
new_circ_decomp.draw("mpl")
# qc == qc2 == new_circ_decomp?
# I check with Operator.equiv but false
# idk why
# from qiskit.circuit.library import XXPlusYYGate, SwapGate, CXGate
# from qiskit.quantum_info import Operator
# cx_decomp = QuantumCircuit(2)
# cx_decomp.u(np.pi / 4, 0, np.pi / 2, 0)
# cx_decomp.u(np.pi / 4, 0, np.pi / 2, 1)
# cx_decomp.append(XXPlusYYGate(-np.pi / 2, 0), [0, 1])
# cx_decomp.u(np.pi / 4, 0, np.pi / 2, 0)
# cx_decomp.u(np.pi / 4, 0, np.pi / 2, 1)
# cx_decomp.append(XXPlusYYGate(-np.pi / 2), [0, 1])
# cx_decomp.u(np.pi / 4, 0, np.pi / 2, 0)
# cx_decomp.u(np.pi / 4, 0, np.pi / 2, 1)
# # sel.add_equivalence(CXGate(), cx_decomp)
# assert Operator(CXGate()).equiv(Operator(cx_decomp))
# swap_decomp = QuantumCircuit(2)
# swap_decomp.u(np.pi / 4, 0, np.pi / 2, 0)
# swap_decomp.u(np.pi / 4, 0, np.pi / 2, 1)
# swap_decomp.append(XXPlusYYGate(-np.pi / 2, 0), [0, 1])
# swap_decomp.u(np.pi / 4, 0, np.pi / 2, 0)
# swap_decomp.u(np.pi / 4, 0, np.pi / 2, 1)
# swap_decomp.append(XXPlusYYGate(-np.pi / 2), [0, 1])
# swap_decomp.u(np.pi / 4, 0, np.pi / 2, 0)
# swap_decomp.u(np.pi / 4, 0, np.pi / 2, 1)
# swap_decomp.append(XXPlusYYGate(-np.pi / 2), [0, 1])
# swap_decomp.u(np.pi / 4, 0, np.pi / 2, 0)
# swap_decomp.u(np.pi / 4, 0, np.pi / 2, 1)
# # sel.add_equivalence(SwapGate(), swap_decomp)
# assert Operator(SwapGate()).equiv(Operator(swap_decomp))
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
from qiskit.algorithms.optimizers import SLSQP
from qiskit.circuit.library import TwoLocal
from qiskit.extensions import UnitaryGate
from weylchamber import canonical_gate
gate = UnitaryGate(canonical_gate(0.5, 0.25, 0.25).full())
# gate ='cx'
num_qubits = 2
ansatz = TwoLocal(num_qubits, ["ry", "rz"], gate)
optimizer = SLSQP(maxiter=1000)
ansatz.decompose().draw("mpl", style="iqx")
from qiskit.primitives import Estimator
estimator = Estimator()
from qiskit.algorithms.minimum_eigensolvers import VQE
vqe = VQE(estimator, ansatz, optimizer)
from qiskit.quantum_info import SparsePauliOp
H2_op = SparsePauliOp.from_list(
[
("II", -1.052373245772859),
("IZ", 0.39793742484318045),
("ZI", -0.39793742484318045),
("ZZ", -0.01128010425623538),
("XX", 0.18093119978423156),
]
)
result = vqe.compute_minimum_eigenvalue(H2_op)
print(result)
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
%matplotlib widget
from monodromy.depthPass import MonodromyDepth
from qiskit.circuit.library import XXPlusYYGate
import numpy as np
from qiskit import QuantumCircuit
from qiskit.quantum_info import Operator
from qiskit.extensions import UnitaryGate
from weylchamber import canonical_gate
gate = XXPlusYYGate(np.pi / 2, np.pi / 6)
qc = QuantumCircuit(2)
qc.append(gate, [0, 1])
qc.swap(0, 1)
gate = UnitaryGate(Operator(qc))
gate = UnitaryGate(canonical_gate(0.5, 0.25, 0.25).full())
MonodromyDepth(basis_gate=gate).coverage_set
from slam.utils.polytopes.coverage_plot import plot_coverage_set
plot_coverage_set(MonodromyDepth(basis_gate=gate).coverage_set)
from qiskit import QuantumCircuit
from weylchamber import c1c2c3, WeylChamber
from qiskit.quantum_info import Operator
import numpy as np
from qiskit import transpile
# observable = SparsePauliOp("XZ")
# qubits = observable.num_qubits
# ansatz = RealAmplitudes(observable.num_qubits, reps=3)
# display(ansatz.decompose().draw('mpl'))
# backend = service.get_backend('ibm_lagos')
# transpiled_ansatz = transpile(ansatz, backend=backend,
# basis_gates=['u1', 'u2', 'u3', 'rx', 'ry', 'rz', 'cx', 'cz'],
# seed_transpiler=42,
# optimization_level=3)
# display(transpiled_ansatz.decompose().draw('mpl'))
# from qiskit.circuit.random import random_circuit
# from qiskit.quantum_info import SparsePauliOp
# from qiskit.circuit.library import RealAmplitudes
# from qiskit_ibm_runtime import QiskitRuntimeService, Session, Estimator, Options
# observable = SparsePauliOp("XZ")
# qubits = observable.num_qubits
# ansatz = RealAmplitudes(observable.num_qubits, reps=3)
# display(ansatz.decompose().draw('mpl'))
# backend = service.get_backend('simulator_statevector')
# transpiled_ansatz = transpile(ansatz, backend=backend,
# basis_gates=['u1', 'u2', 'u3', 'rx', 'ry', 'rz', 'cx', 'cz'],
# seed_transpiler=42,
# optimization_level=3)
# service = QiskitRuntimeService()
# with Session(service=service, backend="ibmq_qasm_simulator") as session:
# estimator = Estimator(session=session, options=options)
# job = estimator.run(circuit, observable)
# result = job.result()
# # Close the session only if all jobs are finished, and you don't need to run more in the session
# session.close() # Closes the session
# display(circuit.draw("mpl"))
# print(f" > Observable: {observable.paulis}")
# print(f" > Expectation value: {result.values[0]}")
# print(f" > Metadata: {result.metadata[0]}")
# from qiskit import QuantumCircuit
# qc = QuantumCircuit(2)
# qc.cx(0, 1)
# qc.swap(0,1)
# qc.draw('mpl', filename='cns.svg')
# # print(qc.draw("latex_source"))
# write circuit for CX decomposed into sqiswaps
from qiskit import QuantumCircuit
qc = QuantumCircuit(2)
qc.cx(0, 1)
from slam.utils.transpiler_pass.weyl_decompose import (
RootiSwapWeylDecomposition,
SiSwapGate,
)
# decomposer = RootiSwapWeylDecomposition()
# from qiskit.converters import circuit_to_dag, dag_to_circuit
# dag = decomposer.run(circuit_to_dag(qc))
# qc2 = dag_to_circuit(dag)
from qiskit.transpiler.passmanager import PassManager
from qiskit.transpiler.passes import Optimize1qGates
pm = PassManager()
pm.append(RootiSwapWeylDecomposition())
pm.append(Optimize1qGates())
qc2 = pm.run(qc)
qc2.draw("mpl")
qc3 = QuantumCircuit(2)
from qiskit.circuit.library import iSwapGate
import numpy as np
# qc3.u(np.pi/2, -np.pi/2, 0, 0)
qc3.ry(np.pi / 2, 0)
qc3.rz(-np.pi / 2, 0)
# qc3.u(np.pi/2, np.pi, -np.pi/2, 1)
qc3.rz(np.pi / 2, 1)
qc3.ry(-np.pi / 2, 1)
qc3.append(SiSwapGate(), [0, 1])
# qc3.u(np.pi, -np.pi/2, np.pi/2, 0)
qc3.rx(np.pi, 0)
# qc3.u(0, 0, np.pi, 1)
qc3.rz(-np.pi, 1)
qc3.append(SiSwapGate(), [0, 1])
# qc3.u(np.pi/2, -np.pi/2, -3*np.pi/2, 0)
qc3.rx(np.pi / 2, 0)
# qc3.u(0, -np.pi/2, -np.pi, 1)
qc3.rz(np.pi / 2, 1)
qc3.draw("mpl", filename="cx-sqiswap.svg")
# from qiskit.quantum_info import Operator
# Operator(qc4).equiv(qc)
qc3 = QuantumCircuit(2)
qc3.u(np.pi / 2, -np.pi / 2, 0, 0)
# qc3.ry(np.pi/2, 0)
# qc3.rz(-np.pi/2, 0)
qc3.u(np.pi / 2, np.pi, -np.pi / 2, 1)
# qc3.rz(np.pi/2, 1)
# qc3.ry(-np.pi/2, 1)
# qc3.append(SiSwapGate(), [0,1])
qc3.barrier()
qc3.u(np.pi, -np.pi / 2, np.pi / 2, 0)
qc3.u(0, 0, np.pi, 1)
# qc3.append(SiSwapGate(), [0,1])
qc3.barrier()
qc3.u(np.pi / 2, -np.pi / 2, -3 * np.pi / 2, 0)
qc3.u(0, -np.pi / 2, -np.pi, 1)
# pm = PassManager()
# # pm.append(RootiSwapWeylDecomposition())
# pm.append(Optimize1qGates(basis=['u']))
# qc4 = pm.run(qc3)
qc4 = transpile(
qc3, basis_gates=["x", "y", "z", "h", "t", "s", "sx", "sy", "sz", "rz", "ry"]
)
qc4.draw("mpl", filename="cx_decomp")
from virtual_swap.cns_transform import cx_replace
from qiskit.transpiler.passes import (
Collect1qRuns,
ConsolidateBlocks,
Unroller,
Optimize1qGates,
)
pm = PassManager()
# pm.append(Collect1qRuns())
# pm.append(ConsolidateBlocks())
# pm.append(Unroller(['u']))
pm.append(Optimize1qGates(basis=["u"]))
# cx_replace.swap(0, 1)
cx_replace2 = pm.run(cx_replace)
cx_replace2.draw("mpl", filename="cx_decomp.svg")
qc = QuantumCircuit(2)
qc.crz(np.pi / 2, 0, 1)
qc = transpile(qc, basis_gates=["u", "cx"])
qc.draw()
# replace the last cx gate with iswap+virtual_swap
from qiskit.converters import circuit_to_dag, dag_to_circuit
from qiskit.circuit.library import CXGate
dag = circuit_to_dag(qc)
cx_node = dag.op_nodes(CXGate)[1]
from virtual_swap.cns_transform import cns_transform
qc2 = dag_to_circuit(cns_transform(dag, cx_node))
qc2.decompose().draw()
Operator(qc2).equiv(qc)
from slam.utils.transpiler_pass.weyl_decompose import RootiSwapWeylDecomposition
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import ConsolidateBlocks, Collect2qBlocks, Unroller
pm = PassManager()
pm.append(Unroller(["u", "cx", "iswap"]))
pm.append(Collect2qBlocks())
pm.append(ConsolidateBlocks(force_consolidate=True))
pm.append(RootiSwapWeylDecomposition())
pm.run(qc2).draw()
qc3 = QuantumCircuit(2)
qc3.cx(1, 0)
qc3.cx(0, 1)
qc3.draw()
Operator(qc3).equiv(cx_replace)
qc = QuantumCircuit(2)
qc.cx(0, 1)
qc.swap(0, 1)
# transpile into CR gates
transpile(qc, basis_gates=["rzx", "u"], optimization_level=3).draw("mpl")
qc = QuantumCircuit(2)
qc.cx(0, 1)
qc.draw("mpl")
from slam.utils.transpiler_pass.weyl_decompose import RootiSwapWeylDecomposition
from qiskit.transpiler import PassManager
pm = PassManager()
pm.append(RootiSwapWeylDecomposition())
qc = pm.run(qc)
qc.draw("mpl")
qc1 = QuantumCircuit(2)
qc1.rx(np.pi / 2, 1)
qc1.rz(-np.pi / 2, 0)
qc1.rz(np.pi / 2, 1)
qc1.iswap(0, 1)
qc1.rx(np.pi / 2, 0)
qc1.iswap(0, 1)
qc1.rz(np.pi / 2, 1)
qc1.draw("mpl")
from qiskit import QuantumCircuit
qc = QuantumCircuit(2)
qc.cx(1, 0)
qc.h(1)
qc.cx(0, 1)
qc.tdg(1)
qc2 = QuantumCircuit(2)
qc2.s(0)
qc2.cx(1, 0)
qc2.sx(1)
qc2.sdg(0)
qc2.t(1)
qc3 = QuantumCircuit(2)
qc3.cx(1, 0)
qc3.cx(0, 1)
qc4 = QuantumCircuit(2)
qc4.cx(0, 1)
qc4.swap(0, 1)
c1 = c1c2c3(Operator(qc).data)
c2 = c1c2c3(Operator(qc2).data)
c3 = c1c2c3(Operator(qc3).data)
c4 = c1c2c3(Operator(qc4).data)
print(c1, c2, c3, c4)
qc3.draw("mpl")
qc4.draw("mpl")
Operator(qc4).equiv(cx_replace)
from virtual_swap.cns_transform import cx_replace, iswap_replace
cx_replace.draw("mpl")
iswap_replace.draw("mpl")
Operator(qc3).equiv(qc4)
# visualize weyl chamber coordinates
from weylchamber import WeylChamber
w = WeylChamber()
N = 1000
for _ in range(N):
qc = QuantumCircuit(2)
# random 1q
qc.u(
2 * np.pi * np.random.rand(),
2 * np.pi * np.random.rand(),
2 * np.pi * np.random.rand(),
0,
)
qc.u(
2 * np.pi * np.random.rand(),
2 * np.pi * np.random.rand(),
2 * np.pi * np.random.rand(),
1,
)
# qc.crz(2 * np.pi * np.random.rand(), 0, 1)
qc.cx(0, 1)
# random 1q
qc.u(
2 * np.pi * np.random.rand(),
2 * np.pi * np.random.rand(),
2 * np.pi * np.random.rand(),
0,
)
qc.u(
2 * np.pi * np.random.rand(),
2 * np.pi * np.random.rand(),
2 * np.pi * np.random.rand(),
1,
)
# qc.swap(0, 1)
# qc.cx(0, 1)
qc.iswap(0, 1)
# random 1q
qc.u(
2 * np.pi * np.random.rand(),
2 * np.pi * np.random.rand(),
2 * np.pi * np.random.rand(),
0,
)
qc.u(
2 * np.pi * np.random.rand(),
2 * np.pi * np.random.rand(),
2 * np.pi * np.random.rand(),
1,
)
qc.swap(0, 1)
op = Operator(qc).data
w.add_point(*c1c2c3(op))
w.plot()
qc.draw("mpl")
# visualize weyl chamber coordinates
from qiskit import QuantumCircuit
from weylchamber import c1c2c3, WeylChamber
from qiskit.quantum_info import Operator
import numpy as np
w = WeylChamber()
N = 1000
for _ in range(N):
qc = QuantumCircuit(2)
# random 1q
qc.u(
2 * np.pi * np.random.rand(),
2 * np.pi * np.random.rand(),
2 * np.pi * np.random.rand(),
0,
)
qc.u(
2 * np.pi * np.random.rand(),
2 * np.pi * np.random.rand(),
2 * np.pi * np.random.rand(),
1,
)
qc.cx(0, 1)
# random 1q
qc.u(
2 * np.pi * np.random.rand(),
2 * np.pi * np.random.rand(),
2 * np.pi * np.random.rand(),
0,
)
qc.u(
2 * np.pi * np.random.rand(),
2 * np.pi * np.random.rand(),
2 * np.pi * np.random.rand(),
1,
)
qc.iswap(0, 1)
# random 1q
qc.u(
2 * np.pi * np.random.rand(),
2 * np.pi * np.random.rand(),
2 * np.pi * np.random.rand(),
0,
)
qc.u(
2 * np.pi * np.random.rand(),
2 * np.pi * np.random.rand(),
2 * np.pi * np.random.rand(),
1,
)
qc.swap(0, 1)
# random 1q
qc.u(
2 * np.pi * np.random.rand(),
2 * np.pi * np.random.rand(),
2 * np.pi * np.random.rand(),
0,
)
qc.u(
2 * np.pi * np.random.rand(),
2 * np.pi * np.random.rand(),
2 * np.pi * np.random.rand(),
1,
)
op = Operator(qc).data
w.add_point(*c1c2c3(op))
w.plot()
import matplotlib.pyplot as plt
w = WeylChamber()
# generate a color gradient
N = 9
color_gradient = [
plt.cm.tab10(i / (N + 1)) for i in range(N + 1)
] # using 'plasma' colormap here
w = WeylChamber()
# create two lists for the two types of operations
op1_list = []
op2_list = []
# iterate from I to CX (theta = 0 to np.pi)
for i in range(N + 1):
qc = QuantumCircuit(2)
qc.cp(np.pi * i / N, 0, 1)
op1 = Operator(qc).data
t = c1c2c3(op1)
# force to use x < 1/2
if t[0] > 0.5:
t = (1 - t[0], t[1], t[2])
op1_list.append((t, color_gradient[i]))
qc.swap(0, 1)
op2 = Operator(qc).data
op2_list.append((c1c2c3(op2), color_gradient[i]))
# add the operations to the Weyl chamber
for coords, color in op1_list:
w.scatter(*coords, color=color)
for coords, color in op2_list:
w.scatter(*coords, color=color)
# define a region using line segments between the following points
# (0,0,0), (1/2, 1/2, 0); (0,0,0), (1,0,0); (1/2, 1/2, 0), (1,0,0); (0,0,0), (1/2, 1/4, 1/4)
lines = [
[(0, 0, 0), (0.5, 0.5, 0)],
[(0, 0, 0), (1, 0, 0)],
[(0.5, 0.5, 0), (1, 0, 0)],
[(0, 0, 0), (0.5, 0.25, 0.25)],
[(0.5, 0.5, 0), (0.5, 0.25, 0.25)],
[(0.5, 0.25, 0.25), (1, 0, 0)],
]
# draw the lines
w.labels = {}
w.plot()
for i in range(len(lines)):
w._draw_line(
w.ax, origin=lines[i][0], end=lines[i][1], color="blue", linestyle="--"
)
w.fig.savefig("cphase_swap.svg", dpi=300)
# fig.savefig("cphase_swap.svg", dpi=300)
w = WeylChamber()
# generate Haar random unitary
from qiskit.quantum_info import random_unitary
op = random_unitary(4).data
qc = QuantumCircuit(2)
qc.unitary(op, [0, 1])
op = Operator(qc).data
w.scatter(*c1c2c3(op), color="blue")
qc.swap(0, 1)
op2 = Operator(qc).data
w.scatter(*c1c2c3(op2), color="red")
w.plot()
import numpy as np
from qiskit.quantum_info import random_unitary
from qiskit.quantum_info import Operator
from qiskit import QuantumCircuit
from weylchamber import WeylChamber, c1c2c3
import matplotlib.pyplot as plt
from matplotlib import cm
w = WeylChamber()
# Generate many random unitaries
N = 1000
coords_initial = []
coords_final = []
for _ in range(N):
# Generate Haar random unitary
op = random_unitary(4).data
qc = QuantumCircuit(2)
qc.unitary(op, [0, 1])
op = Operator(qc).data
coords_initial.append(c1c2c3(op))
# Apply SWAP
qc.swap(0, 1)
op2 = Operator(qc).data
coords_final.append(c1c2c3(op2))
# Convert to numpy arrays for easier handling
coords_initial = np.array(coords_initial)
coords_final = np.array(coords_final)
# Plot initial points with blue color
w.scatter(
coords_initial[:, 0], coords_initial[:, 1], coords_initial[:, 2], color="blue"
)
# Plot final points with red color
w.scatter(coords_final[:, 0], coords_final[:, 1], coords_final[:, 2], color="red")
import matplotlib as mpl
# Create a color map with 256 colors
color_map = mpl.cm.get_cmap("viridis", 256)
# Generate colors from the color map
colors = color_map(np.linspace(0, 1, N))
# # Plot trajectories
# for i in range(N):
# w._draw_line(
# (coords_initial[i, 0], coords_initial[i, 1], coords_initial[i, 2]),
# (coords_final[i, 0], coords_final[i, 1], coords_final[i, 2]),
# color=colors[i],
# )
w.plot()
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
from transpile_benchy.metrics.gate_counts import (
DepthMetric,
TotalMetric,
TotalSwaps,
)
from qiskit.circuit.library import iSwapGate
from qiskit.transpiler import CouplingMap
from mirror_gates.pass_managers import Mirage, QiskitLevel3
from mirror_gates.utilities import SubsMetric
from mirror_gates.logging import transpile_benchy_logger
# N = 4
# coupling_map = CouplingMap.from_line(N)
# coupling_map = CouplingMap.from_heavy_hex(5)
coupling_map = CouplingMap.from_grid(6, 6)
from transpile_benchy.library import CircuitLibrary
library = CircuitLibrary.from_txt("../../../circuits/medium_circuits.txt")
# library = CircuitLibrary.from_txt("../../circuits/debug.txt")
# XXX set consolidate to False
# this is allowed only because my pass manager will preserve consolidation
# see post_stage, I call fastconsolidate manually
# NOTE: use TotalSwaps to verify baselines have > 0 swaps
# otherwise, there is no room for improvement.
# we can include these if we want to show our methods will still work
# but somewhat trivial since we just append VF2Layout
metrics = [
DepthMetric(consolidate=False),
TotalMetric(consolidate=False),
TotalSwaps(consolidate=False),
SubsMetric(),
]
transpilers = [
# QiskitLevel3(coupling_map, cx_basis=True),
# Mirage(coupling_map, cx_basis=True, parallel=0),
QiskitLevel3(coupling_map),
Mirage(coupling_map, logger=transpile_benchy_logger),
]
from transpile_benchy.benchmark import Benchmark
benchmark = Benchmark(
transpilers=transpilers,
circuit_library=library,
metrics=metrics,
logger=transpile_benchy_logger,
num_runs=5,
)
benchmark.run()
# print(benchmark)
print(benchmark)
benchmark.summary_statistics(transpilers[0], transpilers[1])
from transpile_benchy.render import plot_benchmark
plot_benchmark(benchmark, save=1, legend_show=0, filename="grid", color_override=[0, 3])
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
# TODO, show differences related to post-selecting for depth vs post-selectng for total gates added
from qiskit.transpiler import CouplingMap
from mirror_gates.pass_managers import Mirage, QiskitLevel3
from transpile_benchy.metrics.gate_counts import DepthMetric, TotalMetric
from mirror_gates.logging import transpile_benchy_logger
from transpile_benchy.library import CircuitLibrary
library = CircuitLibrary.from_txt("../../circuits/medium_circuits.txt")
coupling_map = CouplingMap.from_heavy_hex(5)
transpilers = [
QiskitLevel3(coupling_map), # 20,4,20
Mirage(
coupling_map,
name="Mirage-Min-Swaps",
cost_function="basic",
fixed_aggression=1,
),
Mirage(
coupling_map,
name="Mirage-Min-Depth",
fixed_aggression=1,
),
]
metrics = [DepthMetric(consolidate=False), TotalMetric(consolidate=False)]
from transpile_benchy.benchmark import Benchmark
# only interested in TimeMetric, is there by default
benchmark = Benchmark(
transpilers=transpilers,
circuit_library=library,
metrics=metrics,
num_runs=5,
logger=transpile_benchy_logger,
)
benchmark.run()
benchmark.summary_statistics(transpilers[0], transpilers[1])
benchmark.summary_statistics(transpilers[1], transpilers[2])
benchmark.summary_statistics(transpilers[0], transpilers[2])
from transpile_benchy.render import plot_benchmark
plot_benchmark(
benchmark,
save=1,
legend_show=1,
filename="post",
override_legend=["Qiskit", "MIRAGE-Swaps", "MIRAGE-Depth"],
)
print(benchmark)
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
# TODO, show how different aggression configurations impact results
from qiskit.transpiler import CouplingMap
from mirror_gates.pass_managers import Mirage, QiskitLevel3
from transpile_benchy.metrics.abc_metrics import MetricInterface
from transpile_benchy.metrics.gate_counts import DepthMetric
from mirror_gates.utilities import DoNothing
from transpile_benchy.library import CircuitLibrary
library = CircuitLibrary.from_txt("../../circuits/aggression_select.txt")
# library = CircuitLibrary.from_txt("../../circuits/small_circuits.txt")
# library = CircuitLibrary.from_txt("speedups.txt")
coupling_map = CouplingMap.from_heavy_hex(5)
transpilers = [
QiskitLevel3(coupling_map),
Mirage(coupling_map, name="Mirage-a0", fixed_aggression=0, no_vf2=True),
Mirage(coupling_map, name="Mirage-a1", fixed_aggression=1, no_vf2=True),
Mirage(coupling_map, name="Mirage-a2", fixed_aggression=2, no_vf2=True),
Mirage(coupling_map, name="Mirage-a3", fixed_aggression=3, no_vf2=True),
]
metrics = [DepthMetric(consolidate=False)]
from transpile_benchy.benchmark import Benchmark
# only interested in TimeMetric, is there by default
benchmark = Benchmark(
transpilers=transpilers,
circuit_library=library,
metrics=metrics,
num_runs=1,
)
benchmark.run()
print(benchmark.summary_statistics(transpilers[0], transpilers[1])["monodromy_depth"])
print(benchmark.summary_statistics(transpilers[0], transpilers[2])["monodromy_depth"])
print(benchmark.summary_statistics(transpilers[0], transpilers[3])["monodromy_depth"])
print(benchmark.summary_statistics(transpilers[0], transpilers[4])["monodromy_depth"])
from transpile_benchy.render import plot_benchmark
plot_benchmark(
benchmark,
save=0,
legend_show=1,
filename="aggression",
color_override=[0, 2, 4, 5, 6],
auto_sort=0,
override_legend=[
"Qiskit",
"Mirage-a0",
"Mirage-a1",
"Mirage-a2",
"Mirage-a3",
],
)
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
# make a graph that shows convergence as a function of layout trials and swap trials
# very important point to not forget
# NOTE, these layout trials are after multiple SWAP trials and through forward-backwards pass
# this means it has already gone through 2 stages of optimization and we still have large variance
# ultimate question is how much time do we need to spend on swap restarts, forward-backward passes, and layout restarts
# maybe we work from bottom up, collect data to get a fair estimate of how much time we need to spend on each?
from qiskit.transpiler import CouplingMap
from mirror_gates.pass_managers import Mirage, QiskitLevel3
from transpile_benchy.metrics.abc_metrics import MetricInterface
from transpile_benchy.metrics.gate_counts import DepthMetric
from mirror_gates.utilities import (
DoNothing,
LayoutTrialsStdMetric,
LayoutTrialsMetric,
)
from mirror_gates.logging import transpile_benchy_logger
from transpile_benchy.library import CircuitLibrary
library = CircuitLibrary.from_txt("../../circuits/iters_select.txt")
coupling_map = CouplingMap.from_heavy_hex(5)
total_work = 80
transpilers = [
# QiskitLevel3(coupling_map),
Mirage(coupling_map, name="Qiskit", fixed_aggression=0),
Mirage(coupling_map, name="Mirage"),
# Mirage(
# coupling_map,
# name="Mirage-b3",
# layout_trials=20,
# fb_iters=total_work // 20,
# anneal_routing=True,
# parallel=False, # something is broken
# ),
]
metrics = [LayoutTrialsMetric()] # , DepthMetric(consolidate=False)]
# coupling_map = CouplingMap.from_heavy_hex(5)
# transpilers = [
# # QiskitLevel3(coupling_map),
# Mirage(coupling_map, name="Mirage-MinSwaps", cost_function="basic"),
# Mirage(coupling_map, name="Mirage-MinDepth"),
# ]
# metrics = [DepthMetric(consolidate=False)] # , TotalMetric(consolidate=False)]
from transpile_benchy.benchmark import Benchmark
# only interested in TimeMetric, is there by default
benchmark = Benchmark(
transpilers=transpilers,
circuit_library=library,
metrics=metrics,
num_runs=10,
logger=transpile_benchy_logger,
)
benchmark.run()
print(benchmark)
benchmark.metrics[0].saved_results
import matplotlib.pyplot as plt
import numpy as np
# Assuming benchmark.metrics[0].saved_results.items() is a dictionary
# where keys are circuit names and values are lists of costs for each trial
for k, v in benchmark.metrics[0].saved_results.items():
print(k)
for circuit, result in v.items():
# print(circuit)
# print(result.data)
# find cumulative min trial-wise
min_trials = np.minimum.accumulate(result.data, axis=1)
print(min_trials.shape)
# print(min_trials)
# average element-wise across all trials
avg = np.mean(min_trials, axis=0)
# print(avg)
# plot cumulative min vs trial
# also plot average cumulative min vs trial
# at each trial we also want to scatter plot each individual trial,
# plot with latex
with plt.style.context(["ipynb", "colorsblind10"]):
plt.rcParams["text.usetex"] = True
for j, trials in enumerate(min_trials):
plt.plot(
trials,
color="blue",
alpha=0.1,
label="Individual Trials" if j == 0 else None,
)
plt.plot(avg, color="red", label="Average")
plt.xlabel("Layout Trials")
plt.ylabel("Cumulative Min Cost")
plt.title(f"{k} {circuit}")
plt.ticklabel_format(style="plain") # Turn off scientific notation
plt.legend()
plt.show()
# # explictly print results
# for k, v in benchmark.metrics[0].saved_results.items():
# for circuit, result in v.items():
# print(result.data)
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
# TODO, show how different aggression configurations impact results
from qiskit.transpiler import CouplingMap
from mirror_gates.pass_managers import Mirage, QiskitLevel3
from transpile_benchy.metrics.abc_metrics import MetricInterface
from transpile_benchy.metrics.gate_counts import DepthMetric
from mirror_gates.utilities import DoNothing
from mirror_gates.logging import transpile_benchy_logger
from transpile_benchy.library import CircuitLibrary
library = CircuitLibrary.from_txt("../../circuits/select.txt")
coupling_map = CouplingMap.from_heavy_hex(5)
total_work = 80
transpilers = [
QiskitLevel3(coupling_map),
Mirage(coupling_map, name="Mirage"),
# Mirage(
# coupling_map,
# name="Mirage-b2",
# layout_trials=3,
# fb_iters=total_work // 3,
# anneal_routing=True,
# ),
Mirage(
coupling_map,
name="Mirage-b3",
layout_trials=4,
fb_iters=total_work // 4,
anneal_routing=True,
),
]
metrics = [DepthMetric(consolidate=False)]
from transpile_benchy.benchmark import Benchmark
# only interested in TimeMetric, is there by default
benchmark = Benchmark(
transpilers=transpilers,
circuit_library=library,
metrics=metrics,
num_runs=1,
logger=transpile_benchy_logger,
)
benchmark.run()
print(benchmark.summary_statistics(transpilers[0], transpilers[1])["monodromy_depth"])
print(benchmark.summary_statistics(transpilers[0], transpilers[2])["monodromy_depth"])
# print(benchmark.summary_statistics(transpilers[0], transpilers[3])["monodromy_depth"])
from transpile_benchy.render import plot_benchmark
plot_benchmark(benchmark, save=0, legend_show=1, filename="annealing")
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
from qiskit.transpiler import CouplingMap
from mirror_gates.pass_managers import Mirage, QiskitLevel3
from mirror_gates.logging import transpile_benchy_logger
from transpile_benchy.library import CircuitLibrary
library = CircuitLibrary.from_txt("../../circuits/iters_select.txt")
coupling_map = CouplingMap.from_line(64)
# coupling_map = CouplingMap.from_heavy_hex(5)
# XXX we hardcoded layout to not be parallelized to avoid a pipe error
# before collecting data for this result -> change the hardcoded value
# maybe requires downgrading to 3.9 to get this to work....????
transpilers = [
QiskitLevel3(coupling_map, python_sabre=True),
Mirage(
coupling_map,
use_fast_settings=True,
name="Mirage",
parallel=True,
swap_trials=6,
layout_trials=6,
),
]
from transpile_benchy.benchmark import Benchmark
# only interested in TimeMetric, is there by default
benchmark = Benchmark(
transpilers=transpilers,
circuit_library=library,
num_runs=1,
logger=transpile_benchy_logger,
)
benchmark.run()
benchmark.summary_statistics(transpilers[0], transpilers[1])
from transpile_benchy.render import plot_benchmark
plot_benchmark(
benchmark,
save=1,
legend_show=1,
filename="speed",
plot_type="trendline",
color_override=[0, 3],
)
print(benchmark)
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
from transpile_benchy.metrics.gate_counts import (
DepthMetric,
TotalMetric,
TotalSwaps,
)
from qiskit.circuit.library import iSwapGate
from qiskit.transpiler import CouplingMap
from mirror_gates.pass_managers import Mirage, QiskitLevel3
from mirror_gates.utilities import SubsMetric
from mirror_gates.logging import transpile_benchy_logger
from clonk.backend_utils.coupling_map import Tree, Corral
tree = Tree()
corral = Corral(num_snails=18)
# N = 4
# coupling_map = CouplingMap.from_line(N)
# coupling_map = CouplingMap.from_heavy_hex(5)
square = CouplingMap.from_grid(6, 6)
from transpile_benchy.library import CircuitLibrary
library = CircuitLibrary.from_txt("../../circuits/medium_circuits.txt")
# library = CircuitLibrary.from_txt("../../circuits/debug.txt")
# XXX set consolidate to False
# this is allowed only because my pass manager will preserve consolidation
# see post_stage, I call fastconsolidate manually
# NOTE: use TotalSwaps to verify baselines have > 0 swaps
# otherwise, there is no room for improvement.
# we can include these if we want to show our methods will still work
# but somewhat trivial since we just append VF2Layout
metrics = [
DepthMetric(consolidate=False),
TotalMetric(consolidate=False),
TotalSwaps(consolidate=False),
SubsMetric(),
]
transpilers = [
QiskitLevel3(square, name="Qiskit-square"),
Mirage(square, name="Mirage-square"),
# QiskitLevel3(tree, name="Qiskit-tree"),
# Mirage(tree, name="Mirage-tree"),
QiskitLevel3(corral, name="Qiskit-corral"),
Mirage(corral, name="Mirage-corral"),
]
from transpile_benchy.benchmark import Benchmark
benchmark = Benchmark(
transpilers=transpilers,
circuit_library=library,
metrics=metrics,
logger=transpile_benchy_logger,
num_runs=1,
)
benchmark.run()
# print(benchmark)
# print(benchmark)
benchmark.summary_statistics(transpilers[2], transpilers[3])
from transpile_benchy.render import plot_benchmark
plot_benchmark(
benchmark,
save=0,
legend_show=1,
filename="grid",
color_override=[0, 3, 6, 7],
)
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
from transpile_benchy.metrics.gate_counts import (
DepthMetric,
TotalMetric,
TotalSwaps,
)
from qiskit.circuit.library import iSwapGate
from qiskit.transpiler import CouplingMap
from mirror_gates.pass_managers import Mirage, QiskitLevel3
from mirror_gates.utilities import SubsMetric
from mirror_gates.logging import transpile_benchy_logger
# N = 4
# coupling_map = CouplingMap.from_line(N)
coupling_map = CouplingMap.from_heavy_hex(5)
# coupling_map = CouplingMap.from_grid(6, 6)
from transpile_benchy.library import CircuitLibrary
library = CircuitLibrary.from_txt("../../../circuits/medium_circuits.txt")
# library = CircuitLibrary.from_txt("../../circuits/debug.txt")
# XXX set consolidate to False
# this is allowed only because my pass manager will preserve consolidation
# see post_stage, I call fastconsolidate manually
# NOTE: use TotalSwaps to verify baselines have > 0 swaps
# otherwise, there is no room for improvement.
# we can include these if we want to show our methods will still work
# but somewhat trivial since we just append VF2Layout
metrics = [
DepthMetric(consolidate=False),
TotalMetric(consolidate=False),
TotalSwaps(consolidate=False),
SubsMetric(),
]
transpilers = [
# QiskitLevel3(coupling_map, cx_basis=True),
# Mirage(coupling_map, cx_basis=True, parallel=0),
QiskitLevel3(coupling_map),
Mirage(coupling_map, logger=transpile_benchy_logger),
]
from transpile_benchy.benchmark import Benchmark
benchmark = Benchmark(
transpilers=transpilers,
circuit_library=library,
metrics=metrics,
logger=transpile_benchy_logger,
num_runs=5,
)
benchmark.run()
# print(benchmark)
print(benchmark)
benchmark.summary_statistics(transpilers[0], transpilers[1])
from transpile_benchy.render import plot_benchmark
plot_benchmark(benchmark, save=1, legend_show=1, filename="hex", color_override=[0, 3])
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
from transpile_benchy.metrics.gate_counts import (
DepthMetric,
TotalMetric,
TotalSwaps,
)
from qiskit.circuit.library import iSwapGate
from qiskit.transpiler import CouplingMap
from mirror_gates.pass_managers import Mirage, QiskitLevel3
from mirror_gates.utilities import SubsMetric
from mirror_gates.logging import transpile_benchy_logger
# N = 4
# coupling_map = CouplingMap.from_line(N)
# coupling_map = CouplingMap.from_heavy_hex(5)
coupling_map = CouplingMap.from_grid(6, 6)
from transpile_benchy.library import CircuitLibrary
library = CircuitLibrary.from_txt("../../../circuits/medium_circuits.txt")
# library = CircuitLibrary.from_txt("../../circuits/debug.txt")
# XXX set consolidate to False
# this is allowed only because my pass manager will preserve consolidation
# see post_stage, I call fastconsolidate manually
# NOTE: use TotalSwaps to verify baselines have > 0 swaps
# otherwise, there is no room for improvement.
# we can include these if we want to show our methods will still work
# but somewhat trivial since we just append VF2Layout
metrics = [
DepthMetric(consolidate=False),
TotalMetric(consolidate=False),
TotalSwaps(consolidate=False),
SubsMetric(),
]
transpilers = [
# QiskitLevel3(coupling_map, cx_basis=True),
# Mirage(coupling_map, cx_basis=True, parallel=0),
QiskitLevel3(coupling_map),
Mirage(coupling_map, logger=transpile_benchy_logger),
]
from transpile_benchy.benchmark import Benchmark
benchmark = Benchmark(
transpilers=transpilers,
circuit_library=library,
metrics=metrics,
logger=transpile_benchy_logger,
num_runs=5,
)
benchmark.run()
# print(benchmark)
print(benchmark)
benchmark.summary_statistics(transpilers[0], transpilers[1])
from transpile_benchy.render import plot_benchmark
plot_benchmark(benchmark, save=1, legend_show=0, filename="grid", color_override=[0, 3])
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
from transpile_benchy.metrics.gate_counts import (
DepthMetric,
TotalMetric,
TotalSwaps,
)
from qiskit.circuit.library import iSwapGate
from qiskit.transpiler import CouplingMap
from mirror_gates.pass_managers import Mirage, QiskitLevel3
from mirror_gates.utilities import SubsMetric
from mirror_gates.logging import transpile_benchy_logger
# N = 4
# coupling_map = CouplingMap.from_line(N)
coupling_map = CouplingMap.from_heavy_hex(5)
from transpile_benchy.library import CircuitLibrary
library = CircuitLibrary.from_txt("../../../circuits/medium_circuits.txt")
# library = CircuitLibrary.from_txt("../../circuits/debug.txt")
# XXX set consolidate to False
# this is allowed only because my pass manager will preserve consolidation
# see post_stage, I call fastconsolidate manually
# NOTE: use TotalSwaps to verify baselines have > 0 swaps
# otherwise, there is no room for improvement.
# we can include these if we want to show our methods will still work
# but somewhat trivial since we just append VF2Layout
metrics = [
DepthMetric(consolidate=False),
TotalMetric(consolidate=False),
TotalSwaps(consolidate=False),
SubsMetric(),
]
transpilers = [
QiskitLevel3(coupling_map, cx_basis=True),
Mirage(coupling_map, logger=transpile_benchy_logger, cx_basis=True),
]
from transpile_benchy.benchmark import Benchmark
benchmark = Benchmark(
transpilers=transpilers,
circuit_library=library,
metrics=metrics,
logger=transpile_benchy_logger,
num_runs=5,
)
benchmark.run()
# print(benchmark)
print(benchmark)
benchmark.summary_statistics(transpilers[0], transpilers[1])
from transpile_benchy.render import plot_benchmark
plot_benchmark(
benchmark,
save=1,
legend_show=1,
filename="cnot_hex",
color_override=[6, 9],
)
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
from transpile_benchy.metrics.gate_counts import (
DepthMetric,
TotalMetric,
TotalSwaps,
)
from qiskit.circuit.library import iSwapGate
from qiskit.transpiler import CouplingMap
from mirror_gates.pass_managers import Mirage, QiskitLevel3
from mirror_gates.utilities import SubsMetric
from mirror_gates.logging import transpile_benchy_logger
# N = 4
# coupling_map = CouplingMap.from_line(N)
coupling_map = CouplingMap.from_grid(6, 6)
from transpile_benchy.library import CircuitLibrary
library = CircuitLibrary.from_txt("../../../circuits/medium_circuits.txt")
# library = CircuitLibrary.from_txt("../../circuits/debug.txt")
# XXX set consolidate to False
# this is allowed only because my pass manager will preserve consolidation
# see post_stage, I call fastconsolidate manually
# NOTE: use TotalSwaps to verify baselines have > 0 swaps
# otherwise, there is no room for improvement.
# we can include these if we want to show our methods will still work
# but somewhat trivial since we just append VF2Layout
metrics = [
DepthMetric(consolidate=False),
TotalMetric(consolidate=False),
TotalSwaps(consolidate=False),
SubsMetric(),
]
transpilers = [
QiskitLevel3(coupling_map, syc_basis=True),
Mirage(
coupling_map,
logger=transpile_benchy_logger,
syc_basis=True,
),
]
benchmark = Benchmark(
transpilers=transpilers,
circuit_library=library,
metrics=metrics,
logger=transpile_benchy_logger,
num_runs=5,
)
benchmark.run()
# print(benchmark)
print(benchmark)
benchmark.summary_statistics(transpilers[0], transpilers[1])
from transpile_benchy.render import plot_benchmark
plot_benchmark(
benchmark,
save=1,
legend_show=1,
filename="syc_sl",
color_override=[7, 8],
)
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
from transpile_benchy.metrics.gate_counts import (
DepthMetric,
TotalMetric,
TotalSwaps,
)
from qiskit.circuit.library import iSwapGate
from qiskit.transpiler import CouplingMap
from mirror_gates.pass_managers import Mirage, QiskitLevel3
from mirror_gates.utilities import SubsMetric
from mirror_gates.logging import transpile_benchy_logger
N = 8
coupling_map = CouplingMap.from_line(N)
# coupling_map = CouplingMap.from_heavy_hex(5)
from transpile_benchy.library import CircuitLibrary
library = CircuitLibrary.from_txt("../../../circuits/twolocal.txt")
# XXX set consolidate to False
# this is allowed only because my pass manager will preserve consolidation
# see post_stage, I call fastconsolidate manually
# NOTE: use TotalSwaps to verify baselines have > 0 swaps
# otherwise, there is no room for improvement.
# we can include these if we want to show our methods will still work
# but somewhat trivial since we just append VF2Layout
metrics = [
DepthMetric(consolidate=False),
TotalMetric(consolidate=False),
TotalSwaps(consolidate=False),
SubsMetric(),
]
transpilers = [
QiskitLevel3(coupling_map, cx_basis=True),
Mirage(
coupling_map,
logger=transpile_benchy_logger,
cx_basis=True,
),
QiskitLevel3(coupling_map, cx_basis=False),
Mirage(
coupling_map,
logger=transpile_benchy_logger,
cx_basis=False,
),
]
from transpile_benchy.benchmark import Benchmark
benchmark = Benchmark(
transpilers=transpilers,
circuit_library=library,
metrics=metrics,
logger=transpile_benchy_logger,
num_runs=3,
)
benchmark.run()
# print(benchmark)
print(benchmark)
benchmark.summary_statistics(transpilers[0], transpilers[1])
from transpile_benchy.render import plot_benchmark
plot_benchmark(
benchmark,
save=1,
legend_show=1,
filename="twolocal",
color_override=[6, 9, 0, 3],
fixed_bar_width=3,
)
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
# determine depolarizing error rate
# such that the fidelity of each two-qubit gate is 0.99
# https://qiskit.org/documentation/locale/de_DE/tutorials/simulators/2_device_noise_simulation.html
from mirror_gates.noisy_fidelity import NoiseModelBuilder
from qiskit.transpiler.coupling import CouplingMap
N = 2
coupling_map = CouplingMap.from_line(N)
basis_gates = ["cx", "u", "rxx", "ryy", "id"]
builder = NoiseModelBuilder(basis_gates=basis_gates, coupling_map=coupling_map)
from mirror_gates.noisy_fidelity import T1, T2
p1, p2 = 0, 0.00658
builder.construct_basic_device_model(p_depol1=p1, p_depol2=p2, t1=T1, t2=T2)
noise_model = builder.noise_model
from qiskit_aer import AerSimulator, QasmSimulator
noisy_simulator = AerSimulator(noise_model=noise_model)
simulator = QasmSimulator(method="density_matrix")
from qiskit.circuit.library import SiSwapGate
from qiskit import QuantumCircuit, transpile
qc = QuantumCircuit(2)
qc.append(SiSwapGate(), [0, 1])
qc = transpile(qc, noisy_simulator, basis_gates=basis_gates, coupling_map=coupling_map)
qc.save_density_matrix(list(range(N)))
qc.draw("mpl")
# test fidelity
from qiskit.quantum_info import state_fidelity
perfect_result = simulator.run(qc).result().data()["density_matrix"]
noisy_result = noisy_simulator.run(qc).result().data()["density_matrix"]
fidelity = state_fidelity(perfect_result, noisy_result)
print(fidelity)
import numpy as np
from scipy.optimize import minimize
from qiskit.circuit.library import SiSwapGate
from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator, QasmSimulator
from qiskit.quantum_info import state_fidelity, random_unitary
from mirror_gates.noisy_fidelity import T1, T2, NoiseModelBuilder
from qiskit.transpiler.coupling import CouplingMap
def fidelity_difference_1Q(p1, desired_fidelity):
# Create a 1Q quantum circuit with a random unitary gate each iteration
u = random_unitary(2).data
qc = QuantumCircuit(1)
qc.h(0)
qc.unitary(u, 0)
return get_fidelity_for_p(p1[0], 0, qc, desired_fidelity)
def fidelity_difference_2Q(p2, p1, desired_fidelity):
# 2Q quantum circuit
qc = QuantumCircuit(2)
qc.append(SiSwapGate(), [0, 1])
return get_fidelity_for_p(p1, p2[0], qc, desired_fidelity)
def get_fidelity_for_p(p1, p2, qc, desired_fidelity):
N = qc.num_qubits
coupling_map = CouplingMap.from_line(N)
basis_gates = ["cx", "u", "rxx", "ryy", "id"]
builder = NoiseModelBuilder(basis_gates=basis_gates, coupling_map=coupling_map)
builder.construct_basic_device_model(p_depol1=p1, p_depol2=p2, t1=T1, t2=T2)
noise_model = builder.noise_model
noisy_simulator = AerSimulator(noise_model=noise_model)
simulator = QasmSimulator(method="density_matrix")
qc = transpile(
qc, noisy_simulator, basis_gates=basis_gates, coupling_map=coupling_map
)
qc.save_density_matrix(list(range(N)))
perfect_result = simulator.run(qc).result().data()["density_matrix"]
noisy_result = noisy_simulator.run(qc).result().data()["density_matrix"]
fidelity = state_fidelity(perfect_result, noisy_result)
return abs(fidelity - desired_fidelity)
if __name__ == "__main__":
desired_fidelity_1Q = 0.9995
res_1Q = minimize(
fidelity_difference_1Q,
[0],
args=(desired_fidelity_1Q,),
bounds=[(0, 0.1)],
method="L-BFGS-B",
)
p1_optimal = res_1Q.x[0]
desired_fidelity_2Q = 0.99
res_2Q = minimize(
fidelity_difference_2Q,
[0],
args=(p1_optimal, desired_fidelity_2Q),
bounds=[(0, 0.1)],
method="L-BFGS-B",
)
p2_optimal = res_2Q.x[0]
print(p1_optimal, p2_optimal)
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
from qiskit.transpiler.coupling import CouplingMap
import numpy as np
# Import from Qiskit Aer noise module
from mirror_gates.noisy_fidelity import get_noisy_fidelity
from tqdm import tqdm
from qiskit.circuit.random import random_circuit
import matplotlib.pyplot as plt
import numpy as np
from qiskit.circuit.library import QFT
from qiskit.transpiler import CouplingMap
from mirror_gates.noisy_fidelity import T1, T2
N = 8
# coupling_map = CouplingMap.from_full(N)
coupling_map = CouplingMap.from_line(N)
data1 = []
for i in tqdm(range(2, 100, 4)):
qc = random_circuit(N, i, max_operands=2, measure=False)
fid, duration, transp, expected_fid = get_noisy_fidelity(qc, coupling_map)
data1.append((i, duration, fid)) # Added depth (i) here
# sort by duration
data1 = sorted(data1, key=lambda x: x[1])
depths_sorted, durations_sorted, fidelities_sorted = zip(*data1)
fig, ax1 = plt.subplots()
# Plotting the fidelity vs. duration (main line)
ax1.set_xlabel("Duration")
ax1.set_ylabel("Fidelity")
ax1.plot(durations_sorted, fidelities_sorted, label="Fidelity")
# Setting the secondary x-axis for the depth of the random circuit
ax2 = ax1.twiny()
ax2.set_xlabel("Depth of Random Circuit")
ax2.set_xticks(durations_sorted)
ax2.set_xticklabels(depths_sorted)
n_qubits = N
duration_samples = np.linspace(min(durations_sorted), max(durations_sorted), 500)
decay_factor = [(1 / T1 + 1 / T2) * duration for duration in duration_samples]
single_qubit_fidelity = [np.exp(-factor) for factor in decay_factor]
total_fidelity = [fidelity**n_qubits for fidelity in single_qubit_fidelity]
label_string = r"$\left( e^{(-D/T_1 -D/T_2)} \right)^{N}$"
ax1.plot(duration_samples, total_fidelity, label=label_string, linestyle="--")
ax1.legend()
plt.title("Random Circuit (8-qubits) Fidelity vs Duration with Circuit Depth Reference")
plt.tight_layout() # Adjust layout to prevent overlap
plt.show()
N = 8
coupling_map = CouplingMap.from_full(N)
data2 = []
for i in tqdm(range(2, N + 1)):
qc = QFT(i)
fid, duration, transp = get_noisy_fidelity(qc, coupling_map)
data2.append((i, duration, fid))
# sort by duration
data2 = sorted(data2, key=lambda x: x[1])
sizes_sorted, durations_sorted, fidelities_sorted = zip(*data2)
fig, ax1 = plt.subplots()
# Plotting the fidelity vs. duration (main line)
ax1.set_xlabel("Duration")
ax1.set_ylabel("Fidelity")
ax1.plot(durations_sorted, fidelities_sorted, label="Fidelity")
ax1.tick_params(axis="y")
# Setting the secondary x-axis for the size of QFT
ax2 = ax1.twiny()
ax2.set_xlabel("Size of QFT")
ax2.set_xticks(durations_sorted)
ax2.set_xticklabels(sizes_sorted)
ax2.tick_params(axis="x")
# Adjusting the reference line calculation
unique_sizes = list(set(sizes_sorted))
reference_y_total = []
duration_samples_total = []
for size in unique_sizes:
min_duration = min(
[
duration
for size_curr, duration in zip(sizes_sorted, durations_sorted)
if size_curr == size
]
)
max_duration = max(
[
duration
for size_curr, duration in zip(sizes_sorted, durations_sorted)
if size_curr == size
]
)
duration_samples = np.linspace(min_duration, max_duration, 100)
reference_y = [
np.exp(-size * duration / (T1 + T2)) for duration in duration_samples
]
reference_y_total.extend(reference_y)
duration_samples_total.extend(duration_samples)
ax1.plot(
duration_samples_total,
reference_y_total,
label="e^{-nD / (T_1+T_2)}",
linestyle="--",
)
plt.title("n-QFT Fidelity vs Duration with QFT Size Reference")
plt.tight_layout() # Adjust layout to prevent overlap
plt.show()
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
from qiskit.transpiler.coupling import CouplingMap
from mirror_gates.pass_managers import Mirage, QiskitLevel3
from qiskit.transpiler import PassManager
from mirror_gates.logging import transpile_benchy_logger
from mirror_gates.sqiswap_decomposer import SiSwapDecomposePass
from qiskit.transpiler.passmanager import PassManager
from qiskit.transpiler.passes import Optimize1qGatesDecomposition
N = 3
# coupling_map = FakeQuitoV2().target.build_coupling_map()
# coupling_map = CouplingMap.from_heavy_hex(5)
coupling_map = CouplingMap.from_line(N)
# coupling_map = CouplingMap.from_heavy_hex(5)
# coupling_map = CouplingMap.from_grid(3, 3)
# coupling_map.draw()
cx_basis = False
from transpile_benchy.library import CircuitLibrary
lib = CircuitLibrary(circuit_list=[])
qc = lib.get_circuit("fredkin_n3")
qc = qc.decompose()
# display(qc.draw("mpl", fold=-1))
runner = Mirage(
coupling_map,
cx_basis=cx_basis,
logger=transpile_benchy_logger,
)
routed = runner.run(qc)
if not cx_basis:
decomposer = PassManager()
decomposer.append(SiSwapDecomposePass())
decomposer.append(Optimize1qGatesDecomposition())
mirage_output = decomposer.run(routed)
else:
mirage_output = routed
# mirage_output.draw("mpl", fold=-1)
runner = QiskitLevel3(coupling_map, cx_basis=cx_basis)
routed = runner.run(qc)
if not cx_basis:
decomposer = PassManager()
decomposer.append(SiSwapDecomposePass())
decomposer.append(Optimize1qGatesDecomposition())
qiskit_output = decomposer.run(routed)
else:
qiskit_output = routed
# qiskit_output.draw("mpl", fold=-1)
from mirror_gates.noisy_fidelity import get_noisy_fidelity
a, b, c, d = get_noisy_fidelity(qiskit_output, coupling_map)
print(f"Fidelity: {a:.3f}, Duration: {b:.3f}")
# display(c.draw("mpl", fold=-1))
a, b, c, d = get_noisy_fidelity(mirage_output, coupling_map)
print(f"Fidelity: {a:.3f}, Duration: {b:.3f}")
# display(c.draw("mpl", fold=-1))
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
from qiskit.transpiler.coupling import CouplingMap
from mirror_gates.pass_managers import Mirage, QiskitLevel3
from transpile_benchy.metrics.gate_counts import (
DepthMetric,
TotalMetric,
TotalSwaps,
)
from qiskit.transpiler import PassManager
import numpy as np
from mirror_gates.logging import transpile_benchy_logger
from mirror_gates.sqiswap_decomposer import SiSwapDecomposePass
from qiskit.transpiler.passmanager import PassManager
from qiskit import Aer, transpile
from qiskit.quantum_info import state_fidelity
from qiskit_aer import AerSimulator
# Import from Qiskit Aer noise module
from qiskit_aer.noise import (
NoiseModel,
QuantumError,
ReadoutError,
pauli_error,
depolarizing_error,
thermal_relaxation_error,
RelaxationNoisePass,
)
from qiskit.circuit import Delay
from qiskit.transpiler.passes import PadDelay, ASAPSchedule
from qiskit import QuantumCircuit
from transpile_benchy.metrics.gate_counts import (
DepthMetric,
TotalMetric,
TotalSwaps,
)
from qiskit.circuit.library import iSwapGate
from qiskit.transpiler import CouplingMap
from mirror_gates.pass_managers import Mirage, QiskitLevel3
from mirror_gates.utilities import SubsMetric
from mirror_gates.logging import transpile_benchy_logger
N = 8
coupling_map = CouplingMap.from_line(8)
from transpile_benchy.library import CircuitLibrary
library = CircuitLibrary.from_txt("../../circuits/small_circuits.txt")
# new metric for simulating fidelity
from transpile_benchy.metrics.abc_metrics import MetricInterface
from qiskit.transpiler.basepasses import AnalysisPass
from mirror_gates.noisy_fidelity import get_noisy_fidelity
from qiskit.converters import dag_to_circuit
from mirror_gates.utilities import DoNothing
# TODO: we could move gate times and T1,T2 to be parameters
# currently, are just hardcoded at the top of the file
class FidelityAnalysis(AnalysisPass):
def __init__(self, coupling_map, sqrt_iswap_basis):
super().__init__()
self.coupling_map = coupling_map
self.sqrt_iswap_basis = sqrt_iswap_basis
def run(self, dag):
qc = dag_to_circuit(dag)
fid, duration, _, expected_fid = get_noisy_fidelity(
qc, self.coupling_map, sqrt_iswap_basis=self.sqrt_iswap_basis
)
self.property_set["noisy_fidelity"] = fid
self.property_set["scheduled_duration"] = duration
self.property_set["expected_fidelity"] = expected_fid
return dag
class FidelityMetric(MetricInterface):
"""Calculate the noisy simulated fidelity."""
def __init__(self, coupling_map):
"""Initialize the metric."""
super().__init__(name="noisy_fidelity", pretty_name="Noisy Fidelity")
self.use_geometric_mean = True
self.coupling_map = coupling_map
def _construct_pass(self, basis_gate):
"""Return the pass associated with this metric."""
sqrt_iswap_basis = basis_gate == iSwapGate().power(1 / 2)
return FidelityAnalysis(self.coupling_map, sqrt_iswap_basis)
class DurationMetric(MetricInterface):
"""Calculate the noisy simulated fidelity."""
def __init__(self):
"""Initialize the metric."""
super().__init__(name="scheduled_duration", pretty_name="Circuit Duration (ns)")
self.use_geometric_mean = True
def _construct_pass(self):
"""Return the pass associated with this metric."""
return DoNothing()
class ExpectedFidelityMetric(MetricInterface):
"""Calculate the noisy simulated fidelity."""
def __init__(self):
"""Initialize the metric."""
super().__init__(name="expected_fidelity", pretty_name="Expected Fidelity")
self.use_geometric_mean = True
def _construct_pass(self):
"""Return the pass associated with this metric."""
return DoNothing()
# XXX set consolidate to False
# this is allowed only because my pass manager will preserve consolidation
# see post_stage, I call fastconsolidate manually
# NOTE: use TotalSwaps to verify baselines have > 0 swaps
# otherwise, there is no room for improvement.
# we can include these if we want to show our methods will still work
# but somewhat trivial since we just append VF2Layout
metrics = [
DepthMetric(consolidate=False),
TotalMetric(consolidate=False),
TotalSwaps(consolidate=False),
SubsMetric(),
FidelityMetric(coupling_map),
DurationMetric(),
ExpectedFidelityMetric(),
]
transpilers = [
# QiskitLevel3(coupling_map, cx_basis=True),
# Mirage(
# coupling_map,
# logger=transpile_benchy_logger,
# cx_basis=True,
# ),
QiskitLevel3(coupling_map, cx_basis=False),
Mirage(
coupling_map,
logger=transpile_benchy_logger,
cx_basis=False,
),
]
from transpile_benchy.benchmark import Benchmark
benchmark = Benchmark(
transpilers=transpilers,
circuit_library=library,
metrics=metrics,
logger=transpile_benchy_logger,
num_runs=1,
)
benchmark.run()
print(benchmark)
benchmark.summary_statistics(transpilers[0], transpilers[1])
from transpile_benchy.render import plot_benchmark
plot_benchmark(
benchmark,
save=1,
legend_show=1,
filename="twolocal",
color_override=[0, 3],
)
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
from mirror_gates.noisy_fidelity import heuristic_fidelity
import numpy as np
import matplotlib.pyplot as plt
import LovelyPlots.utils as lp # noqa: F401
import matplotlib.pyplot as plt
import numpy as np
import scienceplots # noqa: F401
# Constants
N = 16
start_value = 0
end_value = 10_000
num_points = 1000
# Generate Qiskit data
qiskit_durations = np.linspace(
start_value, end_value, num_points
) # Define start_value, end_value, and num_points as per your data
qiskit_fidelities = heuristic_fidelity(N, qiskit_durations)
# Generate MIRAGE data (shifted by depth reduction)
mirage_durations_hh = qiskit_durations * (1 - 0.3119) # 31.19% reduction for heavy-hex
mirage_fidelities_hh = heuristic_fidelity(N, mirage_durations_hh)
with plt.style.context(["ieee"]):
# Plot Qiskit data
plt.plot(qiskit_durations, qiskit_fidelities, label="Qiskit", color="blue")
# Plot MIRAGE data using Qiskit's durations as the x-axis
plt.plot(
qiskit_durations,
mirage_fidelities_hh,
label="MIRAGE (Heavy-Hex)",
color="green",
)
# Add labels, title, legend, etc.
plt.xlabel("Baseline Circuit Duration (Qiskit)")
plt.ylabel("Fidelity")
plt.title("Fidelity vs. Baseline Circuit Duration")
plt.legend()
plt.grid(True)
# Show the plot
plt.show()
circuits = [
"ae_n16",
"bigadder_n18",
"knn_n25",
"multiplier_n15",
"portfolioqaoa_n16",
"qec9xz_n17",
"qft_n18",
"qftentangled_n16",
"qpeexact_n16",
"qram_n20",
"sat_n11",
"seca_n11",
"swap_test_n25",
]
# Values taken from outputs of previous runs
# experiment 1
sqrtiswap_mirage_hh = [
71.369,
103.163,
70.141,
168.167,
113.540,
21.699,
58.570,
51.719,
70.866,
81.952,
225.484,
37.187,
70.141,
]
sqrtiswap_qiskit_hh = [
122.362,
131.494,
79.406,
195.946,
250.689,
30.773,
108.342,
120.588,
167.700,
94.756,
286.870,
49.257,
79.700,
]
# experiment 2
sqrtiswap_mirage_sl = [
67.312,
87.793,
64.635,
147.498,
90.500,
15.751,
52.341,
52.662,
66.810,
76.280,
209.375,
33.892,
64.635,
]
sqrtiswap_qiskit_sl = [
120.638,
109.040,
69.573,
175.528,
236.824,
22.211,
108.948,
95.484,
139.716,
83.561,
235.682,
49.288,
69.392,
]
# experiment 3
cnot_mirage_hh = [
151.813,
158.463,
126.188,
303.863,
181.000,
37.859,
121.184,
97.834,
150.797,
135.909,
356.949,
55.177,
126.188,
]
cnot_qiskit_hh = [
261.086,
192.257,
131.488,
283.823,
431.180,
42.951,
215.338,
223.833,
325.028,
148.078,
440.340,
69.558,
130.761,
]
# experiment 4
syc_mirage_sl = [
136.397,
194.039,
148.365,
336.419,
181.000,
41.089,
100.184,
101.762,
136.397,
155.747,
458.447,
76.565,
148.365,
]
syc_qiskit_sl = [
213.839,
217.868,
143.501,
365.007,
398.886,
49.669,
209.958,
219.996,
271.189,
163.659,
483.290,
96.168,
143.910,
]
# sort so circuits appear as same order they do in the paper
sorted_circuits = [
"qec9xz_n17",
"seca_n11",
"knn_n25",
"swap_test_n25",
"qram_n20",
"qft_n18",
"qftentangled_n16",
"ae_n16",
"bigadder_n18",
"qpeexact_n16",
"multiplier_n15",
"portfolioqaoa_n16",
"sat_n11",
]
# Create a dictionary with circuits as keys and their index in sorted_circuits as values
index_map = {circuit: index for index, circuit in enumerate(sorted_circuits)}
# Sort all your lists based on the order in sorted_circuits
sqrtiswap_mirage_hh = [
x
for _, x in sorted(
zip(circuits, sqrtiswap_mirage_hh), key=lambda pair: index_map[pair[0]]
)
]
sqrtiswap_qiskit_hh = [
x
for _, x in sorted(
zip(circuits, sqrtiswap_qiskit_hh), key=lambda pair: index_map[pair[0]]
)
]
sqrtiswap_mirage_sl = [
x
for _, x in sorted(
zip(circuits, sqrtiswap_mirage_sl), key=lambda pair: index_map[pair[0]]
)
]
sqrtiswap_qiskit_sl = [
x
for _, x in sorted(
zip(circuits, sqrtiswap_qiskit_sl), key=lambda pair: index_map[pair[0]]
)
]
cnot_mirage_hh = [
x
for _, x in sorted(
zip(circuits, cnot_mirage_hh), key=lambda pair: index_map[pair[0]]
)
]
cnot_qiskit_hh = [
x
for _, x in sorted(
zip(circuits, cnot_qiskit_hh), key=lambda pair: index_map[pair[0]]
)
]
syc_mirage_sl = [
x
for _, x in sorted(
zip(circuits, syc_mirage_sl), key=lambda pair: index_map[pair[0]]
)
]
syc_qiskit_sl = [
x
for _, x in sorted(
zip(circuits, syc_qiskit_sl), key=lambda pair: index_map[pair[0]]
)
]
circuits = sorted_circuits
import matplotlib.pyplot as plt
import numpy as np
# Function to convert depth to duration
def depth_to_duration(depth, gate_time_1q=25, gate_time_2q=100):
return (gate_time_1q * depth + gate_time_2q * depth) + gate_time_1q
def hf(n, d):
return heuristic_fidelity(n, d, T1=1600_000, T2=1600_000)
# Calculate durations for all experiments
durations_mirage_hh = [depth_to_duration(d) for d in sqrtiswap_mirage_hh]
durations_qiskit_hh = [depth_to_duration(d) for d in sqrtiswap_qiskit_hh]
durations_mirage_sl = [depth_to_duration(d) for d in sqrtiswap_mirage_sl]
durations_qiskit_sl = [depth_to_duration(d) for d in sqrtiswap_qiskit_sl]
durations_cnot_mirage_hh = [depth_to_duration(d) for d in cnot_mirage_hh]
durations_cnot_qiskit_hh = [depth_to_duration(d) for d in cnot_qiskit_hh]
durations_syc_mirage_sl = [depth_to_duration(d) for d in syc_mirage_sl]
durations_syc_qiskit_sl = [depth_to_duration(d) for d in syc_qiskit_sl]
# Calculate fidelities for all experiments
fidelities_mirage_hh = [
hf(int(circuit.split("_")[-1][1:]), d)
for circuit, d in zip(circuits, durations_mirage_hh)
]
fidelities_qiskit_hh = [
hf(int(circuit.split("_")[-1][1:]), d)
for circuit, d in zip(circuits, durations_qiskit_hh)
]
fidelities_mirage_sl = [
hf(int(circuit.split("_")[-1][1:]), d)
for circuit, d in zip(circuits, durations_mirage_sl)
]
fidelities_qiskit_sl = [
hf(int(circuit.split("_")[-1][1:]), d)
for circuit, d in zip(circuits, durations_qiskit_sl)
]
fidelities_cnot_mirage_hh = [
hf(int(circuit.split("_")[-1][1:]), d)
for circuit, d in zip(circuits, durations_cnot_mirage_hh)
]
fidelities_cnot_qiskit_hh = [
hf(int(circuit.split("_")[-1][1:]), d)
for circuit, d in zip(circuits, durations_cnot_qiskit_hh)
]
fidelities_syc_mirage_sl = [
hf(int(circuit.split("_")[-1][1:]), d)
for circuit, d in zip(circuits, durations_syc_mirage_sl)
]
fidelities_syc_qiskit_sl = [
hf(int(circuit.split("_")[-1][1:]), d)
for circuit, d in zip(circuits, durations_syc_qiskit_sl)
]
# Calculate relative changes in fidelity for all experiments
relative_changes_hh = [
(fm - fq) / fq for fm, fq in zip(fidelities_mirage_hh, fidelities_qiskit_hh)
]
relative_changes_sl = [
(fm - fq) / fq for fm, fq in zip(fidelities_mirage_sl, fidelities_qiskit_sl)
]
relative_changes_cnot_hh = [
(fm - fq) / fq
for fm, fq in zip(fidelities_cnot_mirage_hh, fidelities_cnot_qiskit_hh)
]
relative_changes_syc_sl = [
(fm - fq) / fq for fm, fq in zip(fidelities_syc_mirage_sl, fidelities_syc_qiskit_sl)
]
relative_changes_hh = [
(fm - fq) for fm, fq in zip(fidelities_mirage_hh, fidelities_qiskit_hh)
]
relative_changes_sl = [
(fm - fq) for fm, fq in zip(fidelities_mirage_sl, fidelities_qiskit_sl)
]
relative_changes_cnot_hh = [
(fm - fq) for fm, fq in zip(fidelities_cnot_mirage_hh, fidelities_cnot_qiskit_hh)
]
relative_changes_syc_sl = [
(fm - fq) for fm, fq in zip(fidelities_syc_mirage_sl, fidelities_syc_qiskit_sl)
]
# # Zip all data together using circuits as the key
# data = list(
# zip(
# circuits,
# relative_changes_hh,
# relative_changes_sl,
# relative_changes_cnot_hh,
# relative_changes_syc_sl,
# )
# )
# # Sort the data by the values of sqrtiswap_mirage_hh (Experiment 1)
# sorted_data = sorted(data, key=lambda x: x[1])
# # Unzip the sorted data back into individual lists
# (
# circuits,
# relative_changes_hh,
# relative_changes_sl,
# relative_changes_cnot_hh,
# relative_changes_syc_sl,
# ) = map(list, zip(*sorted_data))
# arithmetic mean
relative_changes_hh.append(np.mean(relative_changes_hh))
relative_changes_sl.append(np.mean(relative_changes_sl))
relative_changes_cnot_hh.append(np.mean(relative_changes_cnot_hh))
relative_changes_syc_sl.append(np.mean(relative_changes_syc_sl))
circuits.append("Average")
from typing import List, Tuple
import LovelyPlots.utils as lp # noqa: F401
import matplotlib.pyplot as plt
import numpy as np
import scienceplots # noqa: F401
from matplotlib.colors import ListedColormap
from matplotlib.figure import Axes, Figure
from matplotlib.ticker import MaxNLocator
from transpile_benchy.benchmark import Benchmark
from transpile_benchy.metrics.abc_metrics import MetricInterface
def _initialize_plot(legend_show: bool) -> Tuple[Figure, Axes]:
"""Initialize the plot and returns the fig and ax."""
ref_size = 1.25 # Assume need .4 for legend
legend_offset = 0.5
if legend_show:
fig, axs = plt.subplots(
2,
figsize=(
3.5,
ref_size + legend_offset,
), # 2 inch for plot + 1 inch for legend
sharex=True,
gridspec_kw={
"height_ratios": [legend_offset, ref_size + legend_offset],
"hspace": 0.01,
}, # 1:2 ratio for legend:plot
)
ax = axs[1]
else:
fig, ax = plt.subplots(figsize=(3.5, ref_size)) # Just 2 inch for the plot
return fig, ax
names = [
"HH-$\sqrt{\mathrm{iSWAP}}$",
"SL-$\sqrt{\mathrm{iSWAP}}$",
"HH-$\mathrm{CNOT}$",
"SL-$\mathrm{SYC}$",
]
cmap = plt.cm.get_cmap("tab10", 10)
plt.rc("legend", fontsize=8)
plt.rc("axes", labelsize=8)
with plt.style.context(["ieee"]):
# Set up the figure and axes
fig, ax = _initialize_plot(True)
bar_width = 0.2
index = np.arange(len(circuits))
# Add bars for each experiment using the relative changes
ax.bar(
index - 1.5 * bar_width,
relative_changes_hh,
width=bar_width,
label=r"HH-$\sqrt{\texttt{iSWAP}}$",
color=cmap(0),
)
ax.bar(
index - 0.5 * bar_width,
relative_changes_sl,
width=bar_width,
label=r"SL-$\sqrt{\texttt{iSWAP}}$",
# color="red",
color=cmap(1),
)
ax.bar(
index + 0.5 * bar_width,
relative_changes_cnot_hh,
width=bar_width,
label=r"HH-$\texttt{CNOT}$",
# color="green",
color=cmap(2),
)
ax.bar(
index + 1.5 * bar_width,
relative_changes_syc_sl,
width=bar_width,
label=r"SL-$\texttt{SYC}$",
# color="orange",
color=cmap(3),
)
# Add labels, title, and legend
ax.set_ylabel("Absolute Fidelity Change")
ax.set_xticks(index)
ax.set_xticklabels(
circuits,
rotation=30,
ha="right",
fontsize=7,
)
# ax.set_yscale("log")
ax.get_yaxis().set_major_formatter(plt.ScalarFormatter())
# we need more ticks on y-axis
ax.yaxis.set_major_locator(MaxNLocator(5))
ax.set_yticklabels(["{:.0f}%".format(val * 100) for val in ax.get_yticks()])
for j, name in enumerate(names):
fig.axes[0].bar(0, 0, color=cmap(j), label=f"{name}")
fig.axes[0].legend(
loc="upper center",
ncol=2,
fontsize=8,
frameon=False,
bbox_to_anchor=(0.5, 1.5), # 1.10
)
fig.axes[0].axis("off")
# show grid
# fig.axes[1].grid(True, axis="y", which="major", linestyle="--", alpha=0.5)
# Show the plot
plt.tight_layout()
fig
fig.savefig(
"test.pdf",
bbox_inches="tight",
pad_inches=0,
)
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
from qiskit.circuit.library import SwapGate, CXGate
from qiskit.quantum_info import random_unitary
from qiskit.extensions import UnitaryGate
from monodromy.haar import expected_cost
from qiskit.circuit.library import iSwapGate, XXPlusYYGate, CXGate
import numpy as np
from monodromy.render import gates_to_coverage_plot
from monodromy.haar import expected_cost
from monodromy.coverage import coverage_lookup_cost
import h5py
import json
import matplotlib.pyplot as plt
from scipy import stats
from collections import Counter
import scienceplots
import LovelyPlots.utils as lp
from tqdm import tqdm
# %matplotlib widget
class ErrorModel:
"""Use exponential decay error model.
Define fidelity model as some function of (time) cost.
"""
def __init__(self, unit_fidelity=0.99):
"""Unit fidelity is the fidelity of operation with unit cost 1.0
NOTE: simple convention is that CX, iSWAP have unit cost 1.0, then
sqrt(CX) and sqrt(iSWAP) have unit cost 0.5, etc.
"""
assert 0 <= unit_fidelity and unit_fidelity <= 1
self.unit_fidelity = unit_fidelity
self.normalized_lifetime = -1.0 / np.log(unit_fidelity)
def fidelity(self, cost):
"""Convert (time) cost to fidelity"""
return np.exp(-cost / self.normalized_lifetime)
def infidelity(self, cost):
"""Convert (time) cost to infidelity"""
return 1 - self.fidelity(cost)
# ErrorModel(0.99).fidelity(1.5)
indx = 2.0
U = iSwapGate().power(1 / indx)
safe_basis_str = f"sqrt_{indx}_iswap"
basis_str = r"$\sqrt[" + f"{indx}" + r"]{\texttt{iSWAP}}$"
basis_cost = 1.0 / indx
unit_fidelity = 0.99
affine_error_model = ErrorModel(unit_fidelity=unit_fidelity)
coverage_1 = gates_to_coverage_plot(U, costs=[basis_cost])
no_mirror_haar_exact = expected_cost(coverage_1)
print(no_mirror_haar_exact)
average_fidelity = affine_error_model.fidelity(no_mirror_haar_exact)
print(average_fidelity)
coverage_2 = gates_to_coverage_plot(U, SwapGate(), costs=[basis_cost, 0])
mirror_haar_exact = expected_cost(coverage_2)
print(mirror_haar_exact)
average_fidelity = affine_error_model.fidelity(mirror_haar_exact)
print(average_fidelity)
def data_collection(coverage_set, error_model, allow_approx, N=1000, save_to=None):
"""Collects data for Haar score calculations.
Args:
coverage_set (List[CircuitPolytopeData]): List of coverage sets.
error_model (ErrorModel): Error model to use for cost calculation.
allow_approx (bool): Whether to allow approximate decomposition.
N (int, optional): Number of iterations. Defaults to 1000.
check_every (int, optional): Check the running average every `check_every` iterations. Defaults to 100.
save_to (str, optional): Path to the HDF5 file to save the data. If None, data won't be saved. Defaults to None.
Returns:
dict: Collected data.
"""
costs = []
running_avgs = []
conf_intervals = []
fidelities = []
progress_bar = tqdm(total=N, desc="Starting")
for _ in range(N):
target = UnitaryGate(random_unitary(4))
# NOTE fidelity here is circuit cost and decomposition fidelity combined
cost, fidelity = coverage_lookup_cost(
coverage_set, target, error_model, allow_approx=allow_approx
)
costs.append(cost)
fidelities.append(fidelity)
running_avgs.append(np.mean(costs))
if len(np.unique(costs)) > 1:
confidence = 0.95
conf_interval = stats.t.interval(
confidence,
len(costs) - 1,
loc=np.mean(costs),
scale=stats.sem(costs),
)
conf_intervals.append(conf_interval)
else:
conf_intervals.append((np.nan, np.nan))
if len(np.unique(costs)) > 1:
progress_bar.set_description(
f"Current average cost: {running_avgs[-1]:.4f}, Std. Error: {stats.sem(costs):.4f}"
)
else:
progress_bar.set_description(
f"Current average cost: {running_avgs[-1]:.4f}"
)
progress_bar.update()
progress_bar.close()
# print frequency of each cost
print(Counter(costs))
print("Monte Carlo: Haar score", np.mean(costs))
# print average fidelity
print("Monte Carlo: Average fidelity", np.mean(fidelities))
data = {
"costs": costs,
"running_avgs": running_avgs,
"conf_intervals": conf_intervals,
"fidelities": fidelities,
}
if save_to is not None:
with h5py.File(save_to, "w") as f:
for key, value in data.items():
f.create_dataset(key, data=json.dumps(value))
return data
coverage_sets = [coverage_1, coverage_1, coverage_2, coverage_2]
allow_approx = [False, True, False, True]
mirror_flags = ["no_mirror", "no_mirror", "mirror", "mirror"]
labels = [
"mirror_data/"
+ rf"{mirror_flag}-{safe_basis_str}-approx{approx_bool}-{affine_error_model.unit_fidelity}"
for mirror_flag, approx_bool in zip(mirror_flags, allow_approx)
]
# # NOTE uncomment if want to actually run the data collection
# for coverage_set, approx_bool, label in zip(coverage_sets, allow_approx, labels):
# print(f"Running: {label}")
# data_collection(
# coverage_set, affine_error_model, approx_bool, save_to=label + ".hdf5"
# )
# print("\n")
def plot_data(data, labels, pretty_labels, exact_convergence=None):
"""Plots running averages and confidence intervals from data.
Args:
data (List[dict]): List of dictionaries containing data from each run.
labels (List[str]): List of labels for each data set (used for exact_convergence matching).
pretty_labels (List[str]): List of 'pretty' labels for each data set (used for plotting).
exact_convergence (dict, optional): Dictionary containing values of exact convergence for each data set. If None, it won't be plotted. Defaults to None.
"""
assert len(labels) == len(
pretty_labels
), "Labels and pretty_labels must have the same length."
with plt.style.context(["ieee", "science"]):
plt.rc("text", usetex=True)
for d, label, pretty_label in zip(data, labels, pretty_labels):
running_avgs = d["running_avgs"]
conf_intervals = d["conf_intervals"]
plt.plot(running_avgs, label=f"{pretty_label}")
# plt.fill_between(
# range(len(running_avgs)),
# [ci[0] for ci in conf_intervals],
# [ci[1] for ci in conf_intervals],
# alpha=0.1,
# )
if exact_convergence and label in exact_convergence:
plt.axhline(
y=exact_convergence[label],
color="k",
linestyle="--",
alpha=0.5,
# label=f"Exact Convergence - {pretty_label}",
)
# # Extract basis gate name and error value from the first label
# directory, label_info = labels[0].split('/')
# basis_gate, name, error_value = label_info.split('-')
# Use the extracted information to build the title
# plt.title(
# f"Haar Score vs Iteration" #, {basis_str}, unit fidelity {unit_fidelity}"
# )
plt.xlabel("Iteration")
plt.ylabel("Haar Score")
# use log scales
# plt.yscale("log")
plt.xscale("log")
# plt.legend()
# put legend above plot in 2 columns
plt.legend(loc="upper center", bbox_to_anchor=(0.5, 1.26), ncol=2)
# shrink figure height
plt.gcf().set_size_inches(3.5, 1.85)
fig = plt.gcf()
plt.show()
# return fig so can be saved
return fig
def load_hdf5_data(filename):
"""Load data from an HDF5 file.
Args:
filename (str): Path to the HDF5 file.
Returns:
dict: Data loaded from the file.
"""
with h5py.File(filename, "r") as f:
data = {key: json.loads(value[()]) for key, value in f.items()}
return data
data = [load_hdf5_data(f"{label}.hdf5") for label in labels]
exact_convergence = {
labels[0]: no_mirror_haar_exact,
labels[2]: mirror_haar_exact,
} # Replace with actual values
pretty_labels = [
"Exact",
"Approximate",
"Exact + Mirrors",
"Approximate + Mirrors",
]
fig = plot_data(data, labels, pretty_labels, exact_convergence=exact_convergence)
fig.savefig(
"weyl_mirror_sqrt[2].pdf",
bbox_inches="tight",
pad_inches=0,
)
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
# !pip uninstall -y matplotlib && pip install matplotlib==3.7.2
from qiskit.circuit.library import SwapGate, CXGate
from qiskit.quantum_info import random_unitary
from qiskit.extensions import UnitaryGate
from monodromy.haar import expected_cost
from qiskit.circuit.library import iSwapGate, XXPlusYYGate, CXGate
import numpy as np
from monodromy.render import gates_to_coverage_plot
from monodromy.haar import expected_cost
from monodromy.coverage import coverage_lookup_cost
import h5py
import json
import matplotlib.pyplot as plt
from scipy import stats
from collections import Counter
import scienceplots
import LovelyPlots.utils as lp
from tqdm import tqdm
# %matplotlib widget
from qiskit import QuantumCircuit
from qiskit.circuit.library import CZGate
from qiskit.quantum_info.operators import Operator
from qiskit.circuit import Gate
from monodromy.haar import gates_to_haar
from qiskit.circuit.library import CXGate, iSwapGate
import numpy as np
qc = QuantumCircuit(2)
qc.append(iSwapGate().power(-1), [0, 1])
qc.append(CZGate().power(1 / 6), [0, 1])
syc = Operator(qc)
syc.name = "syc"
syc.params = []
print(gates_to_haar(syc))
from monodromy.render import gates_to_coverage_plot
gates_to_coverage_plot(syc, overlap=False)
class ErrorModel:
"""Use exponential decay error model.
Define fidelity model as some function of (time) cost.
"""
def __init__(self, unit_fidelity=0.99):
"""Unit fidelity is the fidelity of operation with unit cost 1.0
NOTE: simple convention is that CX, iSWAP have unit cost 1.0, then
sqrt(CX) and sqrt(iSWAP) have unit cost 0.5, etc.
"""
assert 0 <= unit_fidelity and unit_fidelity <= 1
self.unit_fidelity = unit_fidelity
self.normalized_lifetime = -1.0 / np.log(unit_fidelity)
def fidelity(self, cost):
"""Convert (time) cost to fidelity"""
return np.exp(-cost / self.normalized_lifetime)
def infidelity(self, cost):
"""Convert (time) cost to infidelity"""
return 1 - self.fidelity(cost)
# ErrorModel(0.99).fidelity(1.5)
U = syc
safe_basis_str = "syc"
basis_str = "syc"
basis_cost = 1.0
unit_fidelity = 0.99
affine_error_model = ErrorModel(unit_fidelity=unit_fidelity)
coverage_1 = gates_to_coverage_plot(U, costs=[basis_cost])
no_mirror_haar_exact = expected_cost(coverage_1)
print(no_mirror_haar_exact)
average_fidelity = affine_error_model.fidelity(no_mirror_haar_exact)
print(average_fidelity)
coverage_2 = gates_to_coverage_plot(U, SwapGate(), costs=[basis_cost, 0])
mirror_haar_exact = expected_cost(coverage_2)
print(mirror_haar_exact)
average_fidelity = affine_error_model.fidelity(mirror_haar_exact)
print(average_fidelity)
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
from mirror_gates.sycamore import syc
from transpile_benchy.utilities.numerical_decomp import (
Advanced2QDecomposer,
BasicDecomposer,
)
from qiskit import QuantumCircuit
from qiskit.quantum_info import Operator
from qiskit.circuit.parameter import Parameter
from qiskit.circuit.library import CXGate, SwapGate, CZGate, iSwapGate
decomposer = BasicDecomposer(basis_gates=[(syc, 2)])
from qiskit.transpiler.passes import Optimize1qGates
from qiskit.transpiler import PassManager
ansatz = QuantumCircuit(2)
ansatz.u(Parameter("p000"), Parameter("p001"), Parameter("p002"), 0)
ansatz.u(Parameter("q000"), Parameter("q001"), Parameter("q002"), 1)
ansatz.append(iSwapGate().power(-1), [0, 1])
ansatz.append(CZGate().power(1 / 6), [0, 1])
ansatz.u(Parameter("p003"), Parameter("p004"), Parameter("p005"), 0)
ansatz.u(Parameter("q003"), Parameter("q004"), Parameter("q005"), 1)
ansatz.append(iSwapGate().power(-1), [0, 1])
ansatz.append(CZGate().power(1 / 6), [0, 1])
ansatz.u(Parameter("p006"), Parameter("p007"), Parameter("p008"), 0)
ansatz.u(Parameter("q006"), Parameter("q007"), Parameter("q008"), 1)
ret = decomposer.decompose_from_ansatz(target=CXGate(), ansatz=ansatz)
pm = PassManager()
pm.append(Optimize1qGates())
ret = pm.run(ret)
ret.draw("mpl")
ret.qasm(filename="d02_syc_cnot.qasm")
ansatz = QuantumCircuit(2)
ansatz.u(Parameter("p000"), Parameter("p001"), Parameter("p002"), 0)
ansatz.u(Parameter("q000"), Parameter("q001"), Parameter("q002"), 1)
ansatz.append(iSwapGate().power(-1), [0, 1])
ansatz.append(CZGate().power(1 / 6), [0, 1])
ansatz.u(Parameter("p003"), Parameter("p004"), Parameter("p005"), 0)
ansatz.u(Parameter("q003"), Parameter("q004"), Parameter("q005"), 1)
ansatz.append(iSwapGate().power(-1), [0, 1])
ansatz.append(CZGate().power(1 / 6), [0, 1])
ansatz.u(Parameter("p006"), Parameter("p007"), Parameter("p008"), 0)
ansatz.u(Parameter("q006"), Parameter("q007"), Parameter("q008"), 1)
ansatz.append(iSwapGate().power(-1), [0, 1])
ansatz.append(CZGate().power(1 / 6), [0, 1])
ansatz.u(Parameter("p009"), Parameter("p010"), Parameter("p011"), 0)
ansatz.u(Parameter("q009"), Parameter("q010"), Parameter("q011"), 1)
ret = decomposer.decompose_from_ansatz(target=SwapGate(), ansatz=ansatz)
pm.append(Optimize1qGates())
ret = pm.run(ret)
ret.draw("mpl")
ret.qasm(filename="d02_syc_swap.qasm")
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
from qiskit.circuit.library import SwapGate, iSwapGate
from qiskit import QuantumCircuit
from qiskit.quantum_info import random_unitary
from weylchamber import g1g2g3, c1c2c3, WeylChamber
from qiskit.quantum_info import Operator
import matplotlib.pyplot as plt
N = 500
# generate (a,b,c) ->swap-> (a',b',c') pairs
a_pairs, b_pairs, c_pairs = [], [], []
for _ in range(N):
U = random_unitary(4).data
U_prime = SwapGate().to_matrix() @ U
abc = g1g2g3(U)
abc_prime = g1g2g3(U_prime)
a_pairs.append((abc[0], abc_prime[0]))
b_pairs.append((abc[1], abc_prime[1]))
c_pairs.append((abc[2], abc_prime[2]))
# plot
fig, axes = plt.subplots(1, 3, figsize=(15, 5))
for i, (pairs, label) in enumerate(zip([a_pairs, b_pairs, c_pairs], ["a", "b", "c"])):
axes[i].scatter(*zip(*pairs), s=1)
axes[i].set_xlabel(f"{label}")
axes[i].set_ylabel(f"{label}'")
axes[i].set_title(f"{label} vs {label}'")
plt.show()
# experiment with random scattering
N = 400
# generate U + SWAP + U + SWAP
U = iSwapGate().power(3 / 4)
coords = []
for _ in range(N):
qc = QuantumCircuit(2)
qc.append(U, [0, 1])
# random 1Q gate
qc.append(random_unitary(2).to_instruction(), [0])
qc.append(random_unitary(2).to_instruction(), [1])
qc.append(U, [0, 1])
qc.append(random_unitary(2).to_instruction(), [0])
qc.append(random_unitary(2).to_instruction(), [1])
qc.swap(0, 1)
# get coordinates
coords.append(c1c2c3(Operator(qc).data))
# plot
w = WeylChamber()
for c in coords:
w.add_point(*c)
w.plot()
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
"""Test the CNS transformation on a circuit DAG."""
# from qiskit import QuantumCircuit
# from qiskit.converters import circuit_to_dag, dag_to_circuit
# from qiskit.quantum_info import Operator
# from mirror_gates.cns_transform import cns_transform
# def generate_circuit():
# """Generate a circuit to test the CNS transformation."""
# qc = QuantumCircuit(3)
# qc.t(2)
# qc.iswap(0, 2)
# qc.s(0)
# qc.h(1)
# qc.swap(0, 1)
# qc.h(1)
# qc.cx(1, 2)
# qc.t(1)
# qc.rzz(0.5, 2, 0)
# qc.cx(0, 2)
# qc.h(1)
# qc.h(2)
# return qc
# def test_single_nodecns_transform():
# """Test the CNS transformation on a single node."""
# # Generate the original circuit and calculate its operator
# qc_original = generate_circuit()
# dag_original = circuit_to_dag(qc_original)
# op_original = Operator(qc_original)
# # Identify the node to be transformed
# node_to_transform = dag_original.two_qubit_ops()[0]
# # Apply the CNS transformation
# dag_transformed = cns_transform(
# dag_original, node_to_transform, preserve_layout=True
# )
# qc_transformed = dag_to_circuit(dag_transformed)
# # Test equivalence of original and transformed circuits
# assert op_original.equiv(Operator(qc_transformed))
# def test_multiple_nodescns_transform():
# """Test the CNS transformation on multiple nodes."""
# # Generate the original circuit and calculate its operator
# qc_original = generate_circuit()
# dag_original = circuit_to_dag(qc_original)
# op_original = Operator(qc_original)
# # Identify the nodes to be transformed
# # should test the function works if passed neither a CX nor an iSWAP
# nodes_to_transform = dag_original.op_nodes()
# # Apply the CNS transformation
# dag_transformed = cns_transform(
# dag_original, *nodes_to_transform, preserve_layout=True
# )
# qc_transformed = dag_to_circuit(dag_transformed)
# # Test equivalence of original and transformed circuits
# assert op_original.equiv(Operator(qc_transformed))
# if __name__ == "__main__":
# test_single_nodecns_transform()
# test_multiple_nodescns_transform()
|
https://github.com/msramalho/grover-max-cut
|
msramalho
|
##Mar 1, 2019
#
#code designed by Yasuhiro Okura and Takahiko Satoh and Miguel Ramalho and Lakshmi Prakash
# useful additional packages
import matplotlib.pyplot as plt
import matplotlib.axes as axes
%matplotlib inline
import numpy as np
import networkx as nx
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute
%matplotlib inline
# from qiskit import IBMQ #TODO
from qiskit import LegacySimulators as Aer
# Import Aer
# from qiskit import BasicAer
# qr = QuantumRegister(5, 'q')
# cr = ClassicalRegister(5, 'c')
# qc = QuantumCircuit(qr, cr)
import random
n = 4 # number of node
edge_direct = random.randint(1, n)
weight = 1.0
print(edge_direct)
# define edges and weight
# elist = []
# while len(elist)<3:
# # print("success1")
# e_start = random.randint(0, n-1)#it is used to define node connection
# e_end = random.randint(0, n-1)#it is used to define node connection
# # print("success2")
# if e_start != e_end:
# edge = (e_start, e_end, weight)
# elist.append(edge)
# print(elist)
# print(elist)
elist=[(2,3,1.0), (0, 1, 1.0)]
G=nx.Graph()
G.add_nodes_from(np.arange(0, n,1))
G.add_weighted_edges_from(elist)
colors = ['r' for node in G.nodes()]
pos = nx.spring_layout(G)
default_axes = plt.axes(frameon=True)
nx.draw_networkx(G, node_color=colors, node_size=600, alpha=.8, ax=default_axes, pos=pos)
# Computing the weight matrix from the random graph
w = np.zeros([n,n])
for i in range(n):
for j in range(n):
temp = G.get_edge_data(i,j,default=0)
print(temp)
if temp != 0:
w[i,j] = temp["weight"]
print(w)
edges = list(G.edges)
print(edges)
while edges:
i, j = edges.pop()
# i = int(i)
print(i, j)
## difine circuit
num_x = n # num of node
num_a = 1
num_b = 2
num_c = 1
x = QuantumRegister(num_x, "x")
a = QuantumRegister(num_a, "a")
b = QuantumRegister(num_b, "b")
c = QuantumRegister(num_c, "c")
cr = ClassicalRegister(4, "cr")
qc = QuantumCircuit(x, a ,b, c, cr)
#initialize graph weight
#If Threshold >=2 : SUCCESS!!
qc = QuantumCircuit(x, a ,b, c, cr)
# qc.x(x[0])
# qc.x(x[1])
# qc.x(x[2])
# qc.x(x[3])
qc.h(x[0])
qc.h(x[1])
qc.h(x[2])
qc.h(x[3])
qc.h(c[0])
qc.barrier()
qc.draw(output = "mpl")
# colors = []
# colors = ['r' if xbest_brute[i] == 0 else 'b' for i in range(n)]
# nx.draw_networkx(G, node_color=colors, node_size=600, alpha=.8, pos=pos)
edges = list(G.edges)
print(edges)
## V part(Oracle)
def cut(qc, x, a, b, i, j):
qc.cx(x[i], a)
qc.cx(x[j], a)
qc.ccx(a[0], b[0], b[1])
qc.cx(a[0], b[0])
qc.cx(x[j], a)
qc.cx(x[i], a)
## V inverse
def icut(qc, x, a, b, i, j):
qc.cx(x[i], a)
qc.cx(x[j], a)
qc.cx(a[0], b[0])
qc.ccx(a[0], b[0], b[1])
qc.cx(x[j], a)
qc.cx(x[i], a)
def cnx(qc,*qubits): # C^n-NOT gate
if len(qubits) > 3:
last = qubits[-1]
#A matrix: (made up of a and Y rotation, lemma4.3)
qc.crz(np.pi/2, qubits[-2], qubits[-1])
#cry
qc.cu3(np.pi/2, 0, 0, qubits[-2],qubits[-1])
#Control not gate
cnx(qc,*qubits[:-2],qubits[-1])
#B matrix (cry again, but opposite angle)
qc.cu3(-np.pi/2, 0, 0, qubits[-2], qubits[-1])
#Control
cnx(qc,*qubits[:-2],qubits[-1])
#C matrix (final rotation)
qc.crz(-np.pi/2,qubits[-2],qubits[-1])
elif len(qubits)==3:
qc.ccx(*qubits)
elif len(qubits)==2:
qc.cx(*qubits)
print(num_x)
## D part(Diffusion matrix)
def diff(qc, N): # Diffusion matrix
for k in range(N):
qc.h(x[k])
qc.x(x[k])
# qc.h(x[3])
qc.h(x[3])
# cnx(qc, x[0], x[1], x[2], x[3])
cnx(qc, x[0], x[1], x[2], x[3])
# qc.h(x[3])
qc.h(x[3])
for k in range(N):
qc.x(x[k])
qc.h(x[k])
# qc.h(x[k])
# qc.x(x[k])
# print(round(np.log(num_x))) # How many times execute V and D
# for l in np.arange(round(np.log(num_x))):
for l in np.arange(1):
qc.barrier()
for e in edges:
i, j = e
print(i, j)
cut(qc, x, a, b, int(i), int(j)) # when we should apply int ? Is this right timing?
print("success!")
qc.barrier()
qc.cz(b[1], c[0])
qc.barrier()
for e in edges[::-1]:
i, j = e
print(i, j)
icut(qc, x, a, b, int(i), int(j)) # when we should apply int ? Is this right timing?
print("success!")
qc.barrier()
diff(qc, num_x)
qc.barrier()
qc.barrier()
qc.h(c[0])
## measurement
for l in range(num_x):
qc.measure(x[l], cr[l])
# qc.measure(a[0], cr[4])
# for m in range(num_a):
# qc.measure(a[1], cr[num_x+m-1])
qc.draw(output = "mpl")
from qiskit.tools.visualization import plot_histogram
print("############ running on QASM simulater ############")
backend = Aer.get_backend('qasm_simulator')
## StateVector Sim
# Run the quantum circuit on a statevector simulator backend
# backend = BasicAer.get_backend('statevector_simulator')
# job_sim = execute(qc, backend=backend)
# result = job_sim.result()
# outputstate = result.get_statevector(qc, decimals=3)
# print(outputstate)
job_sim = execute(qc, backend=backend)
result = job_sim.result()
count = result.get_counts(qc)
print(sorted(count.items(), key = lambda x: x[1],reverse=True)[0])
print(count)
# from qiskit.tools.visualization import plot_state_city
# plot_state_city(outputstate)
plot_histogram(count)
# TODO
print("############ running on IBMQ ############")
|
https://github.com/liyaochong/quantum-algorithm-learning-and-implementation
|
liyaochong
|
# 导入相应的运算库
import numpy as np
from qiskit import BasicAer, execute
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.tools.visualization import circuit_drawer
desired_vector1 = [6/np.sqrt(200), 8/np.sqrt(200), 1/np.sqrt(2), 0]
desired_vector2 = [10/np.sqrt(101), -1/np.sqrt(101)]
q0 = QuantumRegister(1,'q0')
c0 = ClassicalRegister(1,'c0')
q1 = QuantumRegister(2,'q1')
c1 = ClassicalRegister(2,'c1')
q2 = QuantumRegister(1,'q2')
c2 = ClassicalRegister(1,'c2')
Circuit = QuantumCircuit()
Circuit.add_register(q0,c0)
Circuit.add_register(q1,c1)
Circuit.add_register(q2,c2)
Circuit.initialize(desired_vector1, [q1[0],q1[1]])
Circuit.initialize(desired_vector2, [q2[0]])
Circuit.h(q0[0])
Circuit.ccx(q0[0],q1[1],q2[0])
Circuit.ccx(q0[0],q2[0],q1[1])
Circuit.ccx(q0[0],q1[1],q2[0])
Circuit.h(q0[0])
Circuit.draw(output='mpl')
# 对寄存器q0进行测量
Circuit.measure(q0,c0)
# 测量次数设置为1024次
backend = BasicAer.get_backend('qasm_simulator')
job = execute(Circuit, backend,shots=1024)
job.result().get_counts(Circuit)
P_0 = 0.5-89/202*0.5
P_1 = 0.5+89/202*0.5
Times_0 = P_0*1024
Times_1 = P_1*1024
print('进行测量之后，辅助量子比特为0态的次数是',Times_0)
print('进行测量之后，辅助量子比特为1态的次数是',Times_1)
|
https://github.com/liyaochong/quantum-algorithm-learning-and-implementation
|
liyaochong
|
# 导入相应的运算库
import numpy as np
from qiskit import BasicAer, execute
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.tools.visualization import circuit_drawer
desired_vector1 = [np.sqrt(3)/2, 1/2, 0, 0]
desired_vector2 = [1/2, 1/2, 1/2, 1/2]
q0 = QuantumRegister(1,'q0')
c0 = ClassicalRegister(1,'c0')
q1 = QuantumRegister(2,'q1')
c1 = ClassicalRegister(2,'c1')
q2 = QuantumRegister(2,'q2')
c2 = ClassicalRegister(2,'c2')
Circuit = QuantumCircuit()
Circuit.add_register(q0,c0)
Circuit.add_register(q1,c1)
Circuit.add_register(q2,c2)
Circuit.initialize(desired_vector1, [q1[0],q1[1]])
Circuit.initialize(desired_vector2, [q2[0],q2[1]])
Circuit.h(q0[0])
Circuit.ccx(q0[0],q1[1],q2[1])
Circuit.ccx(q0[0],q2[1],q1[1])
Circuit.ccx(q0[0],q1[1],q2[1])
Circuit.ccx(q0[0],q1[0],q2[0])
Circuit.ccx(q0[0],q2[0],q1[0])
Circuit.ccx(q0[0],q1[0],q2[0])
Circuit.h(q0[0])
Circuit.draw(output='mpl')
# 对寄存器q0进行测量
Circuit.measure(q0,c0)
# 测量次数设置为1024次
backend = BasicAer.get_backend('qasm_simulator')
job = execute(Circuit, backend,shots=1024)
job.result().get_counts(Circuit)
Inner_product = np.sum(np.multiply(np.array(desired_vector1),np.array(desired_vector2)))
Overlap = Inner_product**2
P_0 = 1/2 + Overlap/2
print(P_0*1024)
|
https://github.com/liyaochong/quantum-algorithm-learning-and-implementation
|
liyaochong
|
# 导入相应的运算库
import numpy as np
from math import pi
from qiskit import BasicAer, execute
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.tools.visualization import circuit_drawer
# 定义相应的量子寄存器，并添加至电路当中去
# q0寄存器表示地址寄存器
q0 = QuantumRegister(2,'q0')
c0 = ClassicalRegister(2,'c0')
# q1寄存器表示数据寄存器，寄存器的位数表示计算的精度，这里设置为3，最后误差在0.125以内
q1 = QuantumRegister(4,'q1')
c1 = ClassicalRegister(4,'c1')
# q2寄存器表示执行量子算数的的目标寄存器，位数一般与q1寄存器相同
q2 = QuantumRegister(4,'q2')
c2 = ClassicalRegister(4,'c2')
# q3寄存器用来做辅助量子比特，执行系列的受控旋转操作
q3 = QuantumRegister(1,'q3')
c3 = ClassicalRegister(1,'c3')
# 定义一个量子电路对象
Circuit = QuantumCircuit()
# 往寄存器中添加4个量子寄存器
Circuit.add_register(q0,c0)
Circuit.add_register(q1,c1)
Circuit.add_register(q2,c2)
Circuit.add_register(q3,c3)
# 添加量子门操作，注意这里的命名方式为最低有效位
# 执行H门操作，将地址寄存器q0张开，分叉存储，由于两个数据只需要用1个量子比特进行表示
Circuit.h(q0[0])
Circuit.h(q0[1])
# 写入数据至q1寄存器，更为通用的采用的是QRAM算法，或者其他数据制备算法，注意这里的数据用基态表示，本质上以经典的形式出现
Circuit.barrier()
Circuit.cx(q0[0],q1[0])
Circuit.x(q1[1])
Circuit.x(q0[0])
Circuit.ccx(q0[0],q0[1],q1[2])
Circuit.x(q0[0])
Circuit.cx(q0[1],q1[3])
# 这里执行的量子算数运算，进行的是类似一个函数的运算过程
Circuit.barrier()
Circuit.x(q1[0])
Circuit.cx(q1[0],q2[0])
Circuit.x(q1[0])
Circuit.x(q1[2])
Circuit.ccx(q1[1],q1[2],q2[1])
Circuit.x(q1[2])
Circuit.x(q2[2])
Circuit.x(q1[0])
Circuit.x(q1[2])
Circuit.ccx(q1[0],q1[2],q2[2])
Circuit.x(q1[0])
Circuit.x(q1[2])
Circuit.x(q2[3])
Circuit.x(q1[2])
Circuit.ccx(q1[2],q1[3],q2[3])
Circuit.x(q1[2])
# 执行受控旋转操作，将数据从函数运算的输出，加载到概率幅度上
Circuit.barrier()
Circuit.cu3(pi/2, 0, 0, q2[0], q3)
Circuit.cu3(pi/4, 0, 0, q2[1], q3)
Circuit.cu3(pi/8, 0, 0, q2[2], q3)
Circuit.cu3(pi/16, 0, 0, q2[3], q3)
# 执行量子算数运算的解运算过程
Circuit.barrier()
Circuit.x(q1[2])
Circuit.ccx(q1[2],q1[3],q2[3])
Circuit.x(q1[2])
Circuit.x(q2[3])
Circuit.x(q1[2])
Circuit.x(q1[0])
Circuit.ccx(q1[0],q1[2],q2[2])
Circuit.x(q1[2])
Circuit.x(q1[0])
Circuit.x(q2[2])
Circuit.x(q1[2])
Circuit.ccx(q1[1],q1[2],q2[1])
Circuit.x(q1[2])
Circuit.x(q1[0])
Circuit.cx(q1[0],q2[0])
Circuit.x(q1[0])
# 执行数据的量子制备过程的逆变换（IQRAM），完成解运算
Circuit.barrier()
Circuit.cx(q0[1],q1[3])
Circuit.x(q0[0])
Circuit.ccx(q0[0],q0[1],q1[2])
Circuit.x(q0[0])
Circuit.x(q1[1])
Circuit.cx(q0[0],q1[0])
#Circuit.h(q0[0])
#Circuit.h(q0[1])
# 添加测量操作，量子寄存器关联相应的经典寄存器
Circuit.barrier()
Circuit.measure(q0,c0)
Circuit.measure(q1,c1)
Circuit.measure(q2,c2)
Circuit.measure(q3,c3)
# 绘制整个量子电路图
Circuit.draw(output='mpl')
# 使用 Aer's qasm_simulator
backend_sim = BasicAer.get_backend('qasm_simulator')
# 执行量子仿真器
job_sim = execute(Circuit, backend_sim, shots=8096)
# 获得结果
result_sim = job_sim.result()
counts = result_sim.get_counts(Circuit)
# 打印结果输出
print(counts)
|
https://github.com/liyaochong/quantum-algorithm-learning-and-implementation
|
liyaochong
|
# 导入相应的运算库
import numpy as np
from math import pi
from qiskit import BasicAer, execute
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.tools.visualization import circuit_drawer
# 定义相应的量子寄存器，并添加至电路当中去
# q0寄存器表示地址寄存器
q0 = QuantumRegister(1,'q0')
c0 = ClassicalRegister(1,'c0')
# q1寄存器表示数据寄存器，寄存器的位数表示计算的精度，这里设置为3，最后误差在0.125以内
q1 = QuantumRegister(3,'q1')
c1 = ClassicalRegister(3,'c1')
# q2寄存器表示执行量子算数的的目标寄存器，位数一般与q1寄存器相同
q2 = QuantumRegister(3,'q2')
c2 = ClassicalRegister(3,'c2')
# q3寄存器用来做辅助量子比特，执行系列的受控旋转操作
q3 = QuantumRegister(1,'q3')
c3 = ClassicalRegister(1,'c3')
# 定义一个量子电路对象
Circuit = QuantumCircuit()
# 往寄存器中添加4个量子寄存器
Circuit.add_register(q0,c0)
Circuit.add_register(q1,c1)
Circuit.add_register(q2,c2)
Circuit.add_register(q3,c3)
# 添加量子门操作，注意这里的命名方式为最低有效位
# 执行H门操作，将地址寄存器q0张开，分叉存储，由于两个数据只需要用1个量子比特进行表示
Circuit.h(q0[0])
# 写入数据至q1寄存器，更为通用的采用的是QRAM算法，或者其他数据制备算法，注意这里的数据用基态表示，本质上以经典的形式出现
Circuit.x(q0[0])
Circuit.cx(q0[0],q1[1])
Circuit.x(q0[0])
Circuit.cx(q0[0],q1[0])
Circuit.cx(q0[0],q1[1])
# 这里执行的量子算数运算，进行的是类似一个函数的运算过程
Circuit.barrier()
Circuit.x(q1[0])
Circuit.cx(q1[0],q2[0])
Circuit.x(q1[0])
Circuit.cx(q1[1],q2[1])
Circuit.cx(q1[2],q2[2])
# 执行受控旋转操作，将数据从函数运算的输出，加载到概率幅度上
Circuit.barrier()
Circuit.cu3(pi/2, 0, 0, q2[0], q3)
Circuit.cu3(pi/4, 0, 0, q2[1], q3)
Circuit.cu3(pi/8, 0, 0, q2[2], q3)
# 执行量子算数运算的解运算过程
Circuit.barrier()
Circuit.cx(q1[2],q2[2])
Circuit.cx(q1[1],q2[1])
Circuit.x(q1[0])
Circuit.cx(q1[0],q2[0])
Circuit.x(q1[0])
# 执行数据的量子制备过程的逆变换（IQRAM），完成解运算
Circuit.barrier()
Circuit.cx(q0[0],q1[1])
Circuit.cx(q0[0],q1[0])
Circuit.x(q0[0])
Circuit.cx(q0[0],q1[1])
Circuit.x(q0[0])
# 添加测量操作，量子寄存器关联相应的经典寄存器
Circuit.barrier()
Circuit.measure(q0,c0)
Circuit.measure(q1,c1)
Circuit.measure(q2,c2)
Circuit.measure(q3,c3)
# 绘制整个量子电路图
Circuit.draw(output='mpl')
# 使用 Aer's qasm_simulator
backend_sim = BasicAer.get_backend('qasm_simulator')
# 执行量子仿真器
job_sim = execute(Circuit, backend_sim, shots=8096)
# 获得结果
result_sim = job_sim.result()
counts = result_sim.get_counts(Circuit)
# 打印结果输出
print(counts)
|
https://github.com/liyaochong/quantum-algorithm-learning-and-implementation
|
liyaochong
|
# 导入相应的运算库
import numpy as np
from math import pi
from qiskit import BasicAer, execute
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.tools.visualization import circuit_drawer
# 定义相应的量子寄存器，并添加至电路当中去
# 定义变量n,即完成n量子比特的移位操作
n = 5
# q0寄存器表示地址寄存器
q0 = QuantumRegister(n,'q0')
c0 = ClassicalRegister(n,'c0')
# q1寄存器表示辅助寄存器
q1 = QuantumRegister(n-2,'q1')
# 定义一个量子电路对象
Circuit = QuantumCircuit()
# 往寄存器中添加4个量子寄存器
Circuit.add_register(q0,c0)
Circuit.add_register(q1)
# 此模块为量子循环加一操作，添加量子门操作，注意这里的命名方式为最低有效位
# 初始化输入量子态
Circuit.x(q0[0])
# 用多受控非门分解策略，执行4个控制位的受控非门分解
Circuit.barrier()
Circuit.ccx(q0[0],q0[1],q1[0])
Circuit.ccx(q0[2],q1[0],q1[1])
Circuit.ccx(q0[3],q1[1],q1[2])
Circuit.cx(q1[2],q0[4])
Circuit.ccx(q0[3],q1[1],q1[2])
Circuit.ccx(q0[2],q1[0],q1[1])
Circuit.ccx(q0[0],q0[1],q1[0])
# 用多受控非门分解策略，执行3个控制位的受控非门分解
Circuit.barrier()
Circuit.ccx(q0[0],q0[1],q1[0])
Circuit.ccx(q0[2],q1[0],q1[1])
Circuit.cx(q1[1],q0[3])
Circuit.ccx(q0[2],q1[0],q1[1])
Circuit.ccx(q0[0],q0[1],q1[0])
# 执行2个控制位的受控非门操作
Circuit.barrier()
Circuit.ccx(q0[0],q0[1],q0[2])
# 执行1个控制位的受控非门操作
Circuit.barrier()
Circuit.cx(q0[0],q0[1])
# 执行非门操作
Circuit.barrier()
Circuit.x(q0[0])
# 引入测量操作
Circuit.barrier()
Circuit.measure(q0,c0)
# 绘制整个量子电路图
Circuit.draw(output='mpl')
# 使用 Aer's qasm_simulator
backend_sim = BasicAer.get_backend('qasm_simulator')
# 执行量子仿真器
job_sim = execute(Circuit, backend_sim, shots=8096)
# 获得结果
result_sim = job_sim.result()
counts = result_sim.get_counts(Circuit)
# 打印结果输出
print(counts)
# 此模块为量子循环减一操作，添加量子门操作，注意这里的命名方式为最低有效位
# 初始化输入量子态
Circuit.x(q0[0])
# 执行非门操作
Circuit.barrier()
Circuit.x(q0[0])
# 执行1个控制位的受控非门操作
Circuit.barrier()
Circuit.cx(q0[0],q0[1])
# 执行2个控制位的受控非门操作
Circuit.barrier()
Circuit.ccx(q0[0],q0[1],q0[2])
# 用多受控非门分解策略，执行3个控制位的受控非门分解
Circuit.barrier()
Circuit.ccx(q0[0],q0[1],q1[0])
Circuit.ccx(q0[2],q1[0],q1[1])
Circuit.cx(q1[1],q0[3])
Circuit.ccx(q0[2],q1[0],q1[1])
Circuit.ccx(q0[0],q0[1],q1[0])
# 用多受控非门分解策略，执行4个控制位的受控非门分解
Circuit.barrier()
Circuit.ccx(q0[0],q0[1],q1[0])
Circuit.ccx(q0[2],q1[0],q1[1])
Circuit.ccx(q0[3],q1[1],q1[2])
Circuit.cx(q1[2],q0[4])
Circuit.ccx(q0[3],q1[1],q1[2])
Circuit.ccx(q0[2],q1[0],q1[1])
Circuit.ccx(q0[0],q0[1],q1[0])
Circuit.barrier()
Circuit.measure(q0,c0)
# 绘制整个量子电路图
Circuit.draw(output='mpl')
# 使用 Aer's qasm_simulator
backend_sim = BasicAer.get_backend('qasm_simulator')
# 执行量子仿真器
job_sim = execute(Circuit, backend_sim, shots=8096)
# 获得结果
result_sim = job_sim.result()
counts = result_sim.get_counts(Circuit)
# 打印结果输出
print(counts)
|
https://github.com/liyaochong/quantum-algorithm-learning-and-implementation
|
liyaochong
|
# 导入相应的运算库
import numpy as np
from math import pi
from qiskit import BasicAer, execute
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.tools.visualization import circuit_drawer
from qiskit import Aer
# 定义相应的量子寄存器，并添加至电路当中去
# q0寄存器表示地址寄存器
q0 = QuantumRegister(5,'q0')
c0 = ClassicalRegister(5,'c0')
# 定义一个量子电路对象
Circuit = QuantumCircuit()
# 往寄存器中添加4个量子寄存器
Circuit.add_register(q0,c0)
# 添加量子门操作，注意这里的命名方式为最低有效位
# 执行H门操作，将地址寄存器q0张开，分叉存储，由于两个数据只需要用1个量子比特进行表示
Circuit.h(q0[4])
Circuit.barrier()
Circuit.h(q0[3])
Circuit.barrier()
Circuit.h(q0[2])
Circuit.barrier()
Circuit.h(q0[1])
Circuit.barrier()
Circuit.swap(q0[1], q0[0])
Circuit.barrier()
Circuit.swap(q0[2], q0[1])
Circuit.swap(q0[1], q0[0])
Circuit.barrier()
Circuit.swap(q0[3], q0[2])
Circuit.swap(q0[2], q0[1])
Circuit.swap(q0[1], q0[0])
Circuit.barrier()
Circuit.swap(q0[4], q0[3])
Circuit.swap(q0[3], q0[2])
Circuit.swap(q0[2], q0[1])
Circuit.swap(q0[1], q0[0])
# 绘制整个量子电路图
Circuit.draw(output='mpl')
# 在单一模拟器后端运行量子电路
backend = Aer.get_backend('unitary_simulator')
job = execute(Circuit, backend)
result = job.result()
# 显示结果
print(result.get_unitary(Circuit, decimals=3))
|
https://github.com/liyaochong/quantum-algorithm-learning-and-implementation
|
liyaochong
|
%matplotlib inline
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute
from qiskit import BasicAer
import math
# 设置寄存器中的量子位的数量
n = 4 # 第一寄存器
m = 1 # 第二寄存器
# 用n个量子位创建一个量子寄存器
q = QuantumRegister(n+m, 'q')
# 在q寄存器上创建一个量子电路
register = QuantumCircuit(q)
# j=3,2,1,0
for j in range(n-1,-1,-1):
register.h(q[j])
register.cu1(math.pi/2,q[2],q[3],q[1])
# 实际上是一个受控相位操作，能够看做一个单比特操作；相应电路见小黄书P165
register.u1(math.pi/float(2**(j)), q[j])
for j in range(n):
for k in range(j):
register.cu1(-math.pi/float(2**(j-k)), q[j], q[k])
register.h(q[j])
def swap(qc, q, i, j):
qc.cx(q[i], q[j])
qc.cx(q[j], q[i])
qc.cx(q[i], q[j])
if n%2==1:
for i in range(int((n-1)/2)):
swap(register, q, i, n-i-1)
else:
for i in range(int(n/2)):
swap(register, q, i, n-i-1)
register.draw(output="mpl")
# Create a Classical Register with n bits.
c = ClassicalRegister(n+m, 'c')
# Create a Quantum Circuit
measure = QuantumCircuit(q, c)
measure.barrier(q)
# map the quantum measurement to the classical bits
measure.measure(q,c)
# The Qiskit circuit object supports composition using
# the addition operator.
qc = register+measure
#drawing the circuit
qc.draw(output="mpl")
# Use Aer's qasm_simulator
backend_sim = BasicAer.get_backend('qasm_simulator')
# Execute the circuit on the qasm simulator.
# We've set the number of repeats of the circuit to be 1024, which is the default.
job_sim = execute(qc, backend_sim, shots=1024)
# Grab the results from the job.
result_sim = job_sim.result()
counts = result_sim.get_counts(qc)
print(counts)
from qiskit.tools.visualization import plot_histogram
plot_histogram(result_sim.get_counts(qc))
import numpy as np
1.38148766/(2*np.sqrt(2))
|
https://github.com/liyaochong/quantum-algorithm-learning-and-implementation
|
liyaochong
|
# 导入相应的依赖库
import numpy as np
import math
from math import pi
import re
from qiskit import BasicAer,execute
from qiskit import QuantumCircuit,ClassicalRegister,QuantumRegister
from qiskit.tools.visualization import circuit_drawer
from qiskit import Aer, execute
# 实现目标量子态的制备电路
# 输入经典的数据，以向量的形式给出（注意：这里给出的向量元素为实数）
classic_vec = [0.234,0.567]
# 获得经典向量的二范数，存储至变量x_norm
x_norm = np.linalg.norm(classic_vec, ord=None, axis=None, keepdims=False)
# 获得归一化之后的向量，即对应量子态上的概率幅
norm_vec = classic_vec/x_norm
print(norm_vec)
# 计算制备目标量子态所需要的量子比特
num_qubits = int(math.log(len(classic_vec),2))
# 利用Qiskit中的初始化内置函数，生成对应的制备电路
q_inital = QuantumRegister(num_qubits,'q_inital')
Circuit_inital = QuantumCircuit()
Circuit_inital.add_register(q_inital)
Circuit_inital.initialize(norm_vec,q_inital)
# 对初始化制备电路，生成qsam代码，并截取量子门操作部分的代码
Qasm_Code = Circuit_inital.qasm().split(';')[3:-1]
# 去除list中字符串的‘\n’部分
Qasm_Code = [x.strip() for x in Qasm_Code if x.strip()!='']
# 设置参数的提取规则
p1 = re.compile(r'[(](.*?)[)]', re.S) # 提取圆括号中的数据，返回数据类型为list
p2 = re.compile(r'[[](.*?)[]]', re.S) # 提取方括号中的数据，返回数据类型为list
# 设置数据寄存器和地址寄存器，对应各自的量子比特数量为num_qubits
# q0表示address地址寄存器，量子比特与数据制备寄存器相等
q0 = QuantumRegister(num_qubits,'q0')
c0 = ClassicalRegister(num_qubits,'c0')
# q1表示data数据寄存器，用于数据制备
q1 = QuantumRegister(num_qubits,'q1')
c1 = ClassicalRegister(num_qubits,'c1')
# 辅助量子比特寄存器B，有一个量子比特
q2 = QuantumRegister(1,'q2')
c2 = ClassicalRegister(1,'c2')
# 将寄存器添加至量子电路
Circuit = QuantumCircuit()
Circuit.add_register(q0,c0)
Circuit.add_register(q1,c1)
Circuit.add_register(q2,c2)
# Circuit.add_register(q0)
# Circuit.add_register(q1)
# Circuit.add_register(q2)
# 制备地址寄存器的状态
for i in range(num_qubits):
Circuit.h(q0[i])
# 对目标量子态进行制备（概率幅编码）
for i in range(len(Qasm_Code)):
code_str = Qasm_Code[i]
if code_str[0:2]=='ry':
theta = float(re.findall(p1, code_str)[0])
target_qubit = int(re.findall(p2, code_str)[0])
Circuit.u3(theta,0,0,q1[target_qubit])
elif code_str[0:2]=='cx':
control_qubit = int(re.findall(p2, code_str)[0])
target_qubit = int(re.findall(p2, code_str)[1])
Circuit.cx(q1[control_qubit],q1[target_qubit])
else:
print('The desired vector must be real number!')
Circuit.barrier()
# 执行Hadamard Test操作
Circuit.h(q2[0])
for i in range(len(Qasm_Code)):
code_str = Qasm_Code[len(Qasm_Code)-1-i]
if code_str[0:2]=='ry':
theta = float(re.findall(p1, code_str)[0])
target_qubit = int(re.findall(p2, code_str)[0])
Circuit.cu3(-theta,0,0,q2[0],q1[target_qubit])
elif code_str[0:2]=='cx':
control_qubit = int(re.findall(p2, code_str)[0])
target_qubit = int(re.findall(p2, code_str)[1])
Circuit.ccx(q2[0],q1[control_qubit],q1[target_qubit])
else:
print('The desired vector must be real number!')
for i in range(num_qubits):
Circuit.ccx(q2[0],q0[i],q1[i])
Circuit.h(q2[0])
# 绘制量子电路图
# Circuit.draw(output='mpl')
# 定义两个函数（分解为通用量子门）
# 定义具有两个控制位的受控旋转门（绕Y轴旋转）
def cu3_2(theta,control_1,control_2,target,circuit):
circuit.cu3(theta/2,0,0,control_1,target)
circuit.cu3(theta/2,0,0,control_2,target)
circuit.cx(control_1,control_2)
circuit.cu3(-theta/2,0,0,control_2,target)
circuit.cx(control_1,control_2)
return circuit
# 定义具有三个控制位的受控非门（使用两个初始状态为0态的辅助量子比特）
def cccx(control_1,control_2,control_3,target,circuit):
circuit.ccx(control_1,control_2,q_auxiliary[0])
circuit.ccx(control_3,q_auxiliary[0],q_auxiliary[1])
circuit.cx(q_auxiliary[1],target)
circuit.ccx(control_3,q_auxiliary[0],q_auxiliary[1])
circuit.ccx(control_1,control_2,q_auxiliary[0])
return circuit
# 执行量子相位估计
# 相位估计的第一寄存器q3，量子比特数量决定了计算精度
qpe_control_qubits = 3
q3 = QuantumRegister(qpe_control_qubits,'q3')
c3 = ClassicalRegister(qpe_control_qubits,'c3')
Circuit.add_register(q3,c3)
# Circuit.add_register(q3)
# 三个控制位的受控非门，需要两个辅助量子比特
q_auxiliary = QuantumRegister(2,'q_auxiliary')
c_auxiliary = ClassicalRegister(2,'c_auxiliary')
Circuit.add_register(q_auxiliary,c_auxiliary)
# Circuit.add_register(q_auxiliary)
# 对相位估计的第一寄存器进行全Hadamard门操作
for i in range(qpe_control_qubits):
Circuit.h(q3[i])
Circuit.barrier()
# 对相位估计的第二寄存器执行受控U操作
for i in range(qpe_control_qubits):
# 由控制位决定U的阶数，使用for循环进行操作
for j in range(int(math.pow(2, i))):
# 执行受控Z门以及受控H门的操作，其中控制位为第一寄存器的第i个比特
Circuit.cz(q3[i],q2[0])
Circuit.ch(q3[i],q2[0])
Circuit.barrier()
# 执行多位受控非门的操作
for k in range(num_qubits):
cccx(control_1=q3[i],control_2=q2[0],control_3=q0[k],target=q1[k],circuit=Circuit)
Circuit.barrier()
# 执行两比特控制的U^A操作，用到了两比特控制旋转门以及三比特控制非门的分解电路函数
for t1 in range(len(Qasm_Code)):
code_str = Qasm_Code[t1]
if code_str[0:2]=='ry':
theta = float(re.findall(p1, code_str)[0])
target_qubit = int(re.findall(p2, code_str)[0])
cu3_2(theta=theta,control_1=q3[i],control_2=q2[0],target=q1[target_qubit],circuit=Circuit)
elif code_str[0:2]=='cx':
control_qubit = int(re.findall(p2, code_str)[0])
target_qubit = int(re.findall(p2, code_str)[1])
cccx(control_1=q3[i],control_2=q2[0],control_3=q1[control_qubit],target=q1[target_qubit],circuit=Circuit)
else:
print('The desired vector must be real number!')
Circuit.barrier()
# 执行受控H门操作，其中控制位为第一寄存器的第i个比特
Circuit.ch(q3[i],q2[0])
Circuit.barrier()
# 执行单比特控制的U^A+操作，用到了单比特控制的受控旋转门以及TOFFOLI门
for t2 in range(len(Qasm_Code)):
code_str = Qasm_Code[len(Qasm_Code)-1-t2]
if code_str[0:2]=='ry':
theta = float(re.findall(p1, code_str)[0])
target_qubit = int(re.findall(p2, code_str)[0])
Circuit.cu3(-theta,0,0,q3[i],q1[target_qubit])
elif code_str[0:2]=='cx':
control_qubit = int(re.findall(p2, code_str)[0])
target_qubit = int(re.findall(p2, code_str)[1])
Circuit.ccx(q3[i],q1[control_qubit],q1[target_qubit])
else:
print('The desired vector must be real number!')
Circuit.barrier()
# 多位受控-Z门的操作
# for k in range(num_qubits):
# Circuit.x(q1[k])
# Circuit.ccx(q3[i],q1[0],q_auxiliary[0])
# Circuit.ccx(q1[1],q_auxiliary[0],q_auxiliary[1])
# Circuit.cu3(pi,-pi/2,pi/2,q_auxiliary[1],q2[0])
# Circuit.cu3(pi,pi/2,pi/2,q_auxiliary[1],q2[0])
# Circuit.ccx(q1[1],q_auxiliary[0],q_auxiliary[1])
# Circuit.ccx(q3[i],q1[0],q_auxiliary[0])
# for k in range(num_qubits):
# Circuit.x(q1[k])
# Circuit.barrier()
Circuit.x(q1[0])
Circuit.ccx(q1[0],q3[i],q_auxiliary[0])
Circuit.cu3(pi,-pi/2,pi/2,q_auxiliary[0],q2[0])
Circuit.cu3(pi,pi/2,pi/2,q_auxiliary[0],q2[0])
Circuit.ccx(q1[0],q3[i],q_auxiliary[0])
Circuit.x(q1[0])
Circuit.barrier()
# 执行单比特控制的U^A操作，用到了单比特控制的受控旋转门以及TOFFOLI门
for t3 in range(len(Qasm_Code)):
code_str = Qasm_Code[t3]
if code_str[0:2]=='ry':
theta = float(re.findall(p1, code_str)[0])
target_qubit = int(re.findall(p2, code_str)[0])
Circuit.cu3(theta,0,0,q3[i],q1[target_qubit])
elif code_str[0:2]=='cx':
control_qubit = int(re.findall(p2, code_str)[0])
target_qubit = int(re.findall(p2, code_str)[1])
Circuit.ccx(q3[i],q1[control_qubit],q1[target_qubit])
else:
print('The desired vector must be real number!')
Circuit.barrier()
# 执行受控H门操作，其中控制位为第一寄存器的第i个比特
Circuit.ch(q3[i],q2[0])
Circuit.barrier()
# 执行两比特控制的U^A+操作，用到了两比特控制旋转门以及三比特控制非门的分解电路函数
for t4 in range(len(Qasm_Code)):
code_str = Qasm_Code[len(Qasm_Code)-1-t4]
if code_str[0:2]=='ry':
theta = float(re.findall(p1, code_str)[0])
target_qubit = int(re.findall(p2, code_str)[0])
cu3_2(theta=-theta,control_1=q3[i],control_2=q2[0],target=q1[target_qubit],circuit=Circuit)
elif code_str[0:2]=='cx':
control_qubit = int(re.findall(p2, code_str)[0])
target_qubit = int(re.findall(p2, code_str)[1])
cccx(control_1=q3[i],control_2=q2[0],control_3=q1[control_qubit],target=q1[target_qubit],circuit=Circuit)
else:
print('The desired vector must be real number!')
Circuit.barrier()
# 执行多位受控非门的操作
for k in range(num_qubits):
cccx(control_1=q3[i],control_2=q2[0],control_3=q0[k],target=q1[k],circuit=Circuit)
Circuit.barrier()
# 执行受控H门的操作，其中控制位为第一寄存器的第i个比特
Circuit.ch(q3[i],q2[0])
Circuit.barrier()
# 执行量子相位估计的第二阶段（量子傅里叶逆变换）
Circuit.h(q3[0])
Circuit.cu1(-pi/2,q3[0],q3[1])
Circuit.cu1(-pi/4,q3[0],q3[2])
Circuit.h(q3[1])
Circuit.cu1(-pi/2,q3[1],q3[2])
Circuit.h(q3[2])
Circuit.barrier()
# Circuit.measure(q0,c0)
# Circuit.measure(q1,c1)
# Circuit.measure(q2,c2)
# Circuit.measure(q3,c3)
# Circuit.measure(q_auxiliary,c_auxiliary)
Circuit.draw(output='mpl').savefig('QC.pdf',dpi=800)
simulator = Aer.get_backend('statevector_simulator')
result = execute(Circuit, simulator).result()
statevector = result.get_statevector(Circuit)
print(statevector)
|
https://github.com/Benjreggio/psfam
|
Benjreggio
|
'''
runtests.py
@author: Andrew Lytle
Reorganized by Ben Reggio
Unit tests for psfam
'''
from psfam.pauli_organizer import PauliOrganizer
import functools,itertools
from scipy.stats import unitary_group
import scipy.sparse as sp
import qiskit
from qiskit.quantum_info.states import Statevector
from qiskit.circuit.random import random_circuit
import numpy as np
from numpy.random import normal
import operator
op_I = sp.eye(2)
op_Z = sp.dia_matrix([[1,0],[0,-1]])
op_X = sp.dia_matrix([[0,1],[1,0]])
op_Y = -1j * op_Z @ op_X
pauli_ops = { "I" : op_I, "Z" : op_Z, "X": op_X, "Y" : op_Y }
def sp_kron_dok(mat_A, mat_B):
"""Kronecker (tensor) product of two sparse matrices.
Args:
mat_A, mat_B: 2d numpy arrays
Returns:
Sparse matrix in "dictionary of keys" format (to eliminate zeros)
"""
return sp.kron(mat_A, mat_B, format = "dok")
def contribution_to_EV(m, fam, counts, nshots):
cfs = fam.get_coefficients()
#cfs = [_.real for _ in cfs]
#print(f"{np.sum(np.array(cfs)).real = }")
measurement = 0
for i in range(2**m):
bi = bin(i)[2:]
while(len(bi)<m):
bi = '0' + bi
if(bi in counts):
measurement += counts[bi]*cfs[i]/nshots
return measurement
def to_pauli_vec(mat):
"""Pauli string decomposition of a matrix.
Args:
2d numpy array, mat
Returns:
Dictionary pauli_vec, e.g. {'XX': 0.5, 'XY': 0.5}
"""
pauli_vec = {} # the dictionary we are saving
mat_vec = np.array(mat).ravel()
num_qubits = int(np.log2(np.sqrt(mat_vec.size)))
for pauli_string in itertools.product(pauli_ops.keys(), repeat = num_qubits):
# construct this pauli string as a matrix
ops = [ pauli_ops[tag] for tag in pauli_string ]
op = functools.reduce(sp_kron_dok, ops)
# compute an inner product, same as tr(A @ B) but faster
op_vec = op.transpose().reshape((1, 4**num_qubits))
coefficient = (op_vec * mat_vec).sum() / 2**num_qubits
#if coefficient != 0:
pauli_vec["".join(pauli_string)] = coefficient
return pauli_vec
def statedict_to_arr(statedict):
"Convert state dictionary to numpy array."
keys = list(statedict.keys())
m = len(keys[0])
#print(m)
result = np.zeros(2**m, dtype='complex')
bitstrings = itertools.product('01',repeat=m)
for i, bitstring in enumerate(bitstrings):
key = functools.reduce(operator.add, bitstring)
if key in keys:
result[i] = statedict[key]
else:
result[i] = 0.0
return result
def direct_EV_eval(Hmat, state_circuit):
psi = Statevector(state_circuit)
state = statedict_to_arr(psi.to_dict()) # array.
direct_eval = np.vdot(state,np.dot(Hmat,state))
return direct_eval
def random_evals(N):
"List of Gaussian distributed numbers [(0,1),...]."
vals = []
for i in range(N):
vals.append(normal())
return vals
def dot_all(Ms):
"Dot product of [M1, M2, ...]"
res = np.identity(Ms[0].shape[0])
for M in Ms[::-1]:
res = np.dot(M, res)
return res
def hc(M):
"Hermitian conjugate of M."
return M.conj().T
def random_H(N):
"Random NxN Hermitian matrix."
evs = random_evals(N)
D = np.diag(evs)
U = unitary_group.rvs(N)
H = dot_all([U, D, hc(U)])
return H
def families_EV_eval(m, Hmat, state_circuit, backend, nshots):
decomp = to_pauli_vec(Hmat)
PO = PauliOrganizer(m)
PO.input_pauli_decomps(decomp)
PO.calc_coefficients()
fams = PO.f
total = 0
for fam in fams:
_circuit = state_circuit.copy()
fam.apply_to_circuit(_circuit)
job = backend.run(qiskit.transpile(_circuit, backend), shots=nshots)
result = job.result()
counts = result.get_counts(_circuit)
#logging.info(f"{counts = }")
contribution = contribution_to_EV(m, fam, counts, nshots).real
#logging.info(f"{contribution = }")
total += contribution
return total
def random_unit_test(m):
nshots = 1 # statevector_simulator backend.
N = 2**m
Hmat = random_H(N)
nominal_depth = 4
rc = random_circuit(m, nominal_depth, measure=False)
direct_eval = direct_EV_eval(Hmat, rc)
backend_sim = qiskit.Aer.get_backend('statevector_simulator')
total = families_EV_eval(m, Hmat, rc, backend_sim, nshots)
print(f"{total = }")
print(f"{direct_eval = }")
return np.isclose(total, direct_eval.real)
results = []
for m in range(1,6): # Slows down for m >~ 5.
for test in range(1, 101):
print(f"{m = } , {test = }")
passed = random_unit_test(m)
results.append(passed)
if passed:
continue
else:
print(f"Test failed with {m = }")
break
if not passed:
break
print(f"Performed {len(results)} tests, "
f"all tests passed = {np.array(results).all()==True}")
|
https://github.com/hugosc/quantum-phase-estimation
|
hugosc
|
from qiskit import ClassicalRegister , QuantumCircuit, QuantumRegister
import numpy as np
qr = QuantumRegister(2)
cr = ClassicalRegister(3) #For tree classicals bites
qc = QuantumCircuit(qr , cr)
qc.h(qr[0]) #auxiliary qubit
qc.x(qr[1]) # eigenvector
#qc.cp((3/2)*np.pi , qr[0] , qr[1])
qc.cp(3*np.pi , qr[0] , qr[1])
qc.h(qr[0])
qc.measure(qr[0] , cr[0]) # this is the controlled-U^(2^n-1) operator for determine phi_n
qc.draw("mpl")
qc.reset(qr[0])
qc.h(qr[0])
# la valeur du bit du poids le plus faible est dans cr[0].
#Si cr[0] = 1 on enléve le bit de poids le plus faible en fesant la rotation alpha_2
#et on continu le bit n-1 devient le bit le bit de poids le plus faible
#si cr[0] est à 0 alors on peut appliquer directement la matrice unitaire associé sans avoir
#à faire de rotation inverse alpha_k
with qc.if_test((cr[0] , 1)) as else_:
qc.p(-np.pi/2 , qr[0])
#qc.cp((3/8)*np.pi , qr[0] ,qr[1])
qc.cp((3/2)*np.pi , qr[0] ,qr[1])
qc.h(qr[0]) # For make measure in X basis {|0> , |1>}
qc.measure(qr[0] , cr[1])
qc.draw("mpl")
qc.reset(qr[0])
qc.h(qr[0])
# la valeur du bit du poids le plus faible est dans cr[0].
#Si cr[0] = 1 on enléve le bit de poids le plus faible en fesant la rotation alpha_2
#et on continu le bit n-1 devient le bit le bit de poids le plus faible
#si cr[0] est à 0 alors on peut appliquer directement la matrice unitaire associé sans avoir
#à faire de rotation inverse alpha_k
with qc.if_test((cr[1] , 1)) as else_:
qc.p(-(3/4)*np.pi , qr[0])
qc.cp((3/4)*np.pi , qr[0] ,qr[1])
qc.h(qr[0]) # For make measure in X basis {|0> , |1>}
qc.measure(qr[0] , cr[2])
qc.draw("mpl")
from qiskit_aer import AerSimulator
sim = AerSimulator()
job = sim.run(qc, shots=1000)
result = job.result()
counts = result.get_counts()
counts
import qiskit.tools.jupyter
%qiskit_version_table
|
https://github.com/hugosc/quantum-phase-estimation
|
hugosc
|
# Import the Qiskit SDK
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import available_backends, execute, register, get_backend, compile
from qiskit.tools.visualization import plot_histogram, circuit_drawer
import time
pi = 3.14159265359
qx_config = {
"APItoken": "4c79a44d415dcf5c0c967e7fb488a39c3c6042baacfd60861d6bca9326aeeb64022892979076e63e0bd6c6e007d4ef3d004b697a022bfaf469e8b0a999efdb63",
"url":"https://quantumexperience.ng.bluemix.net/api"}
register(qx_config['APItoken'], qx_config['url'])
available_backends()
from qiskit import least_busy
least_busy(available_backends({'simulator': False}))
# couplingMap = [(0,1),(0,2),(1,2),(2,3),(4,2),(4,3)]
couplingMap = [(1,0),(2,0),(2,1),(3,2),(3,4),(4,2)]
def cRotation(qc, q, i, j, angle):
half_a = angle / 2
if i != 2 and j != 2:
swap(qc, q, 2, j)
cRotation(qc, q, i, 2, angle)
swap(qc, q, 2, j)
else:
qc.u1(half_a, q[i])
if(j,i) in couplingMap:
qc.cx(q[j], q[i])
else:
invertCNOT(qc, q, i, j)
qc.u1(-half_a, q[i])
if(j,i) in couplingMap:
qc.cx(q[j], q[i])
else:
invertCNOT(qc, q, i, j)
qc.u1(half_a, q[j])
def invertCNOT(qc, q, i, j):
qc.h(q[i])
qc.h(q[j])
qc.cx(q[i], q[j])
qc.h(q[i])
qc.h(q[j])
def swap(qc, q, i, j):
if i != 2 and j != 2:
swap(qc, q, 2, j)
swap(qc, q, i, 2)
swap(qc, q, 2, j)
else:
if (i,j) in couplingMap:
qc.cx(q[i], q[j])
invertCNOT(qc, q, i, j)
qc.cx(q[i], q[j])
else:
qc.cx(q[j], q[i])
invertCNOT(qc, q, j, i)
qc.cx(q[j], q[i])
def inverse_qft(qc, q, indices):
rev = list(reversed(indices))
#swaps need to happen
N = len(rev)
for i in range(int(N / 2)):
j = N - i - 1
swap(qc, q, i, j)
for n, i in enumerate(rev):
angle = -pi/2**n
for j in rev[:n]:
cRotation(qc, q, i, j, angle)
angle *= 2
qc.h(q[i])
# Create a Quantum Register with 5 qubits.
q = QuantumRegister(5)
# Create a Classical Register with 5 bits for storing results.
c = ClassicalRegister(5)
# Create a Quantum Circuit
qc = QuantumCircuit(q, c)
# Add a H gate on 4 qubits, putting the qubits in superposition.
qc.h(q[0])
qc.h(q[1])
qc.h(q[2])
qc.h(q[3])
#Put qubit to |1>
qc.x(q[4])
cRotation(qc, q, 3, 4, pi/8)
cRotation(qc, q, 2, 4, pi/4)
cRotation(qc, q, 1, 4, pi/2)
cRotation(qc, q, 0, 4, pi)
inverse_qft(qc, q, range(4))
qc.measure(q, c)
# See a list of available local simulators
print("Local backends: ", available_backends({'local': True}))
# Compile and run the Quantum circuit on a simulator backend
job = execute(qc, "local_qasm_simulator")
my_backend = get_backend('ibmqx4')
qobj = compile(qc, backend=my_backend, shots=1024)
job = my_backend.run(qobj)
lapse = 0
interval = 30
while not job.done:
print('Status @ {} seconds'.format(interval * lapse))
print(job.status)
time.sleep(interval)
lapse += 1
print(job.status)
result = job.result()
counts = result.get_counts()
print(result)
print(counts)
plot_histogram(counts)
circuit_drawer(qc)
print(qc.qasm())
|
https://github.com/rubenandrebarreiro/summer-school-on-quantum-computing-software-for-near-term-quantum-devices-2020
|
rubenandrebarreiro
|
# useful additional packages
import matplotlib.pyplot as plt
import copy
%matplotlib inline
import numpy as np
from qiskit import Aer
from qiskit.aqua import QuantumInstance
from qiskit.aqua.algorithms import NumPyMinimumEigensolver, VQE
from qiskit.circuit.library import TwoLocal
from qiskit.aqua.components.optimizers import SPSA
from qiskit.chemistry.core import Hamiltonian, TransformationType, QubitMappingType
from qiskit.chemistry.drivers import HDF5Driver
import warnings
warnings.filterwarnings('ignore')
# setup qiskit.chemistry logging
import logging
from qiskit.chemistry import set_qiskit_chemistry_logging
set_qiskit_chemistry_logging(logging.ERROR) # choose among DEBUG, INFO, WARNING, ERROR, CRITICAL and NOTSET
# from qiskit import IBMQ
# provider = IBMQ.load_account()
# First, we use classical eigendecomposition to get ground state energy (including nuclear repulsion energy) as reference.
driver = HDF5Driver('H2/H2_equilibrium_0.735_sto-3g.hdf5')
molecule = driver.run()
operator = Hamiltonian(transformation=TransformationType.FULL,
qubit_mapping=QubitMappingType.PARITY,
two_qubit_reduction=True,
freeze_core=False,
orbital_reduction=None)
qubit_op, aux_ops = operator.run(molecule)
result = NumPyMinimumEigensolver(qubit_op).run()
print('Ground state energy (classical): {:.12f}'.format(result.eigenvalue.real))
# Second, we use variational quantum eigensolver (VQE)
var_form = TwoLocal(qubit_op.num_qubits, ['ry', 'rz'], 'cz', reps=3, entanglement='full')
optimizer = SPSA(max_trials=350)
algo = VQE(qubit_op, var_form, optimizer, max_evals_grouped=1)
result = algo.run(QuantumInstance(Aer.get_backend('statevector_simulator')))
result = operator.process_algorithm_result(result)
print('Ground state energy (quantum) : {:.12f}'.format(result.energy))
print("====================================================")
# You can also print out other info
print(result)
# select H2 or LiH to experiment with
molecule='H2'
if molecule == 'LiH':
mol_distances = np.arange(0.6, 5.1, 0.1)
else:
mol_distances = np.arange(0.2, 4.1, 0.1)
algos = ['NumPyMinimumEigensolver', 'VQE']
energy = np.zeros((len(algos), len(mol_distances)))
for j, algo_name in enumerate(algos):
print("Using {}".format(algo_name))
for i, dis in enumerate(mol_distances):
print("Processing atomic distance: {:1.1f} Angstrom".format(dis), end='\r')
if molecule == 'LiH':
operator = Hamiltonian(transformation=TransformationType.FULL,
qubit_mapping=QubitMappingType.PARITY,
two_qubit_reduction=True,
freeze_core=True,
orbital_reduction=[-3, -2])
else:
operator = Hamiltonian(transformation=TransformationType.FULL,
qubit_mapping=QubitMappingType.PARITY,
two_qubit_reduction=True,
freeze_core=False,
orbital_reduction=None)
driver = HDF5Driver("{}/{:1.1f}_sto-3g.hdf5".format(molecule, dis))
qubit_op, aux_ops = operator.run(driver.run())
if algo_name == 'VQE':
if molecule == 'LiH':
var_form = TwoLocal(qubit_op.num_qubits, ['ry', 'rz'], 'cz', reps=5, entanglement='full')
optimizer = SPSA(max_trials=2500)
else:
var_form = TwoLocal(qubit_op.num_qubits, ['ry', 'rz'], 'cz', reps=3, entanglement='full')
optimizer = SPSA(max_trials=350)
algo = VQE(qubit_op, var_form, optimizer, max_evals_grouped=1)
result = algo.run(QuantumInstance(Aer.get_backend('qasm_simulator'), shots=1024))
else:
result = NumPyMinimumEigensolver(qubit_op).run()
result = operator.process_algorithm_result(result)
energy[j][i] = result.energy
print("\n")
for i, algo in enumerate(algos):
plt.plot(mol_distances, energy[i], label=algo)
plt.xlabel('Atomic distance (Angstrom)')
plt.ylabel('Energy')
plt.legend()
plt.show()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/rubenandrebarreiro/summer-school-on-quantum-computing-software-for-near-term-quantum-devices-2020
|
rubenandrebarreiro
|
# import common packages
import numpy as np
from qiskit import Aer
# lib from Qiskit Aqua
from qiskit.aqua import QuantumInstance
from qiskit.aqua.algorithms import VQE, NumPyMinimumEigensolver
from qiskit.aqua.operators import Z2Symmetries
from qiskit.aqua.components.optimizers import COBYLA
# lib from Qiskit Aqua Chemistry
from qiskit.chemistry import FermionicOperator
from qiskit.chemistry.drivers import PySCFDriver, UnitsType
from qiskit.chemistry.components.variational_forms import UCCSD
from qiskit.chemistry.components.initial_states import HartreeFock
# using driver to get fermionic Hamiltonian
# PySCF example
driver = PySCFDriver(atom='Li .0 .0 .0; H .0 .0 1.6', unit=UnitsType.ANGSTROM,
charge=0, spin=0, basis='sto3g')
molecule = driver.run()
# please be aware that the idx here with respective to original idx
freeze_list = [0]
remove_list = [-3, -2] # negative number denotes the reverse order
map_type = 'parity'
h1 = molecule.one_body_integrals
h2 = molecule.two_body_integrals
nuclear_repulsion_energy = molecule.nuclear_repulsion_energy
num_particles = molecule.num_alpha + molecule.num_beta
num_spin_orbitals = molecule.num_orbitals * 2
print("HF energy: {}".format(molecule.hf_energy - molecule.nuclear_repulsion_energy))
print("# of electrons: {}".format(num_particles))
print("# of spin orbitals: {}".format(num_spin_orbitals))
# prepare full idx of freeze_list and remove_list
# convert all negative idx to positive
remove_list = [x % molecule.num_orbitals for x in remove_list]
freeze_list = [x % molecule.num_orbitals for x in freeze_list]
# update the idx in remove_list of the idx after frozen, since the idx of orbitals are changed after freezing
remove_list = [x - len(freeze_list) for x in remove_list]
remove_list += [x + molecule.num_orbitals - len(freeze_list) for x in remove_list]
freeze_list += [x + molecule.num_orbitals for x in freeze_list]
# prepare fermionic hamiltonian with orbital freezing and eliminating, and then map to qubit hamiltonian
# and if PARITY mapping is selected, reduction qubits
energy_shift = 0.0
qubit_reduction = True if map_type == 'parity' else False
ferOp = FermionicOperator(h1=h1, h2=h2)
if len(freeze_list) > 0:
ferOp, energy_shift = ferOp.fermion_mode_freezing(freeze_list)
num_spin_orbitals -= len(freeze_list)
num_particles -= len(freeze_list)
if len(remove_list) > 0:
ferOp = ferOp.fermion_mode_elimination(remove_list)
num_spin_orbitals -= len(remove_list)
qubitOp = ferOp.mapping(map_type=map_type, threshold=0.00000001)
qubitOp = Z2Symmetries.two_qubit_reduction(qubitOp, num_particles) if qubit_reduction else qubitOp
qubitOp.chop(10**-10)
print(qubitOp.print_details())
print(qubitOp)
# Using exact eigensolver to get the smallest eigenvalue
exact_eigensolver = NumPyMinimumEigensolver(qubitOp)
ret = exact_eigensolver.run()
print('The computed energy is: {:.12f}'.format(ret.eigenvalue.real))
print('The total ground state energy is: {:.12f}'.format(ret.eigenvalue.real + energy_shift + nuclear_repulsion_energy))
# from qiskit import IBMQ
# provider = IBMQ.load_account()
backend = Aer.get_backend('statevector_simulator')
# setup COBYLA optimizer
max_eval = 200
cobyla = COBYLA(maxiter=max_eval)
# setup HartreeFock state
HF_state = HartreeFock(num_spin_orbitals, num_particles, map_type,
qubit_reduction)
# setup UCCSD variational form
var_form = UCCSD(num_orbitals=num_spin_orbitals, num_particles=num_particles,
active_occupied=[0], active_unoccupied=[0, 1],
initial_state=HF_state, qubit_mapping=map_type,
two_qubit_reduction=qubit_reduction, num_time_slices=1)
# setup VQE
vqe = VQE(qubitOp, var_form, cobyla)
quantum_instance = QuantumInstance(backend=backend)
results = vqe.run(quantum_instance)
print('The computed ground state energy is: {:.12f}'.format(results.eigenvalue.real))
print('The total ground state energy is: {:.12f}'.format(results.eigenvalue.real + energy_shift + nuclear_repulsion_energy))
print("Parameters: {}".format(results.optimal_point))
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/rubenandrebarreiro/summer-school-on-quantum-computing-software-for-near-term-quantum-devices-2020
|
rubenandrebarreiro
|
import numpy as np
import numpy.fft
import matplotlib.pyplot as plt
from qiskit.aqua.circuits import StateVectorCircuit
from qiskit.circuit.library import QFT, Barrier
from qiskit import QuantumCircuit, QuantumRegister, execute, Aer
def normalize(ψ):
n = np.linalg.norm(ψ)
return ψ if n == 0 else ψ / n
def wavefunction(circuit):
backend = Aer.get_backend('statevector_simulator')
return execute(circuit.copy(), backend).result().get_statevector()
def exercise1():
l = 4 # Number of qubits
N = 2**l
L = 8
Δx = L/N
x = -L/2 + Δx * np.arange(N)
#
# Discretize our function, and normalize it to turn it into a
# quantum state
f = normalize(np.exp(-x**2/2.0))
#
# Use Qiskit to build a quantum circuit that constructs the
# quantum state associated to the discretize function 'f'
f_qc = StateVectorCircuit(f).construct_circuit()
fig, ax = plt.subplots(nrows=1,ncols=1,figsize=(8,4))
ax.plot(x, f, '-')
ax.plot(x, np.abs(wavefunction(f_qc)), '.')
ax.set_title(f'$f$ with $N={N}$')
exercise1()
from qiskit.circuit.library import QFT
QFT(3, insert_barriers=True).draw()
def fQFT(nqubits, **kwdargs):
circuit = QuantumCircuit(nqubits)
return circuit.compose(QFT(nqubits, **kwdargs), qubits=list(reversed(range(0,nqubits))))
fQFT(3).draw()
fQFT(3, insert_barriers=True, do_swaps=True, inverse=True).draw()
def exercise3():
l = 4 # Number of qubits
N = 2**l
L = 8
Δx = L/N
x = -L/2 + Δx * np.arange(N)
#
# The original function
f = normalize(np.exp(-x**2/2.0))
#
# Construct the circuit for the function 'f'
f_qc = StateVectorCircuit(f).construct_circuit()
#
# Construct the circuit for the Quantum Fourier Transform
qft_circuit = QFT(l, do_swaps=True)
#
# The QFT acts on the qubits of the circuit in the opposite
# order than we would like. We explicit this order when
# we compose the circuits
qft_order = list(reversed(range(0, l)))
#
Ff = f_qc.compose(qft_circuit, qubits=qft_order)
#
# We can also compute the classical fourier transform using
# Python's numpy library
DFTf = np.fft.fft(f)
fig, ax = plt.subplots(nrows=1,ncols=1,figsize=(8,4))
ax.plot(x, f, '-', label='f')
ax.plot(x, normalize(np.abs(DFTf)), label='$\\tilde{f}$')
ax.plot(x, np.abs(wavefunction(Ff)), '.', label='$QFT$')
ax.set_title(f'$f$ with $N={N}$')
ax.legend()
exercise3()
aux=QuantumCircuit(4)
aux.cx(1,3)
aux.cx(1,2)
aux.draw()
steps = QuantumCircuit(4)
steps.compose(fQFT(3, insert_barriers=True), qubits=[0,1,2], inplace=True)
steps.cx(2,3)
steps.compose(fQFT(4, insert_barriers=True), inplace=True)
steps.draw()
def exercise6():
l = 4 # Number of input qubits
N = 2**l
L = 8
Δx = L/N
x = -L/2 + Δx * np.arange(N)
lfinal = l+2 # Number of qubits for interpolation
xfinal = -L/2 + (Δx/2**(lfinal-l)) * np.arange(2**lfinal)
#
# Our circuit (with the final number of qubits)
steps = QuantumCircuit(lfinal)
#
# The original function
f = normalize(np.exp(-x**2/2.0))
#
# The interpolated one
ffinal = normalize(np.exp(-xfinal**2/2.0))
#
# Construct the circuit for the function 'f'
f_qc = StateVectorCircuit(f).construct_circuit()
steps.compose(f_qc, qubits=range(0,l), inplace=True)
#
# Construct the circuit for the Quantum Fourier Transform
steps.compose(fQFT(l, insert_barriers=True),
qubits=list(range(0, l)), inplace=True)
#
# Implement padding
for i in range(l, lfinal):
steps.cx(l-1,i)
#
# Implement the inverse transform
steps.compose(fQFT(lfinal, inverse=True, insert_barriers=True),
inplace=True)
#print(steps.draw())
fig, ax = plt.subplots(nrows=1,ncols=1,figsize=(8,4))
ax.plot(xfinal, ffinal, '-', label='exact')
ax.plot(xfinal, np.abs(wavefunction(steps)), '.', label='interpolated')
ax.set_title(f'Interpolate $f$ from {l} to {lfinal} qubits')
ax.legend()
exercise6()
|
https://github.com/rubenandrebarreiro/summer-school-on-quantum-computing-software-for-near-term-quantum-devices-2020
|
rubenandrebarreiro
|
#initialization
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
import math
# importing Qiskit
from qiskit import IBMQ, BasicAer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
# import basic plot tools
from qiskit.tools.visualization import plot_histogram
def cz(circuit,qr):
circuit.h(qr[1])
circuit.cx(qr[0],qr[1])
circuit.h(qr[1])
qr2 = QuantumRegister(2)
czCircuit = QuantumCircuit(qr2)
cz(czCircuit,qr2)
czCircuit.draw(output="mpl")
def ccz(circuit,qr):
circuit.h(qr[2])
# ccx is the Toffoli gate
circuit.ccx(qr[0], qr[1], qr[2])
circuit.h(qr[2])
qr3 = QuantumRegister(3)
cczCircuit = QuantumCircuit(qr3)
ccz(cczCircuit,qr3)
cczCircuit.draw(output="mpl")
def cccz(circuit,qr):
pi = math.pi
circuit.cu1(pi/4,qr[0],qr[3])
circuit.cx(qr[0], qr[1])
circuit.cu1(-pi/4, qr[1],qr[3])
circuit.cx(qr[0], qr[1])
circuit.cu1(pi/4, qr[1],qr[3])
circuit.cx(qr[1], qr[2])
circuit.cu1(-pi/4, qr[2],qr[3])
circuit.cx(qr[0], qr[2])
circuit.cu1(pi/4, qr[2],qr[3])
circuit.cx(qr[1], qr[2])
circuit.cu1(-pi/4, qr[2],qr[3])
circuit.cx(qr[0], qr[2])
circuit.cu1(pi/4, qr[2],qr[3])
qr4 = QuantumRegister(4)
ccczCircuit = QuantumCircuit(qr4)
cccz(ccczCircuit,qr4)
ccczCircuit.draw(output="mpl")
def n_controlled_Z(circuit, qr):
"""Implement a Z gate with multiple controls"""
if (len(qr) > 4):
raise ValueError('The controlled Z with more than 3 controls is not implemented')
# This is the case n = 2 (1 control + 1 target qubit)
elif (len(qr) == 2):
cz(circuit,qr)
# This is the case n = 3 (2 control + 1 target qubit)
elif (len(qr) == 3):
ccz(circuit,qr)
# This is the case n = 4 (3 control + 1 target qubit)
elif (len(qr) == 4):
cccz(circuit,qr)
def phase_oracle(circuit,qr,element):
# element is an array that defines the searched element, for example, element = [0,1,0,1]
n = len(element)
for j,x in enumerate(element):
if (x == 0):
circuit.x(qr[j])
n_controlled_Z(circuit,qr)
for j,x in enumerate(element):
if (x == 0):
circuit.x(qr[j])
def inversion_about_average(circuit, register, n):
"""Apply inversion about the average step of Grover's algorithm."""
circuit.h(register)
circuit.x(register)
n_controlled_Z(circuit, qr)
circuit.x(register)
circuit.h(register)
#Let's plot it!
qr = QuantumRegister(4)
qAverage = QuantumCircuit(qr)
inversion_about_average(qAverage, qr, 4)
qAverage.draw(output='mpl')
|
https://github.com/rubenandrebarreiro/summer-school-on-quantum-computing-software-for-near-term-quantum-devices-2020
|
rubenandrebarreiro
|
from qiskit import Aer
from qiskit.circuit.library import TwoLocal
from qiskit.aqua import QuantumInstance
from qiskit.finance.applications.ising import portfolio
from qiskit.optimization.applications.ising.common import sample_most_likely
from qiskit.finance.data_providers import RandomDataProvider
from qiskit.aqua.algorithms import VQE, QAOA, NumPyMinimumEigensolver
from qiskit.aqua.components.optimizers import COBYLA
import numpy as np
import warnings
import matplotlib.pyplot as plt
import datetime
warnings.filterwarnings('ignore')
# set number of assets (= number of qubits)
num_assets = 5
# Generate expected return and covariance matrix from (random) time-series
stocks = [("TICKER%s" % i) for i in range(num_assets)]
data = RandomDataProvider(tickers=stocks,
start=datetime.datetime(2016,1,1),
end=datetime.datetime(2016,1,30))
data.run()
mu = data.get_period_return_mean_vector()
sigma = data.get_period_return_covariance_matrix()
# plot sigma
plt.imshow(sigma, interpolation='nearest')
plt.show()
q = 0.5 # set risk factor
budget = num_assets // 2 # set budget
penalty = num_assets # set parameter to scale the budget penalty term
qubitOp, offset = portfolio.get_operator(mu, sigma, q, budget, penalty)
def index_to_selection(i, num_assets):
s = "{0:b}".format(i).rjust(num_assets)
x = np.array([1 if s[i]=='1' else 0 for i in reversed(range(num_assets))])
return x
def print_result(result):
selection = sample_most_likely(result.eigenstate)
value = portfolio.portfolio_value(selection, mu, sigma, q, budget, penalty)
print('Optimal: selection {}, value {:.4f}'.format(selection, value))
eigenvector = result.eigenstate if isinstance(result.eigenstate, np.ndarray) else result.eigenstate.to_matrix()
probabilities = np.abs(eigenvector)**2
i_sorted = reversed(np.argsort(probabilities))
print('\n----------------- Full result ---------------------')
print('selection\tvalue\t\tprobability')
print('---------------------------------------------------')
for i in i_sorted:
x = index_to_selection(i, num_assets)
value = portfolio.portfolio_value(x, mu, sigma, q, budget, penalty)
probability = probabilities[i]
print('%10s\t%.4f\t\t%.4f' %(x, value, probability))
exact_eigensolver = NumPyMinimumEigensolver(qubitOp)
result = exact_eigensolver.run()
print_result(result)
backend = Aer.get_backend('statevector_simulator')
seed = 50
cobyla = COBYLA()
cobyla.set_options(maxiter=500)
ry = TwoLocal(qubitOp.num_qubits, 'ry', 'cz', reps=5, entanglement='linear')
vqe = VQE(qubitOp, ry, cobyla)
vqe.random_seed = seed
quantum_instance = QuantumInstance(backend=backend, seed_simulator=seed, seed_transpiler=seed)
result = vqe.run(quantum_instance)
print_result(result)
backend = Aer.get_backend('statevector_simulator')
seed = 50
cobyla = COBYLA()
cobyla.set_options(maxiter=250)
qaoa = QAOA(qubitOp, cobyla, 3)
qaoa.random_seed = seed
quantum_instance = QuantumInstance(backend=backend, seed_simulator=seed, seed_transpiler=seed)
result = qaoa.run(quantum_instance)
print_result(result)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/rubenandrebarreiro/summer-school-on-quantum-computing-software-for-near-term-quantum-devices-2020
|
rubenandrebarreiro
|
#initialization
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
import math
# importing Qiskit
from qiskit import IBMQ, BasicAer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
# import basic plot tools
from qiskit.tools.visualization import plot_histogram
def ising_gate(circuit,qrj,qrl,Jt):
circuit.cx(qrj,qrl)
circuit.u1(-2*Jt,qrl)
circuit.cx(qrj,qrl)
def fieldx_gate(circuit,qrj,Bt):
# We use rotation around x
circuit.rx(-2*Bt,qrj)
def fieldz_gate(circuit,qrj,Bt):
circuit.rz(-2*Bt,qrj)
def initialize_qa(circuit,qr):
circuit.h(qr)
qr = QuantumRegister(2)
cr = QuantumRegister(2)
circuit = QuantumCircuit(qr)
initialize_qa(circuit,qr)
ising_gate(circuit,qr[0],qr[1],1)
fieldx_gate(circuit,qr,1)
circuit.draw(output='mpl')
|
https://github.com/rubenandrebarreiro/summer-school-on-quantum-computing-software-for-near-term-quantum-devices-2020
|
rubenandrebarreiro
|
import numpy as np
import matplotlib.pyplot as plt
plt.rc('font', size=16, family='serif')
from PIL import Image, ImageOps
import urllib.request
urllib.request.urlretrieve("https://raw.githubusercontent.com/juanjosegarciaripoll/uimp-2020/master/cat.png", "cat.png")
cat = ImageOps.grayscale(Image.open('cat.png'))
cat
cat_array = np.asarray(cat)
cat_array[1,1]
cat_array[100,300]
(np.min(cat_array), np.max(cat_array))
cat_I = cat_array.flatten()+0.0
cat_ψ = np.sqrt(cat_I)/np.sqrt(np.sum(cat_I))
np.linalg.norm(cat_ψ)
def order_by_size(ψ, q):
size = [2 for i in range(2*q)]
ndx = [i + j for i in range(q) for j in [0, q]]
return ψ.reshape(size).transpose(ndx)
def order_by_dimension(ψ, q):
size = [2 for i in range(2*q)]
ndx = [2*i + j for j in [0,1] for i in range(q)]
return ψ.reshape(size).transpose(ndx)
def image2state(image, reorder=True):
# Convert image to an array
image = ImageOps.grayscale(image)
image_I = np.asarray(image)
# Reshape to fit some qubit size, the same for both dimensions
L1, L2 = image_I.shape
q1 = int(round(np.log2(L1)))
q2 = int(round(np.log2(L2)))
q = max(q1, q2)
L = 2**q
new_I = np.zeros((L, L), dtype=np.float64)
new_I[0:L1,0:L2] = image_I
I_t = np.sum(new_I.flatten())
ψ = np.sqrt(new_I.flatten())/np.sqrt(I_t)
if reorder:
ψ = order_by_size(ψ, q)
return ψ
def intensity2image(I):
I = np.uint8(np.round(I/np.max(I) * 255.0))
return Image.fromarray(I)
def state2image(ψ, reorder=True):
q = int(round(np.log2(ψ.size))) // 2
L = 2**q
if reorder:
ψ = order_by_dimension(ψ, q)
return intensity2image(np.abs(ψ*ψ).reshape((L,L)))
state2image(image2state(cat, reorder=True), reorder=True)
def resample(ψ, nqubits=None, reorder=True):
q = int(np.round(np.log2(ψ.size)))
if nqubits is None:
nqubits = q-2
elif nqubits < 0:
nqubits = q + nqubits
L1 = 2**nqubits
L2 = ψ.size // L1
#
# We are now going to extract the diagonal of
# the reduced density matrix, and output it as a
# new image
if True:
I = np.einsum('kii->k',
ψ.reshape((L1, L2, 1)) * ψ.conj().reshape(L1, 1, L2))
else:
# This is very slow and consumes a lot of memory
ρ = ψ.reshape((L1,L2)) @ ψ.reshape((L1,L2)).T.conj()
I = np.diag(ρ)
# We may need to undo the ordering of qubits
I = order_by_dimension(I, nqubits//2)
# Intensity is now a vector. We have to rearrange it into
# a square matrix for converting it to an image
L = 2**(nqubits//2)
return intensity2image(I.reshape((L,L)))
resample(image2state(cat), -2)
resample(image2state(cat), -4)
resample(image2state(cat), -6)
resample(image2state(cat), -8)
def enlarge(ψ, nqb):
ψ = ψ.reshape((ψ.size,1)) * np.ones((1,2**nqb))
ψ = ψ.flatten()
return ψ / np.linalg.norm(ψ)
state2image(enlarge(image2state(resample(image2state(cat), -8)), 8))
def Gaussian(nqb, σ=0.1, reorder=True):
x = np.linspace(-1, 1, 2**nqb)
f = np.exp(-0.5 * (x/σ)**2)
f /= np.linalg.norm(f)
ψ = f.reshape((1,2**nqb)) * f.reshape((2**nqb,1))
if reorder:
ψ = order_by_size(ψ, nqb)
return ψ / np.linalg.norm(ψ.flatten())
aux = state2image(Gaussian(9, 0.2))
aux
resample(image2state(aux), -2)
resample(image2state(aux), -4)
resample(image2state(aux), -6)
resample(image2state(aux), -8)
state2image(enlarge(image2state(resample(image2state(aux), -8)), 8))
def Schmidt(ψ, qubits_left=1):
Lleft = 2**qubits_left
Lright = ψ.size // Lleft
ψ = ψ / np.linalg.norm(ψ)
A = ψ.reshape((Lleft, Lright))
Φ, sqrtΛ, Ξ = np.linalg.svd(A)
return (sqrtΛ)**2
ψGaus = Gaussian(9, 0.2)
ψcat = image2state(cat)
fig, ax = plt.subplots()
ax.plot(Schmidt(ψcat, 9), label='cat')
ax.plot(Schmidt(ψGaus, 9), label='Gaussian')
ax.set_ylabel('$\\lambda_i$')
ax.set_xlabel('#eigenvalue')
ax.set_yscale('log')
ax.set_ylim([1e-12,1.2])
ax.legend();
|
https://github.com/rubenandrebarreiro/summer-school-on-quantum-computing-software-for-near-term-quantum-devices-2020
|
rubenandrebarreiro
|
# Importing matplotlib, "in line"
%matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, execute, Aer, IBMQ, QuantumRegister, ClassicalRegister
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
# In Jupyter Notebooks we can display this nicely using Latex.
# If not using Jupyter Notebooks you may need to remove the
# array_to_latex function and use print() instead.
from qiskit_textbook.tools import array_to_latex
# Create a Quantum Register for 2 Qubits (Quantum Bits), with a Total of 4 (2^2) Possible Processed States
qr = QuantumRegister(2)
# Create a Classical Register for 2 Bits (Classical Bits), with a Total of 2 Possible Processed States
cr = ClassicalRegister(2)
# Create a Quantum Circuit, with the two previously created Quantum and Classical Registers
qc = QuantumCircuit(qr,cr)
# Let's setup the set of necessary instructions, in order to build a Quantum Circuit,
# that implements a Quantum Maximally Entangled State in Quantum System with 2 Qubits (Quantum Bits),
# in which if a Qubit it's measured, independently of its outcome, the other Qubit (Quantum Bit)
# will collapse automatically, no matter the distance that separates the both Qubits (Quatum Bits),
# holding the same outcome, i.e., what's it's called, a Bell State, in Quantum Physics/Mechanics
# Per example:
# a) If the 1st Qubit (Quantum Bit) it's measured and collapse to the Classical State |0>,
# it's possible to state with certainty that the 2nd Qubit (Quantum Bit) will also collapse to
# the Classical State |0>, for sure;
# b) If the 1st Qubit (Quantum Bit) it's measured and collapse to the Classical State |1>,
# it's possible to state with certainty that the 2nd Qubit (Quantum Bit) will also collapse to
# the Classical State |1>, for sure;
# Note:
# - The observations derived from this experiment it's also valid, following the same idea,
# when the 2nd Qubit (Quantum Bit) it's measured instead of the 1st Qubit (Quantum Bit)
# Any Quantum Entanglement of States, it's implemented using the CX/CNOT Quantum Logic Gate
# (Controlled-X/Controlled-NOT), which acts on 2 Qubits (Quantum Bits), described as the following:
# - 1) Control Qubit (Quantum Bit);
# - 2) Target Qubit (Quantum Bit);
# This CX/CNOT Quantum Logic Gate (Controlled-X/Controlled-NOT) it's simple and
# has the following behaviour:
# - If the Control Qubit (Control Quantum Bit) it's set as |1>,
# performs the Pauli-X Quantum Logic Gate Operator (X Quantum Logic Gate Operator)
# onto the the Target Qubit (Target Quantum Bit);
# - Otherwise, if the Control Qubit (Control Quantum Bit) it's set as |0>,
# don't perform any Quantum Logic Gate Operator (X Quantum Logic Gate Operator)
# onto the the Target Qubit (Target Quantum Bit), letting it unchanged;
# The CX/CNOT Quantum Logic Gate (Controlled-X/Controlled-NOT) has a behaviour practically equal to a
# XOR Classical Logic Gate Operator (eXclusive OR Classical Logic Gate Operator):
# - CNOT x |q1,q2> = |q1, (q1 ⊕ q2)>;
# Note:
# - In Mathematics, the XOR Classical Logic Gate Operator (eXclusive OR Classical Logic Gate Operator)
# it's represented by the Modulo 2 Arithmetic Addition Operator
# (i.e., represented by the mathematically notation of ⊕);
# Initially, the Quantum Circuit has the both Qubits (Quantum Bits) set as |0>,
# thus the Quantum Circuit, it's represented as the Tensor Product of that two Qubits (Quantum Bits),
# forming a new Quantum State defined as |00>:
# - |Ψ> = |q1>|q2> = |0>|0> = |0> ⊗ |0> = |00>;
# Steps to build this Quantum Circuit:
# 1) In order to, explore all the possible situations of this Experiment,
# let's put the Control Qubit (Control Quantum Bit) in this Quantum Circuit,
# in a Quantum Superposition of States, applying the Hadamard Quantum Logic Gate Operator to it,
# letting the Quantum System defined as:
# - |Ψ> = 1/√2 x (|00> + |10>),
# where the 1st Qubit (Quantum Bit) it's in Quantum Superposition of States;
qc.h(0)
# 2) In order to, explore all the possible situations of this Experiment,
# let's put the Control Qubit (Control Quantum Bit) in this Quantum Circuit,
# in a Quantum Superposition of States, applying the Hadamard Quantum Logic Gate Operator to it,
# letting the Quantum System defined as:
# - |Ψ> = 1/√2 x (|00> + |11>), where:
# - The 1st Qubit (Quantum Bit) it's in Quantum Superposition of States;
# - The 2nd Qubit (Quantum Bit) it's a result of the Pauli-X Quantum Logic Quantum Gate Operator,
# in the cases that the Control Qubit (Control Quantum Bit) it's set as |1>, i.e.,
# the 2nd term of the Quantum System, where |10> => |11>,
# after being applied the CX/CNOT Quantum Logic Gate (Controlled-X/Controlled-NOT);
qc.cnot(0,1)
# Draw the Quantum Circuit for the Bell State, in a graphically representation
qc.draw()
# Print the Quantum Circuit for the Bell State, in a text representation
print(qc)
# Print the Backends available in the Aer Module of the IBM Qiskit Library:
# - The Aer Module, it's the Module responsible for the Simulator of the IBM Qiskit Libraries;
Aer.backends()
# Getting the Backend for the Unitary Representation
# (i.e., the Quantum State represented as an Unitary Matrix)
backend = Aer.get_backend('unitary_simulator')
unitary = execute(qc,backend).result().get_unitary()
array_to_latex(unitary, pretext="\\text{Quantum Circuit (Unitary Matrix) = }\n")
# Getting the Backend for the Statevector Representation
# (i.e., the Quantum State represented as State Vector)
statevector_backend = Aer.get_backend('statevector_simulator')
final_state = execute(qc,statevector_backend).result().get_statevector()
array_to_latex(final_state, pretext="\\text{Quantum Circuit (Statevector) = }\n", precision = 1)
# Plot the Bloch Spheres of the previously defined Quantum System (or, try it...),
# representing a Bell State
# Note:
# - In fact it's not possible to plot Bloch Spheres representing a whole Quantum System,
# which it's currently in a Quantum Entanglement of States, in IBM Qiskit;
plot_bloch_multivector(final_state)
# But, it's possible to plot the Q-Sphere of this Quantum Circuit
# (a "linear" combination of the several Bloch Spheres, involved) of
# the previously defined Quantum System, representing a Bell State
plot_state_qsphere(final_state)
# Now, that the Quantum Circuit it's practically defined, let's apply a Barrier to it, in order to,
# ensure that all the previous Quantum Logic Gate Operators are applied correctly
qc.barrier()
# Draw the Quantum Circuit again, after the Barrier be applied in it
qc.draw()
# Measure the State of the both Qubits (Quantum Bits), contained in the Quantum Circuit
qc.measure(0,0)
qc.measure(1,1)
# Draw the Quantum Circuit again, after the Measurement of the States be applied in it
qc.draw()
# Now, let's execute the Quantum Circuit in the QASM Simulator of the Aer Module,
# of the IBM Qiskit Library
backend = Aer.get_backend('qasm_simulator')
counts = execute(qc,backend,shots=2048).result().get_counts()
# Print the Counts of the Frequencies, resulting from this Experiment
print(counts)
# Plot the Counts of the Frequencies, resulting from this Experiment, through a Histogram
# (i.e., a Distribution of the Probabilities)
plot_histogram(counts)
# Import the IBM Q Experience, from the IBM Qiskit Library
from qiskit import IBMQ
# Update your account info saved locally
IBMQ.update_account()
# Run everytime to load your account info saved locally
IBMQ.load_account()
# Get a Provider, from the IBM Q Hub
provider = IBMQ.get_provider(hub='ibm-q')
# Print available Backends, from the Provider set before
provider.backends()
# Import the "Least Busy" function, in order to get a "Least Busy" Backend
from qiskit.providers.ibmq import least_busy
# Filter the available Backends, in order to get a list of "Large Enough Real Quantum Devices",
# i.e., containing 2 or more 2 Qubits (Quantum Bits)
large_enough_devices = provider.backends(filters = lambda b: b.configuration().n_qubits >= 2 and
not b.configuration().simulator
and b.status().operational==True)
# Or, select the "Least Busy" Backend, from the list of "Large Enough Real Quantum Devices"
backend = least_busy(large_enough_devices)
# Print the Best Backend available (i.e., the Least Busy Backend)
print("The Best Backend is: " + backend.name())
# Execute a Job for this Quantum Circuit, executing the Experiment, for 8192 Shots
job_exp = execute(qc,backend=backend,shots=8192)
# Get the Experiment Result from the previous executed Job for this Quantum Circuit
exp_result = job_exp.result()
# Get the Measurement Results, from the previous Experiment Result,
# executed by the Job for this Quantum Circuit
exp_measurement_result = exp_result.get_counts(qc)
# Print the Measurement Results, from the previous Experiment Result,
# executed by the Job for this Quantum Circuit
print(exp_measurement_result)
# Plot the Histogram (i.e., Frequencies) for the Measurement Results,
# from the previous Experiment Result, executed by the Job for this Quantum Circuit
plot_histogram(exp_measurement_result)
|
https://github.com/rubenandrebarreiro/summer-school-on-quantum-computing-software-for-near-term-quantum-devices-2020
|
rubenandrebarreiro
|
# Importing matplotlib, "in line"
%matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, execute, Aer, IBMQ, QuantumRegister, ClassicalRegister
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
# In Jupyter Notebooks we can display this nicely using Latex.
# If not using Jupyter Notebooks you may need to remove the
# array_to_latex function and use print() instead.
from qiskit_textbook.tools import array_to_latex
# Create a Quantum Register for 2 Qubits (Quantum Bits), with a Total of 4 (2^2) Possible Processed States
qr = QuantumRegister(2)
# Create a Classical Register for 2 Bits (Classical Bits), with a Total of 2 Possible Processed States
cr = ClassicalRegister(2)
# Create a Quantum Circuit, with the two previously created Quantum and Classical Registers
qc = QuantumCircuit(qr,cr)
# Let's setup the set of necessary instructions, in order to build a Quantum Circuit,
# that implements a Quantum Entangled State in Quantum System with 2 Qubits (Quantum Bits),
# in which if a Qubit it's measured, independently of its outcome, the other Qubit (Quantum Bit)
# will collapse automatically, no matter the distance that separates the both Qubits (Quatum Bits),
# holding the opposite outcome, i.e., what's it's called, the Pauli Exclusion Principle,
# in Quantum Physics/Mechanics
# Per example:
# a) If the 1st Qubit (Quantum Bit) it's measured and collapse to the Classical State |0>,
# it's possible to state with certainty that the 2nd Qubit (Quantum Bit) will also collapse to
# the opposite Classical State |1>, for sure;
# b) If the 1st Qubit (Quantum Bit) it's measured and collapse to the Classical State |1>,
# it's possible to state with certainty that the 2nd Qubit (Quantum Bit) will also collapse to
# the opposite Classical State |0>, for sure;
# Note:
# - The observations derived from this experiment it's also valid, following the same idea,
# when the 2nd Qubit (Quantum Bit) it's measured instead of the 1st Qubit (Quantum Bit)
# Any Quantum Entanglement of States, it's implemented using the CX/CNOT Quantum Logic Gate
# (Controlled-X/Controlled-NOT), which acts on 2 Qubits (Quantum Bits), described as the following:
# - 1) Control Qubit (Quantum Bit);
# - 2) Target Qubit (Quantum Bit);
# This CX/CNOT Quantum Logic Gate (Controlled-X/Controlled-NOT) it's simple and
# has the following behaviour:
# - If the Control Qubit (Control Quantum Bit) it's set as |1>,
# performs the Pauli-X Quantum Logic Gate Operator (X Quantum Logic Gate Operator)
# onto the the Target Qubit (Target Quantum Bit);
# - Otherwise, if the Control Qubit (Control Quantum Bit) it's set as |0>,
# don't perform any Quantum Logic Gate Operator (X Quantum Logic Gate Operator)
# onto the the Target Qubit (Target Quantum Bit), letting it unchanged;
# The CX/CNOT Quantum Logic Gate (Controlled-X/Controlled-NOT) has a behaviour practically equal to a
# XOR Classical Logic Gate Operator (eXclusive OR Classical Logic Gate Operator):
# - CNOT x |q1,q2> = |q1, (q1 ⊕ q2)>;
# Note:
# - In Mathematics, the XOR Classical Logic Gate Operator (eXclusive OR Classical Logic Gate Operator)
# it's represented by the Modulo 2 Arithmetic Addition Operator
# (i.e., represented by the mathematically notation of ⊕);
# Initially, the Quantum Circuit has the both Qubits (Quantum Bits) set as |0>,
# thus the Quantum Circuit, it's represented as the Tensor Product of that two Qubits (Quantum Bits),
# forming a new Quantum State defined as |00>:
# - |Ψ> = |q1>|q2> = |0>|0> = |0> ⊗ |0> = |00>;
# Steps to build this Quantum Circuit:
# 1) Initially, let's set the 2nd Qubit (Quantum Bit),
# acting as the Control Qubit (Control Quantum Bit) as |1>,
# applying the Pauli-X Quantum Logic Quantum Gate Operator;
qc.x(1)
# 2) Let's apply a Barrier to it, in order to, ensure that all the
# previous Quantum Logic Gate Operators are applied correctly;
qc.barrier()
# 3) In order to, explore all the possible situations of this Experiment,
# let's put the Control Qubit (Control Quantum Bit) in this Quantum Circuit,
# in a Quantum Superposition of States, applying the Hadamard Quantum Logic Gate Operator to it,
# letting the Quantum System defined as:
# - |Ψ> = 1/√2 x (|01> + |11>),
# where the 1st Qubit (Quantum Bit) it's in Quantum Superposition of States;
qc.h(0)
# 4) In order to, explore all the possible situations of this Experiment,
# let's put the Control Qubit (Control Quantum Bit) in this Quantum Circuit,
# in a Quantum Superposition of States, applying the Hadamard Quantum Logic Gate Operator to it,
# letting the Quantum System defined as:
# - |Ψ> = 1/√2 x (|01> + |10>), where:
# - The 1st Qubit (Quantum Bit) it's in Quantum Superposition of States;
# - The 2nd Qubit (Quantum Bit) it's a result of the Pauli-X Quantum Logic Quantum Gate Operator,
# in the cases that the Control Qubit (Control Quantum Bit) it's set as |1>, i.e.,
# the 2nd term of the Quantum System, where |11> => |10>,
# after being applied the CX/CNOT Quantum Logic Gate (Controlled-X/Controlled-NOT);
qc.cnot(0,1)
# Draw the Quantum Circuit for the Pauli Exclusion Principle, in a graphically representation
qc.draw()
# Print the Quantum Circuit for the Pauli Exclusion Principle, in a text representation
print(qc)
# Print the Backends available in the Aer Module of the IBM Qiskit Library:
# - The Aer Module, it's the Module responsible for the Simulator of the IBM Qiskit Libraries;
Aer.backends()
# Getting the Backend for the Unitary Representation
# (i.e., the Quantum State represented as an Unitary Matrix)
backend = Aer.get_backend('unitary_simulator')
unitary = execute(qc,backend).result().get_unitary()
array_to_latex(unitary, pretext="\\text{Quantum Circuit (Unitary Matrix) = }\n")
# Getting the Backend for the Statevector Representation
# (i.e., the Quantum State represented as State Vector)
statevector_backend = Aer.get_backend('statevector_simulator')
final_state = execute(qc,statevector_backend).result().get_statevector()
array_to_latex(final_state, pretext="\\text{Quantum Circuit (Statevector) = }\n", precision = 1)
# Plot the Bloch Spheres of the previously defined Quantum System (or, try it...),
# representing a Pauli Exclusion Principle
# Note:
# - In fact it's not possible to plot Bloch Spheres representing a whole Quantum System,
# which it's currently in a Quantum Entanglement of States, in IBM Qiskit;
plot_bloch_multivector(final_state)
# But, it's possible to plot the Q-Sphere of this Quantum Circuit
# (a "linear" combination of the several Bloch Spheres, involved) of
# the previously defined Quantum System, representing the Pauli Exclusion Principle
plot_state_qsphere(final_state)
# Now, that the Quantum Circuit it's practically defined, let's apply a Barrier to it, in order to,
# ensure that all the previous Quantum Logic Gate Operators are applied correctly
qc.barrier()
# Draw the Quantum Circuit again, after the Barrier be applied in it
qc.draw()
# Measure the State of the both Qubits (Quantum Bits), contained in the Quantum Circuit
qc.measure(0,0)
qc.measure(1,1)
# Draw the Quantum Circuit again, after the Measurement of the States be applied in it
qc.draw()
# Now, let's execute the Quantum Circuit in the QASM Simulator of the Aer Module,
# of the IBM Qiskit Library
backend = Aer.get_backend('qasm_simulator')
counts = execute(qc,backend,shots=2048).result().get_counts()
# Print the Counts of the Frequencies, resulting from this Experiment
print(counts)
# Plot the Counts of the Frequencies, resulting from this Experiment, through a Histogram
# (i.e., a Distribution of the Probabilities)
plot_histogram(counts)
# Import the IBM Q Experience, from the IBM Qiskit Library
from qiskit import IBMQ
# Update your account info saved locally
IBMQ.update_account()
# Run everytime to load your account info saved locally
IBMQ.load_account()
# Get a Provider, from the IBM Q Hub
provider = IBMQ.get_provider(hub='ibm-q')
# Print available Backends, from the Provider set before
provider.backends()
# Import the "Least Busy" function, in order to get a "Least Busy" Backend
from qiskit.providers.ibmq import least_busy
# Filter the available Backends, in order to get a list of "Large Enough Real Quantum Devices",
# i.e., containing 2 or more 2 Qubits (Quantum Bits)
large_enough_devices = provider.backends(filters = lambda b: b.configuration().n_qubits >= 2 and
not b.configuration().simulator
and b.status().operational==True)
# Or, select the "Least Busy" Backend, from the list of "Large Enough Real Quantum Devices"
backend = least_busy(large_enough_devices)
# Print the Best Backend available (i.e., the Least Busy Backend)
print("The Best Backend is: " + backend.name())
# Execute a Job for this Quantum Circuit, executing the Experiment, for 8192 Shots
job_exp = execute(qc,backend=backend,shots=8192)
# Get the Experiment Result from the previous executed Job for this Quantum Circuit
exp_result = job_exp.result()
# Get the Measurement Results, from the previous Experiment Result,
# executed by the Job for this Quantum Circuit
exp_measurement_result = exp_result.get_counts(qc)
# Print the Measurement Results, from the previous Experiment Result,
# executed by the Job for this Quantum Circuit
print(exp_measurement_result)
# Plot the Histogram (i.e., Frequencies) for the Measurement Results,
# from the previous Experiment Result, executed by the Job for this Quantum Circuit
plot_histogram(exp_measurement_result)
|
https://github.com/rubenandrebarreiro/summer-school-on-quantum-computing-software-for-near-term-quantum-devices-2020
|
rubenandrebarreiro
|
# useful additional packages
import matplotlib.pyplot as plt
import matplotlib.axes as axes
import numpy as np
import networkx as nx
from qiskit import Aer, execute, QuantumCircuit
from qiskit.quantum_info import Statevector
# auxilliary function to plot graphs
def plot_result(G, x):
colors = ['r' if x[i] == 0 else 'b' for i in range(n)]
pos, default_axes = nx.spring_layout(G), plt.axes(frameon=True)
nx.draw_networkx(G, node_color=colors, node_size=600, alpha=.8, pos=pos)
# create graph
G = nx.Graph()
# add nodes
n = 5
G.add_nodes_from(range(n))
# add edges: tuple is (i,j,weight) where (i,j) is the edge
edges = [(0, 1, 1.0), (0, 2, 1.0), (0, 3, 1.0), (1, 2, 1.0), (2, 3, 1.0), (2, 4, 1.0), (3, 4, 1.0)]
G.add_weighted_edges_from(edges)
# plot graph
plot_result(G, [0]*n)
from docplex.mp.model import Model
mdl = Model('MaxCut')
x = mdl.binary_var_list('x{}'.format(i) for i in range(n))
objective = mdl.sum([ w * (x[i] + x[j] - 2*x[i]*x[j]) for (i, j, w) in edges])
mdl.maximize(objective)
mdl.prettyprint()
b = 2
mdl.add_constraint(mdl.sum(x) == b)
mdl.prettyprint()
conda install -c ibmdecisionoptimization cplex
from qiskit.optimization import QuadraticProgram
from qiskit.optimization.algorithms import CplexOptimizer
# convert from DOcplex model to Qiskit Quadratic Program
qp = QuadraticProgram()
qp.from_docplex(mdl)
# Solve Quadratic Program using CPLEX
cplex = CplexOptimizer()
result = cplex.solve(qp)
print(result)
plot_result(G, result.x)
from qiskit.optimization.converters import (
InequalityToEquality, # converts inequality constraints to equality constraints by adding slack variables
LinearEqualityToPenalty, # converts linear equality constraints to quadratic penalty terms
IntegerToBinary, # converts integer variables to binary variables
QuadraticProgramToQubo # combines the previous three converters
)
lineq2penalty = LinearEqualityToPenalty(penalty=1)
qp_wo_constr = lineq2penalty.convert(qp)
qp_wo_constr
# Solve converted Quadratic Program using CPLEX
result = cplex.solve(qp_wo_constr)
print(result)
plot_result(G, result.x)
H, offset = qp_wo_constr.to_ising()
print('offset =', offset)
print()
print('H =', H)
# print Ising Hamiltonian as matrix
H_matrix = np.real(H.to_matrix())
print('dim(H):', H_matrix.shape)
print(H_matrix)
# plot diagonal of matrix
opt_indices = list(np.where(H_matrix.diagonal() == min(H_matrix.diagonal())))[0]
plt.figure(figsize=(12, 5))
plt.bar(range(2**n), H_matrix.diagonal())
plt.bar(opt_indices, H_matrix.diagonal()[opt_indices], color='g')
plt.xticks(range(2**n), ['('+str(i)+') {0:05b}'.format(i) for i in range(2**n)], rotation=90, fontsize=14)
plt.yticks(fontsize=14)
plt.show()
from qiskit.circuit.library import RealAmplitudes
qc = RealAmplitudes(5, reps=1)
qc.draw(fold=120)
# run VQE
from qiskit.aqua.algorithms import VQE
vqe = VQE(H, qc, quantum_instance=Aer.get_backend('statevector_simulator'))
result = vqe.run()
print('optimal value:', np.round(result.eigenvalue, decimals=4))
# plot probabilities
probabilities = np.abs(result.eigenstate)**2
plt.figure(figsize=(12, 5))
plt.bar(range(2**n), probabilities)
plt.bar(opt_indices, probabilities[opt_indices], color='g')
plt.xticks(range(2**n), ['('+str(i)+') {0:05b}'.format(i) for i in range(2**n)], rotation=90, fontsize=14)
plt.yticks(fontsize=14)
plt.show()
from qiskit.circuit import Parameter
gamma, beta = Parameter('gamma'), Parameter('beta')
qc = QuantumCircuit(1)
qc.h(0)
qc.barrier()
qc.rz(gamma, 0)
qc.rx(beta, 0)
qc.barrier()
qc.draw()
def construct_schedule(T, N):
delta_t = T/N
gammas, betas = [], [] # H_C, H_X parameters
for i in range(N+1):
t = i * delta_t
gammas += [ 2 * delta_t * t/T ] # H_C
betas += [ -2 * delta_t * (1 - t/T) ] # H_X
return gammas, betas
T = 5
N = 10
gammas, betas = construct_schedule(T, N)
plt.figure(figsize=(10, 4))
plt.plot(np.linspace(0, T, N+1), gammas, label='gammas')
plt.plot(np.linspace(0, T, N+1), betas, label='betas')
plt.legend(fontsize=14)
plt.xticks(fontsize=14)
plt.xlabel('time', fontsize=14)
plt.yticks(fontsize=14)
plt.ylabel('parameters', fontsize=14);
# track probabilities during trotterized annealing
probabilities = np.zeros((2, N+1))
# construct circuit
qc = QuantumCircuit(1)
qc.h(0)
qc.barrier()
for i, (gamma, beta) in enumerate(zip(gammas, betas)):
qc.rz(gamma, 0)
qc.rx(beta, 0)
qc.barrier()
probabilities[:, i] = Statevector.from_instruction(qc).probabilities()
qc.draw()
plt.figure(figsize=(12, 7))
plt.plot(np.linspace(0, T, N+1), probabilities[1, :], 'gd-', label=r'$|1\rangle$')
plt.plot(np.linspace(0, T, N+1), probabilities[0, :], 'bo-', label=r'$|0\rangle$')
plt.legend(fontsize=14)
plt.xticks(fontsize=14)
plt.xlabel('time $t$', fontsize=14)
plt.yticks(fontsize=14)
plt.ylabel('probabilities', fontsize=14);
plt.figure(figsize=(12, 7))
plt.plot(np.linspace(0, T, N+1), probabilities[0, :] - probabilities[1, :], 'gd-')
plt.xticks(fontsize=14)
plt.xlabel('time $t$', fontsize=14)
plt.yticks(fontsize=14)
plt.ylabel('objective value', fontsize=14);
gamma = Parameter('gamma')
qc1 = QuantumCircuit(2)
qc1.cx(0, 1)
qc1.rz(gamma, 1)
qc1.cx(0, 1)
qc1.draw()
qc2 = QuantumCircuit(2)
qc2.rzz(gamma, 0, 1)
qc2.draw()
from qiskit.aqua.algorithms.minimum_eigen_solvers.qaoa.var_form import QAOAVarForm
# construct parameters from annealing schedule
T = 10
N = 20
gammas, betas = construct_schedule(T, N)
# construct variational form
var_form = QAOAVarForm(H, N+1)
# evaluate circuit
qc = var_form.construct_circuit(gammas + betas)
sv = Statevector.from_instruction(qc)
# plot probabilities
probabilities = sv.probabilities()
plt.figure(figsize=(12, 5))
plt.bar(range(2**n), probabilities)
plt.bar(opt_indices, probabilities[opt_indices], color='g')
plt.xticks(range(2**n), ['('+str(i)+') {0:05b}'.format(i) for i in range(2**n)], rotation=90, fontsize=14)
plt.yticks(fontsize=14);
# draw trotterized annealing circuit for MaxCut
qc.draw()
from qiskit.aqua.components.optimizers import COBYLA
# QAOA circuit for p = 1
gamma, beta = Parameter('gamma'), Parameter('beta')
qc = QuantumCircuit(1)
qc.h(0)
qc.rz(gamma, 0)
qc.rx(beta, 0)
def objective(params):
qc_ = qc.bind_parameters({gamma: params[0], beta: params[1]})
probs = Statevector.from_instruction(qc_).probabilities()
return probs @ [1, -1]
optimizer = COBYLA()
result = optimizer.optimize(num_vars=2, objective_function=objective, initial_point=[0.5, 0.5])
print('optimal params:', np.round(result[0], decimals=4))
print('optimal value: ', np.round(result[1], decimals=4))
print('optimal state: ', np.round(Statevector.from_instruction(qc.bind_parameters(
{gamma: result[0][0], beta: result[0][1]})).data, decimals=4))
# illustrating the QAOA var form
p = 1
var_form = QAOAVarForm(H, p)
var_form.construct_circuit([gamma, beta]).draw()
from qiskit.aqua.algorithms import QAOA
qaoa_mes = QAOA(H, p=1, optimizer=optimizer, quantum_instance=Aer.get_backend('statevector_simulator'))
result = qaoa_mes.run()
print('optimal params: ', result.optimal_parameters)
print('optimal value: ', result.optimal_value)
print('optimal probability: ', sum(np.abs(result.eigenstate[opt_indices])**2))
# plot probabilities
probabilities = np.abs(result['eigenstate'])**2
plt.figure(figsize=(12, 5))
plt.bar(range(2**n), probabilities)
plt.bar(opt_indices, probabilities[opt_indices], color='g')
plt.xticks(range(2**n), ['('+str(i)+') {0:05b}'.format(i) for i in range(2**n)], rotation=90, fontsize=14)
plt.yticks(fontsize=14)
plt.show()
from qiskit.optimization.algorithms import MinimumEigenOptimizer
# construct QAOA as Minimum Eigensolver
qaoa_mes = QAOA(p=1, optimizer=optimizer, quantum_instance=Aer.get_backend('statevector_simulator'))
# construct Minimum Eigen Optimizer based on QAOA
qaoa = MinimumEigenOptimizer(qaoa_mes)
# solve Quadratic Program
result = qaoa.solve(qp)
print(result)
plot_result(G, result.x)
# converts two's complement bit string to corresponding integer
def twos_complement(val, num_bits):
val = int(val, 2)
if (val & (1 << (num_bits - 1))) != 0:
val = val - (1 << num_bits)
return val
print(twos_complement('0011', 4))
print(twos_complement('1011', 4))
from qiskit.circuit.library import QFT
def encode(num_qubits, k):
qc = QuantumCircuit(num_qubits, name='enc({})'.format(k))
for i in range(num_qubits):
theta = 2*np.pi * 2**i / 2**num_qubits * k
qc.rz(theta, i)
return qc
num_value_qubits = 4
qc = QuantumCircuit(num_value_qubits, num_value_qubits)
qc.h(range(num_value_qubits))
qc.barrier()
qc.append(encode(num_value_qubits, 2), range(num_value_qubits))
qc.barrier()
qc.append(QFT(num_value_qubits, do_swaps=False).inverse(), qc.qubits)
qc.measure(qc.qregs[0], qc.cregs[0][::-1])
qc.draw(fold=120)
num_value_qubits = 4
qc = QuantumCircuit(num_value_qubits, num_value_qubits)
qc.h(range(num_value_qubits))
qc.barrier()
qc.extend(encode(num_value_qubits, 2))
# qc.extend(encode(num_value_qubits, -3))
# qc.extend(encode(num_value_qubits, 4))
qc.barrier()
qc.append(QFT(num_value_qubits, do_swaps=False, inverse=True), qc.qubits)
qc.measure(qc.qregs[0], qc.cregs[0][::-1])
qc.draw(fold=120)
counts = execute(qc, Aer.get_backend('qasm_simulator')).result().get_counts()
for key in counts:
print(key, ' -->', twos_complement(key, num_value_qubits))
num_input_qubits = 3
num_total_qubits = num_input_qubits + num_value_qubits
qc = QuantumCircuit(num_total_qubits)
qc.h([0, 1, 2])
qc.barrier()
qc.h(range(num_input_qubits, num_total_qubits))
qc.append(encode(num_value_qubits, 2).control(2), [0, 2] + list(range(num_input_qubits, num_total_qubits)))
qc.append(encode(num_value_qubits, -3).control(), [1] + list(range(num_input_qubits, num_total_qubits)))
qc.append(encode(num_value_qubits, 4).control(), [2] + list(range(num_input_qubits, num_total_qubits)))
qc.append(QFT(num_value_qubits, do_swaps=False).inverse(), range(num_input_qubits, num_total_qubits))
qc.measure_all()
qc.draw(fold=120)
counts = execute(qc, Aer.get_backend('qasm_simulator')).result().get_counts()
for key, value in counts.items():
x = key[num_value_qubits:]
y_bin = key[:num_value_qubits][::-1]
y_int = twos_complement(y_bin, num_value_qubits)
print(x, '-->', y_bin, '-->', y_int, '\t(counts: {})'.format(value))
from qiskit.circuit.library import QuadraticForm
# get quadratic / linear / constant part of quadratic program
A = qp_wo_constr.objective.quadratic.to_array()
b = qp_wo_constr.objective.linear.to_array()
c = qp_wo_constr.objective.constant
# set number of results qubits
num_value_qubits = 5
# construct circuit to evaluate quadratic form
qf = QuadraticForm(num_value_qubits, A, b, c)
qf.draw(fold=115)
qc = QuantumCircuit(n + num_value_qubits)
qc.h(range(n))
qc.append(qf, range(n + num_value_qubits))
qc.measure_all()
qc.draw()
counts = execute(qc, backend=Aer.get_backend('qasm_simulator')).result().get_counts()
for key, value in counts.items():
x_ = key[num_value_qubits:]
x = [0 if x__ == '0' else 1 for x__ in x_][::-1]
y_bin = key[:num_value_qubits]
y_int = twos_complement(y_bin, num_value_qubits)
qx = qp_wo_constr.objective.evaluate(x)
print('x =', x_, '\ty_bin =', y_bin, '\ty_int =', y_int, '\tQ(x) =', qx, '\t(counts: {})'.format(value))
qc = QuantumCircuit(n + num_value_qubits, name='U_f')
qc.append(qf, range(n + num_value_qubits)) # 1. compute Q(x)
qc.z(qc.qubits[-1]) # 2. multiply all |x>|Q(x)> by -1 where Q(x) < 0.
qc.append(qf.inverse(), range(n + num_value_qubits)) # 3. uncompute Q(x).
qc.draw()
qc_grover = QuantumCircuit(n + num_value_qubits)
qc_grover.h(range(n))
qc_grover.append(qc, range(qc_grover.num_qubits))
qc_grover.draw()
data = Statevector.from_instruction(qc_grover).data
x = ['{0:05b}'.format(i) for i in range(2**n)]
y = [qp_wo_constr.objective.evaluate([0 if x__ == '0' else 1 for x__ in reversed(x_)]) for x_ in x]
plt.figure(figsize=(12, 5))
plt.bar(range(2**n), np.real(data[:2**n]))
plt.xticks(range(2**n), ['{} $\leftarrow$ '.format(y[i]) + '{0:05b}'.format(i) for i in range(2**n)], rotation=90, fontsize=14)
plt.yticks(fontsize=14)
plt.show()
reflection = QuantumCircuit(n, name='reflection')
reflection.h(range(reflection.num_qubits))
reflection.barrier()
reflection.x(range(reflection.num_qubits))
reflection.barrier()
reflection.h(-1)
reflection.mct(list(range(reflection.num_qubits - 1)), -1)
reflection.h(-1)
reflection.barrier()
reflection.x(range(reflection.num_qubits))
reflection.barrier()
reflection.h(range(reflection.num_qubits))
reflection.draw()
qc_grover.append(reflection, range(n))
qc_grover.draw()
data = Statevector.from_instruction(qc_grover).data
x = ['{0:05b}'.format(i) for i in range(2**n)]
y = [qp_wo_constr.objective.evaluate([0 if x__ == '0' else 1 for x__ in reversed(x_)]) for x_ in x]
plt.figure(figsize=(12, 5))
plt.bar(range(2**n), -np.real(data[:2**n])) # multiply by -1, since reflection is implemented up to global phase -1
plt.xticks(range(2**n), ['{} $\leftarrow$ '.format(y[i]) + '{0:05b}'.format(i) for i in range(2**n)], rotation=90, fontsize=14)
plt.yticks(fontsize=14)
plt.show()
from qiskit.optimization.algorithms import GroverOptimizer
# set up Grover Optimizer
grover = GroverOptimizer(num_value_qubits=5, quantum_instance=Aer.get_backend('statevector_simulator'))
grover._qubo_converter.penalty = 1 # set to small value to reduce required number of value qubits
# solver problem
result = grover.solve(qp)
print(result)
plot_result(G, result.x)
from qiskit.finance.applications.ising import portfolio
# define tickers and number of assets
n = 6
# set budget
budget = n // 2
# sample expected returns and covariance matrix
mu, sigma = portfolio.random_model(n, seed=4321)
# plot mu/sigma
plt.figure(figsize=(12, 5))
plt.subplot(1,2,1)
plt.title('Expected Returns', fontsize=14)
plt.bar(range(n), mu)
plt.xticks(fontsize=14)
plt.yticks(fontsize=14)
plt.subplot(1,2,2)
plt.title('Covariance Matrix', fontsize=14)
plt.imshow(sigma, interpolation='nearest')
plt.xticks(fontsize=14)
plt.yticks(fontsize=14)
plt.show()
def get_qp(n, mu, sigma, budget, q):
# create model with docplex
mdl = Model('portfolio_optimization')
# define variables:
#
# x_i in {0, 1}
#
x = mdl.binary_var_list(['x{}'.format(i) for i in range(n)])
# set objective function:
#
# maximize { mu^T * x - q * x^T * sigma * x }
#
objective = mdl.sum([mu[i] * x[i] for i in range(n)]) # mu^T * x
objective -= q * mdl.sum([sigma[i][j]*x[i]*x[j] for i in range(n) for j in range(n)])
mdl.maximize(objective)
# add budget constraint:
#
# 1^T * x == budget
#
cost = mdl.sum([x[i] for i in range(n)])
mdl.add_constraint(cost == budget, ctname='budget')
# convert to quadratic program
qp = QuadraticProgram()
qp.from_docplex(mdl)
return qp
# track resulting risk and return
mus = []
sigmas = []
# screen different risk factors
for q in [0, 1, 10]:
# solve the portfolio optimization problem using QAOA
qp = get_qp(n, mu, sigma, budget, q)
result = qaoa.solve(qp)
# track risk and return
mus += [portfolio.portfolio_expected_value(result.x, mu)]
sigmas += [portfolio.portfolio_variance(result.x, sigma)]
# print resulting portfolio
print(result.x)
# plot risk/return efficient frontier
plt.figure(figsize=(8, 5))
plt.plot(sigmas, mus, '--', linewidth=2)
plt.plot(sigmas, mus, 'rD', markersize=7)
plt.xticks(fontsize=14)
plt.yticks(fontsize=14)
plt.xlabel('Risk (Variance)', fontsize=14)
plt.ylabel('Return', fontsize=14)
plt.title('Efficient Frontier', fontsize=14)
plt.show()
|
https://github.com/rubenandrebarreiro/summer-school-on-quantum-computing-software-for-near-term-quantum-devices-2020
|
rubenandrebarreiro
|
#initialization
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
import math
# importing Qiskit
from qiskit import IBMQ, BasicAer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
# import basic plot tools
from qiskit.tools.visualization import plot_histogram
# importing Qiskit
from qiskit import IBMQ, Aer, QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.providers.ibmq import least_busy
from qiskit.quantum_info import Statevector
def cz(circuit,qr):
circuit.h(qr[1])
circuit.cx(qr[0],qr[1])
circuit.h(qr[1])
qr2 = QuantumRegister(2)
czCircuit = QuantumCircuit(qr2)
cz(czCircuit,qr2)
czCircuit.draw(output="mpl")
#Since Z=HXH and X=HZH
#This is identical to a CZ (controlled Z)
def ccz(circuit,qr):
circuit.h(qr[2])
# ccx is the Toffoli gate
circuit.ccx(qr[0], qr[1], qr[2])
circuit.h(qr[2])
qr3 = QuantumRegister(3)
cczCircuit = QuantumCircuit(qr3)
ccz(cczCircuit,qr3)
cczCircuit.draw(output="mpl")
#We are going to check numerically whether this is the CCCZ gate
def cccz(circuit,qr):
pi = math.pi
circuit.x(qr[0]) #we change the inputvalue by applying an X gate at the beggining
circuit.x(qr[1]) #second qubit to 1
circuit.x(qr[2]) #third qubit to 1
circuit.x(qr[3]) #fourth qubit to 1
circuit.cu1(pi/4,qr[0],qr[3])
circuit.cx(qr[0], qr[1])
circuit.cu1(-pi/4, qr[1],qr[3])
circuit.cx(qr[0], qr[1])
circuit.cu1(pi/4, qr[1],qr[3])
circuit.cx(qr[1], qr[2])
circuit.cu1(-pi/4, qr[2],qr[3])
circuit.cx(qr[0], qr[2])
circuit.cu1(pi/4, qr[2],qr[3])
circuit.cx(qr[1], qr[2])
circuit.cu1(-pi/4, qr[2],qr[3])
circuit.cx(qr[0], qr[2])
circuit.cu1(pi/4, qr[2],qr[3])
qr4 = QuantumRegister(4)
ccczCircuit = QuantumCircuit(qr4)
cccz(ccczCircuit,qr4)
ccczCircuit.draw(output="mpl")
from qiskit.visualization import plot_state_qsphere
sv_sim = Aer.get_backend('statevector_simulator')
job_sim = execute(ccczCircuit, sv_sim)
statevec = job_sim.result().get_statevector()
from qiskit_textbook.tools import vector2latex
#vector2latex(statevec, pretext="|\\psi\\rangle =")
plot_state_qsphere(statevec)
def n_controlled_Z(circuit, qr):
"""Implement a Z gate with multiple controls"""
if (len(qr) > 4):
raise ValueError('The controlled Z with more than 3 controls is not implemented')
# This is the case n = 2 (1 control + 1 target qubit)
elif (len(qr) == 2):
cz(circuit,qr)
# This is the case n = 3 (2 control + 1 target qubit)
elif (len(qr) == 3):
ccz(circuit,qr)
# This is the case n = 4 (3 control + 1 target qubit)
elif (len(qr) == 4):
cccz(circuit,qr)
def phase_oracle(circuit,qr,element):
# element is an array that defines the searched element, for example, element = [0,1,0,1]
circuit.x(qr[0]) #we change the inputvalue by applying an X gate at the beggining
# circuit.x(qr[1]) #for the second qubit
circuit.x(qr[2])
# circuit.x(qr[3])
circuit.barrier() #in this part, we are changing the input to the oracle circuit
n = len(element)
for j,x in enumerate(element):
if (x == 0):
circuit.x(qr[j])
n_controlled_Z(circuit,qr)
for j,x in enumerate(element):
if (x == 0):
circuit.x(qr[j])
element=[0,1,0,1]
qr4 = QuantumRegister(4)
oracleCircuit = QuantumCircuit(qr4)
phase_oracle(oracleCircuit,qr4, element)
oracleCircuit.draw(output="mpl")
oracleCircuit.measure_all()
qasm_simulator = Aer.get_backend('statevector_simulator')
job_sim = execute(oracleCircuit, sv_sim)
statevec = job_sim.result().get_statevector()
from qiskit_textbook.tools import vector2latex
vector2latex(statevec, pretext="|\\psi\\rangle =")
def inversion_about_average(circuit, register):
"""Apply inversion about the average step of Grover's algorithm."""
circuit.h(register)
circuit.x(register)
n_controlled_Z(circuit, qr)
circuit.x(register)
circuit.h(register)
#Let's plot it!
qr = QuantumRegister(4)
qAverage = QuantumCircuit(qr)
inversion_about_average(qAverage, qr, 4)
qAverage.draw(output='mpl')
#implementation of the whole Grover Search Algorithm
def cccz(circuit,qr): #first I define again the oracle, since before it was personalized
pi = math.pi
circuit.cu1(pi/4,qr[0],qr[3])
circuit.cx(qr[0], qr[1])
circuit.cu1(-pi/4, qr[1],qr[3])
circuit.cx(qr[0], qr[1])
circuit.cu1(pi/4, qr[1],qr[3])
circuit.cx(qr[1], qr[2])
circuit.cu1(-pi/4, qr[2],qr[3])
circuit.cx(qr[0], qr[2])
circuit.cu1(pi/4, qr[2],qr[3])
circuit.cx(qr[1], qr[2])
circuit.cu1(-pi/4, qr[2],qr[3])
circuit.cx(qr[0], qr[2])
circuit.cu1(pi/4, qr[2],qr[3])
def phase_oracle(circuit,qr,element): #first I define again the oracle, since before it was personalized
circuit.barrier() #in this part, we are changing the input to the oracle circuit
n = len(element)
for j,x in enumerate(element):
if (x == 0):
circuit.x(qr[j])
n_controlled_Z(circuit,qr)
for j,x in enumerate(element):
if (x == 0):
circuit.x(qr[j])
def n_controlled_Z(circuit, qr):
"""Implement a Z gate with multiple controls"""
if (len(qr) > 4):
raise ValueError('The controlled Z with more than 3 controls is not implemented')
# This is the case n = 2 (1 control + 1 target qubit)
elif (len(qr) == 2):
cz(circuit,qr)
# This is the case n = 3 (2 control + 1 target qubit)
elif (len(qr) == 3):
ccz(circuit,qr)
# This is the case n = 4 (3 control + 1 target qubit)
elif (len(qr) == 4):
cccz(circuit,qr)
def grover_algorithm(Circuit,R,qr,element):
for i in range(1,R):
phase_oracle(Circuit,qr,element)
inversion_about_average(Circuit,qr)
#n=2 circuit
qr2=QuantumRegister(2)
print(len(qr2))
cr2=ClassicalRegister(2)
circuit2=QuantumCircuit(qr2,cr2)
circuit2.h(0)
circuit2.h(1)#quantum superposition of the initial states
element2 = [0,1]
grover_algorithm(circuit2,2,qr2,[0,1])
|
https://github.com/rubenandrebarreiro/summer-school-on-quantum-computing-software-for-near-term-quantum-devices-2020
|
rubenandrebarreiro
|
#initialization
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
import math
# importing Qiskit
from qiskit import IBMQ, BasicAer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
# import basic plot tools
from qiskit.tools.visualization import plot_histogram
from qiskit.visualization import plot_state_qsphere
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
##############################EXERCISE 1#############################################
#Define multi-qubit controlled Z-gate for n=2,3 or 4.
#n=2
def cz(circuit,qr):
circuit.h(qr[1])
circuit.cx(qr[0],qr[1])
circuit.h(qr[1])
#n=3
def ccz(circuit,qr):
circuit.h(qr[2])
# ccx is the Toffoli gate
circuit.ccx(qr[0], qr[1], qr[2])
circuit.h(qr[2])
#n=4
def cccz(circuit,qr):
pi = math.pi
circuit.cu1(pi/4,qr[0],qr[3])
circuit.cx(qr[0], qr[1])
circuit.cu1(-pi/4, qr[1],qr[3])
circuit.cx(qr[0], qr[1])
circuit.cu1(pi/4, qr[1],qr[3])
circuit.cx(qr[1], qr[2])
circuit.cu1(-pi/4, qr[2],qr[3])
circuit.cx(qr[0], qr[2])
circuit.cu1(pi/4, qr[2],qr[3])
circuit.cx(qr[1], qr[2])
circuit.cu1(-pi/4, qr[2],qr[3])
circuit.cx(qr[0], qr[2])
circuit.cu1(pi/4, qr[2],qr[3])
#Definition
def n_controlled_Z(circuit, qr):
"""Implement a Z gate with multiple controls"""
if (len(qr) > 4):
raise ValueError('The controlled Z with more than 3 controls is not implemented')
# This is the case n = 2 (1 control + 1 target qubit)
elif (len(qr) == 2):
cz(circuit,qr)
# This is the case n = 3 (2 control + 1 target qubit)
elif (len(qr) == 3):
ccz(circuit,qr)
# This is the case n = 4 (3 control + 1 target qubit)
elif (len(qr) == 4):
cccz(circuit,qr)
#Now we check if this fuction ihas the same function as a multi-qubit controlled Z-gate. (ex.|11>->-|11>).
#####n=2####
##Circuitn2, input=all posible states.
#Create the circuit
qrn2=QuantumRegister(2)
crn2=ClassicalRegister(2)
circuitn2=QuantumCircuit(qrn2,crn2)
#Built all the posible input states using H-gates.
circuitn2.h(0)
circuitn2.h(1)
#Apply our function.
n_controlled_Z(circuitn2, qrn2)
#Draw the circuit.
circuitn2.draw()
#Execute the quantum circuit using qasm simulator.
backend = BasicAer.get_backend('statevector_simulator')
result = execute(circuitn2, backend).result()
psin2 = result.get_statevector(circuitn2)
#Print and plot the results.
plot_state_qsphere(psin2)
#Measure.
circuitn2.measure([0,1],[0,1])
#Execute the quantum circuit using qasm simulator.
backend = BasicAer.get_backend('qasm_simulator')
result = execute(circuitn2, backend, shots=10000).result()
countsn2 = result.get_counts(circuitn2)
#Print and plot the results.
print(countsn2)
plot_histogram(countsn2)
##Circuitn2Z, input=all posible states.
#Create the circuit
qrn2Z=QuantumRegister(2)
crn2Z=ClassicalRegister(2)
circuitn2Z=QuantumCircuit(qrn2Z,crn2Z)
#Built all the posible input states using H-gates.
circuitn2Z.h(0)
circuitn2Z.h(1)
#Apply our function.
circuitn2Z.cz(qrn2Z[0],qrn2Z[1])
#Draw the circuit.
circuitn2Z.draw()
#Execute the quantum circuit using state vector simulator.
backend = BasicAer.get_backend('statevector_simulator')
result = execute(circuitn2Z, backend).result()
psin2Z = result.get_statevector(circuitn2Z)
#Print and plot the results.
plot_state_qsphere(psin2Z)
#####n=3####
##Circuitn3, input=all posible states.
#Create the circuit
qrn3=QuantumRegister(3)
crn3=ClassicalRegister(3)
circuitn3=QuantumCircuit(qrn3,crn3)
#Built all the posible input states using H-gates.
circuitn3.h(0)
circuitn3.h(1)
circuitn3.h(2)
#Apply our function.
n_controlled_Z(circuitn3, qrn3)
#Draw the circuit.
circuitn3.draw()
#Execute the quantum circuit using statevector simulator.
backend = BasicAer.get_backend('statevector_simulator')
result = execute(circuitn3, backend).result()
psin3 = result.get_statevector(circuitn3)
#Print and plot the results.
plot_state_qsphere(psin3)
#Measure.
circuitn3.measure([0,1,2],[0,1,2])
#Execute the quantum circuit using qasm simulator.
backend = BasicAer.get_backend('qasm_simulator')
result = execute(circuitn3, backend, shots=10000).result()
countsn3 = result.get_counts(circuitn3)
#Print and plot the results.
print(countsn3)
plot_histogram(countsn3)
#####n=4####
##Circuitn4, input=all posible states.
#Create the circuit
qrn4=QuantumRegister(4)
crn4=ClassicalRegister(4)
circuitn4=QuantumCircuit(qrn4,crn4)
#Built all the posible input states using H-gates.
circuitn4.h(0)
circuitn4.h(1)
circuitn4.h(2)
circuitn4.h(3)
#Apply our function.
n_controlled_Z(circuitn4, qrn4)
#Draw the circuit.
circuitn4.draw()
#Execute the quantum circuit using statevector simulator.
backend = BasicAer.get_backend('statevector_simulator')
result = execute(circuitn4, backend).result()
psin4 = result.get_statevector(circuitn4)
#Print and plot the results.
plot_state_qsphere(psin4)
#Measure.
circuitn4.measure([0,1,2,3],[0,1,2,3])
#Execute the quantum circuit using qasm simulator.
backend = BasicAer.get_backend('qasm_simulator')
result = execute(circuitn4, backend, shots=10000).result()
countsn4 = result.get_counts(circuitn4)
#Print and plot the results.
print(countsn4)
plot_histogram(countsn4)
##Circuit0n4, input=|0000>.
#Create the circuit
qr0n4=QuantumRegister(4)
cr0n4=ClassicalRegister(4)
circuit0n4=QuantumCircuit(qr0n4,crn4)
#The states are already 0.
#Apply our function.
n_controlled_Z(circuit0n4, qr0n4)
#Draw the circuit.
circuit0n4.draw()
#Execute the quantum circuit using statevector simulator.
backend = BasicAer.get_backend('statevector_simulator')
result = execute(circuit0n4, backend).result()
psi0n4 = result.get_statevector(circuit0n4)
#Print and plot the results.
plot_state_qsphere(psi0n4)
##############################EXERCISE 2#############################################
#Check whether Oracle acts as expected.
#Define Oracle
def phase_oracle(circuit,qr,element):
# element is an array that defines the searched element, for example, element = [0,1,0,1]
n = len(element)
for j,x in enumerate(element):
if (x == 0):
circuit.x(qr[j])
n_controlled_Z(circuit,qr)
for j,x in enumerate(element):
if (x == 0):
circuit.x(qr[j])
# Create Circuite2, input=all posible states.
#Create the circuit
qre2=QuantumRegister(4)
cre2=ClassicalRegister(4)
circuite2=QuantumCircuit(qre2,cre2)
#Built all the posible input states using H-gates.
circuite2.h(0)
circuite2.h(1)
circuite2.h(2)
circuite2.h(3)
#Chose element to search.
elemente2=[0,1,1,0]
#Apply Oracle.
phase_oracle(circuite2,qre2,elemente2)
#Draw the circuit.
circuite2.draw()
#Execute the quantum circuit using statevector simulator.
backend = BasicAer.get_backend('statevector_simulator')
result = execute(circuite2, backend).result()
psie2 = result.get_statevector(circuite2)
#Print and plot the results.
plot_state_qsphere(psie2)
#Measure.
circuite2.measure([0,1,2,3],[0,1,2,3])
#Execute the quantum circuit using qasm simulator.
backend = BasicAer.get_backend('qasm_simulator')
result = execute(circuite2, backend, shots=10000).result()
countse2 = result.get_counts(circuite2)
#Print and plot the results.
print(countse2)
plot_histogram(countse2)
##############################EXERCISE 3#############################################
#Define Inversion
def inversion_about_average(circuit, register):
"""Apply inversion about the average step of Grover's algorithm."""
circuit.h(register)
circuit.x(register)
n_controlled_Z(circuit, qr)
circuit.x(register)
circuit.h(register)
#Circuit that implements the Grover's Algorithm (we define a function in which we introduce our parameters).
def grovers_algorithm(element,R,circuit,qr):
#circuit=defined input of the circuit.
#element=[a,b,c,d] with a,b=0,1, array representing the searched element.
#R=number of repetitions.
#Apply the algorithm R times.
for i in range(1,R):
#Apply Oracle.
phase_oracle(circuit,qr,element)
#Apply Inversion.
inversion_about_average(circuit,qr)
#Ex. searching |1010>
#Create the circuit and set it with input=all posible states (2^4).
qr=QuantumRegister(4)
cr=ClassicalRegister(4)
circuit=QuantumCircuit(qr,cr)
circuit.h(0)
circuit.h(1)
circuit.h(2)
circuit.h(3)
#Apply the algorithm.
grovers_algorithm([0,1,0,1],2,circuit,qr)
#Plot the circuit.
circuit.draw()
#Measure.
circuit.measure([0,1,2,3],[0,1,2,3])
#Execute the quantum circuit using qasm simulator.
backend = BasicAer.get_backend('qasm_simulator')
result = execute(circuit, backend, shots=1000).result()
counts = result.get_counts(circuit)
#Print and plot the results.
print(counts)
plot_histogram(counts)
#Ex. searching |111>
#Create the circuit and set it with input=all posible states (2^4).
qr=QuantumRegister(3)
cr=ClassicalRegister(3)
circuit=QuantumCircuit(qr,cr)
circuit.h(0)
circuit.h(1)
circuit.h(2)
#Apply the algorithm.
grovers_algorithm([1,1,1],3,circuit,qr)
#Plot the circuit.
circuit.draw()
#Measure.
circuit.measure([0,1,2],[0,1,2])
#Execute the quantum circuit using qasm simulator.
backend = BasicAer.get_backend('qasm_simulator')
result = execute(circuit, backend, shots=1000).result()
counts = result.get_counts(circuit)
#Print and plot the results.
print(counts)
plot_histogram(counts)
#Ex. searching |00>
#Create the circuit and set it with input=all posible states (2^4).
qr=QuantumRegister(2)
cr=ClassicalRegister(2)
circuit=QuantumCircuit(qr,cr)
circuit.h(0)
circuit.h(1)
#Apply the algorithm.
grovers_algorithm([0,1],2,circuit,qr)
#Plot the circuit.
circuit.draw()
#Measure.
circuit.measure([0,1],[0,1])
#Execute the quantum circuit using qasm simulator.
backend = BasicAer.get_backend('qasm_simulator')
result = execute(circuit, backend, shots=1000).result()
counts = result.get_counts(circuit)
#Print and plot the results.
print(counts)
plot_histogram(counts)
##############################EXERCISE 4#############################################
#number of measurements: it's easy to see by changing the parameter shoots that it doesn't really affect the results.
#number of iterations: it must be chosen carefully because it follows a repetitive structure, being R~sqrt(n) a good election.
|
https://github.com/rubenandrebarreiro/summer-school-on-quantum-computing-software-for-near-term-quantum-devices-2020
|
rubenandrebarreiro
|
# Expand the Width of the Cells to a ratio of 100%
from IPython.core.display import display, HTML
display(HTML("<style>.container { width:100% !important; }</style>"))
# Update, the Conda's version, if necessary
!conda update -n base conda --yes
# Install other useful Libraries for Quantum Information Science,
# the QuTiP Framework, in this case, based on Python Programming Language
!conda install qutip --yes
# Import the matplotlib Library
import matplotlib.pyplot as plt
%matplotlib inline
# Import the NumPy and Math Libraries,
# based on Python Programming Language
import numpy as np
import math
# Import some basic Modules from Qiskit Library and configuring account
from qiskit import IBMQ, BasicAer
from qiskit import QuantumCircuit, execute, Aer, IBMQ, QuantumRegister, ClassicalRegister
from qiskit.compiler import transpile, assemble
from qiskit.providers.ibmq import least_busy
from qiskit.tools.jupyter import *
from qiskit.visualization import *
# Import some basic Visualization/Plot Modules/Tools from Qiskit Library
from qiskit.tools.visualization import plot_histogram
# In Jupyter Notebooks we can display this nicely using Latex.
# If not using Jupyter Notebooks you may need to remove the
# array_to_latex function and use print() instead.
from qiskit_textbook.tools import array_to_latex
# Import Operator Module from Qiskit Library, for Custom Operators
from qiskit.quantum_info.operators import Operator
def cz(circuit, qr):
circuit.h(qr[1])
circuit.cx(qr[0],qr[1])
circuit.h(qr[1])
# Create a Classical Register for 2 Bits (Classical Bits), with a Total of 2 Possible Processed States
qr2 = QuantumRegister(2)
czCircuit = QuantumCircuit(qr2)
cz(czCircuit,qr2)
czCircuit.draw(output="mpl")
def ccz(circuit,qr):
circuit.h(qr[2])
# CCX is the Toffoli gate
circuit.ccx(qr[0], qr[1], qr[2])
circuit.h(qr[2])
qr3 = QuantumRegister(3)
cczCircuit = QuantumCircuit(qr3)
ccz(cczCircuit,qr3)
cczCircuit.draw(output="mpl")
def cccz(circuit,qr):
pi = math.pi
circuit.cu1(pi/4,qr[0],qr[3])
circuit.cx(qr[0], qr[1])
circuit.cu1(-pi/4, qr[1],qr[3])
circuit.cx(qr[0], qr[1])
circuit.cu1(pi/4, qr[1],qr[3])
circuit.cx(qr[1], qr[2])
circuit.cu1(-pi/4, qr[2],qr[3])
circuit.cx(qr[0], qr[2])
circuit.cu1(pi/4, qr[2],qr[3])
circuit.cx(qr[1], qr[2])
circuit.cu1(-pi/4, qr[2],qr[3])
circuit.cx(qr[0], qr[2])
circuit.cu1(pi/4, qr[2],qr[3])
qr4 = QuantumRegister(4)
ccczCircuit = QuantumCircuit(qr4)
cccz(ccczCircuit,qr4)
ccczCircuit.draw(output="mpl")
def ccccz(circuit, qr):
unitaryMatrixCCCCZ = Operator([
[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 0, 0, 0, 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, 0, 0, 0, 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, 0, 0, 0, 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, 0, 0, 0, 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, 0, 0, 0, 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, 0, 0, 0, 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, 0, 0, 0, 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, 0, 0, 0, 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, 0, 0, 0, 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, 0, 0, 0, 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, 0, 0, 0, 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, 0, 0, 0, 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, 0, 0, 0, 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, 0, 0, 0, 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, 0, 0, 0, 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, 0, 0, 0, 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, 0, 0, 0, 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, 0, 0, 0, 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, 0, 0, 0, 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, 0, 0, 0],
[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, 0, 0],
[0, 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, 0],
[0, 0, 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],
[0, 0, 0, 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, 0, 0, 0, 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, 0, 0, 0, 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, 0, 0, 0, 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, 0, 0, 0, 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, 0, 0, 0, 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, 0, 0, 0, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, -1]
])
circuit.unitary(unitaryMatrixCCCCZ, qr, label='CCCCZ')
qr5 = QuantumRegister(5)
cccczCircuit = QuantumCircuit(qr5)
ccccz(cccczCircuit,qr5)
cccczCircuit.draw(output="mpl")
def n_controlled_Z(circuit, qr):
# Implement a Z-Gate with multiple controls
if (len(qr) > 5):
raise ValueError('The Controlled-Z with more than 4 Control-Qubits is not implemented!!!')
# This is the case n = 2 (1 control + 1 target Qubit)
elif (len(qr) == 2):
cz(circuit,qr)
# This is the case n = 3 (2 control + 1 target Qubit)
elif (len(qr) == 3):
ccz(circuit,qr)
# This is the case n = 4 (3 control + 1 target Qubit)
elif (len(qr) == 4):
cccz(circuit,qr)
# Extra Exercise (Made by Rúben André Barreiro)
# This is the case n = 5 (4 control + 1 target Qubit)
elif (len(qr) == 5):
cccz(circuit,qr)
# Getting the Backend for the Unitary Representation of the Controlled-Z Gate
# (i.e., the Quantum State represented as an Unitary Matrix)
backend = Aer.get_backend('unitary_simulator')
unitaryCZ = execute(czCircuit,backend).result().get_unitary()
unitaryCCZ = execute(cczCircuit,backend).result().get_unitary()
unitaryCCCZ = execute(ccczCircuit,backend).result().get_unitary()
unitaryCCCCZ = execute(cccczCircuit,backend).result().get_unitary()
array_to_latex(unitaryCZ, pretext="\\text{CZ (Controlled-Z) = }\n")
array_to_latex(unitaryCCZ, pretext="\\text{CCZ (Controlled-Controlled-Z) = }\n")
array_to_latex(unitaryCCCZ, pretext="\\text{CCCZ (Controlled-Controlled-Controlled-Z) = }\n")
# Extra Exercise (not asked by the Professors):
# - Multi Controlled-Z Gate for 5 Qubits (Made by Rúben André Barreiro)
array_to_latex(unitaryCCCCZ, pretext="\\text{CCCZ (Controlled-Controlled-Controlled-Controlled-Z) = }\n")
def phase_oracle(circuit,qr,element):
# Element is an Array that defines the searched Element,
# for example, Element = [0,1,0,1]
for j,x in enumerate(element):
if (x == 0):
circuit.x(qr[j])
circuit.barrier()
n_controlled_Z(circuit,qr)
circuit.barrier()
for j,x in enumerate(element):
if (x == 0):
circuit.x(qr[j])
def mark_state(element_test_state, testCircuit):
for qubit_index, element in enumerate(element_test_state):
if element == 1:
testCircuit.x(qubit_index)
testCircuit.barrier()
# Defining some tests, for the Phase Oracle, with n = 2
#element_test_2_states = [0,0]
element_test_2_states = [0,1]
#element_test_2_states = [1,0]
#element_test_2_states = [1,1]
qr2 = QuantumRegister(2)
testFunctionCircuit2 = QuantumCircuit(qr2)
element_test_2_states_binary = ''.join(map(str,element_test_2_states))
print("The Marked State is: |{}⟩".format(element_test_2_states_binary))
element_test_2_states.reverse()
mark_state(element_test_2_states, testFunctionCircuit2)
phase_oracle(testFunctionCircuit2,qr2,element_test_2_states)
testFunctionCircuit2.draw(output="mpl")
# Getting the Backend for the Statevector Representation
# (i.e., the Quantum State represented as State Vector)
statevector_backend = Aer.get_backend('statevector_simulator')
final_state = execute(testFunctionCircuit2,statevector_backend).result().get_statevector()
array_to_latex(final_state, pretext="\\text{Final State for Marked State (Statevector) = }\n", precision = 1)
# Defining some tests, for the Phase Oracle, with n = 3
#element_test_3_states = [0,0,0]
#element_test_3_states = [0,0,1]
#element_test_3_states = [0,1,0]
element_test_3_states = [0,1,1]
#element_test_3_states = [1,0,0]
#element_test_3_states = [1,0,1]
#element_test_3_states = [1,1,0]
#element_test_3_states = [1,1,1]
qr3 = QuantumRegister(3)
testFunctionCircuit3 = QuantumCircuit(qr3)
element_test_3_states_binary = ''.join(map(str,element_test_3_states))
print("The Marked State is: |{}⟩".format(element_test_3_states_binary))
element_test_3_states.reverse()
mark_state(element_test_3_states, testFunctionCircuit3)
phase_oracle(testFunctionCircuit3,qr3,element_test_3_states)
testFunctionCircuit3.draw(output="mpl")
# Getting the Backend for the Statevector Representation
# (i.e., the Quantum State represented as State Vector)
statevector_backend = Aer.get_backend('statevector_simulator')
final_state = execute(testFunctionCircuit3,statevector_backend).result().get_statevector()
array_to_latex(final_state, pretext="\\text{Final State for Marked State (Statevector) = }\n", precision = 1)
# Defining some tests, for the Phase Oracle, with n = 4
#element_test_4_states = [0,0,0,0]
#element_test_4_states = [0,0,0,1]
#element_test_4_states = [0,0,1,0]
#element_test_4_states = [0,0,1,1]
#element_test_4_states = [0,1,0,0]
#element_test_4_states = [0,1,0,1]
#element_test_4_states = [0,1,1,0]
#element_test_4_states = [0,1,1,1]
#element_test_4_states = [1,0,0,0]
#element_test_4_states = [1,0,0,1]
element_test_4_states = [1,0,1,0]
#element_test_4_states = [1,0,1,1]
#element_test_4_states = [1,1,0,0]
#element_test_4_states = [1,1,0,1]
#element_test_4_states = [1,1,1,0]
#element_test_4_states = [1,1,1,1]
qr4 = QuantumRegister(4)
testFunctionCircuit4 = QuantumCircuit(qr4)
element_test_4_states_binary = ''.join(map(str,element_test_4_states))
print("The Marked State is: |{}⟩".format(element_test_4_states_binary))
element_test_4_states.reverse()
mark_state(element_test_4_states, testFunctionCircuit4)
phase_oracle(testFunctionCircuit4,qr4,element_test_4_states)
testFunctionCircuit4.draw(output="mpl")
# Getting the Backend for the Statevector Representation
# (i.e., the Quantum State represented as State Vector)
statevector_backend = Aer.get_backend('statevector_simulator')
final_state = execute(testFunctionCircuit4,statevector_backend).result().get_statevector()
array_to_latex(final_state, pretext="\\text{Final State for Marked State (Statevector) = }\n", precision = 1)
def inversion_about_average(circuit, qr):
# Apply Inversion Operator about the Average step of Grover's Algorithm
circuit.h(qr)
circuit.x(qr)
n_controlled_Z(circuit, qr)
circuit.x(qr)
circuit.h(qr)
# Now, let's plot the Quantum Circuit for the Quantum Average
qr = QuantumRegister(4)
qAverage = QuantumCircuit(qr)
inversion_about_average(qAverage, qr)
qAverage.draw(output='mpl')
def putAllQubitsInQuantumSuperposition(n, quantumCircuit):
for qubit_index in range(n):
quantumCircuit.h(qubit_index)
def measureAllQubits(n, quantumCircuit, quantumRegister, classicalRegister):
for qubit_index in range(n):
quantumCircuit.measure(quantumRegister[qubit_index], classicalRegister[qubit_index])
def grover_algorithm(quantumCircuit,quantumRegister,classicalRegister,element,n):
putAllQubitsInQuantumSuperposition(n,quantumCircuit)
# Experimental Constant Factor,
# for incrementing the number of Steps of the Grover's Algorithm
additional_steps = 0
#additional_steps = 1
#additional_steps = 2
#additional_steps = 3
#additional_steps = 4
for step in range(1, ( n + additional_steps )):
phase_oracle(quantumCircuit,quantumRegister, element)
inversion_about_average(quantumCircuit, quantumRegister)
measureAllQubits(n, quantumCircuit, quantumRegister, classicalRegister)
qr2 = QuantumRegister(2)
cr2 = ClassicalRegister(2)
groverCircuit = QuantumCircuit(qr2,cr2)
#element_2_states = [0,0]
element_2_states = [0,1]
#element_2_states = [1,0]
#element_2_states = [1,1]
element_2_states_binary = ''.join(map(str,element_2_states))
print("The Marked State, we're looking for, is: |{}⟩".format(element_2_states_binary))
element_2_states.reverse()
grover_algorithm(groverCircuit,qr2,cr2,element_2_states,2)
groverCircuit.draw("mpl")
# Now, let's execute the Quantum Circuit in the QASM Simulator of the Aer Module,
# of the IBM Qiskit Library
backend = Aer.get_backend('qasm_simulator')
counts = execute(groverCircuit,backend,shots=2048).result().get_counts()
# Print the Counts of the Frequencies, resulting from this Experiment
print(counts)
# Plot the Counts of the Frequencies, resulting from this Experiment, through a Histogram
# (i.e., a Distribution of the Probabilities)
plot_histogram(counts)
qr3 = QuantumRegister(3)
cr3 = ClassicalRegister(3)
groverCircuit = QuantumCircuit(qr3,cr3)
#element_3_states = [0,0,0]
#element_3_states = [0,0,1]
#element_3_states = [0,1,0]
#element_3_states = [0,1,1]
#element_3_states = [1,0,0]
#element_3_states = [1,0,1]
element_3_states = [1,1,0]
#element_3_states = [1,1,1]
element_3_states_binary = ''.join(map(str,element_3_states))
print("The Marked State, we're looking for, is: |{}⟩".format(element_3_states_binary))
element_3_states.reverse()
grover_algorithm(groverCircuit,qr3,cr3,element_3_states,3)
groverCircuit.draw("mpl")
# Now, let's execute the Quantum Circuit in the QASM Simulator of the Aer Module,
# of the IBM Qiskit Library
backend = Aer.get_backend('qasm_simulator')
counts = execute(groverCircuit,backend,shots=2048).result().get_counts()
# Print the Counts of the Frequencies, resulting from this Experiment
print(counts)
# Plot the Counts of the Frequencies, resulting from this Experiment, through a Histogram
# (i.e., a Distribution of the Probabilities)
plot_histogram(counts)
qr4 = QuantumRegister(4)
cr4 = ClassicalRegister(4)
groverCircuit = QuantumCircuit(qr4,cr4)
#element_4_states = [0,0,0,0]
#element_4_states = [0,0,0,1]
#element_4_states = [0,0,1,0]
#element_4_states = [0,0,1,1]
#element_4_states = [0,1,0,0]
#element_4_states = [0,1,0,1]
#element_4_states = [0,1,1,0]
#element_4_states = [0,1,1,1]
#element_4_states = [1,0,0,0]
#element_4_states = [1,0,0,1]
#element_4_states = [1,0,1,0]
element_4_states = [1,0,1,1]
#element_4_states = [1,1,0,0]
#element_4_states = [1,1,0,1]
#element_4_states = [1,1,1,0]
#element_4_states = [1,1,1,1]
element_4_states_binary = ''.join(map(str,element_4_states))
print("The Marked State, we're looking for, is: |{}⟩".format(element_4_states_binary))
element_4_states.reverse()
grover_algorithm(groverCircuit,qr4,cr4,element_4_states,4)
groverCircuit.draw("mpl")
# Now, let's execute the Quantum Circuit in the QASM Simulator of the Aer Module,
# of the IBM Qiskit Library
backend = Aer.get_backend('qasm_simulator')
counts = execute(groverCircuit,backend,shots=2048).result().get_counts()
# Print the Counts of the Frequencies, resulting from this Experiment
print(counts)
# Plot the Counts of the Frequencies, resulting from this Experiment, through a Histogram
# (i.e., a Distribution of the Probabilities)
plot_histogram(counts)
qr5 = QuantumRegister(5)
cr5 = ClassicalRegister(5)
groverCircuit = QuantumCircuit(qr5,cr5)
#element_5_states = [0,0,0,0,0]
#element_5_states = [0,0,0,0,1]
element_5_states = [0,0,0,1,0]
#element_5_states = [0,0,0,1,1]
#element_5_states = [0,0,1,0,0]
#element_5_states = [0,0,1,0,1]
#element_5_states = [0,0,1,1,0]
#element_5_states = [0,0,1,1,1]
#element_5_states = [0,1,0,0,0]
#element_5_states = [0,1,0,0,1]
#element_5_states = [0,1,0,1,0]
#element_5_states = [0,1,0,1,1]
#element_5_states = [0,1,1,0,0]
#element_5_states = [0,1,1,0,1]
#element_5_states = [0,1,1,1,0]
#element_5_states = [0,1,1,1,1]
#element_5_states = [1,0,0,0,0]
#element_5_states = [1,0,0,0,1]
#element_5_states = [1,0,0,1,0]
#element_5_states = [1,0,0,1,1]
#element_5_states = [1,0,1,0,0]
#element_5_states = [1,0,1,0,1]
#element_5_states = [1,0,1,1,0]
#element_5_states = [1,0,1,1,1]
#element_5_states = [1,1,0,0,0]
#element_5_states = [1,1,0,0,1]
#element_5_states = [1,1,0,1,0]
#element_5_states = [1,1,0,1,1]
#element_5_states = [1,1,1,0,0]
#element_5_states = [1,1,1,0,1]
#element_5_states = [1,1,1,1,0]
#element_5_states = [1,1,1,1,1]
element_5_states_binary = ''.join(map(str,element_5_states))
print("The Marked State, we're looking for, is: |{}⟩".format(element_5_states_binary))
element_5_states.reverse()
grover_algorithm(groverCircuit,qr5,cr5,element_5_states,5)
groverCircuit.draw("mpl")
# Now, let's execute the Quantum Circuit in the QASM Simulator of the Aer Module,
# of the IBM Qiskit Library
backend = Aer.get_backend('qasm_simulator')
counts = execute(groverCircuit,backend,shots=2048).result().get_counts()
# Print the Counts of the Frequencies, resulting from this Experiment
print(counts)
# Plot the Counts of the Frequencies, resulting from this Experiment, through a Histogram
# (i.e., a Distribution of the Probabilities)
plot_histogram(counts)
# Print the current Qiskit's Modules' Version
import qiskit
qiskit.__qiskit_version__
|
https://github.com/kurtchahn/QiskitPrx
|
kurtchahn
|
import qiskit as qk
import qiskit_aer as qaer
import numpy as np
import math
sSimulator = qaer.Aer.backends(name="statevector_simulator")[0]
mSimulator = qaer.Aer.backends(name="qasm_simulator")[0]
qr = qk.QuantumRegister(1)
helloQubit = qk.QuantumCircuit(qr)
## identity operator on q0
helloQubit.id(qr[0])
job = sSimulator.run(helloQubit)
result = job.result()
result.get_statevector()
helloQubit.draw("mpl")
qr = qk.QuantumRegister(3)
qc = qk.QuantumCircuit(qr)
qc.id(qr[0])
qc.id(qr[1])
qc.id(qr[2])
job = sSimulator.run(qc)
result = job.result()
result.get_statevector()
qc.draw("mpl")
qr = qk.QuantumRegister(1)
cr = qk.ClassicalRegister(1)
qc = qk.QuantumCircuit(qr, cr)
qc.h(qr[0])
qc.measure(qr, cr)
job = mSimulator.run(qc)
result = job.result()
result.get_counts(qc)
qc.draw("mpl")
qr = qk.QuantumRegister(2)
cr = qk.ClassicalRegister(2)
qc = qk.QuantumCircuit(qr, cr)
qc.h(qr[0])
qc.h(qr[1])
qc.measure(qr, cr)
counts = mSimulator.run(qc).result().get_counts(qc)
print(counts)
qc.draw("mpl")
## Partial Measurement
qr = qk.QuantumRegister(2)
cr = qk.ClassicalRegister(2)
qc = qk.QuantumCircuit(qr, cr)
qc.h(qr[0])
qc.h(qr[1])
qc.measure(qr[0], cr[0])
counts = mSimulator.run(qc).result().get_counts(qc)
print(counts)
def perfect_coinflip(numFlips):
qr = qk.QuantumRegister(1)
cr = qk.ClassicalRegister(1)
coin = qk.QuantumCircuit(qr, cr)
coin.h(qr[0])
coin.measure(qr, cr)
counts = mSimulator.run(coin, shots=numFlips).result().get_counts(coin)
heads = counts["0"]
tails = counts["1"]
return heads, tails
numHeads, numTails = perfect_coinflip(100)
print(f"Heads: {numHeads}")
print(f"Tails: {numTails}")
|
https://github.com/kurtchahn/QiskitPrx
|
kurtchahn
|
import qiskit as qk
import qiskit_aer as qaer
import numpy as np
import math
sSimulator = qaer.Aer.backends(name="statevector_simulator")[0]
mSimulator = qaer.Aer.backends(name="qasm_simulator")[0]
qr = qk.QuantumRegister(2, name="qr")
cr = qk.ClassicalRegister(2, name="cr")
qc = qk.QuantumCircuit(qr, cr, name="qc")
qc.h(qr[0])
qc.cx(qr[0], qr[1])
qr1 = qk.QuantumRegister(2, name="qr1")
cr1 = qk.ClassicalRegister(2, name="cr1")
qc1 = qk.QuantumCircuit(qr1, cr1, name="qc1")
qr2 = qk.QuantumRegister(2, name="qr2")
cr2 = qk.ClassicalRegister(2, name="cr2")
qc2 = qk.QuantumCircuit(qr2, cr2, name="qc2")
qc1.h(qr1[0])
qc1.id(qr1[1])
qc2.id(qr2[0])
qc2.h(qr2[1])
qc3 = qc1.compose(qc2)
qc1.draw("mpl")
qc2.draw("mpl")
qc3.draw("mpl")
|
https://github.com/kurtchahn/QiskitPrx
|
kurtchahn
|
import qiskit as qk
import qiskit_aer as qaer
import numpy as np
import math
sSimulator = qaer.Aer.backends(name="statevector_simulator")[0]
mSimulator = qaer.Aer.backends(name="qasm_simulator")[0]
qr = qk.QuantumRegister(1, name="qr")
qc = qk.QuantumCircuit(qr, name="qc")
qc.h(qr[0])
sSimulator.run(qc).result().get_statevector()
qc.draw("mpl")
qc.p(math.pi/4, qr[0])
sSimulator.run(qc).result().get_statevector()
qc.draw("mpl")
qr = qk.QuantumRegister(1, name="qr")
qc = qk.QuantumCircuit(qr, name="qc")
qc.rx(math.pi/2, qr[0])
sSimulator.run(qc).result().get_statevector()
qc.draw("mpl")
qr = qk.QuantumRegister(3, name="qr")
qc = qk.QuantumCircuit(qr, name="qc")
qc.h(qr[0])
qc.x(qr[1])
qc.id(qr[2])
qc.cswap(qr[0], qr[1], qr[2])
sSimulator.run(qc).result().get_statevector()
qc.draw("mpl")
|
https://github.com/kurtchahn/QiskitPrx
|
kurtchahn
|
import qiskit as qk
import qiskit_aer as qaer
import numpy as np
import math
sSimulator = qaer.Aer.backends(name="statevector_simulator")[0]
mSimulator = qaer.Aer.backends(name="qasm_simulator")[0]
|
https://github.com/kurtchahn/QiskitPrx
|
kurtchahn
|
import qiskit as qk
import qiskit_aer as qaer
import numpy as np
import math
sSimulator = qaer.Aer.backends(name="statevector_simulator")[0]
mSimulator = qaer.Aer.backends(name="qasm_simulator")[0]
def create_blackbox():
def F1(x):
return 0
def F2(x):
return 1
def F3(x):
return x%2
def F4(x):
return (x+1)%2
functions = [F1, F2, F3, F4]
function = functions[ np.random.randint(0, 3) ]
return function
blackbox = create_blackbox()
print("f(0): ", blackbox(0))
print("f(1): ", blackbox(1))
if (blackbox(0) == blackbox(1)):
print("f is a constant function")
else:
print("f is a balanced function")
def return_blackbox():
q = qk.QuantumRegister(2)
blackbox = qk.QuantumCircuit(q, name=r"$\hat{U}_B$")
rand = np.random.randint(0, 3)
match rand:
case 0: ## f(0,1) -> (0,1)
blackbox.cx(q[0], q[1])
print("balanced")
case 1: ## f(0,1) -> (1,0)
blackbox.x(q[0])
blackbox.cx(q[0], q[1])
blackbox.x(q[0])
print("balanced")
case 2: ## f(0,1) -> (0,0)
blackbox.id(q[0])
blackbox.id(q[1])
print("constant")
case 3: ## f(0,1) -> (1,1)
blackbox.id(q[0])
blackbox.x(q[1])
print("constant")
return blackbox.to_instruction()
q = qk.QuantumRegister(2, name="q")
c = qk.ClassicalRegister(1, name="c")
deutsch = qk.QuantumCircuit(q, c, name="qc")
deutsch.id(q[0])
deutsch.x(q[1])
deutsch.h(q[0])
deutsch.h(q[1])
deutsch.barrier(label=r"$|\psi\rangle_{in}$")
blackbox = return_blackbox()
deutsch.append(blackbox, [0,1])
deutsch.barrier(label=r"$\hat{U}_B|\psi\rangle_{in}$")
deutsch.h(q[0])
deutsch.h(q[1])
deutsch.barrier()
## We only need to measure q0 to determine if f is balanced or constant
deutsch.measure(q[0], c)
deutsch.draw("mpl")
## We only need 1 shot
## We need to decompose the circuit in order for the simulator to read the blackbox instructions
counts = mSimulator.run(deutsch.decompose(), shots=1).result().get_counts(deutsch.decompose())
if ("0" in counts):
print(r"0 state measured: f is a constant function")
elif ("1" in counts):
print(r"1 state measured: f is a balanced function")
|
https://github.com/kurtchahn/QiskitPrx
|
kurtchahn
|
import qiskit as qk
import qiskit_aer as qaer
import numpy as np
import math
sSimulator = qaer.Aer.backends(name="statevector_simulator")[0]
mSimulator = qaer.Aer.backends(name="qasm_simulator")[0]
|
https://github.com/kurtchahn/QiskitPrx
|
kurtchahn
|
import qiskit as qk
import qiskit_aer as qaer
import numpy as np
import math
sSimulator = qaer.Aer.backends(name="statevector_simulator")[0]
mSimulator = qaer.Aer.backends(name="qasm_simulator")[0]
|
https://github.com/crabster/qiskit-learning
|
crabster
|
from argparse import ArgumentParser
from qiskit import execute, BasicAer, IBMQ
from qiskit.visualization import plot_histogram
from qiskit.providers.ibmq import least_busy
from qiskit.tools.monitor import job_monitor
import matplotlib.pyplot as plt
from circuits.test import test_circuit
from circuits.quantum_teleportation import quantum_teleportation_example
from circuits.superdense_coding import superdense_coding_example
from circuits.deutsch_jozsa import deutsch_jozsa_example
from circuits.bernstein_vazirani import bernstein_vazirani_example
from circuits.quantum_fourier_transform import qft_example
from circuits.quantum_phase_estimation import qpe_example
parser = ArgumentParser(description='Run quantum circuit.')
parser.add_argument('-b', '--backend', metavar='BE', default='qasm_simulator',
choices=['auto', 'qasm_simulator', 'ibmqx2', 'ibmq_16_melbourne',
'ibmq_vigo', 'ibmq_ourense', 'ibmq_london',
'ibmq_burlington', 'ibmq_essex', 'ibmq_armonk', 'ibmq_rome'],
help='backend BE on which will the circuit run')
parser.add_argument('-c', '--circuit', metavar='QC', required=True,
choices=['test', 'tp', 'sc', 'dj', 'bv', 'qft', 'qpe'],
help='circuit QC to be run')
parser.add_argument('--shots', type=int, default=1024,
help='plot counts histogram of the result')
parser.add_argument('--plot', action="store_true",
help='plot counts histogram of the result')
args = parser.parse_args()
if args.circuit == 'test':
qc = test_circuit()
if args.circuit == 'tp':
qc = quantum_teleportation_example()
if args.circuit == 'sc':
qc = superdense_coding_example()
if args.circuit == 'dj':
qc = deutsch_jozsa_example()
if args.circuit == 'bv':
qc = bernstein_vazirani_example()
if args.circuit == 'qft':
qc = qft_example()
if args.circuit == 'qpe':
qc = qpe_example()
if args.backend == 'qasm_simulator':
backend = BasicAer.get_backend('qasm_simulator')
else:
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
if args.backend == 'auto':
backends = provider.backends(filters=lambda b:
b.configuration().n_qubits >= qc.num_qubits and
not b.configuration().simulator and
b.status().operational==True)
backend = least_busy(backends)
else:
backend = provider.get_backend(args.backend)
job = execute(qc, backend, shots=args.shots)
job_monitor(job)
counts = job.result().get_counts()
print(counts)
if args.plot:
plot_histogram(counts)
plt.show()
|
https://github.com/crabster/qiskit-learning
|
crabster
|
from qiskit import QuantumCircuit
from QCLG_lvl3.oracles.secret_number_oracle import SecretNUmberOracle
class BernsteinVazirani:
@classmethod
def bernstein_vazirani(cls, random_binary, eval_mode: bool) -> QuantumCircuit:
# Construct secret number oracle
secret_number_oracle = SecretNUmberOracle.create_secret_number_oracle(random_binary=random_binary, eval_mode=eval_mode)
num_of_qubits = secret_number_oracle.num_qubits
# Construct circuit according to the length of the number
dj_circuit = QuantumCircuit(num_of_qubits, num_of_qubits - 1)
dj_circuit_before_oracle = QuantumCircuit(num_of_qubits, num_of_qubits - 1)
# Apply H-gates
for qubit in range(num_of_qubits - 1):
dj_circuit_before_oracle.h(qubit)
# Put output qubit in state |->
dj_circuit_before_oracle.x(num_of_qubits - 1)
dj_circuit_before_oracle.h(num_of_qubits - 1)
dj_circuit += dj_circuit_before_oracle
# Add oracle
dj_circuit += secret_number_oracle
dj_circuit_after_oracle = QuantumCircuit(num_of_qubits, num_of_qubits - 1)
# Repeat H-gates
for qubit in range(num_of_qubits - 1):
dj_circuit_after_oracle.h(qubit)
dj_circuit_after_oracle.barrier()
# Measure
for i in range(num_of_qubits - 1):
dj_circuit_after_oracle.measure(i, i)
dj_circuit += dj_circuit_after_oracle
if not eval_mode:
print("Circuit before the oracle\n")
print(QuantumCircuit.draw(dj_circuit_before_oracle))
print("Circuit after the oracle\n")
print(QuantumCircuit.draw(dj_circuit_after_oracle))
print(dj_circuit)
return dj_circuit
|
https://github.com/crabster/qiskit-learning
|
crabster
|
import qiskit
from math import pi
from random import random
def random_state_gate():
theta = 2*pi*random()
phi = 2*pi*random()
lam = 2*pi*random()
qc = qiskit.QuantumCircuit(1)
qc.u3(theta, phi, lam, 0)
gate = qc.to_gate()
gate.name = f"$U_3$ {theta:.2f},{phi:.2f},{lam:.2f}"
return gate
def phi_plus_gate():
qc = qiskit.QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
gate = qc.to_gate()
gate.name = "$\phi^{+}$"
return gate
def phi_minus_gate():
qc = qiskit.QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.x(0)
qc.z(0)
gate = qc.to_gate()
gate.name = "$\phi^{-}$"
return gate
def psi_plus_gate():
qc = qiskit.QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.x(0)
gate = qc.to_gate()
gate.name = "$\psi^{+}$"
return gate
def psi_minus_gate():
qc = qiskit.QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.z(0)
gate = qc.to_gate()
gate.name = "$\psi^{-}$"
return qc
|
https://github.com/crabster/qiskit-learning
|
crabster
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Sep 19 19:13:26 2023
@author: abdullahalshihry
"""
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Sep 18 19:15:12 2023
@author: abdullahalshihry
"""
import qiskit as qs
import qiskit.visualization as qv
import random
import qiskit.circuit as qf
def Deutsch_Jozsa(circuit):
qr = qs.QuantumRegister(5,'q')
cr = qs.ClassicalRegister(4,'c')
qc = qs.QuantumCircuit(qr,cr)
qc.x(qr[4])
qc.barrier(range(5))
qc.h(qr[0])
qc.h(qr[1])
qc.h(qr[2])
qc.h(qr[3])
qc.h(qr[4])
qc.barrier(range(5))
qc = qc.compose(circuit)
qc.barrier(range(5))
qc.h(qr[0])
qc.h(qr[1])
qc.h(qr[2])
qc.h(qr[3])
qc.barrier(range(5))
qc.measure(0,0)
qc.measure(1,1)
qc.measure(2,2)
qc.measure(3,3)
job1 = qs.execute(qc, qs.Aer.get_backend('aer_simulator'), shots = 1024)
output1 = job1.result().get_counts()
print(output1)
qc.draw('mpl')
def Oracle():
qr = qs.QuantumRegister(5,'q')
cr = qs.ClassicalRegister(4,'c')
qc = qs.QuantumCircuit(qr,cr)
qq = qs.QuantumCircuit(5,name='Uf')
v = random.randint(1, 2)
if v == 1:
qc.cx(0,4)
qc.cx(1,4)
qc.cx(2,4)
qc.cx(3,4)
print('Balanced (1)')
elif v == 2:
qq.i(qr[0])
qq.i(qr[1])
qq.i(qr[2])
qq.i(qr[3])
print('Constant (0)')
qq =qq.to_gate()
qc.append(qq,[0,1,2,3,4])
return qc
Deutsch_Jozsa(Oracle())
|
https://github.com/crabster/qiskit-learning
|
crabster
|
'''
This program implements the quantum Fourier transform (QFT)
'''
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, IBMQ
from qiskit.visualization import circuit_drawer as drawer
from qiskit.tools.visualization import plot_histogram
from qiskit import execute
from qiskit import Aer
import numpy as np
import time, os, shutil
from matplotlib.pyplot import plot, draw, show
def QFT(q, c, n):
qc = QuantumCircuit(q,c)
# First get the most significant bit
for k in range(n):
j = n - k
# now add the Hadamard transform to qubit j-1
qc.h(q[j-1])
# now each qubit from the lowest significance
# takes one conditional phase shift
for i in reversed(range(j-1)):
qc.cp(2*np.pi/2**(j-i), q[i], q[j-1])
# Finally swap the qubits
for i in range(n//2):
qc.swap(q[i], q[n-i-1])
return qc
# QFT is represented in a matrix form with 2^n rows and columns
# where n represents the number of qubits
def QFTmatrix(n):
qft = np.zeros([2**n,2**n], dtype=complex)
for i in range(2**n):
for k in range(2**n):
qft[i,k] = np.exp(i*k*2*2j*np.pi/(2**n))
return(1/np.sqrt(2**n)*qft)
def QFTcircuit(n):
q = QuantumRegister(n, "q")
c = ClassicalRegister(n, "c")
qc = QFT(q, c, n)
backend = Aer.get_backend('unitary_simulator')
job = execute(qc, backend)
actual = job.result().get_unitary()
np.around(actual, 2)
expected = QFTmatrix(n)
delta = actual - expected
print("Deviation: ", round(np.linalg.norm(delta), 10))
return qc
LaTex_folder_QFT = str(os.getcwd())+'/Latex_quantum_gates/Quantum_Fourier_transform/'
if not os.path.exists(LaTex_folder_QFT):
os.makedirs(LaTex_folder_QFT)
else:
shutil.rmtree(LaTex_folder_QFT)
os.makedirs(LaTex_folder_QFT)
n=4
qc = QFTcircuit(n)
# create a LaTex file for the algorithm
LaTex_code = qc.draw(output='latex_source', initial_state=True, justify=None) # draw the circuit
f_name = 'Quantum_Four_transform_'+str(n)+'qubits.tex'
with open(LaTex_folder_QFT+f_name, 'w') as f:
f.write(LaTex_code)
n = 4
q = QuantumRegister(n, "x")
c = ClassicalRegister(n, "c")
qftCircuit = QFT(q, c, n)
initCircuit = QuantumCircuit(q, c)
for qubit in q:
initCircuit.h(qubit)
initCircuit.barrier(q)
qc = QuantumCircuit.compose(initCircuit, qftCircuit)
qc.barrier(q)
qc.measure(q, c)
# on simulator
backend = Aer.get_backend('qasm_simulator')
job = execute(qc, backend)
k = job.result().get_counts()
print(k)
# on a real quantum computer
provider = IBMQ.load_account()
backend = provider.backend.ibmq_lima
print("Status of backened: ", backend.status())
job = execute(qc, backend=backend, shots = 1024)
lapse = 0
print("This step might take some time.")
time.sleep(3)
interval = 60
while((job.status().name != 'DONE')
and (job.status().name != 'Cancelled')
and (job.status().name != 'ERROR')):
print('Status @ {} seconds'.format(interval * lapse))
print(job.status())
print(job.queue_position())
time.sleep(interval)
lapse +=1
print(job.status())
plt = plot_histogram(job.result().get_counts())
|
https://github.com/crabster/qiskit-learning
|
crabster
|
from qiskit import QuantumCircuit, transpile, assemble
from qiskit.circuit.library import QFT
class CtrlMultCircuit(QuantumCircuit):
def __init__(self, a, binary_power, N):
super().__init__(N.bit_length())
self.a = a
self.power = 2 ** binary_power # Convert binary to decimal
self.N = N
self.name = f'{self.a}^{self.power} mod {self.N}'
self._create_circuit()
def _create_circuit(self):
for dec_power in range(self.power):
a_exp = self.a ** dec_power % self.N
for i in range(self.num_qubits):
if a_exp >> i & 1: self.x(i)
for j in range(i + 1, self.num_qubits):
if a_exp >> j & 1: self.swap(i, j)
class QPECircuit(QuantumCircuit):
def __init__(self, a, N):
super().__init__(2 * N.bit_length(), N.bit_length())
self.a = a
self.N = N
self._create_circuit()
def _modular_exponentiation(self):
for qbit_idx in range(self.num_qubits // 2):
self.append(
CtrlMultCircuit(self.a, qbit_idx, self.N).to_gate().control(),
[qbit_idx] + list(range(self.num_qubits // 2, 2 * self.num_qubits // 2))
)
def _create_circuit(self):
self.h(range(self.num_qubits // 2)) # Apply Hadamard gates to the first n qubits
self.x(self.num_qubits - 1)
self.barrier()
self._modular_exponentiation() # Apply controlled modular exponentiation
self.barrier()
self.append(
QFT(self.num_qubits // 2, inverse=True),
range(self.num_qubits // 2) # Apply inverse QFT to the first n qubits
)
def collapse(self, simulator):
self.measure(range(self.num_qubits // 2), range(self.num_qubits // 2))
transpiled_circuit = transpile(self, simulator)
self.collapse_result = simulator.run(transpiled_circuit, memory=True).result()
return self.collapse_result
|
https://github.com/crabster/qiskit-learning
|
crabster
|
'''
This is a implementation of the quantum teleportation algorithm
'''
from qiskit import *
from qiskit.visualization import plot_histogram
import os, shutil, numpy
from matplotlib.pyplot import plot, draw, show
LaTex_folder_Quantum_Teleportation = str(os.getcwd())+'/Latex_quantum_gates/Quantum_Teleportation/'
if not os.path.exists(LaTex_folder_Quantum_Teleportation):
os.makedirs(LaTex_folder_Quantum_Teleportation)
else:
shutil.rmtree(LaTex_folder_Quantum_Teleportation)
os.makedirs(LaTex_folder_Quantum_Teleportation)
qc = QuantumCircuit(3,3)
## prepare the state to be teleported
phi = 0*numpy.pi
theta= 0.5*numpy.pi
lam = 0*numpy.pi
qc.u(phi=phi, theta=theta,lam=lam,qubit=0)
## teleport the state
qc.barrier()
qc.h(1)
qc.cx(1,2)
qc.cz(0,1)
qc.h(0)
qc.h(1)
qc.barrier()
qc.measure([0,1],[0,1])
qc.barrier()
qc.x(2).c_if(0,1)
qc.z(2).c_if(1,1)
qc.h(2)
qc.measure(2,2)
LaTex_code = qc.draw(output='latex_source', initial_state=True, justify=None) # draw the circuit
f_name = 'quantum_teleportation.tex'
with open(LaTex_folder_Quantum_Teleportation+f_name, 'w') as f:
f.write(LaTex_code)
# simulation
simulator = Aer.get_backend('qasm_simulator')
result = execute(qc, backend=simulator, shots=100000).result()
counts = {'0':0,
'1': 0}
print(result.get_counts().keys())
for key, value in result.get_counts().items():
if(key[0] == '0'):
counts['0'] += value
else:
counts['1'] += value
print(counts)
plt = plot_histogram(counts)
draw()
show(block=True)
|
https://github.com/crabster/qiskit-learning
|
crabster
|
import qiskit
from .common_gates import *
import random
def superdense_coding_circuit(msg):
qc = qiskit.QuantumCircuit(2)
phi_plus = phi_plus_gate()
qc.append(phi_plus, [0, 1])
qc.barrier()
if msg[1] == '1':
qc.z(0)
if msg[0] == '1':
qc.x(0)
qc.barrier()
qc.append(phi_plus.inverse(), [0, 1])
qc.name = "SC"
return qc
def superdense_coding_example():
msg = random.choice(["00", "01", "10", "11"])
qc = qiskit.QuantumCircuit(2, 2)
sc_qc = superdense_coding_circuit(msg)
qc.append(sc_qc, [0, 1])
if msg[0] == '1':
qc.x(1)
if msg[1] == '1':
qc.x(0)
qc.measure([0, 1], [0, 1])
print(msg)
print(qc.draw(output="text"))
return qc
|
https://github.com/crabster/qiskit-learning
|
crabster
|
"""
Test Script
"""
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
qrx = QuantumRegister(1, 'q0')
qry = QuantumRegister(1, 'q1')
cr = ClassicalRegister(1, 'c')
qc = QuantumCircuit(qrx, qry, cr)
qc.h(qrx)
qc.x(qry)
qc.h(qry)
qc.barrier()
qc.x(qry)
qc.barrier()
qc.h(qrx)
qc.h(qry)
qc.measure(qrx, cr)
qc.draw("mpl")
from qiskit import execute
from qiskit.providers.aer import AerSimulator
from qiskit.visualization import plot_histogram
sim = AerSimulator()
job = execute(qc, backend = sim, shots = 1000)
result = job.result()
counts = result.get_counts(qc)
print("Counts: ", counts)
plot_histogram(counts)
|
https://github.com/yatharth0610/Quantum-Algorithms-qiskit-
|
yatharth0610
|
from qiskit import *
from qiskit.tools.jupyter import *
from qiskit.visualization import *
import matplotlib.pyplot as plotter
import numpy as np
from IPython.display import display, Math, Latex
%matplotlib inline
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
# The '0' state
plot_bloch_vector([0,0,1])
# The '1' state
plot_bloch_vector([0,0,-1])
qc1 = QuantumCircuit(2,2) # Initializing a quantum ciruit (2 qubits, 2 classical bits)
# All initialized to '0' by default.
qc1.draw(output='mpl') # Draws the circuit diagram
qc1.x(0) # Applying X gate to the first qubit
qc1.draw(output='mpl')
qc1.x(1) # Applying X gate to the second qubit
qc1.draw(output='mpl')
# The '+' state
plot_bloch_vector([1,0,0])
# The '-' state
plot_bloch_vector([-1,0,0])
qc2 = QuantumCircuit(2,2) # A new quantum circuit with 2 qubits and 2 classical bits
qc2.h(0) # Applying the Hadamard gate on first qubit
qc2.draw(output='mpl')
qc2.cx(0,1) # Applying CX gate ('control','target')
qc2.draw(output='mpl')
qc2.measure(0,0) # Measure first qubit and store it in first classical bit
qc2.measure(1,1) # Measure second qubit and store it in second classical bit
# The code below plots a histogram of the measurement result. You can copy it for further use.
def run_circuit(qc):
backend = Aer.get_backend('qasm_simulator') # we choose the simulator as our backend
result = execute(qc, backend, shots = 2000).result() # we run the simulation
counts = result.get_counts() # we get the counts
return counts
counts = run_circuit(qc2)
print(counts)
plot_histogram(counts)
qc1.h(0)
qc1.cx(0, 1)
qc1.draw(output='mpl')
qc1.measure(0,0)
qc1.measure(1,1)
def run_circuit(qc):
backend = Aer.get_backend('qasm_simulator')
result = execute(qc, backend, shots = 2000).result()
counts = result.get_counts()
return counts
counts = run_circuit(qc1)
print(counts)
plot_histogram(counts)
qc3 = QuantumCircuit(3,3)
qc3.x(range(3)) # Setting the all qubits to '1'
qc3.toffoli(0,1,2) # (control,control,target)
qc3.measure(0,0)
qc3.measure(1,1)
qc3.measure(2,2)
def run_circuit(qc3):
backend = Aer.get_backend('qasm_simulator') # we choose the simulator as our backend
result = execute(qc3, backend, shots = 2000).result() # we run the simulation
counts = result.get_counts() # we get the counts
return counts
counts = run_circuit(qc3)
print(counts)
plot_histogram(counts)
# The output should be '011' as the highest (q2) is flipped because the other two qubits were set to '1'
qc4 = QuantumCircuit(2,2)
#Applying the Pauli-X gate to quantum bit 0, we turn it into 1 so that the swap outcome is observable.
qc4.x(0)
qc4.cx(0, 1)
qc4.cx(1, 0)
qc4.cx(0, 1)
qc4.draw(output='mpl')
qc4.measure(0,0)
qc4.measure(1,1)
def run_circuit(qc):
backend = Aer.get_backend('qasm_simulator')
result = execute(qc, backend, shots = 2000).result()
counts = result.get_counts()
return counts
counts = run_circuit(qc4)
print(counts)
plot_histogram(counts)
qc5 = QuantumCircuit(2,2)
#We turn quantum bit 1 into 1 so that we can observe the results of HZH on both 0 (from q0) and 1 (from q1).
qc5.x(1)
qc5.h((0, 1))
qc5.z((0, 1))
qc5.h((0, 1))
qc5.draw(output='mpl')
qc5.measure(0,0)
qc5.measure(1,1)
def run_circuit(qc):
backend = Aer.get_backend('qasm_simulator')
result = execute(qc, backend, shots = 2000).result()
counts = result.get_counts()
return counts
counts = run_circuit(qc5)
print(counts)
plot_histogram(counts)
qc6 = QuantumCircuit(3,3)
#Initializing quantum bits using gates:
#q0 is initialized to 0.
#q1 is initialized to 1.
qc6.x(1)
#q2 is initialized to the state given above.
qc6.x(2)
qc6.h(2)
qc6.t(2)
#We change q2 for the controlled swap now; we'll bring it back to the same state afterwards.
qc6.tdg(2)
qc6.h(2)
#Controlled swap.
qc6.toffoli(0, 2, 1)
qc6.toffoli(1, 2, 0)
qc6.toffoli(0, 2, 1)
#We convert q2 back to whatever it was.
qc6.h(2)
qc6.t(2)
qc6.draw(output='mpl')
qc6.measure(0, 0)
qc6.measure(1, 1)
qc6.measure(2, 2)
def run_circuit(qc):
backend = Aer.get_backend('qasm_simulator')
result = execute(qc, backend, shots = 2000).result()
counts = result.get_counts()
return counts
counts = run_circuit(qc6)
print(counts)
plot_histogram(counts)
|
https://github.com/yatharth0610/Quantum-Algorithms-qiskit-
|
yatharth0610
|
from qiskit import *
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
import matplotlib.pyplot as plotter
import numpy as np
from IPython.display import display, Math, Latex
%matplotlib inline
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
qc1 = QuantumCircuit(3,3)
# All initialized to '0' by default.
qc1.x(0) #This is for the purpose of setting the control qubit to '1'
qc1.x(2) #As a result, the second target qubit becomes '1' while the first remains '0'. Now, lets's try swapping them.
#Fredkin gate:
def fredkin(qc):
qc.toffoli(0,1,2)
qc.toffoli(0,2,1)
qc.toffoli(0,1,2)
fredkin(qc1)
qc1.draw('mpl')
#First let's measure all three qubits.
#We're using the classical bits to store the result obtained on measuring each corresponding qubit.
qc1.measure(0,0)
qc1.measure(1,1)
qc1.measure(2,2)
#Now we use the same function we defined yesterday to run a quantum circuit
def run_circuit(qc2):
backend = Aer.get_backend('qasm_simulator') # we choose the simulator as our backend
result = execute(qc2, backend, shots = 2000).result() # we run the simulation
counts = result.get_counts() # we get the counts
return counts
counts1=run_circuit(qc1)
print(counts1)
plot_histogram(counts1)
qc2 = QuantumCircuit(3,3)
# All initialized to '0' by default.
qc2.x(2) #The second target qubit is initialised to '1'
fredkin(qc2)
qc2.measure(0,0)
qc2.measure(1,1)
qc2.measure(2,2)
qc2.draw(output='mpl')
counts2=run_circuit(qc2)
print(counts2)
plot_histogram(counts2)
qc = QuantumCircuit(1)
#This is how we apply the rotation operators in Qiskit, mentioning the angle of rotation and qubit no. as parameters
qc.rx(np.pi/2, 0)
qc.draw('mpl')
def final_vector(qc):
backend = Aer.get_backend('statevector_simulator')
job = execute(qc, backend)
result = job.result()
outputstate = result.get_statevector(qc, decimals=3)
return outputstate
print(final_vector(qc))
# This prints the vector obtained on applying the above gate to the qubit state '0'
# The Pauli-X gate serves this purpose, as demonstrated below:
qc3 = QuantumCircuit(1)
theta = np.pi/7
qc3.x(0)
qc3.ry(theta, 0)
qc3.x(0)
print(final_vector(qc3))
qc3 = QuantumCircuit(1)
qc3.ry(-theta, 0)
print(final_vector(qc3))
#Run this code for different values of theta and see if the two vectors printed are equal in each case
qc4 = QuantumCircuit(1)
alpha = np.pi/2
beta = 0
gamma = np.pi/2
delta = np.pi
def A(qc, qbits, beta, gamma):
qc.ry(gamma/2, qbits)
qc.rz(beta, qbits)
def B(qc, qbits, beta, gamma, delta):
qc.rz(-(beta+delta)/2, qbits)
qc.ry(-gamma/2, qbits)
def C(qc, qbits, beta, delta):
qc.rz((delta-beta)/2, qbits)
C(qc4, 0, beta, delta)
qc4.x(0)
B(qc4, 0, beta, gamma, delta)
qc4.x(0)
A(qc4, 0, beta, gamma)
qc4.unitary([[1.j, 0.], [0., 1.j]], [0])
print(final_vector(qc4))
qc4 = QuantumCircuit(1)
qc4.h(0)
print(final_vector(qc4))
qc5 = QuantumCircuit(3, 3)
# Target qubit q1 is initially |1> and target qubit q2 is initially |0>.
qc5.x(0) # Control qubit initialized to |1> to see effects of controlled Hadamard.
qc5.x(1) # One target qubit initialized to |1>.
alpha = np.pi/2
beta = 0
gamma = np.pi/2
delta = np.pi
def A(qc, qbits, beta, gamma):
qc.ry(gamma/2, qbits)
qc.rz(beta, qbits)
def B(qc, qbits, beta, gamma, delta):
qc.rz(-(beta+delta)/2, qbits)
qc.ry(-gamma/2, qbits)
def C(qc, qbits, beta, delta):
qc.rz((delta-beta)/2, qbits)
C(qc5, [1, 2], beta, delta)
qc5.cx(0, [1, 2])
B(qc5, [1, 2], beta, gamma, delta)
qc5.cx(0, [1, 2])
A(qc5, [1, 2], beta, gamma)
qc5.s(0) # Using S gate because alpha = pi/2
qc5.measure(0, 0)
qc5.measure(1, 1)
qc5.measure(2, 2)
qc5.draw('mpl')
def run_circuit(qc):
backend = Aer.get_backend('qasm_simulator')
result = execute(qc, backend, shots = 10000).result()
counts = result.get_counts()
return counts
counts = run_circuit(qc5)
print(counts)
plot_histogram(counts)
qc_u3=QuantumCircuit(1)
qc_u3.u3(np.pi/6,-np.pi/2,np.pi/2,0)
print(final_vector(qc_u3))
qc_rx=QuantumCircuit(1)
qc_rx.rx(np.pi/6,0)
print(final_vector(qc_rx))
#Getting the same results will verify our observation stated above
######### Defining some constants and functions ##########
# Constants for the decomposition of Hadamard gate.
H_alpha = np.pi/2
H_beta = 0
H_gamma = np.pi/2
H_delta = np.pi
# V^2 = X
V = [[0.5+0.5j, 0.5-0.5j],
[0.5-0.5j, 0.5+0.5j]]
# Constants for the decomposition of V (where V^2 = X).
V_alpha = np.pi/4
V_beta = np.pi/2
V_gamma = -np.pi/2
V_delta = -np.pi/2
# Functions to implement A, B, C (generalized).
def A_gate(qc, qbits, beta, gamma):
qc.ry(gamma/2, qbits)
qc.rz(beta, qbits)
def B_gate(qc, qbits, beta, gamma, delta):
qc.rz(-(beta+delta)/2, qbits)
qc.ry(-gamma/2, qbits)
def C_gate(qc, qbits, beta, delta):
qc.rz((delta-beta)/2, qbits)
# Higher abstraction functions.
def controlled_V(qc, control, target):
C_gate(qc, target, V_beta, V_delta)
qc.cx(control, target)
B_gate(qc, target, V_beta, V_gamma, V_delta)
qc.cx(control, target)
A_gate(qc, target, V_beta, V_gamma)
qc.t(control) # Using T gate because V_alpha = pi/4.
def controlled_Vdg(qc, control, target):
C_gate(qc, target, V_beta, V_delta)
qc.cx(control, target)
B_gate(qc, target, V_beta, -V_gamma, V_delta)
qc.cx(control, target)
A_gate(qc, target, V_beta, -V_gamma)
qc.tdg(control) # Using Tdg gate because V_alpha = pi/4, so Vdg_alpha would be -pi/4.
def double_controlled_X(qc, control1, control2, target):
controlled_V(qc, control2, target)
qc.cx(control1, control2)
controlled_Vdg(qc, control2, target)
qc.cx(control1, control2)
controlled_V(qc, control1, target)
############ Constructing the circuit ##############
qc6 = QuantumCircuit(7, 5) # No need to measure ancillary qubits :P
# q0, q1, q2, q3 are control qubits
# q4, q5 are ancillary qubits
# q6 is the target qubit
# Change the following line to try different combinations of control qubits:
qc6.x([0,1,2,3])
C_gate(qc6, 6, H_beta, H_delta)
double_controlled_X(qc6, 0, 1, 4)
double_controlled_X(qc6, 2, 3, 5)
double_controlled_X(qc6, 4, 5, 6)
double_controlled_X(qc6, 2, 3, 5)
double_controlled_X(qc6, 0, 1, 4)
B_gate(qc6, 6, H_beta, H_gamma, H_delta)
double_controlled_X(qc6, 0, 1, 4)
double_controlled_X(qc6, 2, 3, 5)
double_controlled_X(qc6, 4, 5, 6)
double_controlled_X(qc6, 2, 3, 5)
double_controlled_X(qc6, 0, 1, 4)
A_gate(qc6, 6, H_beta, H_gamma)
qc6.s([0,1,2,3]) # Using S gate because H_alpha = pi/2.
qc6.measure(0, 0)
qc6.measure(1, 1)
qc6.measure(2, 2)
qc6.measure(3, 3)
qc6.measure(6, 4)
qc6.draw('mpl')
def run_circuit(qc):
backend = Aer.get_backend('qasm_simulator')
result = execute(qc, backend, shots = 2000).result()
counts = result.get_counts()
return counts
counts = run_circuit(qc6)
print(counts)
plot_histogram(counts)
|
https://github.com/yatharth0610/Quantum-Algorithms-qiskit-
|
yatharth0610
|
from qiskit import *
from qiskit.tools.jupyter import *
from qiskit.visualization import *
import matplotlib.pyplot as plotter
import numpy as np
from IPython.display import display, Math, Latex
%matplotlib inline
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
qr = QuantumRegister(3)
crz = ClassicalRegister(1)
crx = ClassicalRegister(2) # we will need seperates registers for using 'c_if' later.
qc = QuantumCircuit(qr,crz,crx)
qc.x(0)
qc.h(0) # 'psi' can't be unknown to us as we are creating it here. Let us take '-' state as our 'psi'
# We will verify later if the '-' is been teleported.
qc.h(1)
qc.cx(1,2) # creating a bell state
qc.barrier() # Use barrier to separate steps, everything till this barrier is just intialisation.
qc.cx(0,1) # '0' and '1' are with Alice and '2' is with Bob.
# psi_1 prepared.
qc.h(0)
# psi_2 prepared.
qc.barrier()
qc.measure(0,0)
qc.measure(1,1)
qc.draw (output = 'mpl')
qc.x(2).c_if(crx,1) # 'c_if' compares a classical register with a value (either 0 or 1) and performs the
qc.z(2).c_if(crz,1) # operation if they are equal.
qc.draw('mpl')
# be careful of the order of applying X and Z!
qc.h(2)
qc.measure(2,crx[1])
def run_circuit(qc):
backend = Aer.get_backend('qasm_simulator') # we choose the simulator as our backend
result = execute(qc, backend, shots = 10000).result() # we run the simulation
counts = result.get_counts() # we get the counts
return counts
counts = run_circuit(qc)
print(counts)
plot_histogram(counts)
# the output should be '1xx' if the teleportation is successful.
# Refer to above cell for a detailed explanation of the strategy.
qc1 = QuantumCircuit(2, 2)
# Preparing Alice's Bell state: \beta_{00}
qc1.h(0)
qc1.cx(0, 1)
# Skyler's mischief:
# Suppose for this example that she applied Pauli-Y.
# You can change 'y' to 'x' or 'z' in the following line for other cases.
qc1.y(0)
# Alice's strategy:
qc1.cx(0, 1)
qc1.h(0)
qc1.measure(0, 0)
qc1.measure(1, 1)
qc1.draw('mpl')
def run_circuit(qc):
backend = Aer.get_backend('qasm_simulator') # we choose the simulator as our backend
result = execute(qc, backend, shots = 10000).result() # we run the simulation
counts = result.get_counts() # we get the counts
return counts
counts = run_circuit(qc1)
print(counts)
if '10' in counts:
print('Skyler used Pauli-X!')
if '11' in counts:
print('Skyler used Pauli-Y!')
if '01' in counts:
print('Skyler used Pauli-Z!')
plot_histogram(counts)
|
https://github.com/yatharth0610/Quantum-Algorithms-qiskit-
|
yatharth0610
|
%matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import *
from qiskit.compiler import *
from qiskit.tools.jupyter import *
from qiskit.visualization import *
import numpy as np
import qiskit.quantum_info as qi
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
#This cell is just for seeing what the U tilde matrix looks like
a, b, c, d = np.cos(np.pi/8), np.sin(np.pi/8), -np.sin(np.pi/8), np.cos(np.pi/8)
u_tilde = np.array([[a,c],[b,d]]).reshape(2,2)
print(u_tilde)
#This cell defines the controlled variant of the U tilde matrix
qc_for_u = QuantumCircuit(1)
qc_for_u.ry(np.pi/4, 0)
qc_for_u.name = "U"
controlled_u_tilde = qc_for_u.to_gate().control(2)
qc1 = QuantumCircuit(3)
qc1.x(0)
qc1.x(1)
qc1.toffoli(0,1,2)#Flipping the third bit if the first two are zero
qc1.x(0) #Essentially 000 -> 001
qc1.x(1)
qc1.x(0)
qc1.toffoli(0,2,1)#Flipping the second bit if the first bit is zero and the third is one
qc1.x(0) #Essentially 001 -> 011
qc1.append(controlled_u_tilde, [1, 2, 0])
qc1.x(0)
qc1.toffoli(0,2,1)#Undoing the flip from before
qc1.x(0)
qc1.x(0)
qc1.x(1)
qc1.toffoli(0,1,2)#Undoing the flip from before
qc1.x(0)
qc1.x(1)
qc1.draw('mpl')
U_circ = qi.Operator(qc1).data
print(U_circ)
qc2 = QuantumCircuit(3)
# Code for U
qc2.x(0)
qc2.x(1)
qc2.toffoli(0,1,2)#Flipping the third bit if the first two are zero
qc2.x(0) #Essentially 000 -> 001
qc2.x(1)
qc2.x(0)
qc2.toffoli(0,2,1)#Flipping the second bit if the first bit is zero and the third is one
qc2.x(0) #Essentially 001 -> 011
qc2.append(controlled_u_tilde, [1, 2, 0])
qc2.x(0)
qc2.toffoli(0,2,1)#Undoing the flip from before
qc2.x(0)
qc2.x(0)
qc2.x(1)
qc2.toffoli(0,1,2)#Undoing the flip from before
qc2.x(0)
qc2.x(1)
# Code for V
qc2.x(0)
qc2.toffoli(0,1,2) # |010> -> |011>
qc2.x(0)
qc2.toffoli(1,2,0) # V-tilde is the same as Toffoli
qc2.x(0)
qc2.toffoli(0,1,2) # Reversing the flip
qc2.x(0)
qc2.draw('mpl')
def without_global_phase(matrix: np.ndarray, atol: float = 1e-8) :
phases1 = np.angle(matrix[abs(matrix) > atol].ravel(order='F'))
if len(phases1) > 0:
matrix = np.exp(-1j * phases1[0]) * matrix
return matrix
V_circ = without_global_phase(qi.Operator(qc2).data)
print(V_circ)
#Function just returns norm ignoring global phase between unitaries
def norm(unitary_a: np.ndarray, unitary_b: np.ndarray) :
return np.linalg.norm(without_global_phase(unitary_b)-without_global_phase(unitary_a), ord=2)
#Make the Pauli Y gate
qcy = QuantumCircuit(1)
for i in range(6):
qcy.t(0)
qcy.h(0)
for i in range(4):
qcy.t(0)
qcy.h(0)
for i in range(2):
qcy.t(0)
Y_circ = qi.Operator(qcy).data
Y = np.array([[0,-1j],[1j,0]])
print(norm(Y_circ,Y))
print("Final Circuit:")
qcy.draw('mpl')
uni_q = np.array([[-0.25+0.60355339j, 0.60355339+0.45710678j],
[0.60355339-0.45710678j, 0.25+0.60355339j]]).reshape(2,2)
while True:
qc3 = QuantumCircuit(1)
for i in range(5):
for j in range(np.random.randint(8)):
qc3.t(0)
qc3.h(0)
for j in range(np.random.randint(8)):
qc3.t(0)
uni_q_circ = qi.Operator(qc3).data
if norm(uni_q_circ,uni_q) < 1e-8:
break
print("Final Error: ", norm(uni_q_circ,uni_q))
print("Final Circuit:")
qc3.draw('mpl')
#Defining the gate as controlled_irx
from qiskit.extensions import *
pi_alpha = np.arccos(0.6)
qc_for_irx = QuantumCircuit(1)
irx = np.array([[1j*np.cos(pi_alpha/2),np.sin(pi_alpha/2)],[np.sin(pi_alpha/2),1j*np.cos(pi_alpha/2)]]).reshape(2,2)
g_irx = UnitaryGate(data=irx,label=None)
controlled_irx = g_irx.control(2)
def final_vector(qc):
backend = Aer.get_backend('statevector_simulator')
job = execute(qc, backend)
result = job.result()
outputstate = result.get_statevector(qc, decimals=3)
return outputstate
n = 4
qcb = QuantumCircuit(n,n)
qcb.x(0)#Ancilla
qcb.x(1)#Ancilla You can use these two as control to use the controlled_irx gate
count1 = 0
while abs(0.5 - (count1*pi_alpha/np.pi)%2) >= 1e-2 or count1 % 4 != 0:
count1 += 1
count2 = 0
while abs(1.5 - (count2*pi_alpha/np.pi)%2) >= 1e-2 or count2 % 4 != 0:
count2 += 1
count3 = 0
while abs(4.0 - (count3*pi_alpha/np.pi)%4) >= 1e-2 or count3 % 4 != 2:
count3 += 1
for i in range(count1): # Rotation about x by pi/2 (count1 % 4 == 0)
qcb.append(controlled_irx, [0, 1, 2])
qcb.cx(2, 3)
for i in range(count2): # Rotation about x by -pi/2 (count2 % 4 == 0)
qcb.append(controlled_irx, [0, 1, 2])
qcb.x(0)
qcb.cx(3, 0)
for i in range(count3): # Rotation about x by 0 (count3 % 4 == 2)
qcb.append(controlled_irx, [0, 2, 3])
qcb.cx(3, 0)
qcb.x(0)
print("Executing circuit...")
#Get state of qubit which should have the |+> state using the backend simulator
i = 3 #Index for the qubit at |+> state
qcb.h(i)#Puts the |+> state to |0>
for i in range(4):
qcb.measure(i, i)
def run_circuit(qcb):
backend = Aer.get_backend('qasm_simulator') # we choose the simulator as our backend
result = execute(qcb, backend, shots = 2000).result() # we run the simulation
counts = result.get_counts() # we get the counts
return counts
counts = run_circuit(qcb)
print(counts)
plot_histogram(counts)
|
https://github.com/yatharth0610/Quantum-Algorithms-qiskit-
|
yatharth0610
|
%matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
import numpy as np
from fractions import Fraction as frac
import qiskit.quantum_info as qi
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
qc=QuantumCircuit(4)
#In this particular oracle, the last qubit is storing the value of the function
qc.cx(0,3)
qc.cx(1,3)
qc.cx(2,3)
#The last qubit is 1 if there are odd no. of 1s in the other 3 qubits
#and 0 otherwise
#Hence it is a balanced function
qc.draw('mpl')
qc1=QuantumCircuit(3)
qc1.x(2)
qc1.h(0)
qc1.h(1)
qc1.h(2)
qc1.barrier(range(3))
qc1.cx(0,2)
qc1.cx(1,2)
qc1.barrier(range(3))
qc1.h(0)
qc1.h(1)
meas = QuantumCircuit(3, 2)
meas.measure(range(2),range(2))
# The Qiskit circuit object supports composition using
# the addition operator.
circ = qc1+meas
circ.draw('mpl')
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = execute(circ, backend_sim, shots=1000)
result_sim = job_sim.result()
counts = result_sim.get_counts(circ)
print(counts)
plot_histogram(counts)
qc2=QuantumCircuit(5)
qc2.x(4)
qc2.h(0)
qc2.h(1)
qc2.h(2)
qc2.h(3)
qc2.h(4)
qc2.barrier(range(5))
#Your code for the oracle here
#YOU ARE PERMITTED TO USE ONLY SINGLE QUBIT GATES AND CNOT(cx) GATES
qc2.cx(0,4)
qc2.cx(1,4)
qc2.cx(2,4)
qc2.cx(3,4)
qc2.x(4)
qc2.barrier(range(5))
qc2.h(0)
qc2.h(1)
qc2.h(2)
qc2.h(3)
meas2 = QuantumCircuit(5, 4)
meas2.measure(range(4),range(4))
circ2 = qc2+meas2
circ2.draw('mpl')
#verification cell, reinitialising the circuit so that it's easier for you to copy-paste the oracle
qc2=QuantumCircuit(5)
#Add X gates HERE as required to change the input state
qc2.x([0,2])
qc2.barrier(range(5))
qc2.cx(0,4)
qc2.cx(1,4)
qc2.cx(2,4)
qc2.cx(3,4)
qc2.x(4)
qc2.barrier(range(5))
measv = QuantumCircuit(5, 1)
measv.measure(4,0)
circv = qc2+measv
circv.draw('mpl')
#DO NOT RUN THIS CELL WITHOUT EDITING THE ABOVE ONE AS DESIRED
#The following code will give you f(x) for the value of x you chose in the above cell
backend_sim2 = Aer.get_backend('qasm_simulator')
job_sim2 = execute(circv, backend_sim2, shots=1000)
result_sim2 = job_sim2.result()
counts2 = result_sim2.get_counts(circv)
print(counts2)
plot_histogram(counts2)
|
https://github.com/yatharth0610/Quantum-Algorithms-qiskit-
|
yatharth0610
|
from qiskit import *
from qiskit.compiler import *
from qiskit.tools.jupyter import *
from qiskit.visualization import *
import matplotlib.pyplot as plotter
import numpy as np
from IPython.display import display, Math, Latex
%matplotlib inline
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
qc1=QuantumCircuit(2)
qc1.h(0)
qc1.h(1)
qc1.barrier() #The part between the barriers is our oracle
qc1.cz(0,1)
#We are using a controlled-Z gate which flips the sign of the second qubit when both qubits are set to '1'
qc1.barrier()
qc1.draw('mpl')
def final_vector(qc):
backend = Aer.get_backend('statevector_simulator')
job = execute(qc, backend)
result = job.result()
outputstate = result.get_statevector(qc, decimals=3)
return outputstate
print(final_vector(qc1)) #We can see that the desired state has been obtained
qc2=QuantumCircuit(3)
qc2.h(0)
qc2.h(1)
qc2.h(2)
qc2.barrier()
#The part between the barriers is our oracle
qc2.x(0)
qc2.h(1)
qc2.x(2)
qc2.ccx(0, 2, 1)
qc2.x(0)
qc2.h(1)
qc2.x(2)
qc2.barrier()
qc2.draw('mpl')
def final_vector(qc):
backend = Aer.get_backend('statevector_simulator')
job = execute(qc, backend)
result = job.result()
outputstate = result.get_statevector(qc, decimals=3)
return outputstate
print(final_vector(qc2))
def ccz_gate(qc,a,b,c):
qc.h(c)
qc.ccx(a,b,c)
qc.h(c)
#Let's create an oracle which will mark the states 101 and 110
#(This particular oracle won't be using ancilla qubits)
def phase_oracle(circuit):
circuit.cz(0, 2)
circuit.cz(0, 1)
n=3
qc2=QuantumCircuit(n,n)
for i in range(0,n):
qc2.h(i)
qc2.barrier([0,1,2])
#This creates a superposition of all states
#We will now perform the Grover iteration
phase_oracle(qc2)
qc2.barrier([0,1,2])
for i in range(0,n):
qc2.h(i)
#Performing a conditional phase shift
qc2.x(0)
qc2.x(1)
qc2.x(2)
ccz_gate(qc2,0,1,2)
qc2.x(0)
qc2.x(1)
qc2.x(2)
for i in range(0,n):
qc2.h(i)
#The Grover iteration is now complete
qc2.barrier([0,1,2])
qc2.draw('mpl')
qc2.measure(0,0)
qc2.measure(1,1)
qc2.measure(2,2)
qc2.draw('mpl')
def counts_circ(circ):
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = execute(circ, backend_sim, shots=2000)
result_sim = job_sim.result()
counts = result_sim.get_counts(circ)
return(counts)
plot_histogram(counts_circ(qc2))
qc_mct=QuantumCircuit(5,5)
for i in range(0,4):
qc_mct.x(i)
qc_mct.mct([0,1,2,3],4)
qc_mct.draw('mpl')
qc_mct.measure(0,0)
qc_mct.measure(1,1)
qc_mct.measure(2,2)
qc_mct.measure(3,3)
qc_mct.measure(4,4)
plot_histogram(counts_circ(qc_mct))
def c3z_gate(qc, a, b, c, d):
qc.h(d)
qc.mct([a, b, c], d)
qc.h(d)
def phase_oracle(qc):
qc.x(1)
qc.x(3)
c3z_gate(qc, 0, 1, 2, 3) # Handles 1010
qc.x(2)
c3z_gate(qc, 0, 1, 2, 3) # Handles 1000
qc.x(3)
c3z_gate(qc, 0, 1, 2, 3) # Handles 1001
qc.x(2)
qc.x(0)
qc.x(3)
c3z_gate(qc, 0, 1, 2, 3) # Handles 0010
qc.x(0)
qc.x(1)
qc.x(3)
n = 4
qc3 = QuantumCircuit(n, n)
for i in range(0,n):
qc3.h(i)
qc3.barrier([0, 1, 2, 3])
phase_oracle(qc3)
qc3.barrier([0, 1, 2, 3])
for i in range(0,n):
qc3.h(i)
qc3.x(0)
qc3.x(1)
qc3.x(2)
qc3.x(3)
c3z_gate(qc3, 0, 1, 2, 3)
qc3.x(0)
qc3.x(1)
qc3.x(2)
qc3.x(3)
for i in range(0,n):
qc3.h(i)
qc3.barrier([0, 1, 2, 3])
qc3.measure(0, 0)
qc3.measure(1, 1)
qc3.measure(2, 2)
qc3.measure(3, 3)
qc3.draw('mpl')
def counts_circ(circ):
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = execute(circ, backend_sim, shots=2000)
result_sim = job_sim.result()
counts = result_sim.get_counts(circ)
return(counts)
plot_histogram(counts_circ(qc3))
|
https://github.com/yatharth0610/Quantum-Algorithms-qiskit-
|
yatharth0610
|
from qiskit import *
from qiskit.compiler import *
from qiskit.tools.jupyter import *
from qiskit.visualization import *
import matplotlib.pyplot as plotter
import scipy
import numpy as np
from IPython.display import display, Math, Latex
import qiskit.quantum_info as qi
%matplotlib inline
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
def qft_rotations(circuit, n):
"""Performs qft on the first n qubits in circuit (without swaps)"""
if n == 0:
return circuit
n -= 1
circuit.h(n)
for qubit in range(n):
circuit.cu1(np.pi/2**(n-qubit), qubit, n)
# At the end of our function, we call the same function again on
# the next qubits (we reduced n by one earlier in the function)
qft_rotations(circuit, n)
def swap_registers(circuit, n):
for qubit in range(n//2):
circuit.swap(qubit, n-qubit-1)
return circuit
def qft(circuit, n):
"""QFT on the first n qubits in circuit"""
qft_rotations(circuit, n)
swap_registers(circuit, n)
return circuit
# Let's see how it looks:
qc = QuantumCircuit(4,4)
qft(qc,4)
qc.draw(output = 'mpl')
def inverse_qft(circuit, n):
"""Does the inverse QFT on the first n qubits in circuit"""
# First we create a QFT circuit of the correct size:
qft_circ = qft(QuantumCircuit(n), n)
# Then we take the inverse of this circuit
invqft_circ = qft_circ.inverse()
# And add it to the first n qubits in our existing circuit
circuit.append(invqft_circ, circuit.qubits[:n])
return circuit.decompose() # .decompose() allows us to see the individual gates
qc = inverse_qft(qc,4)
qc.measure(range(4),range(4))
def run_circuit(qc):
backend = Aer.get_backend('qasm_simulator') # we choose the simulator as our backend
result = execute(qc, backend, shots = 10000).result() # we run the simulation
counts = result.get_counts() # we get the counts
return counts
counts = run_circuit(qc)
print(counts)
plot_histogram(counts)
# we should get the intial state '0000'
qc1 = QuantumCircuit(3,3)
qc1.x(0)
qc1.x(1)
qc1.x(2) # try for different initial values
for i in range(4):# choose the number of times you want to do qft)
qft(qc1,3)
qc1.measure(0,0)
qc1.measure(1,1)
qc1.measure(2,2)
def run_circuit(qc1):
backend = Aer.get_backend('qasm_simulator') # we choose the simulator as our backend
result = execute(qc1, backend, shots = 10000).result() # we run the simulation
counts = result.get_counts() # we get the counts
return counts
counts = run_circuit(qc1)
print(counts)
plot_histogram(counts)
qc2 = QuantumCircuit(2)
for i in range(2):
qft(qc2, 2)
matrix = qi.Operator(qc2).data
print(matrix)
def Modulo_increment(qc):
qft(qc,4)
for i in range(4):
qc.u1(np.pi/(2**(3-i)), i)
qft(qc, 4)
return qc
# checking for the case of '1000'
qc2 = QuantumCircuit(4,4)
qc2.x(3)
qc2 = Modulo_increment(qc2)
qc2.measure(range(4),range(4))
# qc2.draw('mpl')
def run_circuit(qc2):
backend = Aer.get_backend('qasm_simulator') # we choose the simulator as our backend
result = execute(qc2, backend, shots = 10000).result() # we run the simulation
counts = result.get_counts() # we get the counts
return counts
counts = run_circuit(qc2)
print(counts)
plot_histogram(counts)
# checking for the case of '1101'
qc3 = QuantumCircuit(4,4)
qc3.x(3)
qc3.x(2)
qc3.x(0)
qc3 = Modulo_increment(qc2)
qc3.measure(range(4),range(4))
def run_circuit(qc3):
backend = Aer.get_backend('qasm_simulator') # we choose the simulator as our backend
result = execute(qc3, backend, shots = 10000).result() # we run the simulation
counts = result.get_counts() # we get the counts
return counts
counts = run_circuit(qc3)
print(counts)
plot_histogram(counts)
# checking for the case of '1111'
qc4 = QuantumCircuit(4,4)
qc4.x(range(4))
qc4 = Modulo_increment(qc4)
qc4.measure(range(4),range(4))
def run_circuit(qc4):
backend = Aer.get_backend('qasm_simulator') # we choose the simulator as our backend
result = execute(qc4, backend, shots = 10000).result() # we run the simulation
counts = result.get_counts() # we get the counts
return counts
counts = run_circuit(qc4)
print(counts)
plot_histogram(counts)
|
https://github.com/yatharth0610/Quantum-Algorithms-qiskit-
|
yatharth0610
|
!pip install tabulate
%matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from tabulate import tabulate
import numpy as np
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
def qft_dagger(n):
"""n-qubit QFTdagger the first n qubits in circ"""
qc = QuantumCircuit(n)
# Don't forget the Swaps!
for qubit in range(n//2):
qc.swap(qubit, n-qubit-1)
for j in range(n):
for m in range(j):
qc.cu1(-np.pi/float(2**(j-m)), m, j)
qc.h(j)
qc.name = "QFT†"
return qc
def __c_amod15(power):
"""Controlled multiplication by a mod 15"""
U = QuantumCircuit(4)
for iteration in range(power):
U.swap(2,3)
U.swap(1,2)
U.swap(0,1)
for q in range(4):
U.x(q)
U = U.to_gate()
U.name = "a^%i mod 15" % (power)
c_U = U.control()
return c_U
t=3
qc = QuantumCircuit(t+4,t)
for i in range(t):
qc.h(i) # The first t qubits are the first register (storing 'x')
qc.x(6) #The second register is in state |1>
# Oracle for the f(x) mentioned above
def Oracle(qc):
for q in range(3):
qc.append(__c_amod15(2**q), [q] + [i+3 for i in range(4)])
Oracle(qc)
qc.append(qft_dagger(t),range(t)) # inverse quantum fourier transform only of the register (first 4 qubits)
qc.measure(range(t), range(t))
def run_circuit(qc):
backend = Aer.get_backend('qasm_simulator') # we choose the simulator as our backend
result = execute(qc, backend, shots = 100000).result() # we run the simulation
counts = result.get_counts() # we get the counts
return counts
counts = run_circuit(qc)
print(counts)
plot_histogram(counts)
rows, eigenvalues = [], []
for output in counts:
decimal = int(output, 2)
eigenvalue = decimal/(2**t)
eigenvalues.append(eigenvalue)
rows.append(["%s(bin) = %i(dec)" % (output, decimal), "%i/%i = %.2f" % (decimal, 2**t, eigenvalue)])
print(tabulate(rows, headers=["Register Output", "Phase"]))
0.333333333.as_integer_ratio()
rows = []
for eigenvalue in eigenvalues:
numerator, denominator = eigenvalue.as_integer_ratio()
rows.append([eigenvalue, "%i/%i" % (numerator, denominator), denominator])
print(tabulate(rows, headers=["Phase", "Fraction", "Guess for r"], colalign=('right','right','right')))
|
https://github.com/yatharth0610/Quantum-Algorithms-qiskit-
|
yatharth0610
|
%matplotlib inline
# Importing standard Qiskit libraries
import random
from qiskit import *
from qiskit.tools.jupyter import *
from qiskit.visualization import *
#Get the library to check the answers
%pip install -I git+https://github.com/mnp-club/MnP_QC_Workshop.git
from mnp_qc_workshop_2020.bb84 import *
# Configuring account
provider = IBMQ.load_account()
backend = provider.get_backend('ibmq_qasm_simulator') # with this simulator it wouldn't work \
# Initial setup
random.seed(64) # do not change this seed, otherwise you will get a different key
# This is your 'random' bit string that determines your bases
numqubits = 16
bob_bases = str('{0:016b}'.format(random.getrandbits(numqubits)))
def bb84():
print('Bob\'s bases:', bob_bases)
# Now Alice will send her bits one by one...
all_qubit_circuits = []
for qubit_index in range(numqubits):
# This is Alice creating the qubit
thisqubit_circuit = alice_prepare_qubit(qubit_index)
# This is Bob finishing the protocol below
bob_measure_qubit(bob_bases, qubit_index, thisqubit_circuit)
# We collect all these circuits and put them in an array
all_qubit_circuits.append(thisqubit_circuit)
# Now execute all the circuits for each qubit
results = execute(all_qubit_circuits, backend=backend, shots=1).result()
# And combine the results
bits = ''
for qubit_index in range(numqubits):
bits += [measurement for measurement in results.get_counts(qubit_index)][0]
return bits
# Here is your task
def bob_measure_qubit(bob_bases, qubit_index, qubit_circuit):
if bob_bases[qubit_index] == '1':
qubit_circuit.h(0)
qubit_circuit.measure(0,0)
bits = bb84()
print('Bob\'s bits: ', bits)
check_bits(bits)
alice_bases = '0100000101011100' # Alice's bases bits
key = ''
for i in range(16):
if (alice_bases[i] == bob_bases[i]):
key += bits[i]
print(key)
check_key(key)
message = get_message()# encrypted message
decrypted = ''
for i in range(43):
for j in range(8):
decrypted += str((int(message[8*i+j]) + int(key[j]))%2)
print(decrypted)
check_decrypted(decrypted)
decrypted_to_string_ASCII = ''
for i in range(43):
for i in range(43):
decrypted_to_string_ASCII += chr(int(decrypted[8*i:8*(i+1)], 2))
check_message(decrypted_to_string_ASCII)
|
https://github.com/yatharth0610/Quantum-Algorithms-qiskit-
|
yatharth0610
|
!pip install tabulate
%matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from tabulate import tabulate
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
#Get the library to check the answers
%pip install -I git+https://github.com/mnp-club/MnP_QC_Workshop.git
from mnp_qc_workshop_2020.discrete_logarithm import qft_dagger, oracle, check_answer
n_qubits = 3 #Number of qubits for the registers of |x1> and |x2>
#For figuring out you would just need 2*n_qubits classical bits
qc_disc_log = QuantumCircuit(4+n_qubits+n_qubits, n_qubits+n_qubits)
for i in range(2*n_qubits):
qc_disc_log.h(i)
qc_disc_log.x(9)
qc_disc_log.append(oracle(), range(10))
qc_disc_log.append(qft_dagger(3), range(3))
qc_disc_log.append(qft_dagger(3) ,[3,4,5])
qc_disc_log.measure(range(2*n_qubits), range(2*n_qubits))
qc_disc_log.draw('text')
backend = Aer.get_backend('qasm_simulator')
results = execute(qc_disc_log, backend, shots=8192).result()
counts = results.get_counts()
plot_histogram(counts)
rows_x_1, eigenvalues_x_1 = [], []
for output in counts:
decimal = int(output, 2)//8
eigenvalue = decimal/(2**3)
eigenvalues_x_1.append(eigenvalue)
rows_x_1.append(["%s(bin) = %i(dec)" % (output[0:3], decimal), "%i/%i = %.2f" % (decimal, 2**3, eigenvalue)])
print(tabulate(rows_x_1, headers=["Register Output", "Phase"]))
rows_x_2, eigenvalues_x_2 = [], []
for output in counts:
decimal = int(output, 2) - ((int(output, 2)//8)*8)
eigenvalue = decimal/(2**3)
eigenvalues_x_2.append(eigenvalue)
rows_x_2.append(["%s(bin) = %i(dec)" % (output[3:6], decimal), "%i/%i = %.2f" % (decimal, 2**3, eigenvalue)])
print(tabulate(rows_x_2, headers=["Register Output", "Phase"]))
#Store your value for s here
s = 3
#Do analysis of oracle here
qc = QuantumCircuit(10, 4)
qc.x(0)
qc.x(9)
qc.append(oracle(), range(10))
qc.measure([6,7,8,9], range(4))
backend = Aer.get_backend('qasm_simulator')
results = execute(qc, backend, shots=8192).result()
counts = results.get_counts()
plot_histogram(counts)
# On x1=1, ans = 2 and on x2=1, ans = 8
#Store values of a and b here
a, b = 2, 8
check_answer(s,a,b)
|
https://github.com/yatharth0610/Quantum-Algorithms-qiskit-
|
yatharth0610
|
# Importing standard Qiskit libraries and configuring account
from qiskit import *
from qiskit.compiler import *
from qiskit.tools.jupyter import *
from qiskit.visualization import *
import matplotlib.pyplot as plotter
import scipy
import numpy as np
from IPython.display import display, Math, Latex
import qiskit.quantum_info as qi
%matplotlib inline
%pip install -I git+https://github.com/mnp-club/MnP_QC_Workshop.git
from mnp_qc_workshop_2020.unitary_circuit import *
U = get_unitary()
print(U.shape)
fig, (ax1, ax2) = plotter.subplots(nrows = 1, ncols = 2, figsize=(12,6))
ax1.imshow(np.real(U)) #plot real parts of each element
ax2.imshow(np.imag(U)) #plot imaginary parts of each element
fig, (ax3, ax4) = plotter.subplots(nrows = 1, ncols = 2, figsize=(12,6))
ax3.imshow(np.abs(U)) #plot the absolute values of each element
ax4.imshow(np.angle(U)) #plot the phase angles of each element
qc = QuantumCircuit(4)
qc.unitary(U, range(4))
matrix = qi.Operator(qc).data
print(matrix)
#
#
#Your code here
#
#
# qc = transpile(qc,basis_gates=['cx','u3'],optimization_level=3)
# qc.draw('mpl')
#Run this cell for getting your circuit checked
check_circuit(qc)
|
https://github.com/danieljaffe/quantum-algorithms-qiskit
|
danieljaffe
|
from qiskit import QuantumCircuit
from QCLG_lvl3.oracles.secret_number_oracle import SecretNUmberOracle
class BernsteinVazirani:
@classmethod
def bernstein_vazirani(cls, random_binary, eval_mode: bool) -> QuantumCircuit:
# Construct secret number oracle
secret_number_oracle = SecretNUmberOracle.create_secret_number_oracle(random_binary=random_binary, eval_mode=eval_mode)
num_of_qubits = secret_number_oracle.num_qubits
# Construct circuit according to the length of the number
dj_circuit = QuantumCircuit(num_of_qubits, num_of_qubits - 1)
dj_circuit_before_oracle = QuantumCircuit(num_of_qubits, num_of_qubits - 1)
# Apply H-gates
for qubit in range(num_of_qubits - 1):
dj_circuit_before_oracle.h(qubit)
# Put output qubit in state |->
dj_circuit_before_oracle.x(num_of_qubits - 1)
dj_circuit_before_oracle.h(num_of_qubits - 1)
dj_circuit += dj_circuit_before_oracle
# Add oracle
dj_circuit += secret_number_oracle
dj_circuit_after_oracle = QuantumCircuit(num_of_qubits, num_of_qubits - 1)
# Repeat H-gates
for qubit in range(num_of_qubits - 1):
dj_circuit_after_oracle.h(qubit)
dj_circuit_after_oracle.barrier()
# Measure
for i in range(num_of_qubits - 1):
dj_circuit_after_oracle.measure(i, i)
dj_circuit += dj_circuit_after_oracle
if not eval_mode:
print("Circuit before the oracle\n")
print(QuantumCircuit.draw(dj_circuit_before_oracle))
print("Circuit after the oracle\n")
print(QuantumCircuit.draw(dj_circuit_after_oracle))
print(dj_circuit)
return dj_circuit
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.