tequila-basic 1.9.10__tar.gz → 1.9.11__tar.gz

{tequila_basic-1.9.10/src/tequila_basic.egg-info → tequila_basic-1.9.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tequila-basic
-Version: 1.9.10
+Version: 1.9.11
 Summary: A High-Level Abstraction Framework for Quantum Algorithms
 Home-page: https://github.com/tequilahub/tequila
 Author: Tequila Developers 

{tequila_basic-1.9.10 → tequila_basic-1.9.11}/src/tequila/__init__.py

@@ -18,6 +18,7 @@ from tequila.optimizers import minimize, minimize_scipy, minimize_gd, optimizer_
 
 from tequila.simulators.simulator_api import (
     simulate,
+    simulate_density,
     compile,
     compile_to_function,
     draw,

{tequila_basic-1.9.10 → tequila_basic-1.9.11}/src/tequila/apps/__init__.py

@@ -10,7 +10,7 @@ def gem(circuits: list, H, variables: dict = None, *args, **kwargs):
     with matries Hij = <i|H|j>, Sij = <i|j> and states |i> = U[i]|00...0> generated by the circuits given
     returns the energies E and vectors C (same format as numpy.linalg.eigh)
     the total wavefunction for energy i is then:
-    |E(i)> = \sum_k C[k,i] U[k] |0..0>
+    |E(i)> = \\sum_k C[k,i] U[k] |0..0>
 
     Parameters
     ----------

{tequila_basic-1.9.10 → tequila_basic-1.9.11}/src/tequila/circuit/_gates_impl.py

@@ -242,7 +242,7 @@ class DifferentiableGateImpl(ParametrizedGateImpl):
         -------
             List of Tuples: [(weight, shifted_gate), (weight, shifted_gate)]
             The gradient compiler will assemble this the following way
-            <H>_U with U = AU(a)B --> \sum weight <H>_V , with V=A shifted_gate
+            <H>_U with U = AU(a)B --> \\sum weight <H>_V , with V=A shifted_gate
 
             shifted_gate can also be a whole circuit (either as QCircuit object or a list of gates)
         """

{tequila_basic-1.9.10 → tequila_basic-1.9.11}/src/tequila/circuit/circuit.py

@@ -63,6 +63,9 @@ class QCircuit:
         moms = []
         moms.append(Moment())
         for g in self.gates:
+            if not g.qubits:
+                continue
+
             qus = g.qubits
             spots = [table[q] for q in qus]
 

{tequila_basic-1.9.10 → tequila_basic-1.9.11}/src/tequila/circuit/gates.py

@@ -89,13 +89,12 @@ def I(
     target: typing.Union[list, int], control: typing.Union[list, int] = None, power=None, angle=None, *args, **kwargs
 ) -> QCircuit:
     """
-    This function provides a primitive implementation of the identity gate as a place
-    holder gate with no physical effect.
-    The user can add this gate into the circuit and get it also when
-    calling functions regarding the circuit's stats (i.e. gates included)
+    A gate that has no effect, but can be used to mark a qubit as being used.
+    This can for example be useful if a qubit is only being used in some variants
+    of a circuit, but you want to prevent the output format from changing.
     """
-    # zero generator for a no-operation gate
-    generator = lambda q: 0
+    # Ugly workaround, we can't simply use paulis.Zero() because this wouldn't mark the qubit as being used.
+    generator = lambda q: 0 * paulis.X(q)
     return _initialize_power_gate(
         name="I", power=power, angle=angle, target=target, control=control, generator=generator, *args, **kwargs
     )

{tequila_basic-1.9.10 → tequila_basic-1.9.11}/src/tequila/hamiltonian/paulis.py

@@ -296,7 +296,7 @@ def KetBra(
          QubitWaveFunction which defines the bra element
          can also be given as string or array or integer
     hermitian: bool: (Default False)
-         if True the hermitian version H + H^\dagger is returned
+         if True the hermitian version H + H^\\dagger is returned
     threshold: float: (Default 1.e-6)
          elements smaller than the threshold will be ignored
     n_qubits: only needed if ket and/or bra are passed down as integers

{tequila_basic-1.9.10 → tequila_basic-1.9.11}/src/tequila/hamiltonian/qubit_hamiltonian.py

@@ -591,7 +591,7 @@ class QubitHamiltonian:
                 Take for example X(1).
                 If False the operator X(1) will get mapped to X(0)
                 and the function will return the matrix for X(0)
-                otherwise the function will return the matrix 1 \otimes X(1)
+                otherwise the function will return the matrix 1 \\otimes X(1)
 
         :return: np.ndarray(2**N, 2**N) with type complex
 
@@ -676,3 +676,6 @@ class QubitHamiltonian:
             if not p.is_all_z():
                 return False
         return True
+
+    def constant(self):
+        return self._qubit_operator.constant

{tequila_basic-1.9.10 → tequila_basic-1.9.11}/src/tequila/objective/braket.py

@@ -18,7 +18,7 @@ def Fidelity(bra, ket, *args, **kwargs):
     -----
     Initializes an ancilla free implementation using:
     |<A|B>|^2 = <A|B><B|A><0|VAUB|0><0|VBUA|0> = <P0>_{VBAU}
-    VA = U^\dagger_A
+    VA = U^\\dagger_A
     P0 = |0..0><0..0|
     see: https://arxiv.org/abs/2006.03075 Eq.3-4
     or https://arxiv.org/abs/2011.05938 Eq.57

{tequila_basic-1.9.10 → tequila_basic-1.9.11}/src/tequila/optimizers/optimizer_gd.py

@@ -404,7 +404,7 @@ class OptimizerGD(Optimizer):
         comp = self.compile_objective(objective=objective)
         for arg in comp.args:
             if hasattr(arg, "U"):
-                if arg.U.device is not None:
+                if hasattr(arg.U, "device") and arg.U.device is not None:
                     # don't retrieve computer 100 times; pyquil errors out if this happens!
                     self.device = arg.U.device
                     break

{tequila_basic-1.9.10 → tequila_basic-1.9.11}/src/tequila/quantumchemistry/encodings.py

@@ -213,7 +213,7 @@ class JordanWigner(EncodingBase):
         return openfermion.jordan_wigner(fermion_operator, *args, **kwargs)
 
     def map_state(self, state: list, *args, **kwargs):
-        state = state + [0] * (self.n_orbitals - len(state))
+        state = state + [0] * (2 * self.n_orbitals - len(state))
         result = [0] * len(state)
         if self.up_then_down:
             return [state[2 * i] for i in range(self.n_orbitals)] + [state[2 * i + 1] for i in range(self.n_orbitals)]

{tequila_basic-1.9.10 → tequila_basic-1.9.11}/src/tequila/quantumchemistry/orbital_optimizer.py

@@ -50,6 +50,8 @@ def optimize_orbitals(
     molecule_factory=None,
     molecule_arguments=None,
     restrict_to_active_space=True,
+    read_chkfile: str = None,
+    save_chkfile: str = None,
     *args,
     **kwargs,
 ):
@@ -76,6 +78,8 @@ def optimize_orbitals(
                         This initialized a random guess using numpy.random.normal(loc=X, scale=Y) with X=0.0 and Y=0.1 as defaults
     return_mcscf: return the PySCF MCSCF structure after optimization
     molecule_arguments: arguments to pass to molecule_factory or default molecule constructor | only change if you know what you are doing
+    read_chkfile: checkpoint file to read the initial orbitals during the CASSCF optimization. For more info see https://pyscf.org/_modules/pyscf/mcscf/chkfile.html#load_mcscf
+    save_chkfile: checkpoint file to save the intermediate orbitals during the CASSCF optimization.
     args: just here for convenience
     kwargs: just here for conveniece
 
@@ -85,7 +89,7 @@ def optimize_orbitals(
     """
 
     try:
-        from pyscf import mcscf
+        from pyscf import mcscf, lib
         from . import QuantumChemistryPySCF
     except Exception as exception:
         raise Exception("{}\noptimize_orbitals: Need pyscf to run (pip install pyscf)".format(str(exception)))
@@ -103,6 +107,8 @@ def optimize_orbitals(
     result = OptimizeOrbitalsResult()
     mc = mcscf.CASSCF(mf, pyscf_molecule.n_orbitals, pyscf_molecule.n_electrons)
     mc.callback = result
+    if save_chkfile is not None:
+        mc.chkfile = save_chkfile
     c = pyscf_molecule.compute_constant_part()
 
     if circuit is None and vqe_solver is None:
@@ -170,10 +176,14 @@ def optimize_orbitals(
         assert initial_guess.shape[1] == no
         initial_guess = mcscf.project_init_guess(mc, initial_guess)
         mc.kernel(mo_coeff=initial_guess)
+    elif read_chkfile is not None:
+        chk = lib.chkfile.load(read_chkfile, "mcscf")
+        mo_coeff = chk["mo_coeff"]
+        ci0 = chk["ci"] if "ci" in chk.keys() else None
+        mc.kernel(mo_coeff=mo_coeff, ci0=ci0)
     else:
         mc.kernel()
     # make new molecule
-
     mo_coeff = mc.mo_coeff
     transformed_molecule = pyscf_molecule.transform_orbitals(orbital_coefficients=mo_coeff, name="optimized")
     result.molecule = transformed_molecule

{tequila_basic-1.9.10 → tequila_basic-1.9.11}/src/tequila/quantumchemistry/pyscf_interface.py

@@ -1,12 +1,15 @@
 from tequila import TequilaException, QubitWaveFunction
 from tequila.quantumchemistry.qc_base import QuantumChemistryBase
+from tequila.quantumchemistry.encodings import JordanWigner
 from tequila.quantumchemistry import ParametersQC, NBodyTensor
 import pyscf
+from pyscf import fci
 
 from .chemistry_tools import OrbitalData
 
 import numpy
 import typing
+import warnings
 
 
 def _merge_alpha_beta_strs(alpha_str, beta_str, norb):
@@ -112,27 +115,128 @@ class QuantumChemistryPySCF(QuantumChemistryBase):
 
         super().__init__(parameters=parameters, transformation=transformation, orbitals=orbitals, *args, **kwargs)
 
-    def compute_fci(self, get_wfn=False, **kwargs):
-        from pyscf import fci
-
+    def compute_fci(self, get_wfn=False, ci0=None, use_hcb=False, **kwargs):
         c, h1, h2 = self.get_integrals(ordering="chem")
         norb = self.n_orbitals
         nelec = self.n_electrons
-        e, fcivec = fci.direct_spin1.kernel(h1, h2.elems, norb, nelec, **kwargs)
+
+        if ci0 is not None:
+            ci0 = self.create_ci_vector(ci0, use_hcb=use_hcb)
+
+        e, fcivecs = fci.direct_spin1.kernel(
+            h1, h2.elems, norb, nelec, max_cycle=2000, max_space=100, ci0=ci0, **kwargs
+        )
 
         if get_wfn:
-            alpha_strs = fci.cistring.make_strings(range(norb), nelec // 2)
-            beta_strs = alpha_strs.copy()
-            wfn_dim = 2 ** (2 * norb)
-            wfn = numpy.zeros(wfn_dim)
-            for i, alpha_str in enumerate(alpha_strs):
-                for j, beta_str in enumerate(beta_strs):
-                    merged_str, phase = _merge_alpha_beta_strs(alpha_str, beta_str, norb)
-                    wfn[merged_str] = phase * fcivec[i, j]
-            return e + c, QubitWaveFunction.from_array(wfn)
+            if not ("nroots" in kwargs and kwargs["nroots"] > 1):
+                fcivecs = [fcivecs]
+                e = [e]
+            wfns = []
+            energies = [x + c for x in e]
+            for fcivec in fcivecs:
+                if use_hcb:
+                    alpha_strs = fci.cistring.make_strings(range(norb), nelec // 2)
+                    wfn_dim = 2**norb
+                    wfn = numpy.zeros(wfn_dim)
+                    for i, alpha_str in enumerate(alpha_strs):
+                        alpha_str_b = bin(alpha_str)[2:].zfill(norb)[::-1]
+                        merged_str = int(alpha_str_b, 2)
+                        wfn[merged_str] = fcivec[i, i]
+                else:
+                    alpha_strs = fci.cistring.make_strings(range(norb), nelec // 2)
+                    beta_strs = alpha_strs.copy()
+                    wfn_dim = 2 ** (2 * norb)
+                    wfn = numpy.zeros(wfn_dim)
+                    for i, alpha_str in enumerate(alpha_strs):
+                        for j, beta_str in enumerate(beta_strs):
+                            if not self.transformation.up_then_down:
+                                merged_str, phase = _merge_alpha_beta_strs(alpha_str, beta_str, norb)
+                                wfn[merged_str] = phase * fcivec[i, j]
+                            else:
+                                alpha_str_b = bin(alpha_str)[2:].zfill(norb)
+                                beta_str_b = bin(beta_str)[2:].zfill(norb)
+                                merged_str_b = (alpha_str_b + beta_str_b)[::-1]
+                                merged_str = int(merged_str_b, 2)
+                                wfn[merged_str] = fcivec[i, j]
+                wfns.append(QubitWaveFunction.from_array(wfn))
+            if not ("nroots" in kwargs and kwargs["nroots"] > 1):
+                return energies[0], wfns[0]
+            return energies, wfns
 
         return e + c
 
+    def create_ci_vector(self, wfn, use_hcb=False):
+        """
+        Reduces a full Fock space CI vector to the (na, nb) vector
+        required by fci.direct_spin1.
+
+        Args:
+            wfn (np.ndarray): 1D vector of length 2**(2*norb).
+
+        Returns:
+            ci_vector (np.ndarray): 2D vector of shape (na, nb).
+        """
+        if not isinstance(wfn, numpy.ndarray):
+            if hasattr(wfn, "to_array"):
+                wfn = wfn.to_array()
+            else:
+                raise TequilaException(
+                    f"create_ci_vector received wfn object of type {type(wfn)} but needs numpy.ndarray or tq.QubitWaveFunction\nwfn={wfn}"
+                )
+
+        wfn = numpy.real_if_close(wfn).astype(numpy.float64)
+
+        if type(self.transformation).__name__ != "JordanWigner":
+            warnings.warn("!!!guess wavefunctions for pyscf need to be in JordanWigner encoding!!!")
+
+        norb = self.n_orbitals
+        nelec = self.n_electrons
+        neleca = (nelec + 1) // 2
+        nelecb = nelec // 2
+
+        expected_len = 2 ** (2 * norb) if not use_hcb else 2**norb
+        if wfn.size != expected_len:
+            raise ValueError(
+                f"Input vector has length {wfn.size}, "
+                f"but expected full Fock space length {expected_len} (for {norb} orbitals)."
+            )
+
+        na = fci.cistring.num_strings(norb, neleca)
+        nb = fci.cistring.num_strings(norb, nelecb)
+        ci_vector = numpy.zeros((na, nb), dtype=wfn.dtype)
+
+        for i in range(expected_len):
+            if use_hcb:
+                alpha_str = bin(i)[2:].zfill(norb)
+                beta_str = alpha_str
+            else:
+                state_binary_str = bin(i)[2:].zfill(2 * norb)
+                if not self.transformation.up_then_down:
+                    alpha_str = state_binary_str[0::2]
+                    beta_str = state_binary_str[1::2]
+                else:
+                    alpha_str = state_binary_str[0 : len(state_binary_str) // 2]
+                    beta_str = state_binary_str[len(state_binary_str) // 2 : len(state_binary_str)]
+
+            # Only keep states that are particle-number conserving
+            if alpha_str.count("1") == neleca and beta_str.count("1") == nelecb:
+                alpha_int = int(alpha_str, 2)
+                beta_int = int(beta_str, 2)
+
+                # Compute the phase as in _merge_alpha_beta_strs(alpha_str, beta_str, norb)
+                set_bits_beta = [i for i in range(norb) if (beta_int >> i) & 1]
+                try:
+                    phase = (-1) ** sum([(alpha_int & 2**i - 1).bit_count() for i in set_bits_beta])
+                except AttributeError as error:
+                    phase = (-1) ** sum([bin(alpha_int & 2**i - 1).count("1") for i in set_bits_beta])
+
+                coeff = wfn[i]
+                row_idx = fci.cistring.str2addr(norb, neleca, alpha_int)
+                col_idx = fci.cistring.str2addr(norb, nelecb, beta_int)
+                ci_vector[row_idx, col_idx] = phase * coeff
+
+        return ci_vector
+
     def compute_energy(self, method: str, *args, **kwargs) -> float:
         method = method.lower()
 

{tequila_basic-1.9.10 → tequila_basic-1.9.11}/src/tequila/quantumchemistry/qc_base.py

@@ -140,6 +140,7 @@ class QuantumChemistryBase:
         if transformation is None:
             transformation = molecule.transformation
         parameters = molecule.parameters
+        parameters.frozen_core = False
         return cls(
             nuclear_repulsion=c,
             one_body_integrals=h1,
@@ -238,7 +239,7 @@ class QuantumChemistryBase:
         Notes
         ----------
         Creates the transformed hermitian generator of UCC type unitaries:
-              M(a^\dagger_{a_0} a_{i_0} a^\dagger{a_1}a_{i_1} ... - h.c.)
+              M(a^\\dagger_{a_0} a_{i_0} a^\\dagger{a_1}a_{i_1} ... - h.c.)
               where the qubit map M depends is self.transformation
 
         Parameters
@@ -818,6 +819,7 @@ class QuantumChemistryBase:
                     frozen_orbitals=core,
                     orbital_coefficients=coeff,
                     overlap_integrals=s,
+                    orbital_type="orthonormalized-{}-basis".format(self.integral_manager._basis_name),
                 )
                 return self
             else:
@@ -830,6 +832,7 @@ class QuantumChemistryBase:
                     frozen_orbitals=core,
                     orbital_coefficients=coeff,
                     overlap_integrals=s,
+                    orbital_type="orthonormalized-{}-basis".format(self.integral_manager._basis_name),
                 )
                 parameters = copy.deepcopy(self.parameters)
                 result = QuantumChemistryBase(
@@ -914,7 +917,7 @@ class QuantumChemistryBase:
         Compute annihilation operator on spin-orbital in qubit representation
         Spin-orbital order is always (up,down,up,down,...)
         """
-        assert orbital <= self.n_orbitals * 2
+        assert orbital < self.n_orbitals * 2
         aop = openfermion.ops.FermionOperator(f"{orbital}", coefficient)
         return self.transformation(aop)
 
@@ -923,7 +926,7 @@ class QuantumChemistryBase:
         Compute creation operator on spin-orbital in qubit representation
         Spin-orbital order is always (up,down,up,down,...)
         """
-        assert orbital <= self.n_orbitals * 2
+        assert orbital < self.n_orbitals * 2
         cop = openfermion.ops.FermionOperator(f"{orbital}^", coefficient)
         return self.transformation(cop)
 
@@ -2190,7 +2193,7 @@ class QuantumChemistryBase:
             raise TequilaException("Need to specify a Quantum Circuit.")
 
         def _get_hcb_op(op_tuple):
-            """Build the hardcore boson operators: b^\dagger_ib_j + h.c. in qubit encoding"""
+            """Build the hardcore boson operators: b^\\dagger_ib_j + h.c. in qubit encoding"""
             if len(op_tuple) == 2:
                 return 2 * Sm(op_tuple[0][0]) * Sp(op_tuple[1][0])
             elif len(op_tuple) == 4:
@@ -2623,7 +2626,14 @@ class QuantumChemistryBase:
         circuit += gates.GeneralizedRotation(generator=n_down, angle=-2 * phi)
         return circuit
 
-    def get_givens_circuit(self, unitary, tol=1e-12, ordering=OPTIMIZED_ORDERING):
+    def get_givens_circuit(
+        self,
+        unitary,
+        tol=1e-12,
+        ordering=OPTIMIZED_ORDERING,
+        fix: bool = True,
+        label=None,
+    ) -> QCircuit:
         """
         Constructs a quantum circuit from a given real unitary matrix using Givens rotations.
 
@@ -2634,6 +2644,8 @@ class QuantumChemistryBase:
         - unitary (numpy.array): A real unitary matrix representing the transformation to implement.
         - tol (float): A tolerance threshold below which matrix elements are considered zero.
         - ordering (list of tuples or 'Optimized'): Custom ordering of indices for Givens rotations or 'Optimized' to generate them automatically.
+        - fix (bool): whether to set the angle as fixed or as inial value as: angle=tq.Variable(idx) + value. Useful to let further relaxation to the basis change
+        - label: can be passed instead of angle to have auto-naming with label ("R",i,j,label) useful for repreating gates with individual variables
 
         Returns:
         - QCircuit: A quantum circuit implementing the series of rotations decomposed from the unitary.
@@ -2646,11 +2658,25 @@ class QuantumChemistryBase:
 
         # Add all Rz (phase) rotations to the circuit.
         for phi in phi_list:
-            circuit += self.n_rotation(phi[1], phi[0])
+            if fix:
+                circuit += self.n_rotation(i=phi[1], phi=phi[0])
+            else:
+                circuit += self.n_rotation(
+                    i=phi[1],
+                    phi=phi[0] + Variable(f"Ph({phi[1]}" + ("," + str(label)) * (label is not None) + ")"),
+                )
 
         # Add all Givens rotations to the circuit.
         for theta in reversed(theta_list):
-            circuit += self.UR(theta[1], theta[2], theta[0] * 2)
+            if fix:
+                circuit += self.UR(i=theta[1], j=theta[2], angle=theta[0] * 2)
+            else:
+                circuit += self.UR(
+                    i=theta[1],
+                    j=theta[2],
+                    angle=(theta[0] * 2)
+                    + Variable(f"UR({theta[1]},{theta[2]}" + ("," + str(label)) * (label is not None) + ")"),
+                )
 
         return circuit
 

{tequila_basic-1.9.10 → tequila_basic-1.9.11}/src/tequila/simulators/simulator_api.py

@@ -2,16 +2,16 @@ from collections import namedtuple
 import typing
 import warnings
 import numpy
+from importlib.metadata import version, PackageNotFoundError
 from numbers import Real as RealNumber
 from typing import Dict, Union, Hashable
-import pkg_resources
-from pkg_resources import DistributionNotFound
 from tequila.objective import Objective, Variable, assign_variable, format_variable_dictionary, QTensor
 from tequila.utils.exceptions import TequilaException, TequilaWarning
 from tequila.simulators.simulator_base import BackendCircuit, BackendExpectationValue
 from tequila.circuit.noise import NoiseModel
 from tequila.wavefunction.qubit_wavefunction import QubitWaveFunction
 from tequila.simulators.simulator_symbolic import BackendCircuitSymbolic, BackendExpectationValueSymbolic
+from tequila.wavefunction.density_matrix import DensityMatrix
 
 SUPPORTED_BACKENDS = [
     "qulacs",
@@ -30,6 +30,7 @@ SUPPORTED_BACKENDS = [
     "cudaq",
 ]
 
+SUPPORTED_DENSITY_BACKENDS = ["qiskit"]
 # TODO: Reenable noise for Qiskit
 SUPPORTED_NOISE_BACKENDS = ["cirq", "pyquil"]  # qulacs removed in v.1.9
 
@@ -102,7 +103,7 @@ except ImportError:
     HAS_QISKIT_NOISE = False
 
 try:
-    pkg_resources.require("qiskit-aer-gpu")
+    version("qiskit-aer-gpu")
     from tequila.simulators.simulator_qiskit_gpu import BackendCircuitQiskitGpu, BackendExpectationValueQiskitGpu
 
     HAS_QISKIT_GPU = True
@@ -112,7 +113,7 @@ try:
 
     if HAS_QISKIT_GPU_NOISE:
         INSTALLED_NOISE_SAMPLERS["qiskit_gpu"] = BackendTypes(BackendCircuitQiskitGpu, BackendExpectationValueQiskitGpu)
-except (ImportError, DistributionNotFound):
+except (ImportError, PackageNotFoundError):
     HAS_QISKIT_GPU = False
     HAS_QISKIT_GPU_NOISE = False
 
@@ -142,7 +143,6 @@ except ImportError:
     HAS_CIRQ = False
 
 try:
-    pkg_resources.require("qulacs")
     import qulacs
     from tequila.simulators.simulator_qulacs import BackendCircuitQulacs, BackendExpectationValueQulacs
 
@@ -156,11 +156,10 @@ try:
     INSTALLED_NOISE_SAMPLERS["qulacs"] = BackendTypes(
         CircType=BackendCircuitQulacs, ExpValueType=BackendExpectationValueQulacs
     )
-except (ImportError, DistributionNotFound):
+except ImportError:
     HAS_QULACS = False
 
 try:
-    # pkg_resources.require("qulacs-gpu")
     from qulacs import QuantumStateGpu
     from tequila.simulators.simulator_qulacs_gpu import BackendCircuitQulacsGpu, BackendExpectationValueQulacsGpu
 
@@ -174,7 +173,7 @@ try:
     INSTALLED_NOISE_SAMPLERS["qulacs_gpu"] = BackendTypes(
         CircType=BackendCircuitQulacsGpu, ExpValueType=BackendExpectationValueQulacsGpu
     )
-except (ImportError, DistributionNotFound):
+except ImportError:
     HAS_QULACS_GPU = False
 
 
@@ -234,7 +233,12 @@ def show_available_simulators():
 
 
 def pick_backend(
-    backend: str = None, samples: int = None, noise: NoiseModel = None, device=None, exclude_symbolic: bool = True
+    backend: str = None,
+    samples: int = None,
+    simulate_density: bool = False,
+    noise: NoiseModel = None,
+    device=None,
+    exclude_symbolic: bool = True,
 ) -> str:
     """
     choose, or verify, a backend for the user.
@@ -265,6 +269,12 @@ def pick_backend(
         raise TequilaException("device use requires backend specification!")
 
     if backend is None:
+        if simulate_density:
+            for f in SUPPORTED_DENSITY_BACKENDS:
+                if f in INSTALLED_SIMULATORS:
+                    return f
+            raise TequilaException("Density simulators unavailable!")
+
         if noise is None:
             if samples is None:
                 for f in SUPPORTED_BACKENDS:
@@ -320,6 +330,7 @@ def compile_objective(
     variables: typing.Dict["Variable", "RealNumber"] = None,
     backend: str = None,
     samples: int = None,
+    simulate_density: bool = False,
     device: str = None,
     noise: NoiseModel = None,
     *args,
@@ -350,7 +361,9 @@ def compile_objective(
         the compiled objective.
     """
 
-    backend = pick_backend(backend=backend, samples=samples, noise=noise, device=device)
+    backend = pick_backend(
+        backend=backend, samples=samples, simulate_density=simulate_density, noise=noise, device=device
+    )
 
     # dummy variables
     if variables is None:
@@ -405,6 +418,7 @@ def compile_circuit(
     variables: typing.Dict["Variable", "RealNumber"] = None,
     backend: str = None,
     samples: int = None,
+    simulate_density: bool = False,
     noise: NoiseModel = None,
     device: str = None,
     *args,
@@ -516,6 +530,7 @@ def simulate(
     compiled_objective = compile(
         objective=objective,
         samples=samples,
+        simulate_density=False,
         variables=variables,
         backend=backend,
         noise=noise,
@@ -527,6 +542,43 @@ def simulate(
     return compiled_objective(variables=variables, samples=samples, initial_state=initial_state, *args, **kwargs)
 
 
+def simulate_density(
+    objective: typing.Union["Objective", "QCircuit", "QTensor"],
+    variables: Dict[Union[Variable, Hashable], RealNumber] = None,
+    backend: str = None,
+    noise: NoiseModel = None,
+    device: str = None,
+    *args,
+    **kwargs,
+) -> Union[RealNumber, DensityMatrix]:
+    variables = format_variable_dictionary(variables)
+
+    if variables is None and not (len(objective.extract_variables()) == 0):
+        raise TequilaException(
+            "You called simulate for a parametrized type but forgot to pass down the variables: {}".format(
+                objective.extract_variables()
+            )
+        )
+
+    if backend is None:
+        backend = "qiskit"  # currently only permissible backend!
+    elif backend.lower() != "qiskit":
+        TequilaException("Density matrix simulation currently works with only qiskit backend!")
+
+    compiled_objective = compile(
+        objective=objective,
+        samples=None,
+        simulate_density=True,
+        variables=variables,
+        backend=backend,
+        noise=noise,
+        device=device,
+        *args,
+        **kwargs,
+    )
+    return compiled_objective(variables=variables, samples=None, simulate_density=True, *args, **kwargs)
+
+
 def draw(objective, variables=None, backend: str = None, name=None, *args, **kwargs):
     """
     Pretty output (depends on installed backends) for jupyter notebooks
@@ -625,6 +677,7 @@ def compile(
     objective: typing.Union["Objective", "QCircuit", "QTensor"],
     variables: Dict[Union["Variable", Hashable], RealNumber] = None,
     samples: int = None,
+    simulate_density: bool = False,
     backend: str = None,
     noise: NoiseModel = None,
     device: str = None,
@@ -655,7 +708,9 @@ def compile(
 
     """
 
-    backend = pick_backend(backend=backend, noise=noise, samples=samples, device=device)
+    backend = pick_backend(
+        backend=backend, noise=noise, samples=samples, simulate_density=simulate_density, device=device
+    )
 
     if variables is not None:
         # allow hashable types as keys without casting it to variables