def test_for_success__resolve_observed_results(
self, test_for_success__resolve_observed_results
):
"""
_resolve_observed_resultsメソッドの正常系テスト
"""
eigen_values = test_for_success__resolve_observed_results["eigen_values"]
eigen_states = test_for_success__resolve_observed_results["eigen_states"]
unique_eigen_values, projections = _resolve_observed_results(
eigen_values, numpy.array(eigen_states)
)
expected_eigen_values = test_for_success__resolve_observed_results[
"expected_eigen_values"
]
expected_projections = test_for_success__resolve_observed_results[
"expected_projections"
]
for expected_index in range(len(expected_eigen_values)):
is_passed = False
for result_index in range(len(unique_eigen_values)):
if allclose(
expected_eigen_values[expected_index],
unique_eigen_values[result_index],
) and allclose(
expected_projections[expected_index].matrix,
projections[result_index].matrix,
):
is_passed = True
assert is_passed
def test_for_combine_ons(self, dict_for_test_combine_ons):
"""combin_onsメソッドの異常系テスト"""
ons_0 = OrthogonalSystem(dict_for_test_combine_ons["ons_0"])
ons_1 = OrthogonalSystem(dict_for_test_combine_ons["ons_1"])
expected_result = OrthogonalSystem(dict_for_test_combine_ons["result"])
result = combine_ons(ons_0, ons_1)
assert len(result.qubits_list) == len(expected_result.qubits_list)
for index in range(len(result.qubits_list)):
qubits_0 = result.qubits_list[index]
qubits_1 = expected_result.qubits_list[index]
allclose(qubits_0.vector, qubits_1.vector)
def test_for_success_observe(self, test_for_success_observe):
"""
observeメソッドの正常系テスト
"""
observable = test_for_success_observe["observable"]
target = test_for_success_observe["target"]
random.seed(test_for_success_observe["random_seed"])
observed_value, converged_qubits = observe(observable, target)
expected_observed_value = test_for_success_observe["expected_observed_value"]
expected_qubits = test_for_success_observe["expected_qubits"]
assert allclose(observed_value, expected_observed_value)
assert allclose(converged_qubits.matrix, expected_qubits.matrix)
def test_for_success_specialize(self, dict_for_test_specialize):
"""specializeメソッドの正常系テスト"""
target = dict_for_test_specialize["target"]
result = specialize(target)
expected_vector = dict_for_test_specialize["vector"]
expected_qubit_count = dict_for_test_specialize["qubit_count"]
assert allclose(result.vector, expected_vector)
assert result.qubit_count == expected_qubit_count
def test_for_success_inner(self, dict_for_test_valid_inner_input):
"""
innerメソッドの異常系テスト
"""
target_0 = dict_for_test_valid_inner_input["target_0"]
target_1 = dict_for_test_valid_inner_input["target_1"]
result = inner(target_0, target_1)
expected_result = dict_for_test_valid_inner_input["result"]
assert allclose(result, expected_result)
def test_for_success_time_evolve_transformer_transform(
self, dict_for_test_success_time_evolve_transformer_transform):
"""transformメソッドの正常系テスト"""
dict_for_test = dict_for_test_success_time_evolve_transformer_transform
qubits = dict_for_test["qubits"]
state = dict_for_test["state"]
time_evolution = dict_for_test["time_evolution"]
transformer = TimeEvolveTransformer(time_evolution)
result = transformer.transform(state)
assert allclose(result.qubits.matrix, qubits.matrix)
def test_for_success_operate(self, test_for_success_operate):
"""
operateメソッドの正常系テスト
"""
unitary = test_for_success_operate["unitary"]
target = test_for_success_operate["target"]
operated_qubits = unitary.operate(target)
expected_qubits = test_for_success_operate["expected_qubits"]
assert allclose(operated_qubits.matrix, expected_qubits.matrix)
def test_for_success_multiple_combine(
self, dict_for_test_pure_qubits_multiple_combine):
"""
multiple_combineメソッドの正常系テスト
"""
target_list = dict_for_test_pure_qubits_multiple_combine["target_list"]
result = multiple_combine(target_list)
expected_result = PureQubits(
dict_for_test_pure_qubits_multiple_combine["result"])
assert allclose(result.vector, expected_result.vector)
assert result.qubit_count == expected_result.qubit_count
def test_for_success_combine(self, dict_for_test_pure_qubits_combine):
"""
combineメソッドの正常系テスト
"""
target_0 = PureQubits(dict_for_test_pure_qubits_combine["target_0"])
target_1 = PureQubits(dict_for_test_pure_qubits_combine["target_1"])
result = combine(target_0, target_1)
expected_result = PureQubits(
dict_for_test_pure_qubits_combine["result"])
assert allclose(result.vector, expected_result.vector)
assert result.qubit_count == expected_result.qubit_count
def test_for_success_expected_value(self, test_for_success_expected_value_for_pure):
"""
expected_valueメソッドの純粋状態に対する正常系テスト
"""
observable = Observable(test_for_success_expected_value_for_pure["observable"])
target = Qubits(test_for_success_expected_value_for_pure["target"])
expected_value = observable.expected_value(target)
expected_expected_value = test_for_success_expected_value_for_pure[
"expected_value"
]
assert allclose(expected_value, expected_expected_value)
def test_for_success_constructor(self, test_for_success_observable_constructor):
"""
__init__メソッドの正常系テスト
"""
target = test_for_success_observable_constructor["target"]
observable = Observable(target)
matrix = observable.matrix
expected_matrix = numpy.array(test_for_success_observable_constructor["matrix"])
assert allclose(matrix, expected_matrix)
assert matrix.shape == expected_matrix.shape
def test_for_success_constructor(self, dict_for_test_qubits_constructor):
"""__init__メソッドの正常系テスト"""
target = dict_for_test_qubits_constructor["target"]
qubits = Qubits(target)
matrix = qubits.matrix
qubit_count = qubits.qubit_count
expected_matrix = numpy.array(dict_for_test_qubits_constructor["matrix"])
expected_qubit_count = dict_for_test_qubits_constructor["qubit_count"]
assert qubit_count == expected_qubit_count
assert allclose(matrix, expected_matrix)
assert matrix.shape == expected_matrix.shape
def test_for_constructor(self, dict_for_test_unitary_constructor):
"""
__init__メソッドの正常系テスト
"""
target = dict_for_test_unitary_constructor["target"]
unitary = TimeEvolution(target)
matrix = unitary.matrix
expected_matrix = numpy.array(
dict_for_test_unitary_constructor["matrix"])
assert allclose(matrix, expected_matrix)
assert matrix.shape == expected_matrix.shape
def test_for_success_generalize(self, dict_for_test_generalize):
"""generalizeメソッドの正常系テスト"""
target = dict_for_test_generalize["target"]
qubits = generalize(target)
matrix = qubits.matrix
qubit_count = qubits.qubit_count
expected_matrix = numpy.array(dict_for_test_generalize["matrix"])
expected_qubit_count = dict_for_test_generalize["qubit_count"]
assert qubit_count == expected_qubit_count
assert allclose(matrix, expected_matrix)
assert matrix.shape == expected_matrix.shape
def test_for_success_multiple_combine(self, dict_for_test_qubits_multiple_combine):
"""multiple_combineメソッドの正常系テスト"""
qubits_list = dict_for_test_qubits_multiple_combine["qubits_list"]
qubits = multiple_combine(qubits_list)
matrix = qubits.matrix
qubit_count = qubits.qubit_count
expected_matrix = numpy.array(dict_for_test_qubits_multiple_combine["matrix"])
expected_qubit_count = dict_for_test_qubits_multiple_combine["qubit_count"]
assert qubit_count == expected_qubit_count
assert allclose(matrix, expected_matrix)
assert matrix.shape == expected_matrix.shape
def test_for_success_observable_combine(self, test_for_success_observable_combine):
"""
combineメソッドの正常系テスト
"""
target_0 = test_for_success_observable_combine["target_0"]
target_1 = test_for_success_observable_combine["target_1"]
observable = combine(target_0, target_1)
matrix = observable.matrix
expected_matrix = numpy.array(test_for_success_observable_combine["matrix"])
assert allclose(matrix, expected_matrix)
assert matrix.shape == expected_matrix.shape
def test_for_success_create_from_ons(self, test_for_success_create_from_ons):
"""
create_from_onsメソッドの正常系テスト
"""
observed_values = test_for_success_create_from_ons["observed_values"]
ons = test_for_success_create_from_ons["ons"]
observable = create_from_ons(observed_values, ons)
matrix = observable.matrix
expected_matrix = numpy.array(test_for_success_create_from_ons["matrix"])
assert allclose(matrix, expected_matrix)
assert matrix.shape == expected_matrix.shape
def test_for_compose(self, dict_for_test_unitary_compose):
"""
combineメソッドの正常系テスト
"""
unitary_0 = dict_for_test_unitary_compose["unitary_0"]
unitary_1 = dict_for_test_unitary_compose["unitary_1"]
unitary = compose(unitary_0, unitary_1)
matrix = unitary.matrix
expected_matrix = numpy.array(dict_for_test_unitary_compose["matrix"])
assert allclose(matrix, expected_matrix)
assert matrix.shape == expected_matrix.shape
def test_for_create_from_onb(self, dict_for_test_create_from_onb):
"""
create_from_onbメソッドの正常系テスト
"""
onb_0 = dict_for_test_create_from_onb["onb_0"]
onb_1 = dict_for_test_create_from_onb["onb_1"]
unitary = create_from_onb(onb_0, onb_1)
matrix = unitary.matrix
expected_matrix = numpy.array(dict_for_test_create_from_onb["matrix"])
assert allclose(matrix, expected_matrix)
assert matrix.shape == expected_matrix.shape
def test_for_success_convex_combination(self, dict_for_test_convex_combination):
"""convex_combinationメソッドの正常系テスト"""
probabilities = dict_for_test_convex_combination["probabilities"]
qubits_list = dict_for_test_convex_combination["qubits_list"]
qubits = convex_combination(probabilities, qubits_list)
matrix = qubits.matrix
qubit_count = qubits.qubit_count
expected_matrix = numpy.array(dict_for_test_convex_combination["matrix"])
expected_qubit_count = dict_for_test_convex_combination["qubit_count"]
assert qubit_count == expected_qubit_count
assert allclose(matrix, expected_matrix)
assert matrix.shape == expected_matrix.shape
def test_for_success_create_from_ons(self, dict_for_test_create_from_ons):
"""create_from_onsメソッドの正常系テスト"""
probabilities = dict_for_test_create_from_ons["probabilities"]
ons = dict_for_test_create_from_ons["ons"]
qubits = create_from_ons(probabilities, ons)
matrix = qubits.matrix
qubit_count = qubits.qubit_count
expected_matrix = numpy.array(dict_for_test_create_from_ons["matrix"])
expected_qubit_count = dict_for_test_create_from_ons["qubit_count"]
assert qubit_count == expected_qubit_count
assert allclose(matrix, expected_matrix)
assert matrix.shape == expected_matrix.shape
def test_for_multiple_combine(self,
dict_for_test_unitary_multiple_combine):
"""
multiple_combineメソッドの正常系テスト
"""
unitary_list = dict_for_test_unitary_multiple_combine["unitary_list"]
unitary = multiple_combine(unitary_list)
matrix = unitary.matrix
expected_matrix = numpy.array(
dict_for_test_unitary_multiple_combine["matrix"])
assert allclose(matrix, expected_matrix)
assert matrix.shape == expected_matrix.shape
def test_for_success_observe_transformer_transform(
self, dict_for_test_success_observe_transformer_transform):
"""transformメソッドの正常系テスト"""
dict_for_test = dict_for_test_success_observe_transformer_transform
random.seed(dict_for_test["random_seed"])
qubits = dict_for_test["qubits"]
registers = dict_for_test["registers"]
state = dict_for_test["state"]
observable = dict_for_test["observable"]
register_index = dict_for_test["register_index"]
transformer = ObserveTransformer(observable)
result = transformer.transform(state, register_index)
assert allclose(result.qubits.matrix, qubits.matrix)
assert result.registers.get(
register_index) == registers[register_index]
def test_for_success_multiple_reduction(self, dict_for_test_multiple_reduction):
"""multiple_reductionメソッドの正常系テスト"""
qubits = dict_for_test_multiple_reduction["qubits"]
target_particles = dict_for_test_multiple_reduction["target_particles"]
reduced_qubits = multiple_reduction(qubits, target_particles)
matrix = reduced_qubits.matrix
qubit_count = reduced_qubits.qubit_count
expected_matrix = numpy.array(dict_for_test_multiple_reduction["matrix"])
expected_qubit_count = dict_for_test_multiple_reduction["qubit_count"]
assert qubit_count == expected_qubit_count
assert allclose(matrix, expected_matrix)
assert matrix.shape == expected_matrix.shape
def test_for_success_channel_initialize(
self, dict_for_test_success_channel_initialize
):
"""initializeメソッドの正常系テスト"""
dict_for_test = dict_for_test_success_channel_initialize
qubit_count = dict_for_test["qubit_count"]
register_count = dict_for_test["register_count"]
noise = dict_for_test["noise"]
input = dict_for_test["input"]
channel = Channel(qubit_count, register_count, noise)
channel.initialize(input)
state = channel.states[0]
expected_state = dict_for_test["state"]
print(state.qubits.matrix)
print(expected_state.qubits.matrix)
assert allclose(state.qubits.matrix, expected_state.qubits.matrix)
def test_for_success_observable_multiple_combine(
self, test_for_success_observable_multiple_combine
):
"""
multiple_combineメソッドの正常系テスト
"""
target_list = test_for_success_observable_multiple_combine["target_list"]
observable = multiple_combine(target_list)
matrix = observable.matrix
expected_matrix = numpy.array(
test_for_success_observable_multiple_combine["matrix"]
)
assert allclose(matrix, expected_matrix)
assert matrix.shape == expected_matrix.shape
def __init__(self, hermite_matrix: list):
"""
Args:
hermite_matrix (list): 観測量の候補となるリスト。行列形式とndarray形式を許容する
"""
matrix = np.array(hermite_matrix)
# 次元のチェック
if not is_qubits_dim(matrix):
message = "[ERROR]: 与えられたリストはQubit系上の作用素ではありません"
raise InitializeError(message)
# エルミート性のチェック
if not allclose(matrix, np.conj(matrix.T)):
message = "[ERROR]: 与えられたリストはエルミート行列ではありません"
raise InitializeError(message)
# 初期化
self.matrix = matrix
def test_for_success_allocator_allocate(
self, dict_for_test_success_allocator_allocate):
"""allocateメソッドの正常系テスト"""
dict_for_test = dict_for_test_success_allocator_allocate
random.seed(dict_for_test["random_seed"])
input = dict_for_test["input"]
qubit_count = dict_for_test["qubit_count"]
register_count = dict_for_test["register_count"]
qubits = dict_for_test["qubits"]
registers = Registers(register_count)
for index in range(len(dict_for_test["registers"])):
if dict_for_test["registers"][index] is not None:
registers.put(index, dict_for_test["registers"][index])
state = Allocator(input, qubit_count, register_count).allocate()
assert allclose(qubits.matrix, state.qubits.matrix)
for index in range(register_count):
assert state.registers.get(index) == registers.get(index)
def __init__(self, unitary_matrix: list):
"""
Args:
unitary_array: ユニタリ変換の候補となるリスト。行列形式とndarray形式を許容する
"""
matrix = np.array(unitary_matrix)
# 次元のチェック
if not is_qubits_dim(matrix):
message = "[ERROR]: 与えられたリストはQubit系上の作用素ではありません"
raise InitializeError(message)
# ユニタリ性のチェック
hermite_matrix = matrix @ np.conj(matrix.T)
if not allclose(hermite_matrix, np.identity(matrix.shape[0])):
message = "[ERROR]: 与えられたリストはユニタリ変換ではありません"
raise InitializeError(message)
del hermite_matrix
# 初期化
self.matrix = matrix
def _is_pure_qubits(array: numpy.array) -> bool:
"""
与えられたnp.arrayがQubit系を表現しているか判定する。
Args:
array (np.array): 判定対象のnp.array
Returns:
bool: 判定結果
"""
# 要素数が2の累乗個であるかチェック
size = array.size
if not is_pow2(size):
return False
# 長さが1、つまり確率が1になるかをチェック
norm = np.sqrt(np.sum(np.abs(array) ** 2))
if not allclose(norm, 1.0):
return False
return True
