def _build_one_sector(available_hopping_ops): to_be_computed_list = [] for idx, _ in enumerate(mus): m_u = mus[idx] n_u = nus[idx] left_op = available_hopping_ops.get( '_'.join([str(x) for x in excitations_list[m_u]]), None) right_op_1 = available_hopping_ops.get( '_'.join([str(x) for x in excitations_list[n_u]]), None) right_op_2 = available_hopping_ops.get( '_'.join([str(x) for x in reversed(excitations_list[n_u])]), None) to_be_computed_list.append((m_u, n_u, left_op, right_op_1, right_op_2)) if logger.isEnabledFor(logging.INFO): logger.info("Building all commutators:") TextProgressBar(sys.stderr) results = parallel_map(QEquationOfMotion._build_commutator_rountine, to_be_computed_list, task_args=(self._untapered_op, self._z2_symmetries)) for result in results: m_u, n_u, q_mat_op, w_mat_op, m_mat_op, v_mat_op = result q_commutators[m_u][n_u] = op_converter.to_tpb_grouped_weighted_pauli_operator( q_mat_op, TPBGroupedWeightedPauliOperator.sorted_grouping) \ if q_mat_op is not None else q_commutators[m_u][n_u] w_commutators[m_u][n_u] = op_converter.to_tpb_grouped_weighted_pauli_operator( w_mat_op, TPBGroupedWeightedPauliOperator.sorted_grouping) \ if w_mat_op is not None else w_commutators[m_u][n_u] m_commutators[m_u][n_u] = op_converter.to_tpb_grouped_weighted_pauli_operator( m_mat_op, TPBGroupedWeightedPauliOperator.sorted_grouping) \ if m_mat_op is not None else m_commutators[m_u][n_u] v_commutators[m_u][n_u] = op_converter.to_tpb_grouped_weighted_pauli_operator( v_mat_op, TPBGroupedWeightedPauliOperator.sorted_grouping) \ if v_mat_op is not None else v_commutators[m_u][n_u]
def test_equal(self): gop_1 = op_converter.to_tpb_grouped_weighted_pauli_operator( self.qubit_op, TPBGroupedWeightedPauliOperator.sorted_grouping) gop_2 = op_converter.to_tpb_grouped_weighted_pauli_operator( self.qubit_op, TPBGroupedWeightedPauliOperator.unsorted_grouping) self.assertEqual(gop_1, gop_2)
def _config_the_best_mode(self, operator, backend): if not isinstance(operator, (WeightedPauliOperator, MatrixOperator, TPBGroupedWeightedPauliOperator)): logger.debug("Unrecognized operator type, skip auto conversion.") return operator ret_op = operator if not is_statevector_backend(backend) and not ( is_aer_provider(backend) and self._quantum_instance.run_config.shots == 1): if isinstance(operator, (WeightedPauliOperator, MatrixOperator)): logger.debug( "When running with Qasm simulator, grouped pauli can " "save number of measurements. " "We convert the operator into grouped ones.") ret_op = op_converter.to_tpb_grouped_weighted_pauli_operator( operator, TPBGroupedWeightedPauliOperator.sorted_grouping) else: if not is_aer_provider(backend): if not isinstance(operator, MatrixOperator): logger.info( "When running with non-Aer statevector simulator, " "represent operator as a matrix could " "achieve the better performance. We convert " "the operator to matrix.") ret_op = op_converter.to_matrix_operator(operator) else: if not isinstance(operator, WeightedPauliOperator): logger.info("When running with Aer simulator, " "represent operator as weighted paulis could " "achieve the better performance. We convert " "the operator to weighted paulis.") ret_op = op_converter.to_weighted_pauli_operator(operator) return ret_op
def test_evaluate_qasm_mode(self): """ evaluate qasm mode test """ wave_function = self.var_form.construct_circuit( np.array(aqua_globals.random.randn(self.var_form.num_parameters))) wave_fn_statevector = \ self.quantum_instance_statevector.execute(wave_function).get_statevector(wave_function) reference = self.qubit_op.copy().evaluate_with_statevector(wave_fn_statevector) shots = 65536 // len(self.qubit_op.paulis) self.quantum_instance_qasm.set_config(shots=shots) circuits = self.qubit_op.construct_evaluation_circuit(wave_function=wave_function, statevector_mode=False) result = self.quantum_instance_qasm.execute(circuits) pauli_value = self.qubit_op.evaluate_with_result(result=result, statevector_mode=False) grouped_op = op_converter.to_tpb_grouped_weighted_pauli_operator( self.qubit_op, TPBGroupedWeightedPauliOperator.sorted_grouping) shots = 65536 // grouped_op.num_groups self.quantum_instance_qasm.set_config(shots=shots) circuits = grouped_op.construct_evaluation_circuit(wave_function=wave_function, statevector_mode=False) grouped_pauli_value = grouped_op.evaluate_with_result( result=self.quantum_instance_qasm.execute(circuits), statevector_mode=False) self.assertGreaterEqual(reference[0].real, grouped_pauli_value[0].real - 3 * grouped_pauli_value[1].real) self.assertLessEqual(reference[0].real, grouped_pauli_value[0].real + 3 * grouped_pauli_value[1].real) # this check assure the std of grouped pauli is # less than pauli mode under a fixed amount of total shots self.assertLessEqual(grouped_pauli_value[1].real, pauli_value[1].real)
def test_sorted_grouping(self): """Test with color grouping approach.""" num_qubits = 2 paulis = [ Pauli.from_label(pauli_label) for pauli_label in itertools.product('IXYZ', repeat=num_qubits) ] weights = np.random.random(len(paulis)) op = WeightedPauliOperator.from_list(paulis, weights) grouped_op = op_converter.to_tpb_grouped_weighted_pauli_operator( op, TPBGroupedWeightedPauliOperator.sorted_grouping) # check all paulis are still existed. for g_p in grouped_op.paulis: passed = False for pauli in op.paulis: if pauli[1] == g_p[1]: passed = pauli[0] == g_p[0] break self.assertTrue( passed, "non-existed paulis in grouped_paulis: {}".format( g_p[1].to_label())) # check the number of basis of grouped # one should be less than and equal to the original one. self.assertGreaterEqual(len(op.basis), len(grouped_op.basis))
def test_chop(self): """ chop test """ paulis = [ Pauli.from_label(x) for x in ['IIXX', 'ZZXX', 'ZZZZ', 'XXZZ', 'XXXX', 'IXXX'] ] coeffs = [0.2, 0.3, 0.4, 0.5, 0.6, 0.7] op = WeightedPauliOperator.from_list(paulis, coeffs) grouped_op = op_converter.to_tpb_grouped_weighted_pauli_operator( op, TPBGroupedWeightedPauliOperator.sorted_grouping) original_num_basis = len(grouped_op.basis) chopped_grouped_op = grouped_op.chop(0.35, copy=True) self.assertLessEqual(len(chopped_grouped_op.basis), 3) self.assertLessEqual(len(chopped_grouped_op.basis), original_num_basis) # ZZXX group is remove for b, _ in chopped_grouped_op.basis: self.assertFalse(b.to_label() == 'ZZXX') chopped_grouped_op = grouped_op.chop(0.55, copy=True) self.assertLessEqual(len(chopped_grouped_op.basis), 1) self.assertLessEqual(len(chopped_grouped_op.basis), original_num_basis) for b, _ in chopped_grouped_op.basis: self.assertFalse(b.to_label() == 'ZZXX') self.assertFalse(b.to_label() == 'ZZZZ') self.assertFalse(b.to_label() == 'XXZZ')
def test_unsorted_grouping(self): """Test with normal grouping approach.""" num_qubits = 4 paulis = [Pauli.from_label(pauli_label) for pauli_label in itertools.product('IXYZ', repeat=num_qubits)] weights = aqua_globals.random.random_sample(len(paulis)) op = WeightedPauliOperator.from_list(paulis, weights) grouped_op = op_converter.to_tpb_grouped_weighted_pauli_operator( op, TPBGroupedWeightedPauliOperator.unsorted_grouping) for g_p in grouped_op.paulis: passed = False for pauli in op.paulis: if pauli[1] == g_p[1]: passed = pauli[0] == g_p[0] break self.assertTrue(passed, "non-existed paulis in grouped_paulis: {}".format(g_p[1].to_label())) self.assertGreaterEqual(len(op.basis), len(grouped_op.basis))