def make_target(nf, nq, ptype, n_bit, n_bits):
id_list = lambda: [qutip.qeye(2) for _ in range(n_bits + 1)]
x_ops = [id_list() for _ in range(n_bits)]
z_ops = [id_list() for _ in range(n_bits)]
h_ops = [id_list() for _ in range(n_bits)]
ih_ops = [id_list() for _ in range(n_bits)]
cx_ops = []
m_cz_ops = []
m_cx_ops = []
m_cy_ops = []
for i in range(n_bits):
z_ops[i][i + 1] = qutip.sigmaz()
x_ops[i][i + 1] = qutip.sigmax()
h_ops[i][i + 1] = qutip.hadamard_transform()
ih_ops[i][i + 1] = qutip.Qobj([[-1, 1], [-1j, -1j]]) / sqrt(2)
z_ops[i] = qutip.tensor(*z_ops[i])
x_ops[i] = qutip.tensor(*x_ops[i])
h_ops[i] = qutip.tensor(*h_ops[i])
ih_ops[i] = qutip.tensor(*ih_ops[i])
cx_ops.append(
qutip.controlled_gate(qutip.hadamard_transform(), n_bits + 1,
i + 1, 0))
m_cz_ops.append(
qutip.controlled_gate(qutip.sigmax(), n_bits + 1, i + 1, 0))
m_cx_ops.append(h_ops[i] * m_cz_ops[i] * h_ops[i])
m_cy_ops.append(ih_ops[i] * m_cz_ops[i] * ih_ops[i])
for ops in (x_ops, z_ops, h_ops, m_cz_ops, m_cx_ops, m_cy_ops):
ops.reverse()
bits_n = 2**n_bits
flip_target = id_list()
flip_target[0] = qutip.sigmax()
flip_target = qutip.tensor(*flip_target)
if ptype == 'i':
targ = qutip.tensor(*id_list())
elif ptype == 'mz':
targ = m_cz_ops[n_bit - 1] * flip_target
elif ptype == 'mx':
targ = m_cx_ops[n_bit - 1]
elif ptype == 'my':
targ = m_cy_ops[n_bit - 1]
elif ptype == 'x':
targ = x_ops[n_bit - 1]
elif ptype == 'z':
targ = z_ops[n_bit - 1]
U = np.zeros((nq * nf, nq * nf), dtype=np.complex)
U[:bits_n, :bits_n] = targ[:bits_n, :bits_n]
U[nf:nf + bits_n, :bits_n] = targ[bits_n:, :bits_n]
U[:bits_n, nf:nf + bits_n] = targ[:bits_n, bits_n:]
U[nf:nf + bits_n, nf:nf + bits_n] = targ[bits_n:, bits_n:]
mask_c = np.zeros(nf)
mask_c[:bits_n] = 1
mask_q = np.zeros(nq)
mask_q[:2] = 1
mask = np.kron(mask_q, mask_c)
mask = np.arange(len(mask))[mask == 1]
return U, mask
def gen_basis_vectors(n, dims, choice):
vectors = []
basic_states = []
bits = int(math.log(n, 2))
#for i in range(n):
#state=qt.basis(n,i)
#fock_states.append(state)
q = rabbit(bits, [], 0)
basic_states.append(q)
q = rabbit(bits, [1], 0)
basic_states.append(q)
q = rabbit(bits, [n - 1], 0)
basic_states.append(q)
indexvec = []
for i in range(bits):
indexvec.append(i)
q = rabbit(bits, indexvec, 1)
basic_states.append(q)
test_opt1 = [
basic_states[0], basic_states[1], basic_states[2], basic_states[3]
]
test_opt2 = [
basic_states[0], basic_states[1], basic_states[2], basic_states[3],
basic_states[-1] + basic_states[1]
]
if choice == 1: #Basis states
vectors = basic_states
q = qt.Qobj(np.ones(n))
q = q.unit()
vectors.append(q)
vectors.append(state) #there is no two for now
elif choice == 2:
vectors = basic_states
elif choice == 3: #Hadamard option 1
h = tensor_fix(qt.hadamard_transform(bits))
for state in basic_states:
state_n = h * state
state_n = state_n.unit()
vectors.append(state_n)
elif choice == 4: #QFT option 1
quft = tensor_fix(qft.qft(bits))
for state in basic_states:
state_n = quft * state
state_n = state_n.unit()
vectors.append(state_n)
elif choice == 5: #Hadamard option 2
h = tensor_fix(qt.hadamard_transform(bits))
for state in basic_states:
state_n = h * state
state_n = state_n.unit()
vectors.append(state_n)
elif choice == 6: #QFT option 2
quft = tensor_fix(qft.qft(bits))
for state in basic_states:
state_n = quft * state
state_n = state_n.unit()
vectors.append(state_n)
vectors.append(state_n)
return vectors
def gen_basis_vectors(n,dims,choice):
vectors=[]
fock_states=[]
bits=int(math.log(n,2))
q=rabbit(bits,[],0)
basic_states.append(q)
q=rabbit(bits,[1],0)
basic_states.append(q)
q=rabbit(bits,[n-1],0)
basic_states.append(q)
indexvec=[]
for i in range(bits):
indexvec.append(i)
q=rabbit(bits,indexvec,1)
basic_states.append(q)
if choice == 1: #Unused psuedo-Basis states
vectors = basis_states
q=qt.Qobj(np.ones(n))
q=q.unit()
vectors.append(q)
vectors.append(state)
elif choice ==2: #true basis states
vectors=basic_states
elif choice == 3: #Hadamard option 1
h=tensor_fix(qt.hadamard_transform(bits))
for state in basic_states:
state_n=h*state
state_n=state_n.unit()
vectors.append(state_n)
elif choice == 4: #QFT option 1
quft=tensor_fix(qft.qft(bits))
for state in basis_states:
state_n=quft*state
state_n=state_n.unit()
vectors.append(state_n)
elif choice == 5: #Hadamard option 2
h=tensor_fix(qt.hadamard_transform(bits))
for state in basis_states:
state_n=h*state
state_n=state_n.unit()
vectors.append(state_n)
elif choice == 6: #QFT option 2
quft=tensor_fix(qft.qft(bits))
for state in basis_states:
state_n=quft*state
state_n=state_n.unit()
vectors.append(state_n)
vectors.append(state_n)
return vectors
def get_single_gate_data():
inputs = []
h = tensor_fix(qt.hadamard_transform())
zero = tensor_fix(qt.fock(2, 0))
one = tensor_fix(qt.fock(2, 1))
inputs.append(h * zero)
inputs.append(h * one)
inputs.append(h * zero)
inputs.append(h * one)
gate = paulix(1, 0)
ideal = get_ideal([gate], inputs, inputs, 1, 4)
tag = "X"
pop = input("how may data points? ")
pop = int(pop)
path = "SingleDoubleHada2000.csv"
probabilities = []
for i in range(pop):
alt_gate = alter(gate)
temparray = []
for state in inputs:
final = basic_b(state, [alt_gate])
prob = dis(final, state)
temparray.append(prob)
if within_tolerance(0.78, temparray, ideal[0]):
temparray.append("tolerance")
else:
temparray.append(tag)
probabilities.append(temparray)
with open(path, 'a', newline='') as csvFile:
writer = csv.writer(csvFile)
writer.writerow(temparray)
csvFile.close
return probabilities
def genstate(s):
"""helper function to obtain the correct initialization"""
newstr = s.replace("+", "0")
newstr = newstr.replace("-", "1")
print(newstr)
state = qt.ket(newstr)
if s[0] == "+" or s[0] == "-":
operator = qt.hadamard_transform()
else:
operator = qt.identity(2)
for i in range(1, len(s), 1):
if s[i] == "+" or s[i] == "-":
#apply hadamard
operator = qt.tensor([operator, qt.hadamard_transform()])
else:
operator = qt.tensor([operator, qt.identity(2)])
return operator * state
def test_normalize_Fock_superpositons(self):
matrix = qutip.hadamard_transform(N=1).full()
state = (mb.ManyBosonFockState(2, mal=(0, 0)) -
mb.ManyBosonFockState(2, mal=(1, 1)))
state.evolve(matrix)
state.normalize_coefficients()
np.testing.assert_allclose(state.get_coefficients(),
[0.7071067811865475, -0.7071067811865475])
def genstate(s):
"""helper function to obtain the correct initialization"""
newstr = s.replace("+","0")
newstr = newstr.replace("-","1")
print(newstr)
state = qt.ket(newstr)
if s[0] == "+" or s[0]=="-":
operator=qt.hadamard_transform()
else:
operator=qt.identity(2)
for i in range(1,len(s),1):
if s[i] == "+" or s[i]=="-":
#apply hadamard
operator = qt.tensor([operator,qt.hadamard_transform()])
else:
operator = qt.tensor([operator,qt.identity(2)])
return operator * state
def test_create_and_evolve_from_cf(self):
mbfs = mb.ManyBosonFockState(2, mal=(0, 1))
mbps = mbfs.evolve(qutip.hadamard_transform().full())
amps = mbps.get_many_boson_amplitudes()
self.assertEqual(list(amps.keys()), [(1, 1), (2, )])
expected_output_11 = np.array([0])
expected_output_2 = np.array([0.70710678 + 0.j, -0.70710678 + 0.j])
np.testing.assert_allclose(amps[(1, 1)], expected_output_11)
np.testing.assert_allclose(amps[(2, )], expected_output_2)
def hadamard_preprocessing(hada):
storage = hada.full()
(n, n) = hada.shape
q = np.log(n) / np.log(2) #number of qubits
seed = randint(0, q - 1)
forbidden = [] #a vector to hold forbidden seeds
mag = storage[0][0] #magnitude of the elements in the hadamard
ongoing = True
while ongoing:
i = 1
count = 0
while seed in forbidden: #make sure the seed isn't forbidden
seed = randint(0, q - 1)
count += 1
if count == 200: #no infinite loops
break
#initialize test unitary
if seed == 0:
u1 = qt.hadamard_transform(1)
else:
u1 = id2
#create test unitary
while u1.shape != (n, n):
if i == seed: #set a hadamard on specified qubit
u1 = qt.tensor(u1, qt.hadamard_transform(1))
u1 = tensor_fix(u1)
else:
u1 = qt.tensor(u1, id2)
u1 = tensor_fix(u1)
i += 1
check = u1 * hada
if check.full(
)[0][0] > mag: #if there's a hadamard on that qubit, true
ongoing = False
elif count == 200:
print("oops")
break
else: #no hadamard on that seed qubit
forbidden.append(seed)
return hada, seed
def hadamaker(qubits, affected):
array = []
i = 0
while len(array) < qubits:
if i in affected:
gate = qt.hadamard_transform()
gate = tensor_fix(gate)
else:
gate = id2
array.append(gate)
i += 1
hadamade = qt.Qobj([[1]])
for gate in array:
hadamade = qt.tensor(hadamade, gate)
hadamade = tensor_fix(hadamade)
return hadamade
def set_gate_group(self, gate_group, custom_gates=None):
"""
Defines the gate group to be used within the enviroment
Args:
gate_group (str): name of the gate group used
custom_gates (dict): A set of custom gates may be defined using a dictionary,
the form looks like{"gate_name":gate_function}
Returns:
None
"""
gate_group = gate_group.lower()
if gate_group == 'clifford':
# Clifford group uses cnot, phase gate and hadamard
self.gate_group_list = [
self.qcircuit.iden, self.qcircuit.cx, self.qcircuit.h,
self.qcircuit.s, self.qcircuit.t
]
elif gate_group == 'pauli':
self.gate_group_list = [
self.qcircuit.iden, self.qcircuit.h, self.qcircuit.x,
self.qcircuit.z, self.qcircuit.cx
]
elif gate_group == 'IQP':
self.gate_group_list = [
self.qcircuit.iden, self.qcircuit.t, (2, self.c_s_gate)
]
# Sets up the circuit with initial hadamard gates,
# as is necessary for circuits with the IQP format
temp_state = (hadamard_transform(self.num_qubits) *
qubit_states(self.num_qubits)).full()
self.qcircuit.initialize(
temp_state.flatten(),
[self.q_reg[i] for i in range(self.num_qubits)])
elif gate_group == 'custom':
assert custom_gates is not None, 'custom_gates is not defined.'
self.gate_group_list = custom_gates
else:
raise "%s gate_group not defined!" % gate_group
def init_unitaries(self, target_name, U_targ=None):
if not U_targ:
if target_name == 'x' or target_name == 'sigmax' or target_name == 'XGate':
if self.two_level:
U_targ = sigmax()
else:
U_targ = get_sigmax()
elif target_name == 'h' or target_name == 'hadamard':
if self.two_level:
U_targ = hadamard_transform(1)
else:
U_targ = get_hadamard()
elif target_name == 'cnot':
if self.two_level:
U_targ = cnot()
else:
U_targ = get_cnot()
self.U_targ = U_targ
self.target_name = target_name
def get_hadamard():
h = hadamard_transform(1).full()
hadamard_3 = Qobj([[h[0][0], h[0][1], 0], [h[1][0], h[1][1], 0], [0, 0,
1]])
return hadamard_3
def arb_circuit_generator(length,qubits):
circuit=[]
angles=[]
controls=[]
id2=np.identity(2)
id2=qt.Qobj(id2)
n=2**qubits
Had = 0
CNOT = 0
Ran = 0
while len(circuit)<2*length:
seed=randint(1,3)
if seed ==1:
temp=qt.hadamard_transform()
temp=tensor_fix(temp)
circuit.append(temp)
circuit.append("Hadamard")
Had = Had +1
if seed == 2:
temp=rot(qubits,False)
circuit.append(temp)
circuit.append("CNOT")
CNOT = CNOT +1
if seed == 3:
(temp,ang)=unitary_gate(False)
circuit.append(temp)
circuit.append("Random Unitary")
angles.append(ang)
Ran = Ran +1
for i in circuit:
if type(i) == str:
continue
else:
i=tensor_fix(i)
for i in range(len(circuit)):
if type(circuit[i]) == str:
continue
elif circuit[i].full().shape == (n,n):
continue
else:
place=randint(1,qubits)
before=qubits-place
after=qubits-before-1
temp=circuit[i]
temp=qt.Qobj(temp)
if place == 1:
circuit[i]=qt.tensor(temp,id2)
else:
while before > 0:
if circuit[i].full().shape == (n,n):
break
temp=qt.tensor(id2,temp)
temp=tensor_fix(temp)
circuit[i]=temp
before=before-1
while after > 0:
if circuit[i].full().shape == (n,n):
break
temp=qt.tensor(temp,id2)
temp=tensor_fix(temp)
circuit[i]=temp
after=after-1
composition = ["Hadamards:",Had,"CNOT:",CNOT,"Random Unitary:",Ran]
return (circuit,angles,controls,composition)
def hadamard(bits):
return qutip.Qobj(qutip.hadamard_transform(bits).data)
# simulator.py: Defines a class that implements a multi-qubit simulator.
##
# Copyright (c) Sarah Kaiser and Chris Granade.
# Code sample from the book "Learn Quantum Computing with Python and Q#" by
# Sarah Kaiser and Chris Granade, published by Manning Publications Co.
# Book ISBN 9781617296130.
# Code licensed under the MIT License.
##
from interface import QuantumDevice, Qubit
import qutip as qt
import numpy as np
from typing import List
KET_0 = qt.basis(2, 0)
H = qt.hadamard_transform()
# tag::qubit_and_sq_operations[]
class SimulatedQubit(Qubit):
qubit_id: int
parent: "Simulator"
def __init__(self, parent_simulator: "Simulator", id: int): # <1>
self.qubit_id = id
self.parent = parent_simulator
def h(self) -> None:
self.parent._apply(H, [self.qubit_id]) # <2>
def logical_H(self):
S = self.encoder(kraus=True)
return S * qt.hadamard_transform() * S.dag()
def h(self):
self.parent._apply(qt.hadamard_transform(), [self.id])
import qutip
import itertools as it
## Shortcuts of some main qutip objects
zero = qt.qubits.qubit_states(1, [0])
one = qt.qubits.qubit_states(1, [1])
I, X, Y, Z = qt.identity([2]), qt.sigmax(), qt.sigmay(), qt.sigmaz()
Rx, Ry, Rz = qt.rx, qt.ry, qt.rz
op_pauli_1 = [X, Y, Z, I]
s_zero_1, s_one_1 = basis(2, 0), basis(2, 1)
s_plus_1, s_minus_1 = 1 / np.sqrt(2) * (s_zero_1 + s_one_1), 1 / np.sqrt(2) * (
s_zero_1 - s_one_1)
#two qubits
CN = cnot()
HDM = hadamard_transform()
# =========================================================================== #
# Define the functions needed
# =========================================================================== #
# GHZ related functions
def get_ghz(nb_qubits, angle=0):
""" Generate a GHZ state of the form |00..00> + exp(i * angle) |11..11> """
a = tensor([zero for _ in range(nb_qubits)])
b = tensor([one for _ in range(nb_qubits)])
return 1 / np.sqrt(2) * (a + np.exp(1.0j * angle) * b)
def get_ghz_offdiag(nb_qubits):
""" generate the Hermitian operator |0...0><1...1| + |1...1><0...0|"""
