def __init__(self, target_states, cost_multiplier=1.):
"""
See class fields for arguments not listed here.
Arguments:
target_states
"""
super().__init__(cost_multiplier=cost_multiplier)
self.state_count = target_states.shape[0]
self.target_states_dagger = conjugate_transpose(target_states)
def __init__(self, step_count, target_states, cost_multiplier=1.):
"""
See class definition for parameter specification.
target_states :: numpy.ndarray - an array of states
that correspond to the target state for each of the initial states
used in optimization
"""
super().__init__(cost_multiplier=cost_multiplier)
self.state_count = target_states.shape[0]
self.step_count = step_count
self.target_states_dagger = conjugate_transpose(
anp.stack(target_states))
def __init__(self, system_eval_count, target_densities,
cost_eval_step=1, cost_multiplier=1.,):
"""
See class fields for arguments not listed here.
Arguments:
target_densities
"""
super().__init__(cost_multiplier=cost_multiplier)
self.cost_eval_count, _ = np.divmod(system_eval_count - 1, cost_eval_step)
self.density_count = target_densities.shape[0]
self.hilbert_size = target_densities.shape[1]
self.target_densities_dagger = conjugate_transpose(np.stack(target_densities))
def __init__(self, target_states, cost_multiplier=1.):
"""
See class definition for parameter specification.
target_states :: numpy.ndarray - an array of states
that correspond to the target state for each of the initial states
used in optimization
"""
super().__init__(cost_multiplier=cost_multiplier)
self.target_states_dagger = conjugate_transpose(np.stack(target_states))
self.state_normalization_constant = len(target_states)
# This cost function does not make use of parameter penalties.
self.dcost_dparams = (lambda params, states, step:
np.zeros_like(params))
def __init__(self, target_densities, cost_multiplier=1.):
"""
See class definition for arguments not listed here.
Args:
target_densities :: ndarray (density_count x hilbert_size x hilbert_size)
- an array of densities
that correspond to the target density for each of the initial densities
used in optimization
"""
super().__init__(cost_multiplier=cost_multiplier)
self.density_count = target_densities.shape[0]
self.hilbert_size = target_densities.shape[-1]
self.target_densities_dagger = conjugate_transpose(
np.stack(target_densities))
def __init__(
self,
system_eval_count,
target_states,
neglect_relative_pahse=False,
cost_eval_step=1,
cost_multiplier=1.,
):
"""
See class fields for arguments not listed here.
Arguments:
target_states
"""
super().__init__(cost_multiplier=cost_multiplier)
self.cost_eval_count, _ = np.divmod(system_eval_count - 1,
cost_eval_step)
self.state_count = target_states.shape[0]
self.target_states_dagger = conjugate_transpose(
anp.stack(target_states))
self.neglect_relative_pahse = neglect_relative_pahse
def __init__(self,
forbidden_states,
system_step_count,
cost_multiplier=1.):
"""
See class definition for arguments not listed here.
Args:
forbidden_states :: ndarray - an array where each entry
in the first axis is an array of states that the corresponding
evolving state is forbidden from, that is, each evolving
state has its own list of forbidden states
system_step_count :: int - the number of system steps in the evolution
"""
super().__init__(cost_multiplier=cost_multiplier)
self.forbidden_states_dagger = conjugate_transpose(forbidden_states)
state_count = forbidden_states.shape[0]
self.normalization_constant = state_count * system_step_count
self.state_normalization_constants = np.array([
state_forbidden_states.shape[0]
for state_forbidden_states in forbidden_states
])
def _tests():
"""
Run test on the module.
"""
system_step_count = 10
state0 = np.array([[0], [1]])
density0 = np.matmul(state0, conjugate_transpose(state0))
target_state0 = np.array([[1], [0]])
target_density0 = np.matmul(target_state0,
conjugate_transpose(target_state0))
densities = np.stack((density0, ), axis=0)
targets = np.stack((target_density0, ), axis=0)
ti = TargetDensityInfidelityTime(system_step_count, targets)
cost = ti.cost(None, densities, None)
assert (np.allclose(cost, 0.1))
ti = TargetDensityInfidelity(system_step_count, densities)
cost = ti.cost(None, densities, None)
assert (np.allclose(cost, 0.075))
state0 = np.array([[1], [0]])
state1 = (np.array([[1j], [1]]) / np.sqrt(2))
density0 = np.matmul(state0, conjugate_transpose(state0))
density1 = np.matmul(state1, conjugate_transpose(state1))
target_state0 = np.array([[1j], [0]])
target_state1 = np.array([[1], [0]])
target_density0 = np.matmul(target_state0,
conjugate_transpose(target_state0))
target_density1 = np.matmul(target_state1,
conjugate_transpose(target_state1))
densities = np.stack((
density0,
density1,
), axis=0)
targets = np.stack((
target_density0,
target_density1,
), axis=0)
ti = TargetDensityInfidelity(system_step_count, targets)
cost = ti.cost(None, densities, None)
expected_cost = (1 - np.divide(5, 32)) / 10
assert (np.allclose(cost, expected_cost))
def _test():
"""
Run tests on the module.
"""
system_step_count = 10
state0 = np.array([[1], [0]])
density0 = np.matmul(state0, conjugate_transpose(state0))
forbid0_0 = np.array([[1], [0]])
density0_0 = np.matmul(forbid0_0, conjugate_transpose(forbid0_0))
forbid0_1 = np.divide(np.array([[1], [1]]), np.sqrt(2))
density0_1 = np.matmul(forbid0_1, conjugate_transpose(forbid0_1))
state1 = np.array([[0], [1]])
density1 = np.matmul(state1, conjugate_transpose(state1))
forbid1_0 = np.divide(np.array([[1], [1]]), np.sqrt(2))
density1_0 = np.matmul(forbid1_0, conjugate_transpose(forbid1_0))
forbid1_1 = np.divide(np.array([[1j], [1j]]), np.sqrt(2))
density1_1 = np.matmul(forbid1_1, conjugate_transpose(forbid1_1))
densities = np.stack((
density0,
density1,
))
forbidden_densities0 = np.stack((
density0_0,
density0_1,
))
forbidden_densities1 = np.stack((
density1_0,
density1_1,
))
forbidden_densities = np.stack((
forbidden_densities0,
forbidden_densities1,
))
fd = ForbidDensities(forbidden_densities, system_step_count)
cost = fd.cost(None, densities, None)
expected_cost = np.divide(7, 640)
assert (np.allclose(
cost,
expected_cost,
))