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

tequila/tools/random_generators.py

@@ -4,8 +4,10 @@ from tequila.circuit.circuit import QCircuit
 from tequila.hamiltonian.qubit_hamiltonian import QubitHamiltonian
 from scipy.stats import unitary_group, ortho_group
 
-def make_random_circuit(n_qubits: int, rotation_gates: list=['rx', 'ry', 'rz'], n_rotations: int=None,
-                        enable_controls: bool=None) -> QCircuit:
+
+def make_random_circuit(
+    n_qubits: int, rotation_gates: list = ["rx", "ry", "rz"], n_rotations: int = None, enable_controls: bool = None
+) -> QCircuit:
     """Function that creates a circuit with random rotations or random control rotations.
 
     Args:
@@ -15,37 +17,38 @@ def make_random_circuit(n_qubits: int, rotation_gates: list=['rx', 'ry', 'rz'],
         enable_controls (bool): Boolean that switch on controls. Default to None.
 
     Returns:
-        QCircuit: Random quantum circuit consiting of the given rotations gates 
+        QCircuit: Random quantum circuit consiting of the given rotations gates
         and their controlled versions
     """
     if n_rotations is None:
-        n_rotations = np.random.randint(n_qubits, high=n_qubits*3)
+        n_rotations = np.random.randint(n_qubits, high=n_qubits * 3)
 
     gates_list = [np.random.choice(rotation_gates) for i in range(n_rotations)]
-    
-    angles = 2*np.pi * np.random.rand(n_rotations)
-    
+
+    angles = 2 * np.pi * np.random.rand(n_rotations)
+
     circ = QCircuit()
     for i, angle in enumerate(angles):
-        target = i%n_qubits
+        target = i % n_qubits
         if enable_controls:
             controls = [i for i in circ.qubits if i != target]
             control = np.random.choice(controls + [None])
-        else: 
+        else:
             control = None
 
-        if gates_list[i]=='rx':
+        if gates_list[i] == "rx":
             circ += gates.Rx(angle=angle, target=target, control=control)
-        
-        elif gates_list[i]=='ry':
+
+        elif gates_list[i] == "ry":
             circ += gates.Ry(angle=angle, target=target, control=control)
-            
-        elif gates_list[i]=='rz':
+
+        elif gates_list[i] == "rz":
             circ += gates.Rz(angle=angle, target=target, control=control)
-        
+
     return circ
 
-def make_random_hamiltonian(n_qubits: int , paulis: list=['X','Y','Z'], n_ps: int = None) -> QubitHamiltonian:
+
+def make_random_hamiltonian(n_qubits: int, paulis: list = ["X", "Y", "Z"], n_ps: int = None) -> QubitHamiltonian:
     """Function that creates a random Hamiltonian, given the list
        of Pauli ops. to use and the number of Pauli strings.
 
@@ -58,27 +61,28 @@ def make_random_hamiltonian(n_qubits: int , paulis: list=['X','Y','Z'], n_ps: in
         tq.QubitHamiltonian: Random Hamiltonian
     """
     if n_ps is None:
-        n_ps = np.random.randint(1, high=2*n_qubits+1)
-    
-    ham = ''
+        n_ps = np.random.randint(1, high=2 * n_qubits + 1)
+
+    ham = ""
     for ps in range(n_ps):
-        coeff = '{}*'.format(round(np.random.sample(),2))
-        pauli_str = ''
+        coeff = "{}*".format(round(np.random.sample(), 2))
+        pauli_str = ""
         for qb in range(n_qubits):
-            pauli_str += '{}({})'.format(np.random.choice(paulis), qb)
-        
-        if ps < n_ps-1:
-            pauli_str += '+'
-                
-        ham += coeff+pauli_str
-    
-    #print(ham)
-    
+            pauli_str += "{}({})".format(np.random.choice(paulis), qb)
+
+        if ps < n_ps - 1:
+            pauli_str += "+"
+
+        ham += coeff + pauli_str
+
+    # print(ham)
+
     H = QubitHamiltonian(ham)
     return H
 
-def generate_random_unitary(size, complex = False):
-    '''
+
+def generate_random_unitary(size, complex=False):
+    """
     Generates a random unitary (or furthermore orthogonal if complex is False) matrix of a specified size.
 
     Parameters:
@@ -87,8 +91,8 @@ def generate_random_unitary(size, complex = False):
 
     Returns:
     - numpy.ndarray: A randomly generated unitary matrix.
-    '''
+    """
     if complex:
         return unitary_group.rvs(size)
     else:
-        return ortho_group.rvs(size)
+        return ortho_group.rvs(size)

tequila/utils/bitstrings.py

@@ -43,14 +43,14 @@ class BitString:
     @property
     def binary(self):
         if self.numbering is BitNumbering.MSB:
-            return format(self._value, 'b').zfill(self.nbits)
+            return format(self._value, "b").zfill(self.nbits)
         else:
-            return format(self._value, 'b').zfill(self.nbits)[::-1]
+            return format(self._value, "b").zfill(self.nbits)[::-1]
 
     @binary.setter
     def binary(self, other: str):
-        assert (isinstance(other, str))
-        if other.startswith('0b'):
+        assert isinstance(other, str)
+        if other.startswith("0b"):
             other = other[2:]
         if self.numbering == BitNumbering.LSB:
             self._value = int(other[::-1], 2)
@@ -69,6 +69,12 @@ class BitString:
         self.update_nbits()
         return self
 
+    def to_integer(self, numbering: BitNumbering):
+        if numbering == self.numbering:
+            return self.integer
+        else:
+            return reverse_int_bits(self.integer, self.nbits)
+
     @property
     def array(self):
         return [int(i) for i in self.binary]
@@ -172,7 +178,6 @@ class BitString:
 
 
 class BitStringLSB(BitString):
-
     @property
     def numbering(self) -> BitNumbering:
         return BitNumbering.LSB
@@ -191,8 +196,9 @@ def reverse_int_bits(x: int, nbits: int) -> int:
     return x >> (32 - nbits)
 
 
-def initialize_bitstring(integer: int, nbits: int = None, numbering_in: BitNumbering = BitNumbering.MSB,
-                         numbering_out: BitNumbering = None):
+def initialize_bitstring(
+    integer: int, nbits: int = None, numbering_in: BitNumbering = BitNumbering.MSB, numbering_out: BitNumbering = None
+):
     if numbering_out is None:
         numbering_out = numbering_in
 

tequila/utils/exceptions.py

@@ -31,9 +31,16 @@ class TequilaParameterError(TequilaException):
     """
 
     def __init__(self, parameter_name, parameter_class, parameter_value, called_from=""):
-        self.message = "OpenVQE ParameterError:" + called_from + " unknown parameter value: " + str(
-            parameter_name) + "=" + str(
-            parameter_value) + " for " + str(parameter_class)
+        self.message = (
+            "OpenVQE ParameterError:"
+            + called_from
+            + " unknown parameter value: "
+            + str(parameter_name)
+            + "="
+            + str(parameter_value)
+            + " for "
+            + str(parameter_class)
+        )
 
 
 class TequilaTypeError(TequilaException):
@@ -42,5 +49,12 @@ class TequilaTypeError(TequilaException):
     """
 
     def __init__(self, attr, type, expected):
-        self.message = "OpenVQE TypeError: " + "excpected type: " + str(expected) + " but got type " + str(
-            type) + " for attribute " + str(attr)
+        self.message = (
+            "OpenVQE TypeError: "
+            + "excpected type: "
+            + str(expected)
+            + " but got type "
+            + str(type)
+            + " for attribute "
+            + str(attr)
+        )

tequila/utils/joined_transformation.py

@@ -1,12 +1,12 @@
 class JoinedTransformation:
-    '''
+    """
     class structure used to construct,track, and permit differentiation of the computation required
     by mathematical operations on ExpectationValues,Variables and Objectives thereof.
     JoinedTransformations allow operations to be combined.
-    '''
+    """
 
     def __init__(self, left, right, split, op):
-        '''
+        """
         :param left: Callable: the lefthand operation, one level down
         :param right: Callable: the righthand operation, one level down
         :param split: Int: the position in the call method, at which lefthand and righthand arguments split
@@ -15,21 +15,21 @@ class JoinedTransformation:
         Example: split 2, left = numpy.add, right= numpy.subtract, op = numpy.multiply, call on list of length 4:
         then the Joined Transform performs the following computation when called:
         np.Multiply(np.add(arg_0,arg_1),np.subtract(arg_2,arg_3))
-        '''
+        """
         self.split = split
         self.left = left
         self.right = right
         self.op = op
 
     def __call__(self, *args, **kwargs):
-        '''
+        """
 
         :param args: iter: the arguments to the transformation.
         :param kwargs: dict: keyword arguments to the transformation. Must be uniform.
         :return: a number, the result of the calculation.
-        '''
-        E_left = args[:self.split]
-        E_right = args[self.split:]
+        """
+        E_left = args[: self.split]
+        E_right = args[self.split :]
         if self.op is None:
             if len(args) == 1:
                 return args[0]
@@ -39,13 +39,11 @@ class JoinedTransformation:
                 print(len(args))
                 return self.op(*args)
             else:
-
                 return self.op(self.left(*E_left, **kwargs), *E_right)
         if self.left is None:
             if self.right is None:
                 return self.op(*args)
             else:
-
                 return self.op(*E_left, self.right(*E_right, **kwargs))
         else:
             return self.op(self.left(*E_left, **kwargs), self.right(*E_right, **kwargs))

tequila/utils/keymap.py

@@ -4,7 +4,6 @@ from tequila import BitNumbering, BitString, BitStringLSB
 
 
 class KeyMapABC:
-
     @property
     def n_qubits(self):
         return None
@@ -18,7 +17,6 @@ class KeyMapABC:
 
 
 class KeyMapLSB2MSB(KeyMapABC):
-
     def __call__(self, input_state: BitStringLSB, initial_state: int = None) -> BitString:
         if isinstance(input_state, numbers.Integral):
             return BitString.from_int(integer=input_state)
@@ -27,7 +25,6 @@ class KeyMapLSB2MSB(KeyMapABC):
 
 
 class KeyMapMSB2LSB(KeyMapABC):
-
     @property
     def numbering(self) -> BitNumbering:
         return BitNumbering.LSB
@@ -40,7 +37,6 @@ class KeyMapMSB2LSB(KeyMapABC):
 
 
 class KeyMapSubregisterToRegister(KeyMapABC):
-
     @property
     def n_qubits(self):
         return len(self.register)
@@ -93,7 +89,6 @@ class KeyMapSubregisterToRegister(KeyMapABC):
 
 
 class KeyMapRegisterToSubregister(KeyMapSubregisterToRegister):
-
     def __call__(self, input_state: BitString, initial_state: BitString = None) -> BitString:
         """
         Map from register to subregister

tequila/utils/misc.py

@@ -7,20 +7,22 @@ def to_float(number) -> float:
     """
 
     if hasattr(number, "imag"):
-        if isclose(number.imag, 0.0, atol=1.e-6):
+        if isclose(number.imag, 0.0, atol=1.0e-6):
             return float64(number.real)
         else:
             raise TypeError("imaginary part detected {number}".format(number=number))
     elif hasattr(number, "evalf"):
         tmp = complex64(number.evalf())
-        if hasattr(tmp, "imag") and isclose(tmp.imag, 0.0, atol=1.e-6):
+        if hasattr(tmp, "imag") and isclose(tmp.imag, 0.0, atol=1.0e-6):
             return float64(tmp.real)
         else:
             raise TypeError(
-                "casting number {number} of type {type} fo float failed".format(number=number, type=type(number)))
+                "casting number {number} of type {type} fo float failed".format(number=number, type=type(number))
+            )
     else:
         try:
             return float64(number)
         except TypeError:
             raise TypeError(
-                "casting number {number} of type {type} fo float failed".format(number=number, type=type(number)))
+                "casting number {number} of type {type} fo float failed".format(number=number, type=type(number))
+            )

tequila/version.py

@@ -1,2 +1,2 @@
-__version__ = "1.9.8"
+__version__ = "1.9.10"
 __author__ = "Tequila Developers "

tequila/wavefunction/qubit_wavefunction.py

@@ -28,8 +28,9 @@ class QubitWaveFunction:
     Does not enforce normalization.
     """
 
-    def __init__(self, n_qubits: int, numbering: BitNumbering = BitNumbering.MSB, dense: bool = False,
-                 init_state: bool = True) -> None:
+    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.
 
@@ -43,13 +44,14 @@ class QubitWaveFunction:
         self._numbering = numbering
         self._dense = dense
         if init_state:
-            self._state = np.zeros(2 ** self._n_qubits, dtype=complex) if dense else dict()
+            self._state = np.zeros(2**self._n_qubits, dtype=complex) if dense else dict()
         else:
             self._state = None
 
     @classmethod
-    def from_wavefunction(cls, wfn: QubitWaveFunction, keymap: KeyMapABC = None, n_qubits: int = None,
-                          initial_state: BitString = None) -> QubitWaveFunction:
+    def from_wavefunction(
+        cls, wfn: QubitWaveFunction, keymap: KeyMapABC = None, n_qubits: int = None, initial_state: BitString = None
+    ) -> QubitWaveFunction:
         """
         Create a copy of a wavefunction.
 
@@ -66,7 +68,9 @@ class QubitWaveFunction:
             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 = initialize_bitstring(
+                    index, wfn._n_qubits, numbering_in=wfn._numbering, numbering_out=keymap.numbering
+                )
                 key = keymap(key, initial_state)
                 result[key] += coeff
             return result
@@ -74,8 +78,9 @@ class QubitWaveFunction:
             return deepcopy(wfn)
 
     @classmethod
-    def from_array(cls, array: npt.NDArray[complex], numbering: BitNumbering = BitNumbering.MSB,
-                   copy: bool = True) -> QubitWaveFunction:
+    def from_array(
+        cls, array: npt.NDArray[complex], numbering: BitNumbering = BitNumbering.MSB, copy: bool = True
+    ) -> QubitWaveFunction:
         """
         Create a dense wavefunction from a Numpy array.
 
@@ -93,8 +98,9 @@ class QubitWaveFunction:
         return result
 
     @classmethod
-    def from_basis_state(cls, n_qubits: int, basis_state: Union[int, BitString],
-                         numbering: BitNumbering = BitNumbering.MSB) -> QubitWaveFunction:
+    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.
 
@@ -103,11 +109,14 @@ class QubitWaveFunction:
         :param numbering: Whether the first qubit is the most or least significant.
         :return: The created wavefunction.
         """
-        if 2 ** n_qubits <= basis_state:
+        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
+            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
@@ -134,7 +143,7 @@ class QubitWaveFunction:
                 result[index] = coeff
             return result
         except ValueError:
-            raise TequilaException(f"Failed to initialize QubitWaveFunction from string:\n\"{string}\"\n")
+            raise TequilaException(f'Failed to initialize QubitWaveFunction from string:\n"{string}"\n')
 
     @classmethod
     def convert_from(cls, n_qubits: int, val: Union[QubitWaveFunction, int, str, numpy.ndarray]):
@@ -192,7 +201,7 @@ class QubitWaveFunction:
         if self._dense and self._numbering == out_numbering:
             return self._state.copy() if copy else self._state
         else:
-            result = np.zeros(2 ** self._n_qubits, dtype=complex)
+            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)
@@ -208,9 +217,11 @@ class QubitWaveFunction:
         :param copy: Whether to copy the array or use it directly.
             If False, changes to the array or wavefunction will affect each other.
         """
-        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)}")
+        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()
@@ -238,9 +249,11 @@ class QubitWaveFunction:
 
     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)
+        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."""
@@ -256,16 +269,20 @@ class QubitWaveFunction:
 
         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:
+    def isclose(
+        self: QubitWaveFunction,
+        other: QubitWaveFunction,
+        rtol: float = 1e-5,
+        atol: float = 1e-8,
+        ignore_global_phase: bool = True,
+    ) -> bool:
         """
         Check if two wavefunctions are close, up to a global phase.
 
         :param other: The other wavefunction.
         :param rtol: Relative tolerance.
         :param atol: Absolute tolerance.
+        :param ignore_global_phase: Whether to ignore global phase differences.
         :return: Whether the wavefunctions are close.
         """
         inner = self.inner(other)
@@ -273,8 +290,10 @@ class QubitWaveFunction:
         other_norm = other.norm()
         cosine_similarity = inner / (self_norm * other_norm)
 
-        return (np.isclose(abs(cosine_similarity), 1.0, rtol, atol)
-                and np.isclose(self_norm, other_norm, rtol, atol))
+        if ignore_global_phase:
+            cosine_similarity = abs(cosine_similarity)
+
+        return np.isclose(cosine_similarity, 1.0, rtol, atol) and np.isclose(self_norm, other_norm, rtol, atol)
 
     def __add__(self, other: QubitWaveFunction) -> QubitWaveFunction:
         if self._dense and other._dense and self._numbering == other._numbering:
@@ -365,7 +384,7 @@ class QubitWaveFunction:
     # 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())
+        return sum(1 for (k, v) in self.raw_items() if abs(v) > 1e-6)
 
     def __repr__(self):
         result = str()
@@ -373,7 +392,10 @@ class QubitWaveFunction:
             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 np.isclose(coeff.imag, 0.0):
+                result += f"{coeff.real:+2.4f} |{index:0{self._n_qubits}b}> "
+            else:
+                result += f"({coeff.real:+2.4f} + {coeff.imag:+2.4f}i) |{index:0{self._n_qubits}b}> "
         # If the wavefunction contains no states
         if not result:
             result = "empty wavefunction"
@@ -382,7 +404,7 @@ class QubitWaveFunction:
     def compute_expectationvalue(self, operator: QubitHamiltonian) -> numbers.Real:
         tmp = self.apply_qubitoperator(operator=operator)
         E = self.inner(other=tmp)
-        if hasattr(E, "imag") and np.isclose(E.imag, 0.0, atol=1.e-6):
+        if hasattr(E, "imag") and np.isclose(E.imag, 0.0, atol=1.0e-6):
             return float(E.real)
         else:
             return E

{tequila_basic-1.9.8.dist-info → tequila_basic-1.9.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: tequila-basic
-Version: 1.9.8
+Version: 1.9.10
 Summary: A High-Level Abstraction Framework for Quantum Algorithms
 Home-page: https://github.com/tequilahub/tequila
 Author: Tequila Developers 
@@ -15,6 +15,15 @@ Requires-Dist: setuptools
 Requires-Dist: pytest
 Requires-Dist: openfermion~=1.0
 Requires-Dist: dataclasses; python_version < "3.7"
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-lightgrey.svg)](LICENCE) [![DOI](https://zenodo.org/badge/259718912.svg)](https://zenodo.org/badge/latestdoi/259718912) [![PyPI version](https://badge.fury.io/py/tequila-basic.svg)](https://badge.fury.io/py/tequila-basic) ![CI](https://github.com/tequilahub/tequila/actions/workflows/ci_basic.yml/badge.svg)
 
@@ -27,7 +36,8 @@ Tequila can execute the underlying quantum expectation values on state of the ar
 # Getting Started
 
 Get started with our collection of  
-- *[Tutorials](https://tequilahub.github.io/tequila-tutorials/)*  
+- *[Tutorials](https://tequilahub.github.io/tequila-tutorials/)*
+- *[Documentation](https://tequilahub.github.io/tequila-tutorials/docs/sphinx/)*  
 
 Further sources:
 - [overview article](https://arxiv.org/abs/2011.03057)   
@@ -35,8 +45,8 @@ Further sources:
 - [talks and slides](https://kottmanj.github.io/talks_and_material/)  
 
 # Installation
-Recommended Python version is 3.9 (3.10).   
-Tequila supports linux, osx and windows. However, not all optional dependencies are supported on windows.  
+Recommended Python version is 3.10 (3.11).   
+Tequila supports linux, osx and windows. However, not all optional dependencies (especially chemistry) are supported on windows.  
 
 ## Install from PyPi
 **Do not** install like this: (Minecraft lovers excluded)
@@ -47,7 +57,7 @@ You can install tequila from PyPi as:
 pip install tequila-basic
 ```
 this will install tequila with all essential dependencies.
-We recommend to install some fast quantum backends, like qulacs or qibo, as well.
+We recommend to install some fast quantum backends, like qulacs, as well.
 Those can be installed before or after you install tequila.
 ```bash
 # install basic tequila
@@ -148,7 +158,7 @@ print("VQE : {:+2.8}f".format(result.energy))
 print("FCI : {:+2.8}f".format(fci))
 ```
 
-Do you want to create your own methods? Check out the [tutorials](https://github.com/tequilahub/tequila-tutorials)!
+Do you want to create your own methods? Check out the [tutorials]([https://github.com/tequilahub/tequila-tutorials](https://tequilahub.github.io/tequila-tutorials/))!
 
 # Some Research projects using Tequila
 J.S. Kottmann, A. Anand, A. Aspuru-Guzik.  
@@ -313,12 +323,7 @@ pip install pyscf
 Works similar as Psi4. Classical methods are also integrated in the madness interface allowing to use them in a basis-set-free representation.
 
 # Documentation
-You can build the documentation by navigating to `docs` and entering `make html`.
-Open the documentation with a browser over like `firefox docs/build/html/index.html`
-Note that you will need some additional python packages like `sphinx` and `mr2` that are not explicitly listed in the requirements.txt
-
-You can also visit our prebuild online [documentation](https://tequilahub.github.io/tequila/)
-that will correspond to the github master branch
+see [here](https://tequilahub.github.io/tequila-tutorials/docs/sphinx/)  
 
 # How to contribute
 If you find any bugs or inconveniences in `tequila` please don't be shy and let us know.
@@ -330,9 +335,11 @@ Here is how that works:
 1. Make a fork of `tequila` to your own github account.
 2. Checkout the `devel` branch and make sure it is up to date with the main [github repository](https://github.com/aspuru-guzik-group/tequila).
 3. Create and checkout a new branch from `devel` via `git branch pr-my-branch-name` followed by `git checkout pr-my-branch-name`. By typing `git branch` afterwards you can check which branch is currently checked out on your computer.
-4. Introduce changes to the code and commit them with git.
-5. Push the changes to *your* github account
-6. Log into github and create a pull request to the main [github repository](https://github.com/aspuru-guzik-group/tequila). The pull-request should be directed to the `devel` branch (but we can also change that afterwards).
+4. Introduce changes to the code.
+5. Format your code using [Ruff](https://github.com/astral-sh/ruff).
+  You can install Ruff with `pip install ruff`, then run the formatter with `ruff format` and the linter with `ruff check` (most IDEs also provide a way of integrating Ruff and doing this automatically).
+6. Commit them with git and push the changes to *your* github account
+7. Log into github and create a pull request to the main [github repository](https://github.com/aspuru-guzik-group/tequila). The pull-request should be directed to the `devel` branch (but we can also change that afterwards).
 
 If you plan to introduce major changes to the base library it can be beneficial to contact us first.
 This way we might be able to avoid conflicts before they arise.
@@ -400,4 +407,3 @@ They can be installed for example over visual studio.
 Tequila runs on Mac OSX.
 You might get in trouble with installing qulacs since it currently does not work with Apple's clang compiler.
 You need to install latest GNU compile (at least gcc-7 and g++7) and set them as default before installing qulacs over pip.
-