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

tequila/simulators/simulator_qulacs.py

@@ -1,7 +1,8 @@
 from typing import Union
 
 import qulacs
-import numbers, numpy
+import numbers
+import numpy
 import warnings
 
 from tequila import TequilaException, TequilaWarning
@@ -17,10 +18,12 @@ Developer Note:
     The angles are scaled with -1.0 to keep things consistent with the rest of tequila
 """
 
+
 class TequilaQulacsException(TequilaException):
     def __str__(self):
         return "Error in qulacs backend:" + self.message
 
+
 class BackendCircuitQulacs(BackendCircuit):
     """
     Class representing circuits compiled to qulacs.
@@ -49,7 +52,7 @@ class BackendCircuitQulacs(BackendCircuit):
         "trotterized": True,
         "swap": False,
         "multitarget": True,
-        "controlled_rotation": True, # needed for gates depending on variables
+        "controlled_rotation": True,  # needed for gates depending on variables
         "generalized_rotation": True,
         "exponential_pauli": False,
         "controlled_exponential_pauli": True,
@@ -60,7 +63,7 @@ class BackendCircuitQulacs(BackendCircuit):
         "controlled_phase": True,
         "toffoli": False,
         "phase_to_z": True,
-        "cc_max": False
+        "cc_max": False,
     }
 
     numbering = BitNumbering.LSB
@@ -83,41 +86,48 @@ class BackendCircuitQulacs(BackendCircuit):
         kwargs
         """
         self.op_lookup = {
-            'I': qulacs.gate.Identity,
-            'X': qulacs.gate.X,
-            'Y': qulacs.gate.Y,
-            'Z': qulacs.gate.Z,
-            'H': qulacs.gate.H,
-            'Rx': (lambda c: c.add_parametric_RX_gate, qulacs.gate.RX),
-            'Ry': (lambda c: c.add_parametric_RY_gate, qulacs.gate.RY),
-            'Rz': (lambda c: c.add_parametric_RZ_gate, qulacs.gate.RZ),
-            'SWAP': qulacs.gate.SWAP,
-            'Measure': qulacs.gate.Measurement,
-            'Exp-Pauli': None
+            "I": qulacs.gate.Identity,
+            "X": qulacs.gate.X,
+            "Y": qulacs.gate.Y,
+            "Z": qulacs.gate.Z,
+            "H": qulacs.gate.H,
+            "Rx": (lambda c: c.add_parametric_RX_gate, qulacs.gate.RX),
+            "Ry": (lambda c: c.add_parametric_RY_gate, qulacs.gate.RY),
+            "Rz": (lambda c: c.add_parametric_RZ_gate, qulacs.gate.RZ),
+            "SWAP": qulacs.gate.SWAP,
+            "Measure": qulacs.gate.Measurement,
+            "Exp-Pauli": None,
         }
         self.measurements = None
         self.variables = []
         super().__init__(abstract_circuit=abstract_circuit, noise=noise, *args, **kwargs)
-        self.has_noise=False
+        self.has_noise = False
         if noise is not None:
+            warnings.warn(
+                "Warning: noise in qulacs module will be dropped. Currently only works for qulacs version 0.5 or lower",
+                TequilaWarning,
+            )
 
-            warnings.warn("Warning: noise in qulacs module will be dropped. Currently only works for qulacs version 0.5 or lower", TequilaWarning)
-
-            self.has_noise=True
+            self.has_noise = True
             self.noise_lookup = {
-                'bit flip': [qulacs.gate.BitFlipNoise],
-                'phase flip': [lambda target, prob: qulacs.gate.Probabilistic([prob],[qulacs.gate.Z(target)])],
-                'phase damp': [lambda target, prob: qulacs.gate.DephasingNoise(target,(1/2)*(1-numpy.sqrt(1-prob)))],
-                'amplitude damp': [qulacs.gate.AmplitudeDampingNoise],
-                'phase-amplitude damp': [qulacs.gate.AmplitudeDampingNoise,
-                                         lambda target, prob: qulacs.gate.DephasingNoise(target,(1/2)*(1-numpy.sqrt(1-prob)))
-                                         ],
-                'depolarizing': [lambda target,prob: qulacs.gate.DepolarizingNoise(target,3*prob/4)]
+                "bit flip": [qulacs.gate.BitFlipNoise],
+                "phase flip": [lambda target, prob: qulacs.gate.Probabilistic([prob], [qulacs.gate.Z(target)])],
+                "phase damp": [
+                    lambda target, prob: qulacs.gate.DephasingNoise(target, (1 / 2) * (1 - numpy.sqrt(1 - prob)))
+                ],
+                "amplitude damp": [qulacs.gate.AmplitudeDampingNoise],
+                "phase-amplitude damp": [
+                    qulacs.gate.AmplitudeDampingNoise,
+                    lambda target, prob: qulacs.gate.DephasingNoise(target, (1 / 2) * (1 - numpy.sqrt(1 - prob))),
+                ],
+                "depolarizing": [lambda target, prob: qulacs.gate.DepolarizingNoise(target, 3 * prob / 4)],
             }
 
-            self.circuit=self.add_noise_to_circuit(noise)
+            self.circuit = self.add_noise_to_circuit(noise)
 
-    def initialize_state(self, n_qubits: int = None, initial_state: Union[int, QubitWaveFunction] = None) -> qulacs.QuantumState:
+    def initialize_state(
+        self, n_qubits: int = None, initial_state: Union[int, QubitWaveFunction] = None
+    ) -> qulacs.QuantumState:
         if n_qubits is None:
             n_qubits = self.n_qubits
 
@@ -269,13 +279,14 @@ class BackendCircuitQulacs(BackendCircuit):
         None
         """
         assert not gate.is_controlled()
-        convert = {'x': 1, 'y': 2, 'z': 3}
+        convert = {"x": 1, "y": 2, "z": 3}
         pind = [convert[x.lower()] for x in gate.paulistring.values()]
         qind = [self.qubit(x) for x in gate.paulistring.keys()]
         if len(gate.extract_variables()) > 0:
             self.variables.append(-gate.parameter * gate.paulistring.coeff)
-            circuit.add_parametric_multi_Pauli_rotation_gate(qind, pind,
-                                                             -gate.parameter(variables) * gate.paulistring.coeff)
+            circuit.add_parametric_multi_Pauli_rotation_gate(
+                qind, pind, -gate.parameter(variables) * gate.paulistring.coeff
+            )
         else:
             circuit.add_multi_Pauli_rotation_gate(qind, pind, -gate.parameter(variables) * gate.paulistring.coeff)
 
@@ -298,7 +309,7 @@ class BackendCircuitQulacs(BackendCircuit):
         None
         """
         op = self.op_lookup[gate.name]
-        if gate.name == 'Exp-Pauli':
+        if gate.name == "Exp-Pauli":
             self.add_exponential_pauli_gate(gate, circuit, variables)
             return
         else:
@@ -307,7 +318,9 @@ class BackendCircuitQulacs(BackendCircuit):
                 self.variables.append(-gate.parameter)
                 op(circuit)(self.qubit(gate.target[0]), -gate.parameter(variables=variables))
                 if gate.is_controlled():
-                    raise TequilaQulacsException("Gates which depend on variables can not be controlled! Gate was:\n{}".format(gate))
+                    raise TequilaQulacsException(
+                        "Gates which depend on variables can not be controlled! Gate was:\n{}".format(gate)
+                    )
                 return
             else:
                 op = op[1]
@@ -362,8 +375,7 @@ class BackendCircuitQulacs(BackendCircuit):
         self.measurements = sorted(target_qubits)
         return circuit
 
-
-    def add_noise_to_circuit(self,noise_model):
+    def add_noise_to_circuit(self, noise_model):
         """
         Apply noise from a NoiseModel to a circuit.
         Parameters
@@ -376,19 +388,19 @@ class BackendCircuitQulacs(BackendCircuit):
         qulacs.ParametrizedQuantumCircuit:
             self.circuit, with noise added on.
         """
-        c=self.circuit
-        n=noise_model
-        g_count=c.get_gate_count()
-        new=self.initialize_circuit()
+        c = self.circuit
+        n = noise_model
+        g_count = c.get_gate_count()
+        new = self.initialize_circuit()
         for i in range(g_count):
-            g=c.get_gate(i)
+            g = c.get_gate(i)
             new.add_gate(g)
-            qubits=g.get_target_index_list() + g.get_control_index_list()
+            qubits = g.get_target_index_list() + g.get_control_index_list()
             for noise in n.noises:
                 if len(qubits) == noise.level:
-                    for j,channel in enumerate(self.noise_lookup[noise.name]):
+                    for j, channel in enumerate(self.noise_lookup[noise.name]):
                         for q in qubits:
-                            chan=channel(q,noise.probs[j])
+                            chan = channel(q, noise.probs[j])
                             new.add_gate(chan)
         return new
 
@@ -415,17 +427,21 @@ class BackendCircuitQulacs(BackendCircuit):
         opt = qulacs.circuit.QuantumCircuitOptimizer()
         opt.optimize(circuit, max_block_size)
         if not silent:
-            print("qulacs: optimized circuit depth from {} to {} with max_block_size {}".format(old,
-                                                                                                circuit.calculate_depth(),
-                                                                                                max_block_size))
+            print(
+                "qulacs: optimized circuit depth from {} to {} with max_block_size {}".format(
+                    old, circuit.calculate_depth(), max_block_size
+                )
+            )
         return circuit
 
+
 class BackendExpectationValueQulacs(BackendExpectationValue):
     """
     Class representing Expectation Values compiled for Qulacs.
 
     Ovverrides some methods of BackendExpectationValue, which should be seen for details.
     """
+
     use_mapping = True
     BackendCircuitType = BackendCircuitQulacs
 
@@ -460,7 +476,7 @@ class BackendExpectationValueQulacs(BackendExpectationValue):
         result = []
         for H in self.H:
             if isinstance(H, numbers.Number):
-                result.append(H) # those are accumulated unit strings, e.g 0.1*X(3) in wfn on qubits 0,1
+                result.append(H)  # those are accumulated unit strings, e.g 0.1*X(3) in wfn on qubits 0,1
             else:
                 result.append(H.get_expectation_value(state))
 
@@ -483,7 +499,7 @@ class BackendExpectationValueQulacs(BackendExpectationValue):
 
         # map the reduced operators to the potentially smaller qubit system
         qubit_map = {}
-        for i,q in enumerate(self.U.abstract_circuit.qubits):
+        for i, q in enumerate(self.U.abstract_qubits):
             qubit_map[q] = i
 
         result = []
@@ -497,7 +513,9 @@ class BackendExpectationValueQulacs(BackendExpectationValue):
             result.append(qulacs_H)
         return result
 
-    def sample(self, variables, samples, initial_state: Union[int, QubitWaveFunction] = 0, *args, **kwargs) -> numpy.array:
+    def sample(
+        self, variables, samples, initial_state: Union[int, QubitWaveFunction] = 0, *args, **kwargs
+    ) -> numpy.array:
         """
         Sample this Expectation Value.
         Parameters
@@ -520,7 +538,9 @@ class BackendExpectationValueQulacs(BackendExpectationValue):
         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, initial_state=initial_state, *args, **kwargs)
@@ -540,7 +560,9 @@ class BackendExpectationValueQulacs(BackendExpectationValue):
                             state_tmp = state
                         else:
                             state_tmp = state.copy()
-                        if len(bc.gates) > 0:  # otherwise there is no basis change (empty qulacs circuit does not work out)
+                        if (
+                            len(bc.gates) > 0
+                        ):  # otherwise there is no basis change (empty qulacs circuit does not work out)
                             qbc.update_quantum_state(state_tmp)
                         ps_measure = 1.0
                         for idx in ps.keys():
@@ -548,7 +570,7 @@ class BackendExpectationValueQulacs(BackendExpectationValue):
                             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))
-                            ps_measure *= (-2.0 * measured + 1.0)  # 0 becomes 1 and 1 becomes -1
+                            ps_measure *= -2.0 * measured + 1.0  # 0 becomes 1 and 1 becomes -1
                         Esamples.append(ps_measure)
                     E += ps.coeff * sum(Esamples) / len(Esamples)
             result.append(E)

tequila/simulators/simulator_spex.py

@@ -15,10 +15,13 @@ 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
@@ -34,6 +37,7 @@ def extract_pauli_dict(ps):
         return dict(ps.paulistrings[0].items())
     raise TequilaSpexException("Unsupported generator type")
 
+
 def circuit_hash(abstract_circuit, variables=None):
     """
     Create MD5 hash for circuit caching
@@ -44,12 +48,23 @@ def circuit_hash(abstract_circuit, variables=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'))
+        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'))
+            sha.update(f"{key}:{value}\n".encode("utf-8"))
     return sha.hexdigest()
 
+
+def copy_exp_pauli_term(term):
+    """Create a copy of a ExpPauliTerm."""
+    new_term = spex_tequila.ExpPauliTerm()
+    if hasattr(term, "pauli_map"):
+        new_term.pauli_map = dict(term.pauli_map)
+    if hasattr(term, "angle"):
+        new_term.angle = term.angle
+    return new_term
+
+
 class BackendCircuitSpex(BackendCircuit):
     """SPEX circuit implementation using sparse state representation"""
 
@@ -73,18 +88,20 @@ class BackendCircuitSpex(BackendCircuit):
         "cc_max": True,
         "ry_gate": True,
         "y_gate": True,
-        "ch_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):
-        
+    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 = {}
 
@@ -97,7 +114,7 @@ class BackendCircuitSpex(BackendCircuit):
         self.compress_qubits = compress_qubits
         self.n_qubits_compressed = None
         self.hamiltonians = None
-        
+
         super().__init__(abstract_circuit=abstract_circuit, variables=variables, *args, **kwargs)
 
     @property
@@ -107,7 +124,7 @@ class BackendCircuitSpex(BackendCircuit):
         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"):
@@ -125,7 +142,7 @@ class BackendCircuitSpex(BackendCircuit):
 
     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:
@@ -135,46 +152,65 @@ class BackendCircuitSpex(BackendCircuit):
 
         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
+            return self.circuit, self.hamiltonians, self.n_qubits
+
+        new_circuit = [copy_exp_pauli_term(term) for term in self.circuit]
+        for term in new_circuit:
+            if hasattr(term, "pauli_map"):
+                term.pauli_map = dict(term.pauli_map)
+
+        new_hamiltonians = []
+        if self.hamiltonians is not None:
+            for ham in self.hamiltonians:
+                new_ham = []
+                for term, coeff in ham:
+                    cloned = copy_exp_pauli_term(term)
+                    cloned.pauli_map = dict(cloned.pauli_map)
+                    new_ham.append((cloned, coeff))
+                new_hamiltonians.append(new_ham)
 
         # Collect all qubits used in circuit and Hamiltonians
         used_qubits = set()
-        for term in self.circuit:
+        for term in new_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 new_hamiltonians is not None:
+            for ham in new_hamiltonians:
+                for term, _ in ham:
+                    used_qubits.update(term.pauli_map.keys())
 
         if not used_qubits:
             self.n_qubits_compressed = 0
-            return
+            return new_circuit, new_hamiltonians, 0
 
         # Create qubit mapping and remap all terms
         qubit_map = {old: new for new, old in enumerate(sorted(used_qubits))}
-        
-        for term in self.circuit:
+
+        for term in new_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:
+        if new_hamiltonians is not None:
+            for ham in new_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)
 
+        return new_circuit, new_hamiltonians, self.n_qubits_compressed
+
     def update_variables(self, variables, *args, **kwargs):
         if variables is None:
             variables = {}
@@ -192,9 +228,8 @@ class BackendCircuitSpex(BackendCircuit):
         if callable(param):
             result = param(variables)
             return float(result)
-        
-        raise TequilaSpexException(f"Can't assign parameter '{param}'.")
 
+        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"""
@@ -219,7 +254,7 @@ class BackendCircuitSpex(BackendCircuit):
                 self.add_basic_gate(sub_gate, circuit, *args, **kwargs)
 
         elif isinstance(gate, QGateImpl):
-            if gate.name.lower() in ["x","y","z"]:
+            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
@@ -230,7 +265,7 @@ class BackendCircuitSpex(BackendCircuit):
                     exp_term.angle = angle
                     circuit.append(exp_term)
             elif gate.name.lower() in ["h", "hadamard"]:
-                assert len(gate.target)==1
+                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]
@@ -243,10 +278,10 @@ class BackendCircuitSpex(BackendCircuit):
                 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.")
-
-
+            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"""
@@ -271,7 +306,7 @@ class BackendCircuitSpex(BackendCircuit):
             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:
@@ -282,9 +317,10 @@ class BackendCircuitSpex(BackendCircuit):
                 circuit.append(exp_term)
 
         else:
-            raise TequilaSpexException(f"Unsupported gate type: {type(gate)}. "
-                                       "Only Exponential Pauli and Rotation gates are allowed after compilation.")
-
+            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:
         """
@@ -322,7 +358,7 @@ class BackendCircuitSpex(BackendCircuit):
         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)
@@ -332,20 +368,18 @@ class BackendCircuitSpex(BackendCircuit):
 
 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):
+    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
@@ -367,10 +401,10 @@ class BackendExpectationValueSpex(BackendExpectationValue):
             terms = []
             for ps in H.paulistrings:
                 # Construct Pauli string like "X(0)Y(1)"
-                pauli_map = dict(ps.items()) 
+                pauli_map = dict(ps.items())
                 term = spex_tequila.ExpPauliTerm()
-                term.pauli_map = pauli_map 
-                terms.append((term, ps.coeff))                    
+                term.pauli_map = pauli_map
+                terms.append((term, ps.coeff))
             converted.append(terms)
 
         if isinstance(self.U, BackendCircuitSpex):
@@ -378,7 +412,6 @@ class BackendExpectationValueSpex(BackendExpectationValue):
 
         return tuple(converted)
 
-
     def simulate(self, variables, initial_state=0, *args, **kwargs):
         """
         Calculate expectation value through sparse simulation
@@ -388,12 +421,12 @@ class BackendExpectationValueSpex(BackendExpectationValue):
 
         # 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
+        if self.U.compress_qubits:
+            circuit, comp_hams, n_qubits = self.U.compress_qubit_indices()
         else:
+            circuit = self.U.circuit
+            comp_hams = self.H
             n_qubits = self.U.n_qubits
 
         # Prepare the initial state
@@ -406,10 +439,11 @@ class BackendExpectationValueSpex(BackendExpectationValue):
             # 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]
+        circuit = [t for t in 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)
+        final_state = spex_tequila.apply_U(circuit, state, threshold, n_qubits)
+
         del state
 
         if "SPEX_NUM_THREADS" in os.environ:
@@ -419,11 +453,12 @@ class BackendExpectationValueSpex(BackendExpectationValue):
 
         # Calculate the expectation value for each Hamiltonian
         results = []
-        for H_terms in self.H:
+
+        for H_terms in comp_hams:
             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/simulator_symbolic.py

@@ -11,8 +11,8 @@ import sympy
 Simple Symbolic Simulator for debugging purposes
 """
 
-class BackendCircuitSymbolic(BackendCircuit):
 
+class BackendCircuitSymbolic(BackendCircuit):
     # compiler instructions
     compiler_arguments = {
         "trotterized": True,
@@ -29,7 +29,7 @@ class BackendCircuitSymbolic(BackendCircuit):
         "controlled_phase": True,
         "toffoli": True,
         "phase_to_z": True,
-        "cc_max": True
+        "cc_max": True,
     }
 
     convert_to_numpy = True
@@ -49,7 +49,7 @@ class BackendCircuitSymbolic(BackendCircuit):
         return result
 
     @classmethod
-    def apply_on_standard_basis(cls, gate: QGate, basis_state: BitString, qubits:dict, variables) -> QubitWaveFunction:
+    def apply_on_standard_basis(cls, gate: QGate, basis_state: BitString, qubits: dict, variables) -> QubitWaveFunction:
         n_qubits = len(qubits.keys())
         basis_array = basis_state.array
         if gate.is_controlled() and not all(basis_array[qubits[c]] == 1 for c in gate.control):
@@ -70,8 +70,8 @@ class BackendCircuitSymbolic(BackendCircuit):
             fac1 = None
             fac2 = None
             if gate.name == "H":
-                fac1 = (sympy.Integer(-1) ** qt * sympy.sqrt(sympy.Rational(1 / 2)))
-                fac2 = (sympy.sqrt(sympy.Rational(1 / 2)))
+                fac1 = sympy.Integer(-1) ** qt * sympy.sqrt(sympy.Rational(1 / 2))
+                fac2 = sympy.sqrt(sympy.Rational(1 / 2))
             elif gate.name.upper() == "CNOT" or gate.name.upper() == "X":
                 fac2 = sympy.Integer(1)
             elif gate.name.upper() == "Y":
@@ -129,5 +129,6 @@ class BackendCircuitSymbolic(BackendCircuit):
 
         return wfn
 
+
 class BackendExpectationValueSymbolic(BackendExpectationValue):
     BackendCircuitType = BackendCircuitSymbolic