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