tequila-basic 1.9.6__tar.gz → 1.9.8__tar.gz

{tequila_basic-1.9.6/src/tequila_basic.egg-info → tequila_basic-1.9.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tequila-basic
-Version: 1.9.6
+Version: 1.9.8
 Summary: A High-Level Abstraction Framework for Quantum Algorithms
 Home-page: https://github.com/tequilahub/tequila
 Author: Tequila Developers 
@@ -8,7 +8,7 @@ Author-email: jakob.kottmann@gmail.com
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
-Requires-Dist: scipy<1.11
+Requires-Dist: scipy
 Requires-Dist: sympy
 Requires-Dist: autograd
 Requires-Dist: setuptools
@@ -24,11 +24,14 @@ Tequila is an abstraction framework for (variational) quantum algorithms.
 It operates on abstract data structures allowing the formulation, combination, automatic differentiation and optimization of generalized objectives.
 Tequila can execute the underlying quantum expectation values on state of the art simulators as well as on real quantum devices.  
 
+# Getting Started
+
+Get started with our collection of  
+- *[Tutorials](https://tequilahub.github.io/tequila-tutorials/)*  
+
+Further sources:
 - [overview article](https://arxiv.org/abs/2011.03057)   
 - [tequila in a nutshell](https://kottmanj.github.io/tequila-in-a-nutshell/#/)  
-- [getting started](https://jakobkottmann.com/posts/tq-get-started/)    
-- [circuits in tequila](https://jakobkottmann.com/posts/tq-circuits/)  
-- [notebook collection](https://github.com/tequilahub/tequila-tutorials)  
 - [talks and slides](https://kottmanj.github.io/talks_and_material/)  
 
 # Installation
@@ -357,12 +360,7 @@ You can avoid it by downgrading cirq and openfermion
 ```bash
 pip install --upgrade "openfermion<=1.0.0"
 pip install --upgrade "cirq<=0.9.1"
-```  
-
-
-## Qiskit backend
-Qiskit version 0.25 is not yet supported.
-`pip install --upgrade qiskit<0.25` fixes potential issues. If not: Please let us know.
+```
 
 ## Circuit drawing
 Standard graphical circuit representation within a Jupyter environment is often done using `tq.draw`.

{tequila_basic-1.9.6 → tequila_basic-1.9.8}/README.md

@@ -6,11 +6,14 @@ Tequila is an abstraction framework for (variational) quantum algorithms.
 It operates on abstract data structures allowing the formulation, combination, automatic differentiation and optimization of generalized objectives.
 Tequila can execute the underlying quantum expectation values on state of the art simulators as well as on real quantum devices.  
 
+# Getting Started
+
+Get started with our collection of  
+- *[Tutorials](https://tequilahub.github.io/tequila-tutorials/)*  
+
+Further sources:
 - [overview article](https://arxiv.org/abs/2011.03057)   
 - [tequila in a nutshell](https://kottmanj.github.io/tequila-in-a-nutshell/#/)  
-- [getting started](https://jakobkottmann.com/posts/tq-get-started/)    
-- [circuits in tequila](https://jakobkottmann.com/posts/tq-circuits/)  
-- [notebook collection](https://github.com/tequilahub/tequila-tutorials)  
 - [talks and slides](https://kottmanj.github.io/talks_and_material/)  
 
 # Installation
@@ -339,12 +342,7 @@ You can avoid it by downgrading cirq and openfermion
 ```bash
 pip install --upgrade "openfermion<=1.0.0"
 pip install --upgrade "cirq<=0.9.1"
-```  
-
-
-## Qiskit backend
-Qiskit version 0.25 is not yet supported.
-`pip install --upgrade qiskit<0.25` fixes potential issues. If not: Please let us know.
+```
 
 ## Circuit drawing
 Standard graphical circuit representation within a Jupyter environment is often done using `tq.draw`.

{tequila_basic-1.9.6 → tequila_basic-1.9.8}/requirements.txt

@@ -1,6 +1,6 @@
 # necessary
 numpy
-scipy < 1.11 # for now, until issues with scipy/pyscf are fixed # can in principle be smaller, we recommend >= 1.5 for consistency with our tutorials (numerical gradients mostly)
+scipy
 sympy
 #jax
 #jaxlib

{tequila_basic-1.9.6 → tequila_basic-1.9.8}/src/tequila/apps/unary_state_prep.py

@@ -89,7 +89,6 @@ class UnaryStatePrep:
         simulator.convert_to_numpy = False
         variables = None # {k:k.name.evalf() for k in self._abstract_circuit.extract_variables()}
         wfn = simulator.simulate(initial_state=BitString.from_int(0, nbits=self.n_qubits), variables=variables)
-        wfn.n_qubits = self._n_qubits
         equations = []
         for k in target_space:
             equations.append(wfn[k] - abstract_coefficients[k])
@@ -174,7 +173,7 @@ class UnaryStatePrep:
         :return:
         """
         try:
-            assert (len(wfn) == len(self._target_space))
+            assert wfn.length() == len(self._target_space)
             for key in wfn.keys():
                 try:
                     assert (key in self._target_space)

{tequila_basic-1.9.6 → tequila_basic-1.9.8}/src/tequila/circuit/circuit.py

@@ -46,10 +46,7 @@ class QCircuit():
         Convenience: see src/tequila/circuit/qpic.py - export_to for more
         Parameters
         """
-        # this way we allow calling U.export_to("asd.png") instead of having to specify U.export_to(filename="asd.png")
-        if "circuit" not in kwargs:
-            kwargs["circuit"]=self
-        return export_to(*args, **kwargs)
+        return export_to(self, *args, **kwargs)
 
     @property
     def moments(self):
@@ -389,7 +386,7 @@ class QCircuit():
         for k, v in other._parameter_map.items():
             self._parameter_map[k] += [(x[0] + offset, x[1]) for x in v]
 
-        self._gates += other.gates
+        self._gates += copy.deepcopy(other.gates)
         self._min_n_qubits = max(self._min_n_qubits, other._min_n_qubits)
 
         return self

{tequila_basic-1.9.6 → tequila_basic-1.9.8}/src/tequila/hamiltonian/paulis.py

@@ -256,7 +256,7 @@ def Projector(wfn, threshold=0.0, n_qubits=None) -> QubitHamiltonian:
 
     """
 
-    wfn = QubitWaveFunction(state=wfn, n_qubits=n_qubits)
+    wfn = QubitWaveFunction.convert_from(n_qubits, wfn)
 
     H = QubitHamiltonian.zero()
     for k1, v1 in wfn.items():
@@ -304,8 +304,9 @@ def KetBra(ket: QubitWaveFunction, bra: QubitWaveFunction, hermitian: bool = Fal
 
     """
     H = QubitHamiltonian.zero()
-    ket = QubitWaveFunction(state=ket, n_qubits=n_qubits)
-    bra = QubitWaveFunction(state=bra, n_qubits=n_qubits)
+
+    ket = QubitWaveFunction.convert_from(n_qubits, ket)
+    bra = QubitWaveFunction.convert_from(n_qubits, bra)
 
     for k1, v1 in bra.items():
         for k2, v2 in ket.items():

{tequila_basic-1.9.6 → tequila_basic-1.9.8}/src/tequila/quantumchemistry/encodings.py

@@ -128,9 +128,9 @@ class EncodingBase(metaclass=abc.ABCMeta):
         fop = openfermion.FermionOperator(string, 1.0)
         op = self(fop)
         from tequila.wavefunction.qubit_wavefunction import QubitWaveFunction
-        wfn = QubitWaveFunction.from_int(0, n_qubits=n_qubits)
+        wfn = QubitWaveFunction.from_basis_state(n_qubits, 0)
         wfn = wfn.apply_qubitoperator(operator=op)
-        assert (len(wfn.keys()) == 1)
+        assert wfn.length() == 1
         key = list(wfn.keys())[0].array
         return key
 

{tequila_basic-1.9.6 → tequila_basic-1.9.8}/src/tequila/quantumchemistry/orbital_optimizer.py

@@ -208,11 +208,16 @@ class PySCFVQEWrapper:
             H = molecule.make_hardcore_boson_hamiltonian()
         else:
             H = molecule.make_hamiltonian()
+
+        rdm1 = None
+        rdm2 = None
         if self.vqe_solver is not None:
             vqe_solver_arguments = {}
             if self.vqe_solver_arguments is not None:
                 vqe_solver_arguments = self.vqe_solver_arguments
             result = self.vqe_solver(H=H, circuit=self.circuit, molecule=molecule, **vqe_solver_arguments)
+            if hasattr(self.vqe_solver, "compute_rdms"):
+                rdm1, rdm2 = self.vqe_solver.compute_rdms(U=self.circuit, variables=result.variables, molecule=molecule, use_hcb=restrict_to_hcb)
         elif self.circuit is None:
             raise Exception("Orbital Optimizer: Either provide a callable vqe_solver or a circuit")
         else:
@@ -233,8 +238,9 @@ class PySCFVQEWrapper:
             # static ansatz
             U = self.circuit
 
-        rdm1, rdm2 = molecule.compute_rdms(U=U, variables=result.variables, spin_free=True, get_rdm1=True, get_rdm2=True, use_hcb=restrict_to_hcb)
-        rdm2 = self.reorder(rdm2, 'dirac', 'mulliken')
+        if rdm1 is None or rdm2 is None:
+            rdm1, rdm2 = molecule.compute_rdms(U=U, variables=result.variables, spin_free=True, get_rdm1=True, get_rdm2=True, use_hcb=restrict_to_hcb)
+            rdm2 = self.reorder(rdm2, 'dirac', 'mulliken')
         if not self.silent:
             print("{:20} : {}".format("energy", result.energy))
             if len(self.history) > 0:
@@ -259,3 +265,4 @@ class PySCFVQEWrapper:
             else:
                 result += "{:30} : {}\n".format(k, v)
         return result
+

{tequila_basic-1.9.6 → tequila_basic-1.9.8}/src/tequila/quantumchemistry/qc_base.py

@@ -1737,7 +1737,7 @@ class QuantumChemistryBase:
 
     def compute_rdms(self, U: QCircuit = None, variables: Variables = None, spin_free: bool = True,
                      get_rdm1: bool = True, get_rdm2: bool = True, ordering="dirac", use_hcb: bool = False,
-                     rdm_trafo: QubitHamiltonian = None, decompose=None):
+                     rdm_trafo: QubitHamiltonian = None, evaluate=True):
         """
         Computes the one- and two-particle reduced density matrices (rdm1 and rdm2) given
         a unitary U. This method uses the standard ordering in physics as denoted below.
@@ -1768,7 +1768,10 @@ class QuantumChemistryBase:
         rdm_trafo :
             The rdm operators can be transformed, e.g., a^dagger_i a_j -> U^dagger a^dagger_i a_j U,
             where U represents the transformation. The default is set to None, implying that U equas the identity.
-
+        evaluate :
+            if true, the tequila expectation values are evaluated directly via the tq.simulate command.
+            the protocol is optimized to avoid repetation of wavefunction simulation
+            if false, the rdms are returned as tq.QTensors
         Returns
         -------
         """
@@ -1891,13 +1894,14 @@ class QuantumChemistryBase:
                     ops += [op]
             return ops
 
-        def _assemble_rdm1(evals) -> numpy.ndarray:
+        def _assemble_rdm1(evals, rdm1=None) -> numpy.ndarray:
             """
             Returns spin-ful or spin-free one-particle RDM built by symmetry conditions
             Same symmetry with or without spin, so we can use the same function
             """
             N = n_MOs if spin_free else n_SOs
-            rdm1 = numpy.zeros([N, N])
+            if rdm1 is None:
+                rdm1 = numpy.zeros([N, N])
             ctr: int = 0
             for p in range(N):
                 for q in range(p + 1):
@@ -1908,10 +1912,11 @@ class QuantumChemistryBase:
 
             return rdm1
 
-        def _assemble_rdm2_spinful(evals) -> numpy.ndarray:
+        def _assemble_rdm2_spinful(evals, rdm2=None) -> numpy.ndarray:
             """ Returns spin-ful two-particle RDM built by symmetry conditions """
             ctr: int = 0
-            rdm2 = numpy.zeros([n_SOs, n_SOs, n_SOs, n_SOs])
+            if rdm2 is None:
+                rdm2 = numpy.zeros([n_SOs, n_SOs, n_SOs, n_SOs])
             for p in range(n_SOs):
                 for q in range(p):
                     for r in range(n_SOs):
@@ -1933,10 +1938,11 @@ class QuantumChemistryBase:
 
             return rdm2
 
-        def _assemble_rdm2_spinfree(evals) -> numpy.ndarray:
+        def _assemble_rdm2_spinfree(evals, rdm2=None) -> numpy.ndarray:
             """ Returns spin-free two-particle RDM built by symmetry conditions """
             ctr: int = 0
-            rdm2 = numpy.zeros([n_MOs, n_MOs, n_MOs, n_MOs])
+            if rdm2 is None:
+                rdm2 = numpy.zeros([n_MOs, n_MOs, n_MOs, n_MOs])
             for p, q, r, s in product(range(n_MOs), repeat=4):
                 if p * n_MOs + q >= r * n_MOs + s and (p >= q or r >= s):
                     rdm2[p, q, r, s] = evals[ctr]
@@ -2012,18 +2018,25 @@ class QuantumChemistryBase:
         # Transform operator lists to QubitHamiltonians
         if (not use_hcb):
             qops = [_get_qop_hermitian(op) for op in qops]
-        
+
         # Compute expected values
-        if rdm_trafo is None:
-            if decompose is not None:
-                print("MANIPULATED")
-                X = decompose(H=qops, U=U)
-                evals = simulate(X, variables=variables)
+        rdm1 = None
+        rdm2 = None
+        from tequila import QTensor
+        if evaluate:
+            if rdm_trafo is None:
+                evals = simulate(ExpectationValue(H=qops, U=U, shape=[len(qops)]), variables=variables)
             else:
+                qops = [rdm_trafo.dagger()*qops[i]*rdm_trafo for i in range(len(qops))]
                 evals = simulate(ExpectationValue(H=qops, U=U, shape=[len(qops)]), variables=variables)
         else:
-            qops = [rdm_trafo.dagger()*qops[i]*rdm_trafo for i in range(len(qops))]
-            evals = simulate(ExpectationValue(H=qops, U=U, shape=[len(qops)]), variables=variables)
+            if rdm_trafo is None:
+                evals = [ExpectationValue(H=x, U=U) for x in qops]
+                N = n_MOs if spin_free else n_SOs
+                rdm1 = QTensor(shape=[N,N])
+                rdm2 = QTensor(shape=[N, N, N, N])
+            else:
+                raise TequilaException("compute_rdms: rdm_trafo was set but evaluate flag is False (not supported)")
 
         # Assemble density matrices
         # If self._rdm1, self._rdm2 exist, reset them if they are of the other spin-type
@@ -2044,11 +2057,11 @@ class QuantumChemistryBase:
             len_1 = 0
         evals_1, evals_2 = evals[:len_1], evals[len_1:]
         # Build matrices using the expectation values
-        self._rdm1 = _assemble_rdm1(evals_1) if get_rdm1 else self._rdm1
+        self._rdm1 = _assemble_rdm1(evals_1, rdm1=rdm1) if get_rdm1 else self._rdm1
         if spin_free or use_hcb:
-            self._rdm2 = _assemble_rdm2_spinfree(evals_2) if get_rdm2 else self._rdm2
+            self._rdm2 = _assemble_rdm2_spinfree(evals_2, rdm2=rdm2) if get_rdm2 else self._rdm2
         else:
-            self._rdm2 = _assemble_rdm2_spinful(evals_2) if get_rdm2 else self._rdm2
+            self._rdm2 = _assemble_rdm2_spinful(evals_2, rdm2=rdm2) if get_rdm2 else self._rdm2
 
         if get_rdm2:
             rdm2 = NBodyTensor(elems=self.rdm2, ordering="dirac", verify=False)

{tequila_basic-1.9.6 → tequila_basic-1.9.8}/src/tequila/simulators/simulator_api.py

@@ -9,9 +9,10 @@ from tequila.objective import Objective, Variable, assign_variable, format_varia
 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
 
-SUPPORTED_BACKENDS = ["qulacs_gpu", "qulacs",'qibo', "qiskit", "cirq", "pyquil", "symbolic", "qlm"]
-SUPPORTED_NOISE_BACKENDS = ["qiskit", 'cirq', 'pyquil'] # qulacs removed in v.1.9
+SUPPORTED_BACKENDS = ["qulacs", "qulacs_gpu", "qibo", "qiskit", "qiskit_gpu", "cirq", "pyquil", "symbolic", "qlm"]
+SUPPORTED_NOISE_BACKENDS = ["qiskit", "qiskit_gpu", "cirq", "pyquil"]  # qulacs removed in v.1.9
 BackendTypes = namedtuple('BackendTypes', 'CircType ExpValueType')
 INSTALLED_SIMULATORS = {}
 INSTALLED_SAMPLERS = {}
@@ -22,7 +23,6 @@ if typing.TYPE_CHECKING:
     from tequila.objective import Objective, Variable
     from tequila.circuit.gates import QCircuit
     import numbers.Real as RealNumber
-    from tequila.wavefunction.qubit_wavefunction import QubitWaveFunction
 
 """
 Check which simulators are installed
@@ -43,6 +43,19 @@ except ImportError:
     HAS_QISKIT = False
     HAS_QISKIT_NOISE = False
 
+try:
+    pkg_resources.require("qiskit-aer-gpu")
+    from tequila.simulators.simulator_qiskit_gpu import BackendCircuitQiskitGpu, BackendExpectationValueQiskitGpu
+    HAS_QISKIT_GPU = True
+    INSTALLED_SIMULATORS["qiskit_gpu"] = BackendTypes(BackendCircuitQiskitGpu, BackendExpectationValueQiskitGpu)
+    INSTALLED_SAMPLERS["qiskit_gpu"] = BackendTypes(BackendCircuitQiskitGpu, BackendExpectationValueQiskitGpu)
+    from tequila.simulators.simulator_qiskit import HAS_NOISE as HAS_QISKIT_GPU_NOISE
+    if HAS_QISKIT_GPU_NOISE:
+        INSTALLED_NOISE_SAMPLERS["qiskit_gpu"] = BackendTypes(BackendCircuitQiskitGpu, BackendExpectationValueQiskitGpu)
+except (ImportError, DistributionNotFound):
+    HAS_QISKIT_GPU = False
+    HAS_QISKIT_GPU_NOISE = False
+
 HAS_QIBO = True
 try:
     from tequila.simulators.simulator_qibo import BackendCircuitQibo, BackendExpectationValueQibo
@@ -82,8 +95,8 @@ except (ImportError, DistributionNotFound):
     HAS_QULACS = False
 
 try:
-    pkg_resources.require("qulacs-gpu")
-    import qulacs
+    # pkg_resources.require("qulacs-gpu")
+    from qulacs import QuantumStateGpu
     from tequila.simulators.simulator_qulacs_gpu import BackendCircuitQulacsGpu, BackendExpectationValueQulacsGpu
 
     HAS_QULACS_GPU = True
@@ -350,14 +363,15 @@ def compile_circuit(abstract_circuit: 'QCircuit',
     return CircType(abstract_circuit=abstract_circuit, variables=variables, noise=noise, device=device, *args, **kwargs)
 
 
-def simulate(objective: typing.Union['Objective', 'QCircuit','QTensor'],
+def simulate(objective: typing.Union['Objective', 'QCircuit', 'QTensor'],
              variables: Dict[Union[Variable, Hashable], RealNumber] = None,
              samples: int = None,
              backend: str = None,
              noise: NoiseModel = None,
              device: str = None,
+             initial_state: Union[int, QubitWaveFunction] = 0,
              *args,
-             **kwargs) -> Union[RealNumber, 'QubitWaveFunction']:
+             **kwargs) -> Union[RealNumber, QubitWaveFunction]:
     """Simulate a tequila objective or circuit
 
     Parameters
@@ -375,6 +389,8 @@ def simulate(objective: typing.Union['Objective', 'QCircuit','QTensor'],
         specify a noise model to apply to simulation/sampling
     device:
         a device upon which (or in emulation of which) to sample
+    initial_state: int or QubitWaveFunction:
+        the initial state of the circuit
     *args :
 
     **kwargs :
@@ -394,9 +410,9 @@ def simulate(objective: typing.Union['Objective', 'QCircuit','QTensor'],
                 objective.extract_variables()))
 
     compiled_objective = compile(objective=objective, samples=samples, variables=variables, backend=backend,
-                                 noise=noise,device=device, *args, **kwargs)
+                                 noise=noise, device=device, *args, **kwargs)
 
-    return compiled_objective(variables=variables, samples=samples, *args, **kwargs)
+    return compiled_objective(variables=variables, samples=samples, initial_state=initial_state, *args, **kwargs)
 
 
 def draw(objective, variables=None, backend: str = None, name=None, *args, **kwargs):

{tequila_basic-1.9.6 → tequila_basic-1.9.8}/src/tequila/simulators/simulator_base.py

@@ -7,6 +7,7 @@ from tequila.circuit.compiler import change_basis
 from tequila import BitString
 from tequila.objective.objective import Variable, format_variable_dictionary
 from tequila.circuit import compiler
+from typing import Union
 
 import numbers, typing, numpy, copy, warnings
 
@@ -107,6 +108,11 @@ class BackendCircuit():
         "cc_max": True
     }
 
+    # Can be overwritten by backends that allow basis state initialization when sampling
+    supports_sampling_initialization: bool = False
+    # Can be overwritten by backends that allow initializing arbitrary states
+    supports_generic_initialization: bool = False
+
     @property
     def n_qubits(self) -> numbers.Integral:
         return len(self.qubit_map)
@@ -328,7 +334,7 @@ class BackendCircuit():
         """
         self.circuit = self.create_circuit(abstract_circuit=self.abstract_circuit, variables=variables)
 
-    def simulate(self, variables, initial_state=0, *args, **kwargs) -> QubitWaveFunction:
+    def simulate(self, variables, initial_state: Union[int, QubitWaveFunction] = 0, *args, **kwargs) -> QubitWaveFunction:
         """
         simulate the circuit via the backend.
 
@@ -348,26 +354,43 @@ class BackendCircuit():
             the wavefunction of the system produced by the action of the circuit on the initial state.
 
         """
+        if isinstance(initial_state, QubitWaveFunction) and not self.supports_generic_initialization:
+            raise TequilaException("Backend does not support arbitrary initial states")
+
         self.update_variables(variables)
         if isinstance(initial_state, BitString):
             initial_state = initial_state.integer
-        if isinstance(initial_state, QubitWaveFunction):
-            if len(initial_state.keys()) != 1:
-                raise TequilaException("only product states as initial states accepted")
-            initial_state = list(initial_state.keys())[0].integer
 
-        all_qubits = [i for i in range(self.abstract_circuit.n_qubits)]
+        all_qubits = list(range(self.abstract_circuit.n_qubits))
         active_qubits = self.qubit_map.keys()
 
-        # maps from reduced register to full register
-        keymap = KeyMapSubregisterToRegister(subregister=active_qubits, register=all_qubits)
+        # Keymap is only necessary if not all qubits are active
+        keymap_required = sorted(active_qubits) != all_qubits
+
+        # Combining keymap and general initial states is awkward, because it's not clear what should happen with
+        # different states on non-active qubits. For now, this is simply not allowed.
+        # A better solution might be to check if all components of the initial state differ only on the active qubits.
+        if keymap_required and isinstance(initial_state, QubitWaveFunction):
+            raise TequilaException("Can only set non-basis initial state if all qubits are used")
+
+        if keymap_required:
+            # maps from reduced register to full register
+            keymap = KeyMapSubregisterToRegister(subregister=active_qubits, register=all_qubits)
 
-        result = self.do_simulate(variables=variables, initial_state=keymap.inverted(initial_state).integer, *args,
+        if not isinstance(initial_state, QubitWaveFunction):
+            mapped_initial_state = keymap.inverted(initial_state).integer if keymap_required else int(initial_state)
+        else:
+            mapped_initial_state = initial_state
+
+        result = self.do_simulate(variables=variables, initial_state=mapped_initial_state, *args,
                                   **kwargs)
-        result.apply_keymap(keymap=keymap, initial_state=initial_state)
+
+        if keymap_required:
+            result = QubitWaveFunction.from_wavefunction(result, keymap, n_qubits=len(all_qubits), initial_state=initial_state)
+
         return result
 
-    def sample(self, variables, samples, read_out_qubits=None, circuit=None, *args, **kwargs):
+    def sample(self, variables, samples, read_out_qubits=None, circuit=None, initial_state=0, *args, **kwargs):
         """
         Sample the circuit. If circuit natively equips paulistrings, sample therefrom.
         Parameters
@@ -387,6 +410,12 @@ class BackendCircuit():
             The result of sampling, a recreated QubitWaveFunction in the sampled basis.
 
         """
+        if initial_state != 0 and not self.supports_sampling_initialization:
+            raise TequilaException("Backend does not support initial states for sampling")
+
+        if isinstance(initial_state, QubitWaveFunction) and not self.supports_generic_initialization:
+            raise TequilaException("Backend does not support arbitrary initial states")
+
         self.update_variables(variables)
         if read_out_qubits is None:
             read_out_qubits = self.abstract_qubits
@@ -398,7 +427,9 @@ class BackendCircuit():
             circuit = self.add_measurement(circuit=self.circuit, target_qubits=read_out_qubits)
         else:
             circuit = self.add_measurement(circuit=circuit, target_qubits=read_out_qubits)
-        return self.do_sample(samples=samples, circuit=circuit, read_out_qubits=read_out_qubits, *args, **kwargs)
+
+        return self.do_sample(samples=samples, circuit=circuit, read_out_qubits=read_out_qubits,
+                              initial_state=initial_state, *args, **kwargs)
 
     def sample_all_z_hamiltonian(self, samples: int, hamiltonian, variables, *args, **kwargs):
         """
@@ -503,7 +534,7 @@ class BackendCircuit():
         E = E / samples * paulistring.coeff
         return E
 
-    def do_sample(self, samples, circuit, noise, abstract_qubits=None, *args, **kwargs) -> QubitWaveFunction:
+    def do_sample(self, samples, circuit, noise, abstract_qubits=None, initial_state=0, *args, **kwargs) -> QubitWaveFunction:
         """
         helper function for sampling. MUST be overwritten by inheritors.
 
@@ -769,7 +800,7 @@ class BackendExpectationValue:
                 raise TequilaException(
                     "BackendExpectationValue received not all variables. Circuit depends on variables {}, you gave {}".format(
                         self._variables, variables))
-        
+
         if samples is None:
             data = self.simulate(variables=variables, *args, **kwargs)
         else:
@@ -848,7 +879,7 @@ class BackendExpectationValue:
             samples = max(1, int(self.abstract_expectationvalue.samples * total_samples))
             suggested = samples
             # samples are not necessarily set (either the user has to set it or some functions like optimize_measurements)
- 
+
         if suggested is not None and suggested != samples:
             warnings.warn("simulating with samples={}, but expectationvalue carries suggested samples={}\nTry calling with samples='auto-total#ofsamples'".format(samples, suggested), TequilaWarning)
 

{tequila_basic-1.9.6 → tequila_basic-1.9.8}/src/tequila/simulators/simulator_cirq.py

@@ -173,7 +173,7 @@ class BackendCircuitCirq(BackendCircuit):
         simulator = cirq.Simulator()
         backend_result = simulator.simulate(program=self.circuit, param_resolver=self.resolver,
                                             initial_state=initial_state)
-        return QubitWaveFunction.from_array(arr=backend_result.final_state_vector, numbering=self.numbering)
+        return QubitWaveFunction.from_array(array=backend_result.final_state_vector, numbering=self.numbering)
 
     def convert_measurements(self, backend_result: cirq.Result) -> QubitWaveFunction:
         """
@@ -186,18 +186,18 @@ class BackendCircuitCirq(BackendCircuit):
         Returns
         -------
         QubitWaveFunction:
-            the result of sampling, as a tequila QubitWavefunction.
+            the result of sampling, as a tequila QubitWaveFunction.
 
         """
         assert (len(backend_result.measurements) == 1)
         for key, value in backend_result.measurements.items():
-            counter = QubitWaveFunction()
+            counter = QubitWaveFunction(self.n_qubits, self.numbering)
             for sample in value:
                 binary = BitString.from_array(array=sample.astype(int))
-                if binary in counter._state:
-                    counter._state[binary] += 1
+                if binary in counter.keys():
+                    counter[binary] += 1
                 else:
-                    counter._state[binary] = 1
+                    counter[binary] = 1
             return counter
 
     def do_sample(self, samples, circuit, *args, **kwargs) -> QubitWaveFunction:

{tequila_basic-1.9.6 → tequila_basic-1.9.8}/src/tequila/simulators/simulator_pyquil.py

@@ -439,7 +439,7 @@ class BackendCircuitPyquil(BackendCircuit):
             if val > 0:
                 iprep += pyquil.gates.X(i)
         backend_result = simulator.wavefunction(iprep + self.circuit, memory_map=self.resolver)
-        return QubitWaveFunction.from_array(arr=backend_result.amplitudes, numbering=self.numbering)
+        return QubitWaveFunction.from_array(array=backend_result.amplitudes, numbering=self.numbering)
 
     def do_sample(self, samples, circuit, *args, **kwargs) -> QubitWaveFunction:
         """
@@ -495,7 +495,7 @@ class BackendCircuitPyquil(BackendCircuit):
                     listing.append(int(letter))
             return listing
 
-        result = QubitWaveFunction()
+        result = QubitWaveFunction(self.n_qubits, self.numbering)
         bit_dict = {}
         for b in backend_result:
             try:
@@ -505,7 +505,7 @@ class BackendCircuitPyquil(BackendCircuit):
 
         for k, v in bit_dict.items():
             arr = string_to_array(k)
-            result._state[BitString.from_array(arr)] = v
+            result[BitString.from_array(arr)] = v
         return result
 
     def no_translation(self, abstract_circuit):