def plot_basis_state_populations_3d(e_qs: EvolvingQubitSystem):
if e_qs.solve_result is None:
e_qs.solve()
states = get_states(e_qs.N)
times = []
heights = []
xs = []
for i, _solve_result_state in enumerate(e_qs.solve_result.states):
plt.ylim(0, 1)
plt.grid(axis='y')
solve_result_state_populations = np.abs(_solve_result_state.data.toarray().flatten()) ** 2
for _x, state in enumerate(states):
state_product_basis_index = get_product_basis_states_index(state)
basis_state_population = solve_result_state_populations[state_product_basis_index]
times.append(e_qs.solve_result.times[i])
xs.append(_x)
heights.append(basis_state_population)
fig = plt.figure(figsize=(15, 8))
ax = fig.add_subplot(111, projection="3d")
dt = e_qs.solve_result.times[1] - e_qs.solve_result.times[0]
ax.bar3d(xs, times, z=0, dx=0.8, dy=dt, dz=heights)
labels = [get_label_from_state(state) for state in states]
x = np.arange(len(labels))
plt.xticks(x, labels)
ax.yaxis.set_major_formatter(ticker.EngFormatter('s'))
plt.ylabel('Time')
plt.show()
def get_normalised_hamiltonian(N: int, norm_V: float):
norm_e_qs = EvolvingQubitSystem(
N=N, V=norm_V, geometry=RegularLattice1D(),
Omega=None, Delta=None,
t_list=None,
ghz_state=None
)
norm_hamiltonian = norm_e_qs.get_hamiltonian()
norm_H_d = norm_hamiltonian[0] # "drift": time-independent part
norm_H_c = [norm_hamiltonian[1][0], norm_hamiltonian[2][0]] # "control": time-dependent parts
return norm_H_d, norm_H_c, norm_e_qs.psi_0
def solve_and_print_stats(e_qs: EvolvingQubitSystem):
import time
start_time = time.time()
e_qs.solve()
print(f"Solved in {time.time() - start_time:.2f}s")
fidelity_with_ghz = e_qs.get_fidelity_with("ghz")
fidelity_with_ghz_asymmetric = e_qs.get_fidelity_with("ghz_antisymmetric")
print(f"fidelity with GHZ: {fidelity_with_ghz:.4f} (with antisymmetric: {fidelity_with_ghz_asymmetric:.4f})")
fidelity_with_ground = e_qs.get_fidelity_with("ground")
fidelity_with_excited = e_qs.get_fidelity_with("excited")
superposition_probability = fidelity_with_ground + fidelity_with_excited
print(
f"superposition probability: {superposition_probability:.4f} (g: {fidelity_with_ground:.4f}, e: {fidelity_with_excited:.4f})")
e_qs.plot(with_antisymmetric_ghz=True)
def plot_basis_state_populations_2d(e_qs: EvolvingQubitSystem, log=False, log_limit=1e-6):
if e_qs.solve_result is None:
e_qs.solve()
quartile_index = int(len(e_qs.t_list) / 4)
indices = [0, quartile_index, quartile_index * 2, quartile_index * 3, -1]
states = get_states(e_qs.N)
labels = [get_label_from_state(state) for state in states]
x = np.arange(len(labels))
fig, axs = plt.subplots(len(indices) , 1, sharex='all', figsize=(10, 8))
for _i, i in enumerate(indices):
ax = axs[_i]
if not log:
ax.set_ylim(0, 1)
else:
ax.set_ylim(log_limit, 1)
ax.set_yscale('log', basey=10)
ax.grid(axis='y')
ax.set_ylabel(f"{e_qs.solve_result.times[i]:.2e}s")
basis_state_populations = []
_solve_result_state = e_qs.solve_result.states[i]
solve_result_state_populations = np.abs(_solve_result_state.data.toarray().flatten()) ** 2
for state in states:
state_product_basis_index = get_product_basis_states_index(state)
basis_state_population = solve_result_state_populations[state_product_basis_index]
basis_state_populations.append(basis_state_population)
if log:
basis_state_population += log_limit
ax.bar(x=x, height=basis_state_populations)
plt.xticks(x, labels)
plt.tight_layout()
plt.show()
def solve_and_print_stats(e_qs: EvolvingQubitSystem):
e_qs.solve()
fidelity_with_ghz = e_qs.get_fidelity_with("ghz")
fidelity_with_ghz_asymmetric = e_qs.get_fidelity_with("ghz_antisymmetric")
print(
f"fidelity with GHZ: {fidelity_with_ghz:.4f} (with antisymmetric: {fidelity_with_ghz_asymmetric:.4f})"
)
fidelity_with_ground = e_qs.get_fidelity_with("ground")
fidelity_with_excited = e_qs.get_fidelity_with("excited")
superposition_probability = fidelity_with_ground + fidelity_with_excited
print(
f"superposition probability: {superposition_probability:.4f} (g: {fidelity_with_ground:.4f}, e: {fidelity_with_excited:.4f})"
)
e_qs.plot(with_antisymmetric_ghz=True,
savefig_name="evolving_fidelities.png",
show=True)
def _create_evolving_qubit_system(self):
t_list = self.evolving_qubit_system_kwargs['t_list']
_Omegas = np.array(self.recorded_steps['Omega'])
Omega = get_hamiltonian_coeff_linear_interpolation(t_list, self.recorded_steps['Omega'])
_Deltas = np.array(self.recorded_steps['Delta'])
Delta = get_hamiltonian_coeff_linear_interpolation(t_list, _Deltas)
# print("o:", _Omegas)
# print("d:", _Deltas)
evolving_qubit_system = EvolvingQubitSystem(
**self.evolving_qubit_system_kwargs,
Omega=Omega,
Delta=Delta
)
return evolving_qubit_system
def plot_optimresult(result: OptimResult, N: int, t: float, C6: float, characteristic_V: float, geometry: BaseGeometry,
ghz_state: BaseGHZState = None):
if ghz_state is None:
ghz_state = StandardGHZState(N)
final_Omega = np.hstack((result.final_amps[:, 0], result.final_amps[-1, 0]))
final_Delta = np.hstack((result.final_amps[:, 1], result.final_amps[-1, 1]))
time = result.time / characteristic_V
final_Omega *= characteristic_V
final_Delta *= characteristic_V
e_qs = EvolvingQubitSystem(
N=N, V=C6, geometry=geometry,
Omega=get_hamiltonian_coeff_interpolation(time, final_Omega, "previous"),
Delta=get_hamiltonian_coeff_interpolation(time, final_Delta, "previous"),
t_list=np.linspace(0, t, 300),
ghz_state=ghz_state
)
solve_and_print_stats(e_qs)
def solve_and_print_stats(e_qs: EvolvingQubitSystem, **kwargs):
import time
start_time = time.time()
e_qs.solve()
print(f"Solved in {time.time() - start_time:.2f}s")
fidelity_with_ghz = e_qs.get_fidelity_with("ghz")
fidelity_with_ghz_asymmetric = e_qs.get_fidelity_with("ghz_antisymmetric")
print(
f"fidelity with GHZ: {fidelity_with_ghz:.4f} (with antisymmetric: {fidelity_with_ghz_asymmetric:.4f})"
)
fidelity_with_ground = e_qs.get_fidelity_with("ground")
fidelity_with_excited = e_qs.get_fidelity_with("excited")
superposition_probability = fidelity_with_ground + fidelity_with_excited
print(
f"superposition probability: {superposition_probability:.4f} (g: {fidelity_with_ground:.4f}, e: {fidelity_with_excited:.4f})"
)
e_qs.plot(with_antisymmetric_ghz=True,
**kwargs,
fig_kwargs={'figsize': (6, 4)},
plot_titles=False,
plot_others_as_sum=True)
def plot_optimresult(result: OptimResult, N: int, geometry: BaseGeometry,
t: float, unnormalise_V: float, **kwargs):
time = result.time
final_Omega = np.hstack(
(result.final_amps[:, 0], result.final_amps[-1, 0]))
final_Delta = np.hstack(
(result.final_amps[:, 1], result.final_amps[-1, 1]))
t /= unnormalise_V
time = result.time / unnormalise_V
final_Omega *= unnormalise_V
final_Delta *= unnormalise_V
e_qs = EvolvingQubitSystem(
N=N,
V=C6,
geometry=geometry,
Omega=get_hamiltonian_coeff_interpolation(time, final_Omega,
"previous"),
Delta=get_hamiltonian_coeff_interpolation(time, final_Delta,
"previous"),
t_list=np.linspace(0, t, 300),
ghz_state=StandardGHZState(N))
solve_and_print_stats(e_qs, **kwargs)
iter_stop=40,
continue_from=Result.load(OPT_RESULT_DUMP, objectives=objectives) if CONTINUE_FROM else None
)
dump_file_name = OPT_RESULT_DUMP if not CONTINUE_FROM else OPT_RESULT_DUMP + "_1"
opt_result.dump(dump_file_name)
print(opt_result)
if SHOW_PLOTS:
plot_pulse(opt_result.optimized_controls[0], norm_t_list, "Optimised $\Omega$")
plot_pulse(opt_result.optimized_controls[1], norm_t_list, "Optimised $\Delta$")
opt_dynamics = opt_result.optimized_objectives[0].mesolve(
norm_t_list, e_ops=[proj_G, proj_GHZ])
plot_population(opt_dynamics)
final_Omega = opt_result.optimized_controls[0] * characteristic_V
final_Delta = opt_result.optimized_controls[1] * characteristic_V
t_list = norm_t_list / characteristic_V
e_qs = EvolvingQubitSystem(
N=N, V=C6, geometry=RegularLattice1D(LATTICE_SPACING),
Omega=get_hamiltonian_coeff_interpolation(t_list, final_Omega, "cubic"),
Delta=get_hamiltonian_coeff_interpolation(t_list, final_Delta, "cubic"),
t_list=np.linspace(0, t, 300),
ghz_state=StandardGHZState(N)
)
solve_and_print_stats(e_qs)
plt.show()
def rescale_evolving_qubit_system():
t = 1.1e-6
N = 4
e_qs = EvolvingQubitSystem(
N=N,
V=paper_data.V,
geometry=RegularLattice1D(),
Omega=paper_data.get_hamiltonian_coeff_fn(paper_data.Omega, N),
Delta=paper_data.get_hamiltonian_coeff_fn(paper_data.Delta, N),
t_list=np.linspace(0, t, 100),
ghz_state=AlternatingGHZState(N))
e_qs.solve()
# e_qs.plot()
print(e_qs.get_fidelity_with("ghz"))
max_Omega = 50e6
e_qs = EvolvingQubitSystem(
N=N,
V=paper_data.V / max_Omega,
geometry=RegularLattice1D(),
Omega=paper_data.get_hamiltonian_coeff_fn(
{
k: {_k * max_Omega: _v / max_Omega
for _k, _v in v.items()}
for k, v in paper_data.Omega.items()
}, N),
Delta=paper_data.get_hamiltonian_coeff_fn(
{
k: {_k * max_Omega: _v / max_Omega
for _k, _v in v.items()}
for k, v in paper_data.Delta.items()
}, N),
t_list=np.linspace(0, t * max_Omega, 100),
ghz_state=AlternatingGHZState(N))
e_qs.solve()
e_qs.plot()
print(e_qs.get_fidelity_with("ghz"))
def generate_plots_2():
"""
Generates plots for evolving systems for different optimisation methods
"""
def solve_and_print_stats(e_qs: EvolvingQubitSystem, **kwargs):
import time
start_time = time.time()
e_qs.solve()
print(f"Solved in {time.time() - start_time:.2f}s")
fidelity_with_ghz = e_qs.get_fidelity_with("ghz")
fidelity_with_ghz_asymmetric = e_qs.get_fidelity_with(
"ghz_antisymmetric")
print(
f"fidelity with GHZ: {fidelity_with_ghz:.4f} (with antisymmetric: {fidelity_with_ghz_asymmetric:.4f})"
)
fidelity_with_ground = e_qs.get_fidelity_with("ground")
fidelity_with_excited = e_qs.get_fidelity_with("excited")
superposition_probability = fidelity_with_ground + fidelity_with_excited
print(
f"superposition probability: {superposition_probability:.4f} (g: {fidelity_with_ground:.4f}, e: {fidelity_with_excited:.4f})"
)
e_qs.plot(with_antisymmetric_ghz=True,
**kwargs,
fig_kwargs={'figsize': (6, 4)},
plot_titles=False,
plot_others_as_sum=True)
norm_V = C6 / (LATTICE_SPACING**6) / characteristic_V
norm_t = t * characteristic_V
def get_normalised_hamiltonian(N: int):
norm_e_qs = EvolvingQubitSystem(N=N,
V=norm_V,
geometry=RegularLattice1D(),
Omega=None,
Delta=None,
t_list=None,
ghz_state=None)
norm_hamiltonian = norm_e_qs.get_hamiltonian()
norm_H_d = norm_hamiltonian[0] # "drift": time-independent part
norm_H_c = [norm_hamiltonian[1][0],
norm_hamiltonian[2][0]] # "control": time-dependent parts
return norm_H_d, norm_H_c, norm_e_qs.psi_0
def get_optimised_controls(N: int, n_ts: int, alg: str) -> OptimResult:
norm_H_d, norm_H_c, psi_0 = get_normalised_hamiltonian(N)
target_state = StandardGHZState(N).get_state_tensor()
norm_scaling = 0.5 / characteristic_V
optim_shared_kwargs = dict(
amp_lbound=-10,
amp_ubound=10,
# amp_lbound=0, amp_ubound=2e9 * norm_scaling,
gen_stats=True,
max_wall_time=300,
max_iter=10000,
fid_err_targ=1e-10,
log_level=qutip.logging_utils.WARN,
)
if alg == "GRAPE":
norm_result = cpo.optimize_pulse_unitary(
norm_H_d,
norm_H_c,
psi_0,
target_state,
n_ts,
norm_t,
# pulse_scaling=1e9 * norm_scaling, pulse_offset=1e9 * norm_scaling,
# pulse_scaling=0.5,
# optim_method="FMIN_BFGS",
init_pulse_type="RND",
**optim_shared_kwargs)
else:
norm_result = cpo.opt_pulse_crab_unitary(
norm_H_d,
norm_H_c,
psi_0,
target_state,
n_ts,
norm_t,
num_coeffs=10,
guess_pulse_scaling=0.1,
# guess_pulse_scaling=1e9 * norm_scaling, guess_pulse_offset=1e9 * norm_scaling,
guess_pulse_type="RND",
**optim_shared_kwargs)
return norm_result
def report_stats(result: OptimResult, N: int):
result.stats.report()
target_state = StandardGHZState(N).get_state_tensor()
final_fidelity = qutip.fidelity(target_state, result.evo_full_final)**2
print(f"final_fidelity: {final_fidelity:.5f}")
print(f"Final gradient normal {result.grad_norm_final:.3e}")
print(f"Terminated due to {result.termination_reason}")
def plot_optimresult(result: OptimResult, N: int, geometry: BaseGeometry,
t: float, unnormalise_V: float, **kwargs):
time = result.time
final_Omega = np.hstack(
(result.final_amps[:, 0], result.final_amps[-1, 0]))
final_Delta = np.hstack(
(result.final_amps[:, 1], result.final_amps[-1, 1]))
t /= unnormalise_V
time = result.time / unnormalise_V
final_Omega *= unnormalise_V
final_Delta *= unnormalise_V
e_qs = EvolvingQubitSystem(
N=N,
V=C6,
geometry=geometry,
Omega=get_hamiltonian_coeff_interpolation(time, final_Omega,
"previous"),
Delta=get_hamiltonian_coeff_interpolation(time, final_Delta,
"previous"),
t_list=np.linspace(0, t, 300),
ghz_state=StandardGHZState(N))
solve_and_print_stats(e_qs, **kwargs)
# N = 4
# Manual optimisation
# e_qs = EvolvingQubitSystem(
# N=N, V=C6, geometry=RegularLattice1D(spacing=LATTICE_SPACING),
# Omega=get_hamiltonian_coeff_linear_interpolation([0, t / 2, t], [0, 1.4148e9, 0]),
# Delta=get_hamiltonian_coeff_linear_interpolation([0, t], [1.5e9, 1e9]),
# t_list=np.linspace(0, t, 300),
# ghz_state=StandardGHZState(N)
# )
# solve_and_print_stats(e_qs, savefig_name=f'paper_plots_2_n_{N}_manual.png')
# RL
# with open("reinforcement_learning/results/20190814_035606.pkl", "rb") as f:
# data = pickle.load(f)
# t_list = data['evolving_qubit_system_kwargs']['t_list']
# solve_t_list = np.linspace(t_list[0], t_list[-1], 300)
#
# data['evolving_qubit_system_kwargs'].pop('t_list')
# e_qs = EvolvingQubitSystem(
# **data['evolving_qubit_system_kwargs'],
# Omega=get_hamiltonian_coeff_linear_interpolation(t_list, data['protocol'].Omega),
# Delta=get_hamiltonian_coeff_linear_interpolation(t_list, data['protocol'].Delta),
# t_list=solve_t_list,
# )
# solve_and_print_stats(e_qs, savefig_name=f'paper_plots_2_n_{N}_RL.png')
# GRAPE
# optim_result = get_optimised_controls(N, n_ts=15, alg="GRAPE")
# report_stats(optim_result, N)
# plot_optimresult(optim_result, N, norm_t, characteristic_V, savefig_name=f'paper_plots_2_n_{N}_GRAPE.png')
# CRAB
# optim_result = get_optimised_controls(N, n_ts=15, alg="CRAB")
# report_stats(optim_result, N)
# plot_optimresult(optim_result, N, norm_t, characteristic_V, savefig_name=f'paper_plots_2_n_{N}_CRAB.png')
N = 8 # 1d
# Manual optimisation
# e_qs = EvolvingQubitSystem(
# N=N, V=C6, geometry=RegularLattice1D(spacing=LATTICE_SPACING),
# Omega=get_hamiltonian_coeff_linear_interpolation([0, t / 6, t * 5 / 6, t], [0, 379e6, 379e6, 0]),
# Delta=get_hamiltonian_coeff_linear_interpolation([0, t], [1.3e9, 1.21e9]),
# t_list=np.linspace(0, t, 300),
# ghz_state=StandardGHZState(N)
# )
# solve_and_print_stats(e_qs, savefig_name=f'paper_plots_2_n_{N}_manual.png')
# RL
# with open("reinforcement_learning/results/20190814_211310.pkl", "rb") as f:
# data = pickle.load(f)
# t_list = data['evolving_qubit_system_kwargs']['t_list']
# solve_t_list = np.linspace(t_list[0], t_list[-1], 300)
#
# data['evolving_qubit_system_kwargs'].pop('t_list')
# e_qs = EvolvingQubitSystem(
# **data['evolving_qubit_system_kwargs'],
# Omega=get_hamiltonian_coeff_linear_interpolation(t_list, data['protocol'].Omega),
# Delta=get_hamiltonian_coeff_linear_interpolation(t_list, data['protocol'].Delta),
# t_list=solve_t_list,
# )
# solve_and_print_stats(e_qs, savefig_name=f'paper_plots_2_n_{N}_RL.png')
# GRAPE
# with open("optim_results/optim_result_464779.pbs.pkl", "rb") as f:
# optim_result = pickle.load(f)
# report_stats(optim_result, N)
# plot_optimresult(optim_result, N, RegularLattice1D(LATTICE_SPACING), norm_t, characteristic_V,
# savefig_name=f'paper_plots_2_n_{N}_GRAPE.png')
# CRAB
# with open("optim_results/optim_result_464783.pbs.pkl", "rb") as f:
# optim_result = pickle.load(f)
# report_stats(optim_result, N)
# plot_optimresult(optim_result, N, RegularLattice1D(LATTICE_SPACING), norm_t, characteristic_V,
# savefig_name=f'paper_plots_2_n_{N}_CRAB.png')
# N = 8 # 2d
# Manual optimisation
# e_qs = EvolvingQubitSystem(
# N=N, V=C6, geometry=RegularLattice2D((2, 4), spacing=LATTICE_SPACING),
# Omega=get_hamiltonian_coeff_linear_interpolation([0, t / 5, t * 4 / 5, t], [0, 700e6, 700e6, 0]),
# Delta=get_hamiltonian_coeff_linear_interpolation([0, t], [2e9, 1.83e9]),
# t_list=np.linspace(0, t, 300),
# ghz_state=StandardGHZState(N)
# )
# solve_and_print_stats(e_qs, savefig_name=f'paper_plots_2_n_{N}_manual_2d.png')
# RL
# with open("reinforcement_learning/results/20190814_211949.pkl", "rb") as f:
# data = pickle.load(f)
# t_list = data['evolving_qubit_system_kwargs']['t_list']
# solve_t_list = np.linspace(t_list[0], t_list[-1], 300)
#
# data['evolving_qubit_system_kwargs'].pop('t_list')
# e_qs = EvolvingQubitSystem(
# **data['evolving_qubit_system_kwargs'],
# Omega=get_hamiltonian_coeff_linear_interpolation(t_list, data['protocol'].Omega),
# Delta=get_hamiltonian_coeff_linear_interpolation(t_list, data['protocol'].Delta),
# t_list=solve_t_list,
# )
# solve_and_print_stats(e_qs, savefig_name=f'paper_plots_2_n_{N}_RL_2d.png')
# GRAPE
# with open("optim_results/optim_result_464780.pbs.pkl", "rb") as f:
# optim_result = pickle.load(f)
# report_stats(optim_result, N)
# plot_optimresult(optim_result, N, RegularLattice2D((2, 4), LATTICE_SPACING), norm_t, characteristic_V,
# savefig_name=f'paper_plots_2_n_{N}_GRAPE_2d.png')
# CRAB
# with open("optim_results/optim_result_464784.pbs.pkl", "rb") as f:
# optim_result = pickle.load(f)
# report_stats(optim_result, N)
# plot_optimresult(optim_result, N, RegularLattice2D((2, 4), LATTICE_SPACING), norm_t, characteristic_V,
# savefig_name=f'paper_plots_2_n_{N}_CRAB_2d.png')
N = 8 # 3d
# Manual optimisation
# e_qs = EvolvingQubitSystem(
# N=N, V=C6, geometry=RegularLattice3D((2, 2, 2), spacing=LATTICE_SPACING),
# Omega=get_hamiltonian_coeff_linear_interpolation([0, t / 2, t], [0, 1175e6, 0]),
# Delta=get_hamiltonian_coeff_linear_interpolation([0, t], [2.5e9, 2.2e9]),
# t_list=np.linspace(0, t, 300),
# ghz_state=StandardGHZState(N)
# )
# solve_and_print_stats(e_qs, savefig_name=f'paper_plots_2_n_{N}_manual_3d.png')
# RL
with open("reinforcement_learning/results/20190814_215943.pkl", "rb") as f:
data = pickle.load(f)
t_list = data['evolving_qubit_system_kwargs']['t_list']
solve_t_list = np.linspace(t_list[0], t_list[-1], 300)
data['evolving_qubit_system_kwargs'].pop('t_list')
e_qs = EvolvingQubitSystem(
**data['evolving_qubit_system_kwargs'],
Omega=get_hamiltonian_coeff_linear_interpolation(
t_list, data['protocol'].Omega),
Delta=get_hamiltonian_coeff_linear_interpolation(
t_list, data['protocol'].Delta),
t_list=solve_t_list,
)
solve_and_print_stats(e_qs, savefig_name=f'paper_plots_2_n_{N}_RL_3d.png')
# N=N, V=C6, geometry=RegularLattice1D(spacing=LATTICE_SPACING),
# Omega=get_hamiltonian_coeff_linear_interpolation([0, t / 2, t], [0, 751.23e6, 0]),
# Delta=get_hamiltonian_coeff_linear_interpolation([0, t], [1.3e9, 1.14e9]),
# t_list=np.linspace(0, t, 300),
# ghz_state=StandardGHZState(N)
# )
# solve_and_print_stats(e_qs)
# plot_basis_state_populations_2d(e_qs)
N = 8
t = 0.5e-6
e_qs = EvolvingQubitSystem(
N=N, V=C6, geometry=RegularLattice1D(spacing=LATTICE_SPACING),
Omega=get_hamiltonian_coeff_linear_interpolation([0, t / 6, t * 5 / 6, t], [0, 480e6, 490e6, 0]),
Delta=get_hamiltonian_coeff_linear_interpolation([0, t], [1.5e9, 1.2e9]),
t_list=np.linspace(0, t, 100),
ghz_state=StandardGHZState(N)
)
solve_and_print_stats(e_qs)
plot_basis_state_populations_2d(e_qs, log=True)
# N = 8, t = 2e-6
# N = 8
#
# with open("reinforcement_learning/results/20190814_215943.pkl", "rb") as f:
# data = pickle.load(f)
#
# t_list = data['evolving_qubit_system_kwargs']['t_list']
# solve_t_list = np.linspace(t_list[0], t_list[-1], 100)