From ceaf2ab881ef17f6fce76ea4f5dfc6c92094ed5c Mon Sep 17 00:00:00 2001 From: Julian Seither Date: Thu, 8 May 2025 14:14:36 +0900 Subject: [PATCH 01/17] Added interactive test notebooks for closed systems --- tests/interactive/CRAB_gate_closed.md | 107 +++++++++ tests/interactive/CRAB_state_closed.md | 99 +++++++++ tests/interactive/GOAT_gate_closed.md | 265 ++++++++++++++++++++++ tests/interactive/GOAT_state_closed.md | 281 ++++++++++++++++++++++++ tests/interactive/GRAPE_gate_closed.md | 116 ++++++++++ tests/interactive/GRAPE_state_closed.md | 116 ++++++++++ tests/interactive/JOPT_gate_closed.md | 217 ++++++++++++++++++ tests/interactive/JOPT_state_closed.md | 277 +++++++++++++++++++++++ 8 files changed, 1478 insertions(+) create mode 100644 tests/interactive/CRAB_gate_closed.md create mode 100644 tests/interactive/CRAB_state_closed.md create mode 100644 tests/interactive/GOAT_gate_closed.md create mode 100644 tests/interactive/GOAT_state_closed.md create mode 100644 tests/interactive/GRAPE_gate_closed.md create mode 100644 tests/interactive/GRAPE_state_closed.md create mode 100644 tests/interactive/JOPT_gate_closed.md create mode 100644 tests/interactive/JOPT_state_closed.md diff --git a/tests/interactive/CRAB_gate_closed.md b/tests/interactive/CRAB_gate_closed.md new file mode 100644 index 0000000..26b1e4f --- /dev/null +++ b/tests/interactive/CRAB_gate_closed.md @@ -0,0 +1,107 @@ +--- +jupyter: + jupytext: + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.16.7 + kernelspec: + display_name: qutip-dev + language: python + name: python3 +--- + +# CRAB algorithm for a closed system + +```python +import matplotlib.pyplot as plt +import numpy as np +from jax import jit, numpy +from qutip import (about, Qobj, gates, qeye, sigmam, sigmax, sigmay, sigmaz, tensor) +import qutip as qt +from qutip_qoc import Objective, optimize_pulses +``` + +## Problem setup + +```python +hbar = 1 +omega = 0.1 # energy splitting +delta = 1.0 # tunneling +gamma = 0.1 # amplitude damping +sx, sy, sz = sigmax(), sigmay(), sigmaz() + +Hd = 1 / 2 * hbar * omega * sz +Hc = [sx, sy, sz] +H = [Hd, Hc[0], Hc[1], Hc[2]] + +initial = qeye(2) +target = Qobj(1 / np.sqrt(2) * np.array([[1, 1], [1, -1]])) + +times = np.linspace(0, 2*np.pi / 2, 100) +``` + +## CRAB algotihm + +```python +n_params = 3 # adjust in steps of 3 +alg_args = {"alg": "CRAB", "fid_err_targ": 0.001} + +res_crab = optimize_pulses( + objectives=Objective(initial, H, target), + control_parameters={ + "ctrl_x": { + "guess": [1 for _ in range(n_params)], + "bounds": [(-1, 1)] * n_params, + }, + "ctrl_y": { + "guess": [1 for _ in range(n_params)], + "bounds": [(-1, 1)] * n_params, + }, + "ctrl_z": { + "guess": [1 for _ in range(n_params)], + "bounds": [(-1, 1)] * n_params, + }, + }, + tlist=times, + algorithm_kwargs=alg_args, +) + +print('Infidelity: ', res_crab.infidelity) + +plt.plot(times, res_crab.optimized_controls[0], label='optimized pulse sx') +plt.plot(times, res_crab.optimized_controls[1], label='optimized pulse sy') +plt.plot(times, res_crab.optimized_controls[2], label='optimized pulse sz') +plt.title('CRAB pulse') +plt.xlabel('time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +```python +Hresult = [Hd, [Hc[0], res_crab.optimized_controls[0]], [Hc[1], res_crab.optimized_controls[1]], [Hc[2], res_crab.optimized_controls[2]]] +evolution = qt.sesolve(Hresult, initial, times) + + +plt.plot(times, [np.abs(state.overlap(target) / target.norm()) for state in evolution.states], '--', label="Fidelity") +plt.legend() +plt.title("GRAPE performance") +plt.show() +``` + +## Validation + +```python +assert res_crab.infidelity < 0.001 +assert np.abs(evolution.states[-1].overlap(target) / target.norm()) > 1-0.001 +``` + +```python +qt.about() +``` + +```python + +``` diff --git a/tests/interactive/CRAB_state_closed.md b/tests/interactive/CRAB_state_closed.md new file mode 100644 index 0000000..de5ddbb --- /dev/null +++ b/tests/interactive/CRAB_state_closed.md @@ -0,0 +1,99 @@ +--- +jupyter: + jupytext: + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.16.7 + kernelspec: + display_name: qutip-dev + language: python + name: python3 +--- + +# GRAPE algorithm for 2 level system + +```python +import matplotlib.pyplot as plt +import numpy as np +from qutip import (about, fidelity, Qobj, basis) +import qutip as qt +from qutip_qoc import Objective, optimize_pulses +``` + +## Problem setup + +```python +# Energy levels +E1, E2 = 1.0, 2.0 + +Hd = Qobj(np.diag([E1, E2])) +Hc = Qobj(np.array([ + [0, 1], + [1, 0] +])) +H = [Hd, Hc] + +initial_state = basis(2, 0) # |1> +target_state = basis(2, 1) # |2> + +times = np.linspace(0, 2*np.pi, 100) +``` + +## CRAB algorithm + +```python +n_params = 6 # adjust in steps of 3 +alg_args = {"alg": "CRAB", "fid_err_targ": 0.001, "fix_frequency": False} + +res_crab = optimize_pulses( + objectives=Objective(initial_state, H, target_state), + control_parameters={ + "ctrl_x": { + "guess": [1 for _ in range(n_params)], + "bounds": [(-1, 1)] * n_params, + }, + }, + tlist=times, + algorithm_kwargs=alg_args, +) + +print('Infidelity: ', res_crab.infidelity) + + +plt.plot(times, res_crab.optimized_controls[0], label='optimized pulse') +plt.title('CRAB pulse') +plt.xlabel('time') +plt.ylabel('Pulse amplitude') + +plt.legend() +plt.show() +``` + +```python +Hresult = [Hd, [Hc, res_crab.optimized_controls[0]]] +evolution = qt.sesolve(Hresult, initial_state, times) + +plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution.states], label="Overlap with target state") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution.states], '--', label="Fidelity") +plt.legend() +plt.title("CRAB performance") +plt.show() +``` + +## Validation + +```python +assert res_crab.infidelity < 0.001 +assert np.abs(evolution.states[-1].overlap(target_state)) > 1-0.001 +``` + +```python +qt.about() +``` + +```python + +``` diff --git a/tests/interactive/GOAT_gate_closed.md b/tests/interactive/GOAT_gate_closed.md new file mode 100644 index 0000000..a2b990c --- /dev/null +++ b/tests/interactive/GOAT_gate_closed.md @@ -0,0 +1,265 @@ +--- +jupyter: + jupytext: + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.16.7 + kernelspec: + display_name: qutip-dev + language: python + name: python3 +--- + +# GOAT algorithm for a closed system + +```python +import matplotlib.pyplot as plt +import numpy as np +from jax import jit, numpy +from qutip import (about, Qobj, gates, liouvillian, qeye, sigmam, sigmax, sigmay, sigmaz, tensor) +import qutip as qt +from qutip_qoc import Objective, optimize_pulses +``` + +## Problem setup + +```python +hbar = 1 +omega = 0.1 # energy splitting +delta = 1.0 # tunneling +gamma = 0.1 # amplitude damping +sx, sy, sz = sigmax(), sigmay(), sigmaz() + +Hd = 1 / 2 * hbar * omega * sz +Hc = [sx, sy, sz] +H = [Hd, Hc[0], Hc[1], Hc[2]] + +# objective for optimization +initial = qeye(2) +target = Qobj(1 / np.sqrt(2) * np.array([[1, 1], [1, -1]])) + +times = np.linspace(0, 2*np.pi, 100) +``` + +## Guess + +```python +guess = [1, 1] +guess_pulse = guess[0] * np.sin(guess[1] * times) + +Hresult_guess = [Hd] + [[hc, guess_pulse] for hc in Hc] +evolution_guess = qt.sesolve(Hresult_guess, initial, times) + +print('Infidelity: ', qt.fidelity(evolution_guess.states[-1], target)) + +plt.plot(times, [np.abs(state.overlap(initial) / initial.norm())**2 for state in evolution_guess.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target) / initial.norm())**2 for state in evolution_guess.states], label="Overlap with target state") +plt.legend() +plt.title("Guess performance") +plt.show() +``` + +## GOAT algorithm +### a) not optimized over time + +```python +def sin(t, c): + return c[0] * np.sin(c[1] * t) + + +# derivatives +def grad_sin(t, c, idx): + if idx == 0: # w.r.t. c0 + return np.sin(c[1] * t) + if idx == 1: # w.r.t. c1 + return c[0] * np.cos(c[1] * t) * t + if idx == 2: # w.r.t. time + return c[0] * np.cos(c[1] * t) * c[1] + +H = [Hd] + [[hc, sin, {"grad": grad_sin}] for hc in Hc] + +ctrl_parameters = { + id: {"guess": guess, "bounds": [(-1, 1), (0, 2 * np.pi)]} # c0 and c1 + for id in ['x', 'y', 'z'] +} +``` + +```python +# run the optimization +res_goat = optimize_pulses( + objectives=Objective(initial, H, target), + control_parameters=ctrl_parameters, + tlist=times, + algorithm_kwargs={ + "alg": "GOAT", + "fid_err_targ": 0.001, + }, +) + +print('Infidelity: ', res_goat.infidelity) + +plt.plot(times, res_goat.optimized_controls[0], label='optimized pulse sx') +plt.plot(times, res_goat.optimized_controls[1], label='optimized pulse sy') +plt.plot(times, res_goat.optimized_controls[2], label='optimized pulse sz') +plt.title('GOAT pulse') +plt.xlabel('time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +```python +Hresult = [Hd, [Hc[0], np.array(res_goat.optimized_controls[0])], [Hc[1], np.array(res_goat.optimized_controls[1])], + [Hc[2], np.array(res_goat.optimized_controls[2])]] +evolution = qt.sesolve(Hresult, initial, times) + +plt.plot(times, [np.abs(state.overlap(initial) / initial.norm())**2 for state in evolution.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target) / target.norm())**2 for state in evolution.states], label="Overlap with target state") +plt.title('GOAT performance') +plt.xlabel('time') +plt.legend() +plt.show() + +``` + +### b) optimized over time + +```python +# treats time as optimization variable +ctrl_parameters["__time__"] = { + "guess": times[len(times) // 2], + "bounds": [times[0], times[-1]], +} + +# run the optimization +res_goat_time = optimize_pulses( + objectives=Objective(initial, H, target), + control_parameters=ctrl_parameters, + tlist=times, + algorithm_kwargs={ + "alg": "GOAT", + "fid_err_targ": 0.001, + }, +) + +print('Infidelity: ', res_goat_time.infidelity) +print("time: ", times[-1]) +print('optimized time: ', res_goat_time.optimized_params[-1][0]) + +time_range = times < res_goat_time.optimized_params[-1] + +plt.plot(times, res_goat.optimized_controls[0], label='optimized pulse') +plt.plot(times[time_range], np.array(res_goat_time.optimized_controls[0])[time_range], label='optimized (over time) pulse') +plt.title('GOAT pulses') +plt.xlabel('time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +```python +Hresult = [Hd, [Hc[0], np.array(res_goat_time.optimized_controls[0])], [Hc[1], np.array(res_goat_time.optimized_controls[1])], + [Hc[2], np.array(res_goat_time.optimized_controls[2])]] +evolution_time = qt.sesolve(Hresult, initial, times) + +plt.plot(times, [np.abs(state.overlap(initial) / initial.norm())**2 for state in evolution_time.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target) / target.norm())**2 for state in evolution_time.states], label="Overlap with target state") +plt.xlim(0, res_goat_time.optimized_params[-1][0]) + +plt.title('GOAT (optimized over time) performance') +plt.xlabel('time') +plt.legend() +plt.show() +``` + +## Global optimization + +```python +res_goat_global = optimize_pulses( + objectives=Objective(initial, H, target), + control_parameters=ctrl_parameters, + tlist=times, + algorithm_kwargs={ + "alg": "GOAT", + "fid_err_targ": 0.001, + }, + optimizer_kwargs={ + "method": "basinhopping", + "max_iter": 100, + } +) + +print('Infidelity: ', res_goat_global.infidelity) +print('optimized time: ', res_goat_global.optimized_params[-1]) + +global_range = times < res_goat_global.optimized_params[-1] + +plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[0])[global_range], label='global optimized pulse sx') +plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[1])[global_range], label='global optimized pulse sy') +plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[2])[global_range], label='global optimized pulse sz') +plt.title('GOAT pulses (global)') +plt.xlabel('time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +```python +Hresult = [Hd, [Hc[0], np.array(res_goat_global.optimized_controls[0])], [Hc[1], np.array(res_goat_global.optimized_controls[1])], + [Hc[2], np.array(res_goat_global.optimized_controls[2])]] +evolution_global = qt.sesolve(Hresult, initial, times) + +plt.plot(times, [np.abs(state.overlap(initial) / initial.norm()) for state in evolution_global.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target) / target.norm()) for state in evolution_global.states], label="Overlap with target state") +plt.xlim(0, res_goat_global.optimized_params[-1][0]) + +plt.title('GOAT (global) performance') +plt.xlabel('time') +plt.legend() +plt.show() +``` + +## Comparison + +```python +fig, axes = plt.subplots(1, 3, figsize=(18, 4)) # 1 row, 3 columns + +titles = ["GOAT s_x pulses", "GOAT s_y pulses", "GOAT s_z pulses"] + +for i in range(3): + ax = axes[i] + ax.plot(times, sin(times, guess), label='initial guess') + ax.plot(times, res_goat.optimized_controls[i], color='orange', label='optimized pulse') + ax.plot(times[time_range], np.array(res_goat_time.optimized_controls[i])[time_range], label='optimized (over time) pulse') + ax.plot(times[global_range], np.array(res_goat_global.optimized_controls[i])[global_range], label='global optimized pulse') + ax.set_title(titles[i]) + ax.set_xlabel('time') + ax.set_ylabel('Pulse amplitude') + ax.legend() + +plt.tight_layout() +plt.show() + +``` + +## Validation + +```python +assert res_goat.infidelity < 0.001 +assert np.abs(evolution.states[-1].overlap(target)) > 1-0.001 +assert res_goat_time.infidelity < 0.001 +assert max([np.abs(state.overlap(target)) for state in evolution_time.states]) > 1-0.001 +assert res_goat_global.infidelity < 0.001 +assert max([np.abs(state.overlap(target)) for state in evolution_global.states]) > 1-0.001 + +``` + +```python +qt.about() +``` + +```python + +``` diff --git a/tests/interactive/GOAT_state_closed.md b/tests/interactive/GOAT_state_closed.md new file mode 100644 index 0000000..67da337 --- /dev/null +++ b/tests/interactive/GOAT_state_closed.md @@ -0,0 +1,281 @@ +--- +jupyter: + jupytext: + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.16.7 + kernelspec: + display_name: qutip-dev + language: python + name: python3 +--- + +# GOAT algorithm for a 2 level system + +```python +import matplotlib.pyplot as plt +import numpy as np +from qutip import (about, fidelity, Qobj, basis) +import qutip as qt +from qutip_qoc import Objective, optimize_pulses +``` + +## Problem setup + +```python +# Energy levels +E1, E2 = 1.0, 1.0 + +Hd = Qobj(np.diag([E1, E2])) +Hc = Qobj(np.array([ + [0, 1], + [1, 0] +])) +H = [Hd, Hc] + +initial_state = basis(2, 0) # |1> +target_state = basis(2, 1) # |2> + +times = np.linspace(0, 2 * np.pi, 100) +``` + +## Guess + +```python +goat_guess = [1, 0.5] +guess_pulse = goat_guess[0] * np.sin(goat_guess[1] * times) + +Hresult_guess = [Hd, [Hc, guess_pulse]] +evolution_guess = qt.sesolve(Hresult_guess, initial_state, times) + +print('Infidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) + +plt.plot(times, [np.abs(state.overlap(initial_state))**2 for state in evolution_guess.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target_state))**2 for state in evolution_guess.states], label="Overlap with target state") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_guess.states], '--', label="Fidelity") +plt.legend() +plt.title("Guess performance") +plt.show() +``` + +## GOAT algorithm + +```python +# control function +def sin(t, c): + return c[0] * np.sin(c[1] * t) + + +# gradient +def grad_sin(t, c, idx): + if idx == 0: # w.r.t. c0 + return np.sin(c[1] * t) + if idx == 1: # w.r.t. c1 + return c[0] * np.cos(c[1] * t) * t + if idx == 2: # w.r.t. time + return c[0] * np.cos(c[1] * t) * c[1] + +H = [Hd] + [[Hc, sin, {"grad": grad_sin}]] +``` + +### a) not optimized over time + +```python +ctrl_parameters = { + id: {"guess": goat_guess, "bounds": [(-1, 1), (0, 2 * np.pi)]} # c0 and c1 +} + +# run the optimization +res_goat = optimize_pulses( + objectives=Objective(initial_state, H, target_state), + control_parameters=ctrl_parameters, + tlist=times, + algorithm_kwargs={ + "alg": "GOAT", + "fid_err_targ": 0.001, + }, +) + +print('Infidelity: ', res_goat.infidelity) + +plt.plot(times, sin(times, goat_guess), label='initial guess') +plt.plot(times, res_goat.optimized_controls[0], label='optimized pulse') +plt.title('GOAT pulses') +plt.xlabel('time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +```python +Hresult = [Hd, [Hc, np.array(res_goat.optimized_controls[0])]] +evolution = qt.sesolve(Hresult, initial_state, times) + +plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution.states], label="Overlap with target state") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution.states], '--', label="Fidelity") + +plt.title('GOAT performance') +plt.xlabel('time') +plt.legend() +plt.show() + +``` + +### b) optimized over time + +```python +# treats time as optimization variable +ctrl_parameters["__time__"] = { + "guess": times[len(times) // 2], + "bounds": [times[0], times[-1]], +} + +# run the optimization +res_goat_time = optimize_pulses( + objectives=Objective(initial_state, H, target_state), + control_parameters=ctrl_parameters, + tlist=times, + algorithm_kwargs={ + "alg": "GOAT", + "fid_err_targ": 0.001, + }, +) + + +print('Infidelity: ', res_goat_time.infidelity) +print('optimized time: ', res_goat_time.optimized_params[-1]) + +time_range = times < res_goat_time.optimized_params[-1] + +plt.plot(times, res_goat.optimized_controls[0], label='optimized pulse') +plt.plot(times[time_range], np.array(res_goat_time.optimized_controls[0])[time_range], label='optimized (over time) pulse') +plt.title('GOAT pulses') +plt.xlabel('time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +```python +Hresult = [Hd, [Hc, np.array(res_goat_time.optimized_controls[0])]] +evolution_time = qt.sesolve(Hresult, initial_state, times) + +plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution_time.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution_time.states], label="Overlap with target state") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_time.states], '--', label="Fidelity") +plt.xlim(0, res_goat_time.optimized_params[-1][0]) + +plt.title('GOAT (optimized over time) performance') +plt.xlabel('time') +plt.legend() +plt.show() +``` + +### Global optimization + +```python +res_goat_global = optimize_pulses( + objectives=Objective(initial_state, H, target_state), + control_parameters=ctrl_parameters, + tlist=times, + algorithm_kwargs={ + "alg": "GOAT", + "fid_err_targ": 0.001, + }, + optimizer_kwargs={ + "method": "basinhopping", + "max_iter": 1000, + } +) + +print('Infidelity: ', res_goat_global.infidelity) +print('optimized time: ', res_goat_global.optimized_params[-1]) + +global_range = times < res_goat_global.optimized_params[-1] + +plt.plot(times, res_goat.optimized_controls[0], label='optimized pulse') +plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[0])[global_range], label='global optimized pulse') +plt.title('GOAT pulses (global)') +plt.xlabel('time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() + +``` + +```python +Hresult = [Hd, [Hc, np.array(res_goat_global.optimized_controls[0])]] +evolution_global = qt.sesolve(Hresult, initial_state, times) + +plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution_global.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution_global.states], label="Overlap with target state") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_global.states], '--', label="Fidelity") +plt.xlim(0, res_goat_global.optimized_params[-1][0]) + +plt.title('GOAT (global) performance') +plt.xlabel('time') +plt.legend() +plt.show() +``` + +## Comparison + +```python +plt.plot(times, sin(times, goat_guess), label='initial guess') +plt.plot(times, res_goat.optimized_controls[0], label='optimized pulse') +plt.plot(times[time_range], np.array(res_goat_time.optimized_controls[0])[time_range], + label='optimized (over time) pulse') +plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[0])[global_range], + label='global optimized pulse') +plt.title('GOAT pulses') +plt.xlabel('time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +```python +print('Guess Infidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) +print('GOAT Infidelity: ', res_goat.infidelity) +print('Time Infidelity: ', res_goat_time.infidelity) +print('GLobal Infidelity: ', res_goat_global.infidelity) + + +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_guess.states], label="Guess") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution.states], label="Goat") +plt.plot(times[time_range], [qt.fidelity(state, target_state) for state in evolution_time.states[:len(times[time_range])]], + label="Time") +plt.plot(times[global_range], [qt.fidelity(state, target_state) for state in evolution_global.states[:len(times[global_range])]], + label="Global") + + +np.array(res_goat_global.optimized_controls[0])[global_range], + +plt.title('Fidelities') +plt.xlabel('time') +plt.legend() +plt.show() + +``` + +## Validation + +```python +assert res_goat.infidelity < 0.02 +assert np.abs(evolution.states[-1].overlap(target_state)) > 1-0.02 +assert res_goat_time.infidelity < 0.001 +assert max([np.abs(state.overlap(target_state)) for state in evolution_time.states]) > 1-0.001 +assert res_goat_global.infidelity < 0.001 +assert max([np.abs(state.overlap(target_state)) for state in evolution_global.states]) > 1-0.001 +``` + +```python +qt.about() +``` + +```python + +``` diff --git a/tests/interactive/GRAPE_gate_closed.md b/tests/interactive/GRAPE_gate_closed.md new file mode 100644 index 0000000..bc1e1f0 --- /dev/null +++ b/tests/interactive/GRAPE_gate_closed.md @@ -0,0 +1,116 @@ +--- +jupyter: + jupytext: + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.16.7 + kernelspec: + display_name: qutip-dev + language: python + name: python3 +--- + +# GRAPE algorithm for a closed system + +```python +import matplotlib.pyplot as plt +import numpy as np +from qutip import (about, Qobj, gates, liouvillian, fidelity,basis, qeye, sigmam, sigmax, sigmay, sigmaz, tensor) +import qutip as qt +from qutip_qoc import Objective, optimize_pulses +``` + +## Problem setup + +```python +hbar = 1 +omega = 0.1 # energy splitting +delta = 1.0 # tunneling +gamma = 0.1 # amplitude damping +sx, sy, sz = sigmax(), sigmay(), sigmaz() + +Hd = 1 / 2 * hbar * omega * sz +Hc = [sx, sy, sz] +H = [Hd, Hc[0], Hc[1], Hc[2]] + +# objective for optimization +initial_gate = qeye(2) +target_gate = Qobj(1 / np.sqrt(2) * np.array([[1, 1], [1, -1]])) + +times = np.linspace(0, np.pi / 2, 100) +``` + +## Guess + +```python +guess = np.sin(times) + +Hresult_guess = [Hd] + [[hc, guess] for hc in Hc] +evolution_guess = qt.sesolve(Hresult_guess, initial_gate, times) + +print('Fidelity: ', qt.fidelity(evolution_guess.states[-1], target_gate)) + +plt.plot(times, [np.abs(state.overlap(initial_gate) / initial_gate.norm())**2 for state in evolution_guess.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target_gate) / target_gate.norm())**2 for state in evolution_guess.states], label="Overlap with target state") +plt.legend() +plt.title("Guess performance") +plt.show() +``` + +## GRAPE algorithm + +```python +control_params = { + "ctrl_x": {"guess": np.sin(times), "bounds": [-1, 1]}, + "ctrl_y": {"guess": np.cos(times), "bounds": [-1, 1]}, + "ctrl_z": {"guess": np.tanh(times), "bounds": [-1, 1]}, +} + +res_grape = optimize_pulses( + objectives=Objective(initial_gate, H, target_gate), + control_parameters=control_params, + tlist=times, + algorithm_kwargs={"alg": "GRAPE", "fid_err_targ": 0.001}, +) + +print('Infidelity: ', res_grape.infidelity) + + +plt.plot(times, res_grape.optimized_controls[0], label='optimized pulse sx') +plt.plot(times, res_grape.optimized_controls[1], label='optimized pulse sy') +plt.plot(times, res_grape.optimized_controls[2], label='optimized pulse sz') +plt.title('GRAPE pulses') +plt.xlabel('time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +```python +Hresult = [Hd, [Hc[0], res_grape.optimized_controls[0]], [Hc[1], res_grape.optimized_controls[1]], [Hc[2], res_grape.optimized_controls[2]]] +evolution = qt.sesolve(Hresult, initial_gate, times) + + +plt.plot(times, [np.abs(state.overlap(target_gate) / target_gate.norm())**2 for state in evolution.states], label="target overlap") +plt.plot(times, [np.abs(state.overlap(initial_gate) / initial_gate.norm())**2 for state in evolution.states], label="initial overlap") +plt.legend() +plt.title("GRAPE performance") +plt.show() +``` + +## Validation + +```python +assert res_grape.infidelity < 0.001 +assert np.abs(evolution.states[-1].overlap(target_gate)) > 1-0.001 +``` + +```python +qt.about() +``` + +```python + +``` diff --git a/tests/interactive/GRAPE_state_closed.md b/tests/interactive/GRAPE_state_closed.md new file mode 100644 index 0000000..64e60c6 --- /dev/null +++ b/tests/interactive/GRAPE_state_closed.md @@ -0,0 +1,116 @@ +--- +jupyter: + jupytext: + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.16.7 + kernelspec: + display_name: qutip-dev + language: python + name: python3 +--- + +# GRAPE algorithm for 2 level system + +```python +import matplotlib.pyplot as plt +import numpy as np +from qutip import (about, fidelity, Qobj, basis) +import qutip as qt +from qutip_qoc import Objective, optimize_pulses + +import logging +``` + +## Problem setup + +```python +# Energy levels +E1, E2 = 1.0, 2.0 + +Hd = Qobj(np.diag([E1, E2])) +Hc = Qobj(np.array([ + [0, 1], + [1, 0] +])) +H = [Hd, Hc] + +initial_state = basis(2, 0) # |1> +target_state = basis(2, 1) # |2> + +times = np.linspace(0, 2 * np.pi, 100) +``` + +## Guess + +```python +guess = np.sin(times) + +Hresult_guess = [Hd, [Hc, guess]] +evolution_guess = qt.sesolve(Hresult_guess, initial_state, times) + +print('Fidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) + +plt.plot(times, [np.abs(state.overlap(initial_state))**2 for state in evolution_guess.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target_state))**2 for state in evolution_guess.states], label="Overlap with target state") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_guess.states], '--', label="Fidelity") +plt.legend() +plt.title("Guess performance") +plt.show() +``` + +## GRAPE algorithm + +```python +control_params = { + "ctrl_1": {"guess": guess, "bounds": [-1, 1]}, # Control pulse for Hc1 +} + +res_grape = optimize_pulses( + objectives = Objective(initial_state, H, target_state), + control_parameters = control_params, + tlist = times, + algorithm_kwargs = {"alg": "GRAPE", "fid_err_targ": 0.001, "log_level": logging.DEBUG - 2}, +) + +print('Infidelity: ', res_grape.infidelity) + +plt.plot(times, guess, label='initial guess') +plt.plot(times, res_grape.optimized_controls[0], label='optimized pulse') +plt.title('GRAPE pulses') +plt.xlabel('time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +```python +Hresult = [Hd, [Hc, np.array(res_grape.optimized_controls[0])]] +evolution = qt.sesolve(Hresult, initial_state, times) + +plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution.states], label="Overlap with target state") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution.states], '--', label="Fidelity") + +plt.title('GRAPE performance') +plt.xlabel('time') +plt.legend() +plt.show() +``` + +## Validation + +```python +assert res_grape.infidelity < 0.01 +assert np.abs(evolution.states[-1].overlap(target_state)) > 1-0.01 +``` + +```python +qt.about() +``` + +```python + +``` diff --git a/tests/interactive/JOPT_gate_closed.md b/tests/interactive/JOPT_gate_closed.md new file mode 100644 index 0000000..d026b20 --- /dev/null +++ b/tests/interactive/JOPT_gate_closed.md @@ -0,0 +1,217 @@ +--- +jupyter: + jupytext: + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.16.7 + kernelspec: + display_name: qutip-dev + language: python + name: python3 +--- + +# JOPT algorithm for a closed system + +```python +import matplotlib.pyplot as plt +import numpy as np +from jax import jit, numpy +from qutip import (about, Qobj, gates, qeye, sigmam, sigmax, sigmay, sigmaz, fidelity) +import qutip as qt +from qutip_qoc import Objective, optimize_pulses +``` + +## Problem setup + +```python +hbar = 1 +omega = 0.1 # energy splitting +delta = 1.0 # tunneling +gamma = 0.1 # amplitude damping +sx, sy, sz, sm = sigmax(), sigmay(), sigmaz(), sigmam() + +Hc = sx +Hd = 1 / 2 * hbar * omega * sz +H = [Hd, Hc] + +initial = qeye(2) +target = Qobj(1 / np.sqrt(2) * np.array([[1, 1], [1, -1]])) + +times = np.linspace(0, 2*np.pi, 10) +``` + +## Guess + +```python +guess = [1, 1] +guess_pulse = guess[0] * np.sin(guess[1] * times) +``` + +## JOPT algorithm + +```python +@jit +def sin_x(t, c, **kwargs): + return c[0] * numpy.sin(c[1] * t) + +H = [Hd] + [[Hc, sin_x]] + +ctrl_parameters = { + id: {"guess": guess, "bounds": [(-1, 1), (0, 2 * np.pi)]} # c0 and c1 +} + +``` + +### a) not optimized over time + +```python +res_jopt = optimize_pulses( + objectives=Objective(initial, H, target), + control_parameters=ctrl_parameters, + tlist=times, + minimizer_kwargs={ + "method": "Nelder-Mead", + }, + algorithm_kwargs={ + "alg": "JOPT", + "fid_err_targ": 0.5, + }, +) + +print('Infidelity: ', res_jopt.infidelity) + +plt.plot(times, sin_x(times, guess), label='initial guess') +plt.plot(times, res_jopt.optimized_controls[0], label='optimized pulse') +plt.title('JOPT pulses') +plt.xlabel('time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +### b) optimized over time + +```python +# treats time as optimization variable +ctrl_parameters["__time__"] = { + "guess": times[len(times) // 2], + "bounds": [times[0], times[-1]], +} + +# run the optimization +res_jopt_time = optimize_pulses( + objectives=Objective(initial, H, target), + control_parameters=ctrl_parameters, + tlist=times, + minimizer_kwargs={ + "method": "Nelder-Mead", + + }, + algorithm_kwargs={ + "alg": "JOPT", + "fid_err_targ": 0.001, + }, +) + +print('Infidelity: ', res_jopt_time.infidelity) +print('optimized time: ', res_jopt_time.optimized_params[-1]) + +time_range = times < res_jopt_time.optimized_params[-1] + +plt.plot(times, res_jopt.optimized_controls[0], color='orange', label='optimized pulse') +plt.plot(times[time_range], np.array(res_jopt.optimized_controls[0])[time_range], + color='green', label='optimized (over time) pulse') +plt.title('JOPT pulses') +plt.xlabel('time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +## Global optimization + +```python +res_jopt_global = optimize_pulses( + objectives=Objective(initial, H, target), + control_parameters=ctrl_parameters, + tlist=times, + algorithm_kwargs={ + "alg": "JOPT", + "fid_err_targ": 0.001, + }, + optimizer_kwargs={ + "method": "basinhopping", + "max_iter": 1000, + } +) + +print('Infidelity: ', res_jopt_global.infidelity) +print('optimized time: ', res_jopt_global.optimized_params[-1]) + +global_range = times < res_jopt_global.optimized_params[-1] + +plt.plot(times, res_jopt.optimized_controls[0], color='orange', label='optimized pulse') +plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[0])[global_range], color='red', label='global optimized pulse') +plt.title('JOPT pulses (global)') +plt.xlabel('time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() + +``` + +## Comparison + +```python +plt.plot(times, sin_x(times, guess), color='blue', label='initial guess') +plt.plot(times, res_jopt.optimized_controls[0], color='orange', label='optimized pulse') +plt.plot(times[time_range], np.array(res_jopt_time.optimized_controls[0])[time_range], + color='green', label='optimized (over time) pulse') +plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[0])[global_range], + color='red', label='global optimized pulse') +plt.title('GOAT pulses') +plt.xlabel('time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +```python +print('Guess Infidelity: ', qt.fidelity(evolution_guess.states[-1], target)) +print('JOPT Infidelity: ', res_jopt.infidelity) +print('Time Infidelity: ', res_jopt_time.infidelity) +print('GLobal Infidelity: ', res_jopt_global.infidelity) + +plt.plot(times, [qt.fidelity(state, target) for state in evolution_guess.states], color='blue', label="Guess") +plt.plot(times, [qt.fidelity(state, target) for state in evolution.states], color='orange', label="Goat") +plt.plot(times[time_range], [qt.fidelity(state, target) for state in evolution_time.states[:len(times[time_range])]], + color='green', label="Time") +plt.plot(times[global_range], [qt.fidelity(state, target) for state in evolution_global.states[:len(times[global_range])]], + color='red', label="Global") + +np.array(res_jopt_global.optimized_controls[0])[global_range], + +plt.title('Fidelities') +plt.xlabel('time') +plt.legend() +plt.show() +``` + +## Validation + +```python +assert res_jopt.infidelity < 0.02 +assert np.abs(evolution.states[-1].overlap(target_state)) > 1-0.02 +assert res_jopt_time.infidelity < 0.001 +assert max([np.abs(state.overlap(target_state)) for state in evolution_time.states]) > 1-0.001 +assert res_jopt_global.infidelity < 0.001 +assert max([np.abs(state.overlap(target_state)) for state in evolution_global.states]) > 1-0.001 +``` + +```python +qt.about() +``` + + diff --git a/tests/interactive/JOPT_state_closed.md b/tests/interactive/JOPT_state_closed.md new file mode 100644 index 0000000..10301cd --- /dev/null +++ b/tests/interactive/JOPT_state_closed.md @@ -0,0 +1,277 @@ +--- +jupyter: + jupytext: + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.16.7 + kernelspec: + display_name: qutip-dev + language: python + name: python3 +--- + +# JOPT algorithm for a 2 level system + + +```python +import matplotlib.pyplot as plt +import numpy as np +from jax import jit, numpy +from qutip import (about, fidelity, Qobj, basis) +import qutip as qt +from qutip_qoc import Objective, optimize_pulses +``` + +## Problem setup + +```python +# Energy levels +E1, E2 = 1.0, 1.0 + +Hd = Qobj(np.diag([E1, E2])) +Hc = Qobj(np.array([ + [0, 1], + [1, 0] +])) +H = [Hd, Hc] + +initial_state = basis(2, 0) # |1> +target_state = basis(2, 1) # |2> + +times = np.linspace(0, 2 * np.pi, 100) +``` + +## Guess + +```python +jopt_guess = [1, 0.5] +guess_pulse = jopt_guess[0] * np.sin(jopt_guess[1] * times) + +Hresult_guess = [Hd, [Hc, guess_pulse]] +evolution_guess = qt.sesolve(Hresult_guess, initial_state, times) + +print('Infidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) + +plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution_guess.states], label="Initial Overlap") +plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution_guess.states], label="Target Overlap") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_guess.states], '--', label="Fidelity") +plt.legend() +plt.title("Guess performance") +plt.show() +``` + +## JOPT algorithm + +```python +@jit +def sin_x(t, c, **kwargs): + return c[0] * numpy.sin(c[1] * t) + +H = [Hd] + [[Hc, sin_x]] + +ctrl_parameters = { + id: {"guess": [1, 0], "bounds": [(-1, 1), (0, 2 * np.pi)]} # c0 and c1 +} +``` + +### a) not optimized over time + +```python +res_jopt = optimize_pulses( + objectives=Objective(initial_state, H, target_state), + control_parameters=ctrl_parameters, + tlist=times, + minimizer_kwargs={ + "method": "Nelder-Mead", + + }, + algorithm_kwargs={ + "alg": "JOPT", + "fid_err_targ": 0.001, + }, +) + +print('Infidelity: ', res_jopt.infidelity) + +plt.plot(times, sin_x(times, jopt_guess), label='initial guess') +plt.plot(times, res_jopt.optimized_controls[0], label='optimized pulse') +plt.title('JOPT pulses') +plt.xlabel('time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +```python +Hresult = [Hd, [Hc, np.array(res_jopt.optimized_controls[0])]] +evolution = qt.sesolve(Hresult, initial_state, times) + +plt.plot(times, [np.abs(state.overlap(initial_state))**2 for state in evolution.states], label="Overlap with intiial state") +plt.plot(times, [np.abs(state.overlap(target_state))**2 for state in evolution.states], label="Overlap with target state") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution.states], '--', label="Fidelity") + +plt.title('JOPT performance') +plt.xlabel('time') +plt.legend() +plt.show() + +``` + +### b) optimized over time + +```python +# treats time as optimization variable +ctrl_parameters["__time__"] = { + "guess": times[len(times) // 2], + "bounds": [times[0], times[-1]], +} + +# run the optimization +res_jopt_time = optimize_pulses( + objectives=Objective(initial_state, H, target_state), + control_parameters=ctrl_parameters, + tlist=times, + minimizer_kwargs={ + "method": "Nelder-Mead", + + }, + algorithm_kwargs={ + "alg": "JOPT", + "fid_err_targ": 0.001, + }, +) + +print('Infidelity: ', res_jopt_time.infidelity) +print('optimized time: ', res_jopt_time.optimized_params[-1]) + +time_range = times < res_jopt_time.optimized_params[-1] + +plt.plot(times, res_jopt.optimized_controls[0], color='orange', label='optimized pulse') +plt.plot(times[time_range], np.array(res_jopt.optimized_controls[0])[time_range], + color='green', label='optimized (over time) pulse') +plt.title('JOPT pulses') +plt.xlabel('time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +```python +Hresult = [Hd, [Hc, np.array(res_jopt_time.optimized_controls[0])]] +evolution_time = qt.sesolve(Hresult, initial_state, times) + +plt.plot(times, [np.abs(state.overlap(initial_state))**2 for state in evolution_time.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target_state))**2 for state in evolution_time.states], label="Overlap with target state") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_time.states], '--', label="Fidelity") +plt.xlim(0, res_jopt_time.optimized_params[-1][0]) + +plt.title('JOPT (optimized over time) performance') +plt.xlabel('time') +plt.legend() +plt.show() +``` + +## Global optimization + +```python +res_jopt_global = optimize_pulses( + objectives=Objective(initial_state, H, target_state), + control_parameters=ctrl_parameters, + tlist=times, + algorithm_kwargs={ + "alg": "JOPT", + "fid_err_targ": 0.001, + }, + optimizer_kwargs={ + "method": "basinhopping", + "max_iter": 1000, + } +) + +print('Infidelity: ', res_jopt_global.infidelity) +print('optimized time: ', res_jopt_global.optimized_params[-1]) + +global_range = times < res_jopt_global.optimized_params[-1] + +plt.plot(times, res_jopt.optimized_controls[0], color='orange', label='optimized pulse') +plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[0])[global_range], color='red', label='global optimized pulse') +plt.title('JOPT pulses (global)') +plt.xlabel('time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() + +``` + +```python +Hresult = [Hd, [Hc, np.array(res_jopt_global.optimized_controls[0])]] +evolution_global = qt.sesolve(Hresult, initial_state, times) + +plt.plot(times, [np.abs(state.overlap(initial_state))**2 for state in evolution_global.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target_state))**2 for state in evolution_global.states], label="Overlap with target state") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_global.states], '--', label="Fidelity") +plt.xlim(0, res_jopt_global.optimized_params[-1][0]) + +plt.title('JOPT (global) performance') +plt.xlabel('time') +plt.legend() +plt.show() +``` + +## Comparison + +```python +plt.plot(times, sin_x(times, jopt_guess), color='blue', label='initial guess') +plt.plot(times, res_jopt.optimized_controls[0], color='orange', label='optimized pulse') +plt.plot(times[time_range], np.array(res_jopt_time.optimized_controls[0])[time_range], + color='green', label='optimized (over time) pulse') +plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[0])[global_range], + color='red', label='global optimized pulse') +plt.title('GOAT pulses') +plt.xlabel('time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +```python +print('Guess Infidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) +print('JOPT Infidelity: ', res_jopt.infidelity) +print('Time Infidelity: ', res_jopt_time.infidelity) +print('GLobal Infidelity: ', res_jopt_global.infidelity) + +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_guess.states], color='blue', label="Guess") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution.states], color='orange', label="Goat") +plt.plot(times[time_range], [qt.fidelity(state, target_state) for state in evolution_time.states[:len(times[time_range])]], + color='green', label="Time") +plt.plot(times[global_range], [qt.fidelity(state, target_state) for state in evolution_global.states[:len(times[global_range])]], + color='red', label="Global") + +np.array(res_jopt_global.optimized_controls[0])[global_range], + +plt.title('Fidelities') +plt.xlabel('time') +plt.legend() +plt.show() +``` + +## Validation + +```python +assert res_jopt.infidelity < 0.02 +assert np.abs(evolution.states[-1].overlap(target_state)) > 1-0.02 +assert res_jopt_time.infidelity < 0.001 +assert max([np.abs(state.overlap(target_state)) for state in evolution_time.states]) > 1-0.001 +assert res_jopt_global.infidelity < 0.001 +assert max([np.abs(state.overlap(target_state)) for state in evolution_global.states]) > 1-0.001 +``` + +```python +qt.about() +``` + +```python + +``` From 55e3b6d3b27230f3b84067cf304c056b6ad89f5a Mon Sep 17 00:00:00 2001 From: Julian Seither Date: Thu, 8 May 2025 14:32:37 +0900 Subject: [PATCH 02/17] Updated JOPT notebook --- tests/interactive/JOPT_gate_closed.md | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/tests/interactive/JOPT_gate_closed.md b/tests/interactive/JOPT_gate_closed.md index d026b20..b1cd0b0 100644 --- a/tests/interactive/JOPT_gate_closed.md +++ b/tests/interactive/JOPT_gate_closed.md @@ -30,16 +30,17 @@ hbar = 1 omega = 0.1 # energy splitting delta = 1.0 # tunneling gamma = 0.1 # amplitude damping -sx, sy, sz, sm = sigmax(), sigmay(), sigmaz(), sigmam() +sx, sy, sz = sigmax(), sigmay(), sigmaz() -Hc = sx Hd = 1 / 2 * hbar * omega * sz -H = [Hd, Hc] +Hc = [sx, sy, sz] +H = [Hd, Hc[0], Hc[1], Hc[2]] +# objective for optimization initial = qeye(2) target = Qobj(1 / np.sqrt(2) * np.array([[1, 1], [1, -1]])) -times = np.linspace(0, 2*np.pi, 10) +times = np.linspace(0, 2*np.pi, 100) ``` ## Guess @@ -56,10 +57,11 @@ guess_pulse = guess[0] * np.sin(guess[1] * times) def sin_x(t, c, **kwargs): return c[0] * numpy.sin(c[1] * t) -H = [Hd] + [[Hc, sin_x]] +H = [Hd] + [[hc, sin_x] for hc in Hc] ctrl_parameters = { id: {"guess": guess, "bounds": [(-1, 1), (0, 2 * np.pi)]} # c0 and c1 + for id in ['x', 'y', 'z'] } ``` From 9553ebef0c8792db40dc181f9f3cb06f9d893962 Mon Sep 17 00:00:00 2001 From: Julian Seither Date: Thu, 8 May 2025 14:52:02 +0900 Subject: [PATCH 03/17] updated JOPT notebook --- tests/interactive/JOPT_gate_closed.md | 116 ++++++++++++++++++-------- 1 file changed, 79 insertions(+), 37 deletions(-) diff --git a/tests/interactive/JOPT_gate_closed.md b/tests/interactive/JOPT_gate_closed.md index b1cd0b0..6b61d09 100644 --- a/tests/interactive/JOPT_gate_closed.md +++ b/tests/interactive/JOPT_gate_closed.md @@ -48,6 +48,18 @@ times = np.linspace(0, 2*np.pi, 100) ```python guess = [1, 1] guess_pulse = guess[0] * np.sin(guess[1] * times) + +Hresult_guess = [Hd] + [[hc, guess_pulse] for hc in Hc] +evolution_guess = qt.sesolve(Hresult_guess, initial, times) + +print('Infidelity: ', qt.fidelity(evolution_guess.states[-1], target)) + +plt.plot(times, [np.abs(state.overlap(initial) / initial.norm()) for state in evolution_guess.states], label="Initial Overlap") +plt.plot(times, [np.abs(state.overlap(target) / target.norm()) for state in evolution_guess.states], label="Target Overlap") +plt.plot(times, [qt.fidelity(state, target) for state in evolution_guess.states], '--', label="Fidelity") +plt.legend() +plt.title("Guess performance") +plt.show() ``` ## JOPT algorithm @@ -84,8 +96,9 @@ res_jopt = optimize_pulses( print('Infidelity: ', res_jopt.infidelity) -plt.plot(times, sin_x(times, guess), label='initial guess') -plt.plot(times, res_jopt.optimized_controls[0], label='optimized pulse') +plt.plot(times, res_jopt.optimized_controls[0], label='optimized pulse sx') +plt.plot(times, res_jopt.optimized_controls[1], label='optimized pulse sy') +plt.plot(times, res_jopt.optimized_controls[2], label='optimized pulse sz') plt.title('JOPT pulses') plt.xlabel('time') plt.ylabel('Pulse amplitude') @@ -93,6 +106,20 @@ plt.legend() plt.show() ``` +```python +Hresult = [Hd, [Hc[0], np.array(res_jopt.optimized_controls[0])], [Hc[1], np.array(res_jopt.optimized_controls[1])], + [Hc[2], np.array(res_jopt.optimized_controls[2])]] +evolution = qt.sesolve(Hresult, initial, times) + +plt.plot(times, [np.abs(state.overlap(initial) / initial.norm()) for state in evolution.states], label="Overlap with intiial state") +plt.plot(times, [np.abs(state.overlap(target) / target.norm()) for state in evolution.states], label="Overlap with target state") +plt.title('JOPT performance') +plt.xlabel('time') +plt.legend() +plt.show() + +``` + ### b) optimized over time ```python @@ -122,9 +149,9 @@ print('optimized time: ', res_jopt_time.optimized_params[-1]) time_range = times < res_jopt_time.optimized_params[-1] -plt.plot(times, res_jopt.optimized_controls[0], color='orange', label='optimized pulse') -plt.plot(times[time_range], np.array(res_jopt.optimized_controls[0])[time_range], - color='green', label='optimized (over time) pulse') +plt.plot(times, res_jopt_time.optimized_controls[0], label='optimized pulse sx') +plt.plot(times, res_jopt_time.optimized_controls[1], label='optimized pulse sy') +plt.plot(times, res_jopt_time.optimized_controls[2], label='optimized pulse sz') plt.title('JOPT pulses') plt.xlabel('time') plt.ylabel('Pulse amplitude') @@ -132,6 +159,20 @@ plt.legend() plt.show() ``` +```python +Hresult = [Hd, [Hc[0], np.array(res_jopt_time.optimized_controls[0])], [Hc[1], np.array(res_jopt_time.optimized_controls[1])], + [Hc[2], np.array(res_jopt_time.optimized_controls[2])]] +evolution_time = qt.sesolve(Hresult, initial, times) + +plt.plot(times, [np.abs(state.overlap(initial) / initial.norm()) for state in evolution_time.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target) / target.norm()) for state in evolution_time.states], label="Overlap with target state") +plt.xlim(0, res_jopt_time.optimized_params[-1][0]) +plt.title('JOPT (optimized over time) performance') +plt.xlabel('time') +plt.legend() +plt.show() +``` + ## Global optimization ```python @@ -154,8 +195,9 @@ print('optimized time: ', res_jopt_global.optimized_params[-1]) global_range = times < res_jopt_global.optimized_params[-1] -plt.plot(times, res_jopt.optimized_controls[0], color='orange', label='optimized pulse') -plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[0])[global_range], color='red', label='global optimized pulse') +plt.plot(times, res_jopt_global.optimized_controls[0], label='optimized pulse sx') +plt.plot(times, res_jopt_global.optimized_controls[1], label='optimized pulse sy') +plt.plot(times, res_jopt_global.optimized_controls[2], label='optimized pulse sz') plt.title('JOPT pulses (global)') plt.xlabel('time') plt.ylabel('Pulse amplitude') @@ -164,52 +206,52 @@ plt.show() ``` -## Comparison - ```python -plt.plot(times, sin_x(times, guess), color='blue', label='initial guess') -plt.plot(times, res_jopt.optimized_controls[0], color='orange', label='optimized pulse') -plt.plot(times[time_range], np.array(res_jopt_time.optimized_controls[0])[time_range], - color='green', label='optimized (over time) pulse') -plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[0])[global_range], - color='red', label='global optimized pulse') -plt.title('GOAT pulses') +Hresult = [Hd, [Hc[0], np.array(res_jopt_global.optimized_controls[0])], [Hc[1], np.array(res_jopt_global.optimized_controls[1])], + [Hc[2], np.array(res_jopt_global.optimized_controls[2])]] +evolution_global = qt.sesolve(Hresult, initial, times) + +plt.plot(times, [np.abs(state.overlap(initial) / initial.norm()) for state in evolution_global.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target) / target.norm()) for state in evolution_global.states], label="Overlap with target state") +plt.xlim(0, res_jopt_global.optimized_params[-1][0]) +plt.title('JOPT (global) performance') plt.xlabel('time') -plt.ylabel('Pulse amplitude') plt.legend() plt.show() ``` -```python -print('Guess Infidelity: ', qt.fidelity(evolution_guess.states[-1], target)) -print('JOPT Infidelity: ', res_jopt.infidelity) -print('Time Infidelity: ', res_jopt_time.infidelity) -print('GLobal Infidelity: ', res_jopt_global.infidelity) - -plt.plot(times, [qt.fidelity(state, target) for state in evolution_guess.states], color='blue', label="Guess") -plt.plot(times, [qt.fidelity(state, target) for state in evolution.states], color='orange', label="Goat") -plt.plot(times[time_range], [qt.fidelity(state, target) for state in evolution_time.states[:len(times[time_range])]], - color='green', label="Time") -plt.plot(times[global_range], [qt.fidelity(state, target) for state in evolution_global.states[:len(times[global_range])]], - color='red', label="Global") - -np.array(res_jopt_global.optimized_controls[0])[global_range], +## Comparison -plt.title('Fidelities') -plt.xlabel('time') -plt.legend() +```python +fig, axes = plt.subplots(1, 3, figsize=(18, 4)) # 1 row, 3 columns + +titles = ["GOAT s_x pulses", "GOAT s_y pulses", "GOAT s_z pulses"] + +for i in range(3): + ax = axes[i] + ax.plot(times, sin_x(times, guess), label='initial guess') + ax.plot(times, res_jopt.optimized_controls[i], color='orange', label='optimized pulse') + ax.plot(times[time_range], np.array(res_jopt_time.optimized_controls[i])[time_range], label='optimized (over time) pulse') + ax.plot(times[global_range], np.array(res_jopt_global.optimized_controls[i])[global_range], label='global optimized pulse') + ax.set_title(titles[i]) + ax.set_xlabel('time') + ax.set_ylabel('Pulse amplitude') + ax.legend() + +plt.tight_layout() plt.show() + ``` ## Validation ```python assert res_jopt.infidelity < 0.02 -assert np.abs(evolution.states[-1].overlap(target_state)) > 1-0.02 +assert np.abs(evolution.states[-1].overlap(target)) > 1-0.02 assert res_jopt_time.infidelity < 0.001 -assert max([np.abs(state.overlap(target_state)) for state in evolution_time.states]) > 1-0.001 +assert max([np.abs(state.overlap(target)) for state in evolution_time.states]) > 1-0.001 assert res_jopt_global.infidelity < 0.001 -assert max([np.abs(state.overlap(target_state)) for state in evolution_global.states]) > 1-0.001 +assert max([np.abs(state.overlap(target)) for state in evolution_global.states]) > 1-0.001 ``` ```python From 65f7125d5984fc298ed3ac02e71aff2291009d0d Mon Sep 17 00:00:00 2001 From: Paul Menczel Date: Thu, 8 May 2025 14:56:57 +0900 Subject: [PATCH 04/17] Update JOPT notebook --- tests/interactive/JOPT_gate_closed.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/interactive/JOPT_gate_closed.md b/tests/interactive/JOPT_gate_closed.md index 6b61d09..36f947b 100644 --- a/tests/interactive/JOPT_gate_closed.md +++ b/tests/interactive/JOPT_gate_closed.md @@ -5,9 +5,9 @@ jupyter: extension: .md format_name: markdown format_version: '1.3' - jupytext_version: 1.16.7 + jupytext_version: 1.17.1 kernelspec: - display_name: qutip-dev + display_name: Python 3 (ipykernel) language: python name: python3 --- @@ -90,7 +90,7 @@ res_jopt = optimize_pulses( }, algorithm_kwargs={ "alg": "JOPT", - "fid_err_targ": 0.5, + "fid_err_targ": 0.001, }, ) @@ -225,7 +225,7 @@ plt.show() ```python fig, axes = plt.subplots(1, 3, figsize=(18, 4)) # 1 row, 3 columns -titles = ["GOAT s_x pulses", "GOAT s_y pulses", "GOAT s_z pulses"] +titles = ["JOPT s_x pulses", "JOPT s_y pulses", "JOPT s_z pulses"] for i in range(3): ax = axes[i] From 8b15b99672d18b2ed795bc8a0ab55b513aec8929 Mon Sep 17 00:00:00 2001 From: Paul Menczel Date: Thu, 8 May 2025 14:57:18 +0900 Subject: [PATCH 05/17] Added interactive tests to automatic test suite --- .github/workflows/test.yml | 2 +- tests/test_interactive.py | 23 +++++++++++++++++++++++ 2 files changed, 24 insertions(+), 1 deletion(-) create mode 100644 tests/test_interactive.py diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index 14185e3..cae6283 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -79,7 +79,7 @@ jobs: - name: Test with pytest and generate coverage report run: | - pip install pytest-cov coveralls + pip install jupytext pytest-cov coveralls pytest tests --strict-markers --cov=qutip_qoc --cov-report= --color=yes - name: Upload to Coveralls diff --git a/tests/test_interactive.py b/tests/test_interactive.py new file mode 100644 index 0000000..42f2b8a --- /dev/null +++ b/tests/test_interactive.py @@ -0,0 +1,23 @@ +""" +This file contains the test suite for running the interactive test notebooks +in the 'tests/interactive' directory. +Taken, modified from https://github.com/SeldonIO/alibi/blob/master/testing/test_notebooks.py +""" + +import glob +import pytest + +from pathlib import Path +from jupytext.cli import jupytext + +# Set of all example notebooks +NOTEBOOK_DIR = 'tests/interactive' +ALL_NOTEBOOKS = { + Path(x).name for x in glob.glob(str(Path(NOTEBOOK_DIR).joinpath('*.md'))) +} + +@pytest.mark.timeout(600) +@pytest.mark.parametrize("notebook", ALL_NOTEBOOKS) +def test_notebook(notebook): + notebook = Path(NOTEBOOK_DIR, notebook) + jupytext(args=[str(notebook), "--execute"]) \ No newline at end of file From 6b875fb9fc41c49b1d86638603f4e60d4f20043d Mon Sep 17 00:00:00 2001 From: Paul Menczel Date: Thu, 8 May 2025 15:07:11 +0900 Subject: [PATCH 06/17] Removed timeout mark from test --- tests/test_interactive.py | 1 - 1 file changed, 1 deletion(-) diff --git a/tests/test_interactive.py b/tests/test_interactive.py index 42f2b8a..324c43c 100644 --- a/tests/test_interactive.py +++ b/tests/test_interactive.py @@ -16,7 +16,6 @@ Path(x).name for x in glob.glob(str(Path(NOTEBOOK_DIR).joinpath('*.md'))) } -@pytest.mark.timeout(600) @pytest.mark.parametrize("notebook", ALL_NOTEBOOKS) def test_notebook(notebook): notebook = Path(NOTEBOOK_DIR, notebook) From abc9b8d87d16ac13558e2f179c7cfc10fb6cf871 Mon Sep 17 00:00:00 2001 From: Paul Menczel Date: Thu, 8 May 2025 15:16:01 +0900 Subject: [PATCH 07/17] Make sure required packages are installed in test environment --- .github/workflows/test.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml index cae6283..b0272a6 100644 --- a/.github/workflows/test.yml +++ b/.github/workflows/test.yml @@ -79,7 +79,7 @@ jobs: - name: Test with pytest and generate coverage report run: | - pip install jupytext pytest-cov coveralls + pip install jupytext nbconvert ipykernel pytest-cov coveralls pytest tests --strict-markers --cov=qutip_qoc --cov-report= --color=yes - name: Upload to Coveralls From 46797e23f578d37884c3147c7ba7b87ec23d109b Mon Sep 17 00:00:00 2001 From: Paul Menczel Date: Thu, 8 May 2025 19:08:14 +0900 Subject: [PATCH 08/17] Finalized state transfer notebooks --- tests/interactive/CRAB_state_closed.md | 46 +++---- tests/interactive/GOAT_state_closed.md | 149 ++++++++++---------- tests/interactive/GRAPE_state_closed.md | 46 +++---- tests/interactive/JOPT_state_closed.md | 173 +++++++++++++----------- tests/test_interactive.py | 10 +- 5 files changed, 220 insertions(+), 204 deletions(-) diff --git a/tests/interactive/CRAB_state_closed.md b/tests/interactive/CRAB_state_closed.md index de5ddbb..7c28c84 100644 --- a/tests/interactive/CRAB_state_closed.md +++ b/tests/interactive/CRAB_state_closed.md @@ -5,19 +5,19 @@ jupyter: extension: .md format_name: markdown format_version: '1.3' - jupytext_version: 1.16.7 + jupytext_version: 1.17.1 kernelspec: - display_name: qutip-dev + display_name: Python 3 (ipykernel) language: python name: python3 --- -# GRAPE algorithm for 2 level system +# CRAB algorithm for 2 level system ```python import matplotlib.pyplot as plt import numpy as np -from qutip import (about, fidelity, Qobj, basis) +from qutip import (about, basis, Qobj) import qutip as qt from qutip_qoc import Objective, optimize_pulses ``` @@ -26,7 +26,7 @@ from qutip_qoc import Objective, optimize_pulses ```python # Energy levels -E1, E2 = 1.0, 2.0 +E1, E2 = 1.0, 2.0 Hd = Qobj(np.diag([E1, E2])) Hc = Qobj(np.array([ @@ -38,48 +38,48 @@ H = [Hd, Hc] initial_state = basis(2, 0) # |1> target_state = basis(2, 1) # |2> -times = np.linspace(0, 2*np.pi, 100) +times = np.linspace(0, 2 * np.pi, 250) ``` ## CRAB algorithm ```python n_params = 6 # adjust in steps of 3 -alg_args = {"alg": "CRAB", "fid_err_targ": 0.001, "fix_frequency": False} +control_params = { + "ctrl_x": {"guess": [1 for _ in range(n_params)], "bounds": [(-1, 1)] * n_params}, +} res_crab = optimize_pulses( - objectives=Objective(initial_state, H, target_state), - control_parameters={ - "ctrl_x": { - "guess": [1 for _ in range(n_params)], - "bounds": [(-1, 1)] * n_params, - }, + objectives = Objective(initial_state, H, target_state), + control_parameters = control_params, + tlist = times, + algorithm_kwargs = { + "alg": "CRAB", + "fid_err_targ": 0.001 }, - tlist=times, - algorithm_kwargs=alg_args, ) print('Infidelity: ', res_crab.infidelity) - plt.plot(times, res_crab.optimized_controls[0], label='optimized pulse') plt.title('CRAB pulse') -plt.xlabel('time') +plt.xlabel('Time') plt.ylabel('Pulse amplitude') - plt.legend() plt.show() ``` ```python -Hresult = [Hd, [Hc, res_crab.optimized_controls[0]]] -evolution = qt.sesolve(Hresult, initial_state, times) +H_result = [Hd, [Hc, np.array(res_crab.optimized_controls[0])]] +evolution = qt.sesolve(H_result, initial_state, times) plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution.states], label="Overlap with initial state") plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution.states], label="Overlap with target state") plt.plot(times, [qt.fidelity(state, target_state) for state in evolution.states], '--', label="Fidelity") -plt.legend() + plt.title("CRAB performance") +plt.xlabel('Time') +plt.legend() plt.show() ``` @@ -93,7 +93,3 @@ assert np.abs(evolution.states[-1].overlap(target_state)) > 1-0.001 ```python qt.about() ``` - -```python - -``` diff --git a/tests/interactive/GOAT_state_closed.md b/tests/interactive/GOAT_state_closed.md index 67da337..1ca1cc2 100644 --- a/tests/interactive/GOAT_state_closed.md +++ b/tests/interactive/GOAT_state_closed.md @@ -5,9 +5,9 @@ jupyter: extension: .md format_name: markdown format_version: '1.3' - jupytext_version: 1.16.7 + jupytext_version: 1.17.1 kernelspec: - display_name: qutip-dev + display_name: Python 3 (ipykernel) language: python name: python3 --- @@ -17,7 +17,7 @@ jupyter: ```python import matplotlib.pyplot as plt import numpy as np -from qutip import (about, fidelity, Qobj, basis) +from qutip import (about, basis, Qobj) import qutip as qt from qutip_qoc import Objective, optimize_pulses ``` @@ -26,7 +26,7 @@ from qutip_qoc import Objective, optimize_pulses ```python # Energy levels -E1, E2 = 1.0, 1.0 +E1, E2 = 1.0, 2.0 Hd = Qobj(np.diag([E1, E2])) Hc = Qobj(np.array([ @@ -38,7 +38,7 @@ H = [Hd, Hc] initial_state = basis(2, 0) # |1> target_state = basis(2, 1) # |2> -times = np.linspace(0, 2 * np.pi, 100) +times = np.linspace(0, 2 * np.pi, 250) ``` ## Guess @@ -47,16 +47,17 @@ times = np.linspace(0, 2 * np.pi, 100) goat_guess = [1, 0.5] guess_pulse = goat_guess[0] * np.sin(goat_guess[1] * times) -Hresult_guess = [Hd, [Hc, guess_pulse]] -evolution_guess = qt.sesolve(Hresult_guess, initial_state, times) +H_guess = [Hd, [Hc, guess_pulse]] +evolution_guess = qt.sesolve(H_guess, initial_state, times) -print('Infidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) +print('Fidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) -plt.plot(times, [np.abs(state.overlap(initial_state))**2 for state in evolution_guess.states], label="Overlap with initial state") -plt.plot(times, [np.abs(state.overlap(target_state))**2 for state in evolution_guess.states], label="Overlap with target state") +plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution_guess.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution_guess.states], label="Overlap with target state") plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_guess.states], '--', label="Fidelity") -plt.legend() plt.title("Guess performance") +plt.xlabel('Time') +plt.legend() plt.show() ``` @@ -67,7 +68,6 @@ plt.show() def sin(t, c): return c[0] * np.sin(c[1] * t) - # gradient def grad_sin(t, c, idx): if idx == 0: # w.r.t. c0 @@ -83,27 +83,27 @@ H = [Hd] + [[Hc, sin, {"grad": grad_sin}]] ### a) not optimized over time ```python -ctrl_parameters = { - id: {"guess": goat_guess, "bounds": [(-1, 1), (0, 2 * np.pi)]} # c0 and c1 +control_params = { + "ctrl_x": {"guess": goat_guess, "bounds": [(-1, 1), (0, 2 * np.pi)]} # c0 and c1 } # run the optimization res_goat = optimize_pulses( - objectives=Objective(initial_state, H, target_state), - control_parameters=ctrl_parameters, - tlist=times, - algorithm_kwargs={ + objectives = Objective(initial_state, H, target_state), + control_parameters = control_params, + tlist = times, + algorithm_kwargs = { "alg": "GOAT", - "fid_err_targ": 0.001, + "fid_err_targ": 0.001 }, ) print('Infidelity: ', res_goat.infidelity) -plt.plot(times, sin(times, goat_guess), label='initial guess') +plt.plot(times, guess_pulse, label='initial guess') plt.plot(times, res_goat.optimized_controls[0], label='optimized pulse') plt.title('GOAT pulses') -plt.xlabel('time') +plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() plt.show() @@ -118,42 +118,44 @@ plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution.stat plt.plot(times, [qt.fidelity(state, target_state) for state in evolution.states], '--', label="Fidelity") plt.title('GOAT performance') -plt.xlabel('time') +plt.xlabel('Time') plt.legend() plt.show() - ``` +Here, GOAT is stuck in a local minimum and does not reach the desired fidelity. + + ### b) optimized over time ```python # treats time as optimization variable -ctrl_parameters["__time__"] = { +control_params["__time__"] = { "guess": times[len(times) // 2], "bounds": [times[0], times[-1]], } # run the optimization res_goat_time = optimize_pulses( - objectives=Objective(initial_state, H, target_state), - control_parameters=ctrl_parameters, - tlist=times, - algorithm_kwargs={ + objectives = Objective(initial_state, H, target_state), + control_parameters = control_params, + tlist = times, + algorithm_kwargs = { "alg": "GOAT", - "fid_err_targ": 0.001, + "fid_err_targ": 0.001 }, ) - print('Infidelity: ', res_goat_time.infidelity) -print('optimized time: ', res_goat_time.optimized_params[-1]) +print('Optimized time: ', res_goat_time.optimized_params[-1]) time_range = times < res_goat_time.optimized_params[-1] +plt.plot(times, guess_pulse, label='initial guess') plt.plot(times, res_goat.optimized_controls[0], label='optimized pulse') plt.plot(times[time_range], np.array(res_goat_time.optimized_controls[0])[time_range], label='optimized (over time) pulse') -plt.title('GOAT pulses') -plt.xlabel('time') +plt.title('GOAT pulses (time optimization)') +plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() plt.show() @@ -169,41 +171,44 @@ plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_time.st plt.xlim(0, res_goat_time.optimized_params[-1][0]) plt.title('GOAT (optimized over time) performance') -plt.xlabel('time') +plt.xlabel('Time') plt.legend() plt.show() ``` -### Global optimization +GOAT is still stuck in a local minimum, but the fidelity has improved. + + +### c) global optimization ```python res_goat_global = optimize_pulses( - objectives=Objective(initial_state, H, target_state), - control_parameters=ctrl_parameters, - tlist=times, - algorithm_kwargs={ + objectives = Objective(initial_state, H, target_state), + control_parameters = control_params, + tlist = times, + algorithm_kwargs = { "alg": "GOAT", - "fid_err_targ": 0.001, + "fid_err_targ": 0.001 }, optimizer_kwargs={ "method": "basinhopping", - "max_iter": 1000, + "max_iter": 1000 } ) print('Infidelity: ', res_goat_global.infidelity) -print('optimized time: ', res_goat_global.optimized_params[-1]) +print('Optimized time: ', res_goat_global.optimized_params[-1]) global_range = times < res_goat_global.optimized_params[-1] +plt.plot(times, guess_pulse, label='initial guess') plt.plot(times, res_goat.optimized_controls[0], label='optimized pulse') plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[0])[global_range], label='global optimized pulse') plt.title('GOAT pulses (global)') -plt.xlabel('time') +plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() plt.show() - ``` ```python @@ -216,7 +221,7 @@ plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_global. plt.xlim(0, res_goat_global.optimized_params[-1][0]) plt.title('GOAT (global) performance') -plt.xlabel('time') +plt.xlabel('Time') plt.legend() plt.show() ``` @@ -224,58 +229,56 @@ plt.show() ## Comparison ```python -plt.plot(times, sin(times, goat_guess), label='initial guess') -plt.plot(times, res_goat.optimized_controls[0], label='optimized pulse') +plt.plot(times, guess_pulse, color='blue', label='initial guess') +plt.plot(times, res_goat.optimized_controls[0], color='orange', label='optimized pulse') plt.plot(times[time_range], np.array(res_goat_time.optimized_controls[0])[time_range], - label='optimized (over time) pulse') + color='green', label='optimized (over time) pulse') plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[0])[global_range], - label='global optimized pulse') + color='red', label='global optimized pulse') + plt.title('GOAT pulses') -plt.xlabel('time') +plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() plt.show() ``` ```python -print('Guess Infidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) -print('GOAT Infidelity: ', res_goat.infidelity) -print('Time Infidelity: ', res_goat_time.infidelity) -print('GLobal Infidelity: ', res_goat_global.infidelity) - +print('Guess Fidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) +print('GOAT Fidelity: ', 1 - res_goat.infidelity) +print('Time Fidelity: ', 1 - res_goat_time.infidelity) +print('GLobal Fidelity: ', 1 - res_goat_global.infidelity) -plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_guess.states], label="Guess") -plt.plot(times, [qt.fidelity(state, target_state) for state in evolution.states], label="Goat") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_guess.states], color='blue', label="Guess") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution.states], color='orange', label="GOAT") plt.plot(times[time_range], [qt.fidelity(state, target_state) for state in evolution_time.states[:len(times[time_range])]], - label="Time") + color='green', label="Time") plt.plot(times[global_range], [qt.fidelity(state, target_state) for state in evolution_global.states[:len(times[global_range])]], - label="Global") - - -np.array(res_goat_global.optimized_controls[0])[global_range], + color='red', label="Global") plt.title('Fidelities') -plt.xlabel('time') +plt.xlabel('Time') plt.legend() plt.show() - ``` ## Validation ```python -assert res_goat.infidelity < 0.02 -assert np.abs(evolution.states[-1].overlap(target_state)) > 1-0.02 -assert res_goat_time.infidelity < 0.001 -assert max([np.abs(state.overlap(target_state)) for state in evolution_time.states]) > 1-0.001 +guess_fidelity = qt.fidelity(evolution_guess.states[-1], target_state) + +# target fidelity not reached in part a), check that it is better than the guess +assert 1 - res_goat.infidelity > guess_fidelity +assert np.allclose(np.abs(evolution.states[-1].overlap(target_state)), 1 - res_goat.infidelity, atol=1e-3) + +# target fidelity not reached in part b), check that it is better than part a) +assert res_goat_time.infidelity < res_goat.infidelity +assert np.allclose(np.abs(evolution_time.states[len(times[time_range]) - 1].overlap(target_state)), 1 - res_goat_time.infidelity, atol=1e-3) + assert res_goat_global.infidelity < 0.001 -assert max([np.abs(state.overlap(target_state)) for state in evolution_global.states]) > 1-0.001 +assert np.abs(evolution_global.states[len(times[global_range]) - 1].overlap(target_state)) > 1 - 0.001 ``` ```python qt.about() ``` - -```python - -``` diff --git a/tests/interactive/GRAPE_state_closed.md b/tests/interactive/GRAPE_state_closed.md index 64e60c6..582fe0e 100644 --- a/tests/interactive/GRAPE_state_closed.md +++ b/tests/interactive/GRAPE_state_closed.md @@ -5,9 +5,9 @@ jupyter: extension: .md format_name: markdown format_version: '1.3' - jupytext_version: 1.16.7 + jupytext_version: 1.17.1 kernelspec: - display_name: qutip-dev + display_name: Python 3 (ipykernel) language: python name: python3 --- @@ -17,18 +17,16 @@ jupyter: ```python import matplotlib.pyplot as plt import numpy as np -from qutip import (about, fidelity, Qobj, basis) +from qutip import (about, basis, Qobj) import qutip as qt from qutip_qoc import Objective, optimize_pulses - -import logging ``` ## Problem setup ```python # Energy levels -E1, E2 = 1.0, 2.0 +E1, E2 = 1.0, 2.0 Hd = Qobj(np.diag([E1, E2])) Hc = Qobj(np.array([ @@ -40,24 +38,25 @@ H = [Hd, Hc] initial_state = basis(2, 0) # |1> target_state = basis(2, 1) # |2> -times = np.linspace(0, 2 * np.pi, 100) +times = np.linspace(0, 2 * np.pi, 250) ``` ## Guess ```python -guess = np.sin(times) +guess_pulse = np.sin(times) -Hresult_guess = [Hd, [Hc, guess]] -evolution_guess = qt.sesolve(Hresult_guess, initial_state, times) +H_guess = [Hd, [Hc, guess_pulse]] +evolution_guess = qt.sesolve(H_guess, initial_state, times) print('Fidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) -plt.plot(times, [np.abs(state.overlap(initial_state))**2 for state in evolution_guess.states], label="Overlap with initial state") -plt.plot(times, [np.abs(state.overlap(target_state))**2 for state in evolution_guess.states], label="Overlap with target state") +plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution_guess.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution_guess.states], label="Overlap with target state") plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_guess.states], '--', label="Fidelity") -plt.legend() plt.title("Guess performance") +plt.xlabel('Time') +plt.legend() plt.show() ``` @@ -65,37 +64,40 @@ plt.show() ```python control_params = { - "ctrl_1": {"guess": guess, "bounds": [-1, 1]}, # Control pulse for Hc1 + "ctrl_x": {"guess": guess_pulse, "bounds": [-1, 1]}, # Control pulse for Hc1 } res_grape = optimize_pulses( objectives = Objective(initial_state, H, target_state), control_parameters = control_params, tlist = times, - algorithm_kwargs = {"alg": "GRAPE", "fid_err_targ": 0.001, "log_level": logging.DEBUG - 2}, + algorithm_kwargs = { + "alg": "GRAPE", + "fid_err_targ": 0.001 + }, ) print('Infidelity: ', res_grape.infidelity) -plt.plot(times, guess, label='initial guess') +plt.plot(times, guess_pulse, label='initial guess') plt.plot(times, res_grape.optimized_controls[0], label='optimized pulse') plt.title('GRAPE pulses') -plt.xlabel('time') +plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() plt.show() ``` ```python -Hresult = [Hd, [Hc, np.array(res_grape.optimized_controls[0])]] -evolution = qt.sesolve(Hresult, initial_state, times) +H_result = [Hd, [Hc, np.array(res_grape.optimized_controls[0])]] +evolution = qt.sesolve(H_result, initial_state, times) plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution.states], label="Overlap with initial state") plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution.states], label="Overlap with target state") plt.plot(times, [qt.fidelity(state, target_state) for state in evolution.states], '--', label="Fidelity") plt.title('GRAPE performance') -plt.xlabel('time') +plt.xlabel('Time') plt.legend() plt.show() ``` @@ -110,7 +112,3 @@ assert np.abs(evolution.states[-1].overlap(target_state)) > 1-0.01 ```python qt.about() ``` - -```python - -``` diff --git a/tests/interactive/JOPT_state_closed.md b/tests/interactive/JOPT_state_closed.md index 10301cd..d532306 100644 --- a/tests/interactive/JOPT_state_closed.md +++ b/tests/interactive/JOPT_state_closed.md @@ -5,9 +5,9 @@ jupyter: extension: .md format_name: markdown format_version: '1.3' - jupytext_version: 1.16.7 + jupytext_version: 1.17.1 kernelspec: - display_name: qutip-dev + display_name: Python 3 (ipykernel) language: python name: python3 --- @@ -18,17 +18,23 @@ jupyter: ```python import matplotlib.pyplot as plt import numpy as np -from jax import jit, numpy -from qutip import (about, fidelity, Qobj, basis) +from qutip import (about, basis, Qobj) import qutip as qt from qutip_qoc import Objective, optimize_pulses + +try: + from jax import jit + from jax import numpy as jnp +except ImportError: # JAX not available, skip test + import pytest + pytest.skip("JAX not available") ``` ## Problem setup ```python # Energy levels -E1, E2 = 1.0, 1.0 +E1, E2 = 1.0, 2.0 Hd = Qobj(np.diag([E1, E2])) Hc = Qobj(np.array([ @@ -40,7 +46,7 @@ H = [Hd, Hc] initial_state = basis(2, 0) # |1> target_state = basis(2, 1) # |2> -times = np.linspace(0, 2 * np.pi, 100) +times = np.linspace(0, 2 * np.pi, 250) ``` ## Guess @@ -49,16 +55,17 @@ times = np.linspace(0, 2 * np.pi, 100) jopt_guess = [1, 0.5] guess_pulse = jopt_guess[0] * np.sin(jopt_guess[1] * times) -Hresult_guess = [Hd, [Hc, guess_pulse]] -evolution_guess = qt.sesolve(Hresult_guess, initial_state, times) +H_guess = [Hd, [Hc, guess_pulse]] +evolution_guess = qt.sesolve(H_guess, initial_state, times) -print('Infidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) +print('Fidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) -plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution_guess.states], label="Initial Overlap") -plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution_guess.states], label="Target Overlap") +plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution_guess.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution_guess.states], label="Overlap with target state") plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_guess.states], '--', label="Fidelity") -plt.legend() plt.title("Guess performance") +plt.xlabel('Time') +plt.legend() plt.show() ``` @@ -66,28 +73,27 @@ plt.show() ```python @jit -def sin_x(t, c, **kwargs): - return c[0] * numpy.sin(c[1] * t) - -H = [Hd] + [[Hc, sin_x]] +def sin(t, c, **kwargs): + return c[0] * jnp.sin(c[1] * t) -ctrl_parameters = { - id: {"guess": [1, 0], "bounds": [(-1, 1), (0, 2 * np.pi)]} # c0 and c1 -} +H = [Hd] + [[Hc, sin]] ``` ### a) not optimized over time ```python +control_params = { + "ctrl_x": {"guess": [1, 0], "bounds": [(-1, 1), (0, 2 * np.pi)]} # c0 and c1 +} + res_jopt = optimize_pulses( - objectives=Objective(initial_state, H, target_state), - control_parameters=ctrl_parameters, - tlist=times, - minimizer_kwargs={ + objectives = Objective(initial_state, H, target_state), + control_parameters = control_params, + tlist = times, + minimizer_kwargs = { "method": "Nelder-Mead", - }, - algorithm_kwargs={ + algorithm_kwargs = { "alg": "JOPT", "fid_err_targ": 0.001, }, @@ -95,10 +101,10 @@ res_jopt = optimize_pulses( print('Infidelity: ', res_jopt.infidelity) -plt.plot(times, sin_x(times, jopt_guess), label='initial guess') +plt.plot(times, guess_pulse, label='initial guess') plt.plot(times, res_jopt.optimized_controls[0], label='optimized pulse') plt.title('JOPT pulses') -plt.xlabel('time') +plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() plt.show() @@ -108,51 +114,52 @@ plt.show() Hresult = [Hd, [Hc, np.array(res_jopt.optimized_controls[0])]] evolution = qt.sesolve(Hresult, initial_state, times) -plt.plot(times, [np.abs(state.overlap(initial_state))**2 for state in evolution.states], label="Overlap with intiial state") -plt.plot(times, [np.abs(state.overlap(target_state))**2 for state in evolution.states], label="Overlap with target state") +plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution.states], label="Overlap with target state") plt.plot(times, [qt.fidelity(state, target_state) for state in evolution.states], '--', label="Fidelity") plt.title('JOPT performance') -plt.xlabel('time') +plt.xlabel('Time') plt.legend() plt.show() - ``` +Here, JOPT is stuck in a local minimum and does not reach the desired fidelity. + + ### b) optimized over time ```python # treats time as optimization variable -ctrl_parameters["__time__"] = { +control_params["__time__"] = { "guess": times[len(times) // 2], "bounds": [times[0], times[-1]], } # run the optimization res_jopt_time = optimize_pulses( - objectives=Objective(initial_state, H, target_state), - control_parameters=ctrl_parameters, - tlist=times, - minimizer_kwargs={ + objectives = Objective(initial_state, H, target_state), + control_parameters = control_params, + tlist = times, + minimizer_kwargs = { "method": "Nelder-Mead", - }, - algorithm_kwargs={ + algorithm_kwargs = { "alg": "JOPT", "fid_err_targ": 0.001, }, ) print('Infidelity: ', res_jopt_time.infidelity) -print('optimized time: ', res_jopt_time.optimized_params[-1]) +print('Optimized time: ', res_jopt_time.optimized_params[-1]) time_range = times < res_jopt_time.optimized_params[-1] -plt.plot(times, res_jopt.optimized_controls[0], color='orange', label='optimized pulse') -plt.plot(times[time_range], np.array(res_jopt.optimized_controls[0])[time_range], - color='green', label='optimized (over time) pulse') -plt.title('JOPT pulses') -plt.xlabel('time') +plt.plot(times, guess_pulse, label='initial guess') +plt.plot(times, res_jopt.optimized_controls[0], label='optimized pulse') +plt.plot(times[time_range], np.array(res_jopt.optimized_controls[0])[time_range], label='optimized (over time) pulse') +plt.title('JOPT pulses (time optimization)') +plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() plt.show() @@ -162,60 +169,63 @@ plt.show() Hresult = [Hd, [Hc, np.array(res_jopt_time.optimized_controls[0])]] evolution_time = qt.sesolve(Hresult, initial_state, times) -plt.plot(times, [np.abs(state.overlap(initial_state))**2 for state in evolution_time.states], label="Overlap with initial state") -plt.plot(times, [np.abs(state.overlap(target_state))**2 for state in evolution_time.states], label="Overlap with target state") +plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution_time.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution_time.states], label="Overlap with target state") plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_time.states], '--', label="Fidelity") plt.xlim(0, res_jopt_time.optimized_params[-1][0]) plt.title('JOPT (optimized over time) performance') -plt.xlabel('time') +plt.xlabel('Time') plt.legend() plt.show() ``` -## Global optimization +JOPT is still stuck in a local minimum, but the fidelity has improved. + + +### c) global optimization ```python res_jopt_global = optimize_pulses( - objectives=Objective(initial_state, H, target_state), - control_parameters=ctrl_parameters, - tlist=times, - algorithm_kwargs={ + objectives = Objective(initial_state, H, target_state), + control_parameters = control_params, + tlist = times, + algorithm_kwargs = { "alg": "JOPT", - "fid_err_targ": 0.001, + "fid_err_targ": 0.001 }, optimizer_kwargs={ "method": "basinhopping", - "max_iter": 1000, + "max_iter": 1000 } ) print('Infidelity: ', res_jopt_global.infidelity) -print('optimized time: ', res_jopt_global.optimized_params[-1]) +print('Optimized time: ', res_jopt_global.optimized_params[-1]) global_range = times < res_jopt_global.optimized_params[-1] -plt.plot(times, res_jopt.optimized_controls[0], color='orange', label='optimized pulse') -plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[0])[global_range], color='red', label='global optimized pulse') +plt.plot(times, guess_pulse, label='initial guess') +plt.plot(times, res_jopt.optimized_controls[0], label='optimized pulse') +plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[0])[global_range], label='global optimized pulse') plt.title('JOPT pulses (global)') -plt.xlabel('time') +plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() plt.show() - ``` ```python Hresult = [Hd, [Hc, np.array(res_jopt_global.optimized_controls[0])]] evolution_global = qt.sesolve(Hresult, initial_state, times) -plt.plot(times, [np.abs(state.overlap(initial_state))**2 for state in evolution_global.states], label="Overlap with initial state") -plt.plot(times, [np.abs(state.overlap(target_state))**2 for state in evolution_global.states], label="Overlap with target state") +plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution_global.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution_global.states], label="Overlap with target state") plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_global.states], '--', label="Fidelity") plt.xlim(0, res_jopt_global.optimized_params[-1][0]) plt.title('JOPT (global) performance') -plt.xlabel('time') +plt.xlabel('Time') plt.legend() plt.show() ``` @@ -223,24 +233,25 @@ plt.show() ## Comparison ```python -plt.plot(times, sin_x(times, jopt_guess), color='blue', label='initial guess') +plt.plot(times, guess_pulse, color='blue', label='initial guess') plt.plot(times, res_jopt.optimized_controls[0], color='orange', label='optimized pulse') plt.plot(times[time_range], np.array(res_jopt_time.optimized_controls[0])[time_range], color='green', label='optimized (over time) pulse') plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[0])[global_range], color='red', label='global optimized pulse') -plt.title('GOAT pulses') -plt.xlabel('time') + +plt.title('JOPT pulses') +plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() plt.show() ``` ```python -print('Guess Infidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) -print('JOPT Infidelity: ', res_jopt.infidelity) -print('Time Infidelity: ', res_jopt_time.infidelity) -print('GLobal Infidelity: ', res_jopt_global.infidelity) +print('Guess Fidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) +print('JOPT Fidelity: ', 1 - res_jopt.infidelity) +print('Time Fidelity: ', 1 - res_jopt_time.infidelity) +print('GLobal Fidelity: ', 1 - res_jopt_global.infidelity) plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_guess.states], color='blue', label="Guess") plt.plot(times, [qt.fidelity(state, target_state) for state in evolution.states], color='orange', label="Goat") @@ -249,10 +260,8 @@ plt.plot(times[time_range], [qt.fidelity(state, target_state) for state in evolu plt.plot(times[global_range], [qt.fidelity(state, target_state) for state in evolution_global.states[:len(times[global_range])]], color='red', label="Global") -np.array(res_jopt_global.optimized_controls[0])[global_range], - plt.title('Fidelities') -plt.xlabel('time') +plt.xlabel('Time') plt.legend() plt.show() ``` @@ -260,18 +269,20 @@ plt.show() ## Validation ```python -assert res_jopt.infidelity < 0.02 -assert np.abs(evolution.states[-1].overlap(target_state)) > 1-0.02 -assert res_jopt_time.infidelity < 0.001 -assert max([np.abs(state.overlap(target_state)) for state in evolution_time.states]) > 1-0.001 +guess_fidelity = qt.fidelity(evolution_guess.states[-1], target_state) + +# target fidelity not reached in part a), check that it is better than the guess +assert 1 - res_jopt.infidelity > guess_fidelity +assert np.allclose(np.abs(evolution.states[-1].overlap(target_state)), 1 - res_jopt.infidelity, atol=1e-3) + +# target fidelity not reached in part b), check that it is better than part a) +assert res_jopt_time.infidelity < res_jopt.infidelity +assert np.allclose(np.abs(evolution_time.states[len(times[time_range]) - 1].overlap(target_state)), 1 - res_jopt_time.infidelity, atol=1e-3) + assert res_jopt_global.infidelity < 0.001 -assert max([np.abs(state.overlap(target_state)) for state in evolution_global.states]) > 1-0.001 +assert np.abs(evolution_global.states[len(times[global_range]) - 1].overlap(target_state)) > 1 - 0.001 ``` ```python qt.about() ``` - -```python - -``` diff --git a/tests/test_interactive.py b/tests/test_interactive.py index 324c43c..39b69c2 100644 --- a/tests/test_interactive.py +++ b/tests/test_interactive.py @@ -5,10 +5,12 @@ """ import glob +import nbclient.exceptions import pytest from pathlib import Path from jupytext.cli import jupytext +import nbclient # Set of all example notebooks NOTEBOOK_DIR = 'tests/interactive' @@ -19,4 +21,10 @@ @pytest.mark.parametrize("notebook", ALL_NOTEBOOKS) def test_notebook(notebook): notebook = Path(NOTEBOOK_DIR, notebook) - jupytext(args=[str(notebook), "--execute"]) \ No newline at end of file + try: + jupytext(args=[str(notebook), "--execute"]) + except nbclient.exceptions.CellExecutionError as e: + if e.ename == "Skipped": + pytest.skip(e.evalue) + else: + raise e \ No newline at end of file From c69f182b471e4b20b1dfa465b74dce8e8261deaa Mon Sep 17 00:00:00 2001 From: Paul Menczel Date: Fri, 9 May 2025 10:47:55 +0900 Subject: [PATCH 09/17] Fixed failing test --- tests/interactive/GOAT_state_closed.md | 52 ++++++++++++++----------- tests/interactive/JOPT_state_closed.md | 54 +++++++++++++++----------- 2 files changed, 61 insertions(+), 45 deletions(-) diff --git a/tests/interactive/GOAT_state_closed.md b/tests/interactive/GOAT_state_closed.md index 1ca1cc2..03f1cd2 100644 --- a/tests/interactive/GOAT_state_closed.md +++ b/tests/interactive/GOAT_state_closed.md @@ -146,10 +146,11 @@ res_goat_time = optimize_pulses( }, ) -print('Infidelity: ', res_goat_time.infidelity) -print('Optimized time: ', res_goat_time.optimized_params[-1]) +opt_time = res_goat_time.optimized_params[-1][0] +time_range = times < opt_time -time_range = times < res_goat_time.optimized_params[-1] +print('Infidelity: ', res_goat_time.infidelity) +print('Optimized time: ', opt_time) plt.plot(times, guess_pulse, label='initial guess') plt.plot(times, res_goat.optimized_controls[0], label='optimized pulse') @@ -162,13 +163,16 @@ plt.show() ``` ```python -Hresult = [Hd, [Hc, np.array(res_goat_time.optimized_controls[0])]] -evolution_time = qt.sesolve(Hresult, initial_state, times) +times2 = times[time_range] +if opt_time not in times2: + times2 = np.append(times2, opt_time) + +Hresult = qt.QobjEvo([Hd, [Hc, np.array(res_goat_time.optimized_controls[0])]], tlist=times) +evolution_time = qt.sesolve(Hresult, initial_state, times2) -plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution_time.states], label="Overlap with initial state") -plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution_time.states], label="Overlap with target state") -plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_time.states], '--', label="Fidelity") -plt.xlim(0, res_goat_time.optimized_params[-1][0]) +plt.plot(times2, [np.abs(state.overlap(initial_state)) for state in evolution_time.states], label="Overlap with initial state") +plt.plot(times2, [np.abs(state.overlap(target_state)) for state in evolution_time.states], label="Overlap with target state") +plt.plot(times2, [qt.fidelity(state, target_state) for state in evolution_time.states], '--', label="Fidelity") plt.title('GOAT (optimized over time) performance') plt.xlabel('Time') @@ -196,10 +200,11 @@ res_goat_global = optimize_pulses( } ) -print('Infidelity: ', res_goat_global.infidelity) -print('Optimized time: ', res_goat_global.optimized_params[-1]) +global_time = res_goat_global.optimized_params[-1][0] +global_range = times < global_time -global_range = times < res_goat_global.optimized_params[-1] +print('Infidelity: ', res_goat_global.infidelity) +print('Optimized time: ', global_time) plt.plot(times, guess_pulse, label='initial guess') plt.plot(times, res_goat.optimized_controls[0], label='optimized pulse') @@ -212,13 +217,16 @@ plt.show() ``` ```python -Hresult = [Hd, [Hc, np.array(res_goat_global.optimized_controls[0])]] -evolution_global = qt.sesolve(Hresult, initial_state, times) +times3 = times[global_range] +if global_time not in times3: + times3 = np.append(times3, global_time) + +Hresult = qt.QobjEvo([Hd, [Hc, np.array(res_goat_global.optimized_controls[0])]], tlist=times) +evolution_global = qt.sesolve(Hresult, initial_state, times3) -plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution_global.states], label="Overlap with initial state") -plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution_global.states], label="Overlap with target state") -plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_global.states], '--', label="Fidelity") -plt.xlim(0, res_goat_global.optimized_params[-1][0]) +plt.plot(times3, [np.abs(state.overlap(initial_state)) for state in evolution_global.states], label="Overlap with initial state") +plt.plot(times3, [np.abs(state.overlap(target_state)) for state in evolution_global.states], label="Overlap with target state") +plt.plot(times3, [qt.fidelity(state, target_state) for state in evolution_global.states], '--', label="Fidelity") plt.title('GOAT (global) performance') plt.xlabel('Time') @@ -251,9 +259,9 @@ print('GLobal Fidelity: ', 1 - res_goat_global.infidelity) plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_guess.states], color='blue', label="Guess") plt.plot(times, [qt.fidelity(state, target_state) for state in evolution.states], color='orange', label="GOAT") -plt.plot(times[time_range], [qt.fidelity(state, target_state) for state in evolution_time.states[:len(times[time_range])]], +plt.plot(times2, [qt.fidelity(state, target_state) for state in evolution_time.states], color='green', label="Time") -plt.plot(times[global_range], [qt.fidelity(state, target_state) for state in evolution_global.states[:len(times[global_range])]], +plt.plot(times3, [qt.fidelity(state, target_state) for state in evolution_global.states], color='red', label="Global") plt.title('Fidelities') @@ -273,10 +281,10 @@ assert np.allclose(np.abs(evolution.states[-1].overlap(target_state)), 1 - res_g # target fidelity not reached in part b), check that it is better than part a) assert res_goat_time.infidelity < res_goat.infidelity -assert np.allclose(np.abs(evolution_time.states[len(times[time_range]) - 1].overlap(target_state)), 1 - res_goat_time.infidelity, atol=1e-3) +assert np.allclose(np.abs(evolution_time.states[-1].overlap(target_state)), 1 - res_goat_time.infidelity, atol=1e-3) assert res_goat_global.infidelity < 0.001 -assert np.abs(evolution_global.states[len(times[global_range]) - 1].overlap(target_state)) > 1 - 0.001 +assert np.abs(evolution_global.states[-1].overlap(target_state)) > 1 - 0.001 ``` ```python diff --git a/tests/interactive/JOPT_state_closed.md b/tests/interactive/JOPT_state_closed.md index d532306..ba2cdf6 100644 --- a/tests/interactive/JOPT_state_closed.md +++ b/tests/interactive/JOPT_state_closed.md @@ -150,14 +150,15 @@ res_jopt_time = optimize_pulses( }, ) -print('Infidelity: ', res_jopt_time.infidelity) -print('Optimized time: ', res_jopt_time.optimized_params[-1]) +opt_time = res_jopt_time.optimized_params[-1][0] +time_range = times < opt_time -time_range = times < res_jopt_time.optimized_params[-1] +print('Infidelity: ', res_jopt_time.infidelity) +print('Optimized time: ', opt_time) plt.plot(times, guess_pulse, label='initial guess') plt.plot(times, res_jopt.optimized_controls[0], label='optimized pulse') -plt.plot(times[time_range], np.array(res_jopt.optimized_controls[0])[time_range], label='optimized (over time) pulse') +plt.plot(times[time_range], np.array(res_jopt_time.optimized_controls[0])[time_range], label='optimized (over time) pulse') plt.title('JOPT pulses (time optimization)') plt.xlabel('Time') plt.ylabel('Pulse amplitude') @@ -166,13 +167,16 @@ plt.show() ``` ```python -Hresult = [Hd, [Hc, np.array(res_jopt_time.optimized_controls[0])]] -evolution_time = qt.sesolve(Hresult, initial_state, times) +times2 = times[time_range] +if opt_time not in times2: + times2 = np.append(times2, opt_time) + +Hresult = qt.QobjEvo([Hd, [Hc, np.array(res_jopt_time.optimized_controls[0])]], tlist=times) +evolution_time = qt.sesolve(Hresult, initial_state, times2) -plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution_time.states], label="Overlap with initial state") -plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution_time.states], label="Overlap with target state") -plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_time.states], '--', label="Fidelity") -plt.xlim(0, res_jopt_time.optimized_params[-1][0]) +plt.plot(times2, [np.abs(state.overlap(initial_state)) for state in evolution_time.states], label="Overlap with initial state") +plt.plot(times2, [np.abs(state.overlap(target_state)) for state in evolution_time.states], label="Overlap with target state") +plt.plot(times2, [qt.fidelity(state, target_state) for state in evolution_time.states], '--', label="Fidelity") plt.title('JOPT (optimized over time) performance') plt.xlabel('Time') @@ -200,10 +204,11 @@ res_jopt_global = optimize_pulses( } ) -print('Infidelity: ', res_jopt_global.infidelity) -print('Optimized time: ', res_jopt_global.optimized_params[-1]) +global_time = res_jopt_global.optimized_params[-1][0] +global_range = times < global_time -global_range = times < res_jopt_global.optimized_params[-1] +print('Infidelity: ', res_jopt_global.infidelity) +print('Optimized time: ', global_time) plt.plot(times, guess_pulse, label='initial guess') plt.plot(times, res_jopt.optimized_controls[0], label='optimized pulse') @@ -216,13 +221,16 @@ plt.show() ``` ```python -Hresult = [Hd, [Hc, np.array(res_jopt_global.optimized_controls[0])]] -evolution_global = qt.sesolve(Hresult, initial_state, times) +times3 = times[global_range] +if global_time not in times3: + times3 = np.append(times3, global_time) + +Hresult = qt.QobjEvo([Hd, [Hc, np.array(res_jopt_global.optimized_controls[0])]], tlist=times) +evolution_global = qt.sesolve(Hresult, initial_state, times3) -plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution_global.states], label="Overlap with initial state") -plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution_global.states], label="Overlap with target state") -plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_global.states], '--', label="Fidelity") -plt.xlim(0, res_jopt_global.optimized_params[-1][0]) +plt.plot(times3, [np.abs(state.overlap(initial_state)) for state in evolution_global.states], label="Overlap with initial state") +plt.plot(times3, [np.abs(state.overlap(target_state)) for state in evolution_global.states], label="Overlap with target state") +plt.plot(times3, [qt.fidelity(state, target_state) for state in evolution_global.states], '--', label="Fidelity") plt.title('JOPT (global) performance') plt.xlabel('Time') @@ -255,9 +263,9 @@ print('GLobal Fidelity: ', 1 - res_jopt_global.infidelity) plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_guess.states], color='blue', label="Guess") plt.plot(times, [qt.fidelity(state, target_state) for state in evolution.states], color='orange', label="Goat") -plt.plot(times[time_range], [qt.fidelity(state, target_state) for state in evolution_time.states[:len(times[time_range])]], +plt.plot(times2, [qt.fidelity(state, target_state) for state in evolution_time.states], color='green', label="Time") -plt.plot(times[global_range], [qt.fidelity(state, target_state) for state in evolution_global.states[:len(times[global_range])]], +plt.plot(times3, [qt.fidelity(state, target_state) for state in evolution_global.states], color='red', label="Global") plt.title('Fidelities') @@ -277,10 +285,10 @@ assert np.allclose(np.abs(evolution.states[-1].overlap(target_state)), 1 - res_j # target fidelity not reached in part b), check that it is better than part a) assert res_jopt_time.infidelity < res_jopt.infidelity -assert np.allclose(np.abs(evolution_time.states[len(times[time_range]) - 1].overlap(target_state)), 1 - res_jopt_time.infidelity, atol=1e-3) +assert np.allclose(np.abs(evolution_time.states[-1].overlap(target_state)), 1 - res_jopt_time.infidelity, atol=1e-3) assert res_jopt_global.infidelity < 0.001 -assert np.abs(evolution_global.states[len(times[global_range]) - 1].overlap(target_state)) > 1 - 0.001 +assert np.abs(evolution_global.states[-1].overlap(target_state)) > 1 - 0.001 ``` ```python From 40961509b446d3c157676f3fdde3ada9bc361df4 Mon Sep 17 00:00:00 2001 From: Paul Menczel Date: Fri, 9 May 2025 12:59:53 +0900 Subject: [PATCH 10/17] Finalized gate synthesis notebooks --- tests/interactive/CRAB_gate_closed.md | 81 ++++----- tests/interactive/CRAB_state_closed.md | 2 +- tests/interactive/GOAT_gate_closed.md | 215 ++++++++++++----------- tests/interactive/GOAT_state_closed.md | 14 +- tests/interactive/GRAPE_gate_closed.md | 78 +++++---- tests/interactive/GRAPE_state_closed.md | 2 +- tests/interactive/JOPT_gate_closed.md | 220 +++++++++++++----------- tests/interactive/JOPT_state_closed.md | 14 +- 8 files changed, 334 insertions(+), 292 deletions(-) diff --git a/tests/interactive/CRAB_gate_closed.md b/tests/interactive/CRAB_gate_closed.md index 26b1e4f..ea36556 100644 --- a/tests/interactive/CRAB_gate_closed.md +++ b/tests/interactive/CRAB_gate_closed.md @@ -5,9 +5,9 @@ jupyter: extension: .md format_name: markdown format_version: '1.3' - jupytext_version: 1.16.7 + jupytext_version: 1.17.1 kernelspec: - display_name: qutip-dev + display_name: Python 3 (ipykernel) language: python name: python3 --- @@ -17,77 +17,76 @@ jupyter: ```python import matplotlib.pyplot as plt import numpy as np -from jax import jit, numpy -from qutip import (about, Qobj, gates, qeye, sigmam, sigmax, sigmay, sigmaz, tensor) +from qutip import gates, qeye, sigmax, sigmay, sigmaz import qutip as qt from qutip_qoc import Objective, optimize_pulses + +def fidelity(gate, target_gate): + """ + Fidelity used for unitary gates in qutip-qtrl and qutip-qoc + """ + return np.abs(gate.overlap(target_gate) / target_gate.norm()) ``` ## Problem setup ```python -hbar = 1 omega = 0.1 # energy splitting -delta = 1.0 # tunneling -gamma = 0.1 # amplitude damping sx, sy, sz = sigmax(), sigmay(), sigmaz() -Hd = 1 / 2 * hbar * omega * sz +Hd = 1 / 2 * omega * sz Hc = [sx, sy, sz] H = [Hd, Hc[0], Hc[1], Hc[2]] -initial = qeye(2) -target = Qobj(1 / np.sqrt(2) * np.array([[1, 1], [1, -1]])) +# objective for optimization +initial_gate = qeye(2) +target_gate = gates.hadamard_transform() -times = np.linspace(0, 2*np.pi / 2, 100) +times = np.linspace(0, np.pi / 2, 250) ``` -## CRAB algotihm +## CRAB algorithm ```python n_params = 3 # adjust in steps of 3 -alg_args = {"alg": "CRAB", "fid_err_targ": 0.001} +control_params = { + "ctrl_x": {"guess": [1 for _ in range(n_params)], "bounds": [(-1, 1)] * n_params}, + "ctrl_y": {"guess": [1 for _ in range(n_params)], "bounds": [(-1, 1)] * n_params}, + "ctrl_z": {"guess": [1 for _ in range(n_params)], "bounds": [(-1, 1)] * n_params}, +} res_crab = optimize_pulses( - objectives=Objective(initial, H, target), - control_parameters={ - "ctrl_x": { - "guess": [1 for _ in range(n_params)], - "bounds": [(-1, 1)] * n_params, - }, - "ctrl_y": { - "guess": [1 for _ in range(n_params)], - "bounds": [(-1, 1)] * n_params, - }, - "ctrl_z": { - "guess": [1 for _ in range(n_params)], - "bounds": [(-1, 1)] * n_params, - }, + objectives = Objective(initial_gate, H, target_gate), + control_parameters = control_params, + tlist = times, + algorithm_kwargs = { + "alg": "CRAB", + "fid_err_targ": 0.001 }, - tlist=times, - algorithm_kwargs=alg_args, ) print('Infidelity: ', res_crab.infidelity) -plt.plot(times, res_crab.optimized_controls[0], label='optimized pulse sx') -plt.plot(times, res_crab.optimized_controls[1], label='optimized pulse sy') -plt.plot(times, res_crab.optimized_controls[2], label='optimized pulse sz') -plt.title('CRAB pulse') -plt.xlabel('time') +plt.plot(times, res_crab.optimized_controls[0], 'b', label='optimized pulse sx') +plt.plot(times, res_crab.optimized_controls[1], 'g', label='optimized pulse sy') +plt.plot(times, res_crab.optimized_controls[2], 'r', label='optimized pulse sz') +plt.title('CRAB pulses') +plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() plt.show() ``` ```python -Hresult = [Hd, [Hc[0], res_crab.optimized_controls[0]], [Hc[1], res_crab.optimized_controls[1]], [Hc[2], res_crab.optimized_controls[2]]] -evolution = qt.sesolve(Hresult, initial, times) +H_result = [Hd, [Hc[0], res_crab.optimized_controls[0]], [Hc[1], res_crab.optimized_controls[1]], [Hc[2], res_crab.optimized_controls[2]]] +evolution = qt.sesolve(H_result, initial_gate, times) +plt.plot(times, [fidelity(gate, initial_gate) for gate in evolution.states], label="Overlap with initial gate") +plt.plot(times, [fidelity(gate, target_gate) for gate in evolution.states], label="Overlap with target gate") -plt.plot(times, [np.abs(state.overlap(target) / target.norm()) for state in evolution.states], '--', label="Fidelity") +plt.title('CRAB performance') +plt.xlabel('Time') plt.legend() -plt.title("GRAPE performance") plt.show() ``` @@ -95,13 +94,9 @@ plt.show() ```python assert res_crab.infidelity < 0.001 -assert np.abs(evolution.states[-1].overlap(target) / target.norm()) > 1-0.001 +assert fidelity(evolution.states[-1], target_gate) > 1-0.001 ``` ```python qt.about() ``` - -```python - -``` diff --git a/tests/interactive/CRAB_state_closed.md b/tests/interactive/CRAB_state_closed.md index 7c28c84..278ab21 100644 --- a/tests/interactive/CRAB_state_closed.md +++ b/tests/interactive/CRAB_state_closed.md @@ -17,7 +17,7 @@ jupyter: ```python import matplotlib.pyplot as plt import numpy as np -from qutip import (about, basis, Qobj) +from qutip import basis, Qobj import qutip as qt from qutip_qoc import Objective, optimize_pulses ``` diff --git a/tests/interactive/GOAT_gate_closed.md b/tests/interactive/GOAT_gate_closed.md index a2b990c..f6b3f57 100644 --- a/tests/interactive/GOAT_gate_closed.md +++ b/tests/interactive/GOAT_gate_closed.md @@ -5,9 +5,9 @@ jupyter: extension: .md format_name: markdown format_version: '1.3' - jupytext_version: 1.16.7 + jupytext_version: 1.17.1 kernelspec: - display_name: qutip-dev + display_name: Python 3 (ipykernel) language: python name: python3 --- @@ -17,58 +17,59 @@ jupyter: ```python import matplotlib.pyplot as plt import numpy as np -from jax import jit, numpy -from qutip import (about, Qobj, gates, liouvillian, qeye, sigmam, sigmax, sigmay, sigmaz, tensor) +from qutip import gates, qeye, sigmax, sigmay, sigmaz import qutip as qt from qutip_qoc import Objective, optimize_pulses + +def fidelity(gate, target_gate): + """ + Fidelity used for unitary gates in qutip-qtrl and qutip-qoc + """ + return np.abs(gate.overlap(target_gate) / target_gate.norm()) ``` ## Problem setup ```python -hbar = 1 omega = 0.1 # energy splitting -delta = 1.0 # tunneling -gamma = 0.1 # amplitude damping sx, sy, sz = sigmax(), sigmay(), sigmaz() -Hd = 1 / 2 * hbar * omega * sz +Hd = 1 / 2 * omega * sz Hc = [sx, sy, sz] -H = [Hd, Hc[0], Hc[1], Hc[2]] # objective for optimization -initial = qeye(2) -target = Qobj(1 / np.sqrt(2) * np.array([[1, 1], [1, -1]])) +initial_gate = qeye(2) +target_gate = gates.hadamard_transform() -times = np.linspace(0, 2*np.pi, 100) +times = np.linspace(0, np.pi / 2, 250) ``` ## Guess ```python -guess = [1, 1] -guess_pulse = guess[0] * np.sin(guess[1] * times) +goat_guess = [1, 1] +guess_pulse = goat_guess[0] * np.sin(goat_guess[1] * times) -Hresult_guess = [Hd] + [[hc, guess_pulse] for hc in Hc] -evolution_guess = qt.sesolve(Hresult_guess, initial, times) +H_guess = [Hd] + [[hc, guess_pulse] for hc in Hc] +evolution_guess = qt.sesolve(H_guess, initial_gate, times) -print('Infidelity: ', qt.fidelity(evolution_guess.states[-1], target)) +print('Fidelity: ', fidelity(evolution_guess.states[-1], target_gate)) -plt.plot(times, [np.abs(state.overlap(initial) / initial.norm())**2 for state in evolution_guess.states], label="Overlap with initial state") -plt.plot(times, [np.abs(state.overlap(target) / initial.norm())**2 for state in evolution_guess.states], label="Overlap with target state") -plt.legend() +plt.plot(times, [fidelity(gate, initial_gate) for gate in evolution_guess.states], label="Overlap with initial gate") +plt.plot(times, [fidelity(gate, target_gate) for gate in evolution_guess.states], label="Overlap with target gate") plt.title("Guess performance") +plt.xlabel('Time') +plt.legend() plt.show() ``` ## GOAT algorithm -### a) not optimized over time ```python +# control function def sin(t, c): return c[0] * np.sin(c[1] * t) - # derivatives def grad_sin(t, c, idx): if idx == 0: # w.r.t. c0 @@ -79,20 +80,22 @@ def grad_sin(t, c, idx): return c[0] * np.cos(c[1] * t) * c[1] H = [Hd] + [[hc, sin, {"grad": grad_sin}] for hc in Hc] +``` + +### a) not optimized over time -ctrl_parameters = { - id: {"guess": guess, "bounds": [(-1, 1), (0, 2 * np.pi)]} # c0 and c1 +```python +control_params = { + id: {"guess": goat_guess, "bounds": [(-1, 1), (0, 2 * np.pi)]} # c0 and c1 for id in ['x', 'y', 'z'] } -``` -```python # run the optimization res_goat = optimize_pulses( - objectives=Objective(initial, H, target), - control_parameters=ctrl_parameters, - tlist=times, - algorithm_kwargs={ + objectives = Objective(initial_gate, H, target_gate), + control_parameters = control_params, + tlist = times, + algorithm_kwargs = { "alg": "GOAT", "fid_err_targ": 0.001, }, @@ -100,76 +103,86 @@ res_goat = optimize_pulses( print('Infidelity: ', res_goat.infidelity) -plt.plot(times, res_goat.optimized_controls[0], label='optimized pulse sx') -plt.plot(times, res_goat.optimized_controls[1], label='optimized pulse sy') -plt.plot(times, res_goat.optimized_controls[2], label='optimized pulse sz') -plt.title('GOAT pulse') -plt.xlabel('time') +plt.plot(times, guess_pulse, 'k--', label='guess pulse sx, sy, sz') +plt.plot(times, res_goat.optimized_controls[0], 'b', label='optimized pulse sx') +plt.plot(times, res_goat.optimized_controls[1], 'g', label='optimized pulse sy') +plt.plot(times, res_goat.optimized_controls[2], 'r', label='optimized pulse sz') +plt.title('GOAT pulses') +plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() plt.show() ``` ```python -Hresult = [Hd, [Hc[0], np.array(res_goat.optimized_controls[0])], [Hc[1], np.array(res_goat.optimized_controls[1])], - [Hc[2], np.array(res_goat.optimized_controls[2])]] -evolution = qt.sesolve(Hresult, initial, times) +H_result = [Hd, + [Hc[0], np.array(res_goat.optimized_controls[0])], + [Hc[1], np.array(res_goat.optimized_controls[1])], + [Hc[2], np.array(res_goat.optimized_controls[2])]] +evolution = qt.sesolve(H_result, initial_gate, times) + +plt.plot(times, [fidelity(gate, initial_gate) for gate in evolution.states], label="Overlap with initial gate") +plt.plot(times, [fidelity(gate, target_gate) for gate in evolution.states], label="Overlap with target gate") -plt.plot(times, [np.abs(state.overlap(initial) / initial.norm())**2 for state in evolution.states], label="Overlap with initial state") -plt.plot(times, [np.abs(state.overlap(target) / target.norm())**2 for state in evolution.states], label="Overlap with target state") plt.title('GOAT performance') -plt.xlabel('time') +plt.xlabel('Time') plt.legend() plt.show() - ``` ### b) optimized over time ```python # treats time as optimization variable -ctrl_parameters["__time__"] = { +control_params["__time__"] = { "guess": times[len(times) // 2], "bounds": [times[0], times[-1]], } # run the optimization res_goat_time = optimize_pulses( - objectives=Objective(initial, H, target), - control_parameters=ctrl_parameters, - tlist=times, - algorithm_kwargs={ + objectives = Objective(initial_gate, H, target_gate), + control_parameters = control_params, + tlist = times, + algorithm_kwargs = { "alg": "GOAT", "fid_err_targ": 0.001, }, ) -print('Infidelity: ', res_goat_time.infidelity) -print("time: ", times[-1]) -print('optimized time: ', res_goat_time.optimized_params[-1][0]) - -time_range = times < res_goat_time.optimized_params[-1] +opt_time = res_goat_time.optimized_params[-1][0] +time_range = times < opt_time -plt.plot(times, res_goat.optimized_controls[0], label='optimized pulse') -plt.plot(times[time_range], np.array(res_goat_time.optimized_controls[0])[time_range], label='optimized (over time) pulse') -plt.title('GOAT pulses') -plt.xlabel('time') +print('Infidelity: ', res_goat_time.infidelity) +print('Optimized time: ', opt_time) + +plt.plot(times, guess_pulse, 'k--', label='guess pulse sx, sy, sz') +plt.plot(times[time_range], np.array(res_goat_time.optimized_controls[0])[time_range], 'b', label='optimized pulse sx') +plt.plot(times[time_range], np.array(res_goat_time.optimized_controls[1])[time_range], 'g', label='optimized pulse sy') +plt.plot(times[time_range], np.array(res_goat_time.optimized_controls[2])[time_range], 'r', label='optimized pulse sz') +plt.title('GOAT pulses (time optimization)') +plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() plt.show() ``` ```python -Hresult = [Hd, [Hc[0], np.array(res_goat_time.optimized_controls[0])], [Hc[1], np.array(res_goat_time.optimized_controls[1])], - [Hc[2], np.array(res_goat_time.optimized_controls[2])]] -evolution_time = qt.sesolve(Hresult, initial, times) +times2 = times[time_range] +if opt_time not in times2: + times2 = np.append(times2, opt_time) -plt.plot(times, [np.abs(state.overlap(initial) / initial.norm())**2 for state in evolution_time.states], label="Overlap with initial state") -plt.plot(times, [np.abs(state.overlap(target) / target.norm())**2 for state in evolution_time.states], label="Overlap with target state") -plt.xlim(0, res_goat_time.optimized_params[-1][0]) +H_result = qt.QobjEvo( + [Hd, [Hc[0], np.array(res_goat_time.optimized_controls[0])], + [Hc[1], np.array(res_goat_time.optimized_controls[1])], + [Hc[2], np.array(res_goat_time.optimized_controls[2])]], tlist=times) +evolution_time = qt.sesolve(H_result, initial_gate, times2) + +plt.plot(times2, [fidelity(gate, initial_gate) for gate in evolution_time.states], label="Overlap with initial gate") +plt.plot(times2, [fidelity(gate, target_gate) for gate in evolution_time.states], label="Overlap with target gate") plt.title('GOAT (optimized over time) performance') -plt.xlabel('time') +plt.xlabel('Time') plt.legend() plt.show() ``` @@ -178,45 +191,52 @@ plt.show() ```python res_goat_global = optimize_pulses( - objectives=Objective(initial, H, target), - control_parameters=ctrl_parameters, - tlist=times, - algorithm_kwargs={ + objectives = Objective(initial_gate, H, target_gate), + control_parameters = control_params, + tlist = times, + algorithm_kwargs = { "alg": "GOAT", "fid_err_targ": 0.001, }, - optimizer_kwargs={ + optimizer_kwargs = { "method": "basinhopping", "max_iter": 100, } ) -print('Infidelity: ', res_goat_global.infidelity) -print('optimized time: ', res_goat_global.optimized_params[-1]) - -global_range = times < res_goat_global.optimized_params[-1] +global_time = res_goat_global.optimized_params[-1][0] +global_range = times < global_time -plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[0])[global_range], label='global optimized pulse sx') -plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[1])[global_range], label='global optimized pulse sy') -plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[2])[global_range], label='global optimized pulse sz') -plt.title('GOAT pulses (global)') -plt.xlabel('time') +print('Infidelity: ', res_goat_global.infidelity) +print('Optimized time: ', global_time) + +plt.plot(times, guess_pulse, 'k--', label='guess pulse sx, sy, sz') +plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[0])[global_range], 'b', label='optimized pulse sx') +plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[1])[global_range], 'g', label='optimized pulse sy') +plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[2])[global_range], 'r', label='optimized pulse sz') +plt.title('GOAT pulses (global optimization)') +plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() plt.show() ``` ```python -Hresult = [Hd, [Hc[0], np.array(res_goat_global.optimized_controls[0])], [Hc[1], np.array(res_goat_global.optimized_controls[1])], - [Hc[2], np.array(res_goat_global.optimized_controls[2])]] -evolution_global = qt.sesolve(Hresult, initial, times) +times3 = times[global_range] +if global_time not in times3: + times3 = np.append(times3, global_time) -plt.plot(times, [np.abs(state.overlap(initial) / initial.norm()) for state in evolution_global.states], label="Overlap with initial state") -plt.plot(times, [np.abs(state.overlap(target) / target.norm()) for state in evolution_global.states], label="Overlap with target state") -plt.xlim(0, res_goat_global.optimized_params[-1][0]) +H_result = qt.QobjEvo( + [Hd, [Hc[0], np.array(res_goat_global.optimized_controls[0])], + [Hc[1], np.array(res_goat_global.optimized_controls[1])], + [Hc[2], np.array(res_goat_global.optimized_controls[2])]], tlist=times) +evolution_global = qt.sesolve(H_result, initial_gate, times) -plt.title('GOAT (global) performance') -plt.xlabel('time') +plt.plot(times3, [fidelity(gate, initial_gate) for gate in evolution_global.states], label="Overlap with initial gate") +plt.plot(times3, [fidelity(gate, target_gate) for gate in evolution_global.states], label="Overlap with target gate") + +plt.title('GOAT (global optimization) performance') +plt.xlabel('Time') plt.legend() plt.show() ``` @@ -226,40 +246,35 @@ plt.show() ```python fig, axes = plt.subplots(1, 3, figsize=(18, 4)) # 1 row, 3 columns -titles = ["GOAT s_x pulses", "GOAT s_y pulses", "GOAT s_z pulses"] +titles = ["GOAT sx pulses", "GOAT sy pulses", "GOAT sz pulses"] -for i in range(3): - ax = axes[i] - ax.plot(times, sin(times, guess), label='initial guess') - ax.plot(times, res_goat.optimized_controls[i], color='orange', label='optimized pulse') +for i, ax in enumerate(axes): + ax.plot(times, guess_pulse, label='initial guess') + ax.plot(times, res_goat.optimized_controls[i], label='optimized pulse') ax.plot(times[time_range], np.array(res_goat_time.optimized_controls[i])[time_range], label='optimized (over time) pulse') ax.plot(times[global_range], np.array(res_goat_global.optimized_controls[i])[global_range], label='global optimized pulse') ax.set_title(titles[i]) - ax.set_xlabel('time') + ax.set_xlabel('Time') ax.set_ylabel('Pulse amplitude') ax.legend() plt.tight_layout() plt.show() - ``` ## Validation ```python assert res_goat.infidelity < 0.001 -assert np.abs(evolution.states[-1].overlap(target)) > 1-0.001 +assert fidelity(evolution.states[-1], target_gate) > 1-0.001 + assert res_goat_time.infidelity < 0.001 -assert max([np.abs(state.overlap(target)) for state in evolution_time.states]) > 1-0.001 -assert res_goat_global.infidelity < 0.001 -assert max([np.abs(state.overlap(target)) for state in evolution_global.states]) > 1-0.001 +assert fidelity(evolution_time.states[-1], target_gate) > 1-0.001 +assert res_goat_global.infidelity < 0.001 +assert fidelity(evolution_global.states[-1], target_gate) > 1-0.001 ``` ```python qt.about() ``` - -```python - -``` diff --git a/tests/interactive/GOAT_state_closed.md b/tests/interactive/GOAT_state_closed.md index 03f1cd2..bbce5f2 100644 --- a/tests/interactive/GOAT_state_closed.md +++ b/tests/interactive/GOAT_state_closed.md @@ -17,7 +17,7 @@ jupyter: ```python import matplotlib.pyplot as plt import numpy as np -from qutip import (about, basis, Qobj) +from qutip import basis, Qobj import qutip as qt from qutip_qoc import Objective, optimize_pulses ``` @@ -110,8 +110,8 @@ plt.show() ``` ```python -Hresult = [Hd, [Hc, np.array(res_goat.optimized_controls[0])]] -evolution = qt.sesolve(Hresult, initial_state, times) +H_result = [Hd, [Hc, np.array(res_goat.optimized_controls[0])]] +evolution = qt.sesolve(H_result, initial_state, times) plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution.states], label="Overlap with initial state") plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution.states], label="Overlap with target state") @@ -167,8 +167,8 @@ times2 = times[time_range] if opt_time not in times2: times2 = np.append(times2, opt_time) -Hresult = qt.QobjEvo([Hd, [Hc, np.array(res_goat_time.optimized_controls[0])]], tlist=times) -evolution_time = qt.sesolve(Hresult, initial_state, times2) +H_result = qt.QobjEvo([Hd, [Hc, np.array(res_goat_time.optimized_controls[0])]], tlist=times) +evolution_time = qt.sesolve(H_result, initial_state, times2) plt.plot(times2, [np.abs(state.overlap(initial_state)) for state in evolution_time.states], label="Overlap with initial state") plt.plot(times2, [np.abs(state.overlap(target_state)) for state in evolution_time.states], label="Overlap with target state") @@ -221,8 +221,8 @@ times3 = times[global_range] if global_time not in times3: times3 = np.append(times3, global_time) -Hresult = qt.QobjEvo([Hd, [Hc, np.array(res_goat_global.optimized_controls[0])]], tlist=times) -evolution_global = qt.sesolve(Hresult, initial_state, times3) +H_result = qt.QobjEvo([Hd, [Hc, np.array(res_goat_global.optimized_controls[0])]], tlist=times) +evolution_global = qt.sesolve(H_result, initial_state, times3) plt.plot(times3, [np.abs(state.overlap(initial_state)) for state in evolution_global.states], label="Overlap with initial state") plt.plot(times3, [np.abs(state.overlap(target_state)) for state in evolution_global.states], label="Overlap with target state") diff --git a/tests/interactive/GRAPE_gate_closed.md b/tests/interactive/GRAPE_gate_closed.md index bc1e1f0..bb9b145 100644 --- a/tests/interactive/GRAPE_gate_closed.md +++ b/tests/interactive/GRAPE_gate_closed.md @@ -5,9 +5,9 @@ jupyter: extension: .md format_name: markdown format_version: '1.3' - jupytext_version: 1.16.7 + jupytext_version: 1.17.1 kernelspec: - display_name: qutip-dev + display_name: Python 3 (ipykernel) language: python name: python3 --- @@ -17,45 +17,51 @@ jupyter: ```python import matplotlib.pyplot as plt import numpy as np -from qutip import (about, Qobj, gates, liouvillian, fidelity,basis, qeye, sigmam, sigmax, sigmay, sigmaz, tensor) +from qutip import gates, qeye, sigmax, sigmay, sigmaz import qutip as qt from qutip_qoc import Objective, optimize_pulses + +def fidelity(gate, target_gate): + """ + Fidelity used for unitary gates in qutip-qtrl and qutip-qoc + """ + return np.abs(gate.overlap(target_gate) / target_gate.norm()) ``` ## Problem setup ```python -hbar = 1 omega = 0.1 # energy splitting -delta = 1.0 # tunneling -gamma = 0.1 # amplitude damping sx, sy, sz = sigmax(), sigmay(), sigmaz() -Hd = 1 / 2 * hbar * omega * sz +Hd = 1 / 2 * omega * sz Hc = [sx, sy, sz] H = [Hd, Hc[0], Hc[1], Hc[2]] # objective for optimization initial_gate = qeye(2) -target_gate = Qobj(1 / np.sqrt(2) * np.array([[1, 1], [1, -1]])) +target_gate = gates.hadamard_transform() -times = np.linspace(0, np.pi / 2, 100) +times = np.linspace(0, np.pi / 2, 250) ``` ## Guess ```python -guess = np.sin(times) +guess_pulse_x = np.sin(times) +guess_pulse_y = np.cos(times) +guess_pulse_z = np.tanh(times) -Hresult_guess = [Hd] + [[hc, guess] for hc in Hc] -evolution_guess = qt.sesolve(Hresult_guess, initial_gate, times) +H_guess = [Hd, [Hc[0], guess_pulse_x], [Hc[1], guess_pulse_y], [Hc[2], guess_pulse_z]] +evolution_guess = qt.sesolve(H_guess, initial_gate, times) -print('Fidelity: ', qt.fidelity(evolution_guess.states[-1], target_gate)) +print('Fidelity: ', fidelity(evolution_guess.states[-1], target_gate)) -plt.plot(times, [np.abs(state.overlap(initial_gate) / initial_gate.norm())**2 for state in evolution_guess.states], label="Overlap with initial state") -plt.plot(times, [np.abs(state.overlap(target_gate) / target_gate.norm())**2 for state in evolution_guess.states], label="Overlap with target state") -plt.legend() +plt.plot(times, [fidelity(gate, initial_gate) for gate in evolution_guess.states], label="Overlap with initial gate") +plt.plot(times, [fidelity(gate, target_gate) for gate in evolution_guess.states], label="Overlap with target gate") plt.title("Guess performance") +plt.xlabel('Time') +plt.legend() plt.show() ``` @@ -69,34 +75,40 @@ control_params = { } res_grape = optimize_pulses( - objectives=Objective(initial_gate, H, target_gate), - control_parameters=control_params, - tlist=times, - algorithm_kwargs={"alg": "GRAPE", "fid_err_targ": 0.001}, + objectives = Objective(initial_gate, H, target_gate), + control_parameters = control_params, + tlist = times, + algorithm_kwargs = { + "alg": "GRAPE", + "fid_err_targ": 0.001 + }, ) print('Infidelity: ', res_grape.infidelity) - -plt.plot(times, res_grape.optimized_controls[0], label='optimized pulse sx') -plt.plot(times, res_grape.optimized_controls[1], label='optimized pulse sy') -plt.plot(times, res_grape.optimized_controls[2], label='optimized pulse sz') +plt.plot(times, guess_pulse_x, 'b--', label='guess pulse sx') +plt.plot(times, res_grape.optimized_controls[0], 'b', label='optimized pulse sx') +plt.plot(times, guess_pulse_y, 'g--', label='guess pulse sy') +plt.plot(times, res_grape.optimized_controls[1], 'g', label='optimized pulse sy') +plt.plot(times, guess_pulse_z, 'r--', label='guess pulse sz') +plt.plot(times, res_grape.optimized_controls[2], 'r', label='optimized pulse sz') plt.title('GRAPE pulses') -plt.xlabel('time') +plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() plt.show() ``` ```python -Hresult = [Hd, [Hc[0], res_grape.optimized_controls[0]], [Hc[1], res_grape.optimized_controls[1]], [Hc[2], res_grape.optimized_controls[2]]] -evolution = qt.sesolve(Hresult, initial_gate, times) +H_result = [Hd, [Hc[0], res_grape.optimized_controls[0]], [Hc[1], res_grape.optimized_controls[1]], [Hc[2], res_grape.optimized_controls[2]]] +evolution = qt.sesolve(H_result, initial_gate, times) +plt.plot(times, [fidelity(gate, initial_gate) for gate in evolution.states], label="Overlap with initial gate") +plt.plot(times, [fidelity(gate, target_gate) for gate in evolution.states], label="Overlap with target gate") -plt.plot(times, [np.abs(state.overlap(target_gate) / target_gate.norm())**2 for state in evolution.states], label="target overlap") -plt.plot(times, [np.abs(state.overlap(initial_gate) / initial_gate.norm())**2 for state in evolution.states], label="initial overlap") +plt.title('GRAPE performance') +plt.xlabel('Time') plt.legend() -plt.title("GRAPE performance") plt.show() ``` @@ -104,13 +116,9 @@ plt.show() ```python assert res_grape.infidelity < 0.001 -assert np.abs(evolution.states[-1].overlap(target_gate)) > 1-0.001 +assert fidelity(evolution.states[-1], target_gate) > 1-0.001 ``` ```python qt.about() ``` - -```python - -``` diff --git a/tests/interactive/GRAPE_state_closed.md b/tests/interactive/GRAPE_state_closed.md index 582fe0e..2681df7 100644 --- a/tests/interactive/GRAPE_state_closed.md +++ b/tests/interactive/GRAPE_state_closed.md @@ -17,7 +17,7 @@ jupyter: ```python import matplotlib.pyplot as plt import numpy as np -from qutip import (about, basis, Qobj) +from qutip import basis, Qobj import qutip as qt from qutip_qoc import Objective, optimize_pulses ``` diff --git a/tests/interactive/JOPT_gate_closed.md b/tests/interactive/JOPT_gate_closed.md index 36f947b..ce328bc 100644 --- a/tests/interactive/JOPT_gate_closed.md +++ b/tests/interactive/JOPT_gate_closed.md @@ -17,48 +17,56 @@ jupyter: ```python import matplotlib.pyplot as plt import numpy as np -from jax import jit, numpy -from qutip import (about, Qobj, gates, qeye, sigmam, sigmax, sigmay, sigmaz, fidelity) +from qutip import gates, qeye, sigmax, sigmay, sigmaz import qutip as qt from qutip_qoc import Objective, optimize_pulses + +try: + from jax import jit + from jax import numpy as jnp +except ImportError: # JAX not available, skip test + import pytest + pytest.skip("JAX not available") + +def fidelity(gate, target_gate): + """ + Fidelity used for unitary gates in qutip-qtrl and qutip-qoc + """ + return np.abs(gate.overlap(target_gate) / target_gate.norm()) ``` ## Problem setup ```python -hbar = 1 omega = 0.1 # energy splitting -delta = 1.0 # tunneling -gamma = 0.1 # amplitude damping sx, sy, sz = sigmax(), sigmay(), sigmaz() -Hd = 1 / 2 * hbar * omega * sz +Hd = 1 / 2 * omega * sz Hc = [sx, sy, sz] -H = [Hd, Hc[0], Hc[1], Hc[2]] # objective for optimization -initial = qeye(2) -target = Qobj(1 / np.sqrt(2) * np.array([[1, 1], [1, -1]])) +initial_gate = qeye(2) +target_gate = gates.hadamard_transform() -times = np.linspace(0, 2*np.pi, 100) +times = np.linspace(0, np.pi / 2, 250) ``` ## Guess ```python -guess = [1, 1] -guess_pulse = guess[0] * np.sin(guess[1] * times) +jopt_guess = [1, 1] +guess_pulse = jopt_guess[0] * np.sin(jopt_guess[1] * times) -Hresult_guess = [Hd] + [[hc, guess_pulse] for hc in Hc] -evolution_guess = qt.sesolve(Hresult_guess, initial, times) +H_guess = [Hd] + [[hc, guess_pulse] for hc in Hc] +evolution_guess = qt.sesolve(H_guess, initial_gate, times) -print('Infidelity: ', qt.fidelity(evolution_guess.states[-1], target)) +print('Fidelity: ', fidelity(evolution_guess.states[-1], target_gate)) -plt.plot(times, [np.abs(state.overlap(initial) / initial.norm()) for state in evolution_guess.states], label="Initial Overlap") -plt.plot(times, [np.abs(state.overlap(target) / target.norm()) for state in evolution_guess.states], label="Target Overlap") -plt.plot(times, [qt.fidelity(state, target) for state in evolution_guess.states], '--', label="Fidelity") -plt.legend() +plt.plot(times, [fidelity(gate, initial_gate) for gate in evolution_guess.states], label="Overlap with initial gate") +plt.plot(times, [fidelity(gate, target_gate) for gate in evolution_guess.states], label="Overlap with target gate") plt.title("Guess performance") +plt.xlabel('Time') +plt.legend() plt.show() ``` @@ -67,25 +75,24 @@ plt.show() ```python @jit def sin_x(t, c, **kwargs): - return c[0] * numpy.sin(c[1] * t) + return c[0] * jnp.sin(c[1] * t) H = [Hd] + [[hc, sin_x] for hc in Hc] - -ctrl_parameters = { - id: {"guess": guess, "bounds": [(-1, 1), (0, 2 * np.pi)]} # c0 and c1 - for id in ['x', 'y', 'z'] -} - ``` ### a) not optimized over time ```python +control_params = { + id: {"guess": jopt_guess, "bounds": [(-1, 1), (0, 2 * np.pi)]} # c0 and c1 + for id in ['x', 'y', 'z'] +} + res_jopt = optimize_pulses( - objectives=Objective(initial, H, target), - control_parameters=ctrl_parameters, - tlist=times, - minimizer_kwargs={ + objectives = Objective(initial_gate, H, target_gate), + control_parameters = control_params, + tlist = times, + minimizer_kwargs = { "method": "Nelder-Mead", }, algorithm_kwargs={ @@ -96,47 +103,49 @@ res_jopt = optimize_pulses( print('Infidelity: ', res_jopt.infidelity) -plt.plot(times, res_jopt.optimized_controls[0], label='optimized pulse sx') -plt.plot(times, res_jopt.optimized_controls[1], label='optimized pulse sy') -plt.plot(times, res_jopt.optimized_controls[2], label='optimized pulse sz') +plt.plot(times, guess_pulse, 'k--', label='guess pulse sx, sy, sz') +plt.plot(times, res_jopt.optimized_controls[0], 'b', label='optimized pulse sx') +plt.plot(times, res_jopt.optimized_controls[1], 'g', label='optimized pulse sy') +plt.plot(times, res_jopt.optimized_controls[2], 'r', label='optimized pulse sz') plt.title('JOPT pulses') -plt.xlabel('time') +plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() plt.show() ``` ```python -Hresult = [Hd, [Hc[0], np.array(res_jopt.optimized_controls[0])], [Hc[1], np.array(res_jopt.optimized_controls[1])], - [Hc[2], np.array(res_jopt.optimized_controls[2])]] -evolution = qt.sesolve(Hresult, initial, times) +H_result = [Hd, + [Hc[0], np.array(res_jopt.optimized_controls[0])], + [Hc[1], np.array(res_jopt.optimized_controls[1])], + [Hc[2], np.array(res_jopt.optimized_controls[2])]] +evolution = qt.sesolve(H_result, initial_gate, times) + +plt.plot(times, [fidelity(gate, initial_gate) for gate in evolution.states], label="Overlap with initial gate") +plt.plot(times, [fidelity(gate, target_gate) for gate in evolution.states], label="Overlap with target gate") -plt.plot(times, [np.abs(state.overlap(initial) / initial.norm()) for state in evolution.states], label="Overlap with intiial state") -plt.plot(times, [np.abs(state.overlap(target) / target.norm()) for state in evolution.states], label="Overlap with target state") plt.title('JOPT performance') -plt.xlabel('time') +plt.xlabel('Time') plt.legend() plt.show() - ``` ### b) optimized over time ```python # treats time as optimization variable -ctrl_parameters["__time__"] = { +control_params["__time__"] = { "guess": times[len(times) // 2], "bounds": [times[0], times[-1]], } # run the optimization res_jopt_time = optimize_pulses( - objectives=Objective(initial, H, target), - control_parameters=ctrl_parameters, - tlist=times, - minimizer_kwargs={ + objectives = Objective(initial_gate, H, target_gate), + control_parameters = control_params, + tlist = times, + minimizer_kwargs = { "method": "Nelder-Mead", - }, algorithm_kwargs={ "alg": "JOPT", @@ -144,31 +153,39 @@ res_jopt_time = optimize_pulses( }, ) -print('Infidelity: ', res_jopt_time.infidelity) -print('optimized time: ', res_jopt_time.optimized_params[-1]) - -time_range = times < res_jopt_time.optimized_params[-1] +opt_time = res_jopt_time.optimized_params[-1][0] +time_range = times < opt_time -plt.plot(times, res_jopt_time.optimized_controls[0], label='optimized pulse sx') -plt.plot(times, res_jopt_time.optimized_controls[1], label='optimized pulse sy') -plt.plot(times, res_jopt_time.optimized_controls[2], label='optimized pulse sz') -plt.title('JOPT pulses') -plt.xlabel('time') +print('Infidelity: ', res_jopt_time.infidelity) +print('Optimized time: ', opt_time) + +plt.plot(times, guess_pulse, 'k--', label='guess pulse sx, sy, sz') +plt.plot(times[time_range], np.array(res_jopt_time.optimized_controls[0])[time_range], 'b', label='optimized pulse sx') +plt.plot(times[time_range], np.array(res_jopt_time.optimized_controls[1])[time_range], 'g', label='optimized pulse sy') +plt.plot(times[time_range], np.array(res_jopt_time.optimized_controls[2])[time_range], 'r', label='optimized pulse sz') +plt.title('JOPT pulses (time optimization)') +plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() plt.show() ``` ```python -Hresult = [Hd, [Hc[0], np.array(res_jopt_time.optimized_controls[0])], [Hc[1], np.array(res_jopt_time.optimized_controls[1])], - [Hc[2], np.array(res_jopt_time.optimized_controls[2])]] -evolution_time = qt.sesolve(Hresult, initial, times) +times2 = times[time_range] +if opt_time not in times2: + times2 = np.append(times2, opt_time) + +H_result = qt.QobjEvo( + [Hd, [Hc[0], np.array(res_jopt_time.optimized_controls[0])], + [Hc[1], np.array(res_jopt_time.optimized_controls[1])], + [Hc[2], np.array(res_jopt_time.optimized_controls[2])]], tlist=times) +evolution_time = qt.sesolve(H_result, initial_gate, times2) + +plt.plot(times2, [fidelity(gate, initial_gate) for gate in evolution_time.states], label="Overlap with initial gate") +plt.plot(times2, [fidelity(gate, target_gate) for gate in evolution_time.states], label="Overlap with target gate") -plt.plot(times, [np.abs(state.overlap(initial) / initial.norm()) for state in evolution_time.states], label="Overlap with initial state") -plt.plot(times, [np.abs(state.overlap(target) / target.norm()) for state in evolution_time.states], label="Overlap with target state") -plt.xlim(0, res_jopt_time.optimized_params[-1][0]) plt.title('JOPT (optimized over time) performance') -plt.xlabel('time') +plt.xlabel('Time') plt.legend() plt.show() ``` @@ -177,45 +194,52 @@ plt.show() ```python res_jopt_global = optimize_pulses( - objectives=Objective(initial, H, target), - control_parameters=ctrl_parameters, - tlist=times, - algorithm_kwargs={ + objectives = Objective(initial_gate, H, target_gate), + control_parameters = control_params, + tlist = times, + algorithm_kwargs = { "alg": "JOPT", "fid_err_targ": 0.001, }, - optimizer_kwargs={ + optimizer_kwargs = { "method": "basinhopping", - "max_iter": 1000, + "max_iter": 100, } ) -print('Infidelity: ', res_jopt_global.infidelity) -print('optimized time: ', res_jopt_global.optimized_params[-1]) - -global_range = times < res_jopt_global.optimized_params[-1] +global_time = res_jopt_global.optimized_params[-1][0] +global_range = times < global_time -plt.plot(times, res_jopt_global.optimized_controls[0], label='optimized pulse sx') -plt.plot(times, res_jopt_global.optimized_controls[1], label='optimized pulse sy') -plt.plot(times, res_jopt_global.optimized_controls[2], label='optimized pulse sz') -plt.title('JOPT pulses (global)') -plt.xlabel('time') +print('Infidelity: ', res_jopt_global.infidelity) +print('Optimized time: ', global_time) + +plt.plot(times, guess_pulse, 'k--', label='guess pulse sx, sy, sz') +plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[0])[global_range], 'b', label='optimized pulse sx') +plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[1])[global_range], 'g', label='optimized pulse sy') +plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[2])[global_range], 'r', label='optimized pulse sz') +plt.title('JOPT pulses (global optimization)') +plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() plt.show() - ``` ```python -Hresult = [Hd, [Hc[0], np.array(res_jopt_global.optimized_controls[0])], [Hc[1], np.array(res_jopt_global.optimized_controls[1])], - [Hc[2], np.array(res_jopt_global.optimized_controls[2])]] -evolution_global = qt.sesolve(Hresult, initial, times) - -plt.plot(times, [np.abs(state.overlap(initial) / initial.norm()) for state in evolution_global.states], label="Overlap with initial state") -plt.plot(times, [np.abs(state.overlap(target) / target.norm()) for state in evolution_global.states], label="Overlap with target state") -plt.xlim(0, res_jopt_global.optimized_params[-1][0]) -plt.title('JOPT (global) performance') -plt.xlabel('time') +times3 = times[global_range] +if global_time not in times3: + times3 = np.append(times3, global_time) + +H_result = qt.QobjEvo( + [Hd, [Hc[0], np.array(res_jopt_global.optimized_controls[0])], + [Hc[1], np.array(res_jopt_global.optimized_controls[1])], + [Hc[2], np.array(res_jopt_global.optimized_controls[2])]], tlist=times) +evolution_global = qt.sesolve(H_result, initial_gate, times) + +plt.plot(times3, [fidelity(gate, initial_gate) for gate in evolution_global.states], label="Overlap with initial gate") +plt.plot(times3, [fidelity(gate, target_gate) for gate in evolution_global.states], label="Overlap with target gate") + +plt.title('JOPT (global optimization) performance') +plt.xlabel('Time') plt.legend() plt.show() ``` @@ -225,12 +249,11 @@ plt.show() ```python fig, axes = plt.subplots(1, 3, figsize=(18, 4)) # 1 row, 3 columns -titles = ["JOPT s_x pulses", "JOPT s_y pulses", "JOPT s_z pulses"] +titles = ["JOPT sx pulses", "JOPT sy pulses", "JOPT sz pulses"] -for i in range(3): - ax = axes[i] - ax.plot(times, sin_x(times, guess), label='initial guess') - ax.plot(times, res_jopt.optimized_controls[i], color='orange', label='optimized pulse') +for i, ax in enumerate(axes): + ax.plot(times, guess_pulse, label='initial guess') + ax.plot(times, res_jopt.optimized_controls[i], label='optimized pulse') ax.plot(times[time_range], np.array(res_jopt_time.optimized_controls[i])[time_range], label='optimized (over time) pulse') ax.plot(times[global_range], np.array(res_jopt_global.optimized_controls[i])[global_range], label='global optimized pulse') ax.set_title(titles[i]) @@ -240,18 +263,19 @@ for i in range(3): plt.tight_layout() plt.show() - ``` ## Validation ```python -assert res_jopt.infidelity < 0.02 -assert np.abs(evolution.states[-1].overlap(target)) > 1-0.02 +assert res_jopt.infidelity < 0.001 +assert fidelity(evolution.states[-1], target_gate) > 1-0.001 + assert res_jopt_time.infidelity < 0.001 -assert max([np.abs(state.overlap(target)) for state in evolution_time.states]) > 1-0.001 +assert fidelity(evolution_time.states[-1], target_gate) > 1-0.001 + assert res_jopt_global.infidelity < 0.001 -assert max([np.abs(state.overlap(target)) for state in evolution_global.states]) > 1-0.001 +assert fidelity(evolution_global.states[-1], target_gate) > 1-0.001 ``` ```python diff --git a/tests/interactive/JOPT_state_closed.md b/tests/interactive/JOPT_state_closed.md index ba2cdf6..11547cb 100644 --- a/tests/interactive/JOPT_state_closed.md +++ b/tests/interactive/JOPT_state_closed.md @@ -18,7 +18,7 @@ jupyter: ```python import matplotlib.pyplot as plt import numpy as np -from qutip import (about, basis, Qobj) +from qutip import basis, Qobj import qutip as qt from qutip_qoc import Objective, optimize_pulses @@ -111,8 +111,8 @@ plt.show() ``` ```python -Hresult = [Hd, [Hc, np.array(res_jopt.optimized_controls[0])]] -evolution = qt.sesolve(Hresult, initial_state, times) +H_result = [Hd, [Hc, np.array(res_jopt.optimized_controls[0])]] +evolution = qt.sesolve(H_result, initial_state, times) plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution.states], label="Overlap with initial state") plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution.states], label="Overlap with target state") @@ -171,8 +171,8 @@ times2 = times[time_range] if opt_time not in times2: times2 = np.append(times2, opt_time) -Hresult = qt.QobjEvo([Hd, [Hc, np.array(res_jopt_time.optimized_controls[0])]], tlist=times) -evolution_time = qt.sesolve(Hresult, initial_state, times2) +H_result = qt.QobjEvo([Hd, [Hc, np.array(res_jopt_time.optimized_controls[0])]], tlist=times) +evolution_time = qt.sesolve(H_result, initial_state, times2) plt.plot(times2, [np.abs(state.overlap(initial_state)) for state in evolution_time.states], label="Overlap with initial state") plt.plot(times2, [np.abs(state.overlap(target_state)) for state in evolution_time.states], label="Overlap with target state") @@ -225,8 +225,8 @@ times3 = times[global_range] if global_time not in times3: times3 = np.append(times3, global_time) -Hresult = qt.QobjEvo([Hd, [Hc, np.array(res_jopt_global.optimized_controls[0])]], tlist=times) -evolution_global = qt.sesolve(Hresult, initial_state, times3) +H_result = qt.QobjEvo([Hd, [Hc, np.array(res_jopt_global.optimized_controls[0])]], tlist=times) +evolution_global = qt.sesolve(H_result, initial_state, times3) plt.plot(times3, [np.abs(state.overlap(initial_state)) for state in evolution_global.states], label="Overlap with initial state") plt.plot(times3, [np.abs(state.overlap(target_state)) for state in evolution_global.states], label="Overlap with target state") From e4d18449bd6399f7bfbb324b987cab5ddd728093 Mon Sep 17 00:00:00 2001 From: Paul Menczel Date: Fri, 9 May 2025 13:14:11 +0900 Subject: [PATCH 11/17] Added about file for interactive notebooks --- tests/interactive/about.md | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 tests/interactive/about.md diff --git a/tests/interactive/about.md b/tests/interactive/about.md new file mode 100644 index 0000000..9d22894 --- /dev/null +++ b/tests/interactive/about.md @@ -0,0 +1,21 @@ +This directory contains notebooks showcasing the use of all algorithms contained within `QuTiP-QOC`. +The examples are chosen as simple as possible, for the purpose of demonstrating how to use `QuTiP-QOC` in all of these scenarios, and for the purpose of automatically testing `QuTiP-QOC`'s basic functionality in all of these scenarios. +The included algorithms are: +- GRAPE +- CRAB +- GOAT +- JOPT + +For each algorithm, we have: +- a closed-system state transfer example +- an open-system state transfer example +- a closed-system gate synthesis example +- an open-system gate synthesis example + +The notebooks are included automatically in runs of the test suite (see `test_interactive.py`). + +To view and run the notebooks manually, the `jupytext` package is required. +The notebooks can then either be opened from within Jupyter Notebook using "Open With" -> "Jupytext Notebook", or by converting them first to the `ipynb` format using +``` +jupytext --to ipynb [notebook name].nb +``` \ No newline at end of file From 8dbabdd7163e087206051f374bbdee61a5e356da Mon Sep 17 00:00:00 2001 From: Paul Menczel Date: Fri, 9 May 2025 13:25:39 +0900 Subject: [PATCH 12/17] Fixed test again --- tests/test_interactive.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/tests/test_interactive.py b/tests/test_interactive.py index 39b69c2..0961db0 100644 --- a/tests/test_interactive.py +++ b/tests/test_interactive.py @@ -15,7 +15,9 @@ # Set of all example notebooks NOTEBOOK_DIR = 'tests/interactive' ALL_NOTEBOOKS = { - Path(x).name for x in glob.glob(str(Path(NOTEBOOK_DIR).joinpath('*.md'))) + Path(x).name + for x in glob.glob(str(Path(NOTEBOOK_DIR).joinpath('*.md'))) + if Path(x).name != 'about.md' } @pytest.mark.parametrize("notebook", ALL_NOTEBOOKS) From 80337c8b4e8b8806d2cfa5c706dbd95c171cc17b Mon Sep 17 00:00:00 2001 From: Paul Menczel Date: Fri, 9 May 2025 13:39:12 +0900 Subject: [PATCH 13/17] Bugfix --- tests/interactive/GOAT_gate_closed.md | 2 +- tests/interactive/JOPT_gate_closed.md | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/interactive/GOAT_gate_closed.md b/tests/interactive/GOAT_gate_closed.md index f6b3f57..4eafa97 100644 --- a/tests/interactive/GOAT_gate_closed.md +++ b/tests/interactive/GOAT_gate_closed.md @@ -230,7 +230,7 @@ H_result = qt.QobjEvo( [Hd, [Hc[0], np.array(res_goat_global.optimized_controls[0])], [Hc[1], np.array(res_goat_global.optimized_controls[1])], [Hc[2], np.array(res_goat_global.optimized_controls[2])]], tlist=times) -evolution_global = qt.sesolve(H_result, initial_gate, times) +evolution_global = qt.sesolve(H_result, initial_gate, times3) plt.plot(times3, [fidelity(gate, initial_gate) for gate in evolution_global.states], label="Overlap with initial gate") plt.plot(times3, [fidelity(gate, target_gate) for gate in evolution_global.states], label="Overlap with target gate") diff --git a/tests/interactive/JOPT_gate_closed.md b/tests/interactive/JOPT_gate_closed.md index ce328bc..1f3370c 100644 --- a/tests/interactive/JOPT_gate_closed.md +++ b/tests/interactive/JOPT_gate_closed.md @@ -233,7 +233,7 @@ H_result = qt.QobjEvo( [Hd, [Hc[0], np.array(res_jopt_global.optimized_controls[0])], [Hc[1], np.array(res_jopt_global.optimized_controls[1])], [Hc[2], np.array(res_jopt_global.optimized_controls[2])]], tlist=times) -evolution_global = qt.sesolve(H_result, initial_gate, times) +evolution_global = qt.sesolve(H_result, initial_gate, times3) plt.plot(times3, [fidelity(gate, initial_gate) for gate in evolution_global.states], label="Overlap with initial gate") plt.plot(times3, [fidelity(gate, target_gate) for gate in evolution_global.states], label="Overlap with target gate") From 14d5d55176b31c778a343df6396ce73b2ceca361 Mon Sep 17 00:00:00 2001 From: Julian Seither Date: Thu, 15 May 2025 16:17:43 +0900 Subject: [PATCH 14/17] Initial commit: open system interactive notebooks --- tests/interactive/CRAB_gate_open.md | 123 +++++++++++ tests/interactive/CRAB_state_open.md | 107 ++++++++++ tests/interactive/GOAT_gate_open.md | 297 ++++++++++++++++++++++++++ tests/interactive/GOAT_state_open.md | 295 +++++++++++++++++++++++++ tests/interactive/GRAPE_gate_open.md | 122 +++++++++++ tests/interactive/GRAPE_state_open.md | 124 +++++++++++ tests/interactive/JOPT_gate_open.md | 289 +++++++++++++++++++++++++ tests/interactive/JOPT_state_open.md | 273 +++++++++++++++++++++++ 8 files changed, 1630 insertions(+) create mode 100644 tests/interactive/CRAB_gate_open.md create mode 100644 tests/interactive/CRAB_state_open.md create mode 100644 tests/interactive/GOAT_gate_open.md create mode 100644 tests/interactive/GOAT_state_open.md create mode 100644 tests/interactive/GRAPE_gate_open.md create mode 100644 tests/interactive/GRAPE_state_open.md create mode 100644 tests/interactive/JOPT_gate_open.md create mode 100644 tests/interactive/JOPT_state_open.md diff --git a/tests/interactive/CRAB_gate_open.md b/tests/interactive/CRAB_gate_open.md new file mode 100644 index 0000000..84fd0d0 --- /dev/null +++ b/tests/interactive/CRAB_gate_open.md @@ -0,0 +1,123 @@ +--- +jupyter: + jupytext: + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.16.7 + kernelspec: + display_name: qutip-dev + language: python + name: python3 +--- + +# CRAB algorithm + +```python +import matplotlib.pyplot as plt +import numpy as np +from qutip import (about, Qobj, gates, liouvillian, qeye, sigmam, sigmax, sigmay, sigmaz, tensor) +import qutip as qt +from qutip_qoc import Objective, optimize_pulses +``` + +## Problem setup + +```python +hbar = 1 +omega = 0.1 # energy splitting +delta = 1.0 # tunneling +gamma = 0.1 # amplitude damping +sx, sy, sz = sigmax(), sigmay(), sigmaz() +c_ops = [np.sqrt(gamma) * sigmam()] + +Hd = 1 / 2 * hbar * omega * sz +Hd = liouvillian(H=Hd, c_ops=c_ops) +Hc = [liouvillian(sx), liouvillian(sy), liouvillian(sz)] +H = [Hd, Hc[0], Hc[1], Hc[2]] + +initial_gate = qeye(2) +target_gate = Qobj(1 / np.sqrt(2) * np.array([[1, 1], [1, -1]])) + +times = np.linspace(0, np.pi / 2, 250) +``` + +## Crab algorithm + +```python +n_params = 6 # adjust in steps of 3 +control_params = { + "ctrl_x": { + "guess": [1 for _ in range(n_params)], + "bounds": [(-1, 1)] * n_params, + }, + "ctrl_y": { + "guess": [1 for _ in range(n_params)], + "bounds": [(-1, 1)] * n_params, + }, + "ctrl_z": { + "guess": [1 for _ in range(n_params)], + "bounds": [(-1, 1)] * n_params, + }, +} +alg_args = {"alg": "CRAB", "fid_err_targ": 0.01} + + +res_crab = optimize_pulses( + objectives=Objective(initial_gate, H, target_gate), + control_parameters=control_params, + tlist=times, + algorithm_kwargs=alg_args, +) + +print('Infidelity: ', res_crab.infidelity) + +plt.plot(times, res_crab.optimized_controls[0], label='optimized pulse sx') +plt.plot(times, res_crab.optimized_controls[1], label='optimized pulse sy') +plt.plot(times, res_crab.optimized_controls[2], label='optimized pulse sz') +plt.title('CRAB pulse') +plt.xlabel('Time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +```python +H_result = [Hd, + [Hc[0], res_crab.optimized_controls[0]], + [Hc[1], res_crab.optimized_controls[1]], + [Hc[2], res_crab.optimized_controls[2]]] + + +identity_op = qt.qeye(2) +identity_super = qt.spre(identity_op) + +evolution = qt.mesolve(H_result, identity_super, times) + +target_super = qt.to_super(target_gate) +initial_super = qt.to_super(initial_gate) + +initial_overlaps = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution.states] +target_overlaps = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution.states] + +plt.plot(times, initial_overlaps, label="Overlap with initial gate") +plt.plot(times, target_overlaps, label="Overlap with target gate") +plt.title("CRAB performance") +plt.xlabel("Time") +plt.legend() +plt.show() + +``` + +## Validation + +```python +assert res_crab.infidelity < 0.1 +``` + +```python +qt.about() +``` + + diff --git a/tests/interactive/CRAB_state_open.md b/tests/interactive/CRAB_state_open.md new file mode 100644 index 0000000..cd80cab --- /dev/null +++ b/tests/interactive/CRAB_state_open.md @@ -0,0 +1,107 @@ +--- +jupyter: + jupytext: + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.16.7 + kernelspec: + display_name: qutip-dev + language: python + name: python3 +--- + +# GRAPE algorithm for 2 level system + +```python +import matplotlib.pyplot as plt +import numpy as np +from qutip import (about, fidelity, liouvillian, ket2dm, Qobj, basis, sigmam) +import qutip as qt +from qutip_qoc import Objective, optimize_pulses +``` + +## Problem setup + +```python +# Energy levels +E1, E2 = 1.0, 2.0 + +hbar = 1 +omega = 0.1 # energy splitting +delta = 1.0 # tunneling +gamma = 0.1 # amplitude damping +c_ops = [np.sqrt(gamma) * sigmam()] + +Hd = Qobj(np.diag([E1, E2])) +Hd = liouvillian(H=Hd, c_ops=c_ops) +Hc = Qobj(np.array([ + [0, 1], + [1, 0] +])) +Hc = liouvillian(Hc) +H = [Hd, Hc] + + +initial_state = ket2dm(basis(2, 0)) +target_state = ket2dm(basis(2, 1)) + +times = np.linspace(0, 2 * np.pi, 250) +``` + +## CRAB algorithm + +```python +n_params = 6 # adjust in steps of 3 +control_params = { + "ctrl_x": { + "guess": [1 for _ in range(n_params)], + "bounds": [(-1, 1)] * n_params, + }, +} +alg_args = {"alg": "CRAB", "fid_err_targ": 0.001, "fix_frequency": False} + +res_crab = optimize_pulses( + objectives=Objective(initial_state, H, target_state), + control_parameters=control_params, + tlist=times, + algorithm_kwargs=alg_args, +) + +print('Infidelity: ', res_crab.infidelity) + +plt.plot(times, res_crab.optimized_controls[0], label='optimized pulse') +plt.title('CRAB pulse') +plt.xlabel('Time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +```python +H_result = [Hd, [Hc, res_crab.optimized_controls[0]]] +evolution = qt.mesolve(H_result, initial_state, times, c_ops) + +plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution.states], label="Overlap with target state") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution.states], '--', label="Fidelity") +plt.title("CRAB performance") +plt.xlabel('Time') +plt.legend() +plt.show() +``` + +## Validation + +```python +assert res_crab.infidelity < 0.01 +``` + +```python +qt.about() +``` + +```python + +``` diff --git a/tests/interactive/GOAT_gate_open.md b/tests/interactive/GOAT_gate_open.md new file mode 100644 index 0000000..3a4e8ce --- /dev/null +++ b/tests/interactive/GOAT_gate_open.md @@ -0,0 +1,297 @@ +--- +jupyter: + jupytext: + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.16.7 + kernelspec: + display_name: qutip-dev + language: python + name: python3 +--- + +# GOAT algorithm + +```python +import matplotlib.pyplot as plt +import numpy as np +from jax import jit, numpy +from qutip import (about, Qobj, gates, liouvillian, qeye, sigmam, sigmax, sigmay, sigmaz, tensor) +import qutip as qt +from qutip_qoc import Objective, optimize_pulses +``` + +## Problem setup + +```python +hbar = 1 +omega = 0.1 # energy splitting +delta = 1.0 # tunneling +gamma = 0.1 # amplitude damping +sx, sy, sz = sigmax(), sigmay(), sigmaz() + +Hd = 1 / 2 * hbar * omega * sz +Hd = liouvillian(H=Hd, c_ops=[np.sqrt(gamma) * sigmam()]) +Hc = [liouvillian(sx), liouvillian(sy), liouvillian(sz)] + +H = [Hd, Hc[0], Hc[1], Hc[2]] + +# objective for optimization +initial_gate = qeye(2) +target_gate = Qobj(1 / np.sqrt(2) * np.array([[1, 1], [1, -1]])) + +times = np.linspace(0, np.pi / 2, 250) +``` + +## Guess + +```python +goat_guess = [1, 1] +guess_pulse = goat_guess[0] * np.sin(goat_guess[1] * times) +``` + +## Goat algorithm +### a) not optimized over time + +```python +# control function +def sin(t, c): + return c[0] * np.sin(c[1] * t) + + +# derivatives +def grad_sin(t, c, idx): + if idx == 0: # w.r.t. c0 + return np.sin(c[1] * t) + if idx == 1: # w.r.t. c1 + return c[0] * np.cos(c[1] * t) * t + if idx == 2: # w.r.t. time + return c[0] * np.cos(c[1] * t) * c[1] + +H = [Hd] + [[hc, sin, {"grad": grad_sin}] for hc in Hc] + +``` + +```python +ctrl_params = { + id: {"guess": goat_guess, "bounds": [(-1, 1), (0, 2 * np.pi)]} # c0 and c1 + for id in ['x', 'y', 'z'] +} +alg_args = { + "alg": "GOAT", + "fid_err_targ": 0.001, +} + +# run the optimization +res_goat = optimize_pulses( + objectives = Objective(initial_gate, H, target_gate), + control_parameters = ctrl_params, + tlist = times, + algorithm_kwargs = alg_args, +) + +print('Infidelity: ', res_goat.infidelity) + +plt.plot(times, res_goat.optimized_controls[0], label='optimized pulse') +plt.plot(times, res_goat.optimized_controls[1], label='optimized pulse') +plt.plot(times, res_goat.optimized_controls[2], label='optimized pulse') +plt.title('GOAT pulse') +plt.xlabel('Time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +```python +H_result = [Hd, + [Hc[0], np.array(res_goat.optimized_controls[0])], + [Hc[1], np.array(res_goat.optimized_controls[1])], + [Hc[2], np.array(res_goat.optimized_controls[2])]] + + +identity_op = qt.qeye(2) +identity_super = qt.spre(identity_op) + +evolution = qt.mesolve(H_result, identity_super, times) + +target_super = qt.to_super(target_gate) +initial_super = qt.to_super(initial_gate) + +initial_overlaps = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution.states] +target_overlaps = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution.states] + +plt.plot(times, initial_overlaps, label="Overlap with initial gate") +plt.plot(times, target_overlaps, label="Overlap with target gate") +plt.title("GOAT performance") +plt.xlabel("global") +plt.legend() +plt.show() + +``` + +### b) optimized over global + +```python +# treats time as optimization variable +ctrl_params["__time__"] = { + "guess": times[len(times) // 2], + "bounds": [times[0], times[-1]], +} +alg_args = { + "alg": "GOAT", + "fid_err_targ": 0.001, +} + +# run the optimization +res_goat_time = optimize_pulses( + objectives = Objective(initial_gate, H, target_gate), + control_parameters = ctrl_params, + tlist = times, + algorithm_kwargs = alg_args, +) + +time_time = res_goat_time.optimized_params[-1] +time_range = times < time_time + +print('Infidelity: ', res_goat_time.infidelity) +print("Time: ", times[-1]) +print('Optimized time: ', res_goat_time.optimized_params[-1][0]) + +plt.plot(times[time_range], np.array(res_goat_time.optimized_controls[0])[time_range], label='optimized (over time) pulse sx') +plt.plot(times[time_range], np.array(res_goat_time.optimized_controls[1])[time_range], label='optimized (over time) pulse sy') +plt.plot(times[time_range], np.array(res_goat_time.optimized_controls[2])[time_range], label='optimized (over time) pulse sz') +plt.title('GOAT pulses') +plt.xlabel('Time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +```python +H_result = [Hd, + [Hc[0], np.array(res_goat_time.optimized_controls[0])], + [Hc[1], np.array(res_goat_time.optimized_controls[1])], + [Hc[2], np.array(res_goat_time.optimized_controls[2])]] + + +identity_op = qt.qeye(2) +identity_super = qt.spre(identity_op) + +evolution_time = qt.mesolve(H_result, identity_super, times) + +target_super = qt.to_super(target_gate) +initial_super = qt.to_super(initial_gate) + +initial_overlaps = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution_time.states] +target_overlaps = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution_time.states] + +plt.plot(times, initial_overlaps, label="Overlap with initial gate") +plt.plot(times, target_overlaps, label="Overlap with target gate") +plt.title("GOAT performance (optimized over time)") +plt.xlabel("Time") +plt.legend() +plt.show() + +``` + +## Global optimization + +```python +alg_args = { + "alg": "GOAT", + "fid_err_targ": 0.1, +} +opt_args = { + "method": "basinhopping", + "max_iter": 100, +} + +res_goat_global = optimize_pulses( + objectives=Objective(initial_gate, H, target_gate), + control_parameters = ctrl_params, + tlist = times, + algorithm_kwargs = alg_args, + optimizer_kwargs = opt_args +) + +global_time = res_goat_global.optimized_params[-1] +global_range = times < global_time + +print('Infidelity: ', res_goat_global.infidelity) +print('optimized time: ', res_goat_global.optimized_params[-1]) + +plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[0])[global_range], label='global optimized pulse sx') +plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[1])[global_range], label='global optimized pulse sy') +plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[2])[global_range], label='global optimized pulse sz') +plt.title('GOAT pulses (global)') +plt.xlabel('time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +```python +H_result = [Hd, + [Hc[0], np.array(res_goat_global.optimized_controls[0])], + [Hc[1], np.array(res_goat_global.optimized_controls[1])], + [Hc[2], np.array(res_goat_global.optimized_controls[2])]] + + +identity_op = qt.qeye(2) +identity_super = qt.spre(identity_op) + +evolution_global = qt.mesolve(H_result, identity_super, times) + +target_super = qt.to_super(target_gate) +initial_super = qt.to_super(initial_gate) + +initial_overlaps = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution_global.states] +target_overlaps = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution_global.states] + +plt.plot(times, initial_overlaps, label="Overlap with initial gate") +plt.plot(times, target_overlaps, label="Overlap with target gate") +plt.title("GOAT (global) performance") +plt.xlabel("Time") +plt.legend() +plt.show() + +``` + +## Comparison + +```python +fig, axes = plt.subplots(1, 3, figsize=(18, 4)) # 1 row, 3 columns + +titles = ["GOAT s_x pulses", "GOAT s_y pulses", "GOAT s_z pulses"] + +for i in range(3): + ax = axes[i] + ax.plot(times, sin(times, goat_guess), 'k--', label='initial guess') + ax.plot(times, res_goat.optimized_controls[i], color='orange', label='optimized pulse') + ax.plot(times[time_range], np.array(res_goat_time.optimized_controls[i])[time_range], label='optimized (over time) pulse') + ax.plot(times[global_range], np.array(res_goat_global.optimized_controls[i])[global_range], label='global optimized pulse') + ax.set_title(titles[i]) + ax.set_xlabel('time') + ax.set_ylabel('Pulse amplitude') + ax.legend() + +plt.tight_layout() +plt.show() + +``` + +## Validation + +```python +assert res_goat.infidelity < 0.1 +assert res_goat_time.infidelity < 0.1 +assert res_goat_global.infidelity < 0.01 +``` + +```python +qt.about() +``` + + diff --git a/tests/interactive/GOAT_state_open.md b/tests/interactive/GOAT_state_open.md new file mode 100644 index 0000000..352b658 --- /dev/null +++ b/tests/interactive/GOAT_state_open.md @@ -0,0 +1,295 @@ +--- +jupyter: + jupytext: + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.16.7 + kernelspec: + display_name: qutip-dev + language: python + name: python3 +--- + +# GOAT algorithm for a 2 level system + +```python +import matplotlib.pyplot as plt +import numpy as np +from qutip import (fidelity, liouvillian, ket2dm, Qobj, basis, sigmam) +import qutip as qt +from qutip_qoc import Objective, optimize_pulses +``` + +## Problem setup + +```python +# Energy levels +E1, E2 = 1.0, 2.0 + +hbar = 1 +omega = 0.1 # energy splitting +delta = 1.0 # tunneling +gamma = 0.1 # amplitude damping +c_ops = [np.sqrt(gamma) * sigmam()] + +Hd = Qobj(np.diag([E1, E2])) +Hd = liouvillian(H=Hd, c_ops=c_ops) +Hc = Qobj(np.array([ + [0, 1], + [1, 0] +])) +Hc = liouvillian(Hc) +H = [Hd, Hc] + +initial_state = ket2dm(basis(2, 0)) +target_state = ket2dm(basis(2, 1)) + +times = np.linspace(0, 2 * np.pi, 250) +``` + +## Guess + +```python +goat_guess = [1, 0.5] +guess_pulse = goat_guess[0] * np.sin(goat_guess[1] * times) + +H_result_guess = [Hd, [Hc, guess_pulse]] +evolution_guess = qt.mesolve(H_result_guess, initial_state, times, c_ops) + +print('Fidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) + +plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution_guess.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution_guess.states], label="Overlap with target state") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_guess.states], '--', label="Fidelity") +plt.legend() +plt.title("Guess performance") +plt.xlabel("Time") +plt.show() +``` + +## GOAT algorithm + +```python +# control function +def sin(t, c): + return c[0] * np.sin(c[1] * t) + + +# gradient +def grad_sin(t, c, idx): + if idx == 0: # w.r.t. c0 + return np.sin(c[1] * t) + if idx == 1: # w.r.t. c1 + return c[0] * np.cos(c[1] * t) * t + if idx == 2: # w.r.t. time + return c[0] * np.cos(c[1] * t) * c[1] + +H = [Hd] + [[Hc, sin, {"grad": grad_sin}]] +``` + +### a) not optimized over time + +```python +alg_args = { + "alg": "GOAT", + "fid_err_targ": 0.01, +} +ctrl_params = { + id: {"guess": goat_guess, "bounds": [(-10, 10), (0, 2*np.pi)]} # c0 and c1 +} + +# run the optimization +res_goat = optimize_pulses( + objectives = Objective(initial_state, H, target_state), + control_parameters = ctrl_params, + tlist = times, + algorithm_kwargs = alg_args, +) + +print('Infidelity: ', res_goat.infidelity) + +plt.plot(times, sin(times, goat_guess), 'k--', label='initial guess') +plt.plot(times, res_goat.optimized_controls[0], label='optimized pulse') +plt.title('GOAT pulses') +plt.xlabel('Time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +Here, GOAT is stuck in a local minimum and does not reach the desired fidelity. + +```python +H_result = [Hd] + [[Hc, np.array(res_goat.optimized_controls[0])]] +evolution = qt.mesolve(H_result, initial_state, times, c_ops) + +plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution.states], label="Overlap with target state") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution.states], '--', label="Fidelity") +plt.title("GOAT performance") +plt.xlabel("Time") +plt.ylim(0, 1) +plt.legend() +plt.show() +``` + +### b) optimized over time + +```python +# treats time as optimization variable +ctrl_params["__time__"] = { + "guess": times[len(times) // 2], + "bounds": [times[0], times[-1]], +} + +# run the optimization +res_goat_time = optimize_pulses( + objectives = Objective(initial_state, H, target_state), + control_parameters = ctrl_params, + tlist = times, + algorithm_kwargs = alg_args, +) + +opt_time = res_goat_time.optimized_params[-1] +time_range = times < opt_time + +print('Infidelity: ', res_goat_time.infidelity) +print('optimized time: ', res_goat_time.optimized_params[-1]) + +plt.plot(times, res_goat.optimized_controls[0], label='optimized pulse') +plt.plot(times[time_range], np.array(res_goat_time.optimized_controls[0])[time_range], label='optimized (over time) pulse') +plt.title('GOAT pulses') +plt.xlabel('Time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +GOAT is still stuck in a local minimum, but the fidelity has improved. + +```python +times2 = times[time_range] +if opt_time not in times2: + times2 = np.append(times2, opt_time) + +H_result = [Hd] + [[Hc, np.array(res_goat_time.optimized_controls[0])]] +evolution_time = qt.mesolve(H_result, initial_state, times) + +plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution_time.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution_time.states], label="Overlap with target state") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_time.states], '--', label="Fidelity") +plt.title('GOAT (optimized over time) performance') +plt.xlabel('Time') +plt.xlim(0, res_goat_time.optimized_params[-1][0]) +plt.legend() +plt.show() +``` + +### Global optimization + +```python +opt_args = { + "method": "basinhopping", + "max_iter": 100, +} + +res_goat_global = optimize_pulses( + objectives = Objective(initial_state, H, target_state), + control_parameters = ctrl_params, + tlist = times, + algorithm_kwargs = alg_args, + optimizer_kwargs = opt_args +) + +global_time = res_goat_global.optimized_params[-1] +global_range = times < global_time + +print('Infidelity: ', res_goat_global.infidelity) +print('optimized time: ', res_goat_global.optimized_params[-1]) + +plt.plot(times, res_goat.optimized_controls[0], label='optimized pulse') +plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[0])[global_range], label='global optimized pulse') +plt.title('GOAT pulses (global)') +plt.xlabel('Time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() + +``` + +```python +times3 = times[global_range] +if global_time not in times3: + times3 = np.append(times3, global_time) + +H_result = [Hd, [Hc, np.array(res_goat_global.optimized_controls[0])]] +evolution_global = qt.mesolve(H_result, initial_state, times) + +plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution_global.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution_global.states], label="Overlap with target state") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_global.states], '--', label="Fidelity") +plt.xlim(0, res_goat_global.optimized_params[-1][0]) + +plt.title('GOAT (global) performance') +plt.xlabel('Time') +plt.legend() +plt.show() +``` + +## Comparison + +```python +plt.plot(times, guess_pulse, 'k--', label='initial guess') +plt.plot(times, res_goat.optimized_controls[0], label='optimized pulse') +plt.plot(times[time_range], np.array(res_goat_time.optimized_controls[0])[time_range], label='optimized (over time) pulse') +plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[0])[global_range], label='global optimized pulse') +plt.title('GOAT pulses') +plt.xlabel('time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +```python +print('Guess Fidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) +print('GOAT Infidelity: ', res_goat.infidelity) +print('Time Infidelity: ', res_goat_time.infidelity) +print('GLobal Infidelity: ', res_goat_global.infidelity) + +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_guess.states], 'k--', label="Goat") +plt.plot(times[time_range], [qt.fidelity(state, target_state) for state in evolution_time.states[:len(times[time_range])]], label="Time") +plt.plot(times[global_range], [qt.fidelity(state, target_state) for state in evolution_global.states[:len(times[global_range])]], label="Global") + +plt.title('Fidelities') +plt.xlabel('Time') +plt.legend() +plt.show() + +``` + +## Validation + +```python +guess_fidelity = qt.fidelity(evolution_guess.states[-1], target_state) + +# target fidelity not reached in part a), check that it is better than the guess +assert 1 - res_goat.infidelity > guess_fidelity +assert np.allclose(np.abs(evolution.states[-1].overlap(target_state)), 1 - res_goat.infidelity, atol=1e-3) + +# target fidelity not reached in part b), check that it is better than part a) +assert res_goat_time.infidelity < res_goat.infidelity +assert np.allclose(np.abs(evolution_time.states[len(times[time_range]) - 1].overlap(target_state)), 1 - res_goat_time.infidelity, atol=1e-3) + +assert res_goat_global.infidelity < 0.001 +assert np.abs(evolution_global.states[len(times[global_range]) - 1].overlap(target_state)) > 1 - 0.001 +``` + +```python +qt.about() +``` + +```python + +``` diff --git a/tests/interactive/GRAPE_gate_open.md b/tests/interactive/GRAPE_gate_open.md new file mode 100644 index 0000000..1f4bc98 --- /dev/null +++ b/tests/interactive/GRAPE_gate_open.md @@ -0,0 +1,122 @@ +--- +jupyter: + jupytext: + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.16.7 + kernelspec: + display_name: qutip-dev + language: python + name: python3 +--- + +# GRAPE algorithm for 2 level system + +```python +import matplotlib.pyplot as plt +import numpy as np +from qutip import (about, Qobj, gates, liouvillian, fidelity,basis, qeye, sigmam, sigmax, sigmay, sigmaz, tensor) +import qutip as qt +from qutip_qoc import Objective, optimize_pulses +``` + +## Problem setup + +```python +hbar = 1 +omega = 0.1 # energy splitting +delta = 1.0 # tunneling +gamma = 0.1 # amplitude damping +sx, sy, sz = sigmax(), sigmay(), sigmaz() +c_ops = [np.sqrt(gamma) * sigmam()] + +Hd = 1 / 2 * hbar * omega * sz +Hd = liouvillian(H=Hd, c_ops=c_ops) +Hc = sx +Hc = [liouvillian(sx), liouvillian(sy), liouvillian(sz)] + +H = [Hd, Hc[0], Hc[1], Hc[2]] + +# objective for optimization +initial_gate = qeye(2) +target_gate = Qobj(1 / np.sqrt(2) * np.array([[1, 1], [1, -1]])) + +times = np.linspace(0, np.pi / 2, 250) +``` + +## Guess + +```python +grape_guess = np.sin(times) +``` + +## Grape algorithm + +```python +control_params = { + "ctrl_x": {"guess": np.sin(times), "bounds": [-1, 1]}, + "ctrl_y": {"guess": np.cos(times), "bounds": [-1, 1]}, + "ctrl_z": {"guess": np.tanh(times), "bounds": [-1, 1]}, +} +alg_args = {"alg": "GRAPE", "fid_err_targ": 0.001} + +res_grape = optimize_pulses( + objectives=Objective(initial_gate, H, target_gate), + control_parameters=control_params, + tlist=times, + algorithm_kwargs=alg_args, +) + + +print('Infidelity: ', res_grape.infidelity) + +plt.plot(times, res_grape.optimized_controls[0], label='optimized pulse sx') +plt.plot(times, res_grape.optimized_controls[1], label='optimized pulse sy') +plt.plot(times, res_grape.optimized_controls[2], label='optimized pulse sz') +plt.title('GRAPE pulses') +plt.xlabel('Time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +```python +H_result = [Hd, + [Hc[0], res_grape.optimized_controls[0]], + [Hc[1], res_grape.optimized_controls[1]], + [Hc[2], res_grape.optimized_controls[2]]] + + +identity_op = qt.qeye(2) +identity_super = qt.spre(identity_op) + +evolution = qt.mesolve(H_result, identity_super, times) + +target_super = qt.to_super(target_gate) +initial_super = qt.to_super(initial_gate) + +initial_overlaps = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution.states] +target_overlaps = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution.states] + +plt.plot(times, initial_overlaps, label="Overlap with initial gate") +plt.plot(times, target_overlaps, label="Overlap with target gate") +plt.title("GRAPE performance") +plt.xlabel("Time") +plt.legend() +plt.show() + +``` + +## Validation + +```python +assert res_grape.infidelity < 0.01 +``` + +```python +qt.about() +``` + + diff --git a/tests/interactive/GRAPE_state_open.md b/tests/interactive/GRAPE_state_open.md new file mode 100644 index 0000000..92686d4 --- /dev/null +++ b/tests/interactive/GRAPE_state_open.md @@ -0,0 +1,124 @@ +--- +jupyter: + jupytext: + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.16.7 + kernelspec: + display_name: qutip-dev + language: python + name: python3 +--- + +# GRAPE algorithm for 2 level system + +```python +import matplotlib.pyplot as plt +import numpy as np +from qutip import (about, fidelity, liouvillian, ket2dm, Qobj, basis, sigmam) +import qutip as qt +from qutip_qoc import Objective, optimize_pulses + +import logging +``` + +## Problem setup + +```python +# Energy levels +E1, E2 = 1.0, 2.0 + +hbar = 1 +omega = 0.1 # energy splitting +delta = 1.0 # tunneling +gamma = 0.1 # amplitude damping +c_ops = [np.sqrt(gamma) * sigmam()] + +Hd = Qobj(np.diag([E1, E2])) +Hd = liouvillian(H=Hd, c_ops=c_ops) +Hc = Qobj(np.array([ + [0, 1], + [1, 0] +])) +Hc = liouvillian(Hc) +H = [Hd, Hc] + +initial_state = ket2dm(basis(2, 0)) +target_state = ket2dm(basis(2, 1)) + +times = np.linspace(0, 2 * np.pi, 250) +``` + +## Guess + +```python +grape_guess = np.sin(times) + +Hresult_guess = [Hd, [Hc, grape_guess]] +evolution_guess = qt.mesolve(Hresult_guess, initial_state, times) + +print('Fidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) + +plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution_guess.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution_guess.states], label="Overlap with target state") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_guess.states], '--', label="Fidelity") +plt.legend() +plt.title("Guess performance") +plt.xlabel("Time") +plt.show() +``` + +## GRAPE algorithm + +```python +alg_args = {"alg": "GRAPE", "fid_err_targ": 0.001, "log_level": logging.DEBUG - 2} +control_params = { + "ctrl_1": {"guess": grape_guess, "bounds": [-1, 1]}, # Control pulse for Hc1 +} + +res_grape = optimize_pulses( + objectives = Objective(initial_state, H, target_state), + control_parameters = control_params, + tlist = times, + algorithm_kwargs=alg_args, +) + +print('Infidelity: ', res_grape.infidelity) + +plt.plot(times, grape_guess, label='initial guess') +plt.plot(times, res_grape.optimized_controls[0], label='optimized pulse') +plt.title('GRAPE pulses') +plt.xlabel('Time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +```python +H_result = [Hd, [Hc, res_grape.optimized_controls[0]]] +evolution = qt.mesolve(H_result, initial_state, times, c_ops) + +plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution.states]) +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution.states], '--', label="Fidelity") +plt.title("CRAB performance") +plt.xlabel('Time') +plt.legend() +plt.ylim(0, 1) +plt.show() +``` + +## Validation + +```python +assert res_grape.infidelity < 0.01 +``` + +```python +qt.about() +``` + +```python + +``` diff --git a/tests/interactive/JOPT_gate_open.md b/tests/interactive/JOPT_gate_open.md new file mode 100644 index 0000000..31e8bbe --- /dev/null +++ b/tests/interactive/JOPT_gate_open.md @@ -0,0 +1,289 @@ +--- +jupyter: + jupytext: + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.16.7 + kernelspec: + display_name: qutip-dev + language: python + name: python3 +--- + +# JOPT algorithm + +```python +import matplotlib.pyplot as plt +import numpy as np +from jax import jit, numpy +from qutip import (about, Qobj, gates, liouvillian, qeye, sigmam, sigmax, sigmay, sigmaz, fidelity) +import qutip as qt +from qutip_qoc import Objective, optimize_pulses +``` + +## Problem setup + +```python +hbar = 1 +omega = 0.1 # energy splitting +delta = 1.0 # tunneling +gamma = 0.1 # amplitude damping +sx, sy, sz = sigmax(), sigmay(), sigmaz() + +Hd = 1 / 2 * hbar * omega * sz +Hd = liouvillian(H=Hd, c_ops=[np.sqrt(gamma) * sigmam()]) +Hc = [liouvillian(sx), liouvillian(sy), liouvillian(sz)] + +H = [Hd, Hc[0], Hc[1], Hc[2]] + +# objective for optimization +initial_gate = qeye(2) +target_gate = Qobj(1 / np.sqrt(2) * np.array([[1, 1], [1, -1]])) + +times = np.linspace(0, np.pi / 2, 250) +``` + +## Guess + +```python +jopt_guess = [1, 1] +guess_pulse = jopt_guess[0] * np.sin(jopt_guess[1] * times) +``` + +## JOPT algorithm + +```python +@jit +def sin_x(t, c, **kwargs): + return c[0] * numpy.sin(c[1] * t) + +H = [Hd] + [[hc, sin_x, {"grad": sin_x}] for hc in Hc] +``` + +### a) not optimized over time + +```python +ctrl_parameters = { + id: {"guess": jopt_guess, "bounds": [(-1, 1), (0, 2 * np.pi)]} # c0 and c1 + for id in ['x', 'y', 'z'] +} +alg_args = { + "alg": "JOPT", + "fid_err_targ": 0.01, +} + +res_jopt = optimize_pulses( + objectives=Objective(initial_gate, H, target_gate), + control_parameters=ctrl_parameters, + tlist=times, + minimizer_kwargs={ + "method": "Nelder-Mead", + }, + algorithm_kwargs=alg_args, +) + +print('Infidelity: ', res_jopt.infidelity) + +plt.plot(times, res_jopt.optimized_controls[0], label='optimized pulse') +plt.plot(times, res_jopt.optimized_controls[1], label='optimized pulse') +plt.plot(times, res_jopt.optimized_controls[2], label='optimized pulse') +plt.title('JOPT pulses') +plt.xlabel('Time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +```python +H_result = [Hd, + [Hc[0], np.array(res_jopt.optimized_controls[0])], + [Hc[1], np.array(res_jopt.optimized_controls[1])], + [Hc[2], np.array(res_jopt.optimized_controls[2])]] + + +identity_op = qt.qeye(2) +identity_super = qt.spre(identity_op) + +evolution_time = qt.mesolve(H_result, identity_super, times) + +target_super = qt.to_super(target_gate) +initial_super = qt.to_super(initial_gate) + +initial_overlaps = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution_time.states] +target_overlaps = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution_time.states] + +plt.plot(times, initial_overlaps, label="Overlap with initial gate") +plt.plot(times, target_overlaps, label="Overlap with target gate") +plt.title("GOAT performance") +plt.xlabel("Time") +plt.legend() +plt.show() + +``` + +### b) optimized over time + +```python +# treats time as optimization variable +ctrl_parameters["__time__"] = { + "guess": times[len(times) // 2], + "bounds": [times[0], times[-1]], +} +alg_args = { + "alg": "JOPT", + "fid_err_targ": 0.01, +} + +# run the optimization +res_jopt_time = optimize_pulses( + objectives=Objective(initial_gate, H, target_gate), + control_parameters=ctrl_parameters, + tlist=times, + minimizer_kwargs={ + "method": "Nelder-Mead", + }, + algorithm_kwargs=alg_args, +) + +print('Infidelity: ', res_jopt_time.infidelity) +print('Time: ', times[-1]) +print('optimized time: ', res_jopt_time.optimized_params[-1]) + +time_range = times < res_jopt_time.optimized_params[-1] + +plt.plot(times[time_range], np.array(res_jopt_time.optimized_controls[0])[time_range], label='Optimized (over time) pulse sx') +plt.plot(times[time_range], np.array(res_jopt_time.optimized_controls[1])[time_range], label='Optimized (over time) pulse sy') +plt.plot(times[time_range], np.array(res_jopt_time.optimized_controls[2])[time_range], label='Optimized (over time) pulse sz') +plt.title('JOPT pulses') +plt.xlabel('Time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +```python +H_result = [Hd, + [Hc[0], np.array(res_jopt_time.optimized_controls[0])], + [Hc[1], np.array(res_jopt_time.optimized_controls[1])], + [Hc[2], np.array(res_jopt_time.optimized_controls[2])]] + + +identity_op = qt.qeye(2) +identity_super = qt.spre(identity_op) + +evolution_time = qt.mesolve(H_result, identity_super, times) + +target_super = qt.to_super(target_gate) +initial_super = qt.to_super(initial_gate) + +initial_overlaps = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution_time.states] +target_overlaps = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution_time.states] + +plt.plot(times, initial_overlaps, label="Overlap with initial gate") +plt.plot(times, target_overlaps, label="Overlap with target gate") +plt.title("GOAT performance") +plt.xlabel("Time") +plt.legend() +plt.show() + +``` + +## Global optimization + +```python +alg_args = { + "alg": "JOPT", + "fid_err_targ": 0.001, +} +opt_args = { + "method": "basinhopping", + "max_iter": 1000, +} + +res_jopt_global = optimize_pulses( + objectives=Objective(initial_gate, H, target_gate), + control_parameters=ctrl_parameters, + tlist=times, + algorithm_kwargs=alg_args, + optimizer_kwargs=opt_args +) + +print('Infidelity: ', res_jopt_global.infidelity) +print('optimized time: ', res_jopt_global.optimized_params[-1]) + +global_range = times < res_jopt_global.optimized_params[-1] + +plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[0])[global_range], label='Global optimized pulse sx') +plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[1])[global_range], label='Global optimized pulse sy') +plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[2])[global_range], label='Global optimized pulse sz') +plt.title('JOPT pulses (global)') +plt.xlabel('Time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() + +``` + +```python +H_result = [Hd, + [Hc[0], np.array(res_jopt_time.optimized_controls[0])], + [Hc[1], np.array(res_jopt_time.optimized_controls[1])], + [Hc[2], np.array(res_jopt_time.optimized_controls[2])]] + + +identity_op = qt.qeye(2) +identity_super = qt.spre(identity_op) + +evolution_time = qt.mesolve(H_result, identity_super, times) + +target_super = qt.to_super(target_gate) +initial_super = qt.to_super(initial_gate) + +initial_overlaps = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution_time.states] +target_overlaps = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution_time.states] + +plt.plot(times, initial_overlaps, label="Overlap with initial gate") +plt.plot(times, target_overlaps, label="Overlap with target gate") +plt.title("GOAT performance") +plt.xlabel("Time") +plt.legend() +plt.show() + +``` + +## Comparison + +```python +fig, axes = plt.subplots(1, 3, figsize=(18, 4)) # 1 row, 3 columns + +titles = ["JOPT s_x pulses", "JOPT s_y pulses", "JOPT s_z pulses"] + +for i in range(3): + ax = axes[i] + ax.plot(times, sin_x(times, jopt_guess), label='Initial guess') + ax.plot(times, res_jopt.optimized_controls[i], label='Optimized pulse') + ax.plot(times[time_range], np.array(res_jopt_time.optimized_controls[i])[time_range], label='Optimized (over time) pulse') + ax.plot(times[global_range], np.array(res_jopt_global.optimized_controls[i])[global_range], label='Global optimized pulse') + ax.set_title(titles[i]) + ax.set_xlabel('Time') + ax.set_ylabel('Pulse amplitude') + ax.legend() + +plt.tight_layout() +plt.show() + +``` + +## Validation + +```python +assert res_jopt.infidelity < 0.001 +assert res_jopt_time.infidelity < 0.001 +assert res_jopt_global.infidelity < 0.001 +``` + +```python +qt.about() +``` diff --git a/tests/interactive/JOPT_state_open.md b/tests/interactive/JOPT_state_open.md new file mode 100644 index 0000000..77f8424 --- /dev/null +++ b/tests/interactive/JOPT_state_open.md @@ -0,0 +1,273 @@ +--- +jupyter: + jupytext: + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.16.7 + kernelspec: + display_name: qutip-dev + language: python + name: python3 +--- + +# JOPT algorithm for a 2 level system + + +```python +import matplotlib.pyplot as plt +import numpy as np +from qutip import (about, fidelity, liouvillian, ket2dm, Qobj, basis, sigmam) +import qutip as qt +from qutip_qoc import Objective, optimize_pulses +from jax import jit, numpy +``` + +## Problem setup + +```python +# Energy levels +E1, E2 = 1.0, 2.0 + +hbar = 1 +omega = 0.1 # energy splitting +delta = 1.0 # tunneling +gamma = 0.1 # amplitude damping +c_ops = [np.sqrt(gamma) * sigmam()] + +Hd = Qobj(np.diag([E1, E2])) +Hd = liouvillian(H=Hd, c_ops=c_ops) +Hc = Qobj(np.array([ + [0, 1], + [1, 0] +])) +Hc = liouvillian(Hc) +H = [Hd, Hc] + +initial_state = ket2dm(basis(2, 0)) +target_state = ket2dm(basis(2, 1)) + +times = np.linspace(0, 2 * np.pi, 250) +``` + +## Guess + +```python +jopt_guess = [1, 0.5] +guess_pulse = jopt_guess[0] * np.sin(jopt_guess[1] * times) + +Hresult_guess = [Hd, [Hc, guess_pulse]] +evolution_guess = qt.mesolve(Hresult_guess, initial_state, times) + +print('Fidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) + +plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution_guess.states], label="Initial Overlap") +plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution_guess.states], label="Target Overlap") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_guess.states], '--', label="Fidelity") +plt.legend() +plt.title("Guess performance") +plt.show() +``` + +## JOPT algorithm + +```python +@jit +def sin_x(t, c, **kwargs): + return c[0] * numpy.sin(c[1] * t) + +H = [Hd, [Hc, sin_x]] +``` + +### a) not optimized over time + +```python +ctrl_parameters = { + id: {"guess": [1, 0], "bounds": [(-1, 1), (0, 2 * np.pi)]} # c0 and c1 +} +alg_args = { + "alg": "JOPT", + "fid_err_targ": 0.01, +} + +res_jopt = optimize_pulses( + objectives=Objective(initial_state, H, target_state), + control_parameters=ctrl_parameters, + tlist=times, + minimizer_kwargs={ + "method": "Nelder-Mead", + }, + algorithm_kwargs=alg_args, +) + +print('Infidelity: ', res_jopt.infidelity) + +plt.plot(times, sin_x(times, jopt_guess), label='initial guess') +plt.plot(times, res_jopt.optimized_controls[0], label='optimized pulse') +plt.title('JOPT pulses') +plt.xlabel('Time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +```python +H_result = [Hd, [Hc, np.array(res_jopt.optimized_controls[0])]] +evolution = qt.sesolve(H_result, initial_state, times) + +plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution.states], label="Overlap with intiial state") +plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution.states], label="Overlap with target state") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution.states], '--', label="Fidelity") +plt.title('JOPT performance') +plt.xlabel('Time') +plt.legend() +plt.show() + +``` + +### b) optimized over time + +```python +# treats time as optimization variable +ctrl_parameters["__time__"] = { + "guess": times[len(times) // 2], + "bounds": [times[0], times[-1]], +} +alg_args = { + "alg": "JOPT", + "fid_err_targ": 0.001, +} + +# run the optimization +res_jopt_time = optimize_pulses( + objectives=Objective(initial_state, H, target_state), + control_parameters=ctrl_parameters, + tlist=times, + minimizer_kwargs={ + "method": "Nelder-Mead", + + }, + algorithm_kwargs=alg_args, +) + +print('Infidelity: ', res_jopt_time.infidelity) +print('optimized time: ', res_jopt_time.optimized_params[-1]) + +time_range = times < res_jopt_time.optimized_params[-1] + +plt.plot(times, res_jopt.optimized_controls[0], label='Optimized pulse') +plt.plot(times[time_range], np.array(res_jopt.optimized_controls[0])[time_range], label='Optimized (over time) pulse') +plt.title('JOPT pulses') +plt.xlabel('Time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +```python +H_result = [Hd, [Hc, np.array(res_jopt_time.optimized_controls[0])]] +evolution_time = qt.sesolve(H_result, initial_state, times) + +plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution_time.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution_time.states], label="Overlap with target state") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_time.states], '--', label="Fidelity") +plt.title('JOPT (optimized over time) performance') +plt.xlabel('Time') +plt.xlim(0, res_jopt_time.optimized_params[-1][0]) +plt.legend() +plt.show() +``` + +## Global optimization + +```python +opt_args = { + "method": "basinhopping", + "max_iter": 1000, +} + +res_jopt_global = optimize_pulses( + objectives=Objective(initial_state, H, target_state), + control_parameters=ctrl_parameters, + tlist=times, + algorithm_kwargs=alg_args, + optimizer_kwargs=opt_args +) + +global_time = res_jopt_global.optimized_params[-1] +global_range = times < global_time + +print('Infidelity: ', res_jopt_global.infidelity) +print('Optimized time: ', res_jopt_global.optimized_params[-1]) + +plt.plot(times, res_jopt.optimized_controls[0], label='Optimized pulse') +plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[0])[global_range], label='Global optimized pulse') +plt.title('JOPT pulses (global)') +plt.xlabel('Time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() + +``` + +```python +H_result = [Hd, [Hc, np.array(res_jopt_global.optimized_controls[0])]] +evolution_global = qt.sesolve(H_result, initial_state, times) + +plt.plot(times, [np.abs(state.overlap(initial_state))**2 for state in evolution_global.states], label="Overlap with initial state") +plt.plot(times, [np.abs(state.overlap(target_state))**2 for state in evolution_global.states], label="Overlap with target state") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_global.states], '--', label="Fidelity") +plt.xlim(0, res_jopt_global.optimized_params[-1][0]) +plt.title('JOPT (global) performance') +plt.xlabel('Time') +plt.legend() +plt.show() +``` + +## Comparison + +```python +plt.plot(times, sin_x(times, jopt_guess), label='Initial guess') +plt.plot(times, res_jopt.optimized_controls[0], label='Optimized pulse') +plt.plot(times[time_range], np.array(res_jopt_time.optimized_controls[0])[time_range], label='Optimized (over time) pulse') +plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[0])[global_range], label='Global optimized pulse') +plt.title('JOPT pulses') +plt.xlabel('Time') +plt.ylabel('Pulse amplitude') +plt.legend() +plt.show() +``` + +```python +print('Guess Infidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) +print('JOPT Infidelity: ', res_jopt.infidelity) +print('Time Infidelity: ', res_jopt_time.infidelity) +print('GLobal Infidelity: ', res_jopt_global.infidelity) + +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_guess.states], label="Guess") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution.states], label="Goat") +plt.plot(times[time_range], [qt.fidelity(state, target_state) for state in evolution_time.states[:len(times[time_range])]], label="Time") +plt.plot(times[global_range], [qt.fidelity(state, target_state) for state in evolution_global.states[:len(times[global_range])]], label="Global") + +plt.title('Fidelities') +plt.xlabel('time') +plt.legend() +plt.show() +``` + +## Validation + +```python +assert res_jopt.infidelity < 0.001 +assert res_jopt_time.infidelity < 0.001 +assert res_jopt_global.infidelity < 0.001 +``` + +```python +qt.about() +``` + +```python + +``` From 7681756a6945313bec53e93e8638a4edaea922f3 Mon Sep 17 00:00:00 2001 From: Julian Seither Date: Sat, 17 May 2025 13:19:33 +0900 Subject: [PATCH 15/17] Updated open notebooks --- tests/interactive/CRAB_gate_open.md | 80 +- tests/interactive/CRAB_state_open.md | 71 +- tests/interactive/GOAT_gate_open.md | 184 +- tests/interactive/GOAT_state_open.md | 171 +- tests/interactive/GRAPE_gate_open.md | 103 +- tests/interactive/GRAPE_state_open.md | 3818 ++++++++++++++++++++++++- tests/interactive/JOPT_gate_open.md | 120 +- tests/interactive/JOPT_state_open.md | 313 +- 8 files changed, 4668 insertions(+), 192 deletions(-) diff --git a/tests/interactive/CRAB_gate_open.md b/tests/interactive/CRAB_gate_open.md index 84fd0d0..cb81fe0 100644 --- a/tests/interactive/CRAB_gate_open.md +++ b/tests/interactive/CRAB_gate_open.md @@ -1,29 +1,17 @@ ---- -jupyter: - jupytext: - text_representation: - extension: .md - format_name: markdown - format_version: '1.3' - jupytext_version: 1.16.7 - kernelspec: - display_name: qutip-dev - language: python - name: python3 ---- - # CRAB algorithm + ```python import matplotlib.pyplot as plt import numpy as np -from qutip import (about, Qobj, gates, liouvillian, qeye, sigmam, sigmax, sigmay, sigmaz, tensor) +from qutip import (about, Qobj, liouvillian, qeye, sigmam, sigmax, sigmay, sigmaz, tensor) import qutip as qt from qutip_qoc import Objective, optimize_pulses ``` ## Problem setup + ```python hbar = 1 omega = 0.1 # energy splitting @@ -45,6 +33,7 @@ times = np.linspace(0, np.pi / 2, 250) ## Crab algorithm + ```python n_params = 6 # adjust in steps of 3 control_params = { @@ -83,13 +72,28 @@ plt.legend() plt.show() ``` + c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\scipy\optimize\_basinhopping.py:294: RuntimeWarning: Method Nelder-Mead does not use gradient information (jac). + return self.minimizer(self.func, x0, **self.kwargs) + c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\scipy\optimize\_basinhopping.py:294: OptimizeWarning: Unknown solver options: gtol + return self.minimizer(self.func, x0, **self.kwargs) + + + Infidelity: 0.007575498222395387 + + + + +![png](CRAB_gate_open_files/CRAB_gate_open_5_2.png) + + + + ```python H_result = [Hd, [Hc[0], res_crab.optimized_controls[0]], [Hc[1], res_crab.optimized_controls[1]], [Hc[2], res_crab.optimized_controls[2]]] - identity_op = qt.qeye(2) identity_super = qt.spre(identity_op) @@ -110,14 +114,56 @@ plt.show() ``` + + +![png](CRAB_gate_open_files/CRAB_gate_open_6_0.png) + + + ## Validation + ```python -assert res_crab.infidelity < 0.1 +assert res_crab.infidelity < 0.01 ``` + ```python qt.about() ``` + + QuTiP: Quantum Toolbox in Python + ================================ + Copyright (c) QuTiP team 2011 and later. + Current admin team: Alexander Pitchford, Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguère, Boxi Li, Simon Cross, Asier Galicia, Paul Menczel, and Patrick Hopf. + Board members: Daniel Burgarth, Robert Johansson, Anton F. Kockum, Franco Nori and Will Zeng. + Original developers: R. J. Johansson & P. D. Nation. + Previous lead developers: Chris Granade & A. Grimsmo. + Currently developed through wide collaboration. See https://github.com/qutip for details. + + QuTiP Version: 5.1.1 + Numpy Version: 1.26.4 + Scipy Version: 1.15.2 + Cython Version: None + Matplotlib Version: 3.10.0 + Python Version: 3.12.10 + Number of CPUs: 8 + BLAS Info: Generic + INTEL MKL Ext: None + Platform Info: Windows (AMD64) + Installation path: c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\qutip + + Installed QuTiP family packages + ------------------------------- + + qutip-jax: 0.1.0 + qutip-qtrl: 0.1.5 + + ================================================================================ + Please cite QuTiP in your publication. + ================================================================================ + For your convenience a bibtex reference can be easily generated using `qutip.cite()` + + diff --git a/tests/interactive/CRAB_state_open.md b/tests/interactive/CRAB_state_open.md index cd80cab..ba71511 100644 --- a/tests/interactive/CRAB_state_open.md +++ b/tests/interactive/CRAB_state_open.md @@ -1,19 +1,6 @@ ---- -jupyter: - jupytext: - text_representation: - extension: .md - format_name: markdown - format_version: '1.3' - jupytext_version: 1.16.7 - kernelspec: - display_name: qutip-dev - language: python - name: python3 ---- - # GRAPE algorithm for 2 level system + ```python import matplotlib.pyplot as plt import numpy as np @@ -24,6 +11,7 @@ from qutip_qoc import Objective, optimize_pulses ## Problem setup + ```python # Energy levels E1, E2 = 1.0, 2.0 @@ -43,7 +31,6 @@ Hc = Qobj(np.array([ Hc = liouvillian(Hc) H = [Hd, Hc] - initial_state = ket2dm(basis(2, 0)) target_state = ket2dm(basis(2, 1)) @@ -52,6 +39,7 @@ times = np.linspace(0, 2 * np.pi, 250) ## CRAB algorithm + ```python n_params = 6 # adjust in steps of 3 control_params = { @@ -79,6 +67,16 @@ plt.legend() plt.show() ``` + Infidelity: 0.0027237139157979926 + + + + +![png](CRAB_state_open_files/CRAB_state_open_5_1.png) + + + + ```python H_result = [Hd, [Hc, res_crab.optimized_controls[0]]] evolution = qt.mesolve(H_result, initial_state, times, c_ops) @@ -92,16 +90,59 @@ plt.legend() plt.show() ``` + + +![png](CRAB_state_open_files/CRAB_state_open_6_0.png) + + + ## Validation + ```python assert res_crab.infidelity < 0.01 ``` + ```python qt.about() ``` + + QuTiP: Quantum Toolbox in Python + ================================ + Copyright (c) QuTiP team 2011 and later. + Current admin team: Alexander Pitchford, Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguère, Boxi Li, Simon Cross, Asier Galicia, Paul Menczel, and Patrick Hopf. + Board members: Daniel Burgarth, Robert Johansson, Anton F. Kockum, Franco Nori and Will Zeng. + Original developers: R. J. Johansson & P. D. Nation. + Previous lead developers: Chris Granade & A. Grimsmo. + Currently developed through wide collaboration. See https://github.com/qutip for details. + + QuTiP Version: 5.1.1 + Numpy Version: 1.26.4 + Scipy Version: 1.15.2 + Cython Version: None + Matplotlib Version: 3.10.0 + Python Version: 3.12.10 + Number of CPUs: 8 + BLAS Info: Generic + INTEL MKL Ext: None + Platform Info: Windows (AMD64) + Installation path: c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\qutip + + Installed QuTiP family packages + ------------------------------- + + qutip-jax: 0.1.0 + qutip-qtrl: 0.1.5 + + ================================================================================ + Please cite QuTiP in your publication. + ================================================================================ + For your convenience a bibtex reference can be easily generated using `qutip.cite()` + + + ```python ``` diff --git a/tests/interactive/GOAT_gate_open.md b/tests/interactive/GOAT_gate_open.md index 3a4e8ce..83ca6f1 100644 --- a/tests/interactive/GOAT_gate_open.md +++ b/tests/interactive/GOAT_gate_open.md @@ -1,30 +1,17 @@ ---- -jupyter: - jupytext: - text_representation: - extension: .md - format_name: markdown - format_version: '1.3' - jupytext_version: 1.16.7 - kernelspec: - display_name: qutip-dev - language: python - name: python3 ---- - # GOAT algorithm + ```python import matplotlib.pyplot as plt import numpy as np -from jax import jit, numpy -from qutip import (about, Qobj, gates, liouvillian, qeye, sigmam, sigmax, sigmay, sigmaz, tensor) +from qutip import (Qobj, liouvillian, qeye, sigmam, sigmax, sigmay, sigmaz) import qutip as qt from qutip_qoc import Objective, optimize_pulses ``` ## Problem setup + ```python hbar = 1 omega = 0.1 # energy splitting @@ -47,14 +34,46 @@ times = np.linspace(0, np.pi / 2, 250) ## Guess + ```python goat_guess = [1, 1] guess_pulse = goat_guess[0] * np.sin(goat_guess[1] * times) + +H_result_guess = [Hd, + [Hc[0], guess_pulse], + [Hc[1], guess_pulse], + [Hc[2], guess_pulse]] + +identity_op = qt.qeye(2) +identity_super = qt.spre(identity_op) + +evolution_guess = qt.mesolve(H_result_guess, identity_super, times) + +target_super = qt.to_super(target_gate) +initial_super = qt.to_super(initial_gate) + +initial_overlaps_guess = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution_guess.states] +target_overlaps_guess = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution_guess.states] + +plt.plot(times, initial_overlaps_guess, label="Overlap with initial gate") +plt.plot(times, target_overlaps_guess, label="Overlap with target gate") +plt.title("Guess performance") +plt.xlabel("Time") +plt.legend() +plt.show() + ``` + + +![png](GOAT_gate_open_files/GOAT_gate_open_5_0.png) + + + ## Goat algorithm ### a) not optimized over time + ```python # control function def sin(t, c): @@ -74,6 +93,7 @@ H = [Hd] + [[hc, sin, {"grad": grad_sin}] for hc in Hc] ``` + ```python ctrl_params = { id: {"guess": goat_guess, "bounds": [(-1, 1), (0, 2 * np.pi)]} # c0 and c1 @@ -104,13 +124,22 @@ plt.legend() plt.show() ``` + Infidelity: 0.005501824802474568 + + + + +![png](GOAT_gate_open_files/GOAT_gate_open_8_1.png) + + + + ```python H_result = [Hd, [Hc[0], np.array(res_goat.optimized_controls[0])], [Hc[1], np.array(res_goat.optimized_controls[1])], [Hc[2], np.array(res_goat.optimized_controls[2])]] - identity_op = qt.qeye(2) identity_super = qt.spre(identity_op) @@ -125,13 +154,20 @@ target_overlaps = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for plt.plot(times, initial_overlaps, label="Overlap with initial gate") plt.plot(times, target_overlaps, label="Overlap with target gate") plt.title("GOAT performance") -plt.xlabel("global") +plt.xlabel("Time") plt.legend() plt.show() ``` -### b) optimized over global + + +![png](GOAT_gate_open_files/GOAT_gate_open_9_0.png) + + + +### b) optimized over time + ```python # treats time as optimization variable @@ -156,7 +192,6 @@ time_time = res_goat_time.optimized_params[-1] time_range = times < time_time print('Infidelity: ', res_goat_time.infidelity) -print("Time: ", times[-1]) print('Optimized time: ', res_goat_time.optimized_params[-1][0]) plt.plot(times[time_range], np.array(res_goat_time.optimized_controls[0])[time_range], label='optimized (over time) pulse sx') @@ -169,8 +204,19 @@ plt.legend() plt.show() ``` + Infidelity: 0.005093554605043814 + Optimized time: 1.4867367205567528 + + + + +![png](GOAT_gate_open_files/GOAT_gate_open_11_1.png) + + + + ```python -H_result = [Hd, +H_result_time = [Hd, [Hc[0], np.array(res_goat_time.optimized_controls[0])], [Hc[1], np.array(res_goat_time.optimized_controls[1])], [Hc[2], np.array(res_goat_time.optimized_controls[2])]] @@ -179,13 +225,13 @@ H_result = [Hd, identity_op = qt.qeye(2) identity_super = qt.spre(identity_op) -evolution_time = qt.mesolve(H_result, identity_super, times) +evolution_time = qt.mesolve(H_result_time, identity_super, times) target_super = qt.to_super(target_gate) initial_super = qt.to_super(initial_gate) -initial_overlaps = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution_time.states] -target_overlaps = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution_time.states] +initial_overlaps_time = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution_time.states] +target_overlaps_time = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution_time.states] plt.plot(times, initial_overlaps, label="Overlap with initial gate") plt.plot(times, target_overlaps, label="Overlap with target gate") @@ -196,12 +242,19 @@ plt.show() ``` + + +![png](GOAT_gate_open_files/GOAT_gate_open_12_0.png) + + + ## Global optimization + ```python alg_args = { "alg": "GOAT", - "fid_err_targ": 0.1, + "fid_err_targ": 0.01, } opt_args = { "method": "basinhopping", @@ -225,42 +278,59 @@ print('optimized time: ', res_goat_global.optimized_params[-1]) plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[0])[global_range], label='global optimized pulse sx') plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[1])[global_range], label='global optimized pulse sy') plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[2])[global_range], label='global optimized pulse sz') -plt.title('GOAT pulses (global)') +plt.title('GOAT pulses') plt.xlabel('time') plt.ylabel('Pulse amplitude') plt.legend() plt.show() ``` + Infidelity: 0.0065077273552405545 + optimized time: [1.5707963267948966] + + + + +![png](GOAT_gate_open_files/GOAT_gate_open_14_1.png) + + + + ```python -H_result = [Hd, +H_result_global = [Hd, [Hc[0], np.array(res_goat_global.optimized_controls[0])], [Hc[1], np.array(res_goat_global.optimized_controls[1])], [Hc[2], np.array(res_goat_global.optimized_controls[2])]] - identity_op = qt.qeye(2) identity_super = qt.spre(identity_op) -evolution_global = qt.mesolve(H_result, identity_super, times) +evolution_global = qt.mesolve(H_result_global, identity_super, times) target_super = qt.to_super(target_gate) initial_super = qt.to_super(initial_gate) -initial_overlaps = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution_global.states] -target_overlaps = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution_global.states] +initial_overlaps_global = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution_global.states] +target_overlaps_global = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution_global.states] -plt.plot(times, initial_overlaps, label="Overlap with initial gate") -plt.plot(times, target_overlaps, label="Overlap with target gate") -plt.title("GOAT (global) performance") +plt.plot(times, initial_overlaps_global, label="Overlap with initial gate") +plt.plot(times, target_overlaps_global, label="Overlap with target gate") +plt.title("GOAT performance (global)") plt.xlabel("Time") plt.legend() plt.show() ``` + + +![png](GOAT_gate_open_files/GOAT_gate_open_15_0.png) + + + ## Comparison + ```python fig, axes = plt.subplots(1, 3, figsize=(18, 4)) # 1 row, 3 columns @@ -282,16 +352,58 @@ plt.show() ``` + + +![png](GOAT_gate_open_files/GOAT_gate_open_17_0.png) + + + ## Validation + ```python -assert res_goat.infidelity < 0.1 -assert res_goat_time.infidelity < 0.1 +assert res_goat.infidelity < 0.01 +assert res_goat_time.infidelity < 0.01 assert res_goat_global.infidelity < 0.01 ``` + ```python qt.about() ``` + + QuTiP: Quantum Toolbox in Python + ================================ + Copyright (c) QuTiP team 2011 and later. + Current admin team: Alexander Pitchford, Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguère, Boxi Li, Simon Cross, Asier Galicia, Paul Menczel, and Patrick Hopf. + Board members: Daniel Burgarth, Robert Johansson, Anton F. Kockum, Franco Nori and Will Zeng. + Original developers: R. J. Johansson & P. D. Nation. + Previous lead developers: Chris Granade & A. Grimsmo. + Currently developed through wide collaboration. See https://github.com/qutip for details. + + QuTiP Version: 5.1.1 + Numpy Version: 1.26.4 + Scipy Version: 1.15.2 + Cython Version: None + Matplotlib Version: 3.10.0 + Python Version: 3.12.10 + Number of CPUs: 8 + BLAS Info: Generic + INTEL MKL Ext: None + Platform Info: Windows (AMD64) + Installation path: c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\qutip + + Installed QuTiP family packages + ------------------------------- + + qutip-jax: 0.1.0 + qutip-qtrl: 0.1.5 + + ================================================================================ + Please cite QuTiP in your publication. + ================================================================================ + For your convenience a bibtex reference can be easily generated using `qutip.cite()` + + diff --git a/tests/interactive/GOAT_state_open.md b/tests/interactive/GOAT_state_open.md index 352b658..8b49d25 100644 --- a/tests/interactive/GOAT_state_open.md +++ b/tests/interactive/GOAT_state_open.md @@ -1,19 +1,6 @@ ---- -jupyter: - jupytext: - text_representation: - extension: .md - format_name: markdown - format_version: '1.3' - jupytext_version: 1.16.7 - kernelspec: - display_name: qutip-dev - language: python - name: python3 ---- - # GOAT algorithm for a 2 level system + ```python import matplotlib.pyplot as plt import numpy as np @@ -24,6 +11,7 @@ from qutip_qoc import Objective, optimize_pulses ## Problem setup + ```python # Energy levels E1, E2 = 1.0, 2.0 @@ -51,6 +39,7 @@ times = np.linspace(0, 2 * np.pi, 250) ## Guess + ```python goat_guess = [1, 0.5] guess_pulse = goat_guess[0] * np.sin(goat_guess[1] * times) @@ -69,8 +58,18 @@ plt.xlabel("Time") plt.show() ``` + Fidelity: 0.8176293626457246 + + + + +![png](GOAT_state_open_files/GOAT_state_open_5_1.png) + + + ## GOAT algorithm + ```python # control function def sin(t, c): @@ -91,6 +90,7 @@ H = [Hd] + [[Hc, sin, {"grad": grad_sin}]] ### a) not optimized over time + ```python alg_args = { "alg": "GOAT", @@ -119,7 +119,15 @@ plt.legend() plt.show() ``` -Here, GOAT is stuck in a local minimum and does not reach the desired fidelity. + Infidelity: 0.07178736737494786 + + + + +![png](GOAT_state_open_files/GOAT_state_open_9_1.png) + + + ```python H_result = [Hd] + [[Hc, np.array(res_goat.optimized_controls[0])]] @@ -135,8 +143,15 @@ plt.legend() plt.show() ``` + + +![png](GOAT_state_open_files/GOAT_state_open_10_0.png) + + + ### b) optimized over time + ```python # treats time as optimization variable ctrl_params["__time__"] = { @@ -167,29 +182,49 @@ plt.legend() plt.show() ``` -GOAT is still stuck in a local minimum, but the fidelity has improved. + Infidelity: 0.009074574820662817 + optimized time: [0.37202273025971855] + + + + +![png](GOAT_state_open_files/GOAT_state_open_12_1.png) + + + ```python times2 = times[time_range] if opt_time not in times2: times2 = np.append(times2, opt_time) -H_result = [Hd] + [[Hc, np.array(res_goat_time.optimized_controls[0])]] -evolution_time = qt.mesolve(H_result, initial_state, times) +H_result_time = [Hd] + [[Hc, np.array(res_goat_time.optimized_controls[0])]] +evolution_time = qt.mesolve(H_result_time, initial_state, times) plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution_time.states], label="Overlap with initial state") plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution_time.states], label="Overlap with target state") plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_time.states], '--', label="Fidelity") -plt.title('GOAT (optimized over time) performance') +plt.title('GOAT performance (optimized over time)') plt.xlabel('Time') plt.xlim(0, res_goat_time.optimized_params[-1][0]) plt.legend() plt.show() ``` + + +![png](GOAT_state_open_files/GOAT_state_open_13_0.png) + + + ### Global optimization + ```python +alg_args = { + "alg": "GOAT", + "fid_err_targ": 0.01, +} opt_args = { "method": "basinhopping", "max_iter": 100, @@ -211,7 +246,7 @@ print('optimized time: ', res_goat_global.optimized_params[-1]) plt.plot(times, res_goat.optimized_controls[0], label='optimized pulse') plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[0])[global_range], label='global optimized pulse') -plt.title('GOAT pulses (global)') +plt.title('GOAT pulses') plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() @@ -219,27 +254,45 @@ plt.show() ``` + Infidelity: 0.007905283658334122 + optimized time: [1.5444538341679324] + + + + +![png](GOAT_state_open_files/GOAT_state_open_15_1.png) + + + + ```python times3 = times[global_range] if global_time not in times3: times3 = np.append(times3, global_time) -H_result = [Hd, [Hc, np.array(res_goat_global.optimized_controls[0])]] -evolution_global = qt.mesolve(H_result, initial_state, times) +H_result_global = [Hd, [Hc, np.array(res_goat_global.optimized_controls[0])]] +evolution_global = qt.mesolve(H_result_global, initial_state, times) plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution_global.states], label="Overlap with initial state") plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution_global.states], label="Overlap with target state") plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_global.states], '--', label="Fidelity") plt.xlim(0, res_goat_global.optimized_params[-1][0]) -plt.title('GOAT (global) performance') +plt.title('GOAT performance (global)') plt.xlabel('Time') plt.legend() plt.show() ``` + + +![png](GOAT_state_open_files/GOAT_state_open_16_0.png) + + + ## Comparison + ```python plt.plot(times, guess_pulse, 'k--', label='initial guess') plt.plot(times, res_goat.optimized_controls[0], label='optimized pulse') @@ -252,13 +305,21 @@ plt.legend() plt.show() ``` + + +![png](GOAT_state_open_files/GOAT_state_open_18_0.png) + + + + ```python print('Guess Fidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) print('GOAT Infidelity: ', res_goat.infidelity) print('Time Infidelity: ', res_goat_time.infidelity) print('GLobal Infidelity: ', res_goat_global.infidelity) -plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_guess.states], 'k--', label="Goat") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_guess.states], 'k--', label="Guess") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution.states], label="Goat") plt.plot(times[time_range], [qt.fidelity(state, target_state) for state in evolution_time.states[:len(times[time_range])]], label="Time") plt.plot(times[global_range], [qt.fidelity(state, target_state) for state in evolution_global.states[:len(times[global_range])]], label="Global") @@ -269,27 +330,67 @@ plt.show() ``` -## Validation + Guess Fidelity: 0.8176293626457246 + GOAT Infidelity: 0.07178736737494786 + Time Infidelity: 0.009074574820662817 + GLobal Infidelity: 0.007905283658334122 + -```python -guess_fidelity = qt.fidelity(evolution_guess.states[-1], target_state) -# target fidelity not reached in part a), check that it is better than the guess -assert 1 - res_goat.infidelity > guess_fidelity -assert np.allclose(np.abs(evolution.states[-1].overlap(target_state)), 1 - res_goat.infidelity, atol=1e-3) + +![png](GOAT_state_open_files/GOAT_state_open_19_1.png) + + + +## Validation -# target fidelity not reached in part b), check that it is better than part a) -assert res_goat_time.infidelity < res_goat.infidelity -assert np.allclose(np.abs(evolution_time.states[len(times[time_range]) - 1].overlap(target_state)), 1 - res_goat_time.infidelity, atol=1e-3) -assert res_goat_global.infidelity < 0.001 -assert np.abs(evolution_global.states[len(times[global_range]) - 1].overlap(target_state)) > 1 - 0.001 +```python +assert res_goat.infidelity < 0.1 +assert res_goat_time.infidelity < 0.01 +assert res_goat_global.infidelity < 0.01 ``` + ```python qt.about() ``` + + QuTiP: Quantum Toolbox in Python + ================================ + Copyright (c) QuTiP team 2011 and later. + Current admin team: Alexander Pitchford, Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguère, Boxi Li, Simon Cross, Asier Galicia, Paul Menczel, and Patrick Hopf. + Board members: Daniel Burgarth, Robert Johansson, Anton F. Kockum, Franco Nori and Will Zeng. + Original developers: R. J. Johansson & P. D. Nation. + Previous lead developers: Chris Granade & A. Grimsmo. + Currently developed through wide collaboration. See https://github.com/qutip for details. + + QuTiP Version: 5.1.1 + Numpy Version: 1.26.4 + Scipy Version: 1.15.2 + Cython Version: None + Matplotlib Version: 3.10.0 + Python Version: 3.12.10 + Number of CPUs: 8 + BLAS Info: Generic + INTEL MKL Ext: None + Platform Info: Windows (AMD64) + Installation path: c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\qutip + + Installed QuTiP family packages + ------------------------------- + + qutip-jax: 0.1.0 + qutip-qtrl: 0.1.5 + + ================================================================================ + Please cite QuTiP in your publication. + ================================================================================ + For your convenience a bibtex reference can be easily generated using `qutip.cite()` + + + ```python ``` diff --git a/tests/interactive/GRAPE_gate_open.md b/tests/interactive/GRAPE_gate_open.md index 1f4bc98..80c35a3 100644 --- a/tests/interactive/GRAPE_gate_open.md +++ b/tests/interactive/GRAPE_gate_open.md @@ -1,19 +1,6 @@ ---- -jupyter: - jupytext: - text_representation: - extension: .md - format_name: markdown - format_version: '1.3' - jupytext_version: 1.16.7 - kernelspec: - display_name: qutip-dev - language: python - name: python3 ---- - # GRAPE algorithm for 2 level system + ```python import matplotlib.pyplot as plt import numpy as np @@ -24,6 +11,7 @@ from qutip_qoc import Objective, optimize_pulses ## Problem setup + ```python hbar = 1 omega = 0.1 # energy splitting @@ -48,19 +36,51 @@ times = np.linspace(0, np.pi / 2, 250) ## Guess + ```python grape_guess = np.sin(times) + +H_result_guess = [Hd, + [Hc[0], grape_guess], + [Hc[1], grape_guess], + [Hc[2], grape_guess]] + +identity_op = qt.qeye(2) +identity_super = qt.spre(identity_op) + +evolution_guess = qt.mesolve(H_result_guess, identity_super, times) + +target_super = qt.to_super(target_gate) +initial_super = qt.to_super(initial_gate) + +initial_overlaps_guess = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution_guess.states] +target_overlaps_guess = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution_guess.states] + +plt.plot(times, initial_overlaps_guess, label="Overlap with initial gate") +plt.plot(times, target_overlaps_guess, label="Overlap with target gate") +plt.title("Guess performance") +plt.xlabel("Time") +plt.legend() +plt.show() + ``` + + +![png](GRAPE_gate_open_files/GRAPE_gate_open_5_0.png) + + + ## Grape algorithm + ```python control_params = { "ctrl_x": {"guess": np.sin(times), "bounds": [-1, 1]}, "ctrl_y": {"guess": np.cos(times), "bounds": [-1, 1]}, "ctrl_z": {"guess": np.tanh(times), "bounds": [-1, 1]}, } -alg_args = {"alg": "GRAPE", "fid_err_targ": 0.001} +alg_args = {"alg": "GRAPE", "fid_err_targ": 0.01} res_grape = optimize_pulses( objectives=Objective(initial_gate, H, target_gate), @@ -69,7 +89,6 @@ res_grape = optimize_pulses( algorithm_kwargs=alg_args, ) - print('Infidelity: ', res_grape.infidelity) plt.plot(times, res_grape.optimized_controls[0], label='optimized pulse sx') @@ -82,6 +101,16 @@ plt.legend() plt.show() ``` + Infidelity: 0.006817967340126763 + + + + +![png](GRAPE_gate_open_files/GRAPE_gate_open_7_1.png) + + + + ```python H_result = [Hd, [Hc[0], res_grape.optimized_controls[0]], @@ -109,14 +138,56 @@ plt.show() ``` + + +![png](GRAPE_gate_open_files/GRAPE_gate_open_8_0.png) + + + ## Validation + ```python assert res_grape.infidelity < 0.01 ``` + ```python qt.about() ``` + + QuTiP: Quantum Toolbox in Python + ================================ + Copyright (c) QuTiP team 2011 and later. + Current admin team: Alexander Pitchford, Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguère, Boxi Li, Simon Cross, Asier Galicia, Paul Menczel, and Patrick Hopf. + Board members: Daniel Burgarth, Robert Johansson, Anton F. Kockum, Franco Nori and Will Zeng. + Original developers: R. J. Johansson & P. D. Nation. + Previous lead developers: Chris Granade & A. Grimsmo. + Currently developed through wide collaboration. See https://github.com/qutip for details. + + QuTiP Version: 5.1.1 + Numpy Version: 1.26.4 + Scipy Version: 1.15.2 + Cython Version: None + Matplotlib Version: 3.10.0 + Python Version: 3.12.10 + Number of CPUs: 8 + BLAS Info: Generic + INTEL MKL Ext: None + Platform Info: Windows (AMD64) + Installation path: c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\qutip + + Installed QuTiP family packages + ------------------------------- + + qutip-jax: 0.1.0 + qutip-qtrl: 0.1.5 + + ================================================================================ + Please cite QuTiP in your publication. + ================================================================================ + For your convenience a bibtex reference can be easily generated using `qutip.cite()` + + diff --git a/tests/interactive/GRAPE_state_open.md b/tests/interactive/GRAPE_state_open.md index 92686d4..f83289a 100644 --- a/tests/interactive/GRAPE_state_open.md +++ b/tests/interactive/GRAPE_state_open.md @@ -1,19 +1,6 @@ ---- -jupyter: - jupytext: - text_representation: - extension: .md - format_name: markdown - format_version: '1.3' - jupytext_version: 1.16.7 - kernelspec: - display_name: qutip-dev - language: python - name: python3 ---- - # GRAPE algorithm for 2 level system + ```python import matplotlib.pyplot as plt import numpy as np @@ -26,6 +13,7 @@ import logging ## Problem setup + ```python # Energy levels E1, E2 = 1.0, 2.0 @@ -53,11 +41,12 @@ times = np.linspace(0, 2 * np.pi, 250) ## Guess + ```python grape_guess = np.sin(times) -Hresult_guess = [Hd, [Hc, grape_guess]] -evolution_guess = qt.mesolve(Hresult_guess, initial_state, times) +H_result_guess = [Hd, [Hc, grape_guess]] +evolution_guess = qt.mesolve(H_result_guess, initial_state, times) print('Fidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) @@ -70,8 +59,18 @@ plt.xlabel("Time") plt.show() ``` + Fidelity: 0.4768516474214033 + + + + +![png](GRAPE_state_open_files/GRAPE_state_open_5_1.png) + + + ## GRAPE algorithm + ```python alg_args = {"alg": "GRAPE", "fid_err_targ": 0.001, "log_level": logging.DEBUG - 2} control_params = { @@ -96,6 +95,3750 @@ plt.legend() plt.show() ``` + DEBUG:qutip_qtrl.pulseoptim:Optimisation config summary... + object classes: + optimizer: OptimizerLBFGSB + dynamics: DynamicsGenMat + tslotcomp: TSlotCompUpdateAll + fidcomp: FidCompTraceDiff + propcomp: PropCompFrechet + pulsegen: PulseGenRandom + INFO:qutip_qtrl.dynamics:Setting memory optimisations for level 0 + INFO:qutip_qtrl.dynamics:Internal operator data type choosen to be + INFO:qutip_qtrl.dynamics:phased dynamics generator caching False + INFO:qutip_qtrl.dynamics:propagator gradient caching True + INFO:qutip_qtrl.dynamics:eigenvector adjoint caching True + INFO:qutip_qtrl.dynamics:use sparse eigen decomp False + DEBUG:qutip_qtrl.fidcomp:Scale factor calculated as 0.125 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.77189877-2.55094136e-17j] + [-0.06888728+2.98015228e-02j] + [-0.06888728-2.98015228e-02j] + [ 0.22810123+3.09932752e-17j]] + Evo final diff: + [[-0.77189877+2.55094136e-17j] + [ 0.06888728-2.98015228e-02j] + [ 0.06888728+2.98015228e-02j] + [ 0.77189877-3.09932752e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.15036532376635012 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0045647848138128475 + DEBUG:qutip_qtrl.tslotcomp:250 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.77183948+2.11668240e-17j] + [-0.06878968+3.01708340e-02j] + [-0.06878968-3.01708340e-02j] + [ 0.22816052-3.88175187e-17j]] + Evo final diff: + [[-0.77183948-2.11668240e-17j] + [ 0.06878968-3.01708340e-02j] + [ 0.06878968+3.01708340e-02j] + [ 0.77183948+3.88175187e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.15034462159320172 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.004587903075889462 + DEBUG:qutip_qtrl.tslotcomp:246 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.77177915+1.40721819e-16j] + [-0.06869664+3.05472003e-02j] + [-0.06869664-3.05472003e-02j] + [ 0.22822085-1.30622752e-16j]] + Evo final diff: + [[-0.77177915-1.40721819e-16j] + [ 0.06869664-3.05472003e-02j] + [ 0.06869664+3.05472003e-02j] + [ 0.77177915+1.30622752e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.15032385401393628 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.004611869361896642 + DEBUG:qutip_qtrl.tslotcomp:245 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.7717178 -1.27328110e-16j] + [-0.06860605+3.09304740e-02j] + [-0.06860605-3.09304740e-02j] + [ 0.2282822 +1.19721597e-16j]] + Evo final diff: + [[-0.7717178 +1.27328110e-16j] + [ 0.06860605-3.09304740e-02j] + [ 0.06860605+3.09304740e-02j] + [ 0.7717178 -1.19721597e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.15030296035733728 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.004636702772677686 + DEBUG:qutip_qtrl.tslotcomp:243 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.77165535+5.88065328e-17j] + [-0.06851891+3.13212862e-02j] + [-0.06851891-3.13212862e-02j] + [ 0.22834465-8.84404665e-17j]] + Evo final diff: + [[-0.77165535-5.88065328e-17j] + [ 0.06851891-3.13212862e-02j] + [ 0.06851891+3.13212862e-02j] + [ 0.77165535+8.84404665e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1502819613893671 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.004662458936031275 + DEBUG:qutip_qtrl.tslotcomp:243 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.77160369-1.56147982e-16j] + [-0.06844693+3.16424209e-02j] + [-0.06844693-3.16424209e-02j] + [ 0.22839631+1.61263908e-16j]] + Evo final diff: + [[-0.77160369+1.56147982e-16j] + [ 0.06844693-3.16424209e-02j] + [ 0.06844693+3.16424209e-02j] + [ 0.77160369-1.61263908e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.15026461863006424 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.004683963412756786 + DEBUG:qutip_qtrl.tslotcomp:242 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.77153912-2.09592373e-16j] + [-0.06836152+3.20493470e-02j] + [-0.06836152-3.20493470e-02j] + [ 0.22846088+2.41356774e-16j]] + Evo final diff: + [[-0.77153912+2.09592373e-16j] + [ 0.06836152-3.20493470e-02j] + [ 0.06836152+3.20493470e-02j] + [ 0.77153912-2.41356774e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.15024327002109059 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.004711635679508653 + DEBUG:qutip_qtrl.tslotcomp:241 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.77147339-7.78719737e-17j] + [-0.06827832+3.24638088e-02j] + [-0.06827832-3.24638088e-02j] + [ 0.22852661+8.00011105e-17j]] + Evo final diff: + [[-0.77147339+7.78719737e-17j] + [ 0.06827832-3.24638088e-02j] + [ 0.06827832+3.24638088e-02j] + [ 0.77147339-8.00011105e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.15022175486668604 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0047402962406730585 + DEBUG:qutip_qtrl.tslotcomp:240 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.77140648+2.80046031e-17j] + [-0.06819712+3.28860163e-02j] + [-0.06819712-3.28860163e-02j] + [ 0.22859352-3.81147377e-17j]] + Evo final diff: + [[-0.77140648-2.80046031e-17j] + [ 0.06819712-3.28860163e-02j] + [ 0.06819712+3.28860163e-02j] + [ 0.77140648+3.81147377e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1502000733832908 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.004769979617145052 + DEBUG:qutip_qtrl.tslotcomp:240 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.77125928-2.61512952e-17j] + [-0.0680189 +3.38029002e-02j] + [-0.0680189 -3.38029002e-02j] + [ 0.22874072+5.76477707e-18j]] + Evo final diff: + [[-0.77125928+2.61512952e-17j] + [ 0.0680189 -3.38029002e-02j] + [ 0.0680189 +3.38029002e-02j] + [ 0.77125928-5.76477707e-18j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.15015251951338354 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.004836150174125501 + DEBUG:qutip_qtrl.tslotcomp:239 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.77118807+1.22057448e-17j] + [-0.06793595+3.42564861e-02j] + [-0.06793595-3.42564861e-02j] + [ 0.22881193-7.62023164e-19j]] + Evo final diff: + [[-0.77118807-1.22057448e-17j] + [ 0.06793595-3.42564861e-02j] + [ 0.06793595+3.42564861e-02j] + [ 0.77118807+7.62023164e-19j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.15012995838876778 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.004869736714693404 + DEBUG:qutip_qtrl.tslotcomp:239 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.77115973+1.17718943e-16j] + [-0.06790298+3.44358790e-02j] + [-0.06790298-3.44358790e-02j] + [ 0.22884027-1.28526484e-16j]] + Evo final diff: + [[-0.77115973-1.17718943e-16j] + [ 0.06790298-3.44358790e-02j] + [ 0.06790298+3.44358790e-02j] + [ 0.77115973+1.28526484e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.15012099202714108 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.004883171298510743 + DEBUG:qutip_qtrl.tslotcomp:238 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.77108648+1.01261093e-16j] + [-0.06782731+3.49004135e-02j] + [-0.06782731-3.49004135e-02j] + [ 0.22891352-1.05943800e-16j]] + Evo final diff: + [[-0.77108648-1.01261093e-16j] + [ 0.06782731-3.49004135e-02j] + [ 0.06782731+3.49004135e-02j] + [ 0.77108648+1.05943800e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1500982352062954 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0049183050014321335 + DEBUG:qutip_qtrl.tslotcomp:236 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.77101167-1.58451063e-16j] + [-0.06775199+3.53753146e-02j] + [-0.06775199-3.53753146e-02j] + [ 0.22898833+1.42781948e-16j]] + Evo final diff: + [[-0.77101167+1.58451063e-16j] + [ 0.06775199-3.53753146e-02j] + [ 0.06775199+3.53753146e-02j] + [ 0.77101167-1.42781948e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.15007518435797793 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.004954795160336729 + DEBUG:qutip_qtrl.tslotcomp:236 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.77070543+2.84974062e-16j] + [-0.06744441+3.72748920e-02j] + [-0.06744441-3.72748920e-02j] + [ 0.22929457-2.86800334e-16j]] + Evo final diff: + [[-0.77070543-2.84974062e-16j] + [ 0.06744441-3.72748920e-02j] + [ 0.06744441+3.72748920e-02j] + [ 0.77070543+2.86800334e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1499812557582843 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.00510634922996008 + DEBUG:qutip_qtrl.tslotcomp:236 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.7706754 +1.79711587e-16j] + [-0.06741431+3.74574774e-02j] + [-0.06741431-3.74574774e-02j] + [ 0.2293246 -1.73633551e-16j]] + Evo final diff: + [[-0.7706754 -1.79711587e-16j] + [ 0.06741431-3.74574774e-02j] + [ 0.06741431+3.74574774e-02j] + [ 0.7706754 +1.73633551e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1499720816101175 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.005121371114696426 + DEBUG:qutip_qtrl.tslotcomp:235 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.77059155+9.70869127e-17j] + [-0.06733804+3.79884020e-02j] + [-0.06733804-3.79884020e-02j] + [ 0.22940845-1.03221474e-16j]] + Evo final diff: + [[-0.77059155-9.70869127e-17j] + [ 0.06733804-3.79884020e-02j] + [ 0.06733804+3.79884020e-02j] + [ 0.77059155+1.03221474e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1499472181273278 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.005165475053769101 + DEBUG:qutip_qtrl.tslotcomp:235 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.77050403+7.53639071e-17j] + [-0.06725851+3.85367553e-02j] + [-0.06725851-3.85367553e-02j] + [ 0.22949597-5.80013822e-17j]] + Evo final diff: + [[-0.77050403-7.53639071e-17j] + [ 0.06725851-3.85367553e-02j] + [ 0.06725851+3.85367553e-02j] + [ 0.77050403+5.80013822e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1499213110823868 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.005211694407456673 + DEBUG:qutip_qtrl.tslotcomp:234 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.77041598-4.61548226e-17j] + [-0.06718426+3.90903520e-02j] + [-0.06718426-3.90903520e-02j] + [ 0.22958402+5.80490602e-17j]] + Evo final diff: + [[-0.77041598+4.61548226e-17j] + [ 0.06718426-3.90903520e-02j] + [ 0.06718426+3.90903520e-02j] + [ 0.77041598-5.80490602e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1498956394029262 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.005259008966628942 + DEBUG:qutip_qtrl.tslotcomp:234 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.7703487 -2.27062418e-16j] + [-0.06712757+3.95093047e-02j] + [-0.06712757-3.95093047e-02j] + [ 0.2296513 +2.08090810e-16j]] + Evo final diff: + [[-0.7703487 +2.27062418e-16j] + [ 0.06712757-3.95093047e-02j] + [ 0.06712757+3.95093047e-02j] + [ 0.7703487 -2.08090810e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14987605470290266 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.005295254196829969 + DEBUG:qutip_qtrl.tslotcomp:233 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.77025662+7.73849242e-18j] + [-0.06705288+4.00861662e-02j] + [-0.06705288-4.00861662e-02j] + [ 0.22974338-1.06700051e-17j]] + Evo final diff: + [[-0.77025662-7.73849242e-18j] + [ 0.06705288-4.00861662e-02j] + [ 0.06705288+4.00861662e-02j] + [ 0.77025662+1.06700051e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14984956260293078 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.005345766414596359 + DEBUG:qutip_qtrl.tslotcomp:233 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.77014532-5.51960516e-17j] + [-0.06696267+4.07748148e-02j] + [-0.06696267-4.07748148e-02j] + [ 0.22985468+5.32329613e-17j]] + Evo final diff: + [[-0.77014532+5.51960516e-17j] + [ 0.06696267-4.07748148e-02j] + [ 0.06696267+4.07748148e-02j] + [ 0.77014532-5.32329613e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14981760064067148 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0054069598138275846 + DEBUG:qutip_qtrl.tslotcomp:232 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.77004778-2.97572818e-16j] + [-0.06688661+4.13813427e-02j] + [-0.06688661-4.13813427e-02j] + [ 0.22995222+2.98558151e-16j]] + Evo final diff: + [[-0.77004778+2.97572818e-16j] + [ 0.06688661-4.13813427e-02j] + [ 0.06688661+4.13813427e-02j] + [ 0.77004778-2.98558151e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14978995562149755 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.00546164189499911 + DEBUG:qutip_qtrl.tslotcomp:232 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.77004778-2.13858864e-16j] + [-0.06688661+4.13813660e-02j] + [-0.06688661-4.13813660e-02j] + [ 0.22995222+2.06379278e-16j]] + Evo final diff: + [[-0.77004778+2.13858864e-16j] + [ 0.06688661-4.13813660e-02j] + [ 0.06688661+4.13813660e-02j] + [ 0.77004778-2.06379278e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14978995455654862 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.005461644004449913 + DEBUG:qutip_qtrl.tslotcomp:231 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.76994788-2.15691840e-16j] + [-0.06681423+4.19987925e-02j] + [-0.06681423-4.19987925e-02j] + [ 0.23005212+2.35671921e-16j]] + Evo final diff: + [[-0.76994788+2.15691840e-16j] + [ 0.06681423-4.19987925e-02j] + [ 0.06681423+4.19987925e-02j] + [ 0.76994788-2.35671921e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14976194316334568 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.005518008991489866 + DEBUG:qutip_qtrl.tslotcomp:231 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.76953622+5.10422021e-17j] + [-0.06651603+4.44683426e-02j] + [-0.06651603-4.44683426e-02j] + [ 0.23046378-3.06618180e-17j]] + Evo final diff: + [[-0.76953622-5.10422021e-17j] + [ 0.06651603-4.44683426e-02j] + [ 0.06651603+4.44683426e-02j] + [ 0.76953622+3.06618180e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14964695200330014 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.005750410323258551 + DEBUG:qutip_qtrl.tslotcomp:231 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.76948242+1.04422209e-16j] + [-0.06647706+4.47827260e-02j] + [-0.06647706-4.47827260e-02j] + [ 0.23051758-1.12913995e-16j]] + Evo final diff: + [[-0.76948242-1.04422209e-16j] + [ 0.06647706-4.47827260e-02j] + [ 0.06647706+4.47827260e-02j] + [ 0.76948242+1.12913995e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1496319734342141 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.005780753455337895 + DEBUG:qutip_qtrl.tslotcomp:230 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.76936661-1.26207892e-16j] + [-0.0664024 +4.54761475e-02j] + [-0.0664024 -4.54761475e-02j] + [ 0.23063339+1.46787011e-16j]] + Evo final diff: + [[-0.76936661+1.26207892e-16j] + [ 0.0664024 -4.54761475e-02j] + [ 0.0664024 +4.54761475e-02j] + [ 0.76936661-1.46787011e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14960058379623659 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.005848237608974934 + DEBUG:qutip_qtrl.tslotcomp:230 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.76922636-4.78742954e-17j] + [-0.06631196+4.63037782e-02j] + [-0.06631196-4.63037782e-02j] + [ 0.23077364+5.14492464e-17j]] + Evo final diff: + [[-0.76922636+4.78742954e-17j] + [ 0.06631196-4.63037782e-02j] + [ 0.06631196+4.63037782e-02j] + [ 0.76922636-5.14492464e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.149562628360543 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.005929783212781529 + DEBUG:qutip_qtrl.tslotcomp:229 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.76910323-3.12267121e-16j] + [-0.06623954+4.70288504e-02j] + [-0.06623954-4.70288504e-02j] + [ 0.23089677+3.14750096e-16j]] + Evo final diff: + [[-0.76910323+3.12267121e-16j] + [ 0.06623954-4.70288504e-02j] + [ 0.06623954+4.70288504e-02j] + [ 0.76910323-3.14750096e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14952979306786862 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.006002055609451695 + DEBUG:qutip_qtrl.tslotcomp:229 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.76882804+9.48405649e-17j] + [-0.06607742+4.86147590e-02j] + [-0.06607742-4.86147590e-02j] + [ 0.23117196-1.20738295e-16j]] + Evo final diff: + [[-0.76882804-9.48405649e-17j] + [ 0.06607742-4.86147590e-02j] + [ 0.06607742+4.86147590e-02j] + [ 0.76882804+1.20738295e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1494565422264255 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.006162805692159602 + DEBUG:qutip_qtrl.tslotcomp:228 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.76869242-1.32726646e-16j] + [-0.06600174+4.93936816e-02j] + [-0.06600174-4.93936816e-02j] + [ 0.23130758+1.58832098e-16j]] + Evo final diff: + [[-0.76869242+1.32726646e-16j] + [ 0.06600174-4.93936816e-02j] + [ 0.06600174+4.93936816e-02j] + [ 0.76869242-1.58832098e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14942100013087564 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0062430387096873265 + DEBUG:qutip_qtrl.tslotcomp:228 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.76813485+1.03087271e-16j] + [-0.06568986+5.24849732e-02j] + [-0.06568986-5.24849732e-02j] + [ 0.23186515-1.14254687e-16j]] + Evo final diff: + [[-0.76813485-1.03087271e-16j] + [ 0.06568986-5.24849732e-02j] + [ 0.06568986+5.24849732e-02j] + [ 0.76813485+1.14254687e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14927524457291205 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.006569083324916834 + DEBUG:qutip_qtrl.tslotcomp:227 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.76797714-1.02145374e-16j] + [-0.06561178+5.33489773e-02j] + [-0.06561178-5.33489773e-02j] + [ 0.23202286+9.08441224e-17j]] + Evo final diff: + [[-0.76797714+1.02145374e-16j] + [ 0.06561178-5.33489773e-02j] + [ 0.06561178+5.33489773e-02j] + [ 0.76797714-9.08441224e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14923497606342362 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.006662193714221294 + DEBUG:qutip_qtrl.tslotcomp:227 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.76787816-1.72286453e-16j] + [-0.06556271+5.38845233e-02j] + [-0.06556271-5.38845233e-02j] + [ 0.23212184+1.84650925e-16j]] + Evo final diff: + [[-0.76787816+1.72286453e-16j] + [ 0.06556271-5.38845233e-02j] + [ 0.06556271+5.38845233e-02j] + [ 0.76787816-1.84650925e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14920971986666118 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.006720319708394118 + DEBUG:qutip_qtrl.tslotcomp:226 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.76771181-1.31229083e-16j] + [-0.06548706+5.47778875e-02j] + [-0.06548706-5.47778875e-02j] + [ 0.23228819+1.36316939e-16j]] + Evo final diff: + [[-0.76771181+1.31229083e-16j] + [ 0.06548706-5.47778875e-02j] + [ 0.06548706+5.47778875e-02j] + [ 0.76771181-1.36316939e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1491676467800418 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0068179342978206235 + DEBUG:qutip_qtrl.tslotcomp:226 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.76702056-1.20156666e-16j] + [-0.06517078+5.83495373e-02j] + [-0.06517078-5.83495373e-02j] + [ 0.23297944+1.13525377e-16j]] + Evo final diff: + [[-0.76702056+1.20156666e-16j] + [ 0.06517078-5.83495373e-02j] + [ 0.06517078+5.83495373e-02j] + [ 0.76702056-1.13525377e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14899311089617343 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0072160460650746786 + DEBUG:qutip_qtrl.tslotcomp:226 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.76668499-1.60224692e-16j] + [-0.06501627+6.00095078e-02j] + [-0.06501627-6.00095078e-02j] + [ 0.23331501+1.54517133e-16j]] + Evo final diff: + [[-0.76668499+1.60224692e-16j] + [ 0.06501627-6.00095078e-02j] + [ 0.06501627+6.00095078e-02j] + [ 0.76668499-1.54517133e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14890853335678722 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.007404976831375055 + DEBUG:qutip_qtrl.tslotcomp:225 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.76647752-3.76827907e-17j] + [-0.06493397+6.10382228e-02j] + [-0.06493397-6.10382228e-02j] + [ 0.23352248+2.67197039e-17j]] + Evo final diff: + [[-0.76647752+3.76827907e-17j] + [ 0.06493397-6.10382228e-02j] + [ 0.06493397+6.10382228e-02j] + [ 0.76647752-2.67197039e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14885746656123683 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0075231231693443 + DEBUG:qutip_qtrl.tslotcomp:225 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.76561307-1.50751468e-16j] + [-0.0645886 +6.51496310e-02j] + [-0.0645886 -6.51496310e-02j] + [ 0.23438693+1.32237557e-16j]] + Evo final diff: + [[-0.76561307+1.50751468e-16j] + [ 0.0645886 -6.51496310e-02j] + [ 0.0645886 +6.51496310e-02j] + [ 0.76561307-1.32237557e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14864488392760608 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.008003096449816978 + DEBUG:qutip_qtrl.tslotcomp:225 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.76535417-1.15040567e-16j] + [-0.06448449+6.63311800e-02j] + [-0.06448449-6.63311800e-02j] + [ 0.23464583+1.08198358e-16j]] + Evo final diff: + [[-0.76535417+1.15040567e-16j] + [ 0.06448449-6.63311800e-02j] + [ 0.06448449+6.63311800e-02j] + [ 0.76535417-1.08198358e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14858126913238895 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.008143139088336046 + DEBUG:qutip_qtrl.tslotcomp:224 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.76509764+1.42755457e-16j] + [-0.0643946 +6.74994960e-02j] + [-0.0643946 -6.74994960e-02j] + [ 0.23490236-1.53228477e-16j]] + Evo final diff: + [[-0.76509764-1.42755457e-16j] + [ 0.0643946 -6.74994960e-02j] + [ 0.0643946 +6.74994960e-02j] + [ 0.76509764+1.53228477e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14851931020317485 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.008282389953314187 + DEBUG:qutip_qtrl.tslotcomp:224 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.76472984-1.31703374e-16j] + [-0.06426517+6.91391073e-02j] + [-0.06426517-6.91391073e-02j] + [ 0.23527016+1.36538489e-16j]] + Evo final diff: + [[-0.76472984+1.31703374e-16j] + [ 0.06426517-6.91391073e-02j] + [ 0.06426517+6.91391073e-02j] + [ 0.76472984-1.36538489e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1484304875308462 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.008479143336343914 + DEBUG:qutip_qtrl.tslotcomp:223 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.76445043-1.83047089e-16j] + [-0.06417583+7.03657098e-02j] + [-0.06417583-7.03657098e-02j] + [ 0.23554957+1.81247991e-16j]] + Evo final diff: + [[-0.76445043+1.83047089e-16j] + [ 0.06417583-7.03657098e-02j] + [ 0.06417583+7.03657098e-02j] + [ 0.76445043-1.81247991e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14836358394270233 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.008627229039483111 + DEBUG:qutip_qtrl.tslotcomp:223 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.76408158-2.58493949e-16j] + [-0.0640573 +7.19516561e-02j] + [-0.0640573 -7.19516561e-02j] + [ 0.23591842+2.52982728e-16j]] + Evo final diff: + [[-0.76408158+2.58493949e-16j] + [ 0.0640573 -7.19516561e-02j] + [ 0.0640573 +7.19516561e-02j] + [ 0.76408158-2.52982728e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14827525883941334 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.008819840297384056 + DEBUG:qutip_qtrl.tslotcomp:222 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.76377701-7.49657543e-17j] + [-0.06396241+7.32411087e-02j] + [-0.06396241-7.32411087e-02j] + [ 0.23622299+6.72159694e-17j]] + Evo final diff: + [[-0.76377701+7.49657543e-17j] + [ 0.06396241-7.32411087e-02j] + [ 0.06396241+7.32411087e-02j] + [ 0.76377701-6.72159694e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1482026935754332 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.00897731903198797 + DEBUG:qutip_qtrl.tslotcomp:222 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.76250371-6.08101511e-17j] + [-0.06356174+7.83902979e-02j] + [-0.06356174-7.83902979e-02j] + [ 0.23749629+4.20703986e-17j]] + Evo final diff: + [[-0.76250371+6.08101511e-17j] + [ 0.06356174-7.83902979e-02j] + [ 0.06356174+7.83902979e-02j] + [ 0.76250371-4.20703986e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14789925896299908 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.009613410629698838 + DEBUG:qutip_qtrl.tslotcomp:222 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.76210324-9.78356040e-17j] + [-0.0634346 +7.99371549e-02j] + [-0.0634346 -7.99371549e-02j] + [ 0.23789676+9.42272214e-17j]] + Evo final diff: + [[-0.76210324+9.78356040e-17j] + [ 0.0634346 -7.99371549e-02j] + [ 0.0634346 +7.99371549e-02j] + [ 0.76210324-9.42272214e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14780381082268165 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.009806540598442064 + DEBUG:qutip_qtrl.tslotcomp:225 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.76172197+6.92533513e-17j] + [-0.06332874+8.13972831e-02j] + [-0.06332874-8.13972831e-02j] + [ 0.23827803-6.20161667e-17j]] + Evo final diff: + [[-0.76172197-6.92533513e-17j] + [ 0.06332874-8.13972831e-02j] + [ 0.06332874+8.13972831e-02j] + [ 0.76172197+6.20161667e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14771410153424488 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.009989482248806253 + DEBUG:qutip_qtrl.tslotcomp:225 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.76134696-7.44981707e-17j] + [-0.06322419+8.28062610e-02j] + [-0.06322419-8.28062610e-02j] + [ 0.23865304+6.74565076e-17j]] + Evo final diff: + [[-0.76134696+7.44981707e-17j] + [ 0.06322419-8.28062610e-02j] + [ 0.06322419+8.28062610e-02j] + [ 0.76134696-6.74565076e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14762584364038395 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.01016668750784279 + DEBUG:qutip_qtrl.tslotcomp:225 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.76093571-2.86405250e-16j] + [-0.06311941+8.43251460e-02j] + [-0.06311941-8.43251460e-02j] + [ 0.23906429+2.76667005e-16j]] + Evo final diff: + [[-0.76093571+2.86405250e-16j] + [ 0.06311941-8.43251460e-02j] + [ 0.06311941+8.43251460e-02j] + [ 0.76093571-2.76667005e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1475294865389161 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.010358363315847515 + DEBUG:qutip_qtrl.tslotcomp:225 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.7592134 -2.41302423e-16j] + [-0.06267519+9.03846995e-02j] + [-0.06267519-9.03846995e-02j] + [ 0.2407866 +2.42893332e-16j]] + Evo final diff: + [[-0.7592134 +2.41302423e-16j] + [ 0.06267519-9.03846995e-02j] + [ 0.06267519+9.03846995e-02j] + [ 0.7592134 -2.42893332e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1471256381754032 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.011129549789216958 + DEBUG:qutip_qtrl.tslotcomp:225 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.75860469-1.16619341e-16j] + [-0.06251641+9.24221423e-02j] + [-0.06251641-9.24221423e-02j] + [ 0.24139531+1.09256970e-16j]] + Evo final diff: + [[-0.75860469+1.16619341e-16j] + [ 0.06251641-9.24221423e-02j] + [ 0.06251641+9.24221423e-02j] + [ 0.75860469-1.09256970e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14698280674340142 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.011390945064876966 + DEBUG:qutip_qtrl.tslotcomp:229 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.75808376-1.64798275e-17j] + [-0.06239916+9.41413961e-02j] + [-0.06239916-9.41413961e-02j] + [ 0.24191624+3.19520535e-17j]] + Evo final diff: + [[-0.75808376+1.64798275e-17j] + [ 0.06239916-9.41413961e-02j] + [ 0.06239916+9.41413961e-02j] + [ 0.75808376-3.19520535e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1468618118606218 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.011612051434936736 + DEBUG:qutip_qtrl.tslotcomp:229 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.75589997-3.00391237e-16j] + [-0.06190185+1.00993292e-01j] + [-0.06190185-1.00993292e-01j] + [ 0.24410003+2.96853700e-16j]] + Evo final diff: + [[-0.75589997+3.00391237e-16j] + [ 0.06190185-1.00993292e-01j] + [ 0.06190185+1.00993292e-01j] + [ 0.75589997-2.96853700e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14635406186471064 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.01249906868426023 + DEBUG:qutip_qtrl.tslotcomp:229 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.75522407-3.38663468e-16j] + [-0.06174636+1.03009891e-01j] + [-0.06174636-1.03009891e-01j] + [ 0.24477593+3.38545680e-16j]] + Evo final diff: + [[-0.75522407+3.38663468e-16j] + [ 0.06174636-1.03009891e-01j] + [ 0.06174636+1.03009891e-01j] + [ 0.75522407-3.38545680e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14619676207164434 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.01276171507999066 + DEBUG:qutip_qtrl.tslotcomp:228 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.75456473-1.45174409e-16j] + [-0.06161481+1.04944596e-01j] + [-0.06161481-1.04944596e-01j] + [ 0.24543527+1.34732021e-16j]] + Evo final diff: + [[-0.75456473+1.45174409e-16j] + [ 0.06161481-1.04944596e-01j] + [ 0.06161481+1.04944596e-01j] + [ 0.75456473-1.34732021e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14604442241061646 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.013014106977598075 + DEBUG:qutip_qtrl.tslotcomp:228 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.75400074-2.07637869e-16j] + [-0.06150177+1.06567497e-01j] + [-0.06150177-1.06567497e-01j] + [ 0.24599926+1.97342137e-16j]] + Evo final diff: + [[-0.75400074+2.07637869e-16j] + [ 0.06150177-1.06567497e-01j] + [ 0.06150177+1.06567497e-01j] + [ 0.75400074-1.97342137e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14591405262312274 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.013226243087505554 + DEBUG:qutip_qtrl.tslotcomp:227 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.75329322-3.41590726e-16j] + [-0.06137171+1.08567516e-01j] + [-0.06137171-1.08567516e-01j] + [ 0.24670678+3.39017993e-16j]] + Evo final diff: + [[-0.75329322+3.41590726e-16j] + [ 0.06137171-1.08567516e-01j] + [ 0.06137171+1.08567516e-01j] + [ 0.75329322-3.39017993e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14575101699673845 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.013488035471472409 + DEBUG:qutip_qtrl.tslotcomp:227 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.75032552-4.80734022e-16j] + [-0.06081948+1.16524014e-01j] + [-0.06081948-1.16524014e-01j] + [ 0.24967448+4.80915113e-16j]] + Evo final diff: + [[-0.75032552+4.80734022e-16j] + [ 0.06081948-1.16524014e-01j] + [ 0.06081948+1.16524014e-01j] + [ 0.75032552-4.80915113e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14506631033593037 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.014534290505311243 + DEBUG:qutip_qtrl.tslotcomp:227 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.74812307-2.06065599e-16j] + [-0.06040439+1.22036372e-01j] + [-0.06040439-1.22036372e-01j] + [ 0.25187693+2.02477618e-16j]] + Evo final diff: + [[-0.74812307+2.06065599e-16j] + [ 0.06040439-1.22036372e-01j] + [ 0.06040439+1.22036372e-01j] + [ 0.74812307-2.02477618e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14455742521549136 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.015263009664036133 + DEBUG:qutip_qtrl.tslotcomp:226 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.74717651-1.25265637e-16j] + [-0.06024967+1.24328138e-01j] + [-0.06024967-1.24328138e-01j] + [ 0.25282349+1.26390254e-16j]] + Evo final diff: + [[-0.74717651+1.25265637e-16j] + [ 0.06024967-1.24328138e-01j] + [ 0.06024967+1.24328138e-01j] + [ 0.74717651-1.26390254e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14434006304096134 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.01556638707147303 + DEBUG:qutip_qtrl.tslotcomp:226 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.74622892-2.52875771e-16j] + [-0.06009432+1.26572029e-01j] + [-0.06009432-1.26572029e-01j] + [ 0.25377108+2.69034232e-16j]] + Evo final diff: + [[-0.74622892+2.52875771e-16j] + [ 0.06009432-1.26572029e-01j] + [ 0.06009432+1.26572029e-01j] + [ 0.74622892-2.69034232e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14412235331786286 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.01586381333505983 + DEBUG:qutip_qtrl.tslotcomp:225 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.74520604-1.76819258e-16j] + [-0.05994057+1.28941675e-01j] + [-0.05994057-1.28941675e-01j] + [ 0.25479396+1.73642552e-16j]] + Evo final diff: + [[-0.74520604+1.76819258e-16j] + [ 0.05994057-1.28941675e-01j] + [ 0.05994057+1.28941675e-01j] + [ 0.74520604-1.73642552e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14388771644252965 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.016178186421546756 + DEBUG:qutip_qtrl.tslotcomp:225 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.74091634-2.87190550e-16j] + [-0.05929076+1.38338465e-01j] + [-0.05929076-1.38338465e-01j] + [ 0.25908366+2.73786612e-16j]] + Evo final diff: + [[-0.74091634+2.87190550e-16j] + [ 0.05929076-1.38338465e-01j] + [ 0.05929076+1.38338465e-01j] + [ 0.74091634-2.73786612e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14290248850119172 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.017428168981806554 + DEBUG:qutip_qtrl.tslotcomp:225 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.74062063-3.15718456e-16j] + [-0.05924575+1.38957016e-01j] + [-0.05924575-1.38957016e-01j] + [ 0.25937937+3.14054176e-16j]] + Evo final diff: + [[-0.74062063+3.15718456e-16j] + [ 0.05924575-1.38957016e-01j] + [ 0.05924575+1.38957016e-01j] + [ 0.74062063-3.14054176e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1428345054298097 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.017510614819729996 + DEBUG:qutip_qtrl.tslotcomp:224 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.73937414-4.15681474e-16j] + [-0.05907625+1.41533582e-01j] + [-0.05907625-1.41533582e-01j] + [ 0.26062586+4.06640596e-16j]] + Evo final diff: + [[-0.73937414+4.15681474e-16j] + [ 0.05907625-1.41533582e-01j] + [ 0.05907625+1.41533582e-01j] + [ 0.73937414-4.06640596e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14254896842965076 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.01785388130329608 + DEBUG:qutip_qtrl.tslotcomp:224 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.73414975-1.61735124e-16j] + [-0.05836421+1.51726404e-01j] + [-0.05836421-1.51726404e-01j] + [ 0.26585025+1.54396872e-16j]] + Evo final diff: + [[-0.73414975+1.61735124e-16j] + [ 0.05836421-1.51726404e-01j] + [ 0.05836421+1.51726404e-01j] + [ 0.73414975-1.54396872e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1413507852618395 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.019214241062380285 + DEBUG:qutip_qtrl.tslotcomp:224 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.73369778-5.24209189e-16j] + [-0.0583026 +1.52566418e-01j] + [-0.0583026 -1.52566418e-01j] + [ 0.26630222+5.27488180e-16j]] + Evo final diff: + [[-0.73369778+5.24209189e-16j] + [ 0.0583026 -1.52566418e-01j] + [ 0.0583026 +1.52566418e-01j] + [ 0.73369778-5.27488180e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14124703274087408 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.019326496244075477 + DEBUG:qutip_qtrl.tslotcomp:223 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.73217753-2.38035378e-16j] + [-0.05811666+1.55351065e-01j] + [-0.05811666-1.55351065e-01j] + [ 0.26782247+2.39444850e-16j]] + Evo final diff: + [[-0.73217753+2.38035378e-16j] + [ 0.05811666-1.55351065e-01j] + [ 0.05811666+1.55351065e-01j] + [ 0.73217753-2.39444850e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14089885721301582 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.019698470198813694 + DEBUG:qutip_qtrl.tslotcomp:223 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.73137754-2.14833521e-16j] + [-0.05801886+1.56789710e-01j] + [-0.05801886-1.56789710e-01j] + [ 0.26862246+2.21132447e-16j]] + Evo final diff: + [[-0.73137754+2.14833521e-16j] + [ 0.05801886-1.56789710e-01j] + [ 0.05801886+1.56789710e-01j] + [ 0.73137754-2.21132447e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14071557611653554 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.019890710693953796 + DEBUG:qutip_qtrl.tslotcomp:222 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.72977185-2.52048580e-16j] + [-0.05783769+1.59626387e-01j] + [-0.05783769-1.59626387e-01j] + [ 0.27022815+2.45013017e-16j]] + Evo final diff: + [[-0.72977185+2.52048580e-16j] + [ 0.05783769-1.59626387e-01j] + [ 0.05783769+1.59626387e-01j] + [ 0.72977185-2.45013017e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14034818529570556 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.02026964795868936 + DEBUG:qutip_qtrl.tslotcomp:222 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.72305153-4.05055452e-16j] + [-0.05708328+1.70802420e-01j] + [-0.05708328-1.70802420e-01j] + [ 0.27694847+3.91369174e-16j]] + Evo final diff: + [[-0.72305153+4.05055452e-16j] + [ 0.05708328-1.70802420e-01j] + [ 0.05708328+1.70802420e-01j] + [ 0.72305153-3.91369174e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1388088711727402 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.02176359227660934 + DEBUG:qutip_qtrl.tslotcomp:222 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.72031644-3.06935652e-16j] + [-0.05677887+1.75063762e-01j] + [-0.05677887-1.75063762e-01j] + [ 0.27968356+2.96222417e-16j]] + Evo final diff: + [[-0.72031644+3.06935652e-16j] + [ 0.05677887-1.75063762e-01j] + [ 0.05677887+1.75063762e-01j] + [ 0.72031644-2.96222417e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.13818173275480042 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.022333461854079847 + DEBUG:qutip_qtrl.tslotcomp:221 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.71829552-2.74111542e-16j] + [-0.05657714+1.78122920e-01j] + [-0.05657714-1.78122920e-01j] + [ 0.28170448+2.66503711e-16j]] + Evo final diff: + [[-0.71829552+2.74111542e-16j] + [ 0.05657714-1.78122920e-01j] + [ 0.05657714+1.78122920e-01j] + [ 0.71829552-2.66503711e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.13771930071189628 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.022742088412171034 + DEBUG:qutip_qtrl.tslotcomp:221 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.71715224-3.37997683e-17j] + [-0.05646361+1.79819288e-01j] + [-0.05646361-1.79819288e-01j] + [ 0.28284776+3.32857249e-17j]] + Evo final diff: + [[-0.71715224+3.37997683e-17j] + [ 0.05646361-1.79819288e-01j] + [ 0.05646361+1.79819288e-01j] + [ 0.71715224-3.32857249e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.13745761136318932 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.022968666713719377 + DEBUG:qutip_qtrl.tslotcomp:220 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.71501756-5.14151823e-16j] + [-0.05626945+1.82922485e-01j] + [-0.05626945-1.82922485e-01j] + [ 0.28498244+5.28637815e-16j]] + Evo final diff: + [[-0.71501756+5.14151823e-16j] + [ 0.05626945-1.82922485e-01j] + [ 0.05626945+1.82922485e-01j] + [ 0.71501756-5.28637815e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.13696924903939514 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.023382984312986955 + DEBUG:qutip_qtrl.tslotcomp:220 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.70724479-3.80578935e-16j] + [-0.05557519+1.93583144e-01j] + [-0.05557519-1.93583144e-01j] + [ 0.29275521+3.65120435e-16j]] + Evo final diff: + [[-0.70724479+3.80578935e-16j] + [ 0.05557519-1.93583144e-01j] + [ 0.05557519+1.93583144e-01j] + [ 0.70724479-3.65120435e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.13518955822137682 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0248055696744206 + DEBUG:qutip_qtrl.tslotcomp:219 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.70476289-3.36966967e-16j] + [-0.05537687+1.96798521e-01j] + [-0.05537687-1.96798521e-01j] + [ 0.29523711+3.41867197e-16j]] + Evo final diff: + [[-0.70476289+3.36966967e-16j] + [ 0.05537687-1.96798521e-01j] + [ 0.05537687+1.96798521e-01j] + [ 0.70476289-3.41867197e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1346217477240938 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.025233893696598158 + DEBUG:qutip_qtrl.tslotcomp:219 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.69636021-6.66154244e-16j] + [-0.05472491+2.07074352e-01j] + [-0.05472491-2.07074352e-01j] + [ 0.30363979+6.55156393e-16j]] + Evo final diff: + [[-0.69636021+6.66154244e-16j] + [ 0.05472491-2.07074352e-01j] + [ 0.05472491+2.07074352e-01j] + [ 0.69636021-6.55156393e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.13269803577305936 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.026601139778172748 + DEBUG:qutip_qtrl.tslotcomp:218 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.69351084-7.00495450e-16j] + [-0.05452841+2.10362922e-01j] + [-0.05452841-2.10362922e-01j] + [ 0.30648916+7.15640631e-16j]] + Evo final diff: + [[-0.69351084+7.00495450e-16j] + [ 0.05452841-2.10362922e-01j] + [ 0.05452841+2.10362922e-01j] + [ 0.69351084-7.15640631e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.13204579882983583 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.027037884996739613 + DEBUG:qutip_qtrl.tslotcomp:218 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.69221895-4.13943992e-16j] + [-0.05444051+2.11823520e-01j] + [-0.05444051-2.11823520e-01j] + [ 0.30778105+4.07945453e-16j]] + Evo final diff: + [[-0.69221895+4.13943992e-16j] + [ 0.05444051-2.11823520e-01j] + [ 0.05444051+2.11823520e-01j] + [ 0.69221895-4.07945453e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.13175001116099017 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.02723174764585996 + DEBUG:qutip_qtrl.tslotcomp:217 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.68924456-7.61399565e-16j] + [-0.05425896+2.15118460e-01j] + [-0.05425896-2.15118460e-01j] + [ 0.31075544+7.57525576e-16j]] + Evo final diff: + [[-0.68924456+7.61399565e-16j] + [ 0.05425896-2.15118460e-01j] + [ 0.05425896+2.15118460e-01j] + [ 0.68924456-7.57525576e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.13106951377635798 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.027668468893053456 + DEBUG:qutip_qtrl.tslotcomp:217 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.67688921-1.05735288e-16j] + [-0.05355021+2.27852030e-01j] + [-0.05355021-2.27852030e-01j] + [ 0.32311079+1.17867251e-16j]] + Evo final diff: + [[-0.67688921+1.05735288e-16j] + [ 0.05355021-2.27852030e-01j] + [ 0.05355021+2.27852030e-01j] + [ 0.67688921-1.17867251e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1282407928102971 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.029351821888100513 + DEBUG:qutip_qtrl.tslotcomp:217 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.67533842-3.44934309e-16j] + [-0.05346656+2.29350225e-01j] + [-0.05346656-2.29350225e-01j] + [ 0.32466158+3.45994917e-16j]] + Evo final diff: + [[-0.67533842+3.44934309e-16j] + [ 0.05346656-2.29350225e-01j] + [ 0.05346656+2.29350225e-01j] + [ 0.67533842-3.45994917e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.12788554340376415 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.02954935346053595 + DEBUG:qutip_qtrl.tslotcomp:216 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.67185283-3.76863339e-16j] + [-0.05329816+2.32645474e-01j] + [-0.05329816-2.32645474e-01j] + [ 0.32814717+3.85742587e-16j]] + Evo final diff: + [[-0.67185283+3.76863339e-16j] + [ 0.05329816-2.32645474e-01j] + [ 0.05329816+2.32645474e-01j] + [ 0.67185283-3.85742587e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1270877097505528 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.02998299223687019 + DEBUG:qutip_qtrl.tslotcomp:216 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.67137162-3.02515149e-16j] + [-0.05327543+2.33092394e-01j] + [-0.05327543-2.33092394e-01j] + [ 0.32862838+3.12119039e-16j]] + Evo final diff: + [[-0.67137162+3.02515149e-16j] + [ 0.05327543-2.33092394e-01j] + [ 0.05327543+2.33092394e-01j] + [ 0.67137162-3.12119039e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.12697754694141616 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.030041753953705286 + DEBUG:qutip_qtrl.tslotcomp:215 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.66777659-3.33278998e-16j] + [-0.05312731+2.36369924e-01j] + [-0.05312731-2.36369924e-01j] + [ 0.33222341+3.28784122e-16j]] + Evo final diff: + [[-0.66777659+3.33278998e-16j] + [ 0.05312731-2.36369924e-01j] + [ 0.05312731+2.36369924e-01j] + [ 0.66777659-3.28784122e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.12615470502121254 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.030472213981305986 + DEBUG:qutip_qtrl.tslotcomp:215 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.6566633 -6.49942158e-16j] + [-0.05271215+2.45874191e-01j] + [-0.05271215-2.45874191e-01j] + [ 0.3433367 +6.15169790e-16j]] + Evo final diff: + [[-0.6566633 +6.49942158e-16j] + [ 0.05271215-2.45874191e-01j] + [ 0.05271215+2.45874191e-01j] + [ 0.6566633 -6.15169790e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.12360984315044998 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03171612599370095 + DEBUG:qutip_qtrl.tslotcomp:214 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.65267779-6.11073304e-16j] + [-0.05259357+2.49068998e-01j] + [-0.05259357-2.49068998e-01j] + [ 0.34732221+6.02183311e-16j]] + Evo final diff: + [[-0.65267779+6.11073304e-16j] + [ 0.05259357-2.49068998e-01j] + [ 0.05259357+2.49068998e-01j] + [ 0.65267779-6.02183311e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.12269743680533629 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0321323084875968 + DEBUG:qutip_qtrl.tslotcomp:214 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.64250517-6.31996656e-16j] + [-0.05233125+2.56747951e-01j] + [-0.05233125-2.56747951e-01j] + [ 0.35749483+6.45417945e-16j]] + Evo final diff: + [[-0.64250517+6.31996656e-16j] + [ 0.05233125-2.56747951e-01j] + [ 0.05233125+2.56747951e-01j] + [ 0.64250517-6.45417945e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1203677399457908 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.033128544257186636 + DEBUG:qutip_qtrl.tslotcomp:213 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.63817142-3.74367938e-16j] + [-0.05224773+2.59822030e-01j] + [-0.05224773-2.59822030e-01j] + [ 0.36182858+3.68719064e-16j]] + Evo final diff: + [[-0.63817142+3.74367938e-16j] + [ 0.05224773-2.59822030e-01j] + [ 0.05224773+2.59822030e-01j] + [ 0.63817142-3.68719064e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.11937501701153475 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03352562557188911 + DEBUG:qutip_qtrl.tslotcomp:213 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.63638735-7.47434162e-16j] + [-0.0522164 +2.61055047e-01j] + [-0.0522164 -2.61055047e-01j] + [ 0.36361265+7.61622335e-16j]] + Evo final diff: + [[-0.63638735+7.47434162e-16j] + [ 0.0522164 -2.61055047e-01j] + [ 0.0522164 +2.61055047e-01j] + [ 0.63638735-7.61622335e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.11896628721909538 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03368456960336331 + DEBUG:qutip_qtrl.tslotcomp:212 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.63192967-3.41137291e-16j] + [-0.05216594+2.64056561e-01j] + [-0.05216594-2.64056561e-01j] + [ 0.36807033+3.44847895e-16j]] + Evo final diff: + [[-0.63192967+3.41137291e-16j] + [ 0.05216594-2.64056561e-01j] + [ 0.05216594+2.64056561e-01j] + [ 0.63192967-3.44847895e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.11794556487170456 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.034070275835932376 + DEBUG:qutip_qtrl.tslotcomp:212 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.61471667-7.23037961e-16j] + [-0.05207953+2.74628085e-01j] + [-0.05207953-2.74628085e-01j] + [ 0.38528333+7.15646926e-16j]] + Evo final diff: + [[-0.61471667+7.23037961e-16j] + [ 0.05207953-2.74628085e-01j] + [ 0.05207953+2.74628085e-01j] + [ 0.61471667-7.15646926e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.11400236221754698 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03541748065730033 + DEBUG:qutip_qtrl.tslotcomp:211 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.60982546-7.32252542e-16j] + [-0.05209479+2.77356154e-01j] + [-0.05209479-2.77356154e-01j] + [ 0.39017454+7.37513289e-16j]] + Evo final diff: + [[-0.60982546+7.32252542e-16j] + [ 0.05209479-2.77356154e-01j] + [ 0.05209479+2.77356154e-01j] + [ 0.60982546-7.37513289e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.11288184881395368 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03576168589295334 + DEBUG:qutip_qtrl.tslotcomp:210 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.6048515 -5.91742838e-16j] + [-0.05213982+2.80009487e-01j] + [-0.05213982-2.80009487e-01j] + [ 0.3951485 +5.95413362e-16j]] + Evo final diff: + [[-0.6048515 +5.91742838e-16j] + [ 0.05213982-2.80009487e-01j] + [ 0.05213982+2.80009487e-01j] + [ 0.6048515 -5.95413362e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.11174230260470346 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03609484772033449 + DEBUG:qutip_qtrl.tslotcomp:210 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.59190718-5.22138295e-16j] + [-0.05232739+2.86375879e-01j] + [-0.05232739-2.86375879e-01j] + [ 0.40809282+4.98319718e-16j]] + Evo final diff: + [[-0.59190718+5.22138295e-16j] + [ 0.05232739-2.86375879e-01j] + [ 0.05232739+2.86375879e-01j] + [ 0.59190718-4.98319718e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.10877585250548147 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03688639218966988 + DEBUG:qutip_qtrl.tslotcomp:209 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.58665514-6.93706741e-16j] + [-0.05244071+2.88747292e-01j] + [-0.05244071-2.88747292e-01j] + [ 0.41334486+7.16098749e-16j]] + Evo final diff: + [[-0.58665514+6.93706741e-16j] + [ 0.05244071-2.88747292e-01j] + [ 0.05244071+2.88747292e-01j] + [ 0.58665514-7.16098749e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.10757231878717691 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03717784815173896 + DEBUG:qutip_qtrl.tslotcomp:209 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.57551747-2.43829410e-16j] + [-0.05273933+2.93387292e-01j] + [-0.05273933-2.93387292e-01j] + [ 0.42448253+2.54354300e-16j]] + Evo final diff: + [[-0.57551747+2.43829410e-16j] + [ 0.05273933-2.93387292e-01j] + [ 0.05273933+2.93387292e-01j] + [ 0.57551747-2.54354300e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.10501947583332127 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.037741307722651544 + DEBUG:qutip_qtrl.tslotcomp:208 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.57004556-5.38289960e-16j] + [-0.05291526+2.95477594e-01j] + [-0.05291526-2.95477594e-01j] + [ 0.42995444+5.29817841e-16j]] + Evo final diff: + [[-0.57004556+5.38289960e-16j] + [ 0.05291526-2.95477594e-01j] + [ 0.05291526+2.95477594e-01j] + [ 0.57004556-5.29817841e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.10376474223168573 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03799210756936777 + DEBUG:qutip_qtrl.tslotcomp:208 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.56819923-7.01294011e-16j] + [-0.05297896+2.96155687e-01j] + [-0.05297896-2.96155687e-01j] + [ 0.43180077+7.07312924e-16j]] + Evo final diff: + [[-0.56819923+7.01294011e-16j] + [ 0.05297896-2.96155687e-01j] + [ 0.05297896+2.96155687e-01j] + [ 0.56819923-7.07312924e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.10334133261595366 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03807290894205984 + DEBUG:qutip_qtrl.tslotcomp:207 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.56266696-8.23316283e-16j] + [-0.0532038 +2.98107309e-01j] + [-0.0532038 -2.98107309e-01j] + [ 0.43733304+8.25991929e-16j]] + Evo final diff: + [[-0.56266696+8.23316283e-16j] + [ 0.0532038 -2.98107309e-01j] + [ 0.0532038 +2.98107309e-01j] + [ 0.56266696-8.25991929e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.10207317997115345 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.038303405315408705 + DEBUG:qutip_qtrl.tslotcomp:207 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.54380031-5.48640185e-16j] + [-0.05412485+3.03875599e-01j] + [-0.05412485-3.03875599e-01j] + [ 0.45619969+5.63006095e-16j]] + Evo final diff: + [[-0.54380031+5.48640185e-16j] + [ 0.05412485-3.03875599e-01j] + [ 0.05412485+3.03875599e-01j] + [ 0.54380031-5.63006095e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.09774716357938441 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03896463799501109 + DEBUG:qutip_qtrl.tslotcomp:206 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.53806598-7.59563749e-16j] + [-0.05445063+3.05366055e-01j] + [-0.05445063-3.05366055e-01j] + [ 0.46193402+7.61282559e-16j]] + Evo final diff: + [[-0.53806598+7.59563749e-16j] + [ 0.05445063-3.05366055e-01j] + [ 0.05445063+3.05366055e-01j] + [ 0.53806598-7.61282559e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.09643207429105892 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03912916463139644 + DEBUG:qutip_qtrl.tslotcomp:205 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.5323011 -2.72829793e-16j] + [-0.05480985+3.06741722e-01j] + [-0.05480985-3.06741722e-01j] + [ 0.4676989 +2.51845903e-16j]] + Evo final diff: + [[-0.5323011 +2.72829793e-16j] + [ 0.05480985-3.06741722e-01j] + [ 0.05480985+3.06741722e-01j] + [ 0.5323011 -2.51845903e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.09510976729548923 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03927756575439362 + DEBUG:qutip_qtrl.tslotcomp:205 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.5190676 -7.01774783e-16j] + [-0.05572398+3.09449290e-01j] + [-0.05572398-3.09449290e-01j] + [ 0.4809324 +7.10992040e-16j]] + Evo final diff: + [[-0.5190676 +7.01774783e-16j] + [ 0.05572398-3.09449290e-01j] + [ 0.05572398+3.09449290e-01j] + [ 0.5190676 -7.10992040e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.09207379958468942 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.039554883929803615 + DEBUG:qutip_qtrl.tslotcomp:204 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.51323489-6.20733383e-16j] + [-0.05616719+3.10447731e-01j] + [-0.05616719-3.10447731e-01j] + [ 0.48676511+6.23231245e-16j]] + Evo final diff: + [[-0.51323489+6.20733383e-16j] + [ 0.05616719-3.10447731e-01j] + [ 0.05616719+3.10447731e-01j] + [ 0.51323489-6.23231245e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.09073564913180734 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.039650126687170585 + DEBUG:qutip_qtrl.tslotcomp:204 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.50159327-6.42306204e-16j] + [-0.05712893+3.12086894e-01j] + [-0.05712893-3.12086894e-01j] + [ 0.49840673+6.49211321e-16j]] + Evo final diff: + [[-0.50159327+6.42306204e-16j] + [ 0.05712893-3.12086894e-01j] + [ 0.05712893+3.12086894e-01j] + [ 0.50159327-6.49211321e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0880644368823737 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03979051992069293 + DEBUG:qutip_qtrl.tslotcomp:203 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.49572858-3.39014563e-16j] + [-0.05763815+3.12734644e-01j] + [-0.05763815-3.12734644e-01j] + [ 0.50427142+3.31741027e-16j]] + Evo final diff: + [[-0.49572858+3.39014563e-16j] + [ 0.05763815-3.12734644e-01j] + [ 0.05763815+3.12734644e-01j] + [ 0.49572858-3.31741027e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.08671798497037973 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03983741481561637 + DEBUG:qutip_qtrl.tslotcomp:203 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.49419982-7.39012248e-16j] + [-0.05777526+3.12884150e-01j] + [-0.05777526-3.12884150e-01j] + [ 0.50580018+7.32231909e-16j]] + Evo final diff: + [[-0.49419982+7.39012248e-16j] + [ 0.05777526-3.12884150e-01j] + [ 0.05777526+3.12884150e-01j] + [ 0.49419982-7.32231909e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0863669839333387 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03984692665362219 + DEBUG:qutip_qtrl.tslotcomp:202 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.4883668 -4.56155982e-16j] + [-0.05833534+3.13381498e-01j] + [-0.05833534-3.13381498e-01j] + [ 0.5116332 +4.61293259e-16j]] + Evo final diff: + [[-0.4883668 +4.56155982e-16j] + [ 0.05833534-3.13381498e-01j] + [ 0.05833534+3.13381498e-01j] + [ 0.4883668 -4.61293259e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0850282766126049 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.039872746372552934 + DEBUG:qutip_qtrl.tslotcomp:202 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.46935112-4.54854539e-16j] + [-0.06035473+3.14198420e-01j] + [-0.06035473-3.14198420e-01j] + [ 0.53064888+4.24758436e-16j]] + Evo final diff: + [[-0.46935112+4.54854539e-16j] + [ 0.06035473-3.14198420e-01j] + [ 0.06035473+3.14198420e-01j] + [ 0.46935112-4.24758436e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0806634542809313 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03984426682584268 + DEBUG:qutip_qtrl.tslotcomp:201 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.31559106+2.18470835e-16j] + [-0.29201069-1.19719160e-01j] + [-0.29201069+1.19719160e-01j] + [ 0.68440894-2.12766239e-16j]] + Evo final diff: + [[-0.31559106-2.18470835e-16j] + [ 0.29201069+1.19719160e-01j] + [ 0.29201069-1.19719160e-01j] + [ 0.31559106+2.12766239e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.049800159556787876 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.033387858399689184 + DEBUG:qutip_qtrl.tslotcomp:171 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.20131376+1.90780925e-16j] + [-0.13083837+1.38723248e-01j] + [-0.13083837-1.38723248e-01j] + [ 0.79868624-1.98580734e-16j]] + Evo final diff: + [[-0.20131376-1.90780925e-16j] + [ 0.13083837-1.38723248e-01j] + [ 0.13083837+1.38723248e-01j] + [ 0.20131376+1.98580734e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.019222512288685996 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.017491353438115798 + DEBUG:qutip_qtrl.tslotcomp:152 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.1816594 +6.02748488e-17j] + [-0.15067819+6.84261618e-02j] + [-0.15067819-6.84261618e-02j] + [ 0.8183406 -4.15704533e-17j]] + Evo final diff: + [[-0.1816594 -6.02748488e-17j] + [ 0.15067819-6.84261618e-02j] + [ 0.15067819+6.84261618e-02j] + [ 0.1816594 +4.15704533e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.015096548611431919 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.013670082182459433 + DEBUG:qutip_qtrl.tslotcomp:156 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.16849715+2.50135878e-16j] + [-0.13264625+3.34976180e-02j] + [-0.13264625-3.34976180e-02j] + [ 0.83150285-2.56424104e-16j]] + Evo final diff: + [[-0.16849715-2.50135878e-16j] + [ 0.13264625-3.34976180e-02j] + [ 0.13264625+3.34976180e-02j] + [ 0.16849715+2.56424104e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.011777101837078275 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.011480990049517794 + DEBUG:qutip_qtrl.tslotcomp:153 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.15493998+3.51125072e-17j] + [-0.07813057+9.91910478e-03j] + [-0.07813057-9.91910478e-03j] + [ 0.84506002-4.09579686e-17j]] + Evo final diff: + [[-0.15493998-3.51125072e-17j] + [ 0.07813057-9.91910478e-03j] + [ 0.07813057+9.91910478e-03j] + [ 0.15493998+4.09579686e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.007552292958213012 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0062833948937121315 + DEBUG:qutip_qtrl.tslotcomp:137 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.15316377-1.43451255e-16j] + [-0.04009852+1.57617808e-02j] + [-0.04009852-1.57617808e-02j] + [ 0.84683623+1.56843612e-16j]] + Evo final diff: + [[-0.15316377+1.43451255e-16j] + [ 0.04009852-1.57617808e-02j] + [ 0.04009852+1.57617808e-02j] + [ 0.15316377-1.56843612e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.006328866328369624 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.003038745925995049 + DEBUG:qutip_qtrl.tslotcomp:119 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.15306883-4.86970890e-18j] + [-0.030905 +1.50597807e-02j] + [-0.030905 -1.50597807e-02j] + [ 0.84693117+5.39952689e-18j]] + Evo final diff: + [[-0.15306883+4.86970890e-18j] + [ 0.030905 -1.50597807e-02j] + [ 0.030905 +1.50597807e-02j] + [ 0.15306883-5.39952689e-18j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.006152995343819839 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.002508356866757705 + DEBUG:qutip_qtrl.tslotcomp:113 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.15257059-2.86266035e-16j] + [-0.01992457+8.56547658e-03j] + [-0.01992457-8.56547658e-03j] + [ 0.84742941+2.86191075e-16j]] + Evo final diff: + [[-0.15257059+2.86266035e-16j] + [ 0.01992457-8.56547658e-03j] + [ 0.01992457+8.56547658e-03j] + [ 0.15257059-2.86191075e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.005937035062464446 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0015587091954753587 + DEBUG:qutip_qtrl.tslotcomp:115 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.15179587-3.25979993e-17j] + [-0.01463539+3.39500158e-04j] + [-0.01463539-3.39500158e-04j] + [ 0.84820413+3.23200765e-17j]] + Evo final diff: + [[-0.15179587+3.25979993e-17j] + [ 0.01463539-3.39500158e-04j] + [ 0.01463539+3.39500158e-04j] + [ 0.15179587-3.23200765e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.00581407385674651 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0007632515218465383 + DEBUG:qutip_qtrl.tslotcomp:133 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.15103612-1.64565330e-16j] + [-0.01316383-4.05847194e-03j] + [-0.01316383+4.05847194e-03j] + [ 0.84896388+1.74983659e-16j]] + Evo final diff: + [[-0.15103612+1.64565330e-16j] + [ 0.01316383+4.05847194e-03j] + [ 0.01316383-4.05847194e-03j] + [ 0.15103612-1.74983659e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.005750416728963727 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0007035771752061577 + DEBUG:qutip_qtrl.tslotcomp:146 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.14983243-2.07060409e-16j] + [-0.01266315-6.78354613e-03j] + [-0.01266315+6.78354613e-03j] + [ 0.85016757+2.01010929e-16j]] + Evo final diff: + [[-0.14983243+2.07060409e-16j] + [ 0.01266315+6.78354613e-03j] + [ 0.01266315-6.78354613e-03j] + [ 0.14983243-2.01010929e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0056640325098776785 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.000875533443023031 + DEBUG:qutip_qtrl.tslotcomp:147 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.14736865-1.98101729e-17j] + [-0.01395029-7.58517534e-03j] + [-0.01395029+7.58517534e-03j] + [ 0.85263135+2.46437306e-17j]] + Evo final diff: + [[-0.14736865+1.98101729e-17j] + [ 0.01395029+7.58517534e-03j] + [ 0.01395029-7.58517534e-03j] + [ 0.14736865-2.46437306e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.005492416455265949 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0009792637379427893 + DEBUG:qutip_qtrl.tslotcomp:151 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.13543044-9.90346214e-17j] + [-0.031025 +2.26361283e-02j] + [-0.031025 -2.26361283e-02j] + [ 0.86456956+1.25741960e-16j]] + Evo final diff: + [[-0.13543044+9.90346214e-17j] + [ 0.031025 -2.26361283e-02j] + [ 0.031025 +2.26361283e-02j] + [ 0.13543044-1.25741960e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.004954087169670477 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.002816855705100954 + DEBUG:qutip_qtrl.tslotcomp:135 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.13554058-1.42501810e-16j] + [-0.0281265 +1.65553447e-02j] + [-0.0281265 -1.65553447e-02j] + [ 0.86445942+1.43220318e-16j]] + Evo final diff: + [[-0.13554058+1.42501810e-16j] + [ 0.0281265 -1.65553447e-02j] + [ 0.0281265 +1.65553447e-02j] + [ 0.13554058-1.43220318e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.004859107182026605 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0021941396970016616 + DEBUG:qutip_qtrl.tslotcomp:131 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.13575185-3.37779973e-16j] + [-0.02081153+3.77437686e-03j] + [-0.02081153-3.77437686e-03j] + [ 0.86424815+3.10875498e-16j]] + Evo final diff: + [[-0.13575185+3.37779973e-16j] + [ 0.02081153-3.77437686e-03j] + [ 0.02081153+3.77437686e-03j] + [ 0.13575185-3.10875498e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0047189827899690034 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0010073578183123135 + DEBUG:qutip_qtrl.tslotcomp:130 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.13530186-7.27119118e-17j] + [-0.01764337+5.43691276e-04j] + [-0.01764337-5.43691276e-04j] + [ 0.86469814+6.12490329e-17j]] + Evo final diff: + [[-0.13530186+7.27119118e-17j] + [ 0.01764337-5.43691276e-04j] + [ 0.01764337+5.43691276e-04j] + [ 0.13530186-6.12490329e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.004654544041536687 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0007592681905472547 + DEBUG:qutip_qtrl.tslotcomp:126 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.13403186+6.86479517e-17j] + [-0.01393748+1.08562636e-04j] + [-0.01393748-1.08562636e-04j] + [ 0.86596814-7.29814388e-17j]] + Evo final diff: + [[-0.13403186-6.86479517e-17j] + [ 0.01393748-1.08562636e-04j] + [ 0.01393748+1.08562636e-04j] + [ 0.13403186+7.29814388e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0045397014376240725 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0005692317333776652 + DEBUG:qutip_qtrl.tslotcomp:125 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 1.27670784e-01-2.16234204e-16j] + [-7.46907037e-04+2.71856059e-02j] + [-7.46907037e-04-2.71856059e-02j] + [ 8.72329216e-01+2.12601372e-16j]] + Evo final diff: + [[-0.12767078+2.16234204e-16j] + [ 0.00074691-2.71856059e-02j] + [ 0.00074691+2.71856059e-02j] + [ 0.12767078-2.12601372e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.004259861039623093 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0036164830842216594 + DEBUG:qutip_qtrl.tslotcomp:143 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.12674848-2.02792245e-16j] + [-0.00620768+1.95245106e-02j] + [-0.00620768-1.95245106e-02j] + [ 0.87325152+2.07998536e-16j]] + Evo final diff: + [[-0.12674848+2.02792245e-16j] + [ 0.00620768-1.95245106e-02j] + [ 0.00620768+1.95245106e-02j] + [ 0.12674848-2.07998536e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.004121229805969434 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.002423605818773954 + DEBUG:qutip_qtrl.tslotcomp:142 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.12513358-2.73738416e-16j] + [-0.0156496 +7.86097283e-03j] + [-0.0156496 -7.86097283e-03j] + [ 0.87486642+2.70488348e-16j]] + Evo final diff: + [[-0.12513358+2.73738416e-16j] + [ 0.0156496 -7.86097283e-03j] + [ 0.0156496 +7.86097283e-03j] + [ 0.12513358-2.70488348e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0039912794285803434 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.000918881455787781 + DEBUG:qutip_qtrl.tslotcomp:136 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.12454703-1.08713181e-16j] + [-0.01718828+5.79852866e-03j] + [-0.01718828-5.79852866e-03j] + [ 0.87545297+1.21106065e-16j]] + Evo final diff: + [[-0.12454703+1.08713181e-16j] + [ 0.01718828-5.79852866e-03j] + [ 0.01718828+5.79852866e-03j] + [ 0.12454703-1.21106065e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0039602556103499175 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0008779527858675085 + DEBUG:qutip_qtrl.tslotcomp:132 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.1236505 -1.23465683e-16j] + [-0.01811325+3.97205392e-03j] + [-0.01811325-3.97205392e-03j] + [ 0.8763495 +1.24040755e-16j]] + Evo final diff: + [[-0.1236505 +1.23465683e-16j] + [ 0.01811325-3.97205392e-03j] + [ 0.01811325+3.97205392e-03j] + [ 0.1236505 -1.24040755e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.003908328371381658 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0009257862736929979 + DEBUG:qutip_qtrl.tslotcomp:128 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.11777994-2.76891385e-16j] + [-0.01467044+1.94547748e-02j] + [-0.01467044-1.94547748e-02j] + [ 0.88222006+2.87209455e-16j]] + Evo final diff: + [[-0.11777994+2.76891385e-16j] + [ 0.01467044-1.94547748e-02j] + [ 0.01467044+1.94547748e-02j] + [ 0.11777994-2.87209455e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0036164558427296887 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0017534099117774652 + DEBUG:qutip_qtrl.tslotcomp:110 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.11755998+5.74296773e-18j] + [-0.01423278+1.59465433e-02j] + [-0.01423278-1.59465433e-02j] + [ 0.88244002+9.24094171e-19j]] + Evo final diff: + [[-0.11755998-5.74296773e-18j] + [ 0.01423278-1.59465433e-02j] + [ 0.01423278+1.59465433e-02j] + [ 0.11755998-9.24094171e-19j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0035693033154546795 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0014386769254665266 + DEBUG:qutip_qtrl.tslotcomp:105 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.1166713 -1.45522484e-17j] + [-0.01310825+9.04460212e-04j] + [-0.01310825-9.04460212e-04j] + [ 0.8833287 +4.77845036e-17j]] + Evo final diff: + [[-0.1166713 +1.45522484e-17j] + [ 0.01310825-9.04460212e-04j] + [ 0.01310825+9.04460212e-04j] + [ 0.1166713 -4.77845036e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0034462091781149434 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0007094621487583083 + DEBUG:qutip_qtrl.tslotcomp:114 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.1157596 -1.06205488e-17j] + [-0.00838469+6.11512969e-03j] + [-0.00838469-6.11512969e-03j] + [ 0.8842404 +1.63217820e-17j]] + Evo final diff: + [[-0.1157596 +1.06205488e-17j] + [ 0.00838469-6.11512969e-03j] + [ 0.00838469+6.11512969e-03j] + [ 0.1157596 -1.63217820e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0033769958899527034 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0006002112724568193 + DEBUG:qutip_qtrl.tslotcomp:124 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.11540556-1.05495365e-16j] + [-0.00723593+6.14208109e-03j] + [-0.00723593-6.14208109e-03j] + [ 0.88459444+1.28837745e-16j]] + Evo final diff: + [[-0.11540556+1.05495365e-16j] + [ 0.00723593-6.14208109e-03j] + [ 0.00723593+6.14208109e-03j] + [ 0.11540556-1.28837745e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.003352131968892376 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0006206540278559121 + DEBUG:qutip_qtrl.tslotcomp:127 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[0.11730567-6.28545002e-17j] + [0.04132207+5.54769529e-02j] + [0.04132207-5.54769529e-02j] + [0.88269433+5.88631082e-17j]] + Evo final diff: + [[-0.11730567+6.28545002e-17j] + [-0.04132207-5.54769529e-02j] + [-0.04132207+5.54769529e-02j] + [ 0.11730567-5.88631082e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.004636456654879235 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.008466177084199153 + DEBUG:qutip_qtrl.tslotcomp:127 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.11479238-2.16773149e-16j] + [-0.00190573+1.16936871e-02j] + [-0.00190573-1.16936871e-02j] + [ 0.88520762+1.96527670e-16j]] + Evo final diff: + [[-0.11479238+2.16773149e-16j] + [ 0.00190573-1.16936871e-02j] + [ 0.00190573+1.16936871e-02j] + [ 0.11479238-1.96527670e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0033294161351953753 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.00140652457734953 + DEBUG:qutip_qtrl.tslotcomp:161 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[0.11345567-2.64803713e-16j] + [0.02230965+3.05856202e-02j] + [0.02230965-3.05856202e-02j] + [0.88654433+2.51732420e-16j]] + Evo final diff: + [[-0.11345567+2.64803713e-16j] + [-0.02230965-3.05856202e-02j] + [-0.02230965+3.05856202e-02j] + [ 0.11345567-2.51732420e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.003576347575750469 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.004832367011452715 + DEBUG:qutip_qtrl.tslotcomp:161 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[0.11434582-1.97546972e-16j] + [0.0014966 +1.44532218e-02j] + [0.0014966 -1.44532218e-02j] + [0.88565418+1.82179483e-16j]] + Evo final diff: + [[-0.11434582+1.97546972e-16j] + [-0.0014966 -1.44532218e-02j] + [-0.0014966 +1.44532218e-02j] + [ 0.11434582-1.82179483e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0033215252734320284 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0018847109570573012 + DEBUG:qutip_qtrl.tslotcomp:165 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[0.11311129-1.78769439e-16j] + [0.0192881 +2.70178745e-02j] + [0.0192881 -2.70178745e-02j] + [0.88688871+1.80945132e-16j]] + Evo final diff: + [[-0.11311129+1.78769439e-16j] + [-0.0192881 -2.70178745e-02j] + [-0.0192881 +2.70178745e-02j] + [ 0.11311129-1.80945132e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.003474040083892313 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.004284021748206093 + DEBUG:qutip_qtrl.tslotcomp:165 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[0.11415438-2.96243998e-16j] + [0.00294656+1.55132375e-02j] + [0.00294656-1.55132375e-02j] + [0.88584562+3.04878725e-16j]] + Evo final diff: + [[-0.11415438+2.96243998e-16j] + [-0.00294656-1.55132375e-02j] + [-0.00294656+1.55132375e-02j] + [ 0.11415438-3.04878725e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0033201410759716036 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0020800187801302576 + DEBUG:qutip_qtrl.tslotcomp:165 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[1.13780965e-01-9.45985399e-17j] + [3.83794035e-04+1.30577224e-02j] + [3.83794035e-04-1.30577224e-02j] + [8.86219035e-01+1.12315878e-16j]] + Evo final diff: + [[-0.11378096+9.45985399e-17j] + [-0.00038379-1.30577224e-02j] + [-0.00038379+1.30577224e-02j] + [ 0.11378096-1.12315878e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.003279189843179375 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0016500071806924944 + DEBUG:qutip_qtrl.tslotcomp:159 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[0.11140081-3.26953161e-16j] + [0.00983386+2.28050448e-02j] + [0.00983386-2.28050448e-02j] + [0.88859919+3.21754966e-16j]] + Evo final diff: + [[-0.11140081+3.26953161e-16j] + [-0.00983386-2.28050448e-02j] + [-0.00983386+2.28050448e-02j] + [ 0.11140081-3.21754966e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0032567287401730326 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0030620299087130392 + DEBUG:qutip_qtrl.tslotcomp:143 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.11027288-2.60080742e-16j] + [-0.00211515+1.01988537e-02j] + [-0.00211515-1.01988537e-02j] + [ 0.88972712+2.51328848e-16j]] + Evo final diff: + [[-0.11027288+2.60080742e-16j] + [ 0.00211515-1.01988537e-02j] + [ 0.00211515+1.01988537e-02j] + [ 0.11027288-2.51328848e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.003067149372482811 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0010635270647882651 + DEBUG:qutip_qtrl.tslotcomp:142 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.10986347-1.52044276e-16j] + [-0.00676178+3.81635360e-03j] + [-0.00676178-3.81635360e-03j] + [ 0.89013653+1.84026165e-16j]] + Evo final diff: + [[-0.10986347+1.52044276e-16j] + [ 0.00676178-3.81635360e-03j] + [ 0.00676178+3.81635360e-03j] + [ 0.10986347-1.84026165e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.00303256689509992 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.00043067781094844736 + DEBUG:qutip_qtrl.tslotcomp:156 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.10966187-1.51373545e-16j] + [-0.00722021+2.20990232e-03j] + [-0.00722021-2.20990232e-03j] + [ 0.89033813+1.81611675e-16j]] + Evo final diff: + [[-0.10966187+1.51373545e-16j] + [ 0.00722021-2.20990232e-03j] + [ 0.00722021+2.20990232e-03j] + [ 0.10966187-1.81611675e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0030206850268025697 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0004206778835279385 + DEBUG:qutip_qtrl.tslotcomp:144 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.10881918-1.05117998e-16j] + [-0.00818667-9.98658967e-04j] + [-0.00818667+9.98658967e-04j] + [ 0.89118082+8.63042319e-17j]] + Evo final diff: + [[-0.10881918+1.05117998e-16j] + [ 0.00818667+9.98658967e-04j] + [ 0.00818667-9.98658967e-04j] + [ 0.10881918-8.63042319e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.002977408062166688 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0006179572985145115 + DEBUG:qutip_qtrl.tslotcomp:150 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[0.10893369-5.09188722e-17j] + [0.01915619+3.34754429e-02j] + [0.01915619-3.34754429e-02j] + [0.89106631+6.30446511e-17j]] + Evo final diff: + [[-0.10893369+5.09188722e-17j] + [-0.01915619-3.34754429e-02j] + [-0.01915619+3.34754429e-02j] + [ 0.10893369-6.30446511e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0033385283684678937 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.00440432211260146 + DEBUG:qutip_qtrl.tslotcomp:150 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.1082078 -7.62810704e-18j] + [-0.00188368+6.88378461e-03j] + [-0.00188368-6.88378461e-03j] + [ 0.8917922 -2.12907249e-17j]] + Evo final diff: + [[-0.1082078 +7.62810704e-18j] + [ 0.00188368-6.88378461e-03j] + [ 0.00188368+6.88378461e-03j] + [ 0.1082078 +2.12907249e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0029399658007447775 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0007275766472791512 + DEBUG:qutip_qtrl.tslotcomp:150 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.10752116-2.11858619e-16j] + [-0.00168463+6.00524977e-03j] + [-0.00168463-6.00524977e-03j] + [ 0.89247884+1.98456153e-16j]] + Evo final diff: + [[-0.10752116+2.11858619e-16j] + [ 0.00168463-6.00524977e-03j] + [ 0.00168463+6.00524977e-03j] + [ 0.10752116-1.98456153e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.002899925081967757 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0006452058698532823 + DEBUG:qutip_qtrl.tslotcomp:130 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[0.10569875-3.00077911e-16j] + [0.0059499 +1.39251675e-02j] + [0.0059499 -1.39251675e-02j] + [0.89430125+3.16129435e-16j]] + Evo final diff: + [[-0.10569875+3.00077911e-16j] + [-0.0059499 -1.39251675e-02j] + [-0.0059499 +1.39251675e-02j] + [ 0.10569875-3.16129435e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.002850384225861206 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0016855236265835014 + DEBUG:qutip_qtrl.tslotcomp:132 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.10497416-7.39664158e-17j] + [-0.00243508+3.63835198e-03j] + [-0.00243508-3.63835198e-03j] + [ 0.89502584+6.54204692e-17j]] + Evo final diff: + [[-0.10497416+7.39664158e-17j] + [ 0.00243508-3.63835198e-03j] + [ 0.00243508+3.63835198e-03j] + [ 0.10497416-6.54204692e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.002759685324237138 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.000435543446037828 + DEBUG:qutip_qtrl.tslotcomp:134 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.10479938-1.17661387e-17j] + [-0.00446064+1.59815368e-04j] + [-0.00446064-1.59815368e-04j] + [ 0.89520062+3.25578489e-17j]] + Evo final diff: + [[-0.10479938+1.17661387e-17j] + [ 0.00446064-1.59815368e-04j] + [ 0.00446064+1.59815368e-04j] + [ 0.10479938-3.25578489e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.002750708233412382 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0004896581077905727 + DEBUG:qutip_qtrl.tslotcomp:202 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[0.10436742-6.90043500e-17j] + [0.00328362+5.30833354e-03j] + [0.00328362-5.30833354e-03j] + [0.89563258+6.90910003e-17j]] + Evo final diff: + [[-0.10436742+6.90043500e-17j] + [-0.00328362-5.30833354e-03j] + [-0.00328362+5.30833354e-03j] + [ 0.10436742-6.90910003e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0027328799606105027 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.000760130975106369 + DEBUG:qutip_qtrl.tslotcomp:198 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 1.04107186e-01-9.29898879e-17j] + [-3.96115525e-04-5.37137207e-04j] + [-3.96115525e-04+5.37137207e-04j] + [ 8.95892814e-01+1.13300683e-16j]] + Evo final diff: + [[-0.10410719+9.29898879e-17j] + [ 0.00039612+5.37137207e-04j] + [ 0.00039612-5.37137207e-04j] + [ 0.10410719-1.13300683e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0027096879175113045 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0003222966255689542 + DEBUG:qutip_qtrl.tslotcomp:202 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.10399701+1.78748013e-16j] + [-0.00143715-2.01419268e-03j] + [-0.00143715+2.01419268e-03j] + [ 0.89600299-1.71911082e-16j]] + Evo final diff: + [[-0.10399701-1.78748013e-16j] + [ 0.00143715+2.01419268e-03j] + [ 0.00143715-2.01419268e-03j] + [ 0.10399701+1.71911082e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0027053751425556963 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.00040868454197329196 + DEBUG:qutip_qtrl.tslotcomp:206 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[1.03602593e-01+7.41523511e-17j] + [7.76199379e-04-3.33318139e-03j] + [7.76199379e-04+3.33318139e-03j] + [8.96397407e-01-6.98430227e-17j]] + Evo final diff: + [[-0.10360259-7.41523511e-17j] + [-0.0007762 +3.33318139e-03j] + [-0.0007762 -3.33318139e-03j] + [ 0.10360259+6.98430227e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0026863024750416607 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.00039887171896492055 + DEBUG:qutip_qtrl.tslotcomp:212 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[1.02801167e-01+3.76611693e-17j] + [8.77013768e-04+4.08904284e-03j] + [8.77013768e-04-4.08904284e-03j] + [8.97198833e-01-5.32629335e-17j]] + Evo final diff: + [[-0.10280117-3.76611693e-17j] + [-0.00087701-4.08904284e-03j] + [-0.00087701+4.08904284e-03j] + [ 0.10280117+5.32629335e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0026463923436669114 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0005547734083537043 + DEBUG:qutip_qtrl.tslotcomp:208 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.10190409-1.15163006e-16j] + [-0.00172282-1.78044665e-04j] + [-0.00172282+1.78044665e-04j] + [ 0.89809591+1.24903520e-16j]] + Evo final diff: + [[-0.10190409+1.15163006e-16j] + [ 0.00172282+1.78044665e-04j] + [ 0.00172282-1.78044665e-04j] + [ 0.10190409-1.24903520e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.002596860968248521 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0005226078214042328 + DEBUG:qutip_qtrl.tslotcomp:206 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[0.09794285+3.98467394e-17j] + [0.00184585-1.04772205e-03j] + [0.00184585+1.04772205e-03j] + [0.90205715-3.81075707e-17j]] + Evo final diff: + [[-0.09794285-3.98467394e-17j] + [-0.00184585+1.04772205e-03j] + [-0.00184585-1.04772205e-03j] + [ 0.09794285+3.81075707e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.002399326797379077 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.00043545868627036346 + DEBUG:qutip_qtrl.tslotcomp:199 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.09581463+1.18848982e-16j] + [-0.00724779-6.72702891e-03j] + [-0.00724779+6.72702891e-03j] + [ 0.90418537-1.24877144e-16j]] + Evo final diff: + [[-0.09581463-1.18848982e-16j] + [ 0.00724779+6.72702891e-03j] + [ 0.00724779-6.72702891e-03j] + [ 0.09581463+1.24877144e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.002319556861186033 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0013023651442190495 + DEBUG:qutip_qtrl.tslotcomp:206 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.09053693+7.21333751e-17j] + [-0.01521012+2.06478190e-03j] + [-0.01521012-2.06478190e-03j] + [ 0.90946307-5.38625646e-17j]] + Evo final diff: + [[-0.09053693-7.21333751e-17j] + [ 0.01521012-2.06478190e-03j] + [ 0.01521012+2.06478190e-03j] + [ 0.09053693+5.38625646e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.002108136579583669 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0013974311451801593 + DEBUG:qutip_qtrl.tslotcomp:204 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[0.08740393+1.13699959e-16j] + [0.02516675+7.75704131e-03j] + [0.02516675-7.75704131e-03j] + [0.91259607-1.14147599e-16j]] + Evo final diff: + [[-0.08740393-1.13699959e-16j] + [-0.02516675-7.75704131e-03j] + [-0.02516675+7.75704131e-03j] + [ 0.08740393+1.14147599e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0020832461766792203 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.002506533779775255 + DEBUG:qutip_qtrl.tslotcomp:204 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[8.86222058e-02+4.97268253e-17j] + [2.56588382e-04+4.76433737e-03j] + [2.56588382e-04-4.76433737e-03j] + [9.11377794e-01-4.72413309e-17j]] + Evo final diff: + [[-0.08862221-4.97268253e-17j] + [-0.00025659-4.76433737e-03j] + [-0.00025659+4.76433737e-03j] + [ 0.08862221+4.72413309e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0019691650267841965 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0005952728968143743 + DEBUG:qutip_qtrl.tslotcomp:204 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[0.08495534-3.29007930e-17j] + [0.01528129-5.66222785e-03j] + [0.01528129+5.66222785e-03j] + [0.91504466+3.46683616e-17j]] + Evo final diff: + [[-0.08495534+3.29007930e-17j] + [-0.01528129+5.66222785e-03j] + [-0.01528129-5.66222785e-03j] + [ 0.08495534-3.46683616e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0018707471382189164 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.001120846566928445 + DEBUG:qutip_qtrl.tslotcomp:197 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.08263591-1.08670839e-16j] + [-0.0021057 -8.19285612e-03j] + [-0.0021057 +8.19285612e-03j] + [ 0.91736409+1.20622806e-16j]] + Evo final diff: + [[-0.08263591+1.08670839e-16j] + [ 0.0021057 +8.19285612e-03j] + [ 0.0021057 -8.19285612e-03j] + [ 0.08263591-1.20622806e-16j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.001725062577736425 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0010739051187731142 + DEBUG:qutip_qtrl.tslotcomp:198 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.0807071 +3.36395492e-17j] + [-0.00798595-3.76762132e-03j] + [-0.00798595+3.76762132e-03j] + [ 0.9192929 -3.54514155e-17j]] + Evo final diff: + [[-0.0807071 -3.36395492e-17j] + [ 0.00798595+3.76762132e-03j] + [ 0.00798595-3.76762132e-03j] + [ 0.0807071 +3.54514155e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0016479017720151489 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0010189445700085143 + DEBUG:qutip_qtrl.tslotcomp:198 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.07375042+6.28185036e-17j] + [-0.01443816+1.75836628e-02j] + [-0.01443816-1.75836628e-02j] + [ 0.92624958-5.14006535e-17j]] + Evo final diff: + [[-0.07375042-6.28185036e-17j] + [ 0.01443816-1.75836628e-02j] + [ 0.01443816+1.75836628e-02j] + [ 0.07375042+5.14006535e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0014891926475058604 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.001541352580157223 + DEBUG:qutip_qtrl.tslotcomp:207 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.07304985-5.66968551e-17j] + [-0.00896955+8.59571602e-03j] + [-0.00896955-8.59571602e-03j] + [ 0.92695015+4.40306800e-17j]] + Evo final diff: + [[-0.07304985+5.66968551e-17j] + [ 0.00896955-8.59571602e-03j] + [ 0.00896955+8.59571602e-03j] + [ 0.07304985-4.40306800e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0013726548989253327 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0007931689912542538 + DEBUG:qutip_qtrl.tslotcomp:208 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[0.07120002-5.50391068e-17j] + [0.00097728-4.14710189e-03j] + [0.00097728+4.14710189e-03j] + [0.92879998+5.72663573e-17j]] + Evo final diff: + [[-0.07120002+5.50391068e-17j] + [-0.00097728+4.14710189e-03j] + [-0.00097728-4.14710189e-03j] + [ 0.07120002-5.72663573e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0012718991600032883 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0005914141449148123 + DEBUG:qutip_qtrl.tslotcomp:213 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[0.06815425-7.70364037e-17j] + [0.00448965+1.11383284e-03j] + [0.00448965-1.11383284e-03j] + [0.93184575+8.04728568e-17j]] + Evo final diff: + [[-0.06815425+7.70364037e-17j] + [-0.00448965-1.11383284e-03j] + [-0.00448965+1.11383284e-03j] + [ 0.06815425-8.04728568e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0011665998232497808 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.00059355174364513 + DEBUG:qutip_qtrl.tslotcomp:216 amplitudes changed + Level 8:qutip_qtrl.dynamics:Computing evolution + Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... + Target: + [[0.+0.j] + [0.+0.j] + [0.+0.j] + [1.+0.j]] + Evo final: + [[ 0.05542137+7.22898608e-17j] + [-0.00407353+1.49163418e-02j] + [-0.00407353-1.49163418e-02j] + [ 0.94457863-6.48865312e-17j]] + Evo final diff: + [[-0.05542137-7.22898608e-17j] + [ 0.00407353-1.49163418e-02j] + [ 0.00407353+1.49163418e-02j] + [ 0.05542137+6.48865312e-17j]] + DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0008276547544061342 + DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed + DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0015358534376677783 + + + Infidelity: 0.0008276547544061342 + + + + +![png](GRAPE_state_open_files/GRAPE_state_open_7_2.png) + + + + ```python H_result = [Hd, [Hc, res_grape.optimized_controls[0]]] evolution = qt.mesolve(H_result, initial_state, times, c_ops) @@ -109,16 +3852,59 @@ plt.ylim(0, 1) plt.show() ``` + + +![png](GRAPE_state_open_files/GRAPE_state_open_8_0.png) + + + ## Validation + ```python assert res_grape.infidelity < 0.01 ``` + ```python qt.about() ``` + + QuTiP: Quantum Toolbox in Python + ================================ + Copyright (c) QuTiP team 2011 and later. + Current admin team: Alexander Pitchford, Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguère, Boxi Li, Simon Cross, Asier Galicia, Paul Menczel, and Patrick Hopf. + Board members: Daniel Burgarth, Robert Johansson, Anton F. Kockum, Franco Nori and Will Zeng. + Original developers: R. J. Johansson & P. D. Nation. + Previous lead developers: Chris Granade & A. Grimsmo. + Currently developed through wide collaboration. See https://github.com/qutip for details. + + QuTiP Version: 5.1.1 + Numpy Version: 1.26.4 + Scipy Version: 1.15.2 + Cython Version: None + Matplotlib Version: 3.10.0 + Python Version: 3.12.10 + Number of CPUs: 8 + BLAS Info: Generic + INTEL MKL Ext: None + Platform Info: Windows (AMD64) + Installation path: c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\qutip + + Installed QuTiP family packages + ------------------------------- + + qutip-jax: 0.1.0 + qutip-qtrl: 0.1.5 + + ================================================================================ + Please cite QuTiP in your publication. + ================================================================================ + For your convenience a bibtex reference can be easily generated using `qutip.cite()` + + + ```python ``` diff --git a/tests/interactive/JOPT_gate_open.md b/tests/interactive/JOPT_gate_open.md index 31e8bbe..3a3611f 100644 --- a/tests/interactive/JOPT_gate_open.md +++ b/tests/interactive/JOPT_gate_open.md @@ -1,19 +1,6 @@ ---- -jupyter: - jupytext: - text_representation: - extension: .md - format_name: markdown - format_version: '1.3' - jupytext_version: 1.16.7 - kernelspec: - display_name: qutip-dev - language: python - name: python3 ---- - # JOPT algorithm + ```python import matplotlib.pyplot as plt import numpy as np @@ -25,6 +12,7 @@ from qutip_qoc import Objective, optimize_pulses ## Problem setup + ```python hbar = 1 omega = 0.1 # energy splitting @@ -47,13 +35,42 @@ times = np.linspace(0, np.pi / 2, 250) ## Guess + ```python jopt_guess = [1, 1] guess_pulse = jopt_guess[0] * np.sin(jopt_guess[1] * times) ``` + +```python +H_result_guess = [Hd, + [Hc[0], guess_pulse], + [Hc[1], guess_pulse], + [Hc[2], guess_pulse]] + +identity_op = qt.qeye(2) +identity_super = qt.spre(identity_op) + +evolution_guess = qt.mesolve(H_result_guess, identity_super, times) + +target_super = qt.to_super(target_gate) +initial_super = qt.to_super(initial_gate) + +initial_overlaps_guess = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution_guess.states] +target_overlaps_guess = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution_guess.states] + +plt.plot(times, initial_overlaps_guess, label="Overlap with initial gate") +plt.plot(times, target_overlaps_guess, label="Overlap with target gate") +plt.title("Guess performance") +plt.xlabel("Time") +plt.legend() +plt.show() + +``` + ## JOPT algorithm + ```python @jit def sin_x(t, c, **kwargs): @@ -62,8 +79,22 @@ def sin_x(t, c, **kwargs): H = [Hd] + [[hc, sin_x, {"grad": sin_x}] for hc in Hc] ``` + + The Kernel crashed while executing code in the current cell or a previous cell. + + + Please review the code in the cell(s) to identify a possible cause of the failure. + + + Click here for more info. + + + View Jupyter log for further details. + + ### a) not optimized over time + ```python ctrl_parameters = { id: {"guess": jopt_guess, "bounds": [(-1, 1), (0, 2 * np.pi)]} # c0 and c1 @@ -96,27 +127,27 @@ plt.legend() plt.show() ``` + ```python H_result = [Hd, [Hc[0], np.array(res_jopt.optimized_controls[0])], [Hc[1], np.array(res_jopt.optimized_controls[1])], [Hc[2], np.array(res_jopt.optimized_controls[2])]] - identity_op = qt.qeye(2) identity_super = qt.spre(identity_op) -evolution_time = qt.mesolve(H_result, identity_super, times) +evolution = qt.mesolve(H_result, identity_super, times) target_super = qt.to_super(target_gate) initial_super = qt.to_super(initial_gate) -initial_overlaps = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution_time.states] -target_overlaps = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution_time.states] +initial_overlaps = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution.states] +target_overlaps = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution.states] plt.plot(times, initial_overlaps, label="Overlap with initial gate") plt.plot(times, target_overlaps, label="Overlap with target gate") -plt.title("GOAT performance") +plt.title("JOPT performance") plt.xlabel("Time") plt.legend() plt.show() @@ -125,6 +156,7 @@ plt.show() ### b) optimized over time + ```python # treats time as optimization variable ctrl_parameters["__time__"] = { @@ -163,8 +195,9 @@ plt.legend() plt.show() ``` + ```python -H_result = [Hd, +H_result_time = [Hd, [Hc[0], np.array(res_jopt_time.optimized_controls[0])], [Hc[1], np.array(res_jopt_time.optimized_controls[1])], [Hc[2], np.array(res_jopt_time.optimized_controls[2])]] @@ -173,17 +206,17 @@ H_result = [Hd, identity_op = qt.qeye(2) identity_super = qt.spre(identity_op) -evolution_time = qt.mesolve(H_result, identity_super, times) +evolution_time = qt.mesolve(H_result_time, identity_super, times) target_super = qt.to_super(target_gate) initial_super = qt.to_super(initial_gate) -initial_overlaps = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution_time.states] -target_overlaps = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution_time.states] +initial_overlaps_time = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution_time.states] +target_overlaps_time = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution_time.states] -plt.plot(times, initial_overlaps, label="Overlap with initial gate") -plt.plot(times, target_overlaps, label="Overlap with target gate") -plt.title("GOAT performance") +plt.plot(times, initial_overlaps_time, label="Overlap with initial gate") +plt.plot(times, target_overlaps_time, label="Overlap with target gate") +plt.title("JOPT performance (optimized over time)") plt.xlabel("Time") plt.legend() plt.show() @@ -192,6 +225,7 @@ plt.show() ## Global optimization + ```python alg_args = { "alg": "JOPT", @@ -218,7 +252,7 @@ global_range = times < res_jopt_global.optimized_params[-1] plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[0])[global_range], label='Global optimized pulse sx') plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[1])[global_range], label='Global optimized pulse sy') plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[2])[global_range], label='Global optimized pulse sz') -plt.title('JOPT pulses (global)') +plt.title('JOPT pulses') plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() @@ -226,8 +260,9 @@ plt.show() ``` + ```python -H_result = [Hd, +H_result_global = [Hd, [Hc[0], np.array(res_jopt_time.optimized_controls[0])], [Hc[1], np.array(res_jopt_time.optimized_controls[1])], [Hc[2], np.array(res_jopt_time.optimized_controls[2])]] @@ -236,17 +271,17 @@ H_result = [Hd, identity_op = qt.qeye(2) identity_super = qt.spre(identity_op) -evolution_time = qt.mesolve(H_result, identity_super, times) +evolution_global = qt.mesolve(H_result, identity_super, times) target_super = qt.to_super(target_gate) initial_super = qt.to_super(initial_gate) -initial_overlaps = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution_time.states] -target_overlaps = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution_time.states] +initial_overlaps_global = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution_global.states] +target_overlaps_global = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution_global.states] -plt.plot(times, initial_overlaps, label="Overlap with initial gate") -plt.plot(times, target_overlaps, label="Overlap with target gate") -plt.title("GOAT performance") +plt.plot(times, initial_overlaps_global, label="Overlap with initial gate") +plt.plot(times, target_overlaps_global, label="Overlap with target gate") +plt.title("JOPT performance (global)") plt.xlabel("Time") plt.legend() plt.show() @@ -255,6 +290,7 @@ plt.show() ## Comparison + ```python fig, axes = plt.subplots(1, 3, figsize=(18, 4)) # 1 row, 3 columns @@ -278,12 +314,28 @@ plt.show() ## Validation + ```python assert res_jopt.infidelity < 0.001 assert res_jopt_time.infidelity < 0.001 assert res_jopt_global.infidelity < 0.001 ``` + + --------------------------------------------------------------------------- + + NameError Traceback (most recent call last) + + Cell In[1], line 1 + ----> 1 assert res_jopt.infidelity < 0.001 + 2 assert res_jopt_time.infidelity < 0.001 + 3 assert res_jopt_global.infidelity < 0.001 + + + NameError: name 'res_jopt' is not defined + + + ```python qt.about() ``` diff --git a/tests/interactive/JOPT_state_open.md b/tests/interactive/JOPT_state_open.md index 77f8424..bb60208 100644 --- a/tests/interactive/JOPT_state_open.md +++ b/tests/interactive/JOPT_state_open.md @@ -1,20 +1,7 @@ ---- -jupyter: - jupytext: - text_representation: - extension: .md - format_name: markdown - format_version: '1.3' - jupytext_version: 1.16.7 - kernelspec: - display_name: qutip-dev - language: python - name: python3 ---- - # JOPT algorithm for a 2 level system + ```python import matplotlib.pyplot as plt import numpy as np @@ -26,6 +13,7 @@ from jax import jit, numpy ## Problem setup + ```python # Energy levels E1, E2 = 1.0, 2.0 @@ -53,12 +41,13 @@ times = np.linspace(0, 2 * np.pi, 250) ## Guess + ```python jopt_guess = [1, 0.5] guess_pulse = jopt_guess[0] * np.sin(jopt_guess[1] * times) -Hresult_guess = [Hd, [Hc, guess_pulse]] -evolution_guess = qt.mesolve(Hresult_guess, initial_state, times) +H_result_guess = [Hd, [Hc, guess_pulse]] +evolution_guess = qt.mesolve(H_result_guess, initial_state, times) print('Fidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) @@ -70,8 +59,18 @@ plt.title("Guess performance") plt.show() ``` + Fidelity: 0.7628226855907076 + + + + +![png](JOPT_state_open_files/JOPT_state_open_5_1.png) + + + ## JOPT algorithm + ```python @jit def sin_x(t, c, **kwargs): @@ -82,6 +81,7 @@ H = [Hd, [Hc, sin_x]] ### a) not optimized over time + ```python ctrl_parameters = { id: {"guess": [1, 0], "bounds": [(-1, 1), (0, 2 * np.pi)]} # c0 and c1 @@ -112,6 +112,174 @@ plt.legend() plt.show() ``` + c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\scipy\optimize\_basinhopping.py:294: RuntimeWarning: Method Nelder-Mead does not use gradient information (jac). + return self.minimizer(self.func, x0, **self.kwargs) + c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\scipy\optimize\_basinhopping.py:294: OptimizeWarning: Unknown solver options: gtol + return self.minimizer(self.func, x0, **self.kwargs) + c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\equinox\_jit.py:55: UserWarning: Complex dtype support in Diffrax is a work in progress and may not yet produce correct results. Consider splitting your computation into real and imaginary parts instead. + out = fun(*args, **kwargs) + + + + --------------------------------------------------------------------------- + + ValueError Traceback (most recent call last) + + Cell In[17], line 9 + 1 ctrl_parameters = { + 2 id: {"guess": [1, 0], "bounds": [(-1, 1), (0, 2 * np.pi)]} # c0 and c1 + 3 } + 4 alg_args = { + 5 "alg": "JOPT", + 6 "fid_err_targ": 0.01, + 7 } + ----> 9 res_jopt = optimize_pulses( + 10 objectives=Objective(initial_state, H, target_state), + 11 control_parameters=ctrl_parameters, + 12 tlist=times, + 13 minimizer_kwargs={ + 14 "method": "Nelder-Mead", + 15 }, + 16 algorithm_kwargs=alg_args, + 17 ) + 19 print('Infidelity: ', res_jopt.infidelity) + 21 plt.plot(times, sin_x(times, jopt_guess), label='initial guess') + + + File c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\qutip_qoc\pulse_optim.py:422, in optimize_pulses(objectives, control_parameters, tlist, algorithm_kwargs, optimizer_kwargs, minimizer_kwargs, integrator_kwargs, optimization_type) + 419 rl_env.train() + 420 return rl_env.result() + --> 422 return _global_local_optimization( + 423 objectives, + 424 control_parameters, + 425 time_interval, + 426 time_options, + 427 algorithm_kwargs, + 428 optimizer_kwargs, + 429 minimizer_kwargs, + 430 integrator_kwargs, + 431 qtrl_optimizers, + 432 ) + + + File c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\qutip_qoc\_optimizer.py:359, in _global_local_optimization(objectives, control_parameters, time_interval, time_options, algorithm_kwargs, optimizer_kwargs, minimizer_kwargs, integrator_kwargs, qtrl_optimizers) + 356 cllbck = _Callback(result, fid_err_targ, max_wall_time, bounds, disp) + 358 # run the optimization + --> 359 min_res = optimizer( + 360 func=multi_objective.goal_fun, + 361 minimizer_kwargs={ + 362 "jac": multi_objective.grad_fun, + 363 "callback": cllbck.min_callback, + 364 **minimizer_kwargs, + 365 }, + 366 callback=cllbck.opt_callback, + 367 **optimizer_kwargs, + 368 ) + 370 cllbck.stop_clock() # stop the clock + 372 # some global optimization methods do not return the minimum result + 373 # when terminated through StopIteration (see min_callback) + + + File c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\scipy\_lib\_util.py:440, in _transition_to_rng..decorator..wrapper(*args, **kwargs) + 433 message = ( + 434 "The NumPy global RNG was seeded by calling " + 435 f"`np.random.seed`. Beginning in {end_version}, this " + 436 "function will no longer use the global RNG." + 437 ) + cmn_msg + 438 warnings.warn(message, FutureWarning, stacklevel=2) + --> 440 return fun(*args, **kwargs) + + + File c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\scipy\optimize\_basinhopping.py:696, in basinhopping(func, x0, niter, T, stepsize, minimizer_kwargs, take_step, accept_test, callback, interval, disp, niter_success, rng, target_accept_rate, stepwise_factor) + 693 if niter_success is None: + 694 niter_success = niter + 2 + --> 696 bh = BasinHoppingRunner(x0, wrapped_minimizer, take_step_wrapped, + 697 accept_tests, disp=disp) + 699 # The wrapped minimizer is called once during construction of + 700 # BasinHoppingRunner, so run the callback + 701 if callable(callback): + + + File c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\scipy\optimize\_basinhopping.py:78, in BasinHoppingRunner.__init__(self, x0, minimizer, step_taking, accept_tests, disp) + 75 self.res.minimization_failures = 0 + 77 # do initial minimization + ---> 78 minres = minimizer(self.x) + 79 if not minres.success: + 80 self.res.minimization_failures += 1 + + + File c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\scipy\optimize\_basinhopping.py:294, in MinimizerWrapper.__call__(self, x0) + 292 return self.minimizer(x0, **self.kwargs) + 293 else: + --> 294 return self.minimizer(self.func, x0, **self.kwargs) + + + File c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\scipy\optimize\_minimize.py:726, in minimize(fun, x0, args, method, jac, hess, hessp, bounds, constraints, tol, callback, options) + 723 callback = _wrap_callback(callback, meth) + 725 if meth == 'nelder-mead': + --> 726 res = _minimize_neldermead(fun, x0, args, callback, bounds=bounds, + 727 **options) + 728 elif meth == 'powell': + 729 res = _minimize_powell(fun, x0, args, callback, bounds, **options) + + + File c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\scipy\optimize\_optimize.py:833, in _minimize_neldermead(func, x0, args, callback, maxiter, maxfev, disp, return_all, initial_simplex, xatol, fatol, adaptive, bounds, **unknown_options) + 831 try: + 832 for k in range(N + 1): + --> 833 fsim[k] = func(sim[k]) + 834 except _MaxFuncCallError: + 835 pass + + + File c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\scipy\optimize\_optimize.py:542, in _wrap_scalar_function_maxfun_validation..function_wrapper(x, *wrapper_args) + 540 ncalls[0] += 1 + 541 # A copy of x is sent to the user function (gh13740) + --> 542 fx = function(np.copy(x), *(wrapper_args + args)) + 543 # Ideally, we'd like to a have a true scalar returned from f(x). For + 544 # backwards-compatibility, also allow np.array([1.3]), + 545 # np.array([[1.3]]) etc. + 546 if not np.isscalar(fx): + + + File c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\qutip_qoc\objective.py:143, in _MultiObjective.goal_fun(self, params) + 141 infid = 0 + 142 for i, alg in enumerate(self._alg_list): + --> 143 infid += self._weights[i] * alg.infidelity(params) + 144 return infid + + + [... skipping hidden 14 frame] + + + File c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\qutip_qoc\_jopt.py:153, in _JOPT._infid(self, params) + 151 diff = X - self._target + 152 # to prevent if/else in qobj.dag() and qobj.tr() + --> 153 diff_dag = Qobj(diff.data.adjoint(), dims=diff.dims) + 154 g = 1 / 2 * (diff_dag * diff).data.trace() + 155 infid = jnp.real(self._norm_fac * g) + + + File c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\qutip\core\qobj.py:279, in Qobj.__init__(self, arg, dims, copy, superrep, isherm, isunitary) + 277 self._isherm = isherm + 278 self._isunitary = isunitary + --> 279 self._initialize_data(arg, dims, copy) + 281 if superrep is not None: + 282 self.superrep = superrep + + + File c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\qutip\core\qobj.py:265, in Qobj._initialize_data(self, arg, dims, copy) + 261 self._dims = Dimensions( + 262 dims or [[self._data.shape[0]], [self._data.shape[1]]] + 263 ) + 264 if self._dims.shape != self._data.shape: + --> 265 raise ValueError('Provided dimensions do not match the data: ' + + 266 f"{self._dims.shape} vs {self._data.shape}") + + + ValueError: Provided dimensions do not match the data: (4, 1) vs (1, 4) + + + ```python H_result = [Hd, [Hc, np.array(res_jopt.optimized_controls[0])]] evolution = qt.sesolve(H_result, initial_state, times) @@ -126,8 +294,15 @@ plt.show() ``` + + +![png](JOPT_state_open_files/JOPT_state_open_10_0.png) + + + ### b) optimized over time + ```python # treats time as optimization variable ctrl_parameters["__time__"] = { @@ -165,22 +340,40 @@ plt.legend() plt.show() ``` + Infidelity: 0.000510596900193172 + optimized time: [6.283185307179586] + + + + +![png](JOPT_state_open_files/JOPT_state_open_12_1.png) + + + + ```python -H_result = [Hd, [Hc, np.array(res_jopt_time.optimized_controls[0])]] -evolution_time = qt.sesolve(H_result, initial_state, times) +H_result_time = [Hd, [Hc, np.array(res_jopt_time.optimized_controls[0])]] +evolution_time = qt.sesolve(H_result_time, initial_state, times) plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution_time.states], label="Overlap with initial state") plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution_time.states], label="Overlap with target state") plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_time.states], '--', label="Fidelity") -plt.title('JOPT (optimized over time) performance') +plt.title('JOPT performance (optimized over time)') plt.xlabel('Time') plt.xlim(0, res_jopt_time.optimized_params[-1][0]) plt.legend() plt.show() ``` + + +![png](JOPT_state_open_files/JOPT_state_open_13_0.png) + + + ## Global optimization + ```python opt_args = { "method": "basinhopping", @@ -203,7 +396,7 @@ print('Optimized time: ', res_jopt_global.optimized_params[-1]) plt.plot(times, res_jopt.optimized_controls[0], label='Optimized pulse') plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[0])[global_range], label='Global optimized pulse') -plt.title('JOPT pulses (global)') +plt.title('JOPT pulses') plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() @@ -211,22 +404,40 @@ plt.show() ``` + Infidelity: 6.418314632516964e-05 + optimized time: [2.990647906220658] + + + + +![png](JOPT_state_open_files/JOPT_state_open_15_1.png) + + + + ```python -H_result = [Hd, [Hc, np.array(res_jopt_global.optimized_controls[0])]] -evolution_global = qt.sesolve(H_result, initial_state, times) +H_result_global = [Hd, [Hc, np.array(res_jopt_global.optimized_controls[0])]] +evolution_global = qt.sesolve(H_result_global, initial_state, times) plt.plot(times, [np.abs(state.overlap(initial_state))**2 for state in evolution_global.states], label="Overlap with initial state") plt.plot(times, [np.abs(state.overlap(target_state))**2 for state in evolution_global.states], label="Overlap with target state") plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_global.states], '--', label="Fidelity") plt.xlim(0, res_jopt_global.optimized_params[-1][0]) -plt.title('JOPT (global) performance') +plt.title('JOPT performance (global)') plt.xlabel('Time') plt.legend() plt.show() ``` + + +![png](JOPT_state_open_files/JOPT_state_open_16_0.png) + + + ## Comparison + ```python plt.plot(times, sin_x(times, jopt_guess), label='Initial guess') plt.plot(times, res_jopt.optimized_controls[0], label='Optimized pulse') @@ -239,6 +450,13 @@ plt.legend() plt.show() ``` + + +![png](JOPT_state_open_files/JOPT_state_open_18_0.png) + + + + ```python print('Guess Infidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) print('JOPT Infidelity: ', res_jopt.infidelity) @@ -256,18 +474,67 @@ plt.legend() plt.show() ``` + Guess Infidelity: 0.7568009078458054 + JOPT Infidelity: 0.0003454363645383207 + Time Infidelity: 0.000510596900193172 + GLobal Infidelity: 6.418314632516964e-05 + + + + +![png](JOPT_state_open_files/JOPT_state_open_19_1.png) + + + ## Validation + ```python assert res_jopt.infidelity < 0.001 assert res_jopt_time.infidelity < 0.001 assert res_jopt_global.infidelity < 0.001 ``` + ```python qt.about() ``` + + QuTiP: Quantum Toolbox in Python + ================================ + Copyright (c) QuTiP team 2011 and later. + Current admin team: Alexander Pitchford, Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguère, Boxi Li, Simon Cross, Asier Galicia, Paul Menczel, and Patrick Hopf. + Board members: Daniel Burgarth, Robert Johansson, Anton F. Kockum, Franco Nori and Will Zeng. + Original developers: R. J. Johansson & P. D. Nation. + Previous lead developers: Chris Granade & A. Grimsmo. + Currently developed through wide collaboration. See https://github.com/qutip for details. + + QuTiP Version: 5.1.1 + Numpy Version: 1.26.4 + Scipy Version: 1.15.2 + Cython Version: None + Matplotlib Version: 3.10.0 + Python Version: 3.12.10 + Number of CPUs: 8 + BLAS Info: Generic + INTEL MKL Ext: None + Platform Info: Windows (AMD64) + Installation path: c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\qutip + + Installed QuTiP family packages + ------------------------------- + + qutip-jax: 0.1.0 + qutip-qtrl: 0.1.5 + + ================================================================================ + Please cite QuTiP in your publication. + ================================================================================ + For your convenience a bibtex reference can be easily generated using `qutip.cite()` + + + ```python ``` From 69253b206313748f9fcafc03b101b3784f4e43a4 Mon Sep 17 00:00:00 2001 From: Paul Menczel Date: Wed, 20 Aug 2025 14:26:06 +0900 Subject: [PATCH 16/17] Added metadata and removed output from jupytext notebook files, added JOPT skips --- tests/interactive/CRAB_gate_open.md | 73 +- tests/interactive/CRAB_state_open.md | 69 +- tests/interactive/GOAT_gate_open.md | 121 +- tests/interactive/GOAT_state_open.md | 136 +- tests/interactive/GRAPE_gate_open.md | 75 +- tests/interactive/GRAPE_state_open.md | 3889 +------------------------ tests/interactive/JOPT_gate_open.md | 53 +- tests/interactive/JOPT_state_open.md | 301 +- 8 files changed, 171 insertions(+), 4546 deletions(-) diff --git a/tests/interactive/CRAB_gate_open.md b/tests/interactive/CRAB_gate_open.md index cb81fe0..b5c2ece 100644 --- a/tests/interactive/CRAB_gate_open.md +++ b/tests/interactive/CRAB_gate_open.md @@ -1,3 +1,17 @@ +--- +jupyter: + jupytext: + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.17.2 + kernelspec: + display_name: Python 3 (ipykernel) + language: python + name: python3 +--- + # CRAB algorithm @@ -72,22 +86,6 @@ plt.legend() plt.show() ``` - c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\scipy\optimize\_basinhopping.py:294: RuntimeWarning: Method Nelder-Mead does not use gradient information (jac). - return self.minimizer(self.func, x0, **self.kwargs) - c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\scipy\optimize\_basinhopping.py:294: OptimizeWarning: Unknown solver options: gtol - return self.minimizer(self.func, x0, **self.kwargs) - - - Infidelity: 0.007575498222395387 - - - - -![png](CRAB_gate_open_files/CRAB_gate_open_5_2.png) - - - - ```python H_result = [Hd, [Hc[0], res_crab.optimized_controls[0]], @@ -111,15 +109,7 @@ plt.title("CRAB performance") plt.xlabel("Time") plt.legend() plt.show() - ``` - - - -![png](CRAB_gate_open_files/CRAB_gate_open_6_0.png) - - - ## Validation @@ -132,38 +122,3 @@ assert res_crab.infidelity < 0.01 qt.about() ``` - - QuTiP: Quantum Toolbox in Python - ================================ - Copyright (c) QuTiP team 2011 and later. - Current admin team: Alexander Pitchford, Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguère, Boxi Li, Simon Cross, Asier Galicia, Paul Menczel, and Patrick Hopf. - Board members: Daniel Burgarth, Robert Johansson, Anton F. Kockum, Franco Nori and Will Zeng. - Original developers: R. J. Johansson & P. D. Nation. - Previous lead developers: Chris Granade & A. Grimsmo. - Currently developed through wide collaboration. See https://github.com/qutip for details. - - QuTiP Version: 5.1.1 - Numpy Version: 1.26.4 - Scipy Version: 1.15.2 - Cython Version: None - Matplotlib Version: 3.10.0 - Python Version: 3.12.10 - Number of CPUs: 8 - BLAS Info: Generic - INTEL MKL Ext: None - Platform Info: Windows (AMD64) - Installation path: c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\qutip - - Installed QuTiP family packages - ------------------------------- - - qutip-jax: 0.1.0 - qutip-qtrl: 0.1.5 - - ================================================================================ - Please cite QuTiP in your publication. - ================================================================================ - For your convenience a bibtex reference can be easily generated using `qutip.cite()` - - - diff --git a/tests/interactive/CRAB_state_open.md b/tests/interactive/CRAB_state_open.md index ba71511..a63fd3d 100644 --- a/tests/interactive/CRAB_state_open.md +++ b/tests/interactive/CRAB_state_open.md @@ -1,3 +1,17 @@ +--- +jupyter: + jupytext: + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.17.2 + kernelspec: + display_name: Python 3 (ipykernel) + language: python + name: python3 +--- + # GRAPE algorithm for 2 level system @@ -67,16 +81,6 @@ plt.legend() plt.show() ``` - Infidelity: 0.0027237139157979926 - - - - -![png](CRAB_state_open_files/CRAB_state_open_5_1.png) - - - - ```python H_result = [Hd, [Hc, res_crab.optimized_controls[0]]] evolution = qt.mesolve(H_result, initial_state, times, c_ops) @@ -89,13 +93,6 @@ plt.xlabel('Time') plt.legend() plt.show() ``` - - - -![png](CRAB_state_open_files/CRAB_state_open_6_0.png) - - - ## Validation @@ -108,41 +105,3 @@ assert res_crab.infidelity < 0.01 qt.about() ``` - - QuTiP: Quantum Toolbox in Python - ================================ - Copyright (c) QuTiP team 2011 and later. - Current admin team: Alexander Pitchford, Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguère, Boxi Li, Simon Cross, Asier Galicia, Paul Menczel, and Patrick Hopf. - Board members: Daniel Burgarth, Robert Johansson, Anton F. Kockum, Franco Nori and Will Zeng. - Original developers: R. J. Johansson & P. D. Nation. - Previous lead developers: Chris Granade & A. Grimsmo. - Currently developed through wide collaboration. See https://github.com/qutip for details. - - QuTiP Version: 5.1.1 - Numpy Version: 1.26.4 - Scipy Version: 1.15.2 - Cython Version: None - Matplotlib Version: 3.10.0 - Python Version: 3.12.10 - Number of CPUs: 8 - BLAS Info: Generic - INTEL MKL Ext: None - Platform Info: Windows (AMD64) - Installation path: c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\qutip - - Installed QuTiP family packages - ------------------------------- - - qutip-jax: 0.1.0 - qutip-qtrl: 0.1.5 - - ================================================================================ - Please cite QuTiP in your publication. - ================================================================================ - For your convenience a bibtex reference can be easily generated using `qutip.cite()` - - - -```python - -``` diff --git a/tests/interactive/GOAT_gate_open.md b/tests/interactive/GOAT_gate_open.md index 83ca6f1..adf2528 100644 --- a/tests/interactive/GOAT_gate_open.md +++ b/tests/interactive/GOAT_gate_open.md @@ -1,3 +1,17 @@ +--- +jupyter: + jupytext: + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.17.2 + kernelspec: + display_name: Python 3 (ipykernel) + language: python + name: python3 +--- + # GOAT algorithm @@ -61,15 +75,7 @@ plt.title("Guess performance") plt.xlabel("Time") plt.legend() plt.show() - ``` - - - -![png](GOAT_gate_open_files/GOAT_gate_open_5_0.png) - - - ## Goat algorithm ### a) not optimized over time @@ -124,16 +130,6 @@ plt.legend() plt.show() ``` - Infidelity: 0.005501824802474568 - - - - -![png](GOAT_gate_open_files/GOAT_gate_open_8_1.png) - - - - ```python H_result = [Hd, [Hc[0], np.array(res_goat.optimized_controls[0])], @@ -157,15 +153,7 @@ plt.title("GOAT performance") plt.xlabel("Time") plt.legend() plt.show() - ``` - - - -![png](GOAT_gate_open_files/GOAT_gate_open_9_0.png) - - - ### b) optimized over time @@ -204,17 +192,6 @@ plt.legend() plt.show() ``` - Infidelity: 0.005093554605043814 - Optimized time: 1.4867367205567528 - - - - -![png](GOAT_gate_open_files/GOAT_gate_open_11_1.png) - - - - ```python H_result_time = [Hd, [Hc[0], np.array(res_goat_time.optimized_controls[0])], @@ -239,15 +216,7 @@ plt.title("GOAT performance (optimized over time)") plt.xlabel("Time") plt.legend() plt.show() - ``` - - - -![png](GOAT_gate_open_files/GOAT_gate_open_12_0.png) - - - ## Global optimization @@ -285,17 +254,6 @@ plt.legend() plt.show() ``` - Infidelity: 0.0065077273552405545 - optimized time: [1.5707963267948966] - - - - -![png](GOAT_gate_open_files/GOAT_gate_open_14_1.png) - - - - ```python H_result_global = [Hd, [Hc[0], np.array(res_goat_global.optimized_controls[0])], @@ -319,15 +277,7 @@ plt.title("GOAT performance (global)") plt.xlabel("Time") plt.legend() plt.show() - ``` - - - -![png](GOAT_gate_open_files/GOAT_gate_open_15_0.png) - - - ## Comparison @@ -349,15 +299,7 @@ for i in range(3): plt.tight_layout() plt.show() - ``` - - - -![png](GOAT_gate_open_files/GOAT_gate_open_17_0.png) - - - ## Validation @@ -372,38 +314,3 @@ assert res_goat_global.infidelity < 0.01 qt.about() ``` - - QuTiP: Quantum Toolbox in Python - ================================ - Copyright (c) QuTiP team 2011 and later. - Current admin team: Alexander Pitchford, Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguère, Boxi Li, Simon Cross, Asier Galicia, Paul Menczel, and Patrick Hopf. - Board members: Daniel Burgarth, Robert Johansson, Anton F. Kockum, Franco Nori and Will Zeng. - Original developers: R. J. Johansson & P. D. Nation. - Previous lead developers: Chris Granade & A. Grimsmo. - Currently developed through wide collaboration. See https://github.com/qutip for details. - - QuTiP Version: 5.1.1 - Numpy Version: 1.26.4 - Scipy Version: 1.15.2 - Cython Version: None - Matplotlib Version: 3.10.0 - Python Version: 3.12.10 - Number of CPUs: 8 - BLAS Info: Generic - INTEL MKL Ext: None - Platform Info: Windows (AMD64) - Installation path: c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\qutip - - Installed QuTiP family packages - ------------------------------- - - qutip-jax: 0.1.0 - qutip-qtrl: 0.1.5 - - ================================================================================ - Please cite QuTiP in your publication. - ================================================================================ - For your convenience a bibtex reference can be easily generated using `qutip.cite()` - - - diff --git a/tests/interactive/GOAT_state_open.md b/tests/interactive/GOAT_state_open.md index 8b49d25..77d77ec 100644 --- a/tests/interactive/GOAT_state_open.md +++ b/tests/interactive/GOAT_state_open.md @@ -1,3 +1,17 @@ +--- +jupyter: + jupytext: + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.17.2 + kernelspec: + display_name: Python 3 (ipykernel) + language: python + name: python3 +--- + # GOAT algorithm for a 2 level system @@ -58,15 +72,6 @@ plt.xlabel("Time") plt.show() ``` - Fidelity: 0.8176293626457246 - - - - -![png](GOAT_state_open_files/GOAT_state_open_5_1.png) - - - ## GOAT algorithm @@ -119,16 +124,6 @@ plt.legend() plt.show() ``` - Infidelity: 0.07178736737494786 - - - - -![png](GOAT_state_open_files/GOAT_state_open_9_1.png) - - - - ```python H_result = [Hd] + [[Hc, np.array(res_goat.optimized_controls[0])]] evolution = qt.mesolve(H_result, initial_state, times, c_ops) @@ -142,13 +137,6 @@ plt.ylim(0, 1) plt.legend() plt.show() ``` - - - -![png](GOAT_state_open_files/GOAT_state_open_10_0.png) - - - ### b) optimized over time @@ -182,17 +170,6 @@ plt.legend() plt.show() ``` - Infidelity: 0.009074574820662817 - optimized time: [0.37202273025971855] - - - - -![png](GOAT_state_open_files/GOAT_state_open_12_1.png) - - - - ```python times2 = times[time_range] if opt_time not in times2: @@ -210,13 +187,6 @@ plt.xlim(0, res_goat_time.optimized_params[-1][0]) plt.legend() plt.show() ``` - - - -![png](GOAT_state_open_files/GOAT_state_open_13_0.png) - - - ### Global optimization @@ -251,20 +221,8 @@ plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() plt.show() - ``` - Infidelity: 0.007905283658334122 - optimized time: [1.5444538341679324] - - - - -![png](GOAT_state_open_files/GOAT_state_open_15_1.png) - - - - ```python times3 = times[global_range] if global_time not in times3: @@ -283,13 +241,6 @@ plt.xlabel('Time') plt.legend() plt.show() ``` - - - -![png](GOAT_state_open_files/GOAT_state_open_16_0.png) - - - ## Comparison @@ -304,14 +255,6 @@ plt.ylabel('Pulse amplitude') plt.legend() plt.show() ``` - - - -![png](GOAT_state_open_files/GOAT_state_open_18_0.png) - - - - ```python print('Guess Fidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) print('GOAT Infidelity: ', res_goat.infidelity) @@ -327,21 +270,8 @@ plt.title('Fidelities') plt.xlabel('Time') plt.legend() plt.show() - ``` - Guess Fidelity: 0.8176293626457246 - GOAT Infidelity: 0.07178736737494786 - Time Infidelity: 0.009074574820662817 - GLobal Infidelity: 0.007905283658334122 - - - - -![png](GOAT_state_open_files/GOAT_state_open_19_1.png) - - - ## Validation @@ -356,41 +286,3 @@ assert res_goat_global.infidelity < 0.01 qt.about() ``` - - QuTiP: Quantum Toolbox in Python - ================================ - Copyright (c) QuTiP team 2011 and later. - Current admin team: Alexander Pitchford, Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguère, Boxi Li, Simon Cross, Asier Galicia, Paul Menczel, and Patrick Hopf. - Board members: Daniel Burgarth, Robert Johansson, Anton F. Kockum, Franco Nori and Will Zeng. - Original developers: R. J. Johansson & P. D. Nation. - Previous lead developers: Chris Granade & A. Grimsmo. - Currently developed through wide collaboration. See https://github.com/qutip for details. - - QuTiP Version: 5.1.1 - Numpy Version: 1.26.4 - Scipy Version: 1.15.2 - Cython Version: None - Matplotlib Version: 3.10.0 - Python Version: 3.12.10 - Number of CPUs: 8 - BLAS Info: Generic - INTEL MKL Ext: None - Platform Info: Windows (AMD64) - Installation path: c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\qutip - - Installed QuTiP family packages - ------------------------------- - - qutip-jax: 0.1.0 - qutip-qtrl: 0.1.5 - - ================================================================================ - Please cite QuTiP in your publication. - ================================================================================ - For your convenience a bibtex reference can be easily generated using `qutip.cite()` - - - -```python - -``` diff --git a/tests/interactive/GRAPE_gate_open.md b/tests/interactive/GRAPE_gate_open.md index 80c35a3..3c7b566 100644 --- a/tests/interactive/GRAPE_gate_open.md +++ b/tests/interactive/GRAPE_gate_open.md @@ -1,3 +1,17 @@ +--- +jupyter: + jupytext: + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.17.2 + kernelspec: + display_name: Python 3 (ipykernel) + language: python + name: python3 +--- + # GRAPE algorithm for 2 level system @@ -62,15 +76,7 @@ plt.title("Guess performance") plt.xlabel("Time") plt.legend() plt.show() - ``` - - - -![png](GRAPE_gate_open_files/GRAPE_gate_open_5_0.png) - - - ## Grape algorithm @@ -101,16 +107,6 @@ plt.legend() plt.show() ``` - Infidelity: 0.006817967340126763 - - - - -![png](GRAPE_gate_open_files/GRAPE_gate_open_7_1.png) - - - - ```python H_result = [Hd, [Hc[0], res_grape.optimized_controls[0]], @@ -135,15 +131,7 @@ plt.title("GRAPE performance") plt.xlabel("Time") plt.legend() plt.show() - ``` - - - -![png](GRAPE_gate_open_files/GRAPE_gate_open_8_0.png) - - - ## Validation @@ -156,38 +144,3 @@ assert res_grape.infidelity < 0.01 qt.about() ``` - - QuTiP: Quantum Toolbox in Python - ================================ - Copyright (c) QuTiP team 2011 and later. - Current admin team: Alexander Pitchford, Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguère, Boxi Li, Simon Cross, Asier Galicia, Paul Menczel, and Patrick Hopf. - Board members: Daniel Burgarth, Robert Johansson, Anton F. Kockum, Franco Nori and Will Zeng. - Original developers: R. J. Johansson & P. D. Nation. - Previous lead developers: Chris Granade & A. Grimsmo. - Currently developed through wide collaboration. See https://github.com/qutip for details. - - QuTiP Version: 5.1.1 - Numpy Version: 1.26.4 - Scipy Version: 1.15.2 - Cython Version: None - Matplotlib Version: 3.10.0 - Python Version: 3.12.10 - Number of CPUs: 8 - BLAS Info: Generic - INTEL MKL Ext: None - Platform Info: Windows (AMD64) - Installation path: c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\qutip - - Installed QuTiP family packages - ------------------------------- - - qutip-jax: 0.1.0 - qutip-qtrl: 0.1.5 - - ================================================================================ - Please cite QuTiP in your publication. - ================================================================================ - For your convenience a bibtex reference can be easily generated using `qutip.cite()` - - - diff --git a/tests/interactive/GRAPE_state_open.md b/tests/interactive/GRAPE_state_open.md index f83289a..afa2ab2 100644 --- a/tests/interactive/GRAPE_state_open.md +++ b/tests/interactive/GRAPE_state_open.md @@ -1,14 +1,33 @@ +--- +jupyter: + jupytext: + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.17.2 + kernelspec: + display_name: Python 3 (ipykernel) + language: python + name: python3 +--- + # GRAPE algorithm for 2 level system ```python import matplotlib.pyplot as plt import numpy as np -from qutip import (about, fidelity, liouvillian, ket2dm, Qobj, basis, sigmam) +from qutip import basis, ket2dm, liouvillian, sigmam, Qobj import qutip as qt from qutip_qoc import Objective, optimize_pulses -import logging +def fidelity(state, target_state): + """ + Fidelity used for density matrices in qutip-qtrl and qutip-qoc + """ + diff = state - target_state + return 1 - np.real(diff.overlap(diff)) / (2 * target_state.norm()) ``` ## Problem setup @@ -16,22 +35,20 @@ import logging ```python # Energy levels -E1, E2 = 1.0, 2.0 +E1, E2 = 1.0, 2.0 +Hd = Qobj(np.diag([E1, E2])) -hbar = 1 -omega = 0.1 # energy splitting -delta = 1.0 # tunneling gamma = 0.1 # amplitude damping c_ops = [np.sqrt(gamma) * sigmam()] -Hd = Qobj(np.diag([E1, E2])) -Hd = liouvillian(H=Hd, c_ops=c_ops) Hc = Qobj(np.array([ [0, 1], [1, 0] -])) -Hc = liouvillian(Hc) -H = [Hd, Hc] +])) + +Ld = liouvillian(H=Hd, c_ops=c_ops) +Lc = liouvillian(Hc) +L = [Ld, Lc] initial_state = ket2dm(basis(2, 0)) target_state = ket2dm(basis(2, 1)) @@ -43,51 +60,44 @@ times = np.linspace(0, 2 * np.pi, 250) ```python -grape_guess = np.sin(times) +guess_pulse = np.sin(times) -H_result_guess = [Hd, [Hc, grape_guess]] -evolution_guess = qt.mesolve(H_result_guess, initial_state, times) +L_guess = [Ld, [Lc, guess_pulse]] +evolution_guess = qt.mesolve(L_guess, initial_state, times) -print('Fidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) +print('Fidelity: ', fidelity(evolution_guess.states[-1], target_state)) -plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution_guess.states], label="Overlap with initial state") -plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution_guess.states], label="Overlap with target state") -plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_guess.states], '--', label="Fidelity") +plt.plot(times, [fidelity(state, initial_state) for state in evolution_guess.states], label="Overlap with initial state") +plt.plot(times, [fidelity(state, target_state) for state in evolution_guess.states], label="Overlap with target state") plt.legend() plt.title("Guess performance") plt.xlabel("Time") plt.show() ``` - Fidelity: 0.4768516474214033 - - - - -![png](GRAPE_state_open_files/GRAPE_state_open_5_1.png) - - - ## GRAPE algorithm ```python -alg_args = {"alg": "GRAPE", "fid_err_targ": 0.001, "log_level": logging.DEBUG - 2} control_params = { - "ctrl_1": {"guess": grape_guess, "bounds": [-1, 1]}, # Control pulse for Hc1 + "ctrl_x": {"guess": guess_pulse, "bounds": [-1, 1]}, # Control pulse for Hc1 } res_grape = optimize_pulses( - objectives = Objective(initial_state, H, target_state), + objectives = Objective(initial_state, L, target_state), control_parameters = control_params, tlist = times, - algorithm_kwargs=alg_args, + algorithm_kwargs = { + "alg": "GRAPE", + "fid_err_targ": 0.001, + }, ) print('Infidelity: ', res_grape.infidelity) -plt.plot(times, grape_guess, label='initial guess') -plt.plot(times, res_grape.optimized_controls[0], label='optimized pulse') +control_step_function = qt.coefficient(res_grape.optimized_controls[0], tlist=times, order=0) +plt.plot(times, guess_pulse, label='initial guess') +plt.plot(times, [control_step_function(t) for t in times], label='optimized pulse') plt.title('GRAPE pulses') plt.xlabel('Time') plt.ylabel('Pulse amplitude') @@ -95,3816 +105,39 @@ plt.legend() plt.show() ``` - DEBUG:qutip_qtrl.pulseoptim:Optimisation config summary... - object classes: - optimizer: OptimizerLBFGSB - dynamics: DynamicsGenMat - tslotcomp: TSlotCompUpdateAll - fidcomp: FidCompTraceDiff - propcomp: PropCompFrechet - pulsegen: PulseGenRandom - INFO:qutip_qtrl.dynamics:Setting memory optimisations for level 0 - INFO:qutip_qtrl.dynamics:Internal operator data type choosen to be - INFO:qutip_qtrl.dynamics:phased dynamics generator caching False - INFO:qutip_qtrl.dynamics:propagator gradient caching True - INFO:qutip_qtrl.dynamics:eigenvector adjoint caching True - INFO:qutip_qtrl.dynamics:use sparse eigen decomp False - DEBUG:qutip_qtrl.fidcomp:Scale factor calculated as 0.125 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.77189877-2.55094136e-17j] - [-0.06888728+2.98015228e-02j] - [-0.06888728-2.98015228e-02j] - [ 0.22810123+3.09932752e-17j]] - Evo final diff: - [[-0.77189877+2.55094136e-17j] - [ 0.06888728-2.98015228e-02j] - [ 0.06888728+2.98015228e-02j] - [ 0.77189877-3.09932752e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.15036532376635012 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0045647848138128475 - DEBUG:qutip_qtrl.tslotcomp:250 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.77183948+2.11668240e-17j] - [-0.06878968+3.01708340e-02j] - [-0.06878968-3.01708340e-02j] - [ 0.22816052-3.88175187e-17j]] - Evo final diff: - [[-0.77183948-2.11668240e-17j] - [ 0.06878968-3.01708340e-02j] - [ 0.06878968+3.01708340e-02j] - [ 0.77183948+3.88175187e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.15034462159320172 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.004587903075889462 - DEBUG:qutip_qtrl.tslotcomp:246 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.77177915+1.40721819e-16j] - [-0.06869664+3.05472003e-02j] - [-0.06869664-3.05472003e-02j] - [ 0.22822085-1.30622752e-16j]] - Evo final diff: - [[-0.77177915-1.40721819e-16j] - [ 0.06869664-3.05472003e-02j] - [ 0.06869664+3.05472003e-02j] - [ 0.77177915+1.30622752e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.15032385401393628 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.004611869361896642 - DEBUG:qutip_qtrl.tslotcomp:245 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.7717178 -1.27328110e-16j] - [-0.06860605+3.09304740e-02j] - [-0.06860605-3.09304740e-02j] - [ 0.2282822 +1.19721597e-16j]] - Evo final diff: - [[-0.7717178 +1.27328110e-16j] - [ 0.06860605-3.09304740e-02j] - [ 0.06860605+3.09304740e-02j] - [ 0.7717178 -1.19721597e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.15030296035733728 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.004636702772677686 - DEBUG:qutip_qtrl.tslotcomp:243 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.77165535+5.88065328e-17j] - [-0.06851891+3.13212862e-02j] - [-0.06851891-3.13212862e-02j] - [ 0.22834465-8.84404665e-17j]] - Evo final diff: - [[-0.77165535-5.88065328e-17j] - [ 0.06851891-3.13212862e-02j] - [ 0.06851891+3.13212862e-02j] - [ 0.77165535+8.84404665e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1502819613893671 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.004662458936031275 - DEBUG:qutip_qtrl.tslotcomp:243 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.77160369-1.56147982e-16j] - [-0.06844693+3.16424209e-02j] - [-0.06844693-3.16424209e-02j] - [ 0.22839631+1.61263908e-16j]] - Evo final diff: - [[-0.77160369+1.56147982e-16j] - [ 0.06844693-3.16424209e-02j] - [ 0.06844693+3.16424209e-02j] - [ 0.77160369-1.61263908e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.15026461863006424 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.004683963412756786 - DEBUG:qutip_qtrl.tslotcomp:242 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.77153912-2.09592373e-16j] - [-0.06836152+3.20493470e-02j] - [-0.06836152-3.20493470e-02j] - [ 0.22846088+2.41356774e-16j]] - Evo final diff: - [[-0.77153912+2.09592373e-16j] - [ 0.06836152-3.20493470e-02j] - [ 0.06836152+3.20493470e-02j] - [ 0.77153912-2.41356774e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.15024327002109059 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.004711635679508653 - DEBUG:qutip_qtrl.tslotcomp:241 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.77147339-7.78719737e-17j] - [-0.06827832+3.24638088e-02j] - [-0.06827832-3.24638088e-02j] - [ 0.22852661+8.00011105e-17j]] - Evo final diff: - [[-0.77147339+7.78719737e-17j] - [ 0.06827832-3.24638088e-02j] - [ 0.06827832+3.24638088e-02j] - [ 0.77147339-8.00011105e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.15022175486668604 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0047402962406730585 - DEBUG:qutip_qtrl.tslotcomp:240 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.77140648+2.80046031e-17j] - [-0.06819712+3.28860163e-02j] - [-0.06819712-3.28860163e-02j] - [ 0.22859352-3.81147377e-17j]] - Evo final diff: - [[-0.77140648-2.80046031e-17j] - [ 0.06819712-3.28860163e-02j] - [ 0.06819712+3.28860163e-02j] - [ 0.77140648+3.81147377e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1502000733832908 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.004769979617145052 - DEBUG:qutip_qtrl.tslotcomp:240 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.77125928-2.61512952e-17j] - [-0.0680189 +3.38029002e-02j] - [-0.0680189 -3.38029002e-02j] - [ 0.22874072+5.76477707e-18j]] - Evo final diff: - [[-0.77125928+2.61512952e-17j] - [ 0.0680189 -3.38029002e-02j] - [ 0.0680189 +3.38029002e-02j] - [ 0.77125928-5.76477707e-18j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.15015251951338354 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.004836150174125501 - DEBUG:qutip_qtrl.tslotcomp:239 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.77118807+1.22057448e-17j] - [-0.06793595+3.42564861e-02j] - [-0.06793595-3.42564861e-02j] - [ 0.22881193-7.62023164e-19j]] - Evo final diff: - [[-0.77118807-1.22057448e-17j] - [ 0.06793595-3.42564861e-02j] - [ 0.06793595+3.42564861e-02j] - [ 0.77118807+7.62023164e-19j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.15012995838876778 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.004869736714693404 - DEBUG:qutip_qtrl.tslotcomp:239 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.77115973+1.17718943e-16j] - [-0.06790298+3.44358790e-02j] - [-0.06790298-3.44358790e-02j] - [ 0.22884027-1.28526484e-16j]] - Evo final diff: - [[-0.77115973-1.17718943e-16j] - [ 0.06790298-3.44358790e-02j] - [ 0.06790298+3.44358790e-02j] - [ 0.77115973+1.28526484e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.15012099202714108 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.004883171298510743 - DEBUG:qutip_qtrl.tslotcomp:238 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.77108648+1.01261093e-16j] - [-0.06782731+3.49004135e-02j] - [-0.06782731-3.49004135e-02j] - [ 0.22891352-1.05943800e-16j]] - Evo final diff: - [[-0.77108648-1.01261093e-16j] - [ 0.06782731-3.49004135e-02j] - [ 0.06782731+3.49004135e-02j] - [ 0.77108648+1.05943800e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1500982352062954 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0049183050014321335 - DEBUG:qutip_qtrl.tslotcomp:236 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.77101167-1.58451063e-16j] - [-0.06775199+3.53753146e-02j] - [-0.06775199-3.53753146e-02j] - [ 0.22898833+1.42781948e-16j]] - Evo final diff: - [[-0.77101167+1.58451063e-16j] - [ 0.06775199-3.53753146e-02j] - [ 0.06775199+3.53753146e-02j] - [ 0.77101167-1.42781948e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.15007518435797793 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.004954795160336729 - DEBUG:qutip_qtrl.tslotcomp:236 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.77070543+2.84974062e-16j] - [-0.06744441+3.72748920e-02j] - [-0.06744441-3.72748920e-02j] - [ 0.22929457-2.86800334e-16j]] - Evo final diff: - [[-0.77070543-2.84974062e-16j] - [ 0.06744441-3.72748920e-02j] - [ 0.06744441+3.72748920e-02j] - [ 0.77070543+2.86800334e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1499812557582843 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.00510634922996008 - DEBUG:qutip_qtrl.tslotcomp:236 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.7706754 +1.79711587e-16j] - [-0.06741431+3.74574774e-02j] - [-0.06741431-3.74574774e-02j] - [ 0.2293246 -1.73633551e-16j]] - Evo final diff: - [[-0.7706754 -1.79711587e-16j] - [ 0.06741431-3.74574774e-02j] - [ 0.06741431+3.74574774e-02j] - [ 0.7706754 +1.73633551e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1499720816101175 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.005121371114696426 - DEBUG:qutip_qtrl.tslotcomp:235 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.77059155+9.70869127e-17j] - [-0.06733804+3.79884020e-02j] - [-0.06733804-3.79884020e-02j] - [ 0.22940845-1.03221474e-16j]] - Evo final diff: - [[-0.77059155-9.70869127e-17j] - [ 0.06733804-3.79884020e-02j] - [ 0.06733804+3.79884020e-02j] - [ 0.77059155+1.03221474e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1499472181273278 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.005165475053769101 - DEBUG:qutip_qtrl.tslotcomp:235 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.77050403+7.53639071e-17j] - [-0.06725851+3.85367553e-02j] - [-0.06725851-3.85367553e-02j] - [ 0.22949597-5.80013822e-17j]] - Evo final diff: - [[-0.77050403-7.53639071e-17j] - [ 0.06725851-3.85367553e-02j] - [ 0.06725851+3.85367553e-02j] - [ 0.77050403+5.80013822e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1499213110823868 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.005211694407456673 - DEBUG:qutip_qtrl.tslotcomp:234 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.77041598-4.61548226e-17j] - [-0.06718426+3.90903520e-02j] - [-0.06718426-3.90903520e-02j] - [ 0.22958402+5.80490602e-17j]] - Evo final diff: - [[-0.77041598+4.61548226e-17j] - [ 0.06718426-3.90903520e-02j] - [ 0.06718426+3.90903520e-02j] - [ 0.77041598-5.80490602e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1498956394029262 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.005259008966628942 - DEBUG:qutip_qtrl.tslotcomp:234 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.7703487 -2.27062418e-16j] - [-0.06712757+3.95093047e-02j] - [-0.06712757-3.95093047e-02j] - [ 0.2296513 +2.08090810e-16j]] - Evo final diff: - [[-0.7703487 +2.27062418e-16j] - [ 0.06712757-3.95093047e-02j] - [ 0.06712757+3.95093047e-02j] - [ 0.7703487 -2.08090810e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14987605470290266 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.005295254196829969 - DEBUG:qutip_qtrl.tslotcomp:233 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.77025662+7.73849242e-18j] - [-0.06705288+4.00861662e-02j] - [-0.06705288-4.00861662e-02j] - [ 0.22974338-1.06700051e-17j]] - Evo final diff: - [[-0.77025662-7.73849242e-18j] - [ 0.06705288-4.00861662e-02j] - [ 0.06705288+4.00861662e-02j] - [ 0.77025662+1.06700051e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14984956260293078 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.005345766414596359 - DEBUG:qutip_qtrl.tslotcomp:233 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.77014532-5.51960516e-17j] - [-0.06696267+4.07748148e-02j] - [-0.06696267-4.07748148e-02j] - [ 0.22985468+5.32329613e-17j]] - Evo final diff: - [[-0.77014532+5.51960516e-17j] - [ 0.06696267-4.07748148e-02j] - [ 0.06696267+4.07748148e-02j] - [ 0.77014532-5.32329613e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14981760064067148 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0054069598138275846 - DEBUG:qutip_qtrl.tslotcomp:232 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.77004778-2.97572818e-16j] - [-0.06688661+4.13813427e-02j] - [-0.06688661-4.13813427e-02j] - [ 0.22995222+2.98558151e-16j]] - Evo final diff: - [[-0.77004778+2.97572818e-16j] - [ 0.06688661-4.13813427e-02j] - [ 0.06688661+4.13813427e-02j] - [ 0.77004778-2.98558151e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14978995562149755 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.00546164189499911 - DEBUG:qutip_qtrl.tslotcomp:232 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.77004778-2.13858864e-16j] - [-0.06688661+4.13813660e-02j] - [-0.06688661-4.13813660e-02j] - [ 0.22995222+2.06379278e-16j]] - Evo final diff: - [[-0.77004778+2.13858864e-16j] - [ 0.06688661-4.13813660e-02j] - [ 0.06688661+4.13813660e-02j] - [ 0.77004778-2.06379278e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14978995455654862 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.005461644004449913 - DEBUG:qutip_qtrl.tslotcomp:231 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.76994788-2.15691840e-16j] - [-0.06681423+4.19987925e-02j] - [-0.06681423-4.19987925e-02j] - [ 0.23005212+2.35671921e-16j]] - Evo final diff: - [[-0.76994788+2.15691840e-16j] - [ 0.06681423-4.19987925e-02j] - [ 0.06681423+4.19987925e-02j] - [ 0.76994788-2.35671921e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14976194316334568 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.005518008991489866 - DEBUG:qutip_qtrl.tslotcomp:231 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.76953622+5.10422021e-17j] - [-0.06651603+4.44683426e-02j] - [-0.06651603-4.44683426e-02j] - [ 0.23046378-3.06618180e-17j]] - Evo final diff: - [[-0.76953622-5.10422021e-17j] - [ 0.06651603-4.44683426e-02j] - [ 0.06651603+4.44683426e-02j] - [ 0.76953622+3.06618180e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14964695200330014 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.005750410323258551 - DEBUG:qutip_qtrl.tslotcomp:231 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.76948242+1.04422209e-16j] - [-0.06647706+4.47827260e-02j] - [-0.06647706-4.47827260e-02j] - [ 0.23051758-1.12913995e-16j]] - Evo final diff: - [[-0.76948242-1.04422209e-16j] - [ 0.06647706-4.47827260e-02j] - [ 0.06647706+4.47827260e-02j] - [ 0.76948242+1.12913995e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1496319734342141 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.005780753455337895 - DEBUG:qutip_qtrl.tslotcomp:230 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.76936661-1.26207892e-16j] - [-0.0664024 +4.54761475e-02j] - [-0.0664024 -4.54761475e-02j] - [ 0.23063339+1.46787011e-16j]] - Evo final diff: - [[-0.76936661+1.26207892e-16j] - [ 0.0664024 -4.54761475e-02j] - [ 0.0664024 +4.54761475e-02j] - [ 0.76936661-1.46787011e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14960058379623659 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.005848237608974934 - DEBUG:qutip_qtrl.tslotcomp:230 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.76922636-4.78742954e-17j] - [-0.06631196+4.63037782e-02j] - [-0.06631196-4.63037782e-02j] - [ 0.23077364+5.14492464e-17j]] - Evo final diff: - [[-0.76922636+4.78742954e-17j] - [ 0.06631196-4.63037782e-02j] - [ 0.06631196+4.63037782e-02j] - [ 0.76922636-5.14492464e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.149562628360543 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.005929783212781529 - DEBUG:qutip_qtrl.tslotcomp:229 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.76910323-3.12267121e-16j] - [-0.06623954+4.70288504e-02j] - [-0.06623954-4.70288504e-02j] - [ 0.23089677+3.14750096e-16j]] - Evo final diff: - [[-0.76910323+3.12267121e-16j] - [ 0.06623954-4.70288504e-02j] - [ 0.06623954+4.70288504e-02j] - [ 0.76910323-3.14750096e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14952979306786862 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.006002055609451695 - DEBUG:qutip_qtrl.tslotcomp:229 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.76882804+9.48405649e-17j] - [-0.06607742+4.86147590e-02j] - [-0.06607742-4.86147590e-02j] - [ 0.23117196-1.20738295e-16j]] - Evo final diff: - [[-0.76882804-9.48405649e-17j] - [ 0.06607742-4.86147590e-02j] - [ 0.06607742+4.86147590e-02j] - [ 0.76882804+1.20738295e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1494565422264255 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.006162805692159602 - DEBUG:qutip_qtrl.tslotcomp:228 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.76869242-1.32726646e-16j] - [-0.06600174+4.93936816e-02j] - [-0.06600174-4.93936816e-02j] - [ 0.23130758+1.58832098e-16j]] - Evo final diff: - [[-0.76869242+1.32726646e-16j] - [ 0.06600174-4.93936816e-02j] - [ 0.06600174+4.93936816e-02j] - [ 0.76869242-1.58832098e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14942100013087564 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0062430387096873265 - DEBUG:qutip_qtrl.tslotcomp:228 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.76813485+1.03087271e-16j] - [-0.06568986+5.24849732e-02j] - [-0.06568986-5.24849732e-02j] - [ 0.23186515-1.14254687e-16j]] - Evo final diff: - [[-0.76813485-1.03087271e-16j] - [ 0.06568986-5.24849732e-02j] - [ 0.06568986+5.24849732e-02j] - [ 0.76813485+1.14254687e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14927524457291205 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.006569083324916834 - DEBUG:qutip_qtrl.tslotcomp:227 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.76797714-1.02145374e-16j] - [-0.06561178+5.33489773e-02j] - [-0.06561178-5.33489773e-02j] - [ 0.23202286+9.08441224e-17j]] - Evo final diff: - [[-0.76797714+1.02145374e-16j] - [ 0.06561178-5.33489773e-02j] - [ 0.06561178+5.33489773e-02j] - [ 0.76797714-9.08441224e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14923497606342362 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.006662193714221294 - DEBUG:qutip_qtrl.tslotcomp:227 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.76787816-1.72286453e-16j] - [-0.06556271+5.38845233e-02j] - [-0.06556271-5.38845233e-02j] - [ 0.23212184+1.84650925e-16j]] - Evo final diff: - [[-0.76787816+1.72286453e-16j] - [ 0.06556271-5.38845233e-02j] - [ 0.06556271+5.38845233e-02j] - [ 0.76787816-1.84650925e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14920971986666118 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.006720319708394118 - DEBUG:qutip_qtrl.tslotcomp:226 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.76771181-1.31229083e-16j] - [-0.06548706+5.47778875e-02j] - [-0.06548706-5.47778875e-02j] - [ 0.23228819+1.36316939e-16j]] - Evo final diff: - [[-0.76771181+1.31229083e-16j] - [ 0.06548706-5.47778875e-02j] - [ 0.06548706+5.47778875e-02j] - [ 0.76771181-1.36316939e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1491676467800418 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0068179342978206235 - DEBUG:qutip_qtrl.tslotcomp:226 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.76702056-1.20156666e-16j] - [-0.06517078+5.83495373e-02j] - [-0.06517078-5.83495373e-02j] - [ 0.23297944+1.13525377e-16j]] - Evo final diff: - [[-0.76702056+1.20156666e-16j] - [ 0.06517078-5.83495373e-02j] - [ 0.06517078+5.83495373e-02j] - [ 0.76702056-1.13525377e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14899311089617343 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0072160460650746786 - DEBUG:qutip_qtrl.tslotcomp:226 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.76668499-1.60224692e-16j] - [-0.06501627+6.00095078e-02j] - [-0.06501627-6.00095078e-02j] - [ 0.23331501+1.54517133e-16j]] - Evo final diff: - [[-0.76668499+1.60224692e-16j] - [ 0.06501627-6.00095078e-02j] - [ 0.06501627+6.00095078e-02j] - [ 0.76668499-1.54517133e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14890853335678722 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.007404976831375055 - DEBUG:qutip_qtrl.tslotcomp:225 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.76647752-3.76827907e-17j] - [-0.06493397+6.10382228e-02j] - [-0.06493397-6.10382228e-02j] - [ 0.23352248+2.67197039e-17j]] - Evo final diff: - [[-0.76647752+3.76827907e-17j] - [ 0.06493397-6.10382228e-02j] - [ 0.06493397+6.10382228e-02j] - [ 0.76647752-2.67197039e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14885746656123683 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0075231231693443 - DEBUG:qutip_qtrl.tslotcomp:225 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.76561307-1.50751468e-16j] - [-0.0645886 +6.51496310e-02j] - [-0.0645886 -6.51496310e-02j] - [ 0.23438693+1.32237557e-16j]] - Evo final diff: - [[-0.76561307+1.50751468e-16j] - [ 0.0645886 -6.51496310e-02j] - [ 0.0645886 +6.51496310e-02j] - [ 0.76561307-1.32237557e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14864488392760608 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.008003096449816978 - DEBUG:qutip_qtrl.tslotcomp:225 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.76535417-1.15040567e-16j] - [-0.06448449+6.63311800e-02j] - [-0.06448449-6.63311800e-02j] - [ 0.23464583+1.08198358e-16j]] - Evo final diff: - [[-0.76535417+1.15040567e-16j] - [ 0.06448449-6.63311800e-02j] - [ 0.06448449+6.63311800e-02j] - [ 0.76535417-1.08198358e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14858126913238895 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.008143139088336046 - DEBUG:qutip_qtrl.tslotcomp:224 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.76509764+1.42755457e-16j] - [-0.0643946 +6.74994960e-02j] - [-0.0643946 -6.74994960e-02j] - [ 0.23490236-1.53228477e-16j]] - Evo final diff: - [[-0.76509764-1.42755457e-16j] - [ 0.0643946 -6.74994960e-02j] - [ 0.0643946 +6.74994960e-02j] - [ 0.76509764+1.53228477e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14851931020317485 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.008282389953314187 - DEBUG:qutip_qtrl.tslotcomp:224 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.76472984-1.31703374e-16j] - [-0.06426517+6.91391073e-02j] - [-0.06426517-6.91391073e-02j] - [ 0.23527016+1.36538489e-16j]] - Evo final diff: - [[-0.76472984+1.31703374e-16j] - [ 0.06426517-6.91391073e-02j] - [ 0.06426517+6.91391073e-02j] - [ 0.76472984-1.36538489e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1484304875308462 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.008479143336343914 - DEBUG:qutip_qtrl.tslotcomp:223 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.76445043-1.83047089e-16j] - [-0.06417583+7.03657098e-02j] - [-0.06417583-7.03657098e-02j] - [ 0.23554957+1.81247991e-16j]] - Evo final diff: - [[-0.76445043+1.83047089e-16j] - [ 0.06417583-7.03657098e-02j] - [ 0.06417583+7.03657098e-02j] - [ 0.76445043-1.81247991e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14836358394270233 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.008627229039483111 - DEBUG:qutip_qtrl.tslotcomp:223 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.76408158-2.58493949e-16j] - [-0.0640573 +7.19516561e-02j] - [-0.0640573 -7.19516561e-02j] - [ 0.23591842+2.52982728e-16j]] - Evo final diff: - [[-0.76408158+2.58493949e-16j] - [ 0.0640573 -7.19516561e-02j] - [ 0.0640573 +7.19516561e-02j] - [ 0.76408158-2.52982728e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14827525883941334 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.008819840297384056 - DEBUG:qutip_qtrl.tslotcomp:222 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.76377701-7.49657543e-17j] - [-0.06396241+7.32411087e-02j] - [-0.06396241-7.32411087e-02j] - [ 0.23622299+6.72159694e-17j]] - Evo final diff: - [[-0.76377701+7.49657543e-17j] - [ 0.06396241-7.32411087e-02j] - [ 0.06396241+7.32411087e-02j] - [ 0.76377701-6.72159694e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1482026935754332 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.00897731903198797 - DEBUG:qutip_qtrl.tslotcomp:222 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.76250371-6.08101511e-17j] - [-0.06356174+7.83902979e-02j] - [-0.06356174-7.83902979e-02j] - [ 0.23749629+4.20703986e-17j]] - Evo final diff: - [[-0.76250371+6.08101511e-17j] - [ 0.06356174-7.83902979e-02j] - [ 0.06356174+7.83902979e-02j] - [ 0.76250371-4.20703986e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14789925896299908 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.009613410629698838 - DEBUG:qutip_qtrl.tslotcomp:222 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.76210324-9.78356040e-17j] - [-0.0634346 +7.99371549e-02j] - [-0.0634346 -7.99371549e-02j] - [ 0.23789676+9.42272214e-17j]] - Evo final diff: - [[-0.76210324+9.78356040e-17j] - [ 0.0634346 -7.99371549e-02j] - [ 0.0634346 +7.99371549e-02j] - [ 0.76210324-9.42272214e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14780381082268165 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.009806540598442064 - DEBUG:qutip_qtrl.tslotcomp:225 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.76172197+6.92533513e-17j] - [-0.06332874+8.13972831e-02j] - [-0.06332874-8.13972831e-02j] - [ 0.23827803-6.20161667e-17j]] - Evo final diff: - [[-0.76172197-6.92533513e-17j] - [ 0.06332874-8.13972831e-02j] - [ 0.06332874+8.13972831e-02j] - [ 0.76172197+6.20161667e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14771410153424488 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.009989482248806253 - DEBUG:qutip_qtrl.tslotcomp:225 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.76134696-7.44981707e-17j] - [-0.06322419+8.28062610e-02j] - [-0.06322419-8.28062610e-02j] - [ 0.23865304+6.74565076e-17j]] - Evo final diff: - [[-0.76134696+7.44981707e-17j] - [ 0.06322419-8.28062610e-02j] - [ 0.06322419+8.28062610e-02j] - [ 0.76134696-6.74565076e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14762584364038395 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.01016668750784279 - DEBUG:qutip_qtrl.tslotcomp:225 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.76093571-2.86405250e-16j] - [-0.06311941+8.43251460e-02j] - [-0.06311941-8.43251460e-02j] - [ 0.23906429+2.76667005e-16j]] - Evo final diff: - [[-0.76093571+2.86405250e-16j] - [ 0.06311941-8.43251460e-02j] - [ 0.06311941+8.43251460e-02j] - [ 0.76093571-2.76667005e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1475294865389161 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.010358363315847515 - DEBUG:qutip_qtrl.tslotcomp:225 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.7592134 -2.41302423e-16j] - [-0.06267519+9.03846995e-02j] - [-0.06267519-9.03846995e-02j] - [ 0.2407866 +2.42893332e-16j]] - Evo final diff: - [[-0.7592134 +2.41302423e-16j] - [ 0.06267519-9.03846995e-02j] - [ 0.06267519+9.03846995e-02j] - [ 0.7592134 -2.42893332e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1471256381754032 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.011129549789216958 - DEBUG:qutip_qtrl.tslotcomp:225 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.75860469-1.16619341e-16j] - [-0.06251641+9.24221423e-02j] - [-0.06251641-9.24221423e-02j] - [ 0.24139531+1.09256970e-16j]] - Evo final diff: - [[-0.75860469+1.16619341e-16j] - [ 0.06251641-9.24221423e-02j] - [ 0.06251641+9.24221423e-02j] - [ 0.75860469-1.09256970e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14698280674340142 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.011390945064876966 - DEBUG:qutip_qtrl.tslotcomp:229 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.75808376-1.64798275e-17j] - [-0.06239916+9.41413961e-02j] - [-0.06239916-9.41413961e-02j] - [ 0.24191624+3.19520535e-17j]] - Evo final diff: - [[-0.75808376+1.64798275e-17j] - [ 0.06239916-9.41413961e-02j] - [ 0.06239916+9.41413961e-02j] - [ 0.75808376-3.19520535e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1468618118606218 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.011612051434936736 - DEBUG:qutip_qtrl.tslotcomp:229 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.75589997-3.00391237e-16j] - [-0.06190185+1.00993292e-01j] - [-0.06190185-1.00993292e-01j] - [ 0.24410003+2.96853700e-16j]] - Evo final diff: - [[-0.75589997+3.00391237e-16j] - [ 0.06190185-1.00993292e-01j] - [ 0.06190185+1.00993292e-01j] - [ 0.75589997-2.96853700e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14635406186471064 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.01249906868426023 - DEBUG:qutip_qtrl.tslotcomp:229 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.75522407-3.38663468e-16j] - [-0.06174636+1.03009891e-01j] - [-0.06174636-1.03009891e-01j] - [ 0.24477593+3.38545680e-16j]] - Evo final diff: - [[-0.75522407+3.38663468e-16j] - [ 0.06174636-1.03009891e-01j] - [ 0.06174636+1.03009891e-01j] - [ 0.75522407-3.38545680e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14619676207164434 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.01276171507999066 - DEBUG:qutip_qtrl.tslotcomp:228 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.75456473-1.45174409e-16j] - [-0.06161481+1.04944596e-01j] - [-0.06161481-1.04944596e-01j] - [ 0.24543527+1.34732021e-16j]] - Evo final diff: - [[-0.75456473+1.45174409e-16j] - [ 0.06161481-1.04944596e-01j] - [ 0.06161481+1.04944596e-01j] - [ 0.75456473-1.34732021e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14604442241061646 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.013014106977598075 - DEBUG:qutip_qtrl.tslotcomp:228 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.75400074-2.07637869e-16j] - [-0.06150177+1.06567497e-01j] - [-0.06150177-1.06567497e-01j] - [ 0.24599926+1.97342137e-16j]] - Evo final diff: - [[-0.75400074+2.07637869e-16j] - [ 0.06150177-1.06567497e-01j] - [ 0.06150177+1.06567497e-01j] - [ 0.75400074-1.97342137e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14591405262312274 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.013226243087505554 - DEBUG:qutip_qtrl.tslotcomp:227 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.75329322-3.41590726e-16j] - [-0.06137171+1.08567516e-01j] - [-0.06137171-1.08567516e-01j] - [ 0.24670678+3.39017993e-16j]] - Evo final diff: - [[-0.75329322+3.41590726e-16j] - [ 0.06137171-1.08567516e-01j] - [ 0.06137171+1.08567516e-01j] - [ 0.75329322-3.39017993e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14575101699673845 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.013488035471472409 - DEBUG:qutip_qtrl.tslotcomp:227 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.75032552-4.80734022e-16j] - [-0.06081948+1.16524014e-01j] - [-0.06081948-1.16524014e-01j] - [ 0.24967448+4.80915113e-16j]] - Evo final diff: - [[-0.75032552+4.80734022e-16j] - [ 0.06081948-1.16524014e-01j] - [ 0.06081948+1.16524014e-01j] - [ 0.75032552-4.80915113e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14506631033593037 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.014534290505311243 - DEBUG:qutip_qtrl.tslotcomp:227 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.74812307-2.06065599e-16j] - [-0.06040439+1.22036372e-01j] - [-0.06040439-1.22036372e-01j] - [ 0.25187693+2.02477618e-16j]] - Evo final diff: - [[-0.74812307+2.06065599e-16j] - [ 0.06040439-1.22036372e-01j] - [ 0.06040439+1.22036372e-01j] - [ 0.74812307-2.02477618e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14455742521549136 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.015263009664036133 - DEBUG:qutip_qtrl.tslotcomp:226 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.74717651-1.25265637e-16j] - [-0.06024967+1.24328138e-01j] - [-0.06024967-1.24328138e-01j] - [ 0.25282349+1.26390254e-16j]] - Evo final diff: - [[-0.74717651+1.25265637e-16j] - [ 0.06024967-1.24328138e-01j] - [ 0.06024967+1.24328138e-01j] - [ 0.74717651-1.26390254e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14434006304096134 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.01556638707147303 - DEBUG:qutip_qtrl.tslotcomp:226 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.74622892-2.52875771e-16j] - [-0.06009432+1.26572029e-01j] - [-0.06009432-1.26572029e-01j] - [ 0.25377108+2.69034232e-16j]] - Evo final diff: - [[-0.74622892+2.52875771e-16j] - [ 0.06009432-1.26572029e-01j] - [ 0.06009432+1.26572029e-01j] - [ 0.74622892-2.69034232e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14412235331786286 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.01586381333505983 - DEBUG:qutip_qtrl.tslotcomp:225 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.74520604-1.76819258e-16j] - [-0.05994057+1.28941675e-01j] - [-0.05994057-1.28941675e-01j] - [ 0.25479396+1.73642552e-16j]] - Evo final diff: - [[-0.74520604+1.76819258e-16j] - [ 0.05994057-1.28941675e-01j] - [ 0.05994057+1.28941675e-01j] - [ 0.74520604-1.73642552e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14388771644252965 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.016178186421546756 - DEBUG:qutip_qtrl.tslotcomp:225 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.74091634-2.87190550e-16j] - [-0.05929076+1.38338465e-01j] - [-0.05929076-1.38338465e-01j] - [ 0.25908366+2.73786612e-16j]] - Evo final diff: - [[-0.74091634+2.87190550e-16j] - [ 0.05929076-1.38338465e-01j] - [ 0.05929076+1.38338465e-01j] - [ 0.74091634-2.73786612e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14290248850119172 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.017428168981806554 - DEBUG:qutip_qtrl.tslotcomp:225 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.74062063-3.15718456e-16j] - [-0.05924575+1.38957016e-01j] - [-0.05924575-1.38957016e-01j] - [ 0.25937937+3.14054176e-16j]] - Evo final diff: - [[-0.74062063+3.15718456e-16j] - [ 0.05924575-1.38957016e-01j] - [ 0.05924575+1.38957016e-01j] - [ 0.74062063-3.14054176e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1428345054298097 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.017510614819729996 - DEBUG:qutip_qtrl.tslotcomp:224 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.73937414-4.15681474e-16j] - [-0.05907625+1.41533582e-01j] - [-0.05907625-1.41533582e-01j] - [ 0.26062586+4.06640596e-16j]] - Evo final diff: - [[-0.73937414+4.15681474e-16j] - [ 0.05907625-1.41533582e-01j] - [ 0.05907625+1.41533582e-01j] - [ 0.73937414-4.06640596e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14254896842965076 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.01785388130329608 - DEBUG:qutip_qtrl.tslotcomp:224 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.73414975-1.61735124e-16j] - [-0.05836421+1.51726404e-01j] - [-0.05836421-1.51726404e-01j] - [ 0.26585025+1.54396872e-16j]] - Evo final diff: - [[-0.73414975+1.61735124e-16j] - [ 0.05836421-1.51726404e-01j] - [ 0.05836421+1.51726404e-01j] - [ 0.73414975-1.54396872e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1413507852618395 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.019214241062380285 - DEBUG:qutip_qtrl.tslotcomp:224 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.73369778-5.24209189e-16j] - [-0.0583026 +1.52566418e-01j] - [-0.0583026 -1.52566418e-01j] - [ 0.26630222+5.27488180e-16j]] - Evo final diff: - [[-0.73369778+5.24209189e-16j] - [ 0.0583026 -1.52566418e-01j] - [ 0.0583026 +1.52566418e-01j] - [ 0.73369778-5.27488180e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14124703274087408 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.019326496244075477 - DEBUG:qutip_qtrl.tslotcomp:223 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.73217753-2.38035378e-16j] - [-0.05811666+1.55351065e-01j] - [-0.05811666-1.55351065e-01j] - [ 0.26782247+2.39444850e-16j]] - Evo final diff: - [[-0.73217753+2.38035378e-16j] - [ 0.05811666-1.55351065e-01j] - [ 0.05811666+1.55351065e-01j] - [ 0.73217753-2.39444850e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14089885721301582 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.019698470198813694 - DEBUG:qutip_qtrl.tslotcomp:223 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.73137754-2.14833521e-16j] - [-0.05801886+1.56789710e-01j] - [-0.05801886-1.56789710e-01j] - [ 0.26862246+2.21132447e-16j]] - Evo final diff: - [[-0.73137754+2.14833521e-16j] - [ 0.05801886-1.56789710e-01j] - [ 0.05801886+1.56789710e-01j] - [ 0.73137754-2.21132447e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14071557611653554 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.019890710693953796 - DEBUG:qutip_qtrl.tslotcomp:222 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.72977185-2.52048580e-16j] - [-0.05783769+1.59626387e-01j] - [-0.05783769-1.59626387e-01j] - [ 0.27022815+2.45013017e-16j]] - Evo final diff: - [[-0.72977185+2.52048580e-16j] - [ 0.05783769-1.59626387e-01j] - [ 0.05783769+1.59626387e-01j] - [ 0.72977185-2.45013017e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.14034818529570556 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.02026964795868936 - DEBUG:qutip_qtrl.tslotcomp:222 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.72305153-4.05055452e-16j] - [-0.05708328+1.70802420e-01j] - [-0.05708328-1.70802420e-01j] - [ 0.27694847+3.91369174e-16j]] - Evo final diff: - [[-0.72305153+4.05055452e-16j] - [ 0.05708328-1.70802420e-01j] - [ 0.05708328+1.70802420e-01j] - [ 0.72305153-3.91369174e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1388088711727402 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.02176359227660934 - DEBUG:qutip_qtrl.tslotcomp:222 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.72031644-3.06935652e-16j] - [-0.05677887+1.75063762e-01j] - [-0.05677887-1.75063762e-01j] - [ 0.27968356+2.96222417e-16j]] - Evo final diff: - [[-0.72031644+3.06935652e-16j] - [ 0.05677887-1.75063762e-01j] - [ 0.05677887+1.75063762e-01j] - [ 0.72031644-2.96222417e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.13818173275480042 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.022333461854079847 - DEBUG:qutip_qtrl.tslotcomp:221 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.71829552-2.74111542e-16j] - [-0.05657714+1.78122920e-01j] - [-0.05657714-1.78122920e-01j] - [ 0.28170448+2.66503711e-16j]] - Evo final diff: - [[-0.71829552+2.74111542e-16j] - [ 0.05657714-1.78122920e-01j] - [ 0.05657714+1.78122920e-01j] - [ 0.71829552-2.66503711e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.13771930071189628 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.022742088412171034 - DEBUG:qutip_qtrl.tslotcomp:221 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.71715224-3.37997683e-17j] - [-0.05646361+1.79819288e-01j] - [-0.05646361-1.79819288e-01j] - [ 0.28284776+3.32857249e-17j]] - Evo final diff: - [[-0.71715224+3.37997683e-17j] - [ 0.05646361-1.79819288e-01j] - [ 0.05646361+1.79819288e-01j] - [ 0.71715224-3.32857249e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.13745761136318932 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.022968666713719377 - DEBUG:qutip_qtrl.tslotcomp:220 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.71501756-5.14151823e-16j] - [-0.05626945+1.82922485e-01j] - [-0.05626945-1.82922485e-01j] - [ 0.28498244+5.28637815e-16j]] - Evo final diff: - [[-0.71501756+5.14151823e-16j] - [ 0.05626945-1.82922485e-01j] - [ 0.05626945+1.82922485e-01j] - [ 0.71501756-5.28637815e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.13696924903939514 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.023382984312986955 - DEBUG:qutip_qtrl.tslotcomp:220 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.70724479-3.80578935e-16j] - [-0.05557519+1.93583144e-01j] - [-0.05557519-1.93583144e-01j] - [ 0.29275521+3.65120435e-16j]] - Evo final diff: - [[-0.70724479+3.80578935e-16j] - [ 0.05557519-1.93583144e-01j] - [ 0.05557519+1.93583144e-01j] - [ 0.70724479-3.65120435e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.13518955822137682 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0248055696744206 - DEBUG:qutip_qtrl.tslotcomp:219 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.70476289-3.36966967e-16j] - [-0.05537687+1.96798521e-01j] - [-0.05537687-1.96798521e-01j] - [ 0.29523711+3.41867197e-16j]] - Evo final diff: - [[-0.70476289+3.36966967e-16j] - [ 0.05537687-1.96798521e-01j] - [ 0.05537687+1.96798521e-01j] - [ 0.70476289-3.41867197e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1346217477240938 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.025233893696598158 - DEBUG:qutip_qtrl.tslotcomp:219 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.69636021-6.66154244e-16j] - [-0.05472491+2.07074352e-01j] - [-0.05472491-2.07074352e-01j] - [ 0.30363979+6.55156393e-16j]] - Evo final diff: - [[-0.69636021+6.66154244e-16j] - [ 0.05472491-2.07074352e-01j] - [ 0.05472491+2.07074352e-01j] - [ 0.69636021-6.55156393e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.13269803577305936 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.026601139778172748 - DEBUG:qutip_qtrl.tslotcomp:218 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.69351084-7.00495450e-16j] - [-0.05452841+2.10362922e-01j] - [-0.05452841-2.10362922e-01j] - [ 0.30648916+7.15640631e-16j]] - Evo final diff: - [[-0.69351084+7.00495450e-16j] - [ 0.05452841-2.10362922e-01j] - [ 0.05452841+2.10362922e-01j] - [ 0.69351084-7.15640631e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.13204579882983583 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.027037884996739613 - DEBUG:qutip_qtrl.tslotcomp:218 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.69221895-4.13943992e-16j] - [-0.05444051+2.11823520e-01j] - [-0.05444051-2.11823520e-01j] - [ 0.30778105+4.07945453e-16j]] - Evo final diff: - [[-0.69221895+4.13943992e-16j] - [ 0.05444051-2.11823520e-01j] - [ 0.05444051+2.11823520e-01j] - [ 0.69221895-4.07945453e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.13175001116099017 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.02723174764585996 - DEBUG:qutip_qtrl.tslotcomp:217 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.68924456-7.61399565e-16j] - [-0.05425896+2.15118460e-01j] - [-0.05425896-2.15118460e-01j] - [ 0.31075544+7.57525576e-16j]] - Evo final diff: - [[-0.68924456+7.61399565e-16j] - [ 0.05425896-2.15118460e-01j] - [ 0.05425896+2.15118460e-01j] - [ 0.68924456-7.57525576e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.13106951377635798 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.027668468893053456 - DEBUG:qutip_qtrl.tslotcomp:217 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.67688921-1.05735288e-16j] - [-0.05355021+2.27852030e-01j] - [-0.05355021-2.27852030e-01j] - [ 0.32311079+1.17867251e-16j]] - Evo final diff: - [[-0.67688921+1.05735288e-16j] - [ 0.05355021-2.27852030e-01j] - [ 0.05355021+2.27852030e-01j] - [ 0.67688921-1.17867251e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1282407928102971 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.029351821888100513 - DEBUG:qutip_qtrl.tslotcomp:217 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.67533842-3.44934309e-16j] - [-0.05346656+2.29350225e-01j] - [-0.05346656-2.29350225e-01j] - [ 0.32466158+3.45994917e-16j]] - Evo final diff: - [[-0.67533842+3.44934309e-16j] - [ 0.05346656-2.29350225e-01j] - [ 0.05346656+2.29350225e-01j] - [ 0.67533842-3.45994917e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.12788554340376415 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.02954935346053595 - DEBUG:qutip_qtrl.tslotcomp:216 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.67185283-3.76863339e-16j] - [-0.05329816+2.32645474e-01j] - [-0.05329816-2.32645474e-01j] - [ 0.32814717+3.85742587e-16j]] - Evo final diff: - [[-0.67185283+3.76863339e-16j] - [ 0.05329816-2.32645474e-01j] - [ 0.05329816+2.32645474e-01j] - [ 0.67185283-3.85742587e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1270877097505528 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.02998299223687019 - DEBUG:qutip_qtrl.tslotcomp:216 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.67137162-3.02515149e-16j] - [-0.05327543+2.33092394e-01j] - [-0.05327543-2.33092394e-01j] - [ 0.32862838+3.12119039e-16j]] - Evo final diff: - [[-0.67137162+3.02515149e-16j] - [ 0.05327543-2.33092394e-01j] - [ 0.05327543+2.33092394e-01j] - [ 0.67137162-3.12119039e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.12697754694141616 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.030041753953705286 - DEBUG:qutip_qtrl.tslotcomp:215 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.66777659-3.33278998e-16j] - [-0.05312731+2.36369924e-01j] - [-0.05312731-2.36369924e-01j] - [ 0.33222341+3.28784122e-16j]] - Evo final diff: - [[-0.66777659+3.33278998e-16j] - [ 0.05312731-2.36369924e-01j] - [ 0.05312731+2.36369924e-01j] - [ 0.66777659-3.28784122e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.12615470502121254 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.030472213981305986 - DEBUG:qutip_qtrl.tslotcomp:215 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.6566633 -6.49942158e-16j] - [-0.05271215+2.45874191e-01j] - [-0.05271215-2.45874191e-01j] - [ 0.3433367 +6.15169790e-16j]] - Evo final diff: - [[-0.6566633 +6.49942158e-16j] - [ 0.05271215-2.45874191e-01j] - [ 0.05271215+2.45874191e-01j] - [ 0.6566633 -6.15169790e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.12360984315044998 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03171612599370095 - DEBUG:qutip_qtrl.tslotcomp:214 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.65267779-6.11073304e-16j] - [-0.05259357+2.49068998e-01j] - [-0.05259357-2.49068998e-01j] - [ 0.34732221+6.02183311e-16j]] - Evo final diff: - [[-0.65267779+6.11073304e-16j] - [ 0.05259357-2.49068998e-01j] - [ 0.05259357+2.49068998e-01j] - [ 0.65267779-6.02183311e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.12269743680533629 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0321323084875968 - DEBUG:qutip_qtrl.tslotcomp:214 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.64250517-6.31996656e-16j] - [-0.05233125+2.56747951e-01j] - [-0.05233125-2.56747951e-01j] - [ 0.35749483+6.45417945e-16j]] - Evo final diff: - [[-0.64250517+6.31996656e-16j] - [ 0.05233125-2.56747951e-01j] - [ 0.05233125+2.56747951e-01j] - [ 0.64250517-6.45417945e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.1203677399457908 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.033128544257186636 - DEBUG:qutip_qtrl.tslotcomp:213 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.63817142-3.74367938e-16j] - [-0.05224773+2.59822030e-01j] - [-0.05224773-2.59822030e-01j] - [ 0.36182858+3.68719064e-16j]] - Evo final diff: - [[-0.63817142+3.74367938e-16j] - [ 0.05224773-2.59822030e-01j] - [ 0.05224773+2.59822030e-01j] - [ 0.63817142-3.68719064e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.11937501701153475 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03352562557188911 - DEBUG:qutip_qtrl.tslotcomp:213 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.63638735-7.47434162e-16j] - [-0.0522164 +2.61055047e-01j] - [-0.0522164 -2.61055047e-01j] - [ 0.36361265+7.61622335e-16j]] - Evo final diff: - [[-0.63638735+7.47434162e-16j] - [ 0.0522164 -2.61055047e-01j] - [ 0.0522164 +2.61055047e-01j] - [ 0.63638735-7.61622335e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.11896628721909538 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03368456960336331 - DEBUG:qutip_qtrl.tslotcomp:212 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.63192967-3.41137291e-16j] - [-0.05216594+2.64056561e-01j] - [-0.05216594-2.64056561e-01j] - [ 0.36807033+3.44847895e-16j]] - Evo final diff: - [[-0.63192967+3.41137291e-16j] - [ 0.05216594-2.64056561e-01j] - [ 0.05216594+2.64056561e-01j] - [ 0.63192967-3.44847895e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.11794556487170456 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.034070275835932376 - DEBUG:qutip_qtrl.tslotcomp:212 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.61471667-7.23037961e-16j] - [-0.05207953+2.74628085e-01j] - [-0.05207953-2.74628085e-01j] - [ 0.38528333+7.15646926e-16j]] - Evo final diff: - [[-0.61471667+7.23037961e-16j] - [ 0.05207953-2.74628085e-01j] - [ 0.05207953+2.74628085e-01j] - [ 0.61471667-7.15646926e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.11400236221754698 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03541748065730033 - DEBUG:qutip_qtrl.tslotcomp:211 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.60982546-7.32252542e-16j] - [-0.05209479+2.77356154e-01j] - [-0.05209479-2.77356154e-01j] - [ 0.39017454+7.37513289e-16j]] - Evo final diff: - [[-0.60982546+7.32252542e-16j] - [ 0.05209479-2.77356154e-01j] - [ 0.05209479+2.77356154e-01j] - [ 0.60982546-7.37513289e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.11288184881395368 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03576168589295334 - DEBUG:qutip_qtrl.tslotcomp:210 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.6048515 -5.91742838e-16j] - [-0.05213982+2.80009487e-01j] - [-0.05213982-2.80009487e-01j] - [ 0.3951485 +5.95413362e-16j]] - Evo final diff: - [[-0.6048515 +5.91742838e-16j] - [ 0.05213982-2.80009487e-01j] - [ 0.05213982+2.80009487e-01j] - [ 0.6048515 -5.95413362e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.11174230260470346 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03609484772033449 - DEBUG:qutip_qtrl.tslotcomp:210 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.59190718-5.22138295e-16j] - [-0.05232739+2.86375879e-01j] - [-0.05232739-2.86375879e-01j] - [ 0.40809282+4.98319718e-16j]] - Evo final diff: - [[-0.59190718+5.22138295e-16j] - [ 0.05232739-2.86375879e-01j] - [ 0.05232739+2.86375879e-01j] - [ 0.59190718-4.98319718e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.10877585250548147 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03688639218966988 - DEBUG:qutip_qtrl.tslotcomp:209 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.58665514-6.93706741e-16j] - [-0.05244071+2.88747292e-01j] - [-0.05244071-2.88747292e-01j] - [ 0.41334486+7.16098749e-16j]] - Evo final diff: - [[-0.58665514+6.93706741e-16j] - [ 0.05244071-2.88747292e-01j] - [ 0.05244071+2.88747292e-01j] - [ 0.58665514-7.16098749e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.10757231878717691 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03717784815173896 - DEBUG:qutip_qtrl.tslotcomp:209 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.57551747-2.43829410e-16j] - [-0.05273933+2.93387292e-01j] - [-0.05273933-2.93387292e-01j] - [ 0.42448253+2.54354300e-16j]] - Evo final diff: - [[-0.57551747+2.43829410e-16j] - [ 0.05273933-2.93387292e-01j] - [ 0.05273933+2.93387292e-01j] - [ 0.57551747-2.54354300e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.10501947583332127 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.037741307722651544 - DEBUG:qutip_qtrl.tslotcomp:208 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.57004556-5.38289960e-16j] - [-0.05291526+2.95477594e-01j] - [-0.05291526-2.95477594e-01j] - [ 0.42995444+5.29817841e-16j]] - Evo final diff: - [[-0.57004556+5.38289960e-16j] - [ 0.05291526-2.95477594e-01j] - [ 0.05291526+2.95477594e-01j] - [ 0.57004556-5.29817841e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.10376474223168573 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03799210756936777 - DEBUG:qutip_qtrl.tslotcomp:208 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.56819923-7.01294011e-16j] - [-0.05297896+2.96155687e-01j] - [-0.05297896-2.96155687e-01j] - [ 0.43180077+7.07312924e-16j]] - Evo final diff: - [[-0.56819923+7.01294011e-16j] - [ 0.05297896-2.96155687e-01j] - [ 0.05297896+2.96155687e-01j] - [ 0.56819923-7.07312924e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.10334133261595366 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03807290894205984 - DEBUG:qutip_qtrl.tslotcomp:207 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.56266696-8.23316283e-16j] - [-0.0532038 +2.98107309e-01j] - [-0.0532038 -2.98107309e-01j] - [ 0.43733304+8.25991929e-16j]] - Evo final diff: - [[-0.56266696+8.23316283e-16j] - [ 0.0532038 -2.98107309e-01j] - [ 0.0532038 +2.98107309e-01j] - [ 0.56266696-8.25991929e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.10207317997115345 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.038303405315408705 - DEBUG:qutip_qtrl.tslotcomp:207 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.54380031-5.48640185e-16j] - [-0.05412485+3.03875599e-01j] - [-0.05412485-3.03875599e-01j] - [ 0.45619969+5.63006095e-16j]] - Evo final diff: - [[-0.54380031+5.48640185e-16j] - [ 0.05412485-3.03875599e-01j] - [ 0.05412485+3.03875599e-01j] - [ 0.54380031-5.63006095e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.09774716357938441 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03896463799501109 - DEBUG:qutip_qtrl.tslotcomp:206 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.53806598-7.59563749e-16j] - [-0.05445063+3.05366055e-01j] - [-0.05445063-3.05366055e-01j] - [ 0.46193402+7.61282559e-16j]] - Evo final diff: - [[-0.53806598+7.59563749e-16j] - [ 0.05445063-3.05366055e-01j] - [ 0.05445063+3.05366055e-01j] - [ 0.53806598-7.61282559e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.09643207429105892 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03912916463139644 - DEBUG:qutip_qtrl.tslotcomp:205 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.5323011 -2.72829793e-16j] - [-0.05480985+3.06741722e-01j] - [-0.05480985-3.06741722e-01j] - [ 0.4676989 +2.51845903e-16j]] - Evo final diff: - [[-0.5323011 +2.72829793e-16j] - [ 0.05480985-3.06741722e-01j] - [ 0.05480985+3.06741722e-01j] - [ 0.5323011 -2.51845903e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.09510976729548923 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03927756575439362 - DEBUG:qutip_qtrl.tslotcomp:205 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.5190676 -7.01774783e-16j] - [-0.05572398+3.09449290e-01j] - [-0.05572398-3.09449290e-01j] - [ 0.4809324 +7.10992040e-16j]] - Evo final diff: - [[-0.5190676 +7.01774783e-16j] - [ 0.05572398-3.09449290e-01j] - [ 0.05572398+3.09449290e-01j] - [ 0.5190676 -7.10992040e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.09207379958468942 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.039554883929803615 - DEBUG:qutip_qtrl.tslotcomp:204 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.51323489-6.20733383e-16j] - [-0.05616719+3.10447731e-01j] - [-0.05616719-3.10447731e-01j] - [ 0.48676511+6.23231245e-16j]] - Evo final diff: - [[-0.51323489+6.20733383e-16j] - [ 0.05616719-3.10447731e-01j] - [ 0.05616719+3.10447731e-01j] - [ 0.51323489-6.23231245e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.09073564913180734 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.039650126687170585 - DEBUG:qutip_qtrl.tslotcomp:204 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.50159327-6.42306204e-16j] - [-0.05712893+3.12086894e-01j] - [-0.05712893-3.12086894e-01j] - [ 0.49840673+6.49211321e-16j]] - Evo final diff: - [[-0.50159327+6.42306204e-16j] - [ 0.05712893-3.12086894e-01j] - [ 0.05712893+3.12086894e-01j] - [ 0.50159327-6.49211321e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0880644368823737 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03979051992069293 - DEBUG:qutip_qtrl.tslotcomp:203 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.49572858-3.39014563e-16j] - [-0.05763815+3.12734644e-01j] - [-0.05763815-3.12734644e-01j] - [ 0.50427142+3.31741027e-16j]] - Evo final diff: - [[-0.49572858+3.39014563e-16j] - [ 0.05763815-3.12734644e-01j] - [ 0.05763815+3.12734644e-01j] - [ 0.49572858-3.31741027e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.08671798497037973 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03983741481561637 - DEBUG:qutip_qtrl.tslotcomp:203 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.49419982-7.39012248e-16j] - [-0.05777526+3.12884150e-01j] - [-0.05777526-3.12884150e-01j] - [ 0.50580018+7.32231909e-16j]] - Evo final diff: - [[-0.49419982+7.39012248e-16j] - [ 0.05777526-3.12884150e-01j] - [ 0.05777526+3.12884150e-01j] - [ 0.49419982-7.32231909e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0863669839333387 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03984692665362219 - DEBUG:qutip_qtrl.tslotcomp:202 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.4883668 -4.56155982e-16j] - [-0.05833534+3.13381498e-01j] - [-0.05833534-3.13381498e-01j] - [ 0.5116332 +4.61293259e-16j]] - Evo final diff: - [[-0.4883668 +4.56155982e-16j] - [ 0.05833534-3.13381498e-01j] - [ 0.05833534+3.13381498e-01j] - [ 0.4883668 -4.61293259e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0850282766126049 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.039872746372552934 - DEBUG:qutip_qtrl.tslotcomp:202 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.46935112-4.54854539e-16j] - [-0.06035473+3.14198420e-01j] - [-0.06035473-3.14198420e-01j] - [ 0.53064888+4.24758436e-16j]] - Evo final diff: - [[-0.46935112+4.54854539e-16j] - [ 0.06035473-3.14198420e-01j] - [ 0.06035473+3.14198420e-01j] - [ 0.46935112-4.24758436e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0806634542809313 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.03984426682584268 - DEBUG:qutip_qtrl.tslotcomp:201 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.31559106+2.18470835e-16j] - [-0.29201069-1.19719160e-01j] - [-0.29201069+1.19719160e-01j] - [ 0.68440894-2.12766239e-16j]] - Evo final diff: - [[-0.31559106-2.18470835e-16j] - [ 0.29201069+1.19719160e-01j] - [ 0.29201069-1.19719160e-01j] - [ 0.31559106+2.12766239e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.049800159556787876 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.033387858399689184 - DEBUG:qutip_qtrl.tslotcomp:171 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.20131376+1.90780925e-16j] - [-0.13083837+1.38723248e-01j] - [-0.13083837-1.38723248e-01j] - [ 0.79868624-1.98580734e-16j]] - Evo final diff: - [[-0.20131376-1.90780925e-16j] - [ 0.13083837-1.38723248e-01j] - [ 0.13083837+1.38723248e-01j] - [ 0.20131376+1.98580734e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.019222512288685996 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.017491353438115798 - DEBUG:qutip_qtrl.tslotcomp:152 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.1816594 +6.02748488e-17j] - [-0.15067819+6.84261618e-02j] - [-0.15067819-6.84261618e-02j] - [ 0.8183406 -4.15704533e-17j]] - Evo final diff: - [[-0.1816594 -6.02748488e-17j] - [ 0.15067819-6.84261618e-02j] - [ 0.15067819+6.84261618e-02j] - [ 0.1816594 +4.15704533e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.015096548611431919 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.013670082182459433 - DEBUG:qutip_qtrl.tslotcomp:156 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.16849715+2.50135878e-16j] - [-0.13264625+3.34976180e-02j] - [-0.13264625-3.34976180e-02j] - [ 0.83150285-2.56424104e-16j]] - Evo final diff: - [[-0.16849715-2.50135878e-16j] - [ 0.13264625-3.34976180e-02j] - [ 0.13264625+3.34976180e-02j] - [ 0.16849715+2.56424104e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.011777101837078275 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.011480990049517794 - DEBUG:qutip_qtrl.tslotcomp:153 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.15493998+3.51125072e-17j] - [-0.07813057+9.91910478e-03j] - [-0.07813057-9.91910478e-03j] - [ 0.84506002-4.09579686e-17j]] - Evo final diff: - [[-0.15493998-3.51125072e-17j] - [ 0.07813057-9.91910478e-03j] - [ 0.07813057+9.91910478e-03j] - [ 0.15493998+4.09579686e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.007552292958213012 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0062833948937121315 - DEBUG:qutip_qtrl.tslotcomp:137 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.15316377-1.43451255e-16j] - [-0.04009852+1.57617808e-02j] - [-0.04009852-1.57617808e-02j] - [ 0.84683623+1.56843612e-16j]] - Evo final diff: - [[-0.15316377+1.43451255e-16j] - [ 0.04009852-1.57617808e-02j] - [ 0.04009852+1.57617808e-02j] - [ 0.15316377-1.56843612e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.006328866328369624 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.003038745925995049 - DEBUG:qutip_qtrl.tslotcomp:119 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.15306883-4.86970890e-18j] - [-0.030905 +1.50597807e-02j] - [-0.030905 -1.50597807e-02j] - [ 0.84693117+5.39952689e-18j]] - Evo final diff: - [[-0.15306883+4.86970890e-18j] - [ 0.030905 -1.50597807e-02j] - [ 0.030905 +1.50597807e-02j] - [ 0.15306883-5.39952689e-18j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.006152995343819839 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.002508356866757705 - DEBUG:qutip_qtrl.tslotcomp:113 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.15257059-2.86266035e-16j] - [-0.01992457+8.56547658e-03j] - [-0.01992457-8.56547658e-03j] - [ 0.84742941+2.86191075e-16j]] - Evo final diff: - [[-0.15257059+2.86266035e-16j] - [ 0.01992457-8.56547658e-03j] - [ 0.01992457+8.56547658e-03j] - [ 0.15257059-2.86191075e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.005937035062464446 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0015587091954753587 - DEBUG:qutip_qtrl.tslotcomp:115 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.15179587-3.25979993e-17j] - [-0.01463539+3.39500158e-04j] - [-0.01463539-3.39500158e-04j] - [ 0.84820413+3.23200765e-17j]] - Evo final diff: - [[-0.15179587+3.25979993e-17j] - [ 0.01463539-3.39500158e-04j] - [ 0.01463539+3.39500158e-04j] - [ 0.15179587-3.23200765e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.00581407385674651 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0007632515218465383 - DEBUG:qutip_qtrl.tslotcomp:133 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.15103612-1.64565330e-16j] - [-0.01316383-4.05847194e-03j] - [-0.01316383+4.05847194e-03j] - [ 0.84896388+1.74983659e-16j]] - Evo final diff: - [[-0.15103612+1.64565330e-16j] - [ 0.01316383+4.05847194e-03j] - [ 0.01316383-4.05847194e-03j] - [ 0.15103612-1.74983659e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.005750416728963727 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0007035771752061577 - DEBUG:qutip_qtrl.tslotcomp:146 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.14983243-2.07060409e-16j] - [-0.01266315-6.78354613e-03j] - [-0.01266315+6.78354613e-03j] - [ 0.85016757+2.01010929e-16j]] - Evo final diff: - [[-0.14983243+2.07060409e-16j] - [ 0.01266315+6.78354613e-03j] - [ 0.01266315-6.78354613e-03j] - [ 0.14983243-2.01010929e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0056640325098776785 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.000875533443023031 - DEBUG:qutip_qtrl.tslotcomp:147 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.14736865-1.98101729e-17j] - [-0.01395029-7.58517534e-03j] - [-0.01395029+7.58517534e-03j] - [ 0.85263135+2.46437306e-17j]] - Evo final diff: - [[-0.14736865+1.98101729e-17j] - [ 0.01395029+7.58517534e-03j] - [ 0.01395029-7.58517534e-03j] - [ 0.14736865-2.46437306e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.005492416455265949 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0009792637379427893 - DEBUG:qutip_qtrl.tslotcomp:151 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.13543044-9.90346214e-17j] - [-0.031025 +2.26361283e-02j] - [-0.031025 -2.26361283e-02j] - [ 0.86456956+1.25741960e-16j]] - Evo final diff: - [[-0.13543044+9.90346214e-17j] - [ 0.031025 -2.26361283e-02j] - [ 0.031025 +2.26361283e-02j] - [ 0.13543044-1.25741960e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.004954087169670477 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.002816855705100954 - DEBUG:qutip_qtrl.tslotcomp:135 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.13554058-1.42501810e-16j] - [-0.0281265 +1.65553447e-02j] - [-0.0281265 -1.65553447e-02j] - [ 0.86445942+1.43220318e-16j]] - Evo final diff: - [[-0.13554058+1.42501810e-16j] - [ 0.0281265 -1.65553447e-02j] - [ 0.0281265 +1.65553447e-02j] - [ 0.13554058-1.43220318e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.004859107182026605 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0021941396970016616 - DEBUG:qutip_qtrl.tslotcomp:131 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.13575185-3.37779973e-16j] - [-0.02081153+3.77437686e-03j] - [-0.02081153-3.77437686e-03j] - [ 0.86424815+3.10875498e-16j]] - Evo final diff: - [[-0.13575185+3.37779973e-16j] - [ 0.02081153-3.77437686e-03j] - [ 0.02081153+3.77437686e-03j] - [ 0.13575185-3.10875498e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0047189827899690034 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0010073578183123135 - DEBUG:qutip_qtrl.tslotcomp:130 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.13530186-7.27119118e-17j] - [-0.01764337+5.43691276e-04j] - [-0.01764337-5.43691276e-04j] - [ 0.86469814+6.12490329e-17j]] - Evo final diff: - [[-0.13530186+7.27119118e-17j] - [ 0.01764337-5.43691276e-04j] - [ 0.01764337+5.43691276e-04j] - [ 0.13530186-6.12490329e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.004654544041536687 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0007592681905472547 - DEBUG:qutip_qtrl.tslotcomp:126 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.13403186+6.86479517e-17j] - [-0.01393748+1.08562636e-04j] - [-0.01393748-1.08562636e-04j] - [ 0.86596814-7.29814388e-17j]] - Evo final diff: - [[-0.13403186-6.86479517e-17j] - [ 0.01393748-1.08562636e-04j] - [ 0.01393748+1.08562636e-04j] - [ 0.13403186+7.29814388e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0045397014376240725 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0005692317333776652 - DEBUG:qutip_qtrl.tslotcomp:125 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 1.27670784e-01-2.16234204e-16j] - [-7.46907037e-04+2.71856059e-02j] - [-7.46907037e-04-2.71856059e-02j] - [ 8.72329216e-01+2.12601372e-16j]] - Evo final diff: - [[-0.12767078+2.16234204e-16j] - [ 0.00074691-2.71856059e-02j] - [ 0.00074691+2.71856059e-02j] - [ 0.12767078-2.12601372e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.004259861039623093 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0036164830842216594 - DEBUG:qutip_qtrl.tslotcomp:143 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.12674848-2.02792245e-16j] - [-0.00620768+1.95245106e-02j] - [-0.00620768-1.95245106e-02j] - [ 0.87325152+2.07998536e-16j]] - Evo final diff: - [[-0.12674848+2.02792245e-16j] - [ 0.00620768-1.95245106e-02j] - [ 0.00620768+1.95245106e-02j] - [ 0.12674848-2.07998536e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.004121229805969434 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.002423605818773954 - DEBUG:qutip_qtrl.tslotcomp:142 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.12513358-2.73738416e-16j] - [-0.0156496 +7.86097283e-03j] - [-0.0156496 -7.86097283e-03j] - [ 0.87486642+2.70488348e-16j]] - Evo final diff: - [[-0.12513358+2.73738416e-16j] - [ 0.0156496 -7.86097283e-03j] - [ 0.0156496 +7.86097283e-03j] - [ 0.12513358-2.70488348e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0039912794285803434 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.000918881455787781 - DEBUG:qutip_qtrl.tslotcomp:136 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.12454703-1.08713181e-16j] - [-0.01718828+5.79852866e-03j] - [-0.01718828-5.79852866e-03j] - [ 0.87545297+1.21106065e-16j]] - Evo final diff: - [[-0.12454703+1.08713181e-16j] - [ 0.01718828-5.79852866e-03j] - [ 0.01718828+5.79852866e-03j] - [ 0.12454703-1.21106065e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0039602556103499175 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0008779527858675085 - DEBUG:qutip_qtrl.tslotcomp:132 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.1236505 -1.23465683e-16j] - [-0.01811325+3.97205392e-03j] - [-0.01811325-3.97205392e-03j] - [ 0.8763495 +1.24040755e-16j]] - Evo final diff: - [[-0.1236505 +1.23465683e-16j] - [ 0.01811325-3.97205392e-03j] - [ 0.01811325+3.97205392e-03j] - [ 0.1236505 -1.24040755e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.003908328371381658 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0009257862736929979 - DEBUG:qutip_qtrl.tslotcomp:128 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.11777994-2.76891385e-16j] - [-0.01467044+1.94547748e-02j] - [-0.01467044-1.94547748e-02j] - [ 0.88222006+2.87209455e-16j]] - Evo final diff: - [[-0.11777994+2.76891385e-16j] - [ 0.01467044-1.94547748e-02j] - [ 0.01467044+1.94547748e-02j] - [ 0.11777994-2.87209455e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0036164558427296887 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0017534099117774652 - DEBUG:qutip_qtrl.tslotcomp:110 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.11755998+5.74296773e-18j] - [-0.01423278+1.59465433e-02j] - [-0.01423278-1.59465433e-02j] - [ 0.88244002+9.24094171e-19j]] - Evo final diff: - [[-0.11755998-5.74296773e-18j] - [ 0.01423278-1.59465433e-02j] - [ 0.01423278+1.59465433e-02j] - [ 0.11755998-9.24094171e-19j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0035693033154546795 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0014386769254665266 - DEBUG:qutip_qtrl.tslotcomp:105 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.1166713 -1.45522484e-17j] - [-0.01310825+9.04460212e-04j] - [-0.01310825-9.04460212e-04j] - [ 0.8833287 +4.77845036e-17j]] - Evo final diff: - [[-0.1166713 +1.45522484e-17j] - [ 0.01310825-9.04460212e-04j] - [ 0.01310825+9.04460212e-04j] - [ 0.1166713 -4.77845036e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0034462091781149434 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0007094621487583083 - DEBUG:qutip_qtrl.tslotcomp:114 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.1157596 -1.06205488e-17j] - [-0.00838469+6.11512969e-03j] - [-0.00838469-6.11512969e-03j] - [ 0.8842404 +1.63217820e-17j]] - Evo final diff: - [[-0.1157596 +1.06205488e-17j] - [ 0.00838469-6.11512969e-03j] - [ 0.00838469+6.11512969e-03j] - [ 0.1157596 -1.63217820e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0033769958899527034 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0006002112724568193 - DEBUG:qutip_qtrl.tslotcomp:124 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.11540556-1.05495365e-16j] - [-0.00723593+6.14208109e-03j] - [-0.00723593-6.14208109e-03j] - [ 0.88459444+1.28837745e-16j]] - Evo final diff: - [[-0.11540556+1.05495365e-16j] - [ 0.00723593-6.14208109e-03j] - [ 0.00723593+6.14208109e-03j] - [ 0.11540556-1.28837745e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.003352131968892376 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0006206540278559121 - DEBUG:qutip_qtrl.tslotcomp:127 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[0.11730567-6.28545002e-17j] - [0.04132207+5.54769529e-02j] - [0.04132207-5.54769529e-02j] - [0.88269433+5.88631082e-17j]] - Evo final diff: - [[-0.11730567+6.28545002e-17j] - [-0.04132207-5.54769529e-02j] - [-0.04132207+5.54769529e-02j] - [ 0.11730567-5.88631082e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.004636456654879235 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.008466177084199153 - DEBUG:qutip_qtrl.tslotcomp:127 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.11479238-2.16773149e-16j] - [-0.00190573+1.16936871e-02j] - [-0.00190573-1.16936871e-02j] - [ 0.88520762+1.96527670e-16j]] - Evo final diff: - [[-0.11479238+2.16773149e-16j] - [ 0.00190573-1.16936871e-02j] - [ 0.00190573+1.16936871e-02j] - [ 0.11479238-1.96527670e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0033294161351953753 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.00140652457734953 - DEBUG:qutip_qtrl.tslotcomp:161 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[0.11345567-2.64803713e-16j] - [0.02230965+3.05856202e-02j] - [0.02230965-3.05856202e-02j] - [0.88654433+2.51732420e-16j]] - Evo final diff: - [[-0.11345567+2.64803713e-16j] - [-0.02230965-3.05856202e-02j] - [-0.02230965+3.05856202e-02j] - [ 0.11345567-2.51732420e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.003576347575750469 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.004832367011452715 - DEBUG:qutip_qtrl.tslotcomp:161 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[0.11434582-1.97546972e-16j] - [0.0014966 +1.44532218e-02j] - [0.0014966 -1.44532218e-02j] - [0.88565418+1.82179483e-16j]] - Evo final diff: - [[-0.11434582+1.97546972e-16j] - [-0.0014966 -1.44532218e-02j] - [-0.0014966 +1.44532218e-02j] - [ 0.11434582-1.82179483e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0033215252734320284 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0018847109570573012 - DEBUG:qutip_qtrl.tslotcomp:165 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[0.11311129-1.78769439e-16j] - [0.0192881 +2.70178745e-02j] - [0.0192881 -2.70178745e-02j] - [0.88688871+1.80945132e-16j]] - Evo final diff: - [[-0.11311129+1.78769439e-16j] - [-0.0192881 -2.70178745e-02j] - [-0.0192881 +2.70178745e-02j] - [ 0.11311129-1.80945132e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.003474040083892313 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.004284021748206093 - DEBUG:qutip_qtrl.tslotcomp:165 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[0.11415438-2.96243998e-16j] - [0.00294656+1.55132375e-02j] - [0.00294656-1.55132375e-02j] - [0.88584562+3.04878725e-16j]] - Evo final diff: - [[-0.11415438+2.96243998e-16j] - [-0.00294656-1.55132375e-02j] - [-0.00294656+1.55132375e-02j] - [ 0.11415438-3.04878725e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0033201410759716036 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0020800187801302576 - DEBUG:qutip_qtrl.tslotcomp:165 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[1.13780965e-01-9.45985399e-17j] - [3.83794035e-04+1.30577224e-02j] - [3.83794035e-04-1.30577224e-02j] - [8.86219035e-01+1.12315878e-16j]] - Evo final diff: - [[-0.11378096+9.45985399e-17j] - [-0.00038379-1.30577224e-02j] - [-0.00038379+1.30577224e-02j] - [ 0.11378096-1.12315878e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.003279189843179375 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0016500071806924944 - DEBUG:qutip_qtrl.tslotcomp:159 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[0.11140081-3.26953161e-16j] - [0.00983386+2.28050448e-02j] - [0.00983386-2.28050448e-02j] - [0.88859919+3.21754966e-16j]] - Evo final diff: - [[-0.11140081+3.26953161e-16j] - [-0.00983386-2.28050448e-02j] - [-0.00983386+2.28050448e-02j] - [ 0.11140081-3.21754966e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0032567287401730326 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0030620299087130392 - DEBUG:qutip_qtrl.tslotcomp:143 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.11027288-2.60080742e-16j] - [-0.00211515+1.01988537e-02j] - [-0.00211515-1.01988537e-02j] - [ 0.88972712+2.51328848e-16j]] - Evo final diff: - [[-0.11027288+2.60080742e-16j] - [ 0.00211515-1.01988537e-02j] - [ 0.00211515+1.01988537e-02j] - [ 0.11027288-2.51328848e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.003067149372482811 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0010635270647882651 - DEBUG:qutip_qtrl.tslotcomp:142 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.10986347-1.52044276e-16j] - [-0.00676178+3.81635360e-03j] - [-0.00676178-3.81635360e-03j] - [ 0.89013653+1.84026165e-16j]] - Evo final diff: - [[-0.10986347+1.52044276e-16j] - [ 0.00676178-3.81635360e-03j] - [ 0.00676178+3.81635360e-03j] - [ 0.10986347-1.84026165e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.00303256689509992 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.00043067781094844736 - DEBUG:qutip_qtrl.tslotcomp:156 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.10966187-1.51373545e-16j] - [-0.00722021+2.20990232e-03j] - [-0.00722021-2.20990232e-03j] - [ 0.89033813+1.81611675e-16j]] - Evo final diff: - [[-0.10966187+1.51373545e-16j] - [ 0.00722021-2.20990232e-03j] - [ 0.00722021+2.20990232e-03j] - [ 0.10966187-1.81611675e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0030206850268025697 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0004206778835279385 - DEBUG:qutip_qtrl.tslotcomp:144 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.10881918-1.05117998e-16j] - [-0.00818667-9.98658967e-04j] - [-0.00818667+9.98658967e-04j] - [ 0.89118082+8.63042319e-17j]] - Evo final diff: - [[-0.10881918+1.05117998e-16j] - [ 0.00818667+9.98658967e-04j] - [ 0.00818667-9.98658967e-04j] - [ 0.10881918-8.63042319e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.002977408062166688 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0006179572985145115 - DEBUG:qutip_qtrl.tslotcomp:150 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[0.10893369-5.09188722e-17j] - [0.01915619+3.34754429e-02j] - [0.01915619-3.34754429e-02j] - [0.89106631+6.30446511e-17j]] - Evo final diff: - [[-0.10893369+5.09188722e-17j] - [-0.01915619-3.34754429e-02j] - [-0.01915619+3.34754429e-02j] - [ 0.10893369-6.30446511e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0033385283684678937 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.00440432211260146 - DEBUG:qutip_qtrl.tslotcomp:150 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.1082078 -7.62810704e-18j] - [-0.00188368+6.88378461e-03j] - [-0.00188368-6.88378461e-03j] - [ 0.8917922 -2.12907249e-17j]] - Evo final diff: - [[-0.1082078 +7.62810704e-18j] - [ 0.00188368-6.88378461e-03j] - [ 0.00188368+6.88378461e-03j] - [ 0.1082078 +2.12907249e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0029399658007447775 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0007275766472791512 - DEBUG:qutip_qtrl.tslotcomp:150 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.10752116-2.11858619e-16j] - [-0.00168463+6.00524977e-03j] - [-0.00168463-6.00524977e-03j] - [ 0.89247884+1.98456153e-16j]] - Evo final diff: - [[-0.10752116+2.11858619e-16j] - [ 0.00168463-6.00524977e-03j] - [ 0.00168463+6.00524977e-03j] - [ 0.10752116-1.98456153e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.002899925081967757 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0006452058698532823 - DEBUG:qutip_qtrl.tslotcomp:130 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[0.10569875-3.00077911e-16j] - [0.0059499 +1.39251675e-02j] - [0.0059499 -1.39251675e-02j] - [0.89430125+3.16129435e-16j]] - Evo final diff: - [[-0.10569875+3.00077911e-16j] - [-0.0059499 -1.39251675e-02j] - [-0.0059499 +1.39251675e-02j] - [ 0.10569875-3.16129435e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.002850384225861206 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0016855236265835014 - DEBUG:qutip_qtrl.tslotcomp:132 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.10497416-7.39664158e-17j] - [-0.00243508+3.63835198e-03j] - [-0.00243508-3.63835198e-03j] - [ 0.89502584+6.54204692e-17j]] - Evo final diff: - [[-0.10497416+7.39664158e-17j] - [ 0.00243508-3.63835198e-03j] - [ 0.00243508+3.63835198e-03j] - [ 0.10497416-6.54204692e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.002759685324237138 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.000435543446037828 - DEBUG:qutip_qtrl.tslotcomp:134 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.10479938-1.17661387e-17j] - [-0.00446064+1.59815368e-04j] - [-0.00446064-1.59815368e-04j] - [ 0.89520062+3.25578489e-17j]] - Evo final diff: - [[-0.10479938+1.17661387e-17j] - [ 0.00446064-1.59815368e-04j] - [ 0.00446064+1.59815368e-04j] - [ 0.10479938-3.25578489e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.002750708233412382 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0004896581077905727 - DEBUG:qutip_qtrl.tslotcomp:202 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[0.10436742-6.90043500e-17j] - [0.00328362+5.30833354e-03j] - [0.00328362-5.30833354e-03j] - [0.89563258+6.90910003e-17j]] - Evo final diff: - [[-0.10436742+6.90043500e-17j] - [-0.00328362-5.30833354e-03j] - [-0.00328362+5.30833354e-03j] - [ 0.10436742-6.90910003e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0027328799606105027 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.000760130975106369 - DEBUG:qutip_qtrl.tslotcomp:198 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 1.04107186e-01-9.29898879e-17j] - [-3.96115525e-04-5.37137207e-04j] - [-3.96115525e-04+5.37137207e-04j] - [ 8.95892814e-01+1.13300683e-16j]] - Evo final diff: - [[-0.10410719+9.29898879e-17j] - [ 0.00039612+5.37137207e-04j] - [ 0.00039612-5.37137207e-04j] - [ 0.10410719-1.13300683e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0027096879175113045 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0003222966255689542 - DEBUG:qutip_qtrl.tslotcomp:202 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.10399701+1.78748013e-16j] - [-0.00143715-2.01419268e-03j] - [-0.00143715+2.01419268e-03j] - [ 0.89600299-1.71911082e-16j]] - Evo final diff: - [[-0.10399701-1.78748013e-16j] - [ 0.00143715+2.01419268e-03j] - [ 0.00143715-2.01419268e-03j] - [ 0.10399701+1.71911082e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0027053751425556963 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.00040868454197329196 - DEBUG:qutip_qtrl.tslotcomp:206 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[1.03602593e-01+7.41523511e-17j] - [7.76199379e-04-3.33318139e-03j] - [7.76199379e-04+3.33318139e-03j] - [8.96397407e-01-6.98430227e-17j]] - Evo final diff: - [[-0.10360259-7.41523511e-17j] - [-0.0007762 +3.33318139e-03j] - [-0.0007762 -3.33318139e-03j] - [ 0.10360259+6.98430227e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0026863024750416607 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.00039887171896492055 - DEBUG:qutip_qtrl.tslotcomp:212 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[1.02801167e-01+3.76611693e-17j] - [8.77013768e-04+4.08904284e-03j] - [8.77013768e-04-4.08904284e-03j] - [8.97198833e-01-5.32629335e-17j]] - Evo final diff: - [[-0.10280117-3.76611693e-17j] - [-0.00087701-4.08904284e-03j] - [-0.00087701+4.08904284e-03j] - [ 0.10280117+5.32629335e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0026463923436669114 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0005547734083537043 - DEBUG:qutip_qtrl.tslotcomp:208 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.10190409-1.15163006e-16j] - [-0.00172282-1.78044665e-04j] - [-0.00172282+1.78044665e-04j] - [ 0.89809591+1.24903520e-16j]] - Evo final diff: - [[-0.10190409+1.15163006e-16j] - [ 0.00172282+1.78044665e-04j] - [ 0.00172282-1.78044665e-04j] - [ 0.10190409-1.24903520e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.002596860968248521 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0005226078214042328 - DEBUG:qutip_qtrl.tslotcomp:206 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[0.09794285+3.98467394e-17j] - [0.00184585-1.04772205e-03j] - [0.00184585+1.04772205e-03j] - [0.90205715-3.81075707e-17j]] - Evo final diff: - [[-0.09794285-3.98467394e-17j] - [-0.00184585+1.04772205e-03j] - [-0.00184585-1.04772205e-03j] - [ 0.09794285+3.81075707e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.002399326797379077 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.00043545868627036346 - DEBUG:qutip_qtrl.tslotcomp:199 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.09581463+1.18848982e-16j] - [-0.00724779-6.72702891e-03j] - [-0.00724779+6.72702891e-03j] - [ 0.90418537-1.24877144e-16j]] - Evo final diff: - [[-0.09581463-1.18848982e-16j] - [ 0.00724779+6.72702891e-03j] - [ 0.00724779-6.72702891e-03j] - [ 0.09581463+1.24877144e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.002319556861186033 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0013023651442190495 - DEBUG:qutip_qtrl.tslotcomp:206 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.09053693+7.21333751e-17j] - [-0.01521012+2.06478190e-03j] - [-0.01521012-2.06478190e-03j] - [ 0.90946307-5.38625646e-17j]] - Evo final diff: - [[-0.09053693-7.21333751e-17j] - [ 0.01521012-2.06478190e-03j] - [ 0.01521012+2.06478190e-03j] - [ 0.09053693+5.38625646e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.002108136579583669 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0013974311451801593 - DEBUG:qutip_qtrl.tslotcomp:204 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[0.08740393+1.13699959e-16j] - [0.02516675+7.75704131e-03j] - [0.02516675-7.75704131e-03j] - [0.91259607-1.14147599e-16j]] - Evo final diff: - [[-0.08740393-1.13699959e-16j] - [-0.02516675-7.75704131e-03j] - [-0.02516675+7.75704131e-03j] - [ 0.08740393+1.14147599e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0020832461766792203 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.002506533779775255 - DEBUG:qutip_qtrl.tslotcomp:204 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[8.86222058e-02+4.97268253e-17j] - [2.56588382e-04+4.76433737e-03j] - [2.56588382e-04-4.76433737e-03j] - [9.11377794e-01-4.72413309e-17j]] - Evo final diff: - [[-0.08862221-4.97268253e-17j] - [-0.00025659-4.76433737e-03j] - [-0.00025659+4.76433737e-03j] - [ 0.08862221+4.72413309e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0019691650267841965 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0005952728968143743 - DEBUG:qutip_qtrl.tslotcomp:204 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[0.08495534-3.29007930e-17j] - [0.01528129-5.66222785e-03j] - [0.01528129+5.66222785e-03j] - [0.91504466+3.46683616e-17j]] - Evo final diff: - [[-0.08495534+3.29007930e-17j] - [-0.01528129+5.66222785e-03j] - [-0.01528129-5.66222785e-03j] - [ 0.08495534-3.46683616e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0018707471382189164 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.001120846566928445 - DEBUG:qutip_qtrl.tslotcomp:197 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.08263591-1.08670839e-16j] - [-0.0021057 -8.19285612e-03j] - [-0.0021057 +8.19285612e-03j] - [ 0.91736409+1.20622806e-16j]] - Evo final diff: - [[-0.08263591+1.08670839e-16j] - [ 0.0021057 +8.19285612e-03j] - [ 0.0021057 -8.19285612e-03j] - [ 0.08263591-1.20622806e-16j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.001725062577736425 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0010739051187731142 - DEBUG:qutip_qtrl.tslotcomp:198 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.0807071 +3.36395492e-17j] - [-0.00798595-3.76762132e-03j] - [-0.00798595+3.76762132e-03j] - [ 0.9192929 -3.54514155e-17j]] - Evo final diff: - [[-0.0807071 -3.36395492e-17j] - [ 0.00798595+3.76762132e-03j] - [ 0.00798595-3.76762132e-03j] - [ 0.0807071 +3.54514155e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0016479017720151489 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0010189445700085143 - DEBUG:qutip_qtrl.tslotcomp:198 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.07375042+6.28185036e-17j] - [-0.01443816+1.75836628e-02j] - [-0.01443816-1.75836628e-02j] - [ 0.92624958-5.14006535e-17j]] - Evo final diff: - [[-0.07375042-6.28185036e-17j] - [ 0.01443816-1.75836628e-02j] - [ 0.01443816+1.75836628e-02j] - [ 0.07375042+5.14006535e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0014891926475058604 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.001541352580157223 - DEBUG:qutip_qtrl.tslotcomp:207 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.07304985-5.66968551e-17j] - [-0.00896955+8.59571602e-03j] - [-0.00896955-8.59571602e-03j] - [ 0.92695015+4.40306800e-17j]] - Evo final diff: - [[-0.07304985+5.66968551e-17j] - [ 0.00896955-8.59571602e-03j] - [ 0.00896955+8.59571602e-03j] - [ 0.07304985-4.40306800e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0013726548989253327 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0007931689912542538 - DEBUG:qutip_qtrl.tslotcomp:208 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[0.07120002-5.50391068e-17j] - [0.00097728-4.14710189e-03j] - [0.00097728+4.14710189e-03j] - [0.92879998+5.72663573e-17j]] - Evo final diff: - [[-0.07120002+5.50391068e-17j] - [-0.00097728+4.14710189e-03j] - [-0.00097728-4.14710189e-03j] - [ 0.07120002-5.72663573e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0012718991600032883 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0005914141449148123 - DEBUG:qutip_qtrl.tslotcomp:213 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[0.06815425-7.70364037e-17j] - [0.00448965+1.11383284e-03j] - [0.00448965-1.11383284e-03j] - [0.93184575+8.04728568e-17j]] - Evo final diff: - [[-0.06815425+7.70364037e-17j] - [-0.00448965-1.11383284e-03j] - [-0.00448965+1.11383284e-03j] - [ 0.06815425-8.04728568e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0011665998232497808 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.00059355174364513 - DEBUG:qutip_qtrl.tslotcomp:216 amplitudes changed - Level 8:qutip_qtrl.dynamics:Computing evolution - Level 8:qutip_qtrl.fidcomp:Calculating TraceDiff fidelity... - Target: - [[0.+0.j] - [0.+0.j] - [0.+0.j] - [1.+0.j]] - Evo final: - [[ 0.05542137+7.22898608e-17j] - [-0.00407353+1.49163418e-02j] - [-0.00407353-1.49163418e-02j] - [ 0.94457863-6.48865312e-17j]] - Evo final diff: - [[-0.05542137-7.22898608e-17j] - [ 0.00407353-1.49163418e-02j] - [ 0.00407353+1.49163418e-02j] - [ 0.05542137+6.48865312e-17j]] - DEBUG:qutip_qtrl.fidcomp:Fidelity error: 0.0008276547544061342 - DEBUG:qutip_qtrl.tslotcomp:No amplitudes changed - DEBUG:qutip_qtrl.fidcomp:Gradient norm: 0.0015358534376677783 - - - Infidelity: 0.0008276547544061342 - - - - -![png](GRAPE_state_open_files/GRAPE_state_open_7_2.png) - - - - ```python -H_result = [Hd, [Hc, res_grape.optimized_controls[0]]] -evolution = qt.mesolve(H_result, initial_state, times, c_ops) +L_result = [Ld, [Lc, control_step_function]] +evolution = qt.mesolve(L_result, initial_state, times) -plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution.states]) -plt.plot(times, [qt.fidelity(state, target_state) for state in evolution.states], '--', label="Fidelity") -plt.title("CRAB performance") +plt.plot(times, [fidelity(state, initial_state) for state in evolution.states], label="Overlap with initial state") +plt.plot(times, [fidelity(state, target_state) for state in evolution.states], label="Overlap with target state") +plt.title("GRAPE performance") plt.xlabel('Time') plt.legend() -plt.ylim(0, 1) plt.show() -``` +print(1 - fidelity(evolution.states[-1], target_state)) +``` +```python +state = initial_state +dt = times[1] - times[0] - -![png](GRAPE_state_open_files/GRAPE_state_open_8_0.png) - +for c in res_grape.optimized_controls[0][:-1]: + propagator = ((Ld + c * Lc) * dt).expm() + state = propagator(state) +print(1 - fidelity(state, target_state)) +``` ## Validation ```python -assert res_grape.infidelity < 0.01 +assert res_grape.infidelity < 0.001 +assert fidelity(evolution.states[-1], target_state) > 1-0.001 ``` ```python qt.about() -``` - - - QuTiP: Quantum Toolbox in Python - ================================ - Copyright (c) QuTiP team 2011 and later. - Current admin team: Alexander Pitchford, Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguère, Boxi Li, Simon Cross, Asier Galicia, Paul Menczel, and Patrick Hopf. - Board members: Daniel Burgarth, Robert Johansson, Anton F. Kockum, Franco Nori and Will Zeng. - Original developers: R. J. Johansson & P. D. Nation. - Previous lead developers: Chris Granade & A. Grimsmo. - Currently developed through wide collaboration. See https://github.com/qutip for details. - - QuTiP Version: 5.1.1 - Numpy Version: 1.26.4 - Scipy Version: 1.15.2 - Cython Version: None - Matplotlib Version: 3.10.0 - Python Version: 3.12.10 - Number of CPUs: 8 - BLAS Info: Generic - INTEL MKL Ext: None - Platform Info: Windows (AMD64) - Installation path: c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\qutip - - Installed QuTiP family packages - ------------------------------- - - qutip-jax: 0.1.0 - qutip-qtrl: 0.1.5 - - ================================================================================ - Please cite QuTiP in your publication. - ================================================================================ - For your convenience a bibtex reference can be easily generated using `qutip.cite()` - - - -```python - -``` +``` \ No newline at end of file diff --git a/tests/interactive/JOPT_gate_open.md b/tests/interactive/JOPT_gate_open.md index 3a3611f..ce492a9 100644 --- a/tests/interactive/JOPT_gate_open.md +++ b/tests/interactive/JOPT_gate_open.md @@ -1,13 +1,32 @@ +--- +jupyter: + jupytext: + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.17.2 + kernelspec: + display_name: Python 3 (ipykernel) + language: python + name: python3 +--- + # JOPT algorithm ```python import matplotlib.pyplot as plt import numpy as np -from jax import jit, numpy from qutip import (about, Qobj, gates, liouvillian, qeye, sigmam, sigmax, sigmay, sigmaz, fidelity) import qutip as qt from qutip_qoc import Objective, optimize_pulses + +try: + from jax import jit, numpy +except ImportError: # JAX not available, skip test + import pytest + pytest.skip("JAX not available") ``` ## Problem setup @@ -65,7 +84,6 @@ plt.title("Guess performance") plt.xlabel("Time") plt.legend() plt.show() - ``` ## JOPT algorithm @@ -80,18 +98,6 @@ H = [Hd] + [[hc, sin_x, {"grad": sin_x}] for hc in Hc] ``` - The Kernel crashed while executing code in the current cell or a previous cell. - - - Please review the code in the cell(s) to identify a possible cause of the failure. - - - Click here for more info. - - - View Jupyter log for further details. - - ### a) not optimized over time @@ -151,7 +157,6 @@ plt.title("JOPT performance") plt.xlabel("Time") plt.legend() plt.show() - ``` ### b) optimized over time @@ -220,7 +225,6 @@ plt.title("JOPT performance (optimized over time)") plt.xlabel("Time") plt.legend() plt.show() - ``` ## Global optimization @@ -257,7 +261,6 @@ plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() plt.show() - ``` @@ -285,7 +288,6 @@ plt.title("JOPT performance (global)") plt.xlabel("Time") plt.legend() plt.show() - ``` ## Comparison @@ -309,7 +311,6 @@ for i in range(3): plt.tight_layout() plt.show() - ``` ## Validation @@ -322,20 +323,6 @@ assert res_jopt_global.infidelity < 0.001 ``` - --------------------------------------------------------------------------- - - NameError Traceback (most recent call last) - - Cell In[1], line 1 - ----> 1 assert res_jopt.infidelity < 0.001 - 2 assert res_jopt_time.infidelity < 0.001 - 3 assert res_jopt_global.infidelity < 0.001 - - - NameError: name 'res_jopt' is not defined - - - ```python qt.about() ``` diff --git a/tests/interactive/JOPT_state_open.md b/tests/interactive/JOPT_state_open.md index bb60208..8c5d8d8 100644 --- a/tests/interactive/JOPT_state_open.md +++ b/tests/interactive/JOPT_state_open.md @@ -1,3 +1,17 @@ +--- +jupyter: + jupytext: + text_representation: + extension: .md + format_name: markdown + format_version: '1.3' + jupytext_version: 1.17.2 + kernelspec: + display_name: Python 3 (ipykernel) + language: python + name: python3 +--- + # JOPT algorithm for a 2 level system @@ -8,7 +22,12 @@ import numpy as np from qutip import (about, fidelity, liouvillian, ket2dm, Qobj, basis, sigmam) import qutip as qt from qutip_qoc import Objective, optimize_pulses -from jax import jit, numpy + +try: + from jax import jit, numpy +except ImportError: # JAX not available, skip test + import pytest + pytest.skip("JAX not available") ``` ## Problem setup @@ -59,15 +78,6 @@ plt.title("Guess performance") plt.show() ``` - Fidelity: 0.7628226855907076 - - - - -![png](JOPT_state_open_files/JOPT_state_open_5_1.png) - - - ## JOPT algorithm @@ -112,174 +122,6 @@ plt.legend() plt.show() ``` - c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\scipy\optimize\_basinhopping.py:294: RuntimeWarning: Method Nelder-Mead does not use gradient information (jac). - return self.minimizer(self.func, x0, **self.kwargs) - c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\scipy\optimize\_basinhopping.py:294: OptimizeWarning: Unknown solver options: gtol - return self.minimizer(self.func, x0, **self.kwargs) - c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\equinox\_jit.py:55: UserWarning: Complex dtype support in Diffrax is a work in progress and may not yet produce correct results. Consider splitting your computation into real and imaginary parts instead. - out = fun(*args, **kwargs) - - - - --------------------------------------------------------------------------- - - ValueError Traceback (most recent call last) - - Cell In[17], line 9 - 1 ctrl_parameters = { - 2 id: {"guess": [1, 0], "bounds": [(-1, 1), (0, 2 * np.pi)]} # c0 and c1 - 3 } - 4 alg_args = { - 5 "alg": "JOPT", - 6 "fid_err_targ": 0.01, - 7 } - ----> 9 res_jopt = optimize_pulses( - 10 objectives=Objective(initial_state, H, target_state), - 11 control_parameters=ctrl_parameters, - 12 tlist=times, - 13 minimizer_kwargs={ - 14 "method": "Nelder-Mead", - 15 }, - 16 algorithm_kwargs=alg_args, - 17 ) - 19 print('Infidelity: ', res_jopt.infidelity) - 21 plt.plot(times, sin_x(times, jopt_guess), label='initial guess') - - - File c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\qutip_qoc\pulse_optim.py:422, in optimize_pulses(objectives, control_parameters, tlist, algorithm_kwargs, optimizer_kwargs, minimizer_kwargs, integrator_kwargs, optimization_type) - 419 rl_env.train() - 420 return rl_env.result() - --> 422 return _global_local_optimization( - 423 objectives, - 424 control_parameters, - 425 time_interval, - 426 time_options, - 427 algorithm_kwargs, - 428 optimizer_kwargs, - 429 minimizer_kwargs, - 430 integrator_kwargs, - 431 qtrl_optimizers, - 432 ) - - - File c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\qutip_qoc\_optimizer.py:359, in _global_local_optimization(objectives, control_parameters, time_interval, time_options, algorithm_kwargs, optimizer_kwargs, minimizer_kwargs, integrator_kwargs, qtrl_optimizers) - 356 cllbck = _Callback(result, fid_err_targ, max_wall_time, bounds, disp) - 358 # run the optimization - --> 359 min_res = optimizer( - 360 func=multi_objective.goal_fun, - 361 minimizer_kwargs={ - 362 "jac": multi_objective.grad_fun, - 363 "callback": cllbck.min_callback, - 364 **minimizer_kwargs, - 365 }, - 366 callback=cllbck.opt_callback, - 367 **optimizer_kwargs, - 368 ) - 370 cllbck.stop_clock() # stop the clock - 372 # some global optimization methods do not return the minimum result - 373 # when terminated through StopIteration (see min_callback) - - - File c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\scipy\_lib\_util.py:440, in _transition_to_rng..decorator..wrapper(*args, **kwargs) - 433 message = ( - 434 "The NumPy global RNG was seeded by calling " - 435 f"`np.random.seed`. Beginning in {end_version}, this " - 436 "function will no longer use the global RNG." - 437 ) + cmn_msg - 438 warnings.warn(message, FutureWarning, stacklevel=2) - --> 440 return fun(*args, **kwargs) - - - File c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\scipy\optimize\_basinhopping.py:696, in basinhopping(func, x0, niter, T, stepsize, minimizer_kwargs, take_step, accept_test, callback, interval, disp, niter_success, rng, target_accept_rate, stepwise_factor) - 693 if niter_success is None: - 694 niter_success = niter + 2 - --> 696 bh = BasinHoppingRunner(x0, wrapped_minimizer, take_step_wrapped, - 697 accept_tests, disp=disp) - 699 # The wrapped minimizer is called once during construction of - 700 # BasinHoppingRunner, so run the callback - 701 if callable(callback): - - - File c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\scipy\optimize\_basinhopping.py:78, in BasinHoppingRunner.__init__(self, x0, minimizer, step_taking, accept_tests, disp) - 75 self.res.minimization_failures = 0 - 77 # do initial minimization - ---> 78 minres = minimizer(self.x) - 79 if not minres.success: - 80 self.res.minimization_failures += 1 - - - File c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\scipy\optimize\_basinhopping.py:294, in MinimizerWrapper.__call__(self, x0) - 292 return self.minimizer(x0, **self.kwargs) - 293 else: - --> 294 return self.minimizer(self.func, x0, **self.kwargs) - - - File c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\scipy\optimize\_minimize.py:726, in minimize(fun, x0, args, method, jac, hess, hessp, bounds, constraints, tol, callback, options) - 723 callback = _wrap_callback(callback, meth) - 725 if meth == 'nelder-mead': - --> 726 res = _minimize_neldermead(fun, x0, args, callback, bounds=bounds, - 727 **options) - 728 elif meth == 'powell': - 729 res = _minimize_powell(fun, x0, args, callback, bounds, **options) - - - File c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\scipy\optimize\_optimize.py:833, in _minimize_neldermead(func, x0, args, callback, maxiter, maxfev, disp, return_all, initial_simplex, xatol, fatol, adaptive, bounds, **unknown_options) - 831 try: - 832 for k in range(N + 1): - --> 833 fsim[k] = func(sim[k]) - 834 except _MaxFuncCallError: - 835 pass - - - File c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\scipy\optimize\_optimize.py:542, in _wrap_scalar_function_maxfun_validation..function_wrapper(x, *wrapper_args) - 540 ncalls[0] += 1 - 541 # A copy of x is sent to the user function (gh13740) - --> 542 fx = function(np.copy(x), *(wrapper_args + args)) - 543 # Ideally, we'd like to a have a true scalar returned from f(x). For - 544 # backwards-compatibility, also allow np.array([1.3]), - 545 # np.array([[1.3]]) etc. - 546 if not np.isscalar(fx): - - - File c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\qutip_qoc\objective.py:143, in _MultiObjective.goal_fun(self, params) - 141 infid = 0 - 142 for i, alg in enumerate(self._alg_list): - --> 143 infid += self._weights[i] * alg.infidelity(params) - 144 return infid - - - [... skipping hidden 14 frame] - - - File c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\qutip_qoc\_jopt.py:153, in _JOPT._infid(self, params) - 151 diff = X - self._target - 152 # to prevent if/else in qobj.dag() and qobj.tr() - --> 153 diff_dag = Qobj(diff.data.adjoint(), dims=diff.dims) - 154 g = 1 / 2 * (diff_dag * diff).data.trace() - 155 infid = jnp.real(self._norm_fac * g) - - - File c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\qutip\core\qobj.py:279, in Qobj.__init__(self, arg, dims, copy, superrep, isherm, isunitary) - 277 self._isherm = isherm - 278 self._isunitary = isunitary - --> 279 self._initialize_data(arg, dims, copy) - 281 if superrep is not None: - 282 self.superrep = superrep - - - File c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\qutip\core\qobj.py:265, in Qobj._initialize_data(self, arg, dims, copy) - 261 self._dims = Dimensions( - 262 dims or [[self._data.shape[0]], [self._data.shape[1]]] - 263 ) - 264 if self._dims.shape != self._data.shape: - --> 265 raise ValueError('Provided dimensions do not match the data: ' + - 266 f"{self._dims.shape} vs {self._data.shape}") - - - ValueError: Provided dimensions do not match the data: (4, 1) vs (1, 4) - - - ```python H_result = [Hd, [Hc, np.array(res_jopt.optimized_controls[0])]] evolution = qt.sesolve(H_result, initial_state, times) @@ -291,15 +133,7 @@ plt.title('JOPT performance') plt.xlabel('Time') plt.legend() plt.show() - ``` - - - -![png](JOPT_state_open_files/JOPT_state_open_10_0.png) - - - ### b) optimized over time @@ -340,17 +174,6 @@ plt.legend() plt.show() ``` - Infidelity: 0.000510596900193172 - optimized time: [6.283185307179586] - - - - -![png](JOPT_state_open_files/JOPT_state_open_12_1.png) - - - - ```python H_result_time = [Hd, [Hc, np.array(res_jopt_time.optimized_controls[0])]] evolution_time = qt.sesolve(H_result_time, initial_state, times) @@ -364,13 +187,6 @@ plt.xlim(0, res_jopt_time.optimized_params[-1][0]) plt.legend() plt.show() ``` - - - -![png](JOPT_state_open_files/JOPT_state_open_13_0.png) - - - ## Global optimization @@ -401,20 +217,8 @@ plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() plt.show() - ``` - Infidelity: 6.418314632516964e-05 - optimized time: [2.990647906220658] - - - - -![png](JOPT_state_open_files/JOPT_state_open_15_1.png) - - - - ```python H_result_global = [Hd, [Hc, np.array(res_jopt_global.optimized_controls[0])]] evolution_global = qt.sesolve(H_result_global, initial_state, times) @@ -428,13 +232,6 @@ plt.xlabel('Time') plt.legend() plt.show() ``` - - - -![png](JOPT_state_open_files/JOPT_state_open_16_0.png) - - - ## Comparison @@ -449,14 +246,6 @@ plt.ylabel('Pulse amplitude') plt.legend() plt.show() ``` - - - -![png](JOPT_state_open_files/JOPT_state_open_18_0.png) - - - - ```python print('Guess Infidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) print('JOPT Infidelity: ', res_jopt.infidelity) @@ -474,18 +263,6 @@ plt.legend() plt.show() ``` - Guess Infidelity: 0.7568009078458054 - JOPT Infidelity: 0.0003454363645383207 - Time Infidelity: 0.000510596900193172 - GLobal Infidelity: 6.418314632516964e-05 - - - - -![png](JOPT_state_open_files/JOPT_state_open_19_1.png) - - - ## Validation @@ -500,41 +277,3 @@ assert res_jopt_global.infidelity < 0.001 qt.about() ``` - - QuTiP: Quantum Toolbox in Python - ================================ - Copyright (c) QuTiP team 2011 and later. - Current admin team: Alexander Pitchford, Nathan Shammah, Shahnawaz Ahmed, Neill Lambert, Eric Giguère, Boxi Li, Simon Cross, Asier Galicia, Paul Menczel, and Patrick Hopf. - Board members: Daniel Burgarth, Robert Johansson, Anton F. Kockum, Franco Nori and Will Zeng. - Original developers: R. J. Johansson & P. D. Nation. - Previous lead developers: Chris Granade & A. Grimsmo. - Currently developed through wide collaboration. See https://github.com/qutip for details. - - QuTiP Version: 5.1.1 - Numpy Version: 1.26.4 - Scipy Version: 1.15.2 - Cython Version: None - Matplotlib Version: 3.10.0 - Python Version: 3.12.10 - Number of CPUs: 8 - BLAS Info: Generic - INTEL MKL Ext: None - Platform Info: Windows (AMD64) - Installation path: c:\Users\julia\miniforge3\envs\qutip-dev\Lib\site-packages\qutip - - Installed QuTiP family packages - ------------------------------- - - qutip-jax: 0.1.0 - qutip-qtrl: 0.1.5 - - ================================================================================ - Please cite QuTiP in your publication. - ================================================================================ - For your convenience a bibtex reference can be easily generated using `qutip.cite()` - - - -```python - -``` From 4f14df59313524378419bc31ecd753bce9eead73 Mon Sep 17 00:00:00 2001 From: Paul Menczel Date: Thu, 21 Aug 2025 12:53:29 +0900 Subject: [PATCH 17/17] Finishing touches on interactive test notebooks --- tests/interactive/CRAB_gate_closed.md | 6 +- tests/interactive/CRAB_gate_open.md | 79 ++++---- tests/interactive/CRAB_state_closed.md | 6 +- tests/interactive/CRAB_state_open.md | 49 ++--- tests/interactive/GOAT_gate_closed.md | 12 +- tests/interactive/GOAT_gate_open.md | 241 ++++++++++------------ tests/interactive/GOAT_state_closed.md | 6 +- tests/interactive/GOAT_state_open.md | 174 ++++++++-------- tests/interactive/GRAPE_gate_closed.md | 17 +- tests/interactive/GRAPE_gate_open.md | 104 +++++----- tests/interactive/GRAPE_state_closed.md | 6 +- tests/interactive/GRAPE_state_open.md | 64 +++--- tests/interactive/JOPT_gate_closed.md | 12 +- tests/interactive/JOPT_gate_open.md | 254 +++++++++++------------- tests/interactive/JOPT_state_closed.md | 7 +- tests/interactive/JOPT_state_open.md | 218 ++++++++++---------- 16 files changed, 597 insertions(+), 658 deletions(-) diff --git a/tests/interactive/CRAB_gate_closed.md b/tests/interactive/CRAB_gate_closed.md index ea36556..221b42b 100644 --- a/tests/interactive/CRAB_gate_closed.md +++ b/tests/interactive/CRAB_gate_closed.md @@ -5,14 +5,14 @@ jupyter: extension: .md format_name: markdown format_version: '1.3' - jupytext_version: 1.17.1 + jupytext_version: 1.17.2 kernelspec: display_name: Python 3 (ipykernel) language: python name: python3 --- -# CRAB algorithm for a closed system +# CRAB algorithm for a closed system (gate synthesis) ```python import matplotlib.pyplot as plt @@ -94,7 +94,7 @@ plt.show() ```python assert res_crab.infidelity < 0.001 -assert fidelity(evolution.states[-1], target_gate) > 1-0.001 +assert np.allclose(fidelity(evolution.states[-1], target_gate), 1 - res_crab.infidelity, atol=1e-3) ``` ```python diff --git a/tests/interactive/CRAB_gate_open.md b/tests/interactive/CRAB_gate_open.md index b5c2ece..b31f27c 100644 --- a/tests/interactive/CRAB_gate_open.md +++ b/tests/interactive/CRAB_gate_open.md @@ -12,35 +12,39 @@ jupyter: name: python3 --- -# CRAB algorithm - +# CRAB algorithm for an open system (gate synthesis) ```python import matplotlib.pyplot as plt import numpy as np -from qutip import (about, Qobj, liouvillian, qeye, sigmam, sigmax, sigmay, sigmaz, tensor) +from qutip import gates, qeye, liouvillian, sigmam, sigmax, sigmay, sigmaz import qutip as qt from qutip_qoc import Objective, optimize_pulses + +def fidelity(gate_super, target_super): + gate_oper = qt.Qobj(gate_super.data) + target_oper = qt.Qobj(target_super.data) + + return np.abs(gate_oper.overlap(target_oper) / target_oper.norm()) ``` ## Problem setup ```python -hbar = 1 omega = 0.1 # energy splitting -delta = 1.0 # tunneling gamma = 0.1 # amplitude damping sx, sy, sz = sigmax(), sigmay(), sigmaz() c_ops = [np.sqrt(gamma) * sigmam()] -Hd = 1 / 2 * hbar * omega * sz +Hd = 1 / 2 * omega * sz Hd = liouvillian(H=Hd, c_ops=c_ops) Hc = [liouvillian(sx), liouvillian(sy), liouvillian(sz)] H = [Hd, Hc[0], Hc[1], Hc[2]] +# objective for optimization initial_gate = qeye(2) -target_gate = Qobj(1 / np.sqrt(2) * np.array([[1, 1], [1, -1]])) +target_gate = gates.hadamard_transform() times = np.linspace(0, np.pi / 2, 250) ``` @@ -51,35 +55,28 @@ times = np.linspace(0, np.pi / 2, 250) ```python n_params = 6 # adjust in steps of 3 control_params = { - "ctrl_x": { - "guess": [1 for _ in range(n_params)], - "bounds": [(-1, 1)] * n_params, - }, - "ctrl_y": { - "guess": [1 for _ in range(n_params)], - "bounds": [(-1, 1)] * n_params, - }, - "ctrl_z": { - "guess": [1 for _ in range(n_params)], - "bounds": [(-1, 1)] * n_params, - }, + "ctrl_x": {"guess": [1 for _ in range(n_params)], "bounds": [(-1, 1)] * n_params}, + "ctrl_y": {"guess": [1 for _ in range(n_params)], "bounds": [(-1, 1)] * n_params}, + "ctrl_z": {"guess": [1 for _ in range(n_params)], "bounds": [(-1, 1)] * n_params}, } alg_args = {"alg": "CRAB", "fid_err_targ": 0.01} - res_crab = optimize_pulses( - objectives=Objective(initial_gate, H, target_gate), - control_parameters=control_params, - tlist=times, - algorithm_kwargs=alg_args, + objectives = Objective(initial_gate, H, target_gate), + control_parameters = control_params, + tlist = times, + algorithm_kwargs = { + "alg": "CRAB", + "fid_err_targ": 0.01 + }, ) print('Infidelity: ', res_crab.infidelity) -plt.plot(times, res_crab.optimized_controls[0], label='optimized pulse sx') -plt.plot(times, res_crab.optimized_controls[1], label='optimized pulse sy') -plt.plot(times, res_crab.optimized_controls[2], label='optimized pulse sz') -plt.title('CRAB pulse') +plt.plot(times, res_crab.optimized_controls[0], 'b', label='optimized pulse sx') +plt.plot(times, res_crab.optimized_controls[1], 'g', label='optimized pulse sy') +plt.plot(times, res_crab.optimized_controls[2], 'r', label='optimized pulse sz') +plt.title('CRAB pulses') plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() @@ -87,24 +84,18 @@ plt.show() ``` ```python -H_result = [Hd, - [Hc[0], res_crab.optimized_controls[0]], - [Hc[1], res_crab.optimized_controls[1]], - [Hc[2], res_crab.optimized_controls[2]]] - -identity_op = qt.qeye(2) -identity_super = qt.spre(identity_op) - -evolution = qt.mesolve(H_result, identity_super, times) - -target_super = qt.to_super(target_gate) initial_super = qt.to_super(initial_gate) +target_super = qt.to_super(target_gate) + +H_result = [Hd, + [Hc[0], np.array(res_crab.optimized_controls[0])], + [Hc[1], np.array(res_crab.optimized_controls[1])], + [Hc[2], np.array(res_crab.optimized_controls[2])]] +evolution = qt.mesolve(H_result, initial_super, times) -initial_overlaps = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution.states] -target_overlaps = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution.states] +plt.plot(times, [fidelity(gate, initial_super) for gate in evolution.states], label="Overlap with initial gate") +plt.plot(times, [fidelity(gate, target_super) for gate in evolution.states], label="Overlap with target gate") -plt.plot(times, initial_overlaps, label="Overlap with initial gate") -plt.plot(times, target_overlaps, label="Overlap with target gate") plt.title("CRAB performance") plt.xlabel("Time") plt.legend() @@ -115,10 +106,10 @@ plt.show() ```python assert res_crab.infidelity < 0.01 +assert np.allclose(fidelity(evolution.states[-1], target_super), 1 - res_crab.infidelity, atol=1e-3) ``` ```python qt.about() ``` - diff --git a/tests/interactive/CRAB_state_closed.md b/tests/interactive/CRAB_state_closed.md index 278ab21..5eff137 100644 --- a/tests/interactive/CRAB_state_closed.md +++ b/tests/interactive/CRAB_state_closed.md @@ -5,14 +5,14 @@ jupyter: extension: .md format_name: markdown format_version: '1.3' - jupytext_version: 1.17.1 + jupytext_version: 1.17.2 kernelspec: display_name: Python 3 (ipykernel) language: python name: python3 --- -# CRAB algorithm for 2 level system +# CRAB algorithm for a closed system (state transfer) ```python import matplotlib.pyplot as plt @@ -87,7 +87,7 @@ plt.show() ```python assert res_crab.infidelity < 0.001 -assert np.abs(evolution.states[-1].overlap(target_state)) > 1-0.001 +assert np.allclose(np.abs(evolution.states[-1].overlap(target_state)), 1 - res_crab.infidelity, atol=1e-3) ``` ```python diff --git a/tests/interactive/CRAB_state_open.md b/tests/interactive/CRAB_state_open.md index a63fd3d..c26a9a9 100644 --- a/tests/interactive/CRAB_state_open.md +++ b/tests/interactive/CRAB_state_open.md @@ -12,15 +12,22 @@ jupyter: name: python3 --- -# GRAPE algorithm for 2 level system - +# CRAB algorithm for an open system (state transfer) ```python import matplotlib.pyplot as plt import numpy as np -from qutip import (about, fidelity, liouvillian, ket2dm, Qobj, basis, sigmam) +from qutip import basis, ket2dm, liouvillian, sigmam, Qobj import qutip as qt from qutip_qoc import Objective, optimize_pulses + +def fidelity(dm, target_dm): + """ + Fidelity used for density matrices in qutip-qtrl and qutip-qoc + """ + + diff = dm - target_dm + return 1 - np.real(diff.overlap(diff) / target_dm.norm()) / 2 ``` ## Problem setup @@ -28,11 +35,8 @@ from qutip_qoc import Objective, optimize_pulses ```python # Energy levels -E1, E2 = 1.0, 2.0 +E1, E2 = 1.0, 2.0 -hbar = 1 -omega = 0.1 # energy splitting -delta = 1.0 # tunneling gamma = 0.1 # amplitude damping c_ops = [np.sqrt(gamma) * sigmam()] @@ -57,18 +61,17 @@ times = np.linspace(0, 2 * np.pi, 250) ```python n_params = 6 # adjust in steps of 3 control_params = { - "ctrl_x": { - "guess": [1 for _ in range(n_params)], - "bounds": [(-1, 1)] * n_params, - }, + "ctrl_x": {"guess": [1 for _ in range(n_params)], "bounds": [(-1, 1)] * n_params}, } -alg_args = {"alg": "CRAB", "fid_err_targ": 0.001, "fix_frequency": False} res_crab = optimize_pulses( - objectives=Objective(initial_state, H, target_state), - control_parameters=control_params, - tlist=times, - algorithm_kwargs=alg_args, + objectives = Objective(initial_state, H, target_state), + control_parameters = control_params, + tlist = times, + algorithm_kwargs = { + "alg": "CRAB", + "fid_err_targ": 0.02 + }, ) print('Infidelity: ', res_crab.infidelity) @@ -83,11 +86,11 @@ plt.show() ```python H_result = [Hd, [Hc, res_crab.optimized_controls[0]]] -evolution = qt.mesolve(H_result, initial_state, times, c_ops) +evolution = qt.mesolve(H_result, initial_state, times) + +plt.plot(times, [fidelity(dm, initial_state) for dm in evolution.states], label="Overlap with initial state") +plt.plot(times, [fidelity(dm, target_state) for dm in evolution.states], label="Overlap with target state") -plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution.states], label="Overlap with initial state") -plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution.states], label="Overlap with target state") -plt.plot(times, [qt.fidelity(state, target_state) for state in evolution.states], '--', label="Fidelity") plt.title("CRAB performance") plt.xlabel('Time') plt.legend() @@ -97,11 +100,11 @@ plt.show() ```python -assert res_crab.infidelity < 0.01 +assert res_crab.infidelity < 0.02 +assert np.allclose(fidelity(evolution.states[-1], target_state), 1 - res_crab.infidelity, atol=1e-3) ``` ```python qt.about() -``` - +``` \ No newline at end of file diff --git a/tests/interactive/GOAT_gate_closed.md b/tests/interactive/GOAT_gate_closed.md index 4eafa97..9ffcc37 100644 --- a/tests/interactive/GOAT_gate_closed.md +++ b/tests/interactive/GOAT_gate_closed.md @@ -5,14 +5,14 @@ jupyter: extension: .md format_name: markdown format_version: '1.3' - jupytext_version: 1.17.1 + jupytext_version: 1.17.2 kernelspec: display_name: Python 3 (ipykernel) language: python name: python3 --- -# GOAT algorithm for a closed system +# GOAT algorithm for a closed system (gate synthesis)| ```python import matplotlib.pyplot as plt @@ -187,7 +187,7 @@ plt.legend() plt.show() ``` -## Global optimization +### c) global optimization ```python res_goat_global = optimize_pulses( @@ -266,13 +266,13 @@ plt.show() ```python assert res_goat.infidelity < 0.001 -assert fidelity(evolution.states[-1], target_gate) > 1-0.001 +assert np.allclose(fidelity(evolution.states[-1], target_gate), 1 - res_goat.infidelity, atol=1e-3) assert res_goat_time.infidelity < 0.001 -assert fidelity(evolution_time.states[-1], target_gate) > 1-0.001 +assert np.allclose(fidelity(evolution_time.states[-1], target_gate), 1 - res_goat_time.infidelity, atol=1e-3) assert res_goat_global.infidelity < 0.001 -assert fidelity(evolution_global.states[-1], target_gate) > 1-0.001 +assert np.allclose(fidelity(evolution_global.states[-1], target_gate), 1 - res_goat_global.infidelity, atol=1e-3) ``` ```python diff --git a/tests/interactive/GOAT_gate_open.md b/tests/interactive/GOAT_gate_open.md index adf2528..1dca173 100644 --- a/tests/interactive/GOAT_gate_open.md +++ b/tests/interactive/GOAT_gate_open.md @@ -12,36 +12,39 @@ jupyter: name: python3 --- -# GOAT algorithm - +# GOAT algorithm for an open system (gate synthesis) ```python import matplotlib.pyplot as plt import numpy as np -from qutip import (Qobj, liouvillian, qeye, sigmam, sigmax, sigmay, sigmaz) +from qutip import gates, qeye, liouvillian, sigmam, sigmax, sigmay, sigmaz import qutip as qt from qutip_qoc import Objective, optimize_pulses + +def fidelity(gate_super, target_super): + gate_oper = qt.Qobj(gate_super.data) + target_oper = qt.Qobj(target_super.data) + + return np.abs(gate_oper.overlap(target_oper) / target_oper.norm()) ``` ## Problem setup ```python -hbar = 1 omega = 0.1 # energy splitting -delta = 1.0 # tunneling gamma = 0.1 # amplitude damping sx, sy, sz = sigmax(), sigmay(), sigmaz() +c_ops = [np.sqrt(gamma) * sigmam()] -Hd = 1 / 2 * hbar * omega * sz -Hd = liouvillian(H=Hd, c_ops=[np.sqrt(gamma) * sigmam()]) +Hd = 1 / 2 * omega * sz +Hd = liouvillian(H=Hd, c_ops=c_ops) Hc = [liouvillian(sx), liouvillian(sy), liouvillian(sz)] - H = [Hd, Hc[0], Hc[1], Hc[2]] # objective for optimization initial_gate = qeye(2) -target_gate = Qobj(1 / np.sqrt(2) * np.array([[1, 1], [1, -1]])) +target_gate = gates.hadamard_transform() times = np.linspace(0, np.pi / 2, 250) ``` @@ -53,39 +56,27 @@ times = np.linspace(0, np.pi / 2, 250) goat_guess = [1, 1] guess_pulse = goat_guess[0] * np.sin(goat_guess[1] * times) -H_result_guess = [Hd, - [Hc[0], guess_pulse], - [Hc[1], guess_pulse], - [Hc[2], guess_pulse]] - -identity_op = qt.qeye(2) -identity_super = qt.spre(identity_op) - -evolution_guess = qt.mesolve(H_result_guess, identity_super, times) - -target_super = qt.to_super(target_gate) initial_super = qt.to_super(initial_gate) +target_super = qt.to_super(target_gate) -initial_overlaps_guess = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution_guess.states] -target_overlaps_guess = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution_guess.states] +H_guess = [Hd] + [[hc, guess_pulse] for hc in Hc] +evolution_guess = qt.mesolve(H_guess, initial_super, times) -plt.plot(times, initial_overlaps_guess, label="Overlap with initial gate") -plt.plot(times, target_overlaps_guess, label="Overlap with target gate") +plt.plot(times, [fidelity(gate, initial_super) for gate in evolution_guess.states], label="Overlap with initial gate") +plt.plot(times, [fidelity(gate, target_super) for gate in evolution_guess.states], label="Overlap with target gate") plt.title("Guess performance") -plt.xlabel("Time") +plt.xlabel('Time') plt.legend() plt.show() ``` -## Goat algorithm +## GOAT algorithm ### a) not optimized over time - ```python # control function def sin(t, c): return c[0] * np.sin(c[1] * t) - # derivatives def grad_sin(t, c, idx): if idx == 0: # w.r.t. c0 @@ -96,34 +87,32 @@ def grad_sin(t, c, idx): return c[0] * np.cos(c[1] * t) * c[1] H = [Hd] + [[hc, sin, {"grad": grad_sin}] for hc in Hc] - ``` ```python -ctrl_params = { - id: {"guess": goat_guess, "bounds": [(-1, 1), (0, 2 * np.pi)]} # c0 and c1 +control_params = { + id: {"guess": goat_guess, "bounds": [(-1, 1), (0, 2 * np.pi)]} # c0 and c1 for id in ['x', 'y', 'z'] } -alg_args = { - "alg": "GOAT", - "fid_err_targ": 0.001, -} # run the optimization res_goat = optimize_pulses( objectives = Objective(initial_gate, H, target_gate), - control_parameters = ctrl_params, + control_parameters = control_params, tlist = times, - algorithm_kwargs = alg_args, + algorithm_kwargs = { + "alg": "GOAT", + "fid_err_targ": 0.001, + }, ) print('Infidelity: ', res_goat.infidelity) -plt.plot(times, res_goat.optimized_controls[0], label='optimized pulse') -plt.plot(times, res_goat.optimized_controls[1], label='optimized pulse') -plt.plot(times, res_goat.optimized_controls[2], label='optimized pulse') -plt.title('GOAT pulse') +plt.plot(times, res_goat.optimized_controls[0], 'b', label='optimized pulse sx') +plt.plot(times, res_goat.optimized_controls[1], 'g', label='optimized pulse sy') +plt.plot(times, res_goat.optimized_controls[2], 'r', label='optimized pulse sz') +plt.title('GOAT pulses') plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() @@ -135,20 +124,11 @@ H_result = [Hd, [Hc[0], np.array(res_goat.optimized_controls[0])], [Hc[1], np.array(res_goat.optimized_controls[1])], [Hc[2], np.array(res_goat.optimized_controls[2])]] +evolution = qt.mesolve(H_result, initial_super, times) -identity_op = qt.qeye(2) -identity_super = qt.spre(identity_op) - -evolution = qt.mesolve(H_result, identity_super, times) +plt.plot(times, [fidelity(gate, initial_super) for gate in evolution.states], label="Overlap with initial gate") +plt.plot(times, [fidelity(gate, target_super) for gate in evolution.states], label="Overlap with target gate") -target_super = qt.to_super(target_gate) -initial_super = qt.to_super(initial_gate) - -initial_overlaps = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution.states] -target_overlaps = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution.states] - -plt.plot(times, initial_overlaps, label="Overlap with initial gate") -plt.plot(times, target_overlaps, label="Overlap with target gate") plt.title("GOAT performance") plt.xlabel("Time") plt.legend() @@ -159,33 +139,33 @@ plt.show() ```python # treats time as optimization variable -ctrl_params["__time__"] = { +control_params["__time__"] = { "guess": times[len(times) // 2], "bounds": [times[0], times[-1]], } -alg_args = { - "alg": "GOAT", - "fid_err_targ": 0.001, -} # run the optimization res_goat_time = optimize_pulses( objectives = Objective(initial_gate, H, target_gate), - control_parameters = ctrl_params, + control_parameters = control_params, tlist = times, - algorithm_kwargs = alg_args, + algorithm_kwargs = { + "alg": "GOAT", + "fid_err_targ": 0.001, + }, ) -time_time = res_goat_time.optimized_params[-1] -time_range = times < time_time +opt_time = res_goat_time.optimized_params[-1][0] +time_range = times < opt_time print('Infidelity: ', res_goat_time.infidelity) -print('Optimized time: ', res_goat_time.optimized_params[-1][0]) +print('Optimized time: ', opt_time) -plt.plot(times[time_range], np.array(res_goat_time.optimized_controls[0])[time_range], label='optimized (over time) pulse sx') -plt.plot(times[time_range], np.array(res_goat_time.optimized_controls[1])[time_range], label='optimized (over time) pulse sy') -plt.plot(times[time_range], np.array(res_goat_time.optimized_controls[2])[time_range], label='optimized (over time) pulse sz') -plt.title('GOAT pulses') +plt.plot(times, guess_pulse, 'k--', label='guess pulse sx, sy, sz') +plt.plot(times[time_range], np.array(res_goat_time.optimized_controls[0])[time_range], 'b', label='optimized pulse sx') +plt.plot(times[time_range], np.array(res_goat_time.optimized_controls[1])[time_range], 'g', label='optimized pulse sy') +plt.plot(times[time_range], np.array(res_goat_time.optimized_controls[2])[time_range], 'r', label='optimized pulse sz') +plt.title('GOAT pulses (time optimization)') plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() @@ -193,88 +173,74 @@ plt.show() ``` ```python -H_result_time = [Hd, - [Hc[0], np.array(res_goat_time.optimized_controls[0])], - [Hc[1], np.array(res_goat_time.optimized_controls[1])], - [Hc[2], np.array(res_goat_time.optimized_controls[2])]] +times2 = times[time_range] +if opt_time not in times2: + times2 = np.append(times2, opt_time) +H_result = qt.QobjEvo( + [Hd, [Hc[0], np.array(res_goat_time.optimized_controls[0])], + [Hc[1], np.array(res_goat_time.optimized_controls[1])], + [Hc[2], np.array(res_goat_time.optimized_controls[2])]], tlist=times) +evolution_time = qt.mesolve(H_result, initial_super, times2) -identity_op = qt.qeye(2) -identity_super = qt.spre(identity_op) +plt.plot(times2, [fidelity(gate, initial_super) for gate in evolution_time.states], label="Overlap with initial gate") +plt.plot(times2, [fidelity(gate, target_super) for gate in evolution_time.states], label="Overlap with target gate") -evolution_time = qt.mesolve(H_result_time, identity_super, times) - -target_super = qt.to_super(target_gate) -initial_super = qt.to_super(initial_gate) - -initial_overlaps_time = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution_time.states] -target_overlaps_time = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution_time.states] - -plt.plot(times, initial_overlaps, label="Overlap with initial gate") -plt.plot(times, target_overlaps, label="Overlap with target gate") -plt.title("GOAT performance (optimized over time)") +plt.title('GOAT (optimized over time) performance') plt.xlabel("Time") plt.legend() plt.show() ``` -## Global optimization - +### c) global optimization ```python -alg_args = { - "alg": "GOAT", - "fid_err_targ": 0.01, -} -opt_args = { - "method": "basinhopping", - "max_iter": 100, -} - res_goat_global = optimize_pulses( - objectives=Objective(initial_gate, H, target_gate), - control_parameters = ctrl_params, + objectives = Objective(initial_gate, H, target_gate), + control_parameters = control_params, tlist = times, - algorithm_kwargs = alg_args, - optimizer_kwargs = opt_args + algorithm_kwargs = { + "alg": "GOAT", + "fid_err_targ": 0.001, + }, + optimizer_kwargs = { + "method": "basinhopping", + "max_iter": 100, + } ) -global_time = res_goat_global.optimized_params[-1] +global_time = res_goat_global.optimized_params[-1][0] global_range = times < global_time print('Infidelity: ', res_goat_global.infidelity) -print('optimized time: ', res_goat_global.optimized_params[-1]) +print('Optimized time: ', global_time) -plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[0])[global_range], label='global optimized pulse sx') -plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[1])[global_range], label='global optimized pulse sy') -plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[2])[global_range], label='global optimized pulse sz') -plt.title('GOAT pulses') -plt.xlabel('time') +plt.plot(times, guess_pulse, 'k--', label='guess pulse sx, sy, sz') +plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[0])[global_range], 'b', label='optimized pulse sx') +plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[1])[global_range], 'g', label='optimized pulse sy') +plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[2])[global_range], 'r', label='optimized pulse sz') +plt.title('GOAT pulses (global optimization)') +plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() plt.show() ``` ```python -H_result_global = [Hd, - [Hc[0], np.array(res_goat_global.optimized_controls[0])], - [Hc[1], np.array(res_goat_global.optimized_controls[1])], - [Hc[2], np.array(res_goat_global.optimized_controls[2])]] +times3 = times[global_range] +if global_time not in times3: + times3 = np.append(times3, global_time) -identity_op = qt.qeye(2) -identity_super = qt.spre(identity_op) +H_result = qt.QobjEvo( + [Hd, [Hc[0], np.array(res_goat_global.optimized_controls[0])], + [Hc[1], np.array(res_goat_global.optimized_controls[1])], + [Hc[2], np.array(res_goat_global.optimized_controls[2])]], tlist=times) +evolution_global = qt.mesolve(H_result, initial_super, times3) -evolution_global = qt.mesolve(H_result_global, identity_super, times) +plt.plot(times3, [fidelity(gate, initial_super) for gate in evolution_global.states], label="Overlap with initial gate") +plt.plot(times3, [fidelity(gate, target_super) for gate in evolution_global.states], label="Overlap with target gate") -target_super = qt.to_super(target_gate) -initial_super = qt.to_super(initial_gate) - -initial_overlaps_global = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution_global.states] -target_overlaps_global = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution_global.states] - -plt.plot(times, initial_overlaps_global, label="Overlap with initial gate") -plt.plot(times, target_overlaps_global, label="Overlap with target gate") -plt.title("GOAT performance (global)") -plt.xlabel("Time") +plt.title('GOAT (global optimization) performance') +plt.xlabel('Time') plt.legend() plt.show() ``` @@ -284,16 +250,15 @@ plt.show() ```python fig, axes = plt.subplots(1, 3, figsize=(18, 4)) # 1 row, 3 columns -titles = ["GOAT s_x pulses", "GOAT s_y pulses", "GOAT s_z pulses"] +titles = ["GOAT sx pulses", "GOAT sy pulses", "GOAT sz pulses"] -for i in range(3): - ax = axes[i] - ax.plot(times, sin(times, goat_guess), 'k--', label='initial guess') - ax.plot(times, res_goat.optimized_controls[i], color='orange', label='optimized pulse') +for i, ax in enumerate(axes): + ax.plot(times, guess_pulse, label='initial guess') + ax.plot(times, res_goat.optimized_controls[i], label='optimized pulse') ax.plot(times[time_range], np.array(res_goat_time.optimized_controls[i])[time_range], label='optimized (over time) pulse') ax.plot(times[global_range], np.array(res_goat_global.optimized_controls[i])[global_range], label='global optimized pulse') ax.set_title(titles[i]) - ax.set_xlabel('time') + ax.set_xlabel('Time') ax.set_ylabel('Pulse amplitude') ax.legend() @@ -304,13 +269,21 @@ plt.show() ```python -assert res_goat.infidelity < 0.01 -assert res_goat_time.infidelity < 0.01 -assert res_goat_global.infidelity < 0.01 +guess_fidelity = fidelity(evolution_guess.states[-1], target_super) + +# target fidelity not reached in part a), check that it is better than the guess +assert 1 - res_goat.infidelity >= guess_fidelity +assert np.allclose(fidelity(evolution.states[-1], target_super), 1 - res_goat.infidelity, atol=1e-3) + +# target fidelity not reached in part b), check that it is better than part a) +assert res_goat_time.infidelity <= res_goat.infidelity +assert np.allclose(fidelity(evolution_time.states[-1], target_super), 1 - res_goat_time.infidelity, atol=1e-3) + +assert res_goat_global.infidelity <= res_goat_time.infidelity +assert np.allclose(fidelity(evolution_global.states[-1], target_super), 1 - res_goat_global.infidelity, atol=1e-3) ``` ```python qt.about() -``` - +``` \ No newline at end of file diff --git a/tests/interactive/GOAT_state_closed.md b/tests/interactive/GOAT_state_closed.md index bbce5f2..e0316b4 100644 --- a/tests/interactive/GOAT_state_closed.md +++ b/tests/interactive/GOAT_state_closed.md @@ -5,14 +5,14 @@ jupyter: extension: .md format_name: markdown format_version: '1.3' - jupytext_version: 1.17.1 + jupytext_version: 1.17.2 kernelspec: display_name: Python 3 (ipykernel) language: python name: python3 --- -# GOAT algorithm for a 2 level system +# GOAT algorithm for a closed system (state transfer) ```python import matplotlib.pyplot as plt @@ -284,7 +284,7 @@ assert res_goat_time.infidelity < res_goat.infidelity assert np.allclose(np.abs(evolution_time.states[-1].overlap(target_state)), 1 - res_goat_time.infidelity, atol=1e-3) assert res_goat_global.infidelity < 0.001 -assert np.abs(evolution_global.states[-1].overlap(target_state)) > 1 - 0.001 +assert np.allclose(np.abs(evolution_global.states[-1].overlap(target_state)), 1 - res_goat_global.infidelity, atol=1e-3) ``` ```python diff --git a/tests/interactive/GOAT_state_open.md b/tests/interactive/GOAT_state_open.md index 77d77ec..e92e900 100644 --- a/tests/interactive/GOAT_state_open.md +++ b/tests/interactive/GOAT_state_open.md @@ -12,15 +12,22 @@ jupyter: name: python3 --- -# GOAT algorithm for a 2 level system - +# GOAT algorithm for an open system (state transfer) ```python import matplotlib.pyplot as plt import numpy as np -from qutip import (fidelity, liouvillian, ket2dm, Qobj, basis, sigmam) +from qutip import basis, ket2dm, liouvillian, sigmam, Qobj import qutip as qt from qutip_qoc import Objective, optimize_pulses + +def fidelity(dm, target_dm): + """ + Fidelity used for density matrices in qutip-qtrl and qutip-qoc + """ + + diff = dm - target_dm + return 1 - np.real(diff.overlap(diff) / target_dm.norm()) / 2 ``` ## Problem setup @@ -28,11 +35,8 @@ from qutip_qoc import Objective, optimize_pulses ```python # Energy levels -E1, E2 = 1.0, 2.0 +E1, E2 = 1.0, 2.0 -hbar = 1 -omega = 0.1 # energy splitting -delta = 1.0 # tunneling gamma = 0.1 # amplitude damping c_ops = [np.sqrt(gamma) * sigmam()] @@ -58,17 +62,16 @@ times = np.linspace(0, 2 * np.pi, 250) goat_guess = [1, 0.5] guess_pulse = goat_guess[0] * np.sin(goat_guess[1] * times) -H_result_guess = [Hd, [Hc, guess_pulse]] -evolution_guess = qt.mesolve(H_result_guess, initial_state, times, c_ops) +H_guess = [Hd, [Hc, guess_pulse]] +evolution_guess = qt.mesolve(H_guess, initial_state, times) -print('Fidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) +print('Fidelity: ', fidelity(evolution_guess.states[-1], target_state)) -plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution_guess.states], label="Overlap with initial state") -plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution_guess.states], label="Overlap with target state") -plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_guess.states], '--', label="Fidelity") -plt.legend() +plt.plot(times, [fidelity(state, initial_state) for state in evolution_guess.states], label="Overlap with initial state") +plt.plot(times, [fidelity(state, target_state) for state in evolution_guess.states], label="Overlap with target state") plt.title("Guess performance") plt.xlabel("Time") +plt.legend() plt.show() ``` @@ -80,7 +83,6 @@ plt.show() def sin(t, c): return c[0] * np.sin(c[1] * t) - # gradient def grad_sin(t, c, idx): if idx == 0: # w.r.t. c0 @@ -97,25 +99,24 @@ H = [Hd] + [[Hc, sin, {"grad": grad_sin}]] ```python -alg_args = { - "alg": "GOAT", - "fid_err_targ": 0.01, -} -ctrl_params = { - id: {"guess": goat_guess, "bounds": [(-10, 10), (0, 2*np.pi)]} # c0 and c1 +control_params = { + "ctrl_x": {"guess": goat_guess, "bounds": [(-3, 3), (0, 2 * np.pi)]} # c0 and c1 } # run the optimization res_goat = optimize_pulses( objectives = Objective(initial_state, H, target_state), - control_parameters = ctrl_params, + control_parameters = control_params, tlist = times, - algorithm_kwargs = alg_args, + algorithm_kwargs = { + "alg": "GOAT", + "fid_err_targ": 0.01 + }, ) print('Infidelity: ', res_goat.infidelity) -plt.plot(times, sin(times, goat_guess), 'k--', label='initial guess') +plt.plot(times, guess_pulse, label='initial guess') plt.plot(times, res_goat.optimized_controls[0], label='optimized pulse') plt.title('GOAT pulses') plt.xlabel('Time') @@ -125,24 +126,26 @@ plt.show() ``` ```python -H_result = [Hd] + [[Hc, np.array(res_goat.optimized_controls[0])]] -evolution = qt.mesolve(H_result, initial_state, times, c_ops) +H_result = [Hd, [Hc, np.array(res_goat.optimized_controls[0])]] +evolution = qt.mesolve(H_result, initial_state, times) + +plt.plot(times, [fidelity(state, initial_state) for state in evolution.states], label="Overlap with initial state") +plt.plot(times, [fidelity(state, target_state) for state in evolution.states], label="Overlap with target state") -plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution.states], label="Overlap with initial state") -plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution.states], label="Overlap with target state") -plt.plot(times, [qt.fidelity(state, target_state) for state in evolution.states], '--', label="Fidelity") plt.title("GOAT performance") plt.xlabel("Time") -plt.ylim(0, 1) plt.legend() plt.show() ``` +The desired fidelity is not reached. + + ### b) optimized over time ```python # treats time as optimization variable -ctrl_params["__time__"] = { +control_params["__time__"] = { "guess": times[len(times) // 2], "bounds": [times[0], times[-1]], } @@ -150,20 +153,24 @@ ctrl_params["__time__"] = { # run the optimization res_goat_time = optimize_pulses( objectives = Objective(initial_state, H, target_state), - control_parameters = ctrl_params, + control_parameters = control_params, tlist = times, - algorithm_kwargs = alg_args, + algorithm_kwargs = { + "alg": "GOAT", + "fid_err_targ": 0.01 + }, ) -opt_time = res_goat_time.optimized_params[-1] +opt_time = res_goat_time.optimized_params[-1][0] time_range = times < opt_time print('Infidelity: ', res_goat_time.infidelity) -print('optimized time: ', res_goat_time.optimized_params[-1]) +print('Optimized time: ', opt_time) +plt.plot(times, guess_pulse, label='initial guess') plt.plot(times, res_goat.optimized_controls[0], label='optimized pulse') plt.plot(times[time_range], np.array(res_goat_time.optimized_controls[0])[time_range], label='optimized (over time) pulse') -plt.title('GOAT pulses') +plt.title('GOAT pulses (time optimization)') plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() @@ -175,48 +182,47 @@ times2 = times[time_range] if opt_time not in times2: times2 = np.append(times2, opt_time) -H_result_time = [Hd] + [[Hc, np.array(res_goat_time.optimized_controls[0])]] -evolution_time = qt.mesolve(H_result_time, initial_state, times) +H_result = qt.QobjEvo([Hd, [Hc, np.array(res_goat_time.optimized_controls[0])]], tlist=times) +evolution_time = qt.mesolve(H_result, initial_state, times2) + +plt.plot(times2, [fidelity(state, initial_state) for state in evolution_time.states], label="Overlap with initial state") +plt.plot(times2, [fidelity(state, target_state) for state in evolution_time.states], label="Overlap with target state") -plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution_time.states], label="Overlap with initial state") -plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution_time.states], label="Overlap with target state") -plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_time.states], '--', label="Fidelity") -plt.title('GOAT performance (optimized over time)') +plt.title('GOAT (optimized over time) performance') plt.xlabel('Time') -plt.xlim(0, res_goat_time.optimized_params[-1][0]) plt.legend() plt.show() ``` -### Global optimization +The desired fidelity is still not reached. -```python -alg_args = { - "alg": "GOAT", - "fid_err_targ": 0.01, -} -opt_args = { - "method": "basinhopping", - "max_iter": 100, -} +### c) global optimization +```python res_goat_global = optimize_pulses( objectives = Objective(initial_state, H, target_state), - control_parameters = ctrl_params, + control_parameters = control_params, tlist = times, - algorithm_kwargs = alg_args, - optimizer_kwargs = opt_args + algorithm_kwargs = { + "alg": "GOAT", + "fid_err_targ": 0.01 + }, + optimizer_kwargs={ + "method": "basinhopping", + "max_iter": 1000 + } ) -global_time = res_goat_global.optimized_params[-1] +global_time = res_goat_global.optimized_params[-1][0] global_range = times < global_time print('Infidelity: ', res_goat_global.infidelity) -print('optimized time: ', res_goat_global.optimized_params[-1]) +print('Optimized time: ', global_time) +plt.plot(times, guess_pulse, label='initial guess') plt.plot(times, res_goat.optimized_controls[0], label='optimized pulse') plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[0])[global_range], label='global optimized pulse') -plt.title('GOAT pulses') +plt.title('GOAT pulses (global)') plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() @@ -228,45 +234,42 @@ times3 = times[global_range] if global_time not in times3: times3 = np.append(times3, global_time) -H_result_global = [Hd, [Hc, np.array(res_goat_global.optimized_controls[0])]] -evolution_global = qt.mesolve(H_result_global, initial_state, times) +H_result = qt.QobjEvo([Hd, [Hc, np.array(res_goat_global.optimized_controls[0])]], tlist=times) +evolution_global = qt.mesolve(H_result, initial_state, times3) -plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution_global.states], label="Overlap with initial state") -plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution_global.states], label="Overlap with target state") -plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_global.states], '--', label="Fidelity") -plt.xlim(0, res_goat_global.optimized_params[-1][0]) +plt.plot(times3, [fidelity(state, initial_state) for state in evolution_global.states], label="Overlap with initial state") +plt.plot(times3, [fidelity(state, target_state) for state in evolution_global.states], label="Overlap with target state") -plt.title('GOAT performance (global)') +plt.title('GOAT (global) performance') plt.xlabel('Time') plt.legend() plt.show() ``` ## Comparison - ```python -plt.plot(times, guess_pulse, 'k--', label='initial guess') +plt.plot(times, guess_pulse, label='initial guess') plt.plot(times, res_goat.optimized_controls[0], label='optimized pulse') plt.plot(times[time_range], np.array(res_goat_time.optimized_controls[0])[time_range], label='optimized (over time) pulse') plt.plot(times[global_range], np.array(res_goat_global.optimized_controls[0])[global_range], label='global optimized pulse') plt.title('GOAT pulses') -plt.xlabel('time') +plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() plt.show() ``` ```python -print('Guess Fidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) -print('GOAT Infidelity: ', res_goat.infidelity) -print('Time Infidelity: ', res_goat_time.infidelity) -print('GLobal Infidelity: ', res_goat_global.infidelity) +print('Guess Fidelity: ', fidelity(evolution_guess.states[-1], target_state)) +print('GOAT Fidelity: ', 1 - res_goat.infidelity) +print('Time Fidelity: ', 1 - res_goat_time.infidelity) +print('GLobal Fidelity: ', 1 - res_goat_global.infidelity) plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_guess.states], 'k--', label="Guess") -plt.plot(times, [qt.fidelity(state, target_state) for state in evolution.states], label="Goat") -plt.plot(times[time_range], [qt.fidelity(state, target_state) for state in evolution_time.states[:len(times[time_range])]], label="Time") -plt.plot(times[global_range], [qt.fidelity(state, target_state) for state in evolution_global.states[:len(times[global_range])]], label="Global") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution.states], label="GOAT") +plt.plot(times2, [qt.fidelity(state, target_state) for state in evolution_time.states], label="Time") +plt.plot(times3, [qt.fidelity(state, target_state) for state in evolution_global.states], label="Global") -plt.title('Fidelities') +plt.title('GOAT Fidelities') plt.xlabel('Time') plt.legend() plt.show() @@ -276,13 +279,20 @@ plt.show() ```python -assert res_goat.infidelity < 0.1 -assert res_goat_time.infidelity < 0.01 +guess_fidelity = fidelity(evolution_guess.states[-1], target_state) + +# target fidelity not reached in part a), check that it is better than the guess +assert 1 - res_goat.infidelity > guess_fidelity +assert np.allclose(fidelity(evolution.states[-1], target_state), 1 - res_goat.infidelity, atol=1e-3) + +# target fidelity not reached in part b), check that it is better than part a) +assert res_goat_time.infidelity < res_goat.infidelity +assert np.allclose(fidelity(evolution_time.states[-1], target_state), 1 - res_goat_time.infidelity, atol=1e-3) + assert res_goat_global.infidelity < 0.01 +assert np.allclose(fidelity(evolution_global.states[-1], target_state), 1 - res_goat_global.infidelity, atol=1e-3) ``` - ```python qt.about() -``` - +``` \ No newline at end of file diff --git a/tests/interactive/GRAPE_gate_closed.md b/tests/interactive/GRAPE_gate_closed.md index bb9b145..43d5d5c 100644 --- a/tests/interactive/GRAPE_gate_closed.md +++ b/tests/interactive/GRAPE_gate_closed.md @@ -5,14 +5,14 @@ jupyter: extension: .md format_name: markdown format_version: '1.3' - jupytext_version: 1.17.1 + jupytext_version: 1.17.2 kernelspec: display_name: Python 3 (ipykernel) language: python name: python3 --- -# GRAPE algorithm for a closed system +# GRAPE algorithm for a closed system (gate synthesis) ```python import matplotlib.pyplot as plt @@ -69,9 +69,9 @@ plt.show() ```python control_params = { - "ctrl_x": {"guess": np.sin(times), "bounds": [-1, 1]}, - "ctrl_y": {"guess": np.cos(times), "bounds": [-1, 1]}, - "ctrl_z": {"guess": np.tanh(times), "bounds": [-1, 1]}, + "ctrl_x": {"guess": guess_pulse_x, "bounds": [-1, 1]}, + "ctrl_y": {"guess": guess_pulse_y, "bounds": [-1, 1]}, + "ctrl_z": {"guess": guess_pulse_z, "bounds": [-1, 1]}, } res_grape = optimize_pulses( @@ -100,7 +100,10 @@ plt.show() ``` ```python -H_result = [Hd, [Hc[0], res_grape.optimized_controls[0]], [Hc[1], res_grape.optimized_controls[1]], [Hc[2], res_grape.optimized_controls[2]]] +H_result = [Hd, + [Hc[0], np.array(res_grape.optimized_controls[0])], + [Hc[1], np.array(res_grape.optimized_controls[1])], + [Hc[2], np.array(res_grape.optimized_controls[2])]] evolution = qt.sesolve(H_result, initial_gate, times) plt.plot(times, [fidelity(gate, initial_gate) for gate in evolution.states], label="Overlap with initial gate") @@ -116,7 +119,7 @@ plt.show() ```python assert res_grape.infidelity < 0.001 -assert fidelity(evolution.states[-1], target_gate) > 1-0.001 +assert np.allclose(fidelity(evolution.states[-1], target_gate), 1 - res_grape.infidelity, atol=1e-3) ``` ```python diff --git a/tests/interactive/GRAPE_gate_open.md b/tests/interactive/GRAPE_gate_open.md index 3c7b566..50e3807 100644 --- a/tests/interactive/GRAPE_gate_open.md +++ b/tests/interactive/GRAPE_gate_open.md @@ -12,38 +12,39 @@ jupyter: name: python3 --- -# GRAPE algorithm for 2 level system - +# GRAPE algorithm for an open system (gate synthesis) ```python import matplotlib.pyplot as plt import numpy as np -from qutip import (about, Qobj, gates, liouvillian, fidelity,basis, qeye, sigmam, sigmax, sigmay, sigmaz, tensor) +from qutip import gates, qeye, liouvillian, sigmam, sigmax, sigmay, sigmaz import qutip as qt from qutip_qoc import Objective, optimize_pulses + +def fidelity(gate_super, target_super): + gate_oper = qt.Qobj(gate_super.data) + target_oper = qt.Qobj(target_super.data) + + return np.abs(gate_oper.overlap(target_oper) / target_oper.norm()) ``` ## Problem setup ```python -hbar = 1 omega = 0.1 # energy splitting -delta = 1.0 # tunneling gamma = 0.1 # amplitude damping sx, sy, sz = sigmax(), sigmay(), sigmaz() c_ops = [np.sqrt(gamma) * sigmam()] -Hd = 1 / 2 * hbar * omega * sz +Hd = 1 / 2 * omega * sz Hd = liouvillian(H=Hd, c_ops=c_ops) -Hc = sx Hc = [liouvillian(sx), liouvillian(sy), liouvillian(sz)] - H = [Hd, Hc[0], Hc[1], Hc[2]] # objective for optimization initial_gate = qeye(2) -target_gate = Qobj(1 / np.sqrt(2) * np.array([[1, 1], [1, -1]])) +target_gate = gates.hadamard_transform() times = np.linspace(0, np.pi / 2, 250) ``` @@ -52,28 +53,22 @@ times = np.linspace(0, np.pi / 2, 250) ```python -grape_guess = np.sin(times) - -H_result_guess = [Hd, - [Hc[0], grape_guess], - [Hc[1], grape_guess], - [Hc[2], grape_guess]] - -identity_op = qt.qeye(2) -identity_super = qt.spre(identity_op) +guess_pulse_x = np.sin(times) +guess_pulse_y = np.cos(times) +guess_pulse_z = np.tanh(times) -evolution_guess = qt.mesolve(H_result_guess, identity_super, times) - -target_super = qt.to_super(target_gate) initial_super = qt.to_super(initial_gate) +target_super = qt.to_super(target_gate) -initial_overlaps_guess = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution_guess.states] -target_overlaps_guess = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution_guess.states] +H_guess = [Hd, [Hc[0], guess_pulse_x], [Hc[1], guess_pulse_y], [Hc[2], guess_pulse_z]] +evolution_guess = qt.mesolve(H_guess, initial_super, times) -plt.plot(times, initial_overlaps_guess, label="Overlap with initial gate") -plt.plot(times, target_overlaps_guess, label="Overlap with target gate") +print('Fidelity: ', fidelity(evolution_guess.states[-1], target_super)) + +plt.plot(times, [fidelity(gate, initial_super) for gate in evolution_guess.states], label="Overlap with initial gate") +plt.plot(times, [fidelity(gate, target_super) for gate in evolution_guess.states], label="Overlap with target gate") plt.title("Guess performance") -plt.xlabel("Time") +plt.xlabel('Time') plt.legend() plt.show() ``` @@ -82,24 +77,29 @@ plt.show() ```python control_params = { - "ctrl_x": {"guess": np.sin(times), "bounds": [-1, 1]}, - "ctrl_y": {"guess": np.cos(times), "bounds": [-1, 1]}, - "ctrl_z": {"guess": np.tanh(times), "bounds": [-1, 1]}, + "ctrl_x": {"guess": guess_pulse_x, "bounds": [-1, 1]}, + "ctrl_y": {"guess": guess_pulse_y, "bounds": [-1, 1]}, + "ctrl_z": {"guess": guess_pulse_z, "bounds": [-1, 1]}, } -alg_args = {"alg": "GRAPE", "fid_err_targ": 0.01} res_grape = optimize_pulses( - objectives=Objective(initial_gate, H, target_gate), - control_parameters=control_params, - tlist=times, - algorithm_kwargs=alg_args, + objectives = Objective(initial_gate, H, target_gate), + control_parameters = control_params, + tlist = times, + algorithm_kwargs = { + "alg": "GRAPE", + "fid_err_targ": 0.01 + }, ) print('Infidelity: ', res_grape.infidelity) -plt.plot(times, res_grape.optimized_controls[0], label='optimized pulse sx') -plt.plot(times, res_grape.optimized_controls[1], label='optimized pulse sy') -plt.plot(times, res_grape.optimized_controls[2], label='optimized pulse sz') +plt.plot(times, guess_pulse_x, 'b--', label='guess pulse sx') +plt.plot(times, res_grape.optimized_controls[0], 'b', label='optimized pulse sx') +plt.plot(times, guess_pulse_y, 'g--', label='guess pulse sy') +plt.plot(times, res_grape.optimized_controls[1], 'g', label='optimized pulse sy') +plt.plot(times, guess_pulse_z, 'r--', label='guess pulse sz') +plt.plot(times, res_grape.optimized_controls[2], 'r', label='optimized pulse sz') plt.title('GRAPE pulses') plt.xlabel('Time') plt.ylabel('Pulse amplitude') @@ -109,26 +109,16 @@ plt.show() ```python H_result = [Hd, - [Hc[0], res_grape.optimized_controls[0]], - [Hc[1], res_grape.optimized_controls[1]], - [Hc[2], res_grape.optimized_controls[2]]] + [Hc[0], np.array(res_grape.optimized_controls[0])], + [Hc[1], np.array(res_grape.optimized_controls[1])], + [Hc[2], np.array(res_grape.optimized_controls[2])]] +evolution = qt.mesolve(H_result, initial_super, times) +plt.plot(times, [fidelity(gate, initial_super) for gate in evolution.states], label="Overlap with initial gate") +plt.plot(times, [fidelity(gate, target_super) for gate in evolution.states], label="Overlap with target gate") -identity_op = qt.qeye(2) -identity_super = qt.spre(identity_op) - -evolution = qt.mesolve(H_result, identity_super, times) - -target_super = qt.to_super(target_gate) -initial_super = qt.to_super(initial_gate) - -initial_overlaps = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution.states] -target_overlaps = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution.states] - -plt.plot(times, initial_overlaps, label="Overlap with initial gate") -plt.plot(times, target_overlaps, label="Overlap with target gate") -plt.title("GRAPE performance") -plt.xlabel("Time") +plt.title('GRAPE performance') +plt.xlabel('Time') plt.legend() plt.show() ``` @@ -137,10 +127,10 @@ plt.show() ```python assert res_grape.infidelity < 0.01 +assert np.allclose(fidelity(evolution.states[-1], target_super), 1 - res_grape.infidelity, atol=1e-3) ``` ```python qt.about() -``` - +``` \ No newline at end of file diff --git a/tests/interactive/GRAPE_state_closed.md b/tests/interactive/GRAPE_state_closed.md index 2681df7..7893a17 100644 --- a/tests/interactive/GRAPE_state_closed.md +++ b/tests/interactive/GRAPE_state_closed.md @@ -5,14 +5,14 @@ jupyter: extension: .md format_name: markdown format_version: '1.3' - jupytext_version: 1.17.1 + jupytext_version: 1.17.2 kernelspec: display_name: Python 3 (ipykernel) language: python name: python3 --- -# GRAPE algorithm for 2 level system +# GRAPE algorithm for a closed system (state transfer) ```python import matplotlib.pyplot as plt @@ -106,7 +106,7 @@ plt.show() ```python assert res_grape.infidelity < 0.01 -assert np.abs(evolution.states[-1].overlap(target_state)) > 1-0.01 +assert np.allclose(np.abs(evolution.states[-1].overlap(target_state)), 1 - res_grape.infidelity, atol=1e-3) ``` ```python diff --git a/tests/interactive/GRAPE_state_open.md b/tests/interactive/GRAPE_state_open.md index afa2ab2..c9b05dd 100644 --- a/tests/interactive/GRAPE_state_open.md +++ b/tests/interactive/GRAPE_state_open.md @@ -12,8 +12,7 @@ jupyter: name: python3 --- -# GRAPE algorithm for 2 level system - +# GRAPE algorithm for an open system (state transfer) ```python import matplotlib.pyplot as plt @@ -22,12 +21,13 @@ from qutip import basis, ket2dm, liouvillian, sigmam, Qobj import qutip as qt from qutip_qoc import Objective, optimize_pulses -def fidelity(state, target_state): +def fidelity(dm, target_dm): """ Fidelity used for density matrices in qutip-qtrl and qutip-qoc """ - diff = state - target_state - return 1 - np.real(diff.overlap(diff)) / (2 * target_state.norm()) + + diff = dm - target_dm + return 1 - np.real(diff.overlap(diff) / target_dm.norm()) / 2 ``` ## Problem setup @@ -36,19 +36,18 @@ def fidelity(state, target_state): ```python # Energy levels E1, E2 = 1.0, 2.0 -Hd = Qobj(np.diag([E1, E2])) gamma = 0.1 # amplitude damping c_ops = [np.sqrt(gamma) * sigmam()] +Hd = Qobj(np.diag([E1, E2])) +Hd = liouvillian(H=Hd, c_ops=c_ops) Hc = Qobj(np.array([ [0, 1], [1, 0] -])) - -Ld = liouvillian(H=Hd, c_ops=c_ops) -Lc = liouvillian(Hc) -L = [Ld, Lc] +])) +Hc = liouvillian(Hc) +H = [Hd, Hc] initial_state = ket2dm(basis(2, 0)) target_state = ket2dm(basis(2, 1)) @@ -62,16 +61,16 @@ times = np.linspace(0, 2 * np.pi, 250) ```python guess_pulse = np.sin(times) -L_guess = [Ld, [Lc, guess_pulse]] -evolution_guess = qt.mesolve(L_guess, initial_state, times) +H_guess = [Hd, [Hc, guess_pulse]] +evolution_guess = qt.mesolve(H_guess, initial_state, times) print('Fidelity: ', fidelity(evolution_guess.states[-1], target_state)) plt.plot(times, [fidelity(state, initial_state) for state in evolution_guess.states], label="Overlap with initial state") plt.plot(times, [fidelity(state, target_state) for state in evolution_guess.states], label="Overlap with target state") -plt.legend() plt.title("Guess performance") plt.xlabel("Time") +plt.legend() plt.show() ``` @@ -84,20 +83,19 @@ control_params = { } res_grape = optimize_pulses( - objectives = Objective(initial_state, L, target_state), + objectives = Objective(initial_state, H, target_state), control_parameters = control_params, tlist = times, algorithm_kwargs = { "alg": "GRAPE", - "fid_err_targ": 0.001, + "fid_err_targ": 0.01, }, ) print('Infidelity: ', res_grape.infidelity) -control_step_function = qt.coefficient(res_grape.optimized_controls[0], tlist=times, order=0) plt.plot(times, guess_pulse, label='initial guess') -plt.plot(times, [control_step_function(t) for t in times], label='optimized pulse') +plt.plot(times, res_grape.optimized_controls[0], label='optimized pulse') plt.title('GRAPE pulses') plt.xlabel('Time') plt.ylabel('Pulse amplitude') @@ -106,38 +104,28 @@ plt.show() ``` ```python -L_result = [Ld, [Lc, control_step_function]] -evolution = qt.mesolve(L_result, initial_state, times) +control_step_function = qt.coefficient(res_grape.optimized_controls[0], tlist=times, order=0) +H_result = [Hd, [Hc, control_step_function]] -plt.plot(times, [fidelity(state, initial_state) for state in evolution.states], label="Overlap with initial state") -plt.plot(times, [fidelity(state, target_state) for state in evolution.states], label="Overlap with target state") +fine_times = np.linspace(0, times[-1], len(times) * 25) +evolution = qt.mesolve(H_result, initial_state, fine_times) + +plt.plot(fine_times, [fidelity(state, initial_state) for state in evolution.states], label="Overlap with initial state") +plt.plot(fine_times, [fidelity(state, target_state) for state in evolution.states], label="Overlap with target state") plt.title("GRAPE performance") plt.xlabel('Time') plt.legend() plt.show() - -print(1 - fidelity(evolution.states[-1], target_state)) -``` -```python -state = initial_state -dt = times[1] - times[0] - -for c in res_grape.optimized_controls[0][:-1]: - propagator = ((Ld + c * Lc) * dt).expm() - state = propagator(state) - -print(1 - fidelity(state, target_state)) ``` - ## Validation ```python -assert res_grape.infidelity < 0.001 -assert fidelity(evolution.states[-1], target_state) > 1-0.001 +assert res_grape.infidelity < 0.01 +assert np.allclose(fidelity(evolution.states[-1], target_state), 1 - res_grape.infidelity, atol=1e-3) ``` ```python qt.about() -``` \ No newline at end of file +``` diff --git a/tests/interactive/JOPT_gate_closed.md b/tests/interactive/JOPT_gate_closed.md index 1f3370c..dd3b335 100644 --- a/tests/interactive/JOPT_gate_closed.md +++ b/tests/interactive/JOPT_gate_closed.md @@ -5,14 +5,14 @@ jupyter: extension: .md format_name: markdown format_version: '1.3' - jupytext_version: 1.17.1 + jupytext_version: 1.17.2 kernelspec: display_name: Python 3 (ipykernel) language: python name: python3 --- -# JOPT algorithm for a closed system +# JOPT algorithm for a closed system (gate synthesis) ```python import matplotlib.pyplot as plt @@ -190,7 +190,7 @@ plt.legend() plt.show() ``` -## Global optimization +### c) global optimization ```python res_jopt_global = optimize_pulses( @@ -269,13 +269,13 @@ plt.show() ```python assert res_jopt.infidelity < 0.001 -assert fidelity(evolution.states[-1], target_gate) > 1-0.001 +assert np.allclose(fidelity(evolution.states[-1], target_gate), 1 - res_jopt.infidelity, atol=1e-3) assert res_jopt_time.infidelity < 0.001 -assert fidelity(evolution_time.states[-1], target_gate) > 1-0.001 +assert np.allclose(fidelity(evolution_time.states[-1], target_gate), 1 - res_jopt_time.infidelity, atol=1e-3) assert res_jopt_global.infidelity < 0.001 -assert fidelity(evolution_global.states[-1], target_gate) > 1-0.001 +assert np.allclose(fidelity(evolution_global.states[-1], target_gate), 1 - res_jopt_global.infidelity, atol=1e-3) ``` ```python diff --git a/tests/interactive/JOPT_gate_open.md b/tests/interactive/JOPT_gate_open.md index ce492a9..4a886e1 100644 --- a/tests/interactive/JOPT_gate_open.md +++ b/tests/interactive/JOPT_gate_open.md @@ -12,13 +12,12 @@ jupyter: name: python3 --- -# JOPT algorithm - +# JOPT algorithm for an open system (gate synthesis) ```python import matplotlib.pyplot as plt import numpy as np -from qutip import (about, Qobj, gates, liouvillian, qeye, sigmam, sigmax, sigmay, sigmaz, fidelity) +from qutip import gates, qeye, liouvillian, sigmam, sigmax, sigmay, sigmaz import qutip as qt from qutip_qoc import Objective, optimize_pulses @@ -27,27 +26,31 @@ try: except ImportError: # JAX not available, skip test import pytest pytest.skip("JAX not available") + +def fidelity(gate_super, target_super): + gate_oper = qt.Qobj(gate_super.data) + target_oper = qt.Qobj(target_super.data) + + return np.abs(gate_oper.overlap(target_oper) / target_oper.norm()) ``` ## Problem setup ```python -hbar = 1 omega = 0.1 # energy splitting -delta = 1.0 # tunneling gamma = 0.1 # amplitude damping sx, sy, sz = sigmax(), sigmay(), sigmaz() +c_ops = [np.sqrt(gamma) * sigmam()] -Hd = 1 / 2 * hbar * omega * sz -Hd = liouvillian(H=Hd, c_ops=[np.sqrt(gamma) * sigmam()]) +Hd = 1 / 2 * omega * sz +Hd = liouvillian(H=Hd, c_ops=c_ops) Hc = [liouvillian(sx), liouvillian(sy), liouvillian(sz)] - H = [Hd, Hc[0], Hc[1], Hc[2]] # objective for optimization initial_gate = qeye(2) -target_gate = Qobj(1 / np.sqrt(2) * np.array([[1, 1], [1, -1]])) +target_gate = gates.hadamard_transform() times = np.linspace(0, np.pi / 2, 250) ``` @@ -58,34 +61,22 @@ times = np.linspace(0, np.pi / 2, 250) ```python jopt_guess = [1, 1] guess_pulse = jopt_guess[0] * np.sin(jopt_guess[1] * times) -``` - - -```python -H_result_guess = [Hd, - [Hc[0], guess_pulse], - [Hc[1], guess_pulse], - [Hc[2], guess_pulse]] - -identity_op = qt.qeye(2) -identity_super = qt.spre(identity_op) - -evolution_guess = qt.mesolve(H_result_guess, identity_super, times) -target_super = qt.to_super(target_gate) initial_super = qt.to_super(initial_gate) +target_super = qt.to_super(target_gate) -initial_overlaps_guess = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution_guess.states] -target_overlaps_guess = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution_guess.states] +H_guess = [Hd] + [[hc, guess_pulse] for hc in Hc] +evolution_guess = qt.mesolve(H_guess, initial_super, times) -plt.plot(times, initial_overlaps_guess, label="Overlap with initial gate") -plt.plot(times, target_overlaps_guess, label="Overlap with target gate") +plt.plot(times, [fidelity(gate, initial_super) for gate in evolution_guess.states], label="Overlap with initial gate") +plt.plot(times, [fidelity(gate, target_super) for gate in evolution_guess.states], label="Overlap with target gate") plt.title("Guess performance") -plt.xlabel("Time") +plt.xlabel('Time') plt.legend() plt.show() ``` + ## JOPT algorithm @@ -102,30 +93,27 @@ H = [Hd] + [[hc, sin_x, {"grad": sin_x}] for hc in Hc] ```python -ctrl_parameters = { - id: {"guess": jopt_guess, "bounds": [(-1, 1), (0, 2 * np.pi)]} # c0 and c1 +control_params = { + id: {"guess": jopt_guess, "bounds": [(-1, 1), (0, 2 * np.pi)]} # c0 and c1 for id in ['x', 'y', 'z'] } -alg_args = { - "alg": "JOPT", - "fid_err_targ": 0.01, -} +# run the optimization res_jopt = optimize_pulses( - objectives=Objective(initial_gate, H, target_gate), - control_parameters=ctrl_parameters, - tlist=times, - minimizer_kwargs={ - "method": "Nelder-Mead", + objectives = Objective(initial_gate, H, target_gate), + control_parameters = control_params, + tlist = times, + algorithm_kwargs = { + "alg": "JOPT", + "fid_err_targ": 0.001, }, - algorithm_kwargs=alg_args, ) print('Infidelity: ', res_jopt.infidelity) -plt.plot(times, res_jopt.optimized_controls[0], label='optimized pulse') -plt.plot(times, res_jopt.optimized_controls[1], label='optimized pulse') -plt.plot(times, res_jopt.optimized_controls[2], label='optimized pulse') +plt.plot(times, res_jopt.optimized_controls[0], 'b', label='optimized pulse sx') +plt.plot(times, res_jopt.optimized_controls[1], 'g', label='optimized pulse sy') +plt.plot(times, res_jopt.optimized_controls[2], 'r', label='optimized pulse sz') plt.title('JOPT pulses') plt.xlabel('Time') plt.ylabel('Pulse amplitude') @@ -139,20 +127,11 @@ H_result = [Hd, [Hc[0], np.array(res_jopt.optimized_controls[0])], [Hc[1], np.array(res_jopt.optimized_controls[1])], [Hc[2], np.array(res_jopt.optimized_controls[2])]] +evolution = qt.mesolve(H_result, initial_super, times) -identity_op = qt.qeye(2) -identity_super = qt.spre(identity_op) - -evolution = qt.mesolve(H_result, identity_super, times) - -target_super = qt.to_super(target_gate) -initial_super = qt.to_super(initial_gate) - -initial_overlaps = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution.states] -target_overlaps = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution.states] +plt.plot(times, [fidelity(gate, initial_super) for gate in evolution.states], label="Overlap with initial gate") +plt.plot(times, [fidelity(gate, target_super) for gate in evolution.states], label="Overlap with target gate") -plt.plot(times, initial_overlaps, label="Overlap with initial gate") -plt.plot(times, target_overlaps, label="Overlap with target gate") plt.title("JOPT performance") plt.xlabel("Time") plt.legend() @@ -164,36 +143,33 @@ plt.show() ```python # treats time as optimization variable -ctrl_parameters["__time__"] = { +control_params["__time__"] = { "guess": times[len(times) // 2], "bounds": [times[0], times[-1]], } -alg_args = { - "alg": "JOPT", - "fid_err_targ": 0.01, -} # run the optimization res_jopt_time = optimize_pulses( - objectives=Objective(initial_gate, H, target_gate), - control_parameters=ctrl_parameters, - tlist=times, - minimizer_kwargs={ - "method": "Nelder-Mead", + objectives = Objective(initial_gate, H, target_gate), + control_parameters = control_params, + tlist = times, + algorithm_kwargs = { + "alg": "JOPT", + "fid_err_targ": 0.001, }, - algorithm_kwargs=alg_args, ) -print('Infidelity: ', res_jopt_time.infidelity) -print('Time: ', times[-1]) -print('optimized time: ', res_jopt_time.optimized_params[-1]) +opt_time = res_jopt_time.optimized_params[-1][0] +time_range = times < opt_time -time_range = times < res_jopt_time.optimized_params[-1] +print('Infidelity: ', res_jopt_time.infidelity) +print('Optimized time: ', opt_time) -plt.plot(times[time_range], np.array(res_jopt_time.optimized_controls[0])[time_range], label='Optimized (over time) pulse sx') -plt.plot(times[time_range], np.array(res_jopt_time.optimized_controls[1])[time_range], label='Optimized (over time) pulse sy') -plt.plot(times[time_range], np.array(res_jopt_time.optimized_controls[2])[time_range], label='Optimized (over time) pulse sz') -plt.title('JOPT pulses') +plt.plot(times, guess_pulse, 'k--', label='guess pulse sx, sy, sz') +plt.plot(times[time_range], np.array(res_jopt_time.optimized_controls[0])[time_range], 'b', label='optimized pulse sx') +plt.plot(times[time_range], np.array(res_jopt_time.optimized_controls[1])[time_range], 'g', label='optimized pulse sy') +plt.plot(times[time_range], np.array(res_jopt_time.optimized_controls[2])[time_range], 'r', label='optimized pulse sz') +plt.title('JOPT pulses (time optimization)') plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() @@ -202,61 +178,53 @@ plt.show() ```python -H_result_time = [Hd, - [Hc[0], np.array(res_jopt_time.optimized_controls[0])], - [Hc[1], np.array(res_jopt_time.optimized_controls[1])], - [Hc[2], np.array(res_jopt_time.optimized_controls[2])]] - - -identity_op = qt.qeye(2) -identity_super = qt.spre(identity_op) +times2 = times[time_range] +if opt_time not in times2: + times2 = np.append(times2, opt_time) -evolution_time = qt.mesolve(H_result_time, identity_super, times) - -target_super = qt.to_super(target_gate) -initial_super = qt.to_super(initial_gate) +H_result = qt.QobjEvo( + [Hd, [Hc[0], np.array(res_jopt_time.optimized_controls[0])], + [Hc[1], np.array(res_jopt_time.optimized_controls[1])], + [Hc[2], np.array(res_jopt_time.optimized_controls[2])]], tlist=times) +evolution_time = qt.mesolve(H_result, initial_super, times2) -initial_overlaps_time = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution_time.states] -target_overlaps_time = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution_time.states] +plt.plot(times2, [fidelity(gate, initial_super) for gate in evolution_time.states], label="Overlap with initial gate") +plt.plot(times2, [fidelity(gate, target_super) for gate in evolution_time.states], label="Overlap with target gate") -plt.plot(times, initial_overlaps_time, label="Overlap with initial gate") -plt.plot(times, target_overlaps_time, label="Overlap with target gate") -plt.title("JOPT performance (optimized over time)") +plt.title('JOPT (optimized over time) performance') plt.xlabel("Time") plt.legend() plt.show() ``` -## Global optimization - +### c) global optimization ```python -alg_args = { - "alg": "JOPT", - "fid_err_targ": 0.001, -} -opt_args = { - "method": "basinhopping", - "max_iter": 1000, -} - res_jopt_global = optimize_pulses( - objectives=Objective(initial_gate, H, target_gate), - control_parameters=ctrl_parameters, - tlist=times, - algorithm_kwargs=alg_args, - optimizer_kwargs=opt_args + objectives = Objective(initial_gate, H, target_gate), + control_parameters = control_params, + tlist = times, + algorithm_kwargs = { + "alg": "JOPT", + "fid_err_targ": 0.001, + }, + optimizer_kwargs = { + "method": "basinhopping", + "max_iter": 100, + } ) -print('Infidelity: ', res_jopt_global.infidelity) -print('optimized time: ', res_jopt_global.optimized_params[-1]) +global_time = res_jopt_global.optimized_params[-1][0] +global_range = times < global_time -global_range = times < res_jopt_global.optimized_params[-1] +print('Infidelity: ', res_jopt_global.infidelity) +print('Optimized time: ', global_time) -plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[0])[global_range], label='Global optimized pulse sx') -plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[1])[global_range], label='Global optimized pulse sy') -plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[2])[global_range], label='Global optimized pulse sz') -plt.title('JOPT pulses') +plt.plot(times, guess_pulse, 'k--', label='guess pulse sx, sy, sz') +plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[0])[global_range], 'b', label='optimized pulse sx') +plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[1])[global_range], 'g', label='optimized pulse sy') +plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[2])[global_range], 'r', label='optimized pulse sz') +plt.title('JOPT pulses (global optimization)') plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() @@ -265,27 +233,21 @@ plt.show() ```python -H_result_global = [Hd, - [Hc[0], np.array(res_jopt_time.optimized_controls[0])], - [Hc[1], np.array(res_jopt_time.optimized_controls[1])], - [Hc[2], np.array(res_jopt_time.optimized_controls[2])]] - +times3 = times[global_range] +if global_time not in times3: + times3 = np.append(times3, global_time) -identity_op = qt.qeye(2) -identity_super = qt.spre(identity_op) - -evolution_global = qt.mesolve(H_result, identity_super, times) - -target_super = qt.to_super(target_gate) -initial_super = qt.to_super(initial_gate) +H_result = qt.QobjEvo( + [Hd, [Hc[0], np.array(res_jopt_global.optimized_controls[0])], + [Hc[1], np.array(res_jopt_global.optimized_controls[1])], + [Hc[2], np.array(res_jopt_global.optimized_controls[2])]], tlist=times) +evolution_global = qt.mesolve(H_result, initial_super, times3) -initial_overlaps_global = [np.abs((prop.dag() * initial_super).tr()) / (prop.norm() ) for prop in evolution_global.states] -target_overlaps_global = [np.abs((prop.dag() * target_super).tr()) / (prop.norm() ) for prop in evolution_global.states] +plt.plot(times3, [fidelity(gate, initial_super) for gate in evolution_global.states], label="Overlap with initial gate") +plt.plot(times3, [fidelity(gate, target_super) for gate in evolution_global.states], label="Overlap with target gate") -plt.plot(times, initial_overlaps_global, label="Overlap with initial gate") -plt.plot(times, target_overlaps_global, label="Overlap with target gate") -plt.title("JOPT performance (global)") -plt.xlabel("Time") +plt.title('JOPT (global optimization) performance') +plt.xlabel('Time') plt.legend() plt.show() ``` @@ -296,14 +258,13 @@ plt.show() ```python fig, axes = plt.subplots(1, 3, figsize=(18, 4)) # 1 row, 3 columns -titles = ["JOPT s_x pulses", "JOPT s_y pulses", "JOPT s_z pulses"] +titles = ["JOPT sx pulses", "JOPT sy pulses", "JOPT sz pulses"] -for i in range(3): - ax = axes[i] - ax.plot(times, sin_x(times, jopt_guess), label='Initial guess') - ax.plot(times, res_jopt.optimized_controls[i], label='Optimized pulse') - ax.plot(times[time_range], np.array(res_jopt_time.optimized_controls[i])[time_range], label='Optimized (over time) pulse') - ax.plot(times[global_range], np.array(res_jopt_global.optimized_controls[i])[global_range], label='Global optimized pulse') +for i, ax in enumerate(axes): + ax.plot(times, guess_pulse, label='initial guess') + ax.plot(times, res_jopt.optimized_controls[i], label='optimized pulse') + ax.plot(times[time_range], np.array(res_jopt_time.optimized_controls[i])[time_range], label='optimized (over time) pulse') + ax.plot(times[global_range], np.array(res_jopt_global.optimized_controls[i])[global_range], label='global optimized pulse') ax.set_title(titles[i]) ax.set_xlabel('Time') ax.set_ylabel('Pulse amplitude') @@ -317,9 +278,18 @@ plt.show() ```python -assert res_jopt.infidelity < 0.001 -assert res_jopt_time.infidelity < 0.001 -assert res_jopt_global.infidelity < 0.001 +guess_fidelity = fidelity(evolution_guess.states[-1], target_super) + +# target fidelity not reached in part a), check that it is better than the guess +assert 1 - res_jopt.infidelity >= guess_fidelity +assert np.allclose(fidelity(evolution.states[-1], target_super), 1 - res_jopt.infidelity, atol=1e-3) + +# target fidelity not reached in part b), check that it is better than part a) +assert res_jopt_time.infidelity <= res_jopt.infidelity +assert np.allclose(fidelity(evolution_time.states[-1], target_super), 1 - res_jopt_time.infidelity, atol=1e-3) + +assert res_jopt_global.infidelity <= res_jopt_time.infidelity +assert np.allclose(fidelity(evolution_global.states[-1], target_super), 1 - res_jopt_global.infidelity, atol=1e-3) ``` diff --git a/tests/interactive/JOPT_state_closed.md b/tests/interactive/JOPT_state_closed.md index 11547cb..b440642 100644 --- a/tests/interactive/JOPT_state_closed.md +++ b/tests/interactive/JOPT_state_closed.md @@ -5,15 +5,14 @@ jupyter: extension: .md format_name: markdown format_version: '1.3' - jupytext_version: 1.17.1 + jupytext_version: 1.17.2 kernelspec: display_name: Python 3 (ipykernel) language: python name: python3 --- -# JOPT algorithm for a 2 level system - +# JOPT algorithm for a closed system (state transfer) ```python import matplotlib.pyplot as plt @@ -288,7 +287,7 @@ assert res_jopt_time.infidelity < res_jopt.infidelity assert np.allclose(np.abs(evolution_time.states[-1].overlap(target_state)), 1 - res_jopt_time.infidelity, atol=1e-3) assert res_jopt_global.infidelity < 0.001 -assert np.abs(evolution_global.states[-1].overlap(target_state)) > 1 - 0.001 +assert np.allclose(np.abs(evolution_global.states[-1].overlap(target_state)), 1 - res_jopt_global.infidelity, atol=1e-3) ``` ```python diff --git a/tests/interactive/JOPT_state_open.md b/tests/interactive/JOPT_state_open.md index 8c5d8d8..9392cbe 100644 --- a/tests/interactive/JOPT_state_open.md +++ b/tests/interactive/JOPT_state_open.md @@ -12,14 +12,12 @@ jupyter: name: python3 --- -# JOPT algorithm for a 2 level system - - +# JOPT algorithm for an open system (state transfer) ```python import matplotlib.pyplot as plt import numpy as np -from qutip import (about, fidelity, liouvillian, ket2dm, Qobj, basis, sigmam) +from qutip import basis, ket2dm, liouvillian, sigmam, Qobj import qutip as qt from qutip_qoc import Objective, optimize_pulses @@ -28,6 +26,14 @@ try: except ImportError: # JAX not available, skip test import pytest pytest.skip("JAX not available") + +def fidelity(dm, target_dm): + """ + Fidelity used for density matrices in qutip-qtrl and qutip-qoc + """ + + diff = dm - target_dm + return 1 - np.real(diff.overlap(diff) / target_dm.norm()) / 2 ``` ## Problem setup @@ -35,11 +41,8 @@ except ImportError: # JAX not available, skip test ```python # Energy levels -E1, E2 = 1.0, 2.0 +E1, E2 = 1.0, 2.0 -hbar = 1 -omega = 0.1 # energy splitting -delta = 1.0 # tunneling gamma = 0.1 # amplitude damping c_ops = [np.sqrt(gamma) * sigmam()] @@ -65,16 +68,16 @@ times = np.linspace(0, 2 * np.pi, 250) jopt_guess = [1, 0.5] guess_pulse = jopt_guess[0] * np.sin(jopt_guess[1] * times) -H_result_guess = [Hd, [Hc, guess_pulse]] -evolution_guess = qt.mesolve(H_result_guess, initial_state, times) +H_guess = [Hd, [Hc, guess_pulse]] +evolution_guess = qt.mesolve(H_guess, initial_state, times) -print('Fidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) +print('Fidelity: ', fidelity(evolution_guess.states[-1], target_state)) -plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution_guess.states], label="Initial Overlap") -plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution_guess.states], label="Target Overlap") -plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_guess.states], '--', label="Fidelity") -plt.legend() +plt.plot(times, [fidelity(state, initial_state) for state in evolution_guess.states], label="Overlap with initial state") +plt.plot(times, [fidelity(state, target_state) for state in evolution_guess.states], label="Overlap with target state") plt.title("Guess performance") +plt.xlabel("Time") +plt.legend() plt.show() ``` @@ -93,27 +96,24 @@ H = [Hd, [Hc, sin_x]] ```python -ctrl_parameters = { - id: {"guess": [1, 0], "bounds": [(-1, 1), (0, 2 * np.pi)]} # c0 and c1 -} -alg_args = { - "alg": "JOPT", - "fid_err_targ": 0.01, +control_params = { + "ctrl_x": {"guess": jopt_guess, "bounds": [(-3, 3), (0, 2 * np.pi)]} # c0 and c1 } +# run the optimization res_jopt = optimize_pulses( - objectives=Objective(initial_state, H, target_state), - control_parameters=ctrl_parameters, - tlist=times, - minimizer_kwargs={ - "method": "Nelder-Mead", + objectives = Objective(initial_state, H, target_state), + control_parameters = control_params, + tlist = times, + algorithm_kwargs = { + "alg": "JOPT", + "fid_err_targ": 0.01 }, - algorithm_kwargs=alg_args, ) print('Infidelity: ', res_jopt.infidelity) -plt.plot(times, sin_x(times, jopt_guess), label='initial guess') +plt.plot(times, guess_pulse, label='initial guess') plt.plot(times, res_jopt.optimized_controls[0], label='optimized pulse') plt.title('JOPT pulses') plt.xlabel('Time') @@ -124,13 +124,13 @@ plt.show() ```python H_result = [Hd, [Hc, np.array(res_jopt.optimized_controls[0])]] -evolution = qt.sesolve(H_result, initial_state, times) +evolution = qt.mesolve(H_result, initial_state, times) -plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution.states], label="Overlap with intiial state") -plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution.states], label="Overlap with target state") -plt.plot(times, [qt.fidelity(state, target_state) for state in evolution.states], '--', label="Fidelity") -plt.title('JOPT performance') -plt.xlabel('Time') +plt.plot(times, [fidelity(state, initial_state) for state in evolution.states], label="Overlap with initial state") +plt.plot(times, [fidelity(state, target_state) for state in evolution.states], label="Overlap with target state") + +plt.title("JOPT performance") +plt.xlabel("Time") plt.legend() plt.show() ``` @@ -139,80 +139,81 @@ plt.show() ```python # treats time as optimization variable -ctrl_parameters["__time__"] = { +control_params["__time__"] = { "guess": times[len(times) // 2], "bounds": [times[0], times[-1]], } -alg_args = { - "alg": "JOPT", - "fid_err_targ": 0.001, -} # run the optimization res_jopt_time = optimize_pulses( - objectives=Objective(initial_state, H, target_state), - control_parameters=ctrl_parameters, - tlist=times, - minimizer_kwargs={ - "method": "Nelder-Mead", - + objectives = Objective(initial_state, H, target_state), + control_parameters = control_params, + tlist = times, + algorithm_kwargs = { + "alg": "JOPT", + "fid_err_targ": 0.01 }, - algorithm_kwargs=alg_args, ) -print('Infidelity: ', res_jopt_time.infidelity) -print('optimized time: ', res_jopt_time.optimized_params[-1]) +opt_time = res_jopt_time.optimized_params[-1][0] +time_range = times < opt_time -time_range = times < res_jopt_time.optimized_params[-1] +print('Infidelity: ', res_jopt_time.infidelity) +print('Optimized time: ', opt_time) -plt.plot(times, res_jopt.optimized_controls[0], label='Optimized pulse') -plt.plot(times[time_range], np.array(res_jopt.optimized_controls[0])[time_range], label='Optimized (over time) pulse') -plt.title('JOPT pulses') +plt.plot(times, guess_pulse, label='initial guess') +plt.plot(times, res_jopt.optimized_controls[0], label='optimized pulse') +plt.plot(times[time_range], np.array(res_jopt_time.optimized_controls[0])[time_range], label='optimized (over time) pulse') +plt.title('JOPT pulses (time optimization)') plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() -plt.show() +plt.show() ``` ```python -H_result_time = [Hd, [Hc, np.array(res_jopt_time.optimized_controls[0])]] -evolution_time = qt.sesolve(H_result_time, initial_state, times) +times2 = times[time_range] +if opt_time not in times2: + times2 = np.append(times2, opt_time) + +H_result = qt.QobjEvo([Hd, [Hc, np.array(res_jopt_time.optimized_controls[0])]], tlist=times) +evolution_time = qt.mesolve(H_result, initial_state, times2) -plt.plot(times, [np.abs(state.overlap(initial_state)) for state in evolution_time.states], label="Overlap with initial state") -plt.plot(times, [np.abs(state.overlap(target_state)) for state in evolution_time.states], label="Overlap with target state") -plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_time.states], '--', label="Fidelity") -plt.title('JOPT performance (optimized over time)') +plt.plot(times2, [fidelity(state, initial_state) for state in evolution_time.states], label="Overlap with initial state") +plt.plot(times2, [fidelity(state, target_state) for state in evolution_time.states], label="Overlap with target state") + +plt.title('JOPT (optimized over time) performance') plt.xlabel('Time') -plt.xlim(0, res_jopt_time.optimized_params[-1][0]) plt.legend() plt.show() ``` -## Global optimization - +### c) global optimization ```python -opt_args = { - "method": "basinhopping", - "max_iter": 1000, -} - res_jopt_global = optimize_pulses( - objectives=Objective(initial_state, H, target_state), - control_parameters=ctrl_parameters, - tlist=times, - algorithm_kwargs=alg_args, - optimizer_kwargs=opt_args + objectives = Objective(initial_state, H, target_state), + control_parameters = control_params, + tlist = times, + algorithm_kwargs = { + "alg": "JOPT", + "fid_err_targ": 0.01 + }, + optimizer_kwargs={ + "method": "basinhopping", + "max_iter": 1000 + } ) -global_time = res_jopt_global.optimized_params[-1] +global_time = res_jopt_global.optimized_params[-1][0] global_range = times < global_time print('Infidelity: ', res_jopt_global.infidelity) -print('Optimized time: ', res_jopt_global.optimized_params[-1]) +print('Optimized time: ', global_time) -plt.plot(times, res_jopt.optimized_controls[0], label='Optimized pulse') -plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[0])[global_range], label='Global optimized pulse') -plt.title('JOPT pulses') +plt.plot(times, guess_pulse, label='initial guess') +plt.plot(times, res_jopt.optimized_controls[0], label='optimized pulse') +plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[0])[global_range], label='global optimized pulse') +plt.title('JOPT pulses (global)') plt.xlabel('Time') plt.ylabel('Pulse amplitude') plt.legend() @@ -220,14 +221,17 @@ plt.show() ``` ```python -H_result_global = [Hd, [Hc, np.array(res_jopt_global.optimized_controls[0])]] -evolution_global = qt.sesolve(H_result_global, initial_state, times) - -plt.plot(times, [np.abs(state.overlap(initial_state))**2 for state in evolution_global.states], label="Overlap with initial state") -plt.plot(times, [np.abs(state.overlap(target_state))**2 for state in evolution_global.states], label="Overlap with target state") -plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_global.states], '--', label="Fidelity") -plt.xlim(0, res_jopt_global.optimized_params[-1][0]) -plt.title('JOPT performance (global)') +times3 = times[global_range] +if global_time not in times3: + times3 = np.append(times3, global_time) + +H_result = qt.QobjEvo([Hd, [Hc, np.array(res_jopt_global.optimized_controls[0])]], tlist=times) +evolution_global = qt.mesolve(H_result, initial_state, times3) + +plt.plot(times3, [fidelity(state, initial_state) for state in evolution_global.states], label="Overlap with initial state") +plt.plot(times3, [fidelity(state, target_state) for state in evolution_global.states], label="Overlap with target state") + +plt.title('JOPT (global) performance') plt.xlabel('Time') plt.legend() plt.show() @@ -236,10 +240,10 @@ plt.show() ```python -plt.plot(times, sin_x(times, jopt_guess), label='Initial guess') -plt.plot(times, res_jopt.optimized_controls[0], label='Optimized pulse') -plt.plot(times[time_range], np.array(res_jopt_time.optimized_controls[0])[time_range], label='Optimized (over time) pulse') -plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[0])[global_range], label='Global optimized pulse') +plt.plot(times, guess_pulse, label='initial guess') +plt.plot(times, res_jopt.optimized_controls[0], label='optimized pulse') +plt.plot(times[time_range], np.array(res_jopt_time.optimized_controls[0])[time_range], label='optimized (over time) pulse') +plt.plot(times[global_range], np.array(res_jopt_global.optimized_controls[0])[global_range], label='global optimized pulse') plt.title('JOPT pulses') plt.xlabel('Time') plt.ylabel('Pulse amplitude') @@ -247,18 +251,18 @@ plt.legend() plt.show() ``` ```python -print('Guess Infidelity: ', qt.fidelity(evolution_guess.states[-1], target_state)) -print('JOPT Infidelity: ', res_jopt.infidelity) -print('Time Infidelity: ', res_jopt_time.infidelity) -print('GLobal Infidelity: ', res_jopt_global.infidelity) +print('Guess Fidelity: ', fidelity(evolution_guess.states[-1], target_state)) +print('JOPT Fidelity: ', 1 - res_jopt.infidelity) +print('Time Fidelity: ', 1 - res_jopt_time.infidelity) +print('GLobal Fidelity: ', 1 - res_jopt_global.infidelity) -plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_guess.states], label="Guess") -plt.plot(times, [qt.fidelity(state, target_state) for state in evolution.states], label="Goat") -plt.plot(times[time_range], [qt.fidelity(state, target_state) for state in evolution_time.states[:len(times[time_range])]], label="Time") -plt.plot(times[global_range], [qt.fidelity(state, target_state) for state in evolution_global.states[:len(times[global_range])]], label="Global") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution_guess.states], 'k--', label="Guess") +plt.plot(times, [qt.fidelity(state, target_state) for state in evolution.states], label="GOAT") +plt.plot(times2, [qt.fidelity(state, target_state) for state in evolution_time.states], label="Time") +plt.plot(times3, [qt.fidelity(state, target_state) for state in evolution_global.states], label="Global") plt.title('Fidelities') -plt.xlabel('time') +plt.xlabel('Time') plt.legend() plt.show() ``` @@ -267,13 +271,21 @@ plt.show() ```python -assert res_jopt.infidelity < 0.001 -assert res_jopt_time.infidelity < 0.001 -assert res_jopt_global.infidelity < 0.001 +guess_fidelity = fidelity(evolution_guess.states[-1], target_state) + +# target fidelity not reached in part a), check that it is better than the guess +assert 1 - res_jopt.infidelity > guess_fidelity +assert np.allclose(fidelity(evolution.states[-1], target_state), 1 - res_jopt.infidelity, atol=1e-3) + +# target fidelity not reached in part b), check that it is better than part a) +assert res_jopt_time.infidelity < res_jopt.infidelity +assert np.allclose(fidelity(evolution_time.states[-1], target_state), 1 - res_jopt_time.infidelity, atol=1e-3) + +assert res_jopt_global.infidelity < 0.01 +assert np.allclose(fidelity(evolution_global.states[-1], target_state), 1 - res_jopt_global.infidelity, atol=1e-3) ``` ```python qt.about() -``` - +``` \ No newline at end of file