def set_up_ops(self, N):
"""
Generate the Hamiltonians for the spinchain model and save them in the
attribute `ctrls`.
Parameters
----------
N: int
The number of qubits in the system.
"""
# single qubit terms
self.a = tensor(destroy(self.num_levels))
self.pulses.append(
Pulse(self.a.dag() * self.a, [0], spline_kind=self.spline_kind))
for m in range(N):
self.pulses.append(
Pulse(sigmax(), [m + 1], spline_kind=self.spline_kind))
for m in range(N):
self.pulses.append(
Pulse(sigmaz(), [m + 1], spline_kind=self.spline_kind))
# interaction terms
a_full = tensor([destroy(self.num_levels)] +
[identity(2) for n in range(N)])
for n in range(N):
sm = tensor(
[identity(self.num_levels)] +
[destroy(2) if m == n else identity(2) for m in range(N)])
self.pulses.append(
Pulse(a_full.dag() * sm + a_full * sm.dag(),
list(range(N + 1)),
spline_kind=self.spline_kind))
self.psi_proj = tensor([basis(self.num_levels, 0)] +
[identity(2) for n in range(N)])
def set_up_ops(self, N):
"""
Generate the Hamiltonians for the circuitqed model and save them in the
attribute `ctrls`.
Parameters
----------
N: int
The number of qubits in the system.
"""
# single qubit terms
for m in range(N):
self.pulses.append(
Pulse(sigmax(), [m + 1], spline_kind=self.spline_kind))
for m in range(N):
self.pulses.append(
Pulse(sigmaz(), [m + 1], spline_kind=self.spline_kind))
# coupling terms
a = tensor([destroy(self.num_levels)] +
[identity(2) for n in range(N)])
for n in range(N):
sm = tensor(
[identity(self.num_levels)] +
[destroy(2) if m == n else identity(2) for m in range(N)])
self.pulses.append(
Pulse(a.dag() * sm + a * sm.dag(),
list(range(N + 1)),
spline_kind=self.spline_kind))
def set_up_ops(self, num_qubits):
"""
Generate the Hamiltonians for the spinchain model and save them in the
attribute `ctrls`.
Parameters
----------
num_qubits: int
The number of qubits in the system.
"""
# single qubit terms
for m in range(num_qubits):
self.add_control(sigmax(), [m + 1], label="sx" + str(m))
for m in range(num_qubits):
self.add_control(sigmaz(), [m + 1], label="sz" + str(m))
# coupling terms
a = tensor([destroy(self.num_levels)] +
[identity(2) for n in range(num_qubits)])
for n in range(num_qubits):
sm = tensor([identity(self.num_levels)] + [
destroy(2) if m == n else identity(2)
for m in range(num_qubits)
])
self.add_control(a.dag() * sm + a * sm.dag(),
list(range(num_qubits + 1)),
label="g" + str(n))
def set_up_ops(self, N):
"""
Generate the Hamiltonians for the spinchain model and save them in the
attribute `ctrls`.
Parameters
----------
N: int
The number of qubits in the system.
"""
# single qubit terms
self.a = tensor([destroy(self.num_levels)] +
[identity(2) for n in range(N)])
self.ctrls.append(self.a.dag() * self.a)
self.ctrls += [
tensor([identity(self.num_levels)] +
[sigmax() if m == n else identity(2) for n in range(N)])
for m in range(N)
]
self.ctrls += [
tensor([identity(self.num_levels)] +
[sigmaz() if m == n else identity(2) for n in range(N)])
for m in range(N)
]
# interaction terms
for n in range(N):
sm = tensor(
[identity(self.num_levels)] +
[destroy(2) if m == n else identity(2) for m in range(N)])
self.ctrls.append(self.a.dag() * sm + self.a * sm.dag())
self.psi_proj = tensor([basis(self.num_levels, 0)] +
[identity(2) for n in range(N)])
def eliminate_auxillary_modes(self, U):
"""
Eliminate the auxillary modes like the cavity modes in cqed.
"""
psi_proj = tensor([basis(self.num_levels, 0)] +
[identity(2) for n in range(self.N)])
return psi_proj.dag() * U * psi_proj
def set_up_ops(self, N):
"""
Generate the Hamiltonians for the spinchain model and save them in the
attribute `ctrls`.
Parameters
----------
N: int
The number of qubits in the system.
"""
self.pulse_dict = {}
index = 0
# single qubit terms
for m in range(N):
self.pulses.append(
Pulse(sigmax(), [m + 1], spline_kind=self.spline_kind))
self.pulse_dict["sx" + str(m)] = index
index += 1
for m in range(N):
self.pulses.append(
Pulse(sigmaz(), [m + 1], spline_kind=self.spline_kind))
self.pulse_dict["sz" + str(m)] = index
index += 1
# coupling terms
a = tensor([destroy(self.num_levels)] +
[identity(2) for n in range(N)])
for n in range(N):
sm = tensor(
[identity(self.num_levels)] +
[destroy(2) if m == n else identity(2) for m in range(N)])
self.pulses.append(
Pulse(a.dag() * sm + a * sm.dag(),
list(range(N + 1)),
spline_kind=self.spline_kind))
self.pulse_dict["g" + str(n)] = index
index += 1
def frem_anneal(self, schedules, partition, HR_init_state):
"""
Performs a numeric FREM anneal on H using QuTip.
inputs:
---------
schedules - a numeric annealing schedules [reverse, forward]
partition - a parition of H in the form [HR, HF]
init_state - the starting state for the reverse anneal listed as string or list
e.g. '111' or [010]
outputs:
---------
probs - probability of each output state as a list ordered in canconically w.r.t. tensor product
"""
# retrieve useful quantities from input data
f_sch, r_sch = schedules
times = f_sch[0]
HR = DictRep(H=partition['HR'],
qpu='numerical',
vartype='ising',
encoding='logical')
HF = DictRep(H=partition['HF'],
qpu='numerical',
vartype='ising',
encoding='logical')
Rqubits = partition['Rqubits']
# prepare the initial state
statelist = []
fidx = 0
ridx = 0
for qubit in self.qubits:
# if part of HR, give assigned value by user
if qubit in Rqubits:
statelist.append(qts.ket(HR_init_state[ridx]))
ridx += 1
# otherwise, put in equal superposition (i.e. gs of x-basis)
else:
xstate = (qts.ket('0') - qts.ket('1')).unit()
statelist.append(xstate)
fidx += 1
init_state = qto.tensor(*statelist)
# Create the numeric Hamiltonian for HR
ABfuncs = time_interpolation(r_sch, self.processordata)
numericH = get_numeric_H(HR)
A = ABfuncs['A(t)']
B = ABfuncs['B(t)']
HX = numericH['HX']
HZ = numericH['HZ']
# Define list_H for QuTiP
listHR = [[HX, A], [HZ, B]]
# create the numeric Hamiltonian for HF
ABfuncs = time_interpolation(f_sch, self.processordata)
numericH = get_numeric_H(HF)
A = ABfuncs['A(t)']
B = ABfuncs['B(t)']
HX = numericH['HX']
HZ = numericH['HZ']
# "Analytic" or function H(t)
analHF = lambda t: A(t) * HX + B(t) * HZ
# Define list_H for QuTiP
listHF = [[HX, A], [HZ, B]]
# create the total Hamitlontian of HF + HR
list_totH = listHR + listHF
# run the numerical simulation and find probabilities of each state
frem_results = qt.sesolve(list_totH, init_state, times)
probs = np.array([
abs(frem_results.states[-1][i].flatten()[0])**2
for i in range(self.Hsize)
])
return probs