def test_quasi_static_noise_monte_carlo(self):
np.random.seed(0)
h_ctrl = [
DenseOperator(np.diag([.5, -.5])),
]
h_drift = [DenseOperator(np.zeros((2, 2)))]
n_noise_values = 20
noise_levels = 1e-4 * np.arange(1, n_noise_values + 1)
actual_noise_levels = np.zeros((n_noise_values, ))
average_infids = np.zeros((n_noise_values, ))
for i, std_dev in enumerate(noise_levels):
ntg = NTGQuasiStatic(standard_deviation=[
std_dev,
],
n_samples_per_trace=1,
n_traces=2000,
sampling_mode='monte_carlo')
ctrl_amps = 2 * np.pi * np.ones((1, 1)) * 0
t_slot_comp = SchroedingerSMonteCarlo(h_drift=h_drift,
h_ctrl=h_ctrl,
initial_state=DenseOperator(
np.eye(2)),
tau=[1],
h_noise=h_ctrl,
noise_trace_generator=ntg)
t_slot_comp.set_optimization_parameters(ctrl_amps)
quasi_static_infid = OperationNoiseInfidelity(
solver=t_slot_comp,
target=DenseOperator(np.eye(2)),
neglect_systematic_errors=False,
fidelity_measure='entanglement')
average_infids[i] = quasi_static_infid.costs() * (2 / 3)
actual_noise_levels[i] = np.std(ntg.noise_samples)
self.assertLess(
np.sum(
np.abs((np.ones_like(average_infids) - average_infids /
(noise_levels**2 / 6)))) / 100, 0.05)
self.assertLess(
np.sum(
np.abs((np.ones_like(average_infids) - average_infids /
(actual_noise_levels**2 / 6)))) / 100, 0.05)
def test_quasi_static_noise_deterministic_sampling(self):
""" The same problem has also been positively tested with two time
steps. """
h_ctrl = [
DenseOperator(np.diag([.5, -.5])),
]
h_drift = [DenseOperator(np.zeros((2, 2)))]
noise_levels = 1e-4 * np.arange(1, 101)
actual_noise_levels = np.zeros((100, ))
average_infids = np.zeros((100, ))
for i, std_dev in enumerate(noise_levels):
ntg = NTGQuasiStatic(standard_deviation=[
std_dev,
],
n_samples_per_trace=1,
n_traces=200,
sampling_mode='uncorrelated_deterministic')
ctrl_amps = 2 * np.pi * np.ones((1, 1))
t_slot_comp = SchroedingerSMonteCarlo(h_drift=h_drift,
h_ctrl=h_ctrl,
initial_state=DenseOperator(
np.eye(2)),
tau=[1],
h_noise=h_ctrl,
noise_trace_generator=ntg)
t_slot_comp.set_optimization_parameters(ctrl_amps)
quasi_static_infid = OperationNoiseInfidelity(
solver=t_slot_comp,
target=DenseOperator(np.eye(2)),
neglect_systematic_errors=True,
fidelity_measure='entanglement')
average_infids[i] = quasi_static_infid.costs() * (2 / 3)
actual_noise_levels[i] = np.std(ntg.noise_samples)
self.assertLess(
np.sum(
np.abs((np.ones_like(average_infids) - average_infids /
(noise_levels**2 / 6)))) / 100, 0.05)
self.assertLess(
np.sum(
np.abs((np.ones_like(average_infids) - average_infids /
(actual_noise_levels**2 / 6)))) / 100, 1e-5)
def test_relative_gradients_xy(self):
amp_bound = rabi.rabi_frequency_max / rabi.lin_freq_rel
np.random.seed(0)
initial_pulse = amp_bound * (
2 * np.random.rand(rabi.n_time_samples, 2) - 1)
ntg_quasi_static = NTGQuasiStatic(
standard_deviation=[
rabi.sigma_rabi,
],
n_samples_per_trace=rabi.n_time_samples * rabi.oversampling,
n_traces=10,
always_redraw_samples=False,
sampling_mode='uncorrelated_deterministic')
tslot = SchroedingerSMonteCarlo(
h_drift=[
0 * rabi.h_drift,
],
h_ctrl=rabi.h_ctrl,
h_noise=[
rabi.h_drift,
],
noise_trace_generator=ntg_quasi_static,
initial_state=DenseOperator(np.eye(2)),
tau=[
rabi.time_step,
] * rabi.n_time_samples,
is_skew_hermitian=True,
exponential_method='Frechet',
transfer_function=rabi.exponential_transfer_function,
amplitude_function=rabi.lin_amp_func)
entanglement_infid = OperationInfidelity(
solver=tslot,
target=rabi.x_half,
fidelity_measure='entanglement',
index=['Entanglement Fidelity QS-Noise XY-Control'])
tslot_noise = SchroedingerSMonteCarlo(
h_drift=[
0 * rabi.h_drift,
],
h_ctrl=rabi.h_ctrl,
h_noise=[
rabi.h_drift,
],
noise_trace_generator=ntg_quasi_static,
initial_state=DenseOperator(np.eye(2)),
tau=[
rabi.time_step,
] * rabi.n_time_samples,
is_skew_hermitian=True,
exponential_method='Frechet',
transfer_function=rabi.exponential_transfer_function,
amplitude_function=rabi.lin_amp_func)
entanglement_infid_qs_noise_xy = OperationNoiseInfidelity(
solver=tslot_noise,
target=rabi.x_half,
fidelity_measure='entanglement',
index=['Entanglement Fidelity QS-Noise XY-Control'],
neglect_systematic_errors=True)
dynamics = Simulator(solvers=[
tslot,
],
cost_fktns=[
entanglement_infid,
])
dynamics_noise = Simulator(solvers=[
tslot_noise,
],
cost_fktns=[entanglement_infid_qs_noise_xy])
_, rel_grad_deviation_unperturbed = \
dynamics.compare_numeric_to_analytic_gradient(initial_pulse)
self.assertLess(rel_grad_deviation_unperturbed, 1e-6)
_, rel_grad_deviation_qs_noise = \
dynamics_noise.compare_numeric_to_analytic_gradient(initial_pulse)
self.assertLess(rel_grad_deviation_qs_noise, 1e-4)
def test_phase_control_gradient(self):
amp_bound = rabi.rabi_frequency_max / rabi.lin_freq_rel
phase_bound_upper = 50 / 180 * np.pi
phase_bound_lower = -50 / 180 * np.pi
def random_phase_control_pulse(n):
amp = amp_bound * (2 * np.random.rand(n) - 1)
phase = (phase_bound_upper - phase_bound_lower) \
* np.random.rand(n) \
- (phase_bound_upper - phase_bound_lower) / 2
return np.concatenate(
(np.expand_dims(amp, 1), np.expand_dims(phase, 1)), axis=1)
dynamics_phase_control = Simulator(
solvers=[rabi.solver_qs_noise_phase_control],
cost_fktns=[rabi.entanglement_infid_phase_control])
ntg_quasi_static = NTGQuasiStatic(
standard_deviation=[
rabi.sigma_rabi,
],
n_samples_per_trace=rabi.n_time_samples * rabi.oversampling,
n_traces=10,
always_redraw_samples=False,
sampling_mode='uncorrelated_deterministic')
time_slot_comp_qs_noise_phase_control = SchroedingerSMonteCarlo(
h_drift=[
0 * rabi.h_drift,
],
h_ctrl=rabi.h_ctrl,
h_noise=[
rabi.h_drift,
],
noise_trace_generator=ntg_quasi_static,
initial_state=DenseOperator(np.eye(2)),
tau=[
rabi.time_step,
] * rabi.n_time_samples,
is_skew_hermitian=True,
exponential_method='Frechet',
transfer_function=rabi.identity_transfer_function,
amplitude_function=rabi.phase_ctrl_amp_func)
entanglement_infid_qs_noise_phase_control = OperationNoiseInfidelity(
solver=time_slot_comp_qs_noise_phase_control,
target=rabi.x_half,
fidelity_measure='entanglement',
index=['Entanglement Fidelity QS-Noise Phase Control'],
neglect_systematic_errors=True)
dynamics_phase_control_qs_noise = Simulator(
solvers=[
time_slot_comp_qs_noise_phase_control,
],
cost_fktns=[
entanglement_infid_qs_noise_phase_control,
])
np.random.seed(0)
inital_pulse = random_phase_control_pulse(rabi.n_time_samples)
_, rel_grad_deviation_unperturbed = dynamics_phase_control.\
compare_numeric_to_analytic_gradient(inital_pulse)
self.assertLess(rel_grad_deviation_unperturbed, 2e-6)
_, rel_grad_deviation_qs_noise = dynamics_phase_control_qs_noise.\
compare_numeric_to_analytic_gradient(inital_pulse)
self.assertLess(rel_grad_deviation_qs_noise, 5e-5)
amplitude_function=phase_ctrl_amp_func)
# ##################### 8. Cost Function ######################################
# The cost functions calculate the infidelities and are minimized by the
# optimiser.
# 8.1 xy-control
entanglement_infid_xy = OperationInfidelity(
solver=solver_qs_noise_xy,
target=x_half,
fidelity_measure='entanglement',
index=['Entanglement Fidelity XY-Control'])
entanglement_infid_qs_noise_xy = OperationNoiseInfidelity(
solver=solver_qs_noise_xy,
target=y_half,
fidelity_measure='entanglement',
index=['Entanglement Fidelity QS-Noise XY-Control'],
neglect_systematic_errors=True)
entanglement_infid_xy_spectral = OperationInfidelity(
solver=solver_qs_noise_xy_spectral,
target=x_half,
fidelity_measure='entanglement',
index=['Entanglement Fidelity XY-Control'])
entanglement_infid_qs_noise_xy_spectral = OperationNoiseInfidelity(
solver=solver_qs_noise_xy_spectral,
target=y_half,
fidelity_measure='entanglement',
index=['Entanglement Fidelity QS-Noise XY-Control'],
neglect_systematic_errors=True)
def create_discrete_classes(n_bit_ph: int, n_bit_amp: int):
n_max_phase = 2**n_bit_ph - 1
delta_phase = phase_max / n_max_phase * np.pi / 180
# 2.2: from our group
amp_bound = rabi_frequency_max * 2 * np.pi / lin_freq_rel
n_max_amp = 2**n_bit_amp - 1
delta_amp = amp_bound / n_max_amp
discrete_tf_phase = LinearTF(oversampling=1,
bound_type=None,
num_ctrls=1,
linear_factor=delta_phase)
discrete_tf_amp = LinearTF(oversampling=1,
bound_type=None,
num_ctrls=1,
linear_factor=delta_amp)
discrete_tf = ParallelTF(tf1=discrete_tf_amp, tf2=discrete_tf_phase)
total_tf = ConcatenateTF(tf1=discrete_tf,
tf2=exponential_transfer_function)
total_tf.set_times(time_step * np.ones(n_time_samples))
ts_comp_unperturbed_pc_discrete = SchroedingerSolver(
h_drift=[
0 * h_drift,
] * n_time_samples * oversampling,
h_ctrl=h_ctrl,
initial_state=DenseOperator(np.eye(2)),
tau=[
time_step / oversampling,
] * n_time_samples * oversampling,
is_skew_hermitian=True,
exponential_method=exponential_method,
transfer_function=total_tf,
amplitude_function=phase_ctrl_amp_func)
time_slot_comp_qs_noise_pc_discrete = SchroedingerSMonteCarlo(
h_drift=[
0 * h_drift,
] * n_time_samples * oversampling,
h_ctrl=h_ctrl,
h_noise=[
h_drift,
],
noise_trace_generator=ntg_quasi_static,
initial_state=DenseOperator(np.eye(2)),
tau=[
time_step / oversampling,
] * n_time_samples * oversampling,
is_skew_hermitian=True,
exponential_method=exponential_method,
transfer_function=total_tf,
amplitude_function=phase_ctrl_amp_func)
qs_noise_pc_discrete = OperationNoiseInfidelity(
solver=time_slot_comp_qs_noise_pc_discrete,
target=x_half,
fidelity_measure='entanglement',
index=['Entanglement Fidelity QS-Noise Phase Control'],
neglect_systematic_errors=True)
entanglement_infid_pc_discrete = OperationInfidelity(
solver=ts_comp_unperturbed_pc_discrete,
target=x_half,
fidelity_measure='entanglement',
index=['Entanglement Fidelity Phase Control'])
return [ts_comp_unperturbed_pc_discrete,
time_slot_comp_qs_noise_pc_discrete], \
[entanglement_infid_pc_discrete, qs_noise_pc_discrete]