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

tequila/circuit/circuit.py

@@ -9,6 +9,7 @@ import warnings
 
 from .qpic import export_to
 
+
 class QCircuit():
     """
     Fundamental class representing an abstract circuit.
@@ -254,8 +255,8 @@ class QCircuit():
             the gates to add at the corresponding positions
         replace: list of bool: (Default value: None)
             Default is None which corresponds to all true
-            decide if gates shall be replaces or if the new parts shall be inserted without replacement
-            if replace[i] = true: gate at position [i] will be replaces by gates[i]
+            decide if gates shall be replaced or if the new parts shall be inserted without replacement
+            if replace[i] = true: gate at position [i] will be replaced by gates[i]
             if replace[i] = false: gates[i] circuit will be inserted at position [i] (beaming before gate previously at position [i])
         Returns
         -------
@@ -271,8 +272,9 @@ class QCircuit():
         dataset = zip(positions, circuits, replace)
         dataset = sorted(dataset, key=lambda x: x[0])
 
-        offset = 0
-        new_gatelist = self.gates
+        new_gatelist = []
+        last_idx = -1
+
         for idx, circuit, do_replace in dataset:
 
             # failsafe
@@ -283,13 +285,14 @@ class QCircuit():
             else:
                 gatelist = [circuit]
 
-            pos = idx + offset
-            if do_replace:
-                new_gatelist = new_gatelist[:pos] + gatelist + new_gatelist[pos + 1:]
-                offset += len(gatelist) - 1
-            else:
-                new_gatelist = new_gatelist[:pos] + gatelist + new_gatelist[pos:]
-                offset += len(gatelist)
+            new_gatelist += self.gates[last_idx + 1:idx]
+            new_gatelist += gatelist
+            if not do_replace:
+                new_gatelist.append(self.gates[idx])
+
+            last_idx = idx
+
+        new_gatelist += self.gates[last_idx + 1:]
 
         result = QCircuit(gates=new_gatelist)
         result.n_qubits = max(result.n_qubits, self.n_qubits)
@@ -386,7 +389,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 += copy.deepcopy(other.gates)
+        self._gates += other.gates
         self._min_n_qubits = max(self._min_n_qubits, other._min_n_qubits)
 
         return self
@@ -593,7 +596,7 @@ class QCircuit():
 
         This is an in-place method, so it mutates self and doesn't return any value.
 
-        Raise TequilaWarning if there any qubits in common between self and control.
+        Raise TequilaWarning if there are any qubits in common between self and control.
         """
         gates = self.gates
         control = list_assignment(control)
@@ -610,8 +613,10 @@ class QCircuit():
                 if len(control_lst) < len(gate.control) + len(control):
                     # warnings.warn("Some of the controls {} were already included in the control "
                     #               "of a gate {}.".format(control, gate), TequilaWarning)
-                    raise TequilaWarning(f'Some of the controls {control} were already included '
-                                         f'in the control of a gate {gate}.')
+                    raise TequilaWarning(f"Some of the controls {control} were already included "
+                                         f"in the control of a gate {gate}. "
+                                         f"This might be because the same instance of a gate is used in multiple places, "
+                                         f"e.g. because the same circuit was appended twice.")
             else:
                 control_lst, not_control = list(control), list()
 

tequila/objective/objective.py

@@ -1,4 +1,5 @@
 import typing, copy, numbers
+from typing import Union
 from tequila.grouping.compile_groups import compile_commuting_parts
 from tequila import TequilaException
 from tequila.utils import JoinedTransformation
@@ -545,7 +546,7 @@ class Objective:
                "variables          = {}\n" \
                "types              = {}".format(unique, measurements, variables, types)
 
-    def __call__(self, variables=None, *args, **kwargs):
+    def __call__(self, variables=None, initial_state = 0, *args, **kwargs):
         """
         Return the output of the calculation the objective represents.
 
@@ -553,6 +554,8 @@ class Objective:
         ----------
         variables: dict:
             dictionary instantiating all variables that may appear within the objective.
+        initial_state: int or QubitWaveFunction:
+            the initial state of the circuit
         args
         kwargs
 
@@ -579,7 +582,7 @@ class Objective:
         ev_array = []
         for E in self.args:
             if E not in evaluated:  #
-                expval_result = E(variables=variables, *args, **kwargs)
+                expval_result = E(variables=variables, initial_state=initial_state, *args, **kwargs)
                 evaluated[E] = expval_result
             else:
                 expval_result = evaluated[E]

tequila/quantumchemistry/chemistry_tools.py

@@ -442,7 +442,14 @@ class ParametersQC:
             for i in range(natoms):
                 coord += content[2 + i]
             return coord, comment
-
+    def get_xyz(self)->str:
+        geom = self.parameters.get_geometry()
+        f = ''
+        f += f'{len(geom)}\n'
+        f += f'{self.parameters.name}\n'
+        for at in geom:
+            f += f'{at[0]} {at[1][0]} {at[1][1]} {at[1][2]}\n'
+        return f
 
 @dataclass
 class ClosedShellAmplitudes:

tequila/quantumchemistry/orbital_optimizer.py

@@ -217,7 +217,8 @@ class PySCFVQEWrapper:
                 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)
+                rdm1,rdm2 = self.vqe_solver.compute_rdms(U=self.circuit, variables=result.variables, molecule=molecule, use_hcb=restrict_to_hcb)
+                rdm2 = self.reorder(rdm2, 'dirac', 'mulliken')
         elif self.circuit is None:
             raise Exception("Orbital Optimizer: Either provide a callable vqe_solver or a circuit")
         else:

tequila/simulators/simulator_api.py

@@ -11,8 +11,9 @@ from tequila.simulators.simulator_base import BackendCircuit, BackendExpectation
 from tequila.circuit.noise import NoiseModel
 from tequila.wavefunction.qubit_wavefunction import QubitWaveFunction
 
-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
+SUPPORTED_BACKENDS = ["qulacs", "qulacs_gpu", "qibo", "qiskit", "qiskit_gpu", "cirq", "pyquil", "symbolic", "qlm", "spex"]
+# TODO: Reenable noise for Qiskit
+SUPPORTED_NOISE_BACKENDS = ["cirq", "pyquil"]  # qulacs removed in v.1.9
 BackendTypes = namedtuple('BackendTypes', 'CircType ExpValueType')
 INSTALLED_SIMULATORS = {}
 INSTALLED_SAMPLERS = {}
@@ -30,6 +31,15 @@ We are distinguishing two classes of simulators: Samplers and full wavefunction
 """
 
 
+HAS_SPEX = True
+try:
+    from tequila.simulators.simulator_spex import BackendCircuitSpex, BackendExpectationValueSpex
+
+    INSTALLED_SIMULATORS["spex"] = BackendTypes(BackendCircuitSpex, BackendExpectationValueSpex)
+except ImportError:
+    HAS_SPEX = False
+
+
 HAS_QISKIT = True
 try:
     from tequila.simulators.simulator_qiskit import BackendCircuitQiskit, BackendExpectationValueQiskit

tequila/simulators/simulator_base.py

@@ -431,7 +431,8 @@ class BackendCircuit():
         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):
+    def sample_all_z_hamiltonian(self, samples: int, hamiltonian, variables,
+                                 initial_state: Union[int, QubitWaveFunction] = 0, *args, **kwargs):
         """
         Sample from a Hamiltonian which only consists of Pauli-Z and unit operators
         Parameters
@@ -440,6 +441,8 @@ class BackendCircuit():
             number of samples to take
         hamiltonian
             the tequila hamiltonian
+        initial_state
+            the initial state of the circuit
         args
             arguments for do_sample
         kwargs
@@ -458,7 +461,7 @@ class BackendCircuit():
                                                                                                  self.n_qubits))
 
         # run simulators
-        counts = self.sample(samples=samples, read_out_qubits=abstract_qubits_H, variables=variables, *args, **kwargs)
+        counts = self.sample(samples=samples, read_out_qubits=abstract_qubits_H, variables=variables, initial_state=initial_state, *args, **kwargs)
         read_out_map = {q: i for i, q in enumerate(abstract_qubits_H)}
 
         # compute energy
@@ -481,8 +484,8 @@ class BackendCircuit():
             assert n_samples == samples
         return E
 
-    def sample_paulistring(self, samples: int, paulistring, variables, *args,
-                           **kwargs) -> numbers.Real:
+    def sample_paulistring(self, samples: int, paulistring, variables, initial_state: Union[int, QubitWaveFunction] = 0,
+                           *args, **kwargs) -> numbers.Real:
         """
         Sample an individual pauli word (pauli string) and return the average result thereof.
         Parameters
@@ -520,8 +523,8 @@ class BackendCircuit():
         # on construction: tq.ExpectationValue(H=H, U=U, optimize_measurements=True)
         circuit = self.create_circuit(circuit=copy.deepcopy(self.circuit), abstract_circuit=basis_change)
         # run simulators
-        counts = self.sample(samples=samples, circuit=circuit, read_out_qubits=qubits, variables=variables, *args,
-                             **kwargs)
+        counts = self.sample(samples=samples, circuit=circuit, read_out_qubits=qubits, variables=variables,
+                             initial_state=initial_state, *args, **kwargs)
         # compute energy
         E = 0.0
         n_samples = 0
@@ -792,7 +795,7 @@ class BackendExpectationValue:
     def __deepcopy__(self, memodict={}):
         return type(self)(self.abstract_expectationvalue, **self._input_args)
 
-    def __call__(self, variables, samples: int = None, *args, **kwargs):
+    def __call__(self, variables, samples: int = None, initial_state: Union[int, QubitWaveFunction] = 0, *args, **kwargs):
 
         variables = format_variable_dictionary(variables=variables)
         if self._variables is not None and len(self._variables) > 0:
@@ -802,9 +805,9 @@ class BackendExpectationValue:
                         self._variables, variables))
 
         if samples is None:
-            data = self.simulate(variables=variables, *args, **kwargs)
+            data = self.simulate(variables=variables, initial_state=initial_state, *args, **kwargs)
         else:
-            data = self.sample(variables=variables, samples=samples, *args, **kwargs)
+            data = self.sample(variables=variables, samples=samples, initial_state=initial_state, *args, **kwargs)
 
         if self._shape is None and self._contraction is None:
             # this is the default
@@ -852,7 +855,7 @@ class BackendExpectationValue:
         """wrapper over circuit update_variables"""
         self._U.update_variables(variables=variables)
 
-    def sample(self, variables, samples, *args, **kwargs) -> numpy.array:
+    def sample(self, variables, samples, initial_state: Union[int, QubitWaveFunction] = 0, *args, **kwargs) -> numpy.array:
         """
         sample the expectationvalue.
 
@@ -862,6 +865,8 @@ class BackendExpectationValue:
             variables to supply to the unitary.
         samples: int:
             number of samples to perform.
+        initial_state: int or QubitWaveFunction:
+            the initial state of the circuit
         args
         kwargs
 
@@ -891,16 +896,16 @@ class BackendExpectationValue:
             if len(H.qubits) == 0:
                 E = sum([ps.coeff for ps in H.paulistrings])
             elif H.is_all_z():
-                E = self.U.sample_all_z_hamiltonian(samples=samples, hamiltonian=H, variables=variables, *args,
-                                                    **kwargs)
+                E = self.U.sample_all_z_hamiltonian(samples=samples, hamiltonian=H, variables=variables, initial_state=initial_state,
+                                                *args, **kwargs)
             else:
                 for ps in H.paulistrings:
-                    E += self.U.sample_paulistring(samples=samples, paulistring=ps, variables=variables, *args,
-                                                   **kwargs)
+                    E += self.U.sample_paulistring(samples=samples, paulistring=ps, variables=variables, initial_state=initial_state,
+                                                   *args, **kwargs)
             result.append(to_float(E))
         return numpy.asarray(result)
 
-    def simulate(self, variables, *args, **kwargs):
+    def simulate(self, variables, initial_state: Union[int, QubitWaveFunction], *args, **kwargs):
         """
         Simulate the expectationvalue.
 
@@ -908,6 +913,8 @@ class BackendExpectationValue:
         ----------
         variables:
             variables to supply to the unitary.
+        initial_state: int or QubitWaveFunction:
+            the initial state of the circuit
         args
         kwargs
 
@@ -922,7 +929,7 @@ class BackendExpectationValue:
             final_E = 0.0
             # TODO inefficient,
             # Always better to overwrite this function
-            wfn = self.U.simulate(variables=variables, *args, **kwargs)
+            wfn = self.U.simulate(variables=variables, initial_state=initial_state, *args, **kwargs)
             final_E += wfn.compute_expectationvalue(operator=H)
             result.append(to_float(final_E))
         return numpy.asarray(result)

tequila/simulators/simulator_qiskit.py

@@ -9,7 +9,7 @@ from typing import Union
 import warnings
 import numpy as np
 import qiskit, qiskit_aer, qiskit.providers.fake_provider
-from qiskit import QuantumCircuit
+from qiskit import QuantumCircuit, transpile
 
 HAS_NOISE = True
 try:
@@ -316,11 +316,9 @@ class BackendCircuitQiskit(BackendCircuit):
             optimization_level = kwargs['optimization_level']
 
         circuit = self.circuit.assign_parameters(self.resolver)
-
         circuit = self.add_state_init(circuit, initial_state)
-
         circuit.save_statevector()
-
+        circuit = transpile(circuit, qiskit_backend)
         backend_result = qiskit_backend.run(circuit, optimization_level=optimization_level).result()
 
         return QubitWaveFunction.from_array(array=backend_result.get_statevector(circuit).data, numbering=self.numbering)
@@ -349,11 +347,11 @@ class BackendCircuitQiskit(BackendCircuit):
         if 'optimization_level' in kwargs:
             optimization_level = kwargs['optimization_level']
         if self.device is None:
-            qiskit_backend = self.retrieve_device('aer_simulator')
+            qiskit_backend = self.retrieve_device(self.STATEVECTOR_DEVICE_NAME)
         else:
             qiskit_backend = self.retrieve_device(self.device)
 
-        if isinstance(qiskit_backend, IBMBackend):
+        if HAS_IBMQ and isinstance(qiskit_backend, IBMBackend):
             if self.noise_model is not None:
                 raise TequilaException(
                     'Cannot combine backend {} with custom noise models.'.format(str(qiskit_backend)))
@@ -370,7 +368,7 @@ class BackendCircuitQiskit(BackendCircuit):
                 if self.noise_model is not None:
                     from_back = self.noise_model
                 basis = from_back.basis_gates
-                use_backend = self.retrieve_device('aer_simulator')
+                use_backend = self.retrieve_device(self.STATEVECTOR_DEVICE_NAME)
                 use_backend.set_options(noise_model=from_back)
                 circuit = qiskit.transpile(circuit, backend=use_backend,
                                            basis_gates=basis,

tequila/simulators/simulator_qulacs.py

@@ -429,13 +429,15 @@ class BackendExpectationValueQulacs(BackendExpectationValue):
     use_mapping = True
     BackendCircuitType = BackendCircuitQulacs
 
-    def simulate(self, variables, *args, **kwargs) -> numpy.array:
+    def simulate(self, variables, initial_state: Union[int, QubitWaveFunction] = 0, *args, **kwargs) -> numpy.array:
         """
         Perform simulation of this expectationvalue.
         Parameters
         ----------
         variables:
             variables, to be supplied to the underlying circuit.
+        initial_state: int or QubitWaveFunction:
+            the initial state of the circuit
         args
         kwargs
 
@@ -453,7 +455,7 @@ class BackendExpectationValueQulacs(BackendExpectationValue):
             return numpy.asarray[self.H]
 
         self.U.update_variables(variables)
-        state = self.U.initialize_state(self.n_qubits)
+        state = self.U.initialize_state(self.n_qubits, initial_state)
         self.U.circuit.update_quantum_state(state)
         result = []
         for H in self.H:
@@ -495,7 +497,7 @@ class BackendExpectationValueQulacs(BackendExpectationValue):
             result.append(qulacs_H)
         return result
 
-    def sample(self, variables, samples, *args, **kwargs) -> numpy.array:
+    def sample(self, variables, samples, initial_state: Union[int, QubitWaveFunction] = 0, *args, **kwargs) -> numpy.array:
         """
         Sample this Expectation Value.
         Parameters
@@ -504,6 +506,8 @@ class BackendExpectationValueQulacs(BackendExpectationValue):
             variables, to supply to the underlying circuit.
         samples: int:
             the number of samples to take.
+        initial_state: int or QubitWaveFunction:
+            the initial state of the circuit
         args
         kwargs
 
@@ -513,13 +517,13 @@ class BackendExpectationValueQulacs(BackendExpectationValue):
             the result of sampling as a number.
         """
         self.update_variables(variables)
-        state = self.U.initialize_state(self.n_qubits)
+        state = self.U.initialize_state(self.n_qubits, initial_state)
         self.U.circuit.update_quantum_state(state)
         result = []
-        for H in self._reduced_hamiltonians: # those are the hamiltonians which where non-used qubits are already traced out
+        for H in self._reduced_hamiltonians:  # those are the hamiltonians which where non-used qubits are already traced out
             E = 0.0
             if H.is_all_z() and not self.U.has_noise:
-                E = super().sample(samples=samples, variables=variables, *args, **kwargs)
+                E = super().sample(samples=samples, variables=variables, initial_state=initial_state, *args, **kwargs)
             else:
                 for ps in H.paulistrings:
                     # change basis, measurement is destructive so the state will be copied
@@ -530,8 +534,8 @@ class BackendExpectationValueQulacs(BackendExpectationValue):
                     qbc = self.U.create_circuit(abstract_circuit=bc, variables=None)
                     Esamples = []
                     for sample in range(samples):
-                        if self.U.has_noise and sample>0:
-                            state = self.U.initialize_state(self.n_qubits)
+                        if self.U.has_noise and sample > 0:
+                            state = self.U.initialize_state(self.n_qubits, initial_state)
                             self.U.circuit.update_quantum_state(state)
                             state_tmp = state
                         else:
@@ -540,7 +544,7 @@ class BackendExpectationValueQulacs(BackendExpectationValue):
                             qbc.update_quantum_state(state_tmp)
                         ps_measure = 1.0
                         for idx in ps.keys():
-                            assert idx in self.U.abstract_qubits # assert that the hamiltonian was really reduced
+                            assert idx in self.U.abstract_qubits  # assert that the hamiltonian was really reduced
                             M = qulacs.gate.Measurement(self.U.qubit(idx), self.U.qubit(idx))
                             M.update_quantum_state(state_tmp)
                             measured = state_tmp.get_classical_value(self.U.qubit(idx))

tequila/simulators/simulator_spex.py

@@ -0,0 +1,429 @@
+from tequila.simulators.simulator_base import BackendExpectationValue, BackendCircuit
+from tequila.wavefunction.qubit_wavefunction import QubitWaveFunction
+from tequila.utils import TequilaException
+from tequila.hamiltonian import PauliString
+from tequila.circuit._gates_impl import ExponentialPauliGateImpl, QGateImpl, RotationGateImpl, QubitHamiltonian
+from tequila.circuit.gates import QubitExcitationImpl
+from tequila import BitNumbering
+
+
+import hashlib
+import numpy
+import os
+import spex_tequila
+import gc
+
+numbering = BitNumbering.MSB
+
+class TequilaSpexException(TequilaException):
+    """Custom exception for SPEX simulator errors"""
+    pass
+
+def extract_pauli_dict(ps):
+    """
+    Extract qubit:operator mapping from PauliString/QubitHamiltonian
+    Args:
+        ps: PauliString or single-term QubitHamiltonian
+    Returns:
+        dict: {qubit: 'X'/'Y'/'Z'}
+    """
+
+    if isinstance(ps, PauliString):
+        return dict(ps.items())
+    if isinstance(ps, QubitHamiltonian) and len(ps.paulistrings) == 1:
+        return dict(ps.paulistrings[0].items())
+    raise TequilaSpexException("Unsupported generator type")
+
+def circuit_hash(abstract_circuit, variables=None):
+    """
+    Create MD5 hash for circuit caching
+    Uses gate types, targets, controls and generators for uniqueness
+    """
+    sha = hashlib.md5()
+    if abstract_circuit is None:
+        return None
+    for g in abstract_circuit.gates:
+        gate_str = f"{type(g).__name__}:{g.name}:{g.target}:{g.control}:{g.generator}:{getattr(g, 'parameter', None)}\n"
+        sha.update(gate_str.encode('utf-8'))
+    if variables:
+        for key, value in sorted(variables.items()):
+            sha.update(f"{key}:{value}\n".encode('utf-8'))
+    return sha.hexdigest()
+
+class BackendCircuitSpex(BackendCircuit):
+    """SPEX circuit implementation using sparse state representation"""
+
+    # Circuit compilation configuration
+    compiler_arguments = {
+        "multitarget": True,
+        "multicontrol": True,
+        "trotterized": True,
+        "generalized_rotation": True,
+        "exponential_pauli": False,
+        "controlled_exponential_pauli": True,
+        "hadamard_power": True,
+        "controlled_power": True,
+        "power": True,
+        "toffoli": True,
+        "controlled_phase": True,
+        "phase": True,
+        "phase_to_z": True,
+        "controlled_rotation": True,
+        "swap": True,
+        "cc_max": True,
+        "ry_gate": True,
+        "y_gate": True,
+        "ch_gate": True
+    }
+
+    def __init__(self, 
+                 abstract_circuit=None, 
+                 variables=None, 
+                 num_threads=-1, 
+                 amplitude_threshold=1e-14, 
+                 angle_threshold=1e-14,
+                 compress_qubits=True,
+                 *args, **kwargs):
+        
+        # Circuit chaching
+        self.circuit_cache = {}
+
+        # Performance parameters
+        self.num_threads = num_threads
+        self.amplitude_threshold = amplitude_threshold
+        self.angle_threshold = angle_threshold
+
+        # State compression
+        self.compress_qubits = compress_qubits
+        self.n_qubits_compressed = None
+        self.hamiltonians = None
+        
+        super().__init__(abstract_circuit=abstract_circuit, variables=variables, *args, **kwargs)
+
+    @property
+    def n_qubits(self):
+        """Get number of qubits after compression (if enabled)"""
+        used = set()
+        if hasattr(self, "circuit") and self.circuit:
+            for term in self.circuit:
+                used.update(term.pauli_map.keys())
+        
+        if self.abstract_circuit is not None and hasattr(self.abstract_circuit, "gates"):
+            for gate in self.abstract_circuit.gates:
+                if hasattr(gate, "target"):
+                    if isinstance(gate.target, (list, tuple)):
+                        used.update(gate.target)
+                    else:
+                        used.add(gate.target)
+                if hasattr(gate, "control") and gate.control:
+                    if isinstance(gate.control, (list, tuple)):
+                        used.update(gate.control)
+                    else:
+                        used.add(gate.control)
+        computed = max(used) + 1 if used else 0
+        return max(super().n_qubits, computed)
+
+    def initialize_circuit(self, *args, **kwargs):
+        return []
+    
+    def create_circuit(self, abstract_circuit=None, variables=None, *args, **kwargs):
+        """Compile circuit with caching using MD5 hash"""
+        if abstract_circuit is None:
+            abstract_circuit = self.abstract_circuit
+
+        key = circuit_hash(abstract_circuit, variables)
+
+        if key in self.circuit_cache:
+            return self.circuit_cache[key]
+        
+        circuit = super().create_circuit(abstract_circuit=abstract_circuit, variables=variables, *args, **kwargs)
+
+        self.circuit_cache[key] = circuit
+
+        return circuit
+    
+    def compress_qubit_indices(self):
+        """
+        Optimize qubit indices by mapping used qubits to contiguous range
+        Reduces memory usage by eliminating unused qubit dimensions
+        """
+        if not self.compress_qubits or not (hasattr(self, "circuit") and self.circuit):
+            return
+
+        # Collect all qubits used in circuit and Hamiltonians
+        used_qubits = set()
+        for term in self.circuit:
+            used_qubits.update(term.pauli_map.keys())
+        for ham in self.hamiltonians:
+            for term, _ in ham:
+                used_qubits.update(term.pauli_map.keys())
+
+        if not used_qubits:
+            self.n_qubits_compressed = 0
+            return
+
+        # Create qubit mapping and remap all terms
+        qubit_map = {old: new for new, old in enumerate(sorted(used_qubits))}
+        
+        for term in self.circuit:
+            term.pauli_map = {qubit_map[old]: op for old, op in term.pauli_map.items()}
+
+        if self.hamiltonians is not None:    
+            for ham in self.hamiltonians:
+                for term, _ in ham:
+                    term.pauli_map = {qubit_map[old]: op for old, op in term.pauli_map.items()}
+
+        self.n_qubits_compressed = len(used_qubits)
+
+    def update_variables(self, variables, *args, **kwargs):
+        if variables is None:
+            variables = {}
+        super().update_variables(variables)
+        self.circuit = self.create_circuit(abstract_circuit=self.abstract_circuit, variables=variables)
+
+    def assign_parameter(self, param, variables):
+        if isinstance(param, (int, float, complex)):
+            return float(param)
+        if isinstance(param, str):
+            if param in variables:
+                return float(variables[param])
+            else:
+                raise TequilaSpexException(f"Variable '{param}' not found in variables")
+        if callable(param):
+            result = param(variables)
+            return float(result)
+        
+        raise TequilaSpexException(f"Can't assign parameter '{param}'.")
+
+
+    def add_basic_gate(self, gate, circuit, *args, **kwargs):
+        """Convert Tequila gates to SPEX exponential Pauli terms"""
+        exp_term = spex_tequila.ExpPauliTerm()
+        if isinstance(gate, ExponentialPauliGateImpl):
+            if self.angle_threshold is not None and abs(gate.parameter) < self.angle_threshold:
+                return
+            exp_term.pauli_map = extract_pauli_dict(gate.paulistring)
+            exp_term.angle = gate.parameter
+            circuit.append(exp_term)
+
+        elif isinstance(gate, RotationGateImpl):
+            if self.angle_threshold is not None and abs(gate.parameter) < self.angle_threshold:
+                return
+            exp_term.pauli_map = extract_pauli_dict(gate.generator)
+            exp_term.angle = gate.parameter
+            circuit.append(exp_term)
+
+        elif isinstance(gate, QubitExcitationImpl):
+            compiled_gate = gate.compile(exponential_pauli=True)
+            for sub_gate in compiled_gate.abstract_circuit.gates:
+                self.add_basic_gate(sub_gate, circuit, *args, **kwargs)
+
+        elif isinstance(gate, QGateImpl):
+            if gate.name.lower() in ["x","y","z"]:
+                # Convert standard gates to Pauli rotations
+                for ps in gate.make_generator(include_controls=True).paulistrings:
+                    angle = numpy.pi * ps.coeff
+                    if self.angle_threshold is not None and abs(angle) < self.angle_threshold:
+                        continue
+                    exp_term = spex_tequila.ExpPauliTerm()
+                    exp_term.pauli_map = dict(ps.items())
+                    exp_term.angle = angle
+                    circuit.append(exp_term)
+            elif gate.name.lower() in ["h", "hadamard"]:
+                assert len(gate.target)==1
+                target = gate.target[0]
+                for ps in ["-0.25*Y({q})", "Z({q})", "0.25*Y({q})"]:
+                    ps = QubitHamiltonian(ps.format(q=gate.target[0])).paulistrings[0]
+                    angle = numpy.pi * ps.coeff
+                    exp_term = spex_tequila.ExpPauliTerm()
+                    exp_term.pauli_map = dict(ps.items())
+                    exp_term.angle = angle
+                    circuit.append(exp_term)
+            else:
+                raise TequilaSpexException("{} not supported. Only x,y,z,h".format(gate.name.lower()))
+
+        else:
+            raise TequilaSpexException(f"Unsupported gate object type: {type(gate)}. "
+                                       "All gates should be compiled to exponential pauli or rotation gates.")
+
+
+
+    def add_parametrized_gate(self, gate, circuit, *args, **kwargs):
+        """Convert Tequila parametrized gates to SPEX exponential Pauli terms"""
+        exp_term = spex_tequila.ExpPauliTerm()
+        if isinstance(gate, ExponentialPauliGateImpl):
+            angle = self.assign_parameter(gate.parameter, kwargs.get("variables", {}))
+            if self.angle_threshold is not None and abs(angle) < self.angle_threshold:
+                return
+            exp_term.pauli_map = extract_pauli_dict(gate.paulistring)
+            exp_term.angle = angle
+            circuit.append(exp_term)
+
+        elif isinstance(gate, RotationGateImpl):
+            angle = self.assign_parameter(gate.parameter, kwargs.get("variables", {}))
+            if self.angle_threshold is not None and abs(angle) < self.angle_threshold:
+                return
+            exp_term.pauli_map = extract_pauli_dict(gate.generator)
+            exp_term.angle = angle
+            circuit.append(exp_term)
+
+        elif isinstance(gate, QubitExcitationImpl):
+            compiled_gate = gate.compile(exponential_pauli=True)
+            for sub_gate in compiled_gate.abstract_circuit.gates:
+                self.add_parametrized_gate(sub_gate, circuit, *args, **kwargs)
+        
+        elif isinstance(gate, QGateImpl):
+            for ps in gate.make_generator(include_controls=True).paulistrings:
+                if self.angle_threshold is not None and abs(gate.parameter) < self.angle_threshold:
+                    continue
+                exp_term = spex_tequila.ExpPauliTerm()
+                exp_term.pauli_map = dict(ps.items())
+                exp_term.angle = gate.parameter
+                circuit.append(exp_term)
+
+        else:
+            raise TequilaSpexException(f"Unsupported gate type: {type(gate)}. "
+                                       "Only Exponential Pauli and Rotation gates are allowed after compilation.")
+
+
+    def do_simulate(self, variables, initial_state=0, *args, **kwargs) -> QubitWaveFunction:
+        """
+        Simulate circuit and return final state
+        Args:
+            initial_state: Starting state (int or QubitWaveFunction)
+        Returns:
+            QubitWaveFunction: Sparse state representation
+        """
+
+        if self.compress_qubits and self.n_qubits_compressed is not None and self.n_qubits_compressed > 0:
+            n_qubits = self.n_qubits_compressed
+        else:
+            n_qubits = self.n_qubits
+
+        # Initialize state
+        if isinstance(initial_state, (int, numpy.integer)):
+            if initial_state == 0:
+                state = spex_tequila.initialize_zero_state(n_qubits)
+            else:
+                state = {initial_state: 1.0 + 0j}
+        else:
+            # initial_state is already a QubitWaveFunction
+            state = {k: v for k, v in initial_state.raw_items()}
+
+        # Apply circuit with amplitude thresholding, -1.0 disables threshold in spex_tequila
+        threshold = self.amplitude_threshold if self.amplitude_threshold is not None else -1.0
+        final_state = spex_tequila.apply_U(self.circuit, state, threshold, n_qubits)
+
+        wfn_MSB = QubitWaveFunction(n_qubits=n_qubits, numbering=BitNumbering.MSB)
+        for state, amplitude in final_state.items():
+            wfn_MSB[state] = amplitude
+
+        del final_state
+        gc.collect()
+
+        return wfn_MSB
+    
+    def simulate(self, variables, initial_state=0, *args, **kwargs) -> QubitWaveFunction:
+        """Override simulate to avoid automatic mapping by KeyMapSubregisterToRegister"""
+        self.update_variables(variables)
+        result = self.do_simulate(variables=variables, initial_state=initial_state, *args, **kwargs)
+        return result
+
+
+class BackendExpectationValueSpex(BackendExpectationValue):
+    """SPEX expectation value calculator using sparse simulations"""
+    BackendCircuitType = BackendCircuitSpex
+
+    def __init__(self, *args,
+                 num_threads=-1,
+                 amplitude_threshold=1e-14, 
+                 angle_threshold=1e-14,
+                 compress_qubits=True,
+                 **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.num_threads = num_threads
+        self.amplitude_threshold = amplitude_threshold
+        self.angle_threshold = angle_threshold
+    
+        # Configure circuit parameters
+        if isinstance(self.U, BackendCircuitSpex):
+            self.U.num_threads = num_threads
+            self.U.amplitude_threshold = amplitude_threshold
+            self.U.angle_threshold = angle_threshold
+            self.U.compress_qubits = compress_qubits
+
+    def initialize_hamiltonian(self, hamiltonians):
+        """
+        Initializes the Hamiltonian terms for the simulation.
+        Args:
+            hamiltonians: A list of Hamiltonian objects.
+        Returns:
+            tuple: A converted list of (pauli_string, coefficient) tuples.
+        """
+        # Convert Tequila Hamiltonians into a list of (pauli_string, coeff) tuples for spex_tequila.
+        converted = []
+        for H in hamiltonians:
+            terms = []
+            for ps in H.paulistrings:
+                # Construct Pauli string like "X(0)Y(1)"
+                pauli_map = dict(ps.items()) 
+                term = spex_tequila.ExpPauliTerm()
+                term.pauli_map = pauli_map 
+                terms.append((term, ps.coeff))                    
+            converted.append(terms)
+
+        if isinstance(self.U, BackendCircuitSpex):
+            self.U.hamiltonians = converted
+
+        return tuple(converted)
+
+
+    def simulate(self, variables, initial_state=0, *args, **kwargs):
+        """
+        Calculate expectation value through sparse simulation
+        Returns:
+            numpy.ndarray: Expectation values for each Hamiltonian term
+        """
+
+        # Prepare simulation
+        self.update_variables(variables)
+        if self.U.compress_qubits:
+            self.U.compress_qubit_indices()
+
+        if self.U.compress_qubits and self.U.n_qubits_compressed is not None and self.U.n_qubits_compressed > 0:
+            n_qubits = self.U.n_qubits_compressed
+        else:
+            n_qubits = self.U.n_qubits
+
+        # Prepare the initial state
+        if isinstance(initial_state, int):
+            if initial_state == 0:
+                state = spex_tequila.initialize_zero_state(n_qubits)
+            else:
+                state = {initial_state: 1.0 + 0j}
+        else:
+            # initial_state is a QubitWaveFunction
+            state = {k: v for k, v in initial_state.raw_items()}
+
+        self.U.circuit = [t for t in self.U.circuit if abs(t.angle) >= self.U.angle_threshold]
+
+        threshold = self.amplitude_threshold if self.amplitude_threshold is not None else -1.0
+        final_state = spex_tequila.apply_U(self.U.circuit, state, threshold, n_qubits)
+        del state
+
+        if "SPEX_NUM_THREADS" in os.environ:
+            self.num_threads = int(os.environ["SPEX_NUM_THREADS"])
+        elif "OMP_NUM_THREADS" in os.environ:
+            self.num_threads = int(os.environ["OMP_NUM_THREADS"])
+
+        # Calculate the expectation value for each Hamiltonian
+        results = []
+        for H_terms in self.H:
+            val = spex_tequila.expectation_value_parallel(final_state, final_state, H_terms, n_qubits, num_threads=-1)
+            results.append(val.real)
+        
+        del final_state
+        gc.collect()
+        
+        return numpy.array(results)

tequila/simulators/test_spex_simulator.py

@@ -0,0 +1,211 @@
+import tequila as tq
+import numpy as np
+import time
+import os
+import csv
+from tequila.hamiltonian import PauliString
+import pytest
+
+
+#!/usr/bin/env python
+import tequila as tq
+import numpy as np
+import time
+
+print("Test: Circuit und Hamiltonian mit Variablen (SPEX vs. Qulacs)")
+
+# --- Parameterdefinition ---
+# Definiere mehrere Variablen für die Rotation
+a = tq.Variable("a")
+b = tq.Variable("b")
+c = tq.Variable("c")
+variables = {"a": np.pi/3, "b": np.pi/4, "c": np.pi/6}
+
+# --- Circuitaufbau ---
+# Erzeuge einen Circuit, der auf 3 Qubits operiert:
+# - Eine Rx-Rotation auf Qubit 0 (Winkel "a")
+# - Eine Ry-Rotation auf Qubit 1 (Winkel "b")
+# - Eine Rz-Rotation auf Qubit 2 (Winkel "c")
+# - Zusätzlich eine parametrische exponentielle Pauli-Rotation (ExpPauli) auf Qubit 0 und 2 (Pauli-String "X(0)Z(2)")
+U = tq.gates.Rx(angle="a", target=(0,)) \
+    + tq.gates.Ry(angle="b", target=(1,)) \
+    + tq.gates.Rz(angle="c", target=(2,))
+U += tq.gates.ExpPauli(angle="a", paulistring="X(0)Z(2)")
+
+print("\nCircuit U:")
+print(U)
+
+# --- Hamiltonianaufbau ---
+# Erstelle einen zusammengesetzten Hamiltonian auf 3 Qubits,
+# z.B.: H = Z(0) + X(1)Y(2) + Z(0)Z(1)
+H = tq.QubitHamiltonian("Z(0) + X(1)Y(2) + Z(0)Z(1)")
+print("\nHamiltonian H:")
+print(H)
+
+# Erzeuge ein Erwartungswertobjekt
+E = tq.ExpectationValue(U=U, H=H)
+
+# --- Simulation mit SPEX ---
+start = time.time()
+wfn_spex = tq.simulate(U, variables, backend='spex')
+exp_spex = tq.simulate(E, variables, backend='spex')
+end = time.time()
+time_spex = end - start
+
+# --- Simulation mit Qulacs ---
+start = time.time()
+wfn_qulacs = tq.simulate(U, variables, backend='qulacs')
+exp_qulacs = tq.simulate(E, variables, backend='qulacs')
+end = time.time()
+time_qulacs = end - start
+
+# --- Ergebnisse ausgeben ---
+print("\nSimulationsergebnisse:")
+print("Wellenfunktion (SPEX backend):")
+print(wfn_spex)
+print("\nWellenfunktion (Qulacs backend):")
+print(wfn_qulacs)
+
+print("\nErwartungswert (SPEX backend):", exp_spex, f"(Simulationszeit: {time_spex:.3f}s)")
+print("Erwartungswert (Qulacs backend):", exp_qulacs, f"(Simulationszeit: {time_qulacs:.3f}s)")
+
+# Optional: Vergleiche das innere Produkt der beiden Wavefunctions (Quadrat des Betrags)
+inner_prod = np.abs(wfn_spex.inner(wfn_qulacs))**2
+print("\nInneres Produkt (Quadrat) zwischen SPEX und Qulacs:", inner_prod)
+
+
+
+"""
+print("\nTest: 1")
+U = tq.gates.ExpPauli(paulistring=PauliString({0: "X", 1: "Z"}), angle=np.pi / 2)
+H = tq.QubitHamiltonian("Z(0)")
+E = tq.ExpectationValue(U=U, H=H)
+
+print(U)
+print("spex-U:", tq.simulate(U, backend='spex'))
+print("qulacs-U:", tq.simulate(U, backend='qulacs'))
+print("spex:", tq.simulate(E, backend='spex'))
+print("qulacs:", tq.simulate(E, backend='qulacs'))
+
+
+print("\nTest: 2")
+H = tq.QubitHamiltonian("Z(0)X(1)")
+
+U = tq.gates.Rx(angle=np.pi / 4, target=(0,))
+U += tq.gates.Ry(angle=np.pi / 3, target=(1,)) 
+E = tq.ExpectationValue(U=U, H=H)
+
+print(U)
+print("spex-U:", tq.simulate(U, backend='spex'))
+print("qulacs-U:", tq.simulate(U, backend='qulacs'))
+print("spex:", tq.simulate(E, backend='spex'))
+print("qulacs:", tq.simulate(E, backend='qulacs'))
+
+
+print("\nTest: 3")
+H = tq.QubitHamiltonian("Z(0)")
+
+U = tq.gates.X(target=(0,))
+U += tq.gates.Y(target=(1,)) 
+E = tq.ExpectationValue(U=U, H=H)
+
+print(U)
+print("spex-U:", tq.simulate(U, backend='spex'))
+print("qulacs-U:", tq.simulate(U, backend='qulacs'))
+print("spex:", tq.simulate(E, backend='spex'))
+print("qulacs:", tq.simulate(E, backend='qulacs'))
+
+
+print("\nTest: 4")
+U = (
+    tq.gates.Rx(angle=np.pi / 2, target=(0,)) +
+    tq.gates.Rz(angle=np.pi / 2, target=(1,)) +
+    tq.gates.Ry(angle=np.pi / 3, target=(2,)) +
+    tq.gates.ExpPauli(paulistring=PauliString({0: "X", 1: "X", 2: "X"}), angle=np.pi / 4)
+)
+
+H = tq.QubitHamiltonian("X(0)X(1)X(2) + Z(0) + Z(1) + Z(2)")
+E = tq.ExpectationValue(U=U, H=H)
+
+print(U)
+print("spex-U:", tq.simulate(U, backend='spex'))
+print("qulacs-U:", tq.simulate(U, backend='qulacs'))
+print("spex:", tq.simulate(E, backend='spex'))
+print("qulacs:", tq.simulate(E, backend='qulacs'))
+
+print("\nTest: 5")
+os.environ["OMP_NUM_THREADS"] = "6"
+
+results = []
+
+for n in range(1, 15):
+    # 1) Geometrie aufbauen
+    geom = ""
+    for k in range(2*n):
+        geom += f"h 0.0 0.0 {1.5*k}\n"
+
+    # 2) Molekül + Hamiltonian
+    mol = tq.Molecule(geometry=geom, basis_set="sto-3g")
+    H   = mol.make_hardcore_boson_hamiltonian()
+
+    # 3) Ansatz U
+    edges = [(2*i, 2*i+1) for i in range(n)]
+    U = mol.make_ansatz(name="HCB-SPA", edges=edges)
+    # Alle im Ansatz auftretenden Variablen auf 1.0 setzen
+    U = U.map_variables({var: 1.0 for var in U.extract_variables()})
+
+    # 4) Erwartungswert-Objekt
+    E_obj = tq.ExpectationValue(H=H, U=U)
+
+    # -- SPEX-Berechnung --
+    start_spex = time.time()
+    E_spex = tq.simulate(E_obj, backend='spex', num_threads=6)
+    end_spex = time.time()
+    time_spex = end_spex - start_spex
+
+    # -- Qulacs-Berechnung --
+    if n <= 10:
+        start_qulacs = time.time()
+        E_qulacs = tq.simulate(E_obj, backend='qulacs')
+        end_qulacs = time.time()
+        time_qulacs = end_qulacs - start_qulacs
+
+    total_measurements = E_obj.count_measurements()
+
+    # Speichern der Daten
+    results.append({
+        'n': n,
+        'total_measurements' : total_measurements,
+        'E_spex': E_spex,
+        'time_spex': time_spex,
+        'E_qulacs': E_qulacs,
+        'time_qulacs': time_qulacs
+    })
+
+    if E_qulacs is not None:
+        print(f"n={n:2d} | total_measurements={total_measurements} | "
+              f"E_spex={E_spex:.6f} (dt={time_spex:.2f}s) | "
+              f"E_qulacs={E_qulacs:.6f} (dt={time_qulacs:.2f}s)")
+    else:
+        print(f"n={n:2d} | total_measurements={total_measurements} | "
+              f"E_spex={E_spex:.6f} (dt={time_spex:.2f}s) | "
+              f"E_qulacs=--- (dt=---)  (für n>13 nicht berechnet)")
+    
+    with open("spex_qulacs_comparison.csv", mode="w", newline="") as f:
+        writer = csv.writer(f)
+        # Kopfzeile
+        writer.writerow(["n", "total_measurements", "E_spex", "time_spex", "E_qulacs", "time_qulacs"])
+        # Datenzeilen
+        for entry in results:
+            writer.writerow([
+                entry["n"],
+                entry["total_measurements"],
+                entry["E_spex"],
+                entry["time_spex"],
+                entry["E_qulacs"] if entry["E_qulacs"] is not None else "NA",
+                entry["time_qulacs"] if entry["time_qulacs"] is not None else "NA"
+            ])
+    
+    E_qulacs = None
+
+"""

tequila/utils/bitstrings.py

@@ -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]

tequila/version.py

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

tequila/wavefunction/qubit_wavefunction.py

@@ -365,7 +365,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 +373,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"

{tequila_basic-1.9.8.dist-info → tequila_basic-1.9.9.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.9
 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)
 

{tequila_basic-1.9.8.dist-info → tequila_basic-1.9.9.dist-info}/RECORD

@@ -1,6 +1,6 @@
 tequila/__init__.py,sha256=FV8-j7GEw_VYadsZUp3M2mGRQxVUYYG3W1jiI6in3CY,1959
 tequila/autograd_imports.py,sha256=t7V5uYaI0GzjD7pSjkYtiaj3BzSvkm_RL2KcYfNwNhM,1529
-tequila/version.py,sha256=sZDtaWTr_VlllD_RWU9Qeudj0ybXPEgH4_O65N0Myp8,57
+tequila/version.py,sha256=YND9gLv_BQrt_NeUjOzGd6JYX47UlW1-UsIm5a71jLs,57
 tequila/apps/__init__.py,sha256=GJb04napv8AAx5EHxS5C1CMv9kxQeu7aA-ZMWk6X_eQ,1623
 tequila/apps/_unary_state_prep_impl.py,sha256=SzRtI0Nx29ODygvYYdC1NnSTCL70wY7NTAvqhiwpMDs,21757
 tequila/apps/unary_state_prep.py,sha256=X6NTvni5BYzSNv1w-etohh1WwLAZpC06Y3TrSlGKc8U,9367
@@ -13,7 +13,7 @@ tequila/apps/robustness/helpers.py,sha256=t8VgwMfgrhVaa0sNYaxfCIHsEQXL4WAEaT-UJG
 tequila/apps/robustness/interval.py,sha256=m3D1wBRTLRpGQdnabzcDrlxWqN0uCf80NG-enbZrcoY,24735
 tequila/circuit/__init__.py,sha256=ZgoUEjU_NggxjKYkJjh5aO-6VdUjnO5CLxKB44rHzQc,301
 tequila/circuit/_gates_impl.py,sha256=iB40Sg9l9UoCCayu0l4vGjgvEHUVVbXMaGdUtXIHa1w,17821
-tequila/circuit/circuit.py,sha256=5XqOddRAQMgjO_zyRDHQvtGyWt8gBW0seorejsV9KK4,31874
+tequila/circuit/circuit.py,sha256=HASLPspbg6bxqQffm6dkJEUAKgKM9m5HCuwlB03ETnI,32007
 tequila/circuit/compiler.py,sha256=fsHnnNZo43VWUl_n34P21b4GAi7k2kwoYdx0xlbAuZY,32685
 tequila/circuit/gates.py,sha256=buNzNZaflRzVFe1oihCprUBZVL5KcZXyd_kqiWkNbTo,35923
 tequila/circuit/gradient.py,sha256=Y4dNL6nkZUEkKJvaA3hxaSEa8_b_3XZwxy3j8tGsOmA,10465
@@ -39,7 +39,7 @@ tequila/ml/ml_api.py,sha256=T-HEojuiiO3TzeHN_mMX5GheywK2P4pJH7C_9D7HDaM,846
 tequila/ml/utils_ml.py,sha256=uTif6aiNtyJZWTql0uXbxkkKzutAX2w7vbpA7xb9CIw,5533
 tequila/objective/__init__.py,sha256=_BS3tVabs0zdon46nKpKmk3gI40z6KaWsjynIBMnPuc,231
 tequila/objective/braket.py,sha256=10jEj7F3VWAj-fVrD4nhptrgRfrGvij84mVYcJWq4ZU,6019
-tequila/objective/objective.py,sha256=8MzzTousgJf7w7rEdqGr8MU0PRF7S4kwh3BgsMMjnEg,31763
+tequila/objective/objective.py,sha256=SunUH9KdPGV2pWQ2lXKrTJBbDIdNKYsqAknZABviVGg,31930
 tequila/objective/qtensor.py,sha256=eSjFOEVW-kLoM8jn1RD2_E_kHVAm579Ji3_lMcJg7cE,7957
 tequila/optimizers/__init__.py,sha256=1AhFyARYIfdyFGwnjOX0RDDa_kGrhiLJyjEbEm4NgZI,5086
 tequila/optimizers/_containers.py,sha256=CXbWWQory_aADxlaMw4deIr03K_el-0E12GmpA0vX10,7161
@@ -48,39 +48,41 @@ tequila/optimizers/optimizer_gd.py,sha256=QF84K2XDn_-0w9htDlEpIaaGGtfudNamIvVCgx
 tequila/optimizers/optimizer_gpyopt.py,sha256=-aVuutZUScyo6_4q4PyvMMa_OVd3L8ev9Ge2fXyWGV8,11280
 tequila/optimizers/optimizer_scipy.py,sha256=zqRVQ-Whr74KCGP7Zg1jQkl9S3j9s1kS4oCrCtX30gY,18949
 tequila/quantumchemistry/__init__.py,sha256=KP99PNJYVwBcfQGwL-MB9IBLSBJNRPf-5WN9NLqT-Rg,7424
-tequila/quantumchemistry/chemistry_tools.py,sha256=thHsovI-pMJJbEFBuYUAXg2ptitnGe9CeD0mdsh3iV8,46989
+tequila/quantumchemistry/chemistry_tools.py,sha256=PwqDciSHUNeu5J3kxo4koThGIMe2UxBcKE1Ymk912ME,47252
 tequila/quantumchemistry/encodings.py,sha256=GoQrEdzPO0EfvEtVu7_p18TG9VfcMYaqSnyjCmz49hE,11571
 tequila/quantumchemistry/madness_interface.py,sha256=ivwDoaUDyAB6lJoFri0pZpvOZbihGavIuybcc40xTD0,36372
-tequila/quantumchemistry/orbital_optimizer.py,sha256=plaMs77qbVOtrAVDVCwIqQdMOs3dGzC6-fIjm-LugUo,12670
+tequila/quantumchemistry/orbital_optimizer.py,sha256=nxxQ1ILDnJy1EN0PAzltTcQjYYxCdpNXsb5mMFMx-PE,12732
 tequila/quantumchemistry/psi4_interface.py,sha256=syNaDvlSmCsyB4f7idn3VGbMKyKo83vJHD5y5LpHwaM,29953
 tequila/quantumchemistry/pyscf_interface.py,sha256=XgecUnKKg2rGiKqsYCJnDQ89ekkDkKuwc3qHULLMYck,6152
 tequila/quantumchemistry/qc_base.py,sha256=IqPQ-FylaOsKtiLur8QWnvMqFBa_X_i3rdjMHSgQ9fA,107121
 tequila/simulators/__init__.py,sha256=VFw4sJIt4Zc0-__eYnksN8Ku9qMhbPpHJEkXMWUiD30,4
-tequila/simulators/simulator_api.py,sha256=qz5dXCv-C4JXz09WK6eF1jBSMRuIqFIMAfPvNoapOrs,25394
-tequila/simulators/simulator_base.py,sha256=j0v00qA4WFE8agOmcoKGCDH85s40UJAX6gbjYrYamI8,34838
+tequila/simulators/simulator_api.py,sha256=VCKdz4kxB5QX1c4ncHuB9y5SJxwMkkK25SVon3AuHJs,25672
+tequila/simulators/simulator_base.py,sha256=gEbX7MgA09qGYXVA_j1p7xJ_izuiFvEKNB13PEpdMYI,35571
 tequila/simulators/simulator_cirq.py,sha256=j2noXfhqcyPJoramWik_PLwKxNNq_rB794PkIZt8ktA,16552
 tequila/simulators/simulator_pyquil.py,sha256=1n6bQqoDUiXulBJX_9t8knl439aKpIeepRBwcyU72QU,24264
 tequila/simulators/simulator_qibo.py,sha256=8A2YZBmAi23tErfR28eqdWWuwulgblFGZ9Hbrwy7Ht8,25220
-tequila/simulators/simulator_qiskit.py,sha256=8go0PehReRtmdk-onJQ7hKhbM7bKLwhr7YCaSTow2Go,25046
+tequila/simulators/simulator_qiskit.py,sha256=28l18iL3VI3kT0kUSqcizwJjnImyUf1VyERLVCGpWnk,25146
 tequila/simulators/simulator_qiskit_gpu.py,sha256=EXlHtpl5w1bqlYOR1aPIZXFO_Jei5JJTWTESnRli9cc,339
 tequila/simulators/simulator_qlm.py,sha256=OQPZEdbM0UkfzoTx2pa0SM14cN7r6PsGS1cDlfJqTl8,15431
-tequila/simulators/simulator_qulacs.py,sha256=L7pWxSmbUkFEbTffikvnzXLhqjhFbjIy6O0YhZXlWXc,19829
+tequila/simulators/simulator_qulacs.py,sha256=9Q1LlmUIcYcw9KGBfQ5j09sAJSinof6U7hCqWWLDkOk,20195
 tequila/simulators/simulator_qulacs_gpu.py,sha256=3yVIACmQYQp_6ntvjvaGiYoHXbc1mKtb_Oa6Mo-2bSc,557
+tequila/simulators/simulator_spex.py,sha256=DWmHDTnQdIExRwQnt-xOD62wNOuFucXC_tk9UtC22wU,16980
 tequila/simulators/simulator_symbolic.py,sha256=nyS1lwk_dxcsTWKQ2YL4kvdl-kTdC0NoB-EmH6seP-M,5074
+tequila/simulators/test_spex_simulator.py,sha256=Y9jWLxDDEPeTrnCZr017liqA0kJvLANk6wcuqkuXPB8,6480
 tequila/tools/__init__.py,sha256=mJChgkme6v6Ohj2s3tJ96Mq4U0kmVmc6d8Y6_1pEZMg,72
 tequila/tools/convenience.py,sha256=9WYQJvx5i2QwQG8c7lssYTUv5hzW8h16JTr1GHxYf18,1291
 tequila/tools/qng.py,sha256=p19A1rcKo06DAyBVUCQzNhwIGni6eAT6IGPnEPhKa4Y,21326
 tequila/tools/random_generators.py,sha256=UwkDMmNxxSPgaH1LNBswZUiHnLDd8arI3F5QshfBtBY,3417
 tequila/utils/__init__.py,sha256=nlulDMHcq-XyBZf3NPx2bn_tcixi2mvhRc6MhU9TBWI,317
-tequila/utils/bitstrings.py,sha256=81U4Mg6voNzWfQVrrhqaqcOsQnPPkFI2UWQDSAlsMdo,5941
+tequila/utils/bitstrings.py,sha256=e3kptMWj6Nv6h4QsX41H-b_S-t8OBHjqnxmRXOLhzFQ,6141
 tequila/utils/exceptions.py,sha256=QK7AcDO2-7Itr8Aw6rLP_WtSkH6rfT8PHWcvNM6sQnc,1188
 tequila/utils/joined_transformation.py,sha256=R2-aMTi6h7ZnjYUnX6cvFuPEQwgf49W0w33q6018qdc,2013
 tequila/utils/keymap.py,sha256=RgQzeHEfRVee0-uoH-QsLYsGsXyMhEp3n33KCH-EV2k,3735
 tequila/utils/misc.py,sha256=e62ASkFReaLJQXnBXzyYukzXZnXNoURsM1luoMeIXiE,919
 tequila/wavefunction/__init__.py,sha256=q4DVL0lGFg03PogRMYA6S8MQqqmLYQiU9VNOF-YQxfQ,50
-tequila/wavefunction/qubit_wavefunction.py,sha256=2S3vUMwbuUOuFrZ_-ST6s7CU9nSjKTql7rCoc39UPQ8,17529
-tequila_basic-1.9.8.dist-info/LICENSE,sha256=oG1FtUav5_xrym9ByiG5emJDQRcbnAfTB08fRV9TCiE,1114
-tequila_basic-1.9.8.dist-info/METADATA,sha256=RRoQh2vohcUKQGx-Iysn7qOHZHqY5WhHma2eLM5uuDQ,19170
-tequila_basic-1.9.8.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
-tequila_basic-1.9.8.dist-info/top_level.txt,sha256=VBH0gl6mDMbcLHKlO0yEAqtcq08DqBHz4gRJ9jafl5w,8
-tequila_basic-1.9.8.dist-info/RECORD,,
+tequila/wavefunction/qubit_wavefunction.py,sha256=6-Cgg8I6zIi0tfYMrI_jqds1_2vRO5alRSA13tl944Y,17730
+tequila_basic-1.9.9.dist-info/licenses/LICENSE,sha256=oG1FtUav5_xrym9ByiG5emJDQRcbnAfTB08fRV9TCiE,1114
+tequila_basic-1.9.9.dist-info/METADATA,sha256=Pf7NfCw-bJlFp9Z5LQeA0sOOhyxHaUJh0iUMIRHMkRc,19368
+tequila_basic-1.9.9.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+tequila_basic-1.9.9.dist-info/top_level.txt,sha256=VBH0gl6mDMbcLHKlO0yEAqtcq08DqBHz4gRJ9jafl5w,8
+tequila_basic-1.9.9.dist-info/RECORD,,

{tequila_basic-1.9.8.dist-info → tequila_basic-1.9.9.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.5.0)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any