Add indexing and inner product to Statevector

qiskit/quantum_info/states/statevector.py

@@ -190,6 +190,29 @@ def _ipython_display_(self):
 
             display(out)
 
+    def __getitem__(self, key):
+        """Return Statevector item either by index or binary label
+        Args:
+            key (int or str): index or corresponding binary label, e.g. '01' = 1.
+
+        Returns:
+            np.complex128: Statevector item.
+
+        Raises:
+            QiskitError: if key is not valid.
+        """
+        if isinstance(key, str):
+            if re.match(r"^[01]+$", key) is None:
+                raise QiskitError("Key contains invalid characters.")
+            key = int(key, 2)
+        if isinstance(key, int):
+            if key < self.dim:
+                return self._data[key]
+            else:
+                raise QiskitError("Key is greater than Statevector dimension.")
+        else:
+            raise QiskitError("Key must be int or a valid binary string.")
+
     @property
     def data(self):
         """Return data."""
@@ -244,6 +267,26 @@ def tensor(self, other):
         ret._data = np.kron(self._data, other._data)
         return ret
 
+    def inner(self, other):
+        r"""Return the inner product of self and other as
+        :math:`\langle self| other \rangle`.
+
+        Args:
+            other (Statevector): a quantum state object.
+
+        Returns:
+            Statevector: the inner product of self and other, :math:`\langle self| other \rangle`.
+
+        Raises:
+            QiskitError: if other is not a quantum state or has different dimension.
+        """
+        if not isinstance(other, Statevector):
+            other = Statevector(other)
+        if self.dim != other.dim:
+            raise QiskitError("Other Statevector has different dimensions.")
+        inner = np.dot(self.conjugate().data, other.data)
+        return inner
+
     def expand(self, other):
         """Return the tensor product state other ⊗ self.
 
@@ -805,6 +848,7 @@ def _evolve_instruction(statevec, obj, qargs=None):
                     obj.name, type(obj.definition)
                 )
             )
+
         if obj.definition.global_phase:
             statevec._data *= np.exp(1j * float(obj.definition.global_phase))
         qubits = {qubit: i for i, qubit in enumerate(obj.definition.qubits)}

releasenotes/notes/make-statevector-subscriptable-and-add-inner-product_method-a0337393d9a5b666.yaml

@@ -0,0 +1,15 @@
+---
+features:
+  - |
+    Make :class:`qiskit.quantum_info.states.statevector.Statevector` subscriptable.
+    User can now retrieve the i-th elementh in a Statevector by index as statevec[i].
+
+    See `#4916 <https://github.com/Qiskit/qiskit-terra/issues/4916>`__ from more information.
+
+    Add inner product method to :class:`qiskit.quantum_info.states.statevector.Statevector`.
+    It takes as imput an other statevector an outputs the inner product.
+
+    For example::
+      statevec_inner_other = statevec.inner(other)
+
+    See `#4934 <https://github.com/Qiskit/qiskit-terra/issues/4934>`__ from more information.

test/python/quantum_info/states/test_statevector.py

@@ -18,7 +18,7 @@
 from itertools import permutations
 from ddt import ddt, data
 import numpy as np
-from numpy.testing import assert_allclose
+from numpy.testing import assert_allclose, assert_almost_equal
 
 from qiskit.test import QiskitTestCase
 from qiskit import QiskitError
@@ -208,6 +208,15 @@ def test_equal(self):
             vec = self.rand_vec(4)
             self.assertEqual(Statevector(vec), Statevector(vec.tolist()))
 
+    def test_getitem(self):
+        """Test __getitem__ method"""
+        for _ in range(10):
+            vec = self.rand_vec(4)
+            state = Statevector(vec)
+            for i in range(4):
+                self.assertEqual(state[i], vec[i])
+                self.assertEqual(state[format(i, "b")], vec[i])
+
     def test_copy(self):
         """Test Statevector copy method"""
         for _ in range(5):
@@ -335,6 +344,20 @@ def test_tensor(self):
             self.assertEqual(state.dims(), (3, 2))
             assert_allclose(state.data, target)
 
+    def test_inner(self):
+        """Test inner method."""
+        for _ in range(10):
+            seed = np.random.randint(0, np.iinfo(np.int32).max)
+            rng = np.random.default_rng(seed)
+            dim = 2 ** rng.integers(1, 4)
+            vec0 = Statevector(self.rand_vec(dim))
+            vec1 = Statevector(self.rand_vec(dim))
+            target = 0
+            for i in range(vec0.dim):
+                target += np.conj(vec0.data[i]) * vec1.data[i]
+            result = vec0.inner(vec1)
+            assert_almost_equal(result, target)
+
     def test_add(self):
         """Test add method."""
         for _ in range(10):