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

tequila/simulators/simulator_qiskit.py

@@ -8,19 +8,21 @@ from tequila.utils import to_float
 from typing import Union
 import warnings
 import numpy as np
-import qiskit, qiskit_aer, qiskit.providers.fake_provider
-from qiskit import QuantumCircuit
+import qiskit
+import qiskit_aer
+import qiskit.providers.fake_provider
+from qiskit import QuantumCircuit, transpile
 
 HAS_NOISE = True
 try:
     from qiskit_aer import noise as qiskitnoise, AerSimulator
-except:
+except Exception:
     HAS_NOISE = False
 
 HAS_IBMQ = True
 try:
     from qiskit_ibm_runtime import IBMBackend
-except:
+except Exception:
     HAS_IBMQ = False
 
 
@@ -37,7 +39,7 @@ def get_bit_flip(p):
     type:
         qiskit pauli error
     """
-    return qiskitnoise.pauli_error(noise_ops=[('X', p), ('I', 1 - p)])
+    return qiskitnoise.pauli_error(noise_ops=[("X", p), ("I", 1 - p)])
 
 
 def get_phase_flip(p):
@@ -53,31 +55,30 @@ def get_phase_flip(p):
     type:
         qiskit pauli error
     """
-    return qiskitnoise.pauli_error(noise_ops=[('Z', p), ('I', 1 - p)])
+    return qiskitnoise.pauli_error(noise_ops=[("Z", p), ("I", 1 - p)])
 
 
 gate_qubit_lookup = {
-    'x': 1,
-    'y': 1,
-    'z': 1,
-    'h': 1,
-    'u1': 1,
-    'u2': 1,
-    'u3': 1,
-    'cx': 2,
-    'cy': 2,
-    'cz': 2,
-    'ch': 2,
-    'cu3': 2,
-    'ccx': 3,
-    'r': 1,
-    'single': 1,
-    'control': 2,
-    'multicontrol': 3
+    "x": 1,
+    "y": 1,
+    "z": 1,
+    "h": 1,
+    "u1": 1,
+    "u2": 1,
+    "u3": 1,
+    "cx": 2,
+    "cy": 2,
+    "cz": 2,
+    "ch": 2,
+    "cu3": 2,
+    "ccx": 3,
+    "r": 1,
+    "single": 1,
+    "control": 2,
+    "multicontrol": 3,
 }
 
-full_basis = ['x', 'y', 'z', 'id', 'u1', 'u2', 'u3', 'h', 'unitary', 'sx',
-              'cx', 'cy', 'cz', 'cu3', 'ccx']
+full_basis = ["x", "y", "z", "id", "u1", "u2", "u3", "h", "unitary", "sx", "cx", "cy", "cz", "cu3", "ccx"]
 
 
 def qiskit_device_dict():
@@ -85,8 +86,11 @@ def qiskit_device_dict():
     # deprecated in the future
     # TODO: Instead of building a dict with all backends just to search it, search directly with `get_backend`
     # https://qiskit.github.io/qiskit-aer/stubs/qiskit_aer.AerProvider.html#qiskit_aer.AerProvider.get_backend
-    devices = {backend.name.lower(): backend for backend in qiskit_aer.AerProvider().backends()
-               if isinstance(backend, AerSimulator)}
+    devices = {
+        backend.name.lower(): backend
+        for backend in qiskit_aer.AerProvider().backends()
+        if isinstance(backend, AerSimulator)
+    }
 
     # FakeProvider has been removed, see https://github.com/Qiskit/qiskit/issues/10954
     # devices.update({str(x).lower(): x for x in qiskit.test.mock.FakeProvider().backends()})
@@ -139,6 +143,7 @@ class BackendCircuitQiskit(BackendCircuit):
         transform a tequila NoiseModel into a qiskit noise model.
 
     """
+
     STATEVECTOR_DEVICE_NAME = "aer_simulator_statevector"
 
     compiler_arguments = {
@@ -157,7 +162,7 @@ class BackendCircuitQiskit(BackendCircuit):
         "controlled_phase": False,
         "toffoli": False,
         "phase_to_z": False,
-        "cc_max": True
+        "cc_max": True,
     }
 
     numbering = BitNumbering.LSB
@@ -165,8 +170,7 @@ class BackendCircuitQiskit(BackendCircuit):
     supports_sampling_initialization = True
     supports_generic_initialization = True
 
-    def __init__(self, abstract_circuit: QCircuit, variables, qubit_map=None, noise=None,
-                 device=None, *args, **kwargs):
+    def __init__(self, abstract_circuit: QCircuit, variables, qubit_map=None, noise=None, device=None, *args, **kwargs):
         """
 
         Parameters
@@ -188,16 +192,16 @@ class BackendCircuitQiskit(BackendCircuit):
         kwargs
         """
         self.op_lookup = {
-            'I': (lambda c: c.iden),
-            'X': (lambda c: c.x, lambda c: c.cx, lambda c: c.ccx),
-            'Y': (lambda c: c.y, lambda c: c.cy, lambda c: c.ccy),
-            'Z': (lambda c: c.z, lambda c: c.cz, lambda c: c.ccz),
-            'H': (lambda c: c.h, lambda c: c.ch, lambda c: c.cch),
-            'Rx': (lambda c: c.rx, lambda c: c.mcrx),
-            'Ry': (lambda c: c.ry, lambda c: c.mcry),
-            'Rz': (lambda c: c.rz, lambda c: c.mcrz),
-            'Phase': (lambda c: c.p, lambda c: c.cp),
-            'SWAP': (lambda c: c.swap, lambda c: c.cswap),
+            "I": (lambda c: c.iden),
+            "X": (lambda c: c.x, lambda c: c.cx, lambda c: c.ccx),
+            "Y": (lambda c: c.y, lambda c: c.cy, lambda c: c.ccy),
+            "Z": (lambda c: c.z, lambda c: c.cz, lambda c: c.ccz),
+            "H": (lambda c: c.h, lambda c: c.ch, lambda c: c.cch),
+            "Rx": (lambda c: c.rx, lambda c: c.mcrx),
+            "Ry": (lambda c: c.ry, lambda c: c.mcry),
+            "Rz": (lambda c: c.rz, lambda c: c.mcrz),
+            "Phase": (lambda c: c.p, lambda c: c.cp),
+            "SWAP": (lambda c: c.swap, lambda c: c.cswap),
         }
 
         self.resolver = {}
@@ -207,28 +211,37 @@ class BackendCircuitQiskit(BackendCircuit):
         if qubit_map is None:
             qubit_map = {q: i for i, q in enumerate(abstract_circuit.qubits)}
         else:
-            warnings.warn(f"reveived custom qubit_map = {qubit_map}\n"
-                          "This is not fully integrated with qiskit and might result in unexpected behaviour",
-                          TequilaWarning)
+            warnings.warn(
+                f"reveived custom qubit_map = {qubit_map}\n"
+                "This is not fully integrated with qiskit and might result in unexpected behaviour",
+                TequilaWarning,
+            )
 
         n_qubits = max(qubit_map.values()) + 1
 
         self.q = qiskit.QuantumRegister(n_qubits, "q")
         self.c = qiskit.ClassicalRegister(n_qubits, "c")
 
-        super().__init__(abstract_circuit=abstract_circuit, variables=variables, noise=noise, device=device,
-                         qubit_map=qubit_map, *args, **kwargs)
+        super().__init__(
+            abstract_circuit=abstract_circuit,
+            variables=variables,
+            noise=noise,
+            device=device,
+            qubit_map=qubit_map,
+            *args,
+            **kwargs,
+        )
 
         self.classical_map = self.make_classical_map(qubit_map=self.qubit_map)
 
         if noise is not None:
             self.noise_lookup = {
-                'phase damp': qiskitnoise.phase_damping_error,
-                'amplitude damp': qiskitnoise.amplitude_damping_error,
-                'bit flip': get_bit_flip,
-                'phase flip': get_phase_flip,
-                'phase-amplitude damp': qiskitnoise.phase_amplitude_damping_error,
-                'depolarizing': qiskitnoise.depolarizing_error
+                "phase damp": qiskitnoise.phase_damping_error,
+                "amplitude damp": qiskitnoise.amplitude_damping_error,
+                "bit flip": get_bit_flip,
+                "phase flip": get_phase_flip,
+                "phase-amplitude damp": qiskitnoise.phase_amplitude_damping_error,
+                "depolarizing": qiskitnoise.depolarizing_error,
             }
 
             if isinstance(noise, str):  # string noise means "use the same noise as the device I tell you to get."
@@ -274,7 +287,7 @@ class BackendCircuitQiskit(BackendCircuit):
         if isinstance(initial_state, QubitWaveFunction):
             statevector = initial_state.to_array(self.numbering)
         else:
-            statevector = np.zeros(2 ** self.n_qubits)
+            statevector = np.zeros(2**self.n_qubits)
             statevector[reverse_int_bits(initial_state, self.n_qubits)] = 1.0
 
         init_circuit = qiskit.QuantumCircuit(self.q, self.c)
@@ -302,10 +315,12 @@ class BackendCircuitQiskit(BackendCircuit):
             if self.device is None:
                 qiskit_backend = self.retrieve_device(self.STATEVECTOR_DEVICE_NAME)
             else:
-                if 'statevector' not in str(self.device):
+                if "statevector" not in str(self.device):
                     raise TequilaException(
-                        'For simulation, only state vector simulators are supported; recieved device={}, you might have forgoten to set the samples keyword - e.g. (device={}, samples=1000). If not set, tequila assumes that full wavefunction simualtion is demanded which is not compatible with qiskit devices or fake devices except for device=statevector'.format(
-                            self.device, self.device))
+                        "For simulation, only state vector simulators are supported; recieved device={}, you might have forgoten to set the samples keyword - e.g. (device={}, samples=1000). If not set, tequila assumes that full wavefunction simualtion is demanded which is not compatible with qiskit devices or fake devices except for device=statevector".format(
+                            self.device, self.device
+                        )
+                    )
                 else:
                     qiskit_backend = self.retrieve_device(self.device)
         else:
@@ -313,20 +328,21 @@ class BackendCircuitQiskit(BackendCircuit):
 
         optimization_level = None
         if "optimization_level" in kwargs:
-            optimization_level = kwargs['optimization_level']
+            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)
+        return QubitWaveFunction.from_array(
+            array=backend_result.get_statevector(circuit).data, numbering=self.numbering
+        )
 
-    def do_sample(self, circuit: qiskit.QuantumCircuit, samples: int, read_out_qubits, initial_state=0, *args,
-                  **kwargs) -> QubitWaveFunction:
+    def do_sample(
+        self, circuit: qiskit.QuantumCircuit, samples: int, read_out_qubits, initial_state=0, *args, **kwargs
+    ) -> QubitWaveFunction:
         """
         Helper function for performing sampling.
         Parameters
@@ -346,22 +362,24 @@ class BackendCircuitQiskit(BackendCircuit):
             the result of sampling.
         """
         optimization_level = 1
-        if 'optimization_level' in kwargs:
-            optimization_level = kwargs['optimization_level']
+        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)))
+                    "Cannot combine backend {} with custom noise models.".format(str(qiskit_backend))
+                )
             circuit = circuit.assign_parameters(self.resolver)  # this is necessary in spite of qiskit "fixing" it
             circuit = qiskit.transpile(circuit, qiskit_backend)
-            return self.convert_measurements(qiskit_backend.run(circuit, shots=samples,
-                                                                optimization_level=optimization_level),
-                                             target_qubits=read_out_qubits)
+            return self.convert_measurements(
+                qiskit_backend.run(circuit, shots=samples, optimization_level=optimization_level),
+                target_qubits=read_out_qubits,
+            )
         else:
             if isinstance(qiskit_backend, qiskit.providers.fake_provider.FakeBackend):
                 circuit = circuit.assign_parameters(self.resolver)  # this is necessary in spite of qiskit "fixing" it
@@ -370,13 +388,15 @@ 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,
-                                           coupling_map=coupling_map,
-                                           optimization_level=optimization_level
-                                           )
+                circuit = qiskit.transpile(
+                    circuit,
+                    backend=use_backend,
+                    basis_gates=basis,
+                    coupling_map=coupling_map,
+                    optimization_level=optimization_level,
+                )
 
                 job = qiskit_backend.run(circuit, shots=samples)
                 return self.convert_measurements(job, target_qubits=read_out_qubits)
@@ -388,10 +408,9 @@ class BackendCircuitQiskit(BackendCircuit):
                     use_basis = qiskit_backend.configuration().basis_gates
                 circuit = circuit.assign_parameters(self.resolver)  # this is necessary -- see qiskit-aer issue 1346
                 circuit = self.add_state_init(circuit, initial_state)
-                circuit = qiskit.transpile(circuit, backend=qiskit_backend,
-                                           basis_gates=use_basis,
-                                           optimization_level=optimization_level
-                                           )
+                circuit = qiskit.transpile(
+                    circuit, backend=qiskit_backend, basis_gates=use_basis, optimization_level=optimization_level
+                )
 
                 job = qiskit_backend.run(circuit, shots=samples)
                 return self.convert_measurements(job, target_qubits=read_out_qubits)
@@ -463,9 +482,10 @@ class BackendCircuitQiskit(BackendCircuit):
         if len(gate.extract_variables()) > 0:
             try:
                 par = self.tq_to_pars[gate.parameter]
-            except:
+            except Exception:
                 par = qiskit.circuit.parameter.Parameter(
-                    '{}_{}'.format(self._name_variable_objective(gate.parameter), str(self.counter)))
+                    "{}_{}".format(self._name_variable_objective(gate.parameter), str(self.counter))
+                )
                 self.tq_to_pars[gate.parameter] = par
                 self.counter += 1
         else:
@@ -473,7 +493,8 @@ class BackendCircuitQiskit(BackendCircuit):
         if gate.is_controlled():
             if len(gate.control) > 2:
                 raise TequilaQiskitException(
-                    "multi-controls beyond 2 not yet supported for the qiskit backend. Gate was:\n{}".format(gate))
+                    "multi-controls beyond 2 not yet supported for the qiskit backend. Gate was:\n{}".format(gate)
+                )
             ops[1](circuit)(par, self.qubit(gate.control[0]), self.qubit(gate.target[0]))
         else:
             ops[0](circuit)(par, self.qubit(gate.target[0]))
@@ -526,7 +547,8 @@ class BackendCircuitQiskit(BackendCircuit):
         if gate.is_controlled():
             if len(gate.control) > 2:
                 raise TequilaQiskitException(
-                    "multi-controls beyond 2 not yet supported for the qiskit backend. Gate was:\n{}".format(gate))
+                    "multi-controls beyond 2 not yet supported for the qiskit backend. Gate was:\n{}".format(gate)
+                )
             ops[len(gate.control)](circuit)(*[self.qubit(q) for q in gate.control + gate.target])
         else:
             ops[0](circuit)(*[self.qubit(q) for q in gate.target])
@@ -563,32 +585,16 @@ class BackendCircuitQiskit(BackendCircuit):
                         active = active.tensor(action)
 
             if noise.level == 2:
-                targets = ['cx',
-                           'cy',
-                           'cz',
-                           'crz',
-                           'crx',
-                           'cry',
-                           'cu3',
-                           'ch']
+                targets = ["cx", "cy", "cz", "crz", "crx", "cry", "cu3", "ch"]
 
             elif noise.level == 1:
-                targets = ['x',
-                           'y',
-                           'z',
-                           'u3',
-                           'u1',
-                           'u2',
-                           'h',
-                           'sx',
-                           'unitary'
-                           ]
+                targets = ["x", "y", "z", "u3", "u1", "u2", "h", "sx", "unitary"]
 
             elif noise.level == 3:
-                targets = ['ccx']
+                targets = ["ccx"]
 
             else:
-                raise TequilaQiskitException('Sorry, no support yet for qiskit for noise on more than 3 qubits.')
+                raise TequilaQiskitException("Sorry, no support yet for qiskit for noise on more than 3 qubits.")
             qnoise.add_all_qubit_quantum_error(active, targets)
 
         return qnoise
@@ -632,12 +638,12 @@ class BackendCircuitQiskit(BackendCircuit):
 
         elif isinstance(device, dict):
             try:
-                qiskit_provider = device['provider']
-                d = device['name'].lower()
+                qiskit_provider = device["provider"]
+                d = device["name"].lower()
                 qiskit_provider.get_backend(name=d)
                 return
-            except:
-                raise TequilaQiskitException('dictionary initialization with device = {} failed.'.format(str(device)))
+            except Exception:
+                raise TequilaQiskitException("dictionary initialization with device = {} failed.".format(str(device)))
 
         elif isinstance(device, str):
             if device.lower() in qiskit_device_dict().keys():
@@ -650,8 +656,10 @@ class BackendCircuitQiskit(BackendCircuit):
                 return
         else:
             raise TequilaQiskitException(
-                'received device {} of unrecognized type {}; only None, strings, dicts, and qiskit backends allowed'.format(
-                    str(device), type(device)))
+                "received device {} of unrecognized type {}; only None, strings, dicts, and qiskit backends allowed".format(
+                    str(device), type(device)
+                )
+            )
 
     def retrieve_device(self, device):
         """
@@ -674,8 +682,8 @@ class BackendCircuitQiskit(BackendCircuit):
             return device
 
         elif isinstance(device, dict):
-            qiskit_provider = device['provider']
-            d = device['name'].lower()
+            qiskit_provider = device["provider"]
+            d = device["name"].lower()
             return qiskit_provider.get_backend(name=d)
 
         elif isinstance(device, str):
@@ -689,8 +697,10 @@ class BackendCircuitQiskit(BackendCircuit):
                 return qiskit_provider.get_backend(device)
         else:
             raise TequilaQiskitException(
-                'received device {} of unrecognized type {}; only None, strings, dicts, and qiskit backends allowed'.format(
-                    str(device), type(device)))
+                "received device {} of unrecognized type {}; only None, strings, dicts, and qiskit backends allowed".format(
+                    str(device), type(device)
+                )
+            )
 
 
 class BackendExpectationValueQiskit(BackendExpectationValue):

tequila/simulators/simulator_qlm.py

@@ -2,13 +2,11 @@ import typing
 from dataclasses import dataclass
 
 import numpy as np
-from qat.lang.AQASM import (PH, RX, RY, RZ, SWAP, AbstractGate, H, I, Program,
-                            QRoutine, X, Y, Z, build_gate)
+from qat.lang.AQASM import PH, RX, RY, RZ, SWAP, AbstractGate, H, I, Program, QRoutine, X, Y, Z, build_gate
 from qat.lang.AQASM.qint import QInt
 from tequila.circuit._gates_impl import QGateImpl
 from tequila.circuit.circuit import QCircuit
-from tequila.simulators.simulator_base import (BackendCircuit,
-                                               BackendExpectationValue)
+from tequila.simulators.simulator_base import BackendCircuit, BackendExpectationValue
 from tequila.utils.bitstrings import BitNumbering, BitString
 from tequila.utils.exceptions import TequilaException
 from tequila.utils.misc import to_float
@@ -18,6 +16,7 @@ from tequila.wavefunction.qubit_wavefunction import QubitWaveFunction
 MY_QLM = True
 try:
     from qat.qpus import LinAlg
+
     MY_QLM = False
 except ImportError:
     from qat.qpus import PyLinalg
@@ -42,7 +41,7 @@ def get_statevector(result) -> np.ndarray:
     if result.statevector:
         return result.statevector
     qubits = result[0].qregs[0].length
-    statevector = np.zeros((2 ** qubits,), dtype=complex)
+    statevector = np.zeros((2**qubits,), dtype=complex)
     for sample in result:
         statevector[sample._state] = sample.amplitude
     return statevector
@@ -62,12 +61,14 @@ def initialize_state(initial_state: int, n_qubits: int):
     ----------
         an abstract gate that uses X gates to create the wanted initial state.
     """
+
     @build_gate("INIT", [])
     def initialize():
         routine = QRoutine()
         qints = routine.new_wires(n_qubits, QInt)
         qints.set_value(initial_state)
         return routine
+
     return initialize
 
 
@@ -76,6 +77,7 @@ class RawCircuit:
     """
     A helper class to use the qlm program object more like circuits of other simulators.
     """
+
     program: str
     qubits: float
     measure: typing.List[int] = None
@@ -123,6 +125,7 @@ class BackendCircuitQLM(BackendCircuit):
     Methods
     -------
     """
+
     compiler_arguments = {
         "multitarget": True,
         "multicontrol": False,
@@ -142,14 +145,24 @@ class BackendCircuitQLM(BackendCircuit):
         "cc_max": False,
         "ry_gate": False,
         "y_gate": False,
-        "ch_gate": False
+        "ch_gate": False,
     }
 
     numbering = BitNumbering.MSB
 
-    def __init__(self, abstract_circuit: QCircuit, variables, noise=None, device=None,
-                 qubit_map=None, optimize_circuit=True, qpu=None, map_exact_qubits=False,
-                 *args, **kwargs):
+    def __init__(
+        self,
+        abstract_circuit: QCircuit,
+        variables,
+        noise=None,
+        device=None,
+        qubit_map=None,
+        optimize_circuit=True,
+        qpu=None,
+        map_exact_qubits=False,
+        *args,
+        **kwargs,
+    ):
         """
         Parameters
         ----------
@@ -177,16 +190,16 @@ class BackendCircuitQLM(BackendCircuit):
         """
 
         self.op_lookup = {
-            'I': I,
-            'X': X,
-            'Y': Y,
-            'Z': Z,
-            'H': H,
-            'Rx': RX,
-            'Ry': RY,
-            'Rz': RZ,
-            'Phase': PH,
-            'SWAP': SWAP
+            "I": I,
+            "X": X,
+            "Y": Y,
+            "Z": Z,
+            "H": H,
+            "Rx": RX,
+            "Ry": RY,
+            "Rz": RZ,
+            "Phase": PH,
+            "SWAP": SWAP,
         }
 
         self.tq_to_pars = {}
@@ -204,15 +217,25 @@ class BackendCircuitQLM(BackendCircuit):
                 "Use of device not suppoted. Device can be imitated by giving a QPu from QLM as parameter 'qpu'."
             )
 
-        super().__init__(abstract_circuit=abstract_circuit, variables=variables, noise=noise, device=device,
-                         qubit_map=qubit_map, optimize_circuit=optimize_circuit, *args, **kwargs)
+        super().__init__(
+            abstract_circuit=abstract_circuit,
+            variables=variables,
+            noise=noise,
+            device=device,
+            qubit_map=qubit_map,
+            optimize_circuit=optimize_circuit,
+            *args,
+            **kwargs,
+        )
 
         if len(self.tq_to_pars.keys()) is None:
             self.pars_to_tq = None
             self.pars_for_job = None
         else:
             self.pars_to_tq = {v: k for k, v in self.tq_to_pars.items()}
-            self.pars_for_job = {next(iter(k.get_variables())): to_float(v(variables)) for k, v in self.pars_to_tq.items()}
+            self.pars_for_job = {
+                next(iter(k.get_variables())): to_float(v(variables)) for k, v in self.pars_to_tq.items()
+            }
             print(self.pars_for_job)
 
     def initialize_circuit(self, *args, **kwargs) -> RawCircuit:
@@ -258,7 +281,7 @@ class BackendCircuitQLM(BackendCircuit):
             try:
                 parameter = self.tq_to_pars[gate.parameter]
             except KeyError:
-                parameter_name = f'{self._name_variable_objective(gate.parameter)}_{self.counter}'.replace(" ", "$")
+                parameter_name = f"{self._name_variable_objective(gate.parameter)}_{self.counter}".replace(" ", "$")
                 parameter = circuit.new_var(parameter_name)
                 self.tq_to_pars[gate.parameter] = parameter
                 self.counter += 1
@@ -318,8 +341,9 @@ class BackendCircuitQLM(BackendCircuit):
         circuit.measure = target_qubits
         return circuit
 
-    def do_sample(self, samples, circuit: RawCircuit, noise=None, abstract_qubits=None,
-                  initial_state=0, *args, **kwargs) -> QubitWaveFunction:
+    def do_sample(
+        self, samples, circuit: RawCircuit, noise=None, abstract_qubits=None, initial_state=0, *args, **kwargs
+    ) -> QubitWaveFunction:
         """
         Helper function for performing sampling.
 
@@ -414,7 +438,9 @@ class BackendCircuitQLM(BackendCircuit):
         None
         """
         if self.pars_to_tq is not None:
-            self.pars_for_job = {next(iter(k.get_variables())): to_float(v(variables)) for k, v in self.pars_to_tq.items()}
+            self.pars_for_job = {
+                next(iter(k.get_variables())): to_float(v(variables)) for k, v in self.pars_to_tq.items()
+            }
         else:
             self.pars_for_job = None