tequila-basic 1.9.6__py3-none-any.whl → 1.9.8__py3-none-any.whl

tequila/wavefunction/qubit_wavefunction.py

@@ -1,302 +1,410 @@
 from __future__ import annotations
-import copy
+
 import typing
-from typing import Dict, Union
+from copy import deepcopy
+from math import log2
+from typing import Union, Generator
+
 import numpy
+import numpy as np
+import numpy.typing as npt
 import numbers
 
-from tequila.utils.bitstrings import BitNumbering, BitString, initialize_bitstring
-from tequila import TequilaException
-from tequila.utils.keymap import KeyMapLSB2MSB, KeyMapMSB2LSB
-from tequila.tools import number_to_string
+import sympy
 
-# from __future__ import annotations # can use that in python 3.7+ to get rid of string type hints
+from tequila.utils.bitstrings import BitString, reverse_int_bits
+from tequila import TequilaException, BitNumbering, initialize_bitstring
+from tequila.utils.keymap import KeyMapABC
 
 if typing.TYPE_CHECKING:
-    # don't need those structures, just for convenient type hinting
+    # Don't need those structures, just for convenient type hinting
     from tequila.hamiltonian.qubit_hamiltonian import QubitHamiltonian, PauliString
 
 
 class QubitWaveFunction:
     """
-    Store Wavefunction as dictionary of comp. basis state and complex numbers
-    Use the same structure for Measurments results with int instead of complex numbers (counts)
+    Represents a wavefunction.
+    Amplitudes are either stored in a Numpy array for dense wavefunctions, or a dictionary for sparse wavefunctions.
+    Does not enforce normalization.
     """
 
-    numbering = BitNumbering.MSB
-
-    def apply_keymap(self, keymap, initial_state: BitString = None):
-        self.n_qubits = keymap.n_qubits
-        mapped_state = dict()
-        for k, v in self.state.items():
-            mapped_key=keymap(input_state=k, initial_state=initial_state)
-            if mapped_key in mapped_state:
-                mapped_state[mapped_key] += v
-            else:
-                mapped_state[mapped_key] = v
-
-        self.state = mapped_state
-        return self
+    def __init__(self, n_qubits: int, numbering: BitNumbering = BitNumbering.MSB, dense: bool = False,
+                 init_state: bool = True) -> None:
+        """
+        Initialize a QubitWaveFunction with all amplitudes set to zero.
 
-    @property
-    def n_qubits(self) -> int:
-        if self._n_qubits is None:
-            return self.min_qubits()
+        :param n_qubits: Number of qubits.
+        :param numbering: Whether the first qubit is the most or least significant.
+        :param dense: Whether to store the amplitudes in a Numpy array instead of a dictionary.
+        :param init_state: Whether to initialize the state array.
+            If False, set_state must be called immediately after the constructor.
+        """
+        self._n_qubits: int = n_qubits
+        self._numbering = numbering
+        self._dense = dense
+        if init_state:
+            self._state = np.zeros(2 ** self._n_qubits, dtype=complex) if dense else dict()
         else:
-            return max(self._n_qubits, self.min_qubits())
+            self._state = None
 
-    def min_qubits(self) -> int:
-        if len(self.state) > 0:
-            maxk = max(self.state.keys())
-            return maxk.nbits
+    @classmethod
+    def from_wavefunction(cls, wfn: QubitWaveFunction, keymap: KeyMapABC = None, n_qubits: int = None,
+                          initial_state: BitString = None) -> QubitWaveFunction:
+        """
+        Create a copy of a wavefunction.
+
+        :param wfn: The wavefunction to copy.
+        :param keymap: A keymap to apply to the wavefunction.
+        :param n_qubits: Number of qubits of the new wavefunction.
+            Must not be None if keymap is not None.
+        :param initial_state: Initial state to pass to the keymap.
+        :return: The copied wavefunction.
+        """
+        if keymap is not None:
+            result = QubitWaveFunction(n_qubits, numbering=wfn._numbering, dense=wfn._dense)
+            # Change amplitudes to sympy objects
+            if wfn._dense and wfn._state.dtype == object:
+                result = sympy.Integer(1) * result
+            for index, coeff in wfn.raw_items():
+                key = initialize_bitstring(index, wfn._n_qubits, numbering_in=wfn._numbering, numbering_out=keymap.numbering)
+                key = keymap(key, initial_state)
+                result[key] += coeff
+            return result
         else:
-            return 0
+            return deepcopy(wfn)
 
-    @n_qubits.setter
-    def n_qubits(self, n_qubits):
-        if n_qubits is not None:
-            self._n_qubits = max(n_qubits, self.min_qubits())
-        return self
-
-    @property
-    def state(self):
-        if self._state is None:
-            return dict()
-        else:
-            return self._state
-
-    @state.setter
-    def state(self, other: Dict[BitString, complex]):
-        assert (isinstance(other, dict))
-        self._state = other
-
-    def __init__(self, state: Dict[BitString, complex] = None, n_qubits=None):
-        if state is None:
-            self._state = dict()
-        elif isinstance(state, int):
-            self._state = self.from_int(i=state, n_qubits=n_qubits).state
-        elif isinstance(state, str):
-            self._state = self.from_string(string=state, n_qubits=n_qubits).state
-        elif isinstance(state, numpy.ndarray) or isinstance(state, list):
-            self._state = self.from_array(arr=state, n_qubits=n_qubits).state
-        elif hasattr(state, "state"):
-            self._state = state.state
-        else:
-            self._state = state
-        self._n_qubits = n_qubits
+    @classmethod
+    def from_array(cls, array: npt.NDArray[complex], numbering: BitNumbering = BitNumbering.MSB,
+                   copy: bool = True) -> QubitWaveFunction:
+        """
+        Create a dense wavefunction from a Numpy array.
 
-    def items(self):
-        return self.state.items()
+        :param array: Array of amplitudes.
+        :param numbering: Whether the first qubit is the most or least significant.
+        :param copy: Whether to copy the array or use it directly.
+            If False, the array must not be modified after the constructor.
+        :return: The created wavefunction.
+        """
+        if not log2(len(array)).is_integer():
+            raise ValueError(f"Array length must be a power of 2, received {len(array)}")
+        n_qubits = int(log2(len(array)))
+        result = QubitWaveFunction(n_qubits, numbering, dense=True, init_state=False)
+        result.set_state(array, copy)
+        return result
 
-    def keys(self):
-        return self.state.keys()
+    @classmethod
+    def from_basis_state(cls, n_qubits: int, basis_state: Union[int, BitString],
+                         numbering: BitNumbering = BitNumbering.MSB) -> QubitWaveFunction:
+        """
+        Create a sparse wavefunction that is a basis state.
 
-    def values(self):
-        return self.state.values()
+        :param n_qubits: Number of qubits.
+        :param basis_state: Index of the basis state.
+        :param numbering: Whether the first qubit is the most or least significant.
+        :return: The created wavefunction.
+        """
+        if 2 ** n_qubits <= basis_state:
+            raise ValueError(f"Number of qubits {n_qubits} insufficient for basis state {basis_state}")
+        if isinstance(basis_state, BitString):
+            basis_state = reverse_int_bits(basis_state.integer,
+                                           basis_state.nbits) if numbering != basis_state.numbering else basis_state.integer
+        result = QubitWaveFunction(n_qubits, numbering)
+        result[basis_state] = 1.0
+        return result
 
-    @staticmethod
-    def convert_bitstring(key: Union[BitString, numbers.Integral], n_qubits):
-        if isinstance(key, numbers.Integral):
-            return BitString.from_int(integer=key, nbits=n_qubits)
-        elif isinstance(key, str):
-            return BitString.from_binary(binary=key, nbits=n_qubits)
-        else:
-            return key
+    @classmethod
+    def from_string(cls, string: str, numbering: BitNumbering = BitNumbering.MSB) -> QubitWaveFunction:
+        """
+        Create a sparse wavefunction from a string.
 
-    def __getitem__(self, item: BitString):
-        key = self.convert_bitstring(item, self.n_qubits)
-        return self.state[key]
+        :param string: String representation of the wavefunction.
+        :param numbering: Whether the first qubit is the most or least significant.
+        :return: The created wavefunction.
+        """
+        try:
+            string = string.replace(" ", "")
+            string = string.replace("*", "")
+            terms = string.split(">")[:-1]
+            n_qubits = len(terms[0].split("|")[-1])
+            result = QubitWaveFunction(n_qubits, numbering)
+            for term in terms:
+                coeff, index = term.split("|")
+                coeff = complex(coeff) if coeff != "" else 1.0
+                index = int(index, 2)
+                result[index] = coeff
+            return result
+        except ValueError:
+            raise TequilaException(f"Failed to initialize QubitWaveFunction from string:\n\"{string}\"\n")
 
-    def __call__(self, key, *args, **kwargs) -> numbers.Number:
+    @classmethod
+    def convert_from(cls, n_qubits: int, val: Union[QubitWaveFunction, int, str, numpy.ndarray]):
         """
-        Like getitem but returns zero if key is not there
-
-        Parameters
-        ----------
-        key: bitstring (or int or str)
-        Returns
-        -------
-            Return the amplitude or measurement occurence of a bitstring
+        Convert a value to a QubitWaveFunction.
+        Accepts QubitWaveFunction, int, str, and numpy.ndarray.
+
+        :param n_qubits: Number of qubits.
+        :param val: Value to convert.
+        :return: The converted value.
         """
-        ckey = self.convert_bitstring(key, self.n_qubits)
-        if ckey in self.state:
-            return self.state[ckey]
+        if isinstance(val, QubitWaveFunction):
+            return val
+        elif isinstance(val, int):
+            return cls.from_basis_state(n_qubits=n_qubits, basis_state=val)
+        elif isinstance(val, str):
+            return cls.from_string(val)
+        elif isinstance(val, numpy.ndarray):
+            return cls.from_array(val)
         else:
-            return 0.0
+            raise TequilaException(f"Cannot initialize QubitWaveFunction from type {type(val)}")
 
+    @property
+    def n_qubits(self) -> int:
+        """
+        Returns number of qubits in the wavefunction.
+        """
+        return self._n_qubits
 
+    @property
+    def numbering(self) -> BitNumbering:
+        """
+        Returns the bit numbering of the wavefunction.
+        """
+        return self._numbering
 
-    def __setitem__(self, key: BitString, value: numbers.Number):
-        self._state[self.convert_bitstring(key, self.n_qubits)] = value
-        return self
-
-    def __contains__(self, item: BitString):
-        return self.convert_bitstring(item, self.n_qubits) in self.keys()
-
-    def __len__(self):
-        return len(self.state)
-
-    @classmethod
-    def from_array(cls, arr: numpy.ndarray, keymap=None, threshold: float = 1.e-6,
-                   numbering: BitNumbering = BitNumbering.MSB, n_qubits: int = None):
-        arr = numpy.asarray(arr)
-        assert (len(arr.shape) == 1)
-        state = dict()
-        maxkey = len(arr) - 1
-        maxbit = initialize_bitstring(integer=maxkey, numbering_in=numbering, numbering_out=cls.numbering).nbits
-        for ii, v in enumerate(arr):
-            i = initialize_bitstring(integer=ii, nbits=maxbit, numbering_in=numbering, numbering_out=cls.numbering)
-            if not numpy.isclose(abs(v), 0.0, atol=threshold):
-                key = i if keymap is None else keymap(i)
-                state[key] = v
-        result = QubitWaveFunction(state, n_qubits=n_qubits)
-
-        if cls.numbering != numbering:
-            if cls.numbering == BitNumbering.MSB:
-                result.apply_keymap(keymap=KeyMapLSB2MSB())
-            else:
-                result.apply_keymap(keymap=KeyMapMSB2LSB())
-
-        return result
+    @property
+    def dense(self) -> bool:
+        """
+        Returns whether the wavefunction is dense.
+        """
+        return self._dense
 
-    @classmethod
-    def from_int(cls, i: int, coeff=1, n_qubits: int = None):
-        if isinstance(i, BitString):
-            return QubitWaveFunction(state={i: coeff}, n_qubits=n_qubits)
+    def to_array(self, out_numbering: BitNumbering = BitNumbering.MSB, copy: bool = True) -> npt.NDArray[complex]:
+        """
+        Returns array of amplitudes.
+
+        :param out_numbering: Whether the first qubit is the most or least significant in the output array indices.
+            For dense wavefunctions, this operation is significantly cheaper when this is the same as the numbering
+            of the wavefunction.
+        :param copy: Whether to copy the array or use it directly for dense Wavefunctions.
+            If False, changes to the array or wavefunction will affect each other.
+        :return: Array of amplitudes.
+        """
+        if self._dense and self._numbering == out_numbering:
+            return self._state.copy() if copy else self._state
         else:
-            return QubitWaveFunction(state={BitString.from_int(integer=i, nbits=n_qubits): coeff}, n_qubits=n_qubits)
+            result = np.zeros(2 ** self._n_qubits, dtype=complex)
+            for k, v in self.raw_items():
+                if self._numbering != out_numbering:
+                    k = reverse_int_bits(k, self._n_qubits)
+                result[k] = v
+            return result
+
+    def set_state(self, value: npt.NDArray[complex], copy: bool = True) -> None:
+        """
+        Sets the state to an array.
+        After this call, the wavefunction will be dense.
 
-    @classmethod
-    def from_string(cls, string: str, n_qubits: int = None):
+        :param value: Array of amplitudes. Length must be 2 ** n_qubits.
+        :param copy: Whether to copy the array or use it directly.
+            If False, changes to the array or wavefunction will affect each other.
         """
-        Complex values like (x+iy)|...> will currently not work, you need to type Real and imaginary separately
-        Or improve this constructor :-)
-        e.g instead of (0.5+1.0j)|0101> do 0.5|0101> + 1.0j|0101>
-        :param paths:
-        :param string:
-        :return:
+        if len(value) != 2 ** self._n_qubits:
+            raise ValueError(f"Wavefunction of {self._n_qubits} qubits must have {2 ** self._n_qubits} amplitudes, "
+                             f"received {len(value)}")
+        self._dense = True
+        if copy:
+            self._state = value.copy()
+        else:
+            self._state = value
+
+    def __getitem__(self, key: Union[int, BitString]) -> complex:
+        if isinstance(key, BitString):
+            key = reverse_int_bits(key.integer, key.nbits) if self._numbering != key.numbering else key.integer
+        return self._state[key] if self._dense else self._state.get(key, 0)
+
+    def __setitem__(self, key: Union[int, BitString], value: complex) -> None:
+        if isinstance(key, BitString):
+            key = reverse_int_bits(key.integer, key.nbits) if self._numbering != key.numbering else key.integer
+        self._state[key] = value
+
+    def __contains__(self, item: Union[int, BitString]) -> bool:
+        if isinstance(item, BitString):
+            item = reverse_int_bits(item.integer, item.nbits) if self._numbering != item.numbering else item.integer
+        return abs(self[item]) > 1e-6
+
+    def raw_items(self) -> Generator[tuple[int, complex]]:
+        """Returns a generator of non-zero amplitudes with integer indices."""
+        return ((k, v) for k, v in (enumerate(self._state) if self._dense else self._state.items()))
+
+    def items(self) -> Generator[tuple[BitString, complex]]:
+        """Returns a generator of non-zero amplitudes with BitString indices."""
+        return ((initialize_bitstring(k, self._n_qubits, self._numbering), v)
+                for k, v in self.raw_items()
+                if isinstance(v, sympy.Basic) or abs(v) > 1e-6)
+
+    def keys(self) -> Generator[BitString]:
+        """Returns a generator of BitString indices of non-zero amplitudes."""
+        return (k for k, v in self.items())
+
+    def values(self) -> Generator[complex]:
+        """Returns a generator of non-zero amplitudes."""
+        return (v for k, v in self.items())
+
+    def __eq__(self, other) -> bool:
+        if not isinstance(other, QubitWaveFunction):
+            return False
+
+        raise TequilaException("Wavefunction equality is not well-defined. Consider using isclose.")
+
+    def isclose(self: QubitWaveFunction,
+                other: QubitWaveFunction,
+                rtol: float = 1e-5,
+                atol: float = 1e-8) -> bool:
         """
-        try:
-            state = dict()
-            string = string.replace(" ", "")
-            string = string.replace("*", "")
-            string = string.replace("+-", "-")
-            string = string.replace("-+", "-")
-            terms = (string + "terminate").split('>')
-            for term in terms:
-                if term == 'terminate':
-                    break
-                tmp = term.split("|")
-                coeff = tmp[0]
-                if coeff == '':
-                    coeff = 1.0
-                else:
-                    coeff = complex(coeff)
-                basis_state = BitString.from_binary(binary=tmp[1])
+        Check if two wavefunctions are close, up to a global phase.
 
-                state[basis_state] = coeff
-        except ValueError:
-            raise TequilaException("Failed to initialize QubitWaveFunction from string:" + string + "\n"
-                                                                                                    "did you try complex values?\n"
-                                                                                                    "currently you need to type real and imaginary parts separately\n"
-                                                                                                    "e.g. instead of (0.5+1.0j)|0101> do 0.5|0101> + 1.0j|0101>")
-        except:
-            raise TequilaException("Failed to initialize QubitWaveFunction from string:" + string)
-        return QubitWaveFunction(state=state, n_qubits=n_qubits)
+        :param other: The other wavefunction.
+        :param rtol: Relative tolerance.
+        :param atol: Absolute tolerance.
+        :return: Whether the wavefunctions are close.
+        """
+        inner = self.inner(other)
+        self_norm = self.norm()
+        other_norm = other.norm()
+        cosine_similarity = inner / (self_norm * other_norm)
 
-    def __repr__(self):
-        result = str()
-        for k, v in self.items():
-            result += number_to_string(number=v) + "|" + str(k.binary) + "> "
-        return result
+        return (np.isclose(abs(cosine_similarity), 1.0, rtol, atol)
+                and np.isclose(self_norm, other_norm, rtol, atol))
 
-    def __eq__(self, other):
-        raise TequilaException("Wavefunction equality is not well-defined. Consider using inner"
-                               + " product equality, wf1.isclose(wf2).")
-
-    def isclose(self :  'QubitWaveFunction',
-                other : 'QubitWaveFunction',
-                rtol : float=1e-5,
-                atol : float=1e-8) -> bool:
-        """Return whether this wavefunction is similar to the target wavefunction."""
-        over1 = complex(self.inner(other))
-        over2 = numpy.sqrt(complex(self.inner(self) * other.inner(other)))
-        # Explicit casts to complex() is required if self or other are sympy
-        # wavefunction with sympy-typed amplitudes
-
-        # Check if the two numbers are equal.
-        return numpy.isclose(over1, over2, rtol=rtol, atol=atol)
-
-    def __add__(self, other):
-        result = QubitWaveFunction(state=copy.deepcopy(self._state))
-        for k, v in other.items():
-            if k in result._state:
-                result._state[k] += v
-            else:
-                result._state[k] = v
-        return result
+    def __add__(self, other: QubitWaveFunction) -> QubitWaveFunction:
+        if self._dense and other._dense and self._numbering == other._numbering:
+            return QubitWaveFunction.from_array(self._state + other._state, self.numbering, copy=False)
+        else:
+            result = QubitWaveFunction.from_wavefunction(self)
+            result += other
+            return result
 
-    def __sub__(self, other):
-        return self + -1.0 * other
+    def __iadd__(self, other: QubitWaveFunction) -> QubitWaveFunction:
+        if self._dense and other._dense and self._numbering == other._numbering:
+            self._state += other._state
+        else:
+            for k, v in other.raw_items():
+                if self._numbering != other._numbering:
+                    k = reverse_int_bits(k, self._n_qubits)
+                self[k] += v
+        return self
+
+    def __sub__(self, other: QubitWaveFunction) -> QubitWaveFunction:
+        if self._dense and other._dense and self._numbering == other._numbering:
+            return QubitWaveFunction.from_array(self._state - other._state, self.numbering, copy=False)
+        else:
+            result = QubitWaveFunction.from_wavefunction(self)
+            result -= other
+            return result
 
-    def __iadd__(self, other):
-        for k, v in other.items():
-            if k in self._state:
-                self._state[k] += v
-            else:
-                self._state[k] = v
+    def __isub__(self, other: QubitWaveFunction) -> QubitWaveFunction:
+        if self._dense and other._dense and self._numbering == other._numbering:
+            self._state -= other._state
+        else:
+            for k, v in other.raw_items():
+                if self._numbering != other._numbering:
+                    k = reverse_int_bits(k, self._n_qubits)
+                self[k] -= v
         return self
 
-    def __rmul__(self, other):
-        result = QubitWaveFunction(state=copy.deepcopy(self._state))
-        for k, v in result._state.items():
-            result._state[k] *= other
-        return result
+    def __rmul__(self, other: complex) -> QubitWaveFunction:
+        if self._dense:
+            return QubitWaveFunction.from_array(other * self._state, self.numbering, copy=False)
+        else:
+            result = QubitWaveFunction.from_wavefunction(self)
+            result *= other
+            return result
 
-    def inner(self, other):
-        # currently very slow and not optimized in any way
-        result = 0.0
-        for k, v in self.items():
-            if k in other._state:
-                result += v.conjugate() * other._state[k]
-        return result
+    def __imul__(self, other: complex) -> QubitWaveFunction:
+        if self._dense:
+            self._state *= other
+        else:
+            for k, v in self.raw_items():
+                self[k] = other * v
+        return self
 
-    def normalize(self):
+    def inner(self, other: QubitWaveFunction) -> complex:
+        """Returns the inner product with another wavefunction."""
+        if self._dense and other._dense and self._numbering == other._numbering:
+            return np.inner(self._state.conjugate(), other._state)
+        else:
+            result = 0
+            for k, v in self.raw_items():
+                if self._numbering != other._numbering:
+                    k = reverse_int_bits(k, self._n_qubits)
+                result += v.conjugate() * other[k]
+            if isinstance(result, sympy.Basic):
+                result = complex(result)
+            return result
+
+    def norm(self) -> float:
+        """Returns the norm of the wavefunction."""
+        return np.sqrt(self.inner(self))
+
+    def normalize(self, inplace: bool = False) -> QubitWaveFunction:
         """
-        NOT AN Inplace operation
-        :return: Normalizes the wavefunction/countrate
+        Normalizes the wavefunction.
+
+        :param inplace: Whether to normalize the wavefunction in place or return a new one.
+        :return: The normalized wavefunction.
         """
-        norm2 = self.inner(other=self)
-        normalized = 1.0 / numpy.sqrt(norm2) * self
-        return normalized
+        norm = self.norm()
+        if inplace:
+            self *= 1.0 / norm
+            return self
+        else:
+            return (1.0 / norm) * QubitWaveFunction.from_wavefunction(self)
+
+    # It would be nice to call this __len__, however for some reason this causes infinite loops
+    # when multiplying wave functions with some types of numbers from the right sight, likely
+    # because the __mul__ implementation of the number tries to perform some sort of array
+    # operation.
+    def length(self):
+        return sum(1 for _ in self.raw_items())
+
+    def __repr__(self):
+        result = str()
+        for index, coeff in self.items():
+            index = index.integer
+            if self.numbering == BitNumbering.LSB:
+                index = reverse_int_bits(index, self._n_qubits)
+            result += f"{coeff} |{index:0{self._n_qubits}b}> "
+        # If the wavefunction contains no states
+        if not result:
+            result = "empty wavefunction"
+        return result
 
-    def compute_expectationvalue(self, operator: 'QubitHamiltonian') -> numbers.Real:
+    def compute_expectationvalue(self, operator: QubitHamiltonian) -> numbers.Real:
         tmp = self.apply_qubitoperator(operator=operator)
         E = self.inner(other=tmp)
-        if hasattr(E, "imag") and numpy.isclose(E.imag, 0.0, atol=1.e-6):
+        if hasattr(E, "imag") and np.isclose(E.imag, 0.0, atol=1.e-6):
             return float(E.real)
         else:
             return E
 
-    def apply_qubitoperator(self, operator: 'QubitHamiltonian'):
+    def apply_qubitoperator(self, operator: QubitHamiltonian) -> QubitWaveFunction:
         """
         Inefficient function which computes the action of a QubitHamiltonian on this wfn
         :param operator: QubitOperator
         :return: resulting Qubitwavefunction
         """
-        result = QubitWaveFunction()
+        result = QubitWaveFunction(self.n_qubits, self._numbering)
         for ps in operator.paulistrings:
             result += self.apply_paulistring(paulistring=ps)
-        result = result.simplify()
         return result
 
-    def apply_paulistring(self, paulistring: 'PauliString'):
+    def apply_paulistring(self, paulistring: PauliString) -> QubitWaveFunction:
         """
         Inefficient function which computes action of a single paulistring
         :param paulistring: PauliString
         :return: Expectation Value
         """
-        result = QubitWaveFunction()
+        result = QubitWaveFunction(self._n_qubits, self._numbering)
         for k, v in self.items():
             arr = k.array
             c = v
@@ -312,17 +420,3 @@ class QubitWaveFunction:
                     raise TequilaException("unknown pauli: " + str(p))
             result[BitString.from_array(array=arr)] = c
         return paulistring.coeff * result
-
-    def to_array(self):
-        result = numpy.zeros(shape=2 ** self.n_qubits, dtype=complex)
-        for k, v in self.items():
-            result[int(k)] = v
-        return result
-
-    def simplify(self, threshold = 1.e-8):
-        state = {}
-        for k, v in self.state.items():
-            if not numpy.isclose(v, 0.0, atol=threshold):
-                state[k] = v
-        return QubitWaveFunction(state=state)
-