def test_circuit_statevector_repr_decimal(self): """Test postprocessing of statevector giving decimals arg.""" raw_statevector = np.array( [ 0.35355339 + 0.0j, 0.35355339 + 0.0j, 0.35355339 + 0.0j, 0.35355339 + 0.0j, 0.35355339 + 0.0j, 0.35355339 + 0.0j, 0.35355339 + 0.0j, 0.35355339 + 0.0j, ], dtype=np.complex_, ) processed_sv = np.array( [ 0.354 + 0.0j, 0.354 + 0.0j, 0.354 + 0.0j, 0.354 + 0.0j, 0.354 + 0.0j, 0.354 + 0.0j, 0.354 + 0.0j, 0.354 + 0.0j, ], dtype=np.complex_, ) data = models.ExperimentResultData(statevector=raw_statevector) exp_result = models.ExperimentResult(shots=1, success=True, data=data) result = Result(results=[exp_result], **self.base_result_args) statevector = result.get_statevector(decimals=3) self.assertEqual(statevector.shape, (8, )) self.assertEqual(statevector.dtype, np.complex_) np.testing.assert_almost_equal(statevector, processed_sv)
def _compute_phases( self, num_unitary_qubits: int, circuit_result: Result ) -> Union[numpy.ndarray, qiskit.result.Counts]: """Compute frequencies/counts of phases from the result of running the QPE circuit. How the frequencies are computed depends on whether the backend computes amplitude or samples outcomes. 1) If the backend is a statevector simulator, then the reduced density matrix of the phase-reading register is computed from the combined phase-reading- and input-state registers. The elements of the diagonal :math:`(i, i)` give the probability to measure the each of the states `i`. The index `i` expressed as a binary integer with the LSB rightmost gives the state of the phase-reading register with the LSB leftmost when interpreted as a phase. In order to maintain the compact representation, the phases are maintained as decimal integers. They may be converted to other forms via the results object, `PhaseEstimationResult` or `HamiltonianPhaseEstimationResult`. 2) If the backend samples bitstrings, then the counts are first retrieved as a dict. The binary strings (the keys) are then reversed so that the LSB is rightmost and the counts are converted to frequencies. Then the keys are sorted according to increasing phase, so that they can be easily understood when displaying or plotting a histogram. Args: num_unitary_qubits: The number of qubits in the unitary. circuit_result: the result object returned by the backend that ran the QPE circuit. Returns: Either a dict or numpy.ndarray representing the frequencies of the phases. """ if self._quantum_instance.is_statevector: state_vec = circuit_result.get_statevector() evaluation_density_matrix = qiskit.quantum_info.partial_trace( state_vec, range(self._num_evaluation_qubits, self._num_evaluation_qubits + num_unitary_qubits), ) phases = evaluation_density_matrix.probabilities() else: # return counts with keys sorted numerically num_shots = circuit_result.results[0].shots counts = circuit_result.get_counts() phases = {k[::-1]: counts[k] / num_shots for k in counts.keys()} phases = _sort_phases(phases) phases = qiskit.result.Counts(phases, memory_slots=counts.memory_slots, creg_sizes=counts.creg_sizes) return phases