From da5dc5f1420b9b2582de2efbe4373ed8d6828a1e Mon Sep 17 00:00:00 2001
From: BrunoLiegiBastonLiegi <andreapapaluca@gmail.com>
Date: Sun, 7 Jul 2024 13:01:14 +0900
Subject: [PATCH 01/44] feat: allowing for samples as input of
 expectation_from_samples

---
 src/qibo/hamiltonians/hamiltonians.py | 6 +++++-
 src/qibo/measurements.py              | 2 +-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/qibo/hamiltonians/hamiltonians.py b/src/qibo/hamiltonians/hamiltonians.py
index b270c5d008..893c1256d4 100644
--- a/src/qibo/hamiltonians/hamiltonians.py
+++ b/src/qibo/hamiltonians/hamiltonians.py
@@ -534,7 +534,7 @@ def calculate_dense(self):
     def expectation(self, state, normalize=False):
         return Hamiltonian.expectation(self, state, normalize)
 
-    def expectation_from_samples(self, freq, qubit_map=None):
+    def expectation_from_samples(self, freq, qubit_map=None, input_samples=False):
         terms = self.terms
         for term in terms:
             # pylint: disable=E1101
@@ -545,6 +545,10 @@ def expectation_from_samples(self, freq, qubit_map=None):
                     )
             if len(term.factors) != len(set(term.factors)):
                 raise_error(NotImplementedError, "Z^k is not implemented since Z^2=I.")
+        if input_samples:
+            nqubits = freq.shape[-1]
+            freq = self.backend.calculate_frequencies(freq)
+            freq = {format(k, f"0{nqubits}b"): v for k, v in freq.items()}
         keys = list(freq.keys())
         counts = np.array(list(freq.values())) / sum(freq.values())
         coeff = list(self.form.as_coefficients_dict().values())
diff --git a/src/qibo/measurements.py b/src/qibo/measurements.py
index e46ffe6a00..9c3bcf06e5 100644
--- a/src/qibo/measurements.py
+++ b/src/qibo/measurements.py
@@ -120,7 +120,7 @@ def has_samples(self):
     def register_samples(self, samples, backend=None):
         """Register samples array to the ``MeasurementResult`` object."""
         self._samples = samples
-        self.nshots = len(samples)
+        self.nshots = samples.shape[0]  # len(samples)
 
     def register_frequencies(self, frequencies, backend=None):
         """Register frequencies to the ``MeasurementResult`` object."""

From d00827b841933ba1c4c06982b81b3349f5460872 Mon Sep 17 00:00:00 2001
From: BrunoLiegiBastonLiegi <andreapapaluca@gmail.com>
Date: Tue, 9 Jul 2024 09:38:43 +0200
Subject: [PATCH 02/44] test: added test for exp from samples with samples

---
 tests/test_hamiltonians_symbolic.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/tests/test_hamiltonians_symbolic.py b/tests/test_hamiltonians_symbolic.py
index d9a3b597e4..d023875a5e 100644
--- a/tests/test_hamiltonians_symbolic.py
+++ b/tests/test_hamiltonians_symbolic.py
@@ -308,7 +308,8 @@ def test_symbolic_hamiltonian_state_expectation_different_nqubits(
             local_ev = local_ham.expectation(state)
 
 
-def test_hamiltonian_expectation_from_samples(backend):
+@pytest.mark.parametrize("use_samples", [False, True])
+def test_hamiltonian_expectation_from_samples(backend, use_samples):
     """Test Hamiltonian expectation value calculation."""
     backend.set_seed(0)
     obs0 = 2 * Z(0) * Z(1) + Z(0) * Z(2)
@@ -323,8 +324,8 @@ def test_hamiltonian_expectation_from_samples(backend):
     c.add(gates.M(0, 1, 2, 3))
     nshots = 10**5
     result = backend.execute_circuit(c, nshots=nshots)
-    freq = result.frequencies(binary=True)
-    ev0 = h0.expectation_from_samples(freq, qubit_map=None)
+    freq = result.samples() if use_samples else result.frequencies(binary=True)
+    ev0 = h0.expectation_from_samples(freq, qubit_map=None, input_samples=use_samples)
     ev1 = h1.expectation(result.state())
     backend.assert_allclose(ev0, ev1, atol=20 / np.sqrt(nshots))
 

From cf60cc5ce50c403ae96a584e2746a821f3be7f14 Mon Sep 17 00:00:00 2001
From: BrunoLiegiBastonLiegi <andreapapaluca@gmail.com>
Date: Tue, 9 Jul 2024 18:02:05 +0200
Subject: [PATCH 03/44] fix: converting samples to decimal first

---
 src/qibo/hamiltonians/hamiltonians.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/qibo/hamiltonians/hamiltonians.py b/src/qibo/hamiltonians/hamiltonians.py
index 893c1256d4..36139f964d 100644
--- a/src/qibo/hamiltonians/hamiltonians.py
+++ b/src/qibo/hamiltonians/hamiltonians.py
@@ -547,7 +547,9 @@ def expectation_from_samples(self, freq, qubit_map=None, input_samples=False):
                 raise_error(NotImplementedError, "Z^k is not implemented since Z^2=I.")
         if input_samples:
             nqubits = freq.shape[-1]
-            freq = self.backend.calculate_frequencies(freq)
+            freq = self.backend.calculate_frequencies(
+                self.backend.samples_to_decimal(freq, nqubits=nqubits)
+            )
             freq = {format(k, f"0{nqubits}b"): v for k, v in freq.items()}
         keys = list(freq.keys())
         counts = np.array(list(freq.values())) / sum(freq.values())

From bbc75eda9296d44a83a1fbf668e5a3a9d1d6ce24 Mon Sep 17 00:00:00 2001
From: BrunoLiegiBastonLiegi <andreapapaluca@gmail.com>
Date: Tue, 9 Jul 2024 21:20:17 +0200
Subject: [PATCH 04/44] feat: updated standard hamiltonian as well

---
 src/qibo/hamiltonians/hamiltonians.py | 8 +++++++-
 tests/test_hamiltonians.py            | 7 ++++---
 2 files changed, 11 insertions(+), 4 deletions(-)

diff --git a/src/qibo/hamiltonians/hamiltonians.py b/src/qibo/hamiltonians/hamiltonians.py
index 36139f964d..adb1731c5e 100644
--- a/src/qibo/hamiltonians/hamiltonians.py
+++ b/src/qibo/hamiltonians/hamiltonians.py
@@ -138,10 +138,16 @@ def expectation(self, state, normalize=False):
             + f"value for state of type {type(state)}",
         )
 
-    def expectation_from_samples(self, freq, qubit_map=None):
+    def expectation_from_samples(self, freq, qubit_map=None, input_samples=False):
         obs = self.matrix
         if np.count_nonzero(obs - np.diag(np.diagonal(obs))) != 0:
             raise_error(NotImplementedError, "Observable is not diagonal.")
+        if input_samples:
+            nqubits = freq.shape[-1]
+            freq = self.backend.calculate_frequencies(
+                self.backend.samples_to_decimal(freq, nqubits=nqubits)
+            )
+            freq = {format(k, f"0{nqubits}b"): v for k, v in freq.items()}
         keys = list(freq.keys())
         if qubit_map is None:
             qubit_map = list(range(int(np.log2(len(obs)))))
diff --git a/tests/test_hamiltonians.py b/tests/test_hamiltonians.py
index c0089cc59b..bbefe0d903 100644
--- a/tests/test_hamiltonians.py
+++ b/tests/test_hamiltonians.py
@@ -261,7 +261,8 @@ def test_hamiltonian_expectation_errors(backend):
         h.expectation("test")
 
 
-def test_hamiltonian_expectation_from_samples(backend):
+@pytest.mark.parametrize("use_samples", [False, True])
+def test_hamiltonian_expectation_from_samples(backend, use_samples):
     """Test Hamiltonian expectation value calculation."""
     backend.set_seed(12)
     obs0 = 2 * Z(0) * Z(1) + Z(0) * Z(2)
@@ -278,11 +279,11 @@ def test_hamiltonian_expectation_from_samples(backend):
     nshots = 10**5
     # result = c(nshots=nshots)
     result = backend.execute_circuit(c, nshots=nshots)
-    freq = result.frequencies(binary=True)
+    freq = result.samples() if use_samples else result.frequencies(binary=True)
 
     Obs0 = hamiltonians.Hamiltonian(
         3, matrix, backend=backend
-    ).expectation_from_samples(freq, qubit_map=None)
+    ).expectation_from_samples(freq, qubit_map=None, input_samples=use_samples)
     Obs0 = backend.cast(Obs0, dtype=Obs0.dtype)
 
     Obs1 = h1.expectation(result.state())

From 6eb81b2d77e69ea596ea906fc3b469853db5e371 Mon Sep 17 00:00:00 2001
From: BrunoLiegiBastonLiegi <andreapapaluca@gmail.com>
Date: Mon, 22 Jul 2024 19:17:48 +0200
Subject: [PATCH 05/44] feat: casting in expectation_from_samples

---
 src/qibo/hamiltonians/hamiltonians.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/qibo/hamiltonians/hamiltonians.py b/src/qibo/hamiltonians/hamiltonians.py
index 68b16afa47..12c22c5099 100644
--- a/src/qibo/hamiltonians/hamiltonians.py
+++ b/src/qibo/hamiltonians/hamiltonians.py
@@ -553,6 +553,7 @@ def expectation(self, state, normalize=False):
         return Hamiltonian.expectation(self, state, normalize)
 
     def expectation_from_samples(self, freq, qubit_map=None, input_samples=False):
+        # breakpoint()
         terms = self.terms
         for term in terms:
             # pylint: disable=E1101
@@ -590,7 +591,7 @@ def expectation_from_samples(self, freq, qubit_map=None, input_samples=False):
                     expval_k = -1
                 expval_q += expval_k * counts[i]
             expval += expval_q * self.terms[j].coefficient.real
-        return expval + self.constant.real
+        return self.backend.cast(expval + self.constant.real)
 
     def __add__(self, o):
         if isinstance(o, self.__class__):

From 957acbcea33af757490154325020a3ab003f8442 Mon Sep 17 00:00:00 2001
From: BrunoLiegiBastonLiegi <andreapapaluca@gmail.com>
Date: Wed, 28 Aug 2024 13:19:31 +0200
Subject: [PATCH 06/44] fix: fix to torch.cast for empty lists

---
 src/qibo/backends/pytorch.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/qibo/backends/pytorch.py b/src/qibo/backends/pytorch.py
index 392aeed405..b4021e869c 100644
--- a/src/qibo/backends/pytorch.py
+++ b/src/qibo/backends/pytorch.py
@@ -120,7 +120,11 @@ def cast(
 
         if isinstance(x, self.np.Tensor):
             x = x.to(dtype)
-        elif isinstance(x, list) and all(isinstance(row, self.np.Tensor) for row in x):
+        elif (
+            isinstance(x, list)
+            and len(x) > 0
+            and all(isinstance(row, self.np.Tensor) for row in x)
+        ):
             x = self.np.stack(x)
         else:
             x = self.np.tensor(x, dtype=dtype, requires_grad=requires_grad)

From 9b80fed472ba6ab4013ec3b325ccba7e78ca88b7 Mon Sep 17 00:00:00 2001
From: BrunoLiegiBastonLiegi <andreapapaluca@gmail.com>
Date: Mon, 2 Sep 2024 12:08:08 +0200
Subject: [PATCH 07/44] feat: implemented custom curve_fit for pytorch

---
 src/qibo/hamiltonians/hamiltonians.py | 18 ++------
 src/qibo/models/error_mitigation.py   | 65 ++++++++++++++++++++++-----
 tests/test_hamiltonians.py            |  7 ++-
 tests/test_hamiltonians_symbolic.py   |  9 ++--
 4 files changed, 63 insertions(+), 36 deletions(-)

diff --git a/src/qibo/hamiltonians/hamiltonians.py b/src/qibo/hamiltonians/hamiltonians.py
index 12c22c5099..98434ed32c 100644
--- a/src/qibo/hamiltonians/hamiltonians.py
+++ b/src/qibo/hamiltonians/hamiltonians.py
@@ -142,7 +142,7 @@ def expectation(self, state, normalize=False):
             + f"value for state of type {type(state)}",
         )
 
-    def expectation_from_samples(self, freq, qubit_map=None, input_samples=False):
+    def expectation_from_samples(self, freq, qubit_map=None):
         obs = self.matrix
         if (
             self.backend.np.count_nonzero(
@@ -151,12 +151,6 @@ def expectation_from_samples(self, freq, qubit_map=None, input_samples=False):
             != 0
         ):
             raise_error(NotImplementedError, "Observable is not diagonal.")
-        if input_samples:
-            nqubits = freq.shape[-1]
-            freq = self.backend.calculate_frequencies(
-                self.backend.samples_to_decimal(freq, nqubits=nqubits)
-            )
-            freq = {format(k, f"0{nqubits}b"): v for k, v in freq.items()}
         keys = list(freq.keys())
         if qubit_map is None:
             qubit_map = list(range(int(np.log2(len(obs)))))
@@ -552,7 +546,7 @@ def calculate_dense(self):
     def expectation(self, state, normalize=False):
         return Hamiltonian.expectation(self, state, normalize)
 
-    def expectation_from_samples(self, freq, qubit_map=None, input_samples=False):
+    def expectation_from_samples(self, freq, qubit_map=None):
         # breakpoint()
         terms = self.terms
         for term in terms:
@@ -564,12 +558,6 @@ def expectation_from_samples(self, freq, qubit_map=None, input_samples=False):
                     )
             if len(term.factors) != len(set(term.factors)):
                 raise_error(NotImplementedError, "Z^k is not implemented since Z^2=I.")
-        if input_samples:
-            nqubits = freq.shape[-1]
-            freq = self.backend.calculate_frequencies(
-                self.backend.samples_to_decimal(freq, nqubits=nqubits)
-            )
-            freq = {format(k, f"0{nqubits}b"): v for k, v in freq.items()}
         keys = list(freq.keys())
         counts = np.array(list(freq.values())) / sum(freq.values())
         qubits = []
@@ -591,7 +579,7 @@ def expectation_from_samples(self, freq, qubit_map=None, input_samples=False):
                     expval_k = -1
                 expval_q += expval_k * counts[i]
             expval += expval_q * self.terms[j].coefficient.real
-        return self.backend.cast(expval + self.constant.real)
+        return self.backend.cast(expval + self.constant.real, self.backend.np.float64)
 
     def __add__(self, o):
         if isinstance(o, self.__class__):
diff --git a/src/qibo/models/error_mitigation.py b/src/qibo/models/error_mitigation.py
index dd1f927501..fae6d4f10e 100644
--- a/src/qibo/models/error_mitigation.py
+++ b/src/qibo/models/error_mitigation.py
@@ -176,9 +176,12 @@ def ZNE(
         )
         expected_values.append(val)
 
-    gamma = get_gammas(noise_levels, analytical=solve_for_gammas)
+    gamma = backend.cast(
+        get_gammas(noise_levels, analytical=solve_for_gammas), backend.np.float64
+    )
+    expected_values = backend.cast(expected_values, backend.np.float64)
 
-    return np.sum(gamma * expected_values)
+    return backend.np.sum(gamma * expected_values)
 
 
 def sample_training_circuit_cdr(
@@ -338,7 +341,7 @@ def CDR(
     for circ in training_circuits:
         result = backend.execute_circuit(circ, nshots=nshots)
         val = result.expectation_from_samples(observable)
-        train_val["noise-free"].append(val)
+        train_val["noise-free"].append(float(val))
         val = get_expectation_val_with_readout_mitigation(
             circ,
             observable,
@@ -349,7 +352,7 @@ def CDR(
             seed=local_state,
             backend=backend,
         )
-        train_val["noisy"].append(val)
+        train_val["noisy"].append(float(val))
 
     optimal_params = curve_fit(model, train_val["noisy"], train_val["noise-free"])[0]
 
@@ -371,13 +374,42 @@ def CDR(
     return mit_val
 
 
+def _curve_fit(backend, model, params, xdata, ydata, lr=1e-2, max_iter=int(1e3)):
+    loss = lambda pred, target: backend.np.mean((pred - target) ** 2)
+    if backend.name == "pytorch":
+        ydata = backend.cast(ydata, backend.np.float64)
+        params = backend.cast(params, dtype=backend.np.float64)
+        optimizer = backend.np.optim.LBFGS([params], lr=lr, max_iter=max_iter)
+
+        # losses = []
+        def closure():
+            for param in params:
+                param.grad = None
+            # optimizer.zero_grad()
+            output = model(xdata, params.reshape(-1, 1))
+            loss_val = loss(output, ydata)
+            loss_val.backward()
+            # losses.append(loss_val.clone())
+            return loss_val
+
+        optimizer.step(closure)
+        # losses = backend.cast(losses)
+        return params
+    elif backend.name == "tensorflow":
+        wrapped_model = lambda x, *params: model(x, np.asarray(params).reshape(-1, 1))
+        return curve_fit(wrapped_model, xdata, ydata, p0=params)[0]
+    else:
+        wrapped_model = lambda x, *params: model(x, np.asarray(params).reshape(-1, 1))
+        return curve_fit(wrapped_model, xdata, ydata, p0=params)[0]
+
+
 def vnCDR(
     circuit,
     observable,
     noise_levels,
     noise_model,
     nshots: int = 10000,
-    model=lambda x, *params: (x * np.array(params).reshape(-1, 1)).sum(0),
+    model=None,
     n_training_samples: int = 100,
     insertion_gate: str = "CNOT",
     full_output: bool = False,
@@ -432,6 +464,9 @@ def vnCDR(
     """
     backend, local_state = _check_backend_and_local_state(seed, backend)
 
+    if model is None:
+        model = lambda x, params: backend.np.sum(x * params, axis=0)
+
     if readout is None:
         readout = {}
 
@@ -444,7 +479,7 @@ def vnCDR(
     for circ in training_circuits:
         result = backend.execute_circuit(circ, nshots=nshots)
         val = result.expectation_from_samples(observable)
-        train_val["noise-free"].append(val)
+        train_val["noise-free"].append(float(val))
         for level in noise_levels:
             noisy_c = get_noisy_circuit(circ, level, insertion_gate=insertion_gate)
             val = get_expectation_val_with_readout_mitigation(
@@ -457,12 +492,17 @@ def vnCDR(
                 seed=local_state,
                 backend=backend,
             )
-            train_val["noisy"].append(val)
+            train_val["noisy"].append(float(val))
 
-    noisy_array = np.array(train_val["noisy"]).reshape(-1, len(noise_levels))
+    noisy_array = backend.cast(train_val["noisy"], backend.np.float64).reshape(
+        -1, len(noise_levels)
+    )
 
     params = local_state.random(len(noise_levels))
-    optimal_params = curve_fit(model, noisy_array.T, train_val["noise-free"], p0=params)
+    optimal_params = _curve_fit(
+        backend, model, params, noisy_array.T, train_val["noise-free"]
+    )
+    # optimal_params = curve_fit(model, noisy_array.T, train_val["noise-free"], p0=params)
 
     val = []
     for level in noise_levels:
@@ -479,7 +519,9 @@ def vnCDR(
         )
         val.append(expval)
 
-    mit_val = model(np.array(val).reshape(-1, 1), *optimal_params[0])[0]
+    mit_val = model(
+        backend.cast(val, backend.np.float64).reshape(-1, 1), optimal_params
+    )[0]
 
     if full_output:
         return mit_val, val, optimal_params, train_val
@@ -758,8 +800,7 @@ def get_expectation_val_with_readout_mitigation(
     exp_val = circuit_result.expectation_from_samples(observable)
 
     if "ncircuits" in readout:
-        exp_val /= circuit_result_cal.expectation_from_samples(observable)
-
+        return exp_val / circuit_result_cal.expectation_from_samples(observable)
     return exp_val
 
 
diff --git a/tests/test_hamiltonians.py b/tests/test_hamiltonians.py
index c8d054888c..5dce386185 100644
--- a/tests/test_hamiltonians.py
+++ b/tests/test_hamiltonians.py
@@ -261,8 +261,7 @@ def test_hamiltonian_expectation_errors(backend):
         h.expectation("test")
 
 
-@pytest.mark.parametrize("use_samples", [False, True])
-def test_hamiltonian_expectation_from_samples(backend, use_samples):
+def test_hamiltonian_expectation_from_samples(backend):
     """Test Hamiltonian expectation value calculation."""
     backend.set_seed(12)
     obs0 = 2 * Z(0) * Z(1) + Z(0) * Z(2)
@@ -279,11 +278,11 @@ def test_hamiltonian_expectation_from_samples(backend, use_samples):
     nshots = 10**5
     # result = c(nshots=nshots)
     result = backend.execute_circuit(c, nshots=nshots)
-    freq = result.samples() if use_samples else result.frequencies(binary=True)
+    freq = result.frequencies(binary=True)
 
     Obs0 = hamiltonians.Hamiltonian(
         3, matrix, backend=backend
-    ).expectation_from_samples(freq, qubit_map=None, input_samples=use_samples)
+    ).expectation_from_samples(freq, qubit_map=None)
     Obs0 = backend.cast(Obs0, dtype=Obs0.dtype)
 
     Obs1 = h1.expectation(result.state())
diff --git a/tests/test_hamiltonians_symbolic.py b/tests/test_hamiltonians_symbolic.py
index 8668103a25..54d8dac2e3 100644
--- a/tests/test_hamiltonians_symbolic.py
+++ b/tests/test_hamiltonians_symbolic.py
@@ -309,8 +309,7 @@ def test_symbolic_hamiltonian_state_expectation_different_nqubits(
             local_ev = local_ham.expectation(state)
 
 
-@pytest.mark.parametrize("use_samples", [False, True])
-def test_hamiltonian_expectation_from_samples(backend, use_samples):
+def test_hamiltonian_expectation_from_samples(backend):
     """Test Hamiltonian expectation value calculation."""
     backend.set_seed(0)
     obs0 = 2 * Z(0) * Z(1) + Z(0) * Z(2)
@@ -325,8 +324,8 @@ def test_hamiltonian_expectation_from_samples(backend, use_samples):
     c.add(gates.M(0, 1, 2, 3))
     nshots = 10**5
     result = backend.execute_circuit(c, nshots=nshots)
-    freq = result.samples() if use_samples else result.frequencies(binary=True)
-    ev0 = h0.expectation_from_samples(freq, qubit_map=None, input_samples=use_samples)
+    freq = result.frequencies(binary=True)
+    ev0 = h0.expectation_from_samples(freq, qubit_map=None)
     ev1 = h1.expectation(result.state())
     backend.assert_allclose(ev0, ev1, atol=20 / np.sqrt(nshots))
 
@@ -396,4 +395,4 @@ def test_symbolic_hamiltonian_with_constant(backend):
     h = hamiltonians.SymbolicHamiltonian(1e6 - Z(0), backend=backend)
 
     result = c.execute(nshots=10000)
-    assert result.expectation_from_samples(h) == approx(1e6, rel=1e-5, abs=0.0)
+    assert float(result.expectation_from_samples(h)) == approx(1e6, rel=1e-5, abs=0.0)

From e74f891bc2c4262813b906cb9d1c5aa19d4ea676 Mon Sep 17 00:00:00 2001
From: BrunoLiegiBastonLiegi <andreapapaluca@gmail.com>
Date: Mon, 2 Sep 2024 15:43:52 +0200
Subject: [PATCH 08/44] fix: fixing readout mitigation test and ics

---
 src/qibo/models/error_mitigation.py   | 16 ++++++----------
 tests/test_models_error_mitigation.py |  2 +-
 2 files changed, 7 insertions(+), 11 deletions(-)

diff --git a/src/qibo/models/error_mitigation.py b/src/qibo/models/error_mitigation.py
index fae6d4f10e..6a8ac1bdc3 100644
--- a/src/qibo/models/error_mitigation.py
+++ b/src/qibo/models/error_mitigation.py
@@ -381,19 +381,14 @@ def _curve_fit(backend, model, params, xdata, ydata, lr=1e-2, max_iter=int(1e3))
         params = backend.cast(params, dtype=backend.np.float64)
         optimizer = backend.np.optim.LBFGS([params], lr=lr, max_iter=max_iter)
 
-        # losses = []
         def closure():
-            for param in params:
-                param.grad = None
-            # optimizer.zero_grad()
+            optimizer.zero_grad()
             output = model(xdata, params.reshape(-1, 1))
             loss_val = loss(output, ydata)
             loss_val.backward()
-            # losses.append(loss_val.clone())
             return loss_val
 
         optimizer.step(closure)
-        # losses = backend.cast(losses)
         return params
     elif backend.name == "tensorflow":
         wrapped_model = lambda x, *params: model(x, np.asarray(params).reshape(-1, 1))
@@ -502,7 +497,6 @@ def vnCDR(
     optimal_params = _curve_fit(
         backend, model, params, noisy_array.T, train_val["noise-free"]
     )
-    # optimal_params = curve_fit(model, noisy_array.T, train_val["noise-free"], p0=params)
 
     val = []
     for level in noise_levels:
@@ -520,7 +514,8 @@ def vnCDR(
         val.append(expval)
 
     mit_val = model(
-        backend.cast(val, backend.np.float64).reshape(-1, 1), optimal_params
+        backend.cast(val, backend.np.float64).reshape(-1, 1),
+        optimal_params.reshape(-1, 1),
     )[0]
 
     if full_output:
@@ -1048,8 +1043,9 @@ def ICS(
         data["noisy"].append(noisy_expectation)
         lambda_list.append(1 - noisy_expectation / expectation)
 
-    dep_param = np.mean(lambda_list)
-    dep_param_std = np.std(lambda_list)
+    lambda_list = backend.cast(lambda_list, backend.np.float64)
+    dep_param = backend.np.mean(lambda_list)
+    dep_param_std = backend.np.std(lambda_list)
 
     noisy_expectation = get_expectation_val_with_readout_mitigation(
         circuit,
diff --git a/tests/test_models_error_mitigation.py b/tests/test_models_error_mitigation.py
index 4335f909f7..613e2c47f1 100644
--- a/tests/test_models_error_mitigation.py
+++ b/tests/test_models_error_mitigation.py
@@ -315,7 +315,7 @@ def test_readout_mitigation(backend, nqubits, nmeas, method, ibu_iters):
         c, obs, noise, nshots, readout, backend=backend
     )
 
-    assert np.abs(true_val - mit_val) <= np.abs(true_val - noisy_val)
+    assert backend.np.abs(true_val - mit_val) <= backend.np.abs(true_val - noisy_val)
 
 
 @pytest.mark.parametrize("nqubits", [3])

From ec9810a43a04d99a898683b7d68e84b6d1bd9987 Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Wed, 4 Sep 2024 11:26:49 +0400
Subject: [PATCH 09/44] modifications

---
 src/qibo/models/circuit.py | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/src/qibo/models/circuit.py b/src/qibo/models/circuit.py
index c4586c5ae2..4ecd30221f 100644
--- a/src/qibo/models/circuit.py
+++ b/src/qibo/models/circuit.py
@@ -1,5 +1,6 @@
 import collections
 import copy
+import sys
 from typing import Dict, List, Optional, Tuple, Union
 
 import numpy as np
@@ -1267,16 +1268,17 @@ def _update_draw_matrix(self, matrix, idx, gate, gate_symbol=None):
 
         return matrix, idx
 
-    def draw(self, line_wrap=70, legend=False) -> str:
+    def draw(self, line_wrap: int = 70, legend: bool = False, output_string: bool = False) -> str:
         """Draw text circuit using unicode symbols.
 
         Args:
-            line_wrap (int): maximum number of characters per line. This option
+            line_wrap (int, optional): maximum number of characters per line. This option
                 split the circuit text diagram in chunks of line_wrap characters.
-            legend (bool): If ``True`` prints a legend below the circuit for
+                Defaults to :math:`70`.
+            legend (bool, optional): If ``True`` prints a legend below the circuit for
                 callbacks and channels. Default is ``False``.
 
-        Return:
+        Returns:
             String containing text circuit diagram.
         """
         # build string representation of gates
@@ -1368,4 +1370,10 @@ def chunkstring(string, length):
         if legend:
             output += table
 
-        return output.rstrip("\n")
+        output = output.rstrip("\n")
+
+        if not output_string:
+            sys.stdout.write(output)
+            return
+
+        return output

From d2fec4c0f5a9106412032b0b20ea56c4683d190e Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 4 Sep 2024 07:29:41 +0000
Subject: [PATCH 10/44] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/qibo/models/circuit.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/qibo/models/circuit.py b/src/qibo/models/circuit.py
index 4ecd30221f..75231add4c 100644
--- a/src/qibo/models/circuit.py
+++ b/src/qibo/models/circuit.py
@@ -1268,7 +1268,9 @@ def _update_draw_matrix(self, matrix, idx, gate, gate_symbol=None):
 
         return matrix, idx
 
-    def draw(self, line_wrap: int = 70, legend: bool = False, output_string: bool = False) -> str:
+    def draw(
+        self, line_wrap: int = 70, legend: bool = False, output_string: bool = False
+    ) -> str:
         """Draw text circuit using unicode symbols.
 
         Args:

From 6278b0e8e6c19ad2a8f7f9539420a96748896dec Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Wed, 4 Sep 2024 12:39:13 +0400
Subject: [PATCH 11/44] fix tests and change examples

---
 doc/source/code-examples/advancedexamples.rst |  6 +++---
 examples/adiabatic_qml/adiabatic-qml.ipynb    |  2 +-
 examples/anomaly_detection/test.py            |  2 +-
 examples/anomaly_detection/train.py           |  2 +-
 examples/qcnn_classifier/qcnn_demo.ipynb      |  2 +-
 examples/qfiae/qfiae_demo.ipynb               |  8 ++++----
 src/qibo/gates/measurements.py                |  2 +-
 tests/conftest.py                             |  6 +++---
 tests/test_measurements.py                    |  2 +-
 tests/test_models_circuit.py                  | 10 +++++-----
 tests/test_noise.py                           |  4 +++-
 11 files changed, 24 insertions(+), 22 deletions(-)

diff --git a/doc/source/code-examples/advancedexamples.rst b/doc/source/code-examples/advancedexamples.rst
index 50ebdef539..e6740b5141 100644
--- a/doc/source/code-examples/advancedexamples.rst
+++ b/doc/source/code-examples/advancedexamples.rst
@@ -1151,7 +1151,7 @@ Additionally, one can also pass single-qubit readout error probabilities (`reado
     )
 
     print("raw circuit:")
-    print(circuit.draw())
+    circuit.draw()
 
     parameters = {
         "t1": {"0": 250*1e-06, "1": 240*1e-06},
@@ -1168,7 +1168,7 @@ Additionally, one can also pass single-qubit readout error probabilities (`reado
     noisy_circuit = noise_model.apply(circuit)
 
     print("noisy circuit:")
-    print(noisy_circuit.draw())
+    noisy_circuit.draw()
 
 .. testoutput::
    :hide:
@@ -1242,7 +1242,7 @@ Let's see how to use them. For starters, let's define a dummy circuit with some
    circ.add(gates.M(*range(nqubits)))
 
    # visualize the circuit
-   print(circ.draw())
+   circ.draw()
 
    #  q0: ─RZ─RX─RZ─RX─RZ─o────o────────M─
    #  q1: ─RZ─RX─RZ─RX─RZ─X─RZ─X─o────o─M─
diff --git a/examples/adiabatic_qml/adiabatic-qml.ipynb b/examples/adiabatic_qml/adiabatic-qml.ipynb
index 0ee08d3d32..423c4531b6 100644
--- a/examples/adiabatic_qml/adiabatic-qml.ipynb
+++ b/examples/adiabatic_qml/adiabatic-qml.ipynb
@@ -568,7 +568,7 @@
     "circ1 = rotcirc.rotations_circuit(t=0.1)\n",
     "circ2 = rotcirc.rotations_circuit(t=0.8)\n",
     "\n",
-    "print(f\"Circuit diagram: {circ1.draw()}\")\n",
+    "print(f\"Circuit diagram: {circ1.draw(output_string=True)}\")\n",
     "print(f\"\\nCirc1 params: {circ1.get_parameters()}\")\n",
     "print(f\"\\nCirc2 params: {circ2.get_parameters()}\")"
    ]
diff --git a/examples/anomaly_detection/test.py b/examples/anomaly_detection/test.py
index 043db58a0c..6104fa6294 100644
--- a/examples/anomaly_detection/test.py
+++ b/examples/anomaly_detection/test.py
@@ -99,7 +99,7 @@ def compute_loss_test(encoder, vector):
     encoder_test = make_encoder(n_qubits, n_layers, trained_params, q_compression)
     encoder_test.compile()
     print("Circuit model summary")
-    print(encoder_test.draw())
+    encoder_test.draw()
 
     print("Computing losses...")
     # Compute loss for standard data
diff --git a/examples/anomaly_detection/train.py b/examples/anomaly_detection/train.py
index 0f662a01f3..0406a1f122 100644
--- a/examples/anomaly_detection/train.py
+++ b/examples/anomaly_detection/train.py
@@ -123,7 +123,7 @@ def train_step(batch_size, encoder, params, dataset):
     # Create and print encoder circuit
     encoder = make_encoder(n_qubits, n_layers, params, q_compression)
     print("Circuit model summary")
-    print(encoder.draw())
+    encoder.draw()
 
     # Define optimizer parameters
     steps_for_epoch = math.ceil(train_size / batch_size)
diff --git a/examples/qcnn_classifier/qcnn_demo.ipynb b/examples/qcnn_classifier/qcnn_demo.ipynb
index 0f72938bab..6b372e22e1 100644
--- a/examples/qcnn_classifier/qcnn_demo.ipynb
+++ b/examples/qcnn_classifier/qcnn_demo.ipynb
@@ -240,7 +240,7 @@
    "source": [
     "test = QuantumCNN(nqubits=4, nlayers=1, nclasses=2)\n",
     "testcircuit = test._circuit\n",
-    "print(testcircuit.draw())"
+    "testcircuit.draw()"
    ]
   },
   {
diff --git a/examples/qfiae/qfiae_demo.ipynb b/examples/qfiae/qfiae_demo.ipynb
index 59d78b008d..04f118d5ba 100644
--- a/examples/qfiae/qfiae_demo.ipynb
+++ b/examples/qfiae/qfiae_demo.ipynb
@@ -359,7 +359,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1500x700 with 1 Axes>"
       ]
@@ -464,7 +464,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -655,7 +655,7 @@
    ],
    "source": [
     "circuit_a_prob = create_circuit_a(n_qubits = 4,b_max = x_max_int, b_min = x_min_int)\n",
-    "print(circuit_a_prob.draw())"
+    "circuit_a_prob.draw()"
    ]
   },
   {
@@ -753,7 +753,7 @@
     }
    ],
    "source": [
-    "print(create_circuit_q(n_qubits=4,circuit_a=circuit_a_prob).draw())"
+    "create_circuit_q(n_qubits=4,circuit_a=circuit_a_prob).draw()"
    ]
   },
   {
diff --git a/src/qibo/gates/measurements.py b/src/qibo/gates/measurements.py
index 34e1ca4f1a..ac5b831ead 100644
--- a/src/qibo/gates/measurements.py
+++ b/src/qibo/gates/measurements.py
@@ -245,7 +245,7 @@ def on_qubits(self, qubit_map) -> "Gate":
                 c = models.Circuit(3)
                 c.add(measurement.on_qubits({0: 0, 1: 2}))
                 assert c.queue[0].result is measurement.result
-                print(c.draw())
+                c.draw()
             .. testoutput::
 
                 q0: ─M─
diff --git a/tests/conftest.py b/tests/conftest.py
index 538ed7a1e5..767011411a 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -14,9 +14,9 @@
     "numpy",
     "tensorflow",
     "pytorch",
-    "qibojit-numba",
-    "qibojit-cupy",
-    "qibojit-cuquantum",
+    # "qibojit-numba",
+    # "qibojit-cupy",
+    # "qibojit-cuquantum",
 ]
 # multigpu configurations to be tested (only with qibojit-cupy)
 ACCELERATORS = [
diff --git a/tests/test_measurements.py b/tests/test_measurements.py
index 050d2c1970..ef9f563096 100644
--- a/tests/test_measurements.py
+++ b/tests/test_measurements.py
@@ -440,7 +440,7 @@ def test_measurement_basis_list(backend):
     result = backend.execute_circuit(c, nshots=100)
     assert result.frequencies() == {"0011": 100}
     assert (
-        c.draw()
+        c.draw(output_string=True)
         == """q0: ─H─H───M─
 q1: ───────M─
 q2: ─X─H─H─M─
diff --git a/tests/test_models_circuit.py b/tests/test_models_circuit.py
index 33036dad22..a2e7fa24c3 100644
--- a/tests/test_models_circuit.py
+++ b/tests/test_models_circuit.py
@@ -634,7 +634,7 @@ def test_circuit_draw():
     circuit.add(gates.SWAP(0, 4))
     circuit.add(gates.SWAP(1, 3))
 
-    assert circuit.draw() == ref
+    assert circuit.draw(output_string=True) == ref
 
 
 def test_circuit_wire_names_errors():
@@ -667,7 +667,7 @@ def test_circuit_draw_wire_names():
     circuit.add(gates.SWAP(0, 4))
     circuit.add(gates.SWAP(1, 3))
 
-    assert circuit.draw() == ref
+    assert circuit.draw(output_string=True) == ref
 
 
 def test_circuit_draw_line_wrap():
@@ -861,7 +861,7 @@ def test_circuit_draw_labels():
             circuit.add(gate)
     circuit.add(gates.SWAP(0, 4))
     circuit.add(gates.SWAP(1, 3))
-    assert circuit.draw() == ref
+    assert circuit == ref
 
 
 def test_circuit_draw_names():
@@ -882,7 +882,7 @@ def test_circuit_draw_names():
             circuit.add(gate)
     circuit.add(gates.SWAP(0, 4))
     circuit.add(gates.SWAP(1, 3))
-    assert circuit.draw() == ref
+    assert circuit.draw(output_string=True) == ref
 
 
 def test_circuit_draw_error():
@@ -894,4 +894,4 @@ def test_circuit_draw_error():
     circuit.add(error_gate)
 
     with pytest.raises(NotImplementedError):
-        circuit.draw()
+        circuit.draw(output_string=True)
diff --git a/tests/test_noise.py b/tests/test_noise.py
index 325ec95e2d..27c07310ce 100644
--- a/tests/test_noise.py
+++ b/tests/test_noise.py
@@ -758,7 +758,9 @@ def test_ibmq_noise(
 
     noisy_circuit_target = noise_model_target.apply(circuit)
 
-    assert noisy_circuit.draw() == noisy_circuit_target.draw()
+    assert noisy_circuit.draw(output_string=True) == noisy_circuit_target.draw(
+        output_string=True
+    )
 
     backend.set_seed(2024)
     state = backend.execute_circuit(noisy_circuit, nshots=10)

From ee59bf4411d5c07767a81c8cf2afa3d7091fa44d Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Wed, 4 Sep 2024 12:40:06 +0400
Subject: [PATCH 12/44] fix tests and change examples

---
 doc/source/code-examples/examples.rst | 2 +-
 src/qibo/gates/abstract.py            | 2 +-
 tests/test_models_circuit_fuse.py     | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/doc/source/code-examples/examples.rst b/doc/source/code-examples/examples.rst
index 1d3d43b52b..8fcc06448a 100644
--- a/doc/source/code-examples/examples.rst
+++ b/doc/source/code-examples/examples.rst
@@ -310,7 +310,7 @@ For example
     from qibo.models import QFT
 
     c = QFT(5)
-    print(c.draw())
+    print(c.draw(output_string=True))
     # Prints
     '''
     q0: ─H─U1─U1─U1─U1───────────────────────────x───
diff --git a/src/qibo/gates/abstract.py b/src/qibo/gates/abstract.py
index b829392995..e7a8c9a8b3 100644
--- a/src/qibo/gates/abstract.py
+++ b/src/qibo/gates/abstract.py
@@ -255,7 +255,7 @@ def on_qubits(self, qubit_map) -> "Gate":
                 c.add(gates.CNOT(2, 3).on_qubits({2: 3, 3: 0})) # equivalent to gates.CNOT(3, 0)
                 c.add(gates.CNOT(2, 3).on_qubits({2: 1, 3: 3})) # equivalent to gates.CNOT(1, 3)
                 c.add(gates.CNOT(2, 3).on_qubits({2: 2, 3: 1})) # equivalent to gates.CNOT(2, 1)
-                print(c.draw())
+                c.draw()
             .. testoutput::
 
                 q0: ───X─────
diff --git a/tests/test_models_circuit_fuse.py b/tests/test_models_circuit_fuse.py
index 6ba1ef729b..7ce1b359c5 100644
--- a/tests/test_models_circuit_fuse.py
+++ b/tests/test_models_circuit_fuse.py
@@ -236,4 +236,4 @@ def test_fused_gate_draw():
     circuit.add(gates.SWAP(0, 4))
     circuit.add(gates.SWAP(1, 3))
     circuit = circuit.fuse()
-    assert circuit.draw() == ref
+    assert circuit.draw(output_string=True) == ref

From a0cfb96126078b9a971218a2e40ef3989d055b2e Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Wed, 4 Sep 2024 14:54:13 +0400
Subject: [PATCH 13/44] fix more tests

---
 tests/test_models_circuit.py | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/tests/test_models_circuit.py b/tests/test_models_circuit.py
index a2e7fa24c3..58cb1e1d0f 100644
--- a/tests/test_models_circuit.py
+++ b/tests/test_models_circuit.py
@@ -723,8 +723,8 @@ def test_circuit_draw_line_wrap():
     circuit.add(gates.GeneralizedfSim(0, 2, np.eye(2), 0))
     circuit.add(gates.X(4).controlled_by(1, 2, 3))
     circuit.add(gates.M(*range(3)))
-    assert circuit.draw(line_wrap=50) == ref_line_wrap_50
-    assert circuit.draw(line_wrap=30) == ref_line_wrap_30
+    assert circuit.draw(line_wrap=50, output_string=True) == ref_line_wrap_50
+    assert circuit.draw(line_wrap=30, output_string=True) == ref_line_wrap_30
 
 
 def test_circuit_draw_line_wrap_names():
@@ -780,8 +780,8 @@ def test_circuit_draw_line_wrap_names():
     circuit.add(gates.GeneralizedfSim(0, 2, np.eye(2), 0))
     circuit.add(gates.X(4).controlled_by(1, 2, 3))
     circuit.add(gates.M(*range(3)))
-    assert circuit.draw(line_wrap=50) == ref_line_wrap_50
-    assert circuit.draw(line_wrap=30) == ref_line_wrap_30
+    assert circuit.draw(line_wrap=50, output_string=True) == ref_line_wrap_50
+    assert circuit.draw(line_wrap=30, output_string=True) == ref_line_wrap_30
 
 
 @pytest.mark.parametrize("legend", [True, False])
@@ -814,7 +814,7 @@ def test_circuit_draw_channels(legend):
             "| PauliNoiseChannel   | PN       |"
         )
 
-    assert circuit.draw(legend=legend) == ref
+    assert circuit.draw(legend=legend, output_string=True) == ref
 
 
 @pytest.mark.parametrize("legend", [True, False])
@@ -840,7 +840,7 @@ def test_circuit_draw_callbacks(legend):
             "| EntanglementEntropy | EE       |"
         )
 
-    assert c.draw(legend=legend) == ref
+    assert c.draw(legend=legend, output_string=True) == ref
 
 
 def test_circuit_draw_labels():

From 20c2d573cf34ec91809cdf66ade6763f08e8855b Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Wed, 4 Sep 2024 15:05:41 +0400
Subject: [PATCH 14/44] Fix test

---
 tests/test_models_circuit.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/test_models_circuit.py b/tests/test_models_circuit.py
index 58cb1e1d0f..804de2311a 100644
--- a/tests/test_models_circuit.py
+++ b/tests/test_models_circuit.py
@@ -861,7 +861,7 @@ def test_circuit_draw_labels():
             circuit.add(gate)
     circuit.add(gates.SWAP(0, 4))
     circuit.add(gates.SWAP(1, 3))
-    assert circuit == ref
+    assert circuit.draw(output_string=True) == ref
 
 
 def test_circuit_draw_names():

From 96e7d30a089a9d7f4aeb7594b254de8bc2dc09e6 Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Thu, 5 Sep 2024 11:15:54 +0400
Subject: [PATCH 15/44] coverage

---
 tests/test_models_circuit.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/tests/test_models_circuit.py b/tests/test_models_circuit.py
index 804de2311a..2ad751bf14 100644
--- a/tests/test_models_circuit.py
+++ b/tests/test_models_circuit.py
@@ -864,7 +864,7 @@ def test_circuit_draw_labels():
     assert circuit.draw(output_string=True) == ref
 
 
-def test_circuit_draw_names():
+def test_circuit_draw_names(capsys):
     """Test circuit text draw."""
     ref = (
         "q0: ─H─cx─cx─cx─cx───────────────────────────x───\n"
@@ -884,6 +884,11 @@ def test_circuit_draw_names():
     circuit.add(gates.SWAP(1, 3))
     assert circuit.draw(output_string=True) == ref
 
+    # Testing circuit text draw when ``output_string == False``
+    circuit.draw()
+    out, _  = capsys.readouterr()
+    assert out == ref
+
 
 def test_circuit_draw_error():
     """Test NotImplementedError in circuit draw."""

From f4ea68177c3203a667609b6779e70d0cc37770da Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Thu, 5 Sep 2024 07:16:23 +0000
Subject: [PATCH 16/44] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 tests/test_models_circuit.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/test_models_circuit.py b/tests/test_models_circuit.py
index 2ad751bf14..a3c8619ffc 100644
--- a/tests/test_models_circuit.py
+++ b/tests/test_models_circuit.py
@@ -886,7 +886,7 @@ def test_circuit_draw_names(capsys):
 
     # Testing circuit text draw when ``output_string == False``
     circuit.draw()
-    out, _  = capsys.readouterr()
+    out, _ = capsys.readouterr()
     assert out == ref
 
 

From 74f69b075111b16d965105b316ec10e7408039de Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Thu, 5 Sep 2024 12:18:51 +0400
Subject: [PATCH 17/44] lint disable

---
 src/qibo/ui/mpldrawer.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py
index 778a429fe2..cac3759be3 100644
--- a/src/qibo/ui/mpldrawer.py
+++ b/src/qibo/ui/mpldrawer.py
@@ -601,7 +601,7 @@ def _process_gates(array_gates):
                 item += ("q_" + str(qbit),)
                 gates_plot.append(item)
         elif init_label == "ENTANGLEMENTENTROPY":
-            for qbit in list(range(circuit.nqubits)):
+            for qbit in list(range(circuit.nqubits)):  # pylint: disable=E0602
                 item = (init_label,)
                 item += ("q_" + str(qbit),)
                 gates_plot.append(item)

From a5986dfd76e1b9b30fadd4900027918281055641 Mon Sep 17 00:00:00 2001
From: BrunoLiegiBastonLiegi <andreapapaluca@gmail.com>
Date: Thu, 12 Sep 2024 10:52:30 +0200
Subject: [PATCH 18/44] fix: moved casts

---
 src/qibo/models/error_mitigation.py | 55 ++++++++++++++---------------
 1 file changed, 27 insertions(+), 28 deletions(-)

diff --git a/src/qibo/models/error_mitigation.py b/src/qibo/models/error_mitigation.py
index 6a8ac1bdc3..a5ee0f674a 100644
--- a/src/qibo/models/error_mitigation.py
+++ b/src/qibo/models/error_mitigation.py
@@ -274,6 +274,25 @@ def sample_training_circuit_cdr(
     return sampled_circuit
 
 
+def _curve_fit(backend, model, params, xdata, ydata, lr=1e-2, max_iter=int(1e3)):
+    if backend.name == "pytorch":
+        loss = lambda pred, target: backend.np.mean((pred - target) ** 2)
+        optimizer = backend.np.optim.LBFGS([params], lr=lr, max_iter=max_iter)
+
+        def closure():
+            optimizer.zero_grad()
+            output = model(xdata, params.reshape(-1, 1))
+            loss_val = loss(output, ydata)
+            loss_val.backward()
+            return loss_val
+
+        optimizer.step(closure)
+        return params
+    else:
+        wrapped_model = lambda x, *params: model(x, np.asarray(params).reshape(-1, 1))
+        return curve_fit(wrapped_model, xdata, ydata, p0=params)[0]
+
+
 def CDR(
     circuit,
     observable,
@@ -374,30 +393,6 @@ def CDR(
     return mit_val
 
 
-def _curve_fit(backend, model, params, xdata, ydata, lr=1e-2, max_iter=int(1e3)):
-    loss = lambda pred, target: backend.np.mean((pred - target) ** 2)
-    if backend.name == "pytorch":
-        ydata = backend.cast(ydata, backend.np.float64)
-        params = backend.cast(params, dtype=backend.np.float64)
-        optimizer = backend.np.optim.LBFGS([params], lr=lr, max_iter=max_iter)
-
-        def closure():
-            optimizer.zero_grad()
-            output = model(xdata, params.reshape(-1, 1))
-            loss_val = loss(output, ydata)
-            loss_val.backward()
-            return loss_val
-
-        optimizer.step(closure)
-        return params
-    elif backend.name == "tensorflow":
-        wrapped_model = lambda x, *params: model(x, np.asarray(params).reshape(-1, 1))
-        return curve_fit(wrapped_model, xdata, ydata, p0=params)[0]
-    else:
-        wrapped_model = lambda x, *params: model(x, np.asarray(params).reshape(-1, 1))
-        return curve_fit(wrapped_model, xdata, ydata, p0=params)[0]
-
-
 def vnCDR(
     circuit,
     observable,
@@ -489,13 +484,17 @@ def vnCDR(
             )
             train_val["noisy"].append(float(val))
 
-    noisy_array = backend.cast(train_val["noisy"], backend.np.float64).reshape(
+    noisy_array = backend.cast(train_val["noisy"], backend.precision).reshape(
         -1, len(noise_levels)
     )
 
-    params = local_state.random(len(noise_levels))
+    params = backend.cast(local_state.random(len(noise_levels)), backend.precision)
     optimal_params = _curve_fit(
-        backend, model, params, noisy_array.T, train_val["noise-free"]
+        backend,
+        model,
+        params,
+        noisy_array.T,
+        backend.cast(train_val["noise-free"], backend.precision),
     )
 
     val = []
@@ -514,7 +513,7 @@ def vnCDR(
         val.append(expval)
 
     mit_val = model(
-        backend.cast(val, backend.np.float64).reshape(-1, 1),
+        backend.cast(val, backend.precision).reshape(-1, 1),
         optimal_params.reshape(-1, 1),
     )[0]
 

From 30584ba65e0c1733b2a53ed0af2cde55fcd0d907 Mon Sep 17 00:00:00 2001
From: BrunoLiegiBastonLiegi <andreapapaluca@gmail.com>
Date: Thu, 12 Sep 2024 14:22:08 +0200
Subject: [PATCH 19/44] fix: using custom _curve_fit for CDR as well

---
 src/qibo/hamiltonians/hamiltonians.py |  7 +++--
 src/qibo/models/error_mitigation.py   | 45 ++++++++++++++++++---------
 2 files changed, 34 insertions(+), 18 deletions(-)

diff --git a/src/qibo/hamiltonians/hamiltonians.py b/src/qibo/hamiltonians/hamiltonians.py
index 49ff52c6f7..75fd10c7ba 100644
--- a/src/qibo/hamiltonians/hamiltonians.py
+++ b/src/qibo/hamiltonians/hamiltonians.py
@@ -553,7 +553,6 @@ def expectation(self, state, normalize=False):
         return Hamiltonian.expectation(self, state, normalize)
 
     def expectation_from_samples(self, freq, qubit_map=None):
-        # breakpoint()
         terms = self.terms
         for term in terms:
             # pylint: disable=E1101
@@ -565,7 +564,9 @@ def expectation_from_samples(self, freq, qubit_map=None):
             if len(term.factors) != len(set(term.factors)):
                 raise_error(NotImplementedError, "Z^k is not implemented since Z^2=I.")
         keys = list(freq.keys())
-        counts = np.array(list(freq.values())) / sum(freq.values())
+        counts = self.backend.cast(list(freq.values()), self.backend.precision) / sum(
+            freq.values()
+        )
         qubits = []
         for term in terms:
             qubits_term = []
@@ -585,7 +586,7 @@ def expectation_from_samples(self, freq, qubit_map=None):
                     expval_k = -1
                 expval_q += expval_k * counts[i]
             expval += expval_q * self.terms[j].coefficient.real
-        return self.backend.cast(expval + self.constant.real, self.backend.np.float64)
+        return expval + self.constant.real
 
     def __add__(self, o):
         if isinstance(o, self.__class__):
diff --git a/src/qibo/models/error_mitigation.py b/src/qibo/models/error_mitigation.py
index 07d3777ce6..7473d08c2e 100644
--- a/src/qibo/models/error_mitigation.py
+++ b/src/qibo/models/error_mitigation.py
@@ -1,6 +1,7 @@
 """Error Mitigation Methods."""
 
 import math
+from inspect import signature
 from itertools import product
 
 import numpy as np
@@ -208,9 +209,9 @@ def ZNE(
         expected_values.append(val)
 
     gamma = backend.cast(
-        get_gammas(noise_levels, analytical=solve_for_gammas), backend.np.float64
+        get_gammas(noise_levels, analytical=solve_for_gammas), backend.precision
     )
-    expected_values = backend.cast(expected_values, backend.np.float64)
+    expected_values = backend.cast(expected_values, backend.precision)
 
     return backend.np.sum(gamma * expected_values)
 
@@ -305,23 +306,26 @@ def sample_training_circuit_cdr(
     return sampled_circuit
 
 
-def _curve_fit(backend, model, params, xdata, ydata, lr=1e-2, max_iter=int(1e3)):
+def _curve_fit(
+    backend, model, params, xdata, ydata, lr=1, max_iter=int(1e2), tolerance_grad=1e-5
+):
     if backend.name == "pytorch":
         loss = lambda pred, target: backend.np.mean((pred - target) ** 2)
-        optimizer = backend.np.optim.LBFGS([params], lr=lr, max_iter=max_iter)
+        optimizer = backend.np.optim.LBFGS(
+            [params], lr=lr, max_iter=max_iter, tolerance_grad=tolerance_grad
+        )
 
         def closure():
             optimizer.zero_grad()
-            output = model(xdata, params.reshape(-1, 1))
+            output = model(xdata, *params)
             loss_val = loss(output, ydata)
-            loss_val.backward()
+            loss_val.backward(retain_graph=True)
             return loss_val
 
         optimizer.step(closure)
         return params
     else:
-        wrapped_model = lambda x, *params: model(x, np.asarray(params).reshape(-1, 1))
-        return curve_fit(wrapped_model, xdata, ydata, p0=params)[0]
+        return curve_fit(model, xdata, ydata, p0=params)[0]
 
 
 def CDR(
@@ -391,7 +395,7 @@ def CDR(
     for circ in training_circuits:
         result = backend.execute_circuit(circ, nshots=nshots)
         val = result.expectation_from_samples(observable)
-        train_val["noise-free"].append(float(val))
+        train_val["noise-free"].append(val)
         val = get_expectation_val_with_readout_mitigation(
             circ,
             observable,
@@ -402,9 +406,19 @@ def CDR(
             seed=local_state,
             backend=backend,
         )
-        train_val["noisy"].append(float(val))
+        train_val["noisy"].append(val)
 
-    optimal_params = curve_fit(model, train_val["noisy"], train_val["noise-free"])[0]
+    nparams = (
+        len(signature(model).parameters) - 1
+    )  # first arg is the input and the *params afterwards
+    params = backend.cast(local_state.random(nparams), backend.precision)
+    optimal_params = _curve_fit(
+        backend,
+        model,
+        params,
+        backend.cast(train_val["noisy"], backend.precision),
+        backend.cast(train_val["noise-free"], backend.precision),
+    )
 
     val = get_expectation_val_with_readout_mitigation(
         circuit,
@@ -486,7 +500,7 @@ def vnCDR(
     backend, local_state = _check_backend_and_local_state(seed, backend)
 
     if model is None:
-        model = lambda x, params: backend.np.sum(x * params, axis=0)
+        model = lambda x, *params: backend.np.sum(x * backend.np.vstack(params), axis=0)
 
     if readout is None:
         readout = {}
@@ -518,7 +532,6 @@ def vnCDR(
     noisy_array = backend.cast(train_val["noisy"], backend.precision).reshape(
         -1, len(noise_levels)
     )
-
     params = backend.cast(local_state.random(len(noise_levels)), backend.precision)
     optimal_params = _curve_fit(
         backend,
@@ -526,6 +539,8 @@ def vnCDR(
         params,
         noisy_array.T,
         backend.cast(train_val["noise-free"], backend.precision),
+        lr=1,
+        tolerance_grad=1e-7,
     )
 
     val = []
@@ -545,7 +560,7 @@ def vnCDR(
 
     mit_val = model(
         backend.cast(val, backend.precision).reshape(-1, 1),
-        optimal_params.reshape(-1, 1),
+        *optimal_params,
     )[0]
 
     if full_output:
@@ -1073,7 +1088,7 @@ def ICS(
         data["noisy"].append(noisy_expectation)
         lambda_list.append(1 - noisy_expectation / expectation)
 
-    lambda_list = backend.cast(lambda_list, backend.np.float64)
+    lambda_list = backend.cast(lambda_list, backend.precision)
     dep_param = backend.np.mean(lambda_list)
     dep_param_std = backend.np.std(lambda_list)
 

From e8e768edf70849d94dfbebd2a55862a0c25bd7bc Mon Sep 17 00:00:00 2001
From: BrunoLiegiBastonLiegi <andreapapaluca@gmail.com>
Date: Thu, 12 Sep 2024 14:37:43 +0200
Subject: [PATCH 20/44] fix: removed nshots setting

---
 src/qibo/measurements.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/qibo/measurements.py b/src/qibo/measurements.py
index df06004f58..3c8f6d2231 100644
--- a/src/qibo/measurements.py
+++ b/src/qibo/measurements.py
@@ -136,7 +136,6 @@ def has_samples(self):
     def register_samples(self, samples):
         """Register samples array to the ``MeasurementResult`` object."""
         self._samples = samples
-        self.nshots = samples.shape[0]
 
     def register_frequencies(self, frequencies):
         """Register frequencies to the ``MeasurementResult`` object."""

From 284d54b923ac8aae10d9554f737fabc0bfc7565a Mon Sep 17 00:00:00 2001
From: BrunoLiegiBastonLiegi
 <45011234+BrunoLiegiBastonLiegi@users.noreply.github.com>
Date: Fri, 13 Sep 2024 09:13:52 +0200
Subject: [PATCH 21/44] Update src/qibo/models/error_mitigation.py

Co-authored-by: Renato Mello <renato.msf@gmail.com>
---
 src/qibo/models/error_mitigation.py | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/qibo/models/error_mitigation.py b/src/qibo/models/error_mitigation.py
index 7473d08c2e..bbb475cbb5 100644
--- a/src/qibo/models/error_mitigation.py
+++ b/src/qibo/models/error_mitigation.py
@@ -324,8 +324,7 @@ def closure():
 
         optimizer.step(closure)
         return params
-    else:
-        return curve_fit(model, xdata, ydata, p0=params)[0]
+    return curve_fit(model, xdata, ydata, p0=params)[0]
 
 
 def CDR(

From 993c33cc0d0451efd22c12c65c1e65330f9966c4 Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Wed, 18 Sep 2024 09:22:58 +0400
Subject: [PATCH 22/44] Alessandro's suggestion

---
 src/qibo/models/circuit.py | 36 ++++++++++++++++--------------------
 1 file changed, 16 insertions(+), 20 deletions(-)

diff --git a/src/qibo/models/circuit.py b/src/qibo/models/circuit.py
index 75231add4c..c0ff113428 100644
--- a/src/qibo/models/circuit.py
+++ b/src/qibo/models/circuit.py
@@ -1268,21 +1268,7 @@ def _update_draw_matrix(self, matrix, idx, gate, gate_symbol=None):
 
         return matrix, idx
 
-    def draw(
-        self, line_wrap: int = 70, legend: bool = False, output_string: bool = False
-    ) -> str:
-        """Draw text circuit using unicode symbols.
-
-        Args:
-            line_wrap (int, optional): maximum number of characters per line. This option
-                split the circuit text diagram in chunks of line_wrap characters.
-                Defaults to :math:`70`.
-            legend (bool, optional): If ``True`` prints a legend below the circuit for
-                callbacks and channels. Default is ``False``.
-
-        Returns:
-            String containing text circuit diagram.
-        """
+    def __str__(self, line_wrap: int = 70, legend: bool = False) -> str:
         # build string representation of gates
         matrix = [[] for _ in range(self.nqubits)]
         idx = [0] * self.nqubits
@@ -1372,10 +1358,20 @@ def chunkstring(string, length):
         if legend:
             output += table
 
-        output = output.rstrip("\n")
+        return output.rstrip("\n")
 
-        if not output_string:
-            sys.stdout.write(output)
-            return
 
-        return output
+    def draw(self, line_wrap: int = 70, legend: bool = False):
+        """Draw text circuit using unicode symbols.
+
+        Args:
+            line_wrap (int, optional): maximum number of characters per line. This option
+                split the circuit text diagram in chunks of line_wrap characters.
+                Defaults to :math:`70`.
+            legend (bool, optional): If ``True`` prints a legend below the circuit for
+                callbacks and channels. Defaults to ``False``.
+
+        Returns:
+            String containing text circuit diagram.
+        """
+        sys.stdout.write(self.__str__(line_wrap, legend))

From f739fd3953c0b634647c1aa7e3e922bf0a2e8cef Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 18 Sep 2024 05:23:26 +0000
Subject: [PATCH 23/44] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/qibo/models/circuit.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/qibo/models/circuit.py b/src/qibo/models/circuit.py
index c0ff113428..eba1779488 100644
--- a/src/qibo/models/circuit.py
+++ b/src/qibo/models/circuit.py
@@ -1360,7 +1360,6 @@ def chunkstring(string, length):
 
         return output.rstrip("\n")
 
-
     def draw(self, line_wrap: int = 70, legend: bool = False):
         """Draw text circuit using unicode symbols.
 

From 9c09a199c4d918b05128361e2bdfed7e99dd9912 Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Wed, 18 Sep 2024 09:35:02 +0400
Subject: [PATCH 24/44] Introduce warning

---
 src/qibo/models/circuit.py | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/src/qibo/models/circuit.py b/src/qibo/models/circuit.py
index eba1779488..3242db7df2 100644
--- a/src/qibo/models/circuit.py
+++ b/src/qibo/models/circuit.py
@@ -1360,7 +1360,19 @@ def chunkstring(string, length):
 
         return output.rstrip("\n")
 
+
     def draw(self, line_wrap: int = 70, legend: bool = False):
+        qibo.config.log.warning(
+            "Starting on qibo 0.2.13, ``Circuit.draw`` will work in-place. "
+            + "The in-place method is currently implemented as ``Circuit.display``, but "
+            + "will be renamed as ``Circuit.draw`` on release 0.2.13. "
+            + "In release 0.2.12, the in-place print of circuits is accessible as "
+            + "``Circuit.display``."
+        )
+        return self.__str__(line_wrap, legend)
+
+
+    def display(self, line_wrap: int = 70, legend: bool = False):
         """Draw text circuit using unicode symbols.
 
         Args:

From f55ec8347ad3e08dcf998a9b4ee4701741eb46c6 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 18 Sep 2024 05:35:33 +0000
Subject: [PATCH 25/44] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/qibo/models/circuit.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/qibo/models/circuit.py b/src/qibo/models/circuit.py
index 3242db7df2..e891b1a726 100644
--- a/src/qibo/models/circuit.py
+++ b/src/qibo/models/circuit.py
@@ -1360,7 +1360,6 @@ def chunkstring(string, length):
 
         return output.rstrip("\n")
 
-
     def draw(self, line_wrap: int = 70, legend: bool = False):
         qibo.config.log.warning(
             "Starting on qibo 0.2.13, ``Circuit.draw`` will work in-place. "
@@ -1371,7 +1370,6 @@ def draw(self, line_wrap: int = 70, legend: bool = False):
         )
         return self.__str__(line_wrap, legend)
 
-
     def display(self, line_wrap: int = 70, legend: bool = False):
         """Draw text circuit using unicode symbols.
 

From 53b20daf5dfabdce21dd9c50008bc5e396b54013 Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Wed, 18 Sep 2024 09:44:37 +0400
Subject: [PATCH 26/44] fix docstring

---
 src/qibo/models/circuit.py | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/src/qibo/models/circuit.py b/src/qibo/models/circuit.py
index 3242db7df2..a743bd13e0 100644
--- a/src/qibo/models/circuit.py
+++ b/src/qibo/models/circuit.py
@@ -1362,17 +1362,29 @@ def chunkstring(string, length):
 
 
     def draw(self, line_wrap: int = 70, legend: bool = False):
+        """Draw text circuit using unicode symbols.
+
+        Args:
+            line_wrap (int, optional): maximum number of characters per line. This option
+                split the circuit text diagram in chunks of line_wrap characters.
+                Defaults to :math:`70`.
+            legend (bool, optional): If ``True`` prints a legend below the circuit for
+                callbacks and channels. Defaults to ``False``.
+
+        Returns:
+            String containing text circuit diagram.
+        """
         qibo.config.log.warning(
             "Starting on qibo 0.2.13, ``Circuit.draw`` will work in-place. "
             + "The in-place method is currently implemented as ``Circuit.display``, but "
             + "will be renamed as ``Circuit.draw`` on release 0.2.13. "
             + "In release 0.2.12, the in-place print of circuits is accessible as "
-            + "``Circuit.display``."
+            + "``Circuit._display``."
         )
         return self.__str__(line_wrap, legend)
 
 
-    def display(self, line_wrap: int = 70, legend: bool = False):
+    def _display(self, line_wrap: int = 70, legend: bool = False):
         """Draw text circuit using unicode symbols.
 
         Args:

From c2584b83ecf4b98ca37a197d40b04c30be2fc752 Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Wed, 18 Sep 2024 09:44:44 +0400
Subject: [PATCH 27/44] fix test

---
 tests/test_models_circuit.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/test_models_circuit.py b/tests/test_models_circuit.py
index a3c8619ffc..440b99e1f9 100644
--- a/tests/test_models_circuit.py
+++ b/tests/test_models_circuit.py
@@ -885,7 +885,7 @@ def test_circuit_draw_names(capsys):
     assert circuit.draw(output_string=True) == ref
 
     # Testing circuit text draw when ``output_string == False``
-    circuit.draw()
+    circuit._display()
     out, _ = capsys.readouterr()
     assert out == ref
 

From b3c9f0fe06e0587de9a7d63b4f4bf2f5dacada6b Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 18 Sep 2024 05:45:46 +0000
Subject: [PATCH 28/44] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 src/qibo/models/circuit.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/qibo/models/circuit.py b/src/qibo/models/circuit.py
index 1083a04576..b6d40ac360 100644
--- a/src/qibo/models/circuit.py
+++ b/src/qibo/models/circuit.py
@@ -1382,7 +1382,6 @@ def draw(self, line_wrap: int = 70, legend: bool = False):
         )
         return self.__str__(line_wrap, legend)
 
-
     def _display(self, line_wrap: int = 70, legend: bool = False):
         """Draw text circuit using unicode symbols.
 

From 690a70e4a31a3b0987aa855e4a3250ebf5757b6f Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Wed, 18 Sep 2024 10:08:03 +0400
Subject: [PATCH 29/44] uncomment test backends

---
 tests/conftest.py | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/conftest.py b/tests/conftest.py
index 767011411a..538ed7a1e5 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -14,9 +14,9 @@
     "numpy",
     "tensorflow",
     "pytorch",
-    # "qibojit-numba",
-    # "qibojit-cupy",
-    # "qibojit-cuquantum",
+    "qibojit-numba",
+    "qibojit-cupy",
+    "qibojit-cuquantum",
 ]
 # multigpu configurations to be tested (only with qibojit-cupy)
 ACCELERATORS = [

From b0fa293bdc45e1540f9717fa3c48722b47d02e1b Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Wed, 18 Sep 2024 10:14:56 +0400
Subject: [PATCH 30/44] fix tests

---
 examples/adiabatic_qml/adiabatic-qml.ipynb |  2 +-
 tests/test_measurements.py                 |  2 +-
 tests/test_models_circuit.py               | 22 +++++++++++-----------
 tests/test_models_circuit_fuse.py          |  2 +-
 tests/test_noise.py                        |  4 ++--
 5 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/examples/adiabatic_qml/adiabatic-qml.ipynb b/examples/adiabatic_qml/adiabatic-qml.ipynb
index 423c4531b6..072d02392c 100644
--- a/examples/adiabatic_qml/adiabatic-qml.ipynb
+++ b/examples/adiabatic_qml/adiabatic-qml.ipynb
@@ -568,7 +568,7 @@
     "circ1 = rotcirc.rotations_circuit(t=0.1)\n",
     "circ2 = rotcirc.rotations_circuit(t=0.8)\n",
     "\n",
-    "print(f\"Circuit diagram: {circ1.draw(output_string=True)}\")\n",
+    "print(f\"Circuit diagram: {print(circ1.draw())}\")\n",
     "print(f\"\\nCirc1 params: {circ1.get_parameters()}\")\n",
     "print(f\"\\nCirc2 params: {circ2.get_parameters()}\")"
    ]
diff --git a/tests/test_measurements.py b/tests/test_measurements.py
index 171d3fbf99..d29d65a0a1 100644
--- a/tests/test_measurements.py
+++ b/tests/test_measurements.py
@@ -442,7 +442,7 @@ def test_measurement_basis_list(backend):
     result = backend.execute_circuit(c, nshots=100)
     assert result.frequencies() == {"0011": 100}
     assert (
-        c.draw(output_string=True)
+        print(c.draw())
         == """q0: ─H─H───M─
 q1: ───────M─
 q2: ─X─H─H─M─
diff --git a/tests/test_models_circuit.py b/tests/test_models_circuit.py
index 440b99e1f9..06c64a05f1 100644
--- a/tests/test_models_circuit.py
+++ b/tests/test_models_circuit.py
@@ -634,7 +634,7 @@ def test_circuit_draw():
     circuit.add(gates.SWAP(0, 4))
     circuit.add(gates.SWAP(1, 3))
 
-    assert circuit.draw(output_string=True) == ref
+    assert circuit.draw() == ref
 
 
 def test_circuit_wire_names_errors():
@@ -667,7 +667,7 @@ def test_circuit_draw_wire_names():
     circuit.add(gates.SWAP(0, 4))
     circuit.add(gates.SWAP(1, 3))
 
-    assert circuit.draw(output_string=True) == ref
+    assert circuit.draw() == ref
 
 
 def test_circuit_draw_line_wrap():
@@ -723,8 +723,8 @@ def test_circuit_draw_line_wrap():
     circuit.add(gates.GeneralizedfSim(0, 2, np.eye(2), 0))
     circuit.add(gates.X(4).controlled_by(1, 2, 3))
     circuit.add(gates.M(*range(3)))
-    assert circuit.draw(line_wrap=50, output_string=True) == ref_line_wrap_50
-    assert circuit.draw(line_wrap=30, output_string=True) == ref_line_wrap_30
+    assert circuit.draw(line_wrap=50, ) == ref_line_wrap_50
+    assert circuit.draw(line_wrap=30, ) == ref_line_wrap_30
 
 
 def test_circuit_draw_line_wrap_names():
@@ -780,8 +780,8 @@ def test_circuit_draw_line_wrap_names():
     circuit.add(gates.GeneralizedfSim(0, 2, np.eye(2), 0))
     circuit.add(gates.X(4).controlled_by(1, 2, 3))
     circuit.add(gates.M(*range(3)))
-    assert circuit.draw(line_wrap=50, output_string=True) == ref_line_wrap_50
-    assert circuit.draw(line_wrap=30, output_string=True) == ref_line_wrap_30
+    assert circuit.draw(line_wrap=50, ) == ref_line_wrap_50
+    assert circuit.draw(line_wrap=30, ) == ref_line_wrap_30
 
 
 @pytest.mark.parametrize("legend", [True, False])
@@ -814,7 +814,7 @@ def test_circuit_draw_channels(legend):
             "| PauliNoiseChannel   | PN       |"
         )
 
-    assert circuit.draw(legend=legend, output_string=True) == ref
+    assert circuit.draw(legend=legend, ) == ref
 
 
 @pytest.mark.parametrize("legend", [True, False])
@@ -840,7 +840,7 @@ def test_circuit_draw_callbacks(legend):
             "| EntanglementEntropy | EE       |"
         )
 
-    assert c.draw(legend=legend, output_string=True) == ref
+    assert c.draw(legend=legend, ) == ref
 
 
 def test_circuit_draw_labels():
@@ -861,7 +861,7 @@ def test_circuit_draw_labels():
             circuit.add(gate)
     circuit.add(gates.SWAP(0, 4))
     circuit.add(gates.SWAP(1, 3))
-    assert circuit.draw(output_string=True) == ref
+    assert circuit.draw() == ref
 
 
 def test_circuit_draw_names(capsys):
@@ -882,7 +882,7 @@ def test_circuit_draw_names(capsys):
             circuit.add(gate)
     circuit.add(gates.SWAP(0, 4))
     circuit.add(gates.SWAP(1, 3))
-    assert circuit.draw(output_string=True) == ref
+    assert circuit.draw() == ref
 
     # Testing circuit text draw when ``output_string == False``
     circuit._display()
@@ -899,4 +899,4 @@ def test_circuit_draw_error():
     circuit.add(error_gate)
 
     with pytest.raises(NotImplementedError):
-        circuit.draw(output_string=True)
+        circuit.draw()
diff --git a/tests/test_models_circuit_fuse.py b/tests/test_models_circuit_fuse.py
index 7ce1b359c5..6ba1ef729b 100644
--- a/tests/test_models_circuit_fuse.py
+++ b/tests/test_models_circuit_fuse.py
@@ -236,4 +236,4 @@ def test_fused_gate_draw():
     circuit.add(gates.SWAP(0, 4))
     circuit.add(gates.SWAP(1, 3))
     circuit = circuit.fuse()
-    assert circuit.draw(output_string=True) == ref
+    assert circuit.draw() == ref
diff --git a/tests/test_noise.py b/tests/test_noise.py
index 27c07310ce..f46dcd9188 100644
--- a/tests/test_noise.py
+++ b/tests/test_noise.py
@@ -758,8 +758,8 @@ def test_ibmq_noise(
 
     noisy_circuit_target = noise_model_target.apply(circuit)
 
-    assert noisy_circuit.draw(output_string=True) == noisy_circuit_target.draw(
-        output_string=True
+    assert noisy_circuit.draw() == noisy_circuit_target.draw(
+        
     )
 
     backend.set_seed(2024)

From fa9bca87120113f805d38f308cc78ae76bab1d73 Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Wed, 18 Sep 2024 10:15:09 +0400
Subject: [PATCH 31/44] Alessandro's suggestion

---
 src/qibo/models/circuit.py | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/qibo/models/circuit.py b/src/qibo/models/circuit.py
index b6d40ac360..39b11cec0e 100644
--- a/src/qibo/models/circuit.py
+++ b/src/qibo/models/circuit.py
@@ -1268,7 +1268,7 @@ def _update_draw_matrix(self, matrix, idx, gate, gate_symbol=None):
 
         return matrix, idx
 
-    def __str__(self, line_wrap: int = 70, legend: bool = False) -> str:
+    def _diagram(self, line_wrap: int = 70, legend: bool = False) -> str:
         # build string representation of gates
         matrix = [[] for _ in range(self.nqubits)]
         idx = [0] * self.nqubits
@@ -1360,6 +1360,9 @@ def chunkstring(string, length):
 
         return output.rstrip("\n")
 
+    def __str__(self):
+        return self._diagram()
+
     def draw(self, line_wrap: int = 70, legend: bool = False):
         """Draw text circuit using unicode symbols.
 
@@ -1380,7 +1383,7 @@ def draw(self, line_wrap: int = 70, legend: bool = False):
             + "In release 0.2.12, the in-place print of circuits is accessible as "
             + "``Circuit._display``."
         )
-        return self.__str__(line_wrap, legend)
+        return self._diagram(line_wrap, legend)
 
     def _display(self, line_wrap: int = 70, legend: bool = False):
         """Draw text circuit using unicode symbols.
@@ -1395,4 +1398,4 @@ def _display(self, line_wrap: int = 70, legend: bool = False):
         Returns:
             String containing text circuit diagram.
         """
-        sys.stdout.write(self.__str__(line_wrap, legend))
+        sys.stdout.write(self._diagram(line_wrap, legend))

From 66b77f7a4d008aad48b1deadb97ed78346b772b7 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 18 Sep 2024 06:15:37 +0000
Subject: [PATCH 32/44] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 tests/test_models_circuit.py | 42 ++++++++++++++++++++++++++++++------
 tests/test_noise.py          |  4 +---
 2 files changed, 37 insertions(+), 9 deletions(-)

diff --git a/tests/test_models_circuit.py b/tests/test_models_circuit.py
index 06c64a05f1..236aafd867 100644
--- a/tests/test_models_circuit.py
+++ b/tests/test_models_circuit.py
@@ -723,8 +723,18 @@ def test_circuit_draw_line_wrap():
     circuit.add(gates.GeneralizedfSim(0, 2, np.eye(2), 0))
     circuit.add(gates.X(4).controlled_by(1, 2, 3))
     circuit.add(gates.M(*range(3)))
-    assert circuit.draw(line_wrap=50, ) == ref_line_wrap_50
-    assert circuit.draw(line_wrap=30, ) == ref_line_wrap_30
+    assert (
+        circuit.draw(
+            line_wrap=50,
+        )
+        == ref_line_wrap_50
+    )
+    assert (
+        circuit.draw(
+            line_wrap=30,
+        )
+        == ref_line_wrap_30
+    )
 
 
 def test_circuit_draw_line_wrap_names():
@@ -780,8 +790,18 @@ def test_circuit_draw_line_wrap_names():
     circuit.add(gates.GeneralizedfSim(0, 2, np.eye(2), 0))
     circuit.add(gates.X(4).controlled_by(1, 2, 3))
     circuit.add(gates.M(*range(3)))
-    assert circuit.draw(line_wrap=50, ) == ref_line_wrap_50
-    assert circuit.draw(line_wrap=30, ) == ref_line_wrap_30
+    assert (
+        circuit.draw(
+            line_wrap=50,
+        )
+        == ref_line_wrap_50
+    )
+    assert (
+        circuit.draw(
+            line_wrap=30,
+        )
+        == ref_line_wrap_30
+    )
 
 
 @pytest.mark.parametrize("legend", [True, False])
@@ -814,7 +834,12 @@ def test_circuit_draw_channels(legend):
             "| PauliNoiseChannel   | PN       |"
         )
 
-    assert circuit.draw(legend=legend, ) == ref
+    assert (
+        circuit.draw(
+            legend=legend,
+        )
+        == ref
+    )
 
 
 @pytest.mark.parametrize("legend", [True, False])
@@ -840,7 +865,12 @@ def test_circuit_draw_callbacks(legend):
             "| EntanglementEntropy | EE       |"
         )
 
-    assert c.draw(legend=legend, ) == ref
+    assert (
+        c.draw(
+            legend=legend,
+        )
+        == ref
+    )
 
 
 def test_circuit_draw_labels():
diff --git a/tests/test_noise.py b/tests/test_noise.py
index f46dcd9188..325ec95e2d 100644
--- a/tests/test_noise.py
+++ b/tests/test_noise.py
@@ -758,9 +758,7 @@ def test_ibmq_noise(
 
     noisy_circuit_target = noise_model_target.apply(circuit)
 
-    assert noisy_circuit.draw() == noisy_circuit_target.draw(
-        
-    )
+    assert noisy_circuit.draw() == noisy_circuit_target.draw()
 
     backend.set_seed(2024)
     state = backend.execute_circuit(noisy_circuit, nshots=10)

From 58ec073d22f51b5b5372e55298e56b2e383852d5 Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Wed, 18 Sep 2024 10:40:50 +0400
Subject: [PATCH 33/44] fix tests

---
 src/qibo/models/circuit.py |  2 +-
 tests/test_measurements.py | 59 +++++++++++++++++++-------------------
 2 files changed, 30 insertions(+), 31 deletions(-)

diff --git a/src/qibo/models/circuit.py b/src/qibo/models/circuit.py
index 39b11cec0e..3790d789e8 100644
--- a/src/qibo/models/circuit.py
+++ b/src/qibo/models/circuit.py
@@ -1380,7 +1380,7 @@ def draw(self, line_wrap: int = 70, legend: bool = False):
             "Starting on qibo 0.2.13, ``Circuit.draw`` will work in-place. "
             + "The in-place method is currently implemented as ``Circuit.display``, but "
             + "will be renamed as ``Circuit.draw`` on release 0.2.13. "
-            + "In release 0.2.12, the in-place print of circuits is accessible as "
+            + "In release 0.2.12, the in-place display of circuits is accessible as "
             + "``Circuit._display``."
         )
         return self._diagram(line_wrap, legend)
diff --git a/tests/test_measurements.py b/tests/test_measurements.py
index d29d65a0a1..72be72a6c7 100644
--- a/tests/test_measurements.py
+++ b/tests/test_measurements.py
@@ -6,7 +6,8 @@
 import numpy as np
 import pytest
 
-from qibo import gates, models
+from qibo import Circuit, gates
+from qibo.models import QFT
 from qibo.measurements import MeasurementResult
 
 
@@ -62,7 +63,7 @@ def assert_register_result(
 @pytest.mark.parametrize("n", [0, 1])
 @pytest.mark.parametrize("nshots", [100, 1000000])
 def test_measurement_gate(backend, n, nshots):
-    c = models.Circuit(2)
+    c = Circuit(2)
     if n:
         c.add(gates.X(1))
     c.add(gates.M(1))
@@ -78,7 +79,7 @@ def test_measurement_gate(backend, n, nshots):
 
 
 def test_multiple_qubit_measurement_gate(backend):
-    c = models.Circuit(2)
+    c = Circuit(2)
     c.add(gates.X(0))
     c.add(gates.M(0, 1))
     result = backend.execute_circuit(c, nshots=100)
@@ -105,7 +106,7 @@ def test_measurement_gate_errors(backend):
 
 
 def test_measurement_circuit(backend, accelerators):
-    c = models.Circuit(4, accelerators)
+    c = Circuit(4, accelerators)
     c.add(gates.X(0))
     c.add(gates.M(0))
     result = backend.execute_circuit(c, nshots=100)
@@ -116,7 +117,7 @@ def test_measurement_circuit(backend, accelerators):
 
 @pytest.mark.parametrize("registers", [False, True])
 def test_measurement_qubit_order_simple(backend, registers):
-    c = models.Circuit(2)
+    c = Circuit(2)
     c.add(gates.X(0))
     if registers:
         c.add(gates.M(1, 0))
@@ -134,7 +135,7 @@ def test_measurement_qubit_order_simple(backend, registers):
 
 @pytest.mark.parametrize("nshots", [100, 1000000])
 def test_measurement_qubit_order(backend, accelerators, nshots):
-    c = models.Circuit(6, accelerators)
+    c = Circuit(6, accelerators)
     c.add(gates.X(0))
     c.add(gates.X(1))
     c.add(gates.M(1, 5, 2, 0))
@@ -154,7 +155,7 @@ def test_measurement_qubit_order(backend, accelerators, nshots):
 
 
 def test_multiple_measurement_gates_circuit(backend):
-    c = models.Circuit(4)
+    c = Circuit(4)
     c.add(gates.X(1))
     c.add(gates.X(2))
     c.add(gates.M(0, 1))
@@ -170,7 +171,7 @@ def test_multiple_measurement_gates_circuit(backend):
 
 
 def test_circuit_with_unmeasured_qubits(backend, accelerators):
-    c = models.Circuit(5, accelerators)
+    c = Circuit(5, accelerators)
     c.add(gates.X(4))
     c.add(gates.X(2))
     c.add(gates.M(0, 2))
@@ -192,11 +193,11 @@ def test_circuit_with_unmeasured_qubits(backend, accelerators):
 
 
 def test_circuit_addition_with_measurements(backend):
-    c = models.Circuit(2)
+    c = Circuit(2)
     c.add(gates.X(0))
     c.add(gates.X(1))
 
-    meas_c = models.Circuit(2)
+    meas_c = Circuit(2)
     c.add(gates.M(0, 1))
 
     c += meas_c
@@ -213,12 +214,12 @@ def test_circuit_addition_with_measurements(backend):
 
 
 def test_circuit_addition_with_measurements_in_both_circuits(backend, accelerators):
-    c1 = models.Circuit(4, accelerators)
+    c1 = Circuit(4, accelerators)
     c1.add(gates.X(0))
     c1.add(gates.X(1))
     c1.add(gates.M(1, register_name="a"))
 
-    c2 = models.Circuit(4, accelerators)
+    c2 = Circuit(4, accelerators)
     c2.add(gates.X(0))
     c2.add(gates.M(0, register_name="b"))
 
@@ -232,7 +233,7 @@ def test_circuit_addition_with_measurements_in_both_circuits(backend, accelerato
 
 
 def test_circuit_copy_with_measurements(backend, accelerators):
-    c1 = models.Circuit(6, accelerators)
+    c1 = Circuit(6, accelerators)
     c1.add([gates.X(0), gates.X(1), gates.X(3)])
     c1.add(gates.M(5, 1, 3, register_name="a"))
     c1.add(gates.M(2, 0, register_name="b"))
@@ -250,7 +251,7 @@ def test_circuit_copy_with_measurements(backend, accelerators):
 
 
 def test_measurement_compiled_circuit(backend):
-    c = models.Circuit(2)
+    c = Circuit(2)
     c.add(gates.X(0))
     c.add(gates.M(0))
     c.add(gates.M(1))
@@ -274,14 +275,14 @@ def test_measurement_compiled_circuit(backend):
 
 def test_final_state(backend, accelerators):
     """Check that final state is logged correctly when using measurements."""
-    c = models.Circuit(4, accelerators)
+    c = Circuit(4, accelerators)
     c.add(gates.X(1))
     c.add(gates.X(2))
     c.add(gates.M(0, 1))
     c.add(gates.M(2))
     c.add(gates.X(3))
     result = backend.execute_circuit(c, nshots=100)
-    c = models.Circuit(4, accelerators)
+    c = Circuit(4, accelerators)
     c.add(gates.X(1))
     c.add(gates.X(2))
     c.add(gates.X(3))
@@ -300,7 +301,7 @@ def test_measurement_gate_bitflip_errors():
 
 
 def test_register_measurements(backend):
-    c = models.Circuit(3)
+    c = Circuit(3)
     c.add(gates.X(0))
     c.add(gates.X(1))
     c.add(gates.M(0, 2))
@@ -323,7 +324,7 @@ def test_register_measurements(backend):
 
 
 def test_measurement_qubit_order_multiple_registers(backend, accelerators):
-    c = models.Circuit(6, accelerators)
+    c = Circuit(6, accelerators)
     c.add(gates.X(0))
     c.add(gates.X(1))
     c.add(gates.X(3))
@@ -364,7 +365,7 @@ def test_measurement_qubit_order_multiple_registers(backend, accelerators):
 
 def test_registers_in_circuit_with_unmeasured_qubits(backend, accelerators):
     """Check that register measurements are unaffected by unmeasured qubits."""
-    c = models.Circuit(5, accelerators)
+    c = Circuit(5, accelerators)
     c.add(gates.X(1))
     c.add(gates.X(2))
     c.add(gates.M(0, 2, register_name="A"))
@@ -390,7 +391,7 @@ def test_registers_in_circuit_with_unmeasured_qubits(backend, accelerators):
 
 
 def test_measurement_density_matrix(backend):
-    c = models.Circuit(2, density_matrix=True)
+    c = Circuit(2, density_matrix=True)
     c.add(gates.X(0))
     c.add(gates.M(0, 1))
     result = backend.execute_circuit(c, nshots=100)
@@ -407,7 +408,7 @@ def test_measurement_density_matrix(backend):
 
 
 def test_measurement_result_vs_circuit_result(backend, accelerators):
-    c = models.Circuit(6, accelerators)
+    c = Circuit(6, accelerators)
     c.add([gates.X(0), gates.X(1), gates.X(3)])
     ma = c.add(gates.M(5, 1, 3, register_name="a"))
     mb = c.add(gates.M(2, 0, register_name="b"))
@@ -423,7 +424,7 @@ def test_measurement_result_vs_circuit_result(backend, accelerators):
 @pytest.mark.parametrize("nqubits", [1, 4])
 @pytest.mark.parametrize("outcome", [0, 1])
 def test_measurement_basis(backend, nqubits, outcome):
-    c = models.Circuit(nqubits)
+    c = Circuit(nqubits)
     if outcome:
         c.add(gates.X(q) for q in range(nqubits))
     c.add(gates.H(q) for q in range(nqubits))
@@ -433,7 +434,7 @@ def test_measurement_basis(backend, nqubits, outcome):
 
 
 def test_measurement_basis_list(backend):
-    c = models.Circuit(4)
+    c = Circuit(4)
     c.add(gates.H(0))
     c.add(gates.X(2))
     c.add(gates.H(2))
@@ -442,7 +443,7 @@ def test_measurement_basis_list(backend):
     result = backend.execute_circuit(c, nshots=100)
     assert result.frequencies() == {"0011": 100}
     assert (
-        print(c.draw())
+        c.draw()
         == """q0: ─H─H───M─
 q1: ───────M─
 q2: ─X─H─H─M─
@@ -450,22 +451,20 @@ def test_measurement_basis_list(backend):
     )
 
 
-def test_measurement_basis_list_error(backend):
-    c = models.Circuit(4)
+def test_measurement_basis_list_error():
+    c = Circuit(4)
     with pytest.raises(ValueError):
         c.add(gates.M(0, 1, 2, 3, basis=[gates.X, gates.Z, gates.X]))
 
 
-def test_measurement_same_qubit_different_registers_error(backend):
-    c = models.Circuit(4)
+def test_measurement_same_qubit_different_registers_error():
+    c = Circuit(4)
     c.add(gates.M(0, 1, 3, register_name="a"))
     with pytest.raises(KeyError):
         c.add(gates.M(1, 2, 3, register_name="a"))
 
 
 def test_measurementsymbol_pickling(backend):
-    from qibo.models import QFT
-
     c = QFT(3)
     c.add(gates.M(0, 2, basis=[gates.X, gates.Z]))
     backend.execute_circuit(c).samples()

From 6e51ac2e154ede5b4c3af4b86a29820cc25ba74b Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Wed, 18 Sep 2024 06:41:17 +0000
Subject: [PATCH 34/44] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 tests/test_measurements.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/test_measurements.py b/tests/test_measurements.py
index 72be72a6c7..5a8e6a66e6 100644
--- a/tests/test_measurements.py
+++ b/tests/test_measurements.py
@@ -7,8 +7,8 @@
 import pytest
 
 from qibo import Circuit, gates
-from qibo.models import QFT
 from qibo.measurements import MeasurementResult
+from qibo.models import QFT
 
 
 def assert_result(

From 0b2c4cb637dcb6a4162759743b20d24155ad546e Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Wed, 18 Sep 2024 10:42:44 +0400
Subject: [PATCH 35/44] Alessandro's suggestion

---
 src/qibo/models/circuit.py   | 12 ++++++------
 tests/test_models_circuit.py |  2 +-
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/qibo/models/circuit.py b/src/qibo/models/circuit.py
index 3790d789e8..e356dd0214 100644
--- a/src/qibo/models/circuit.py
+++ b/src/qibo/models/circuit.py
@@ -1268,7 +1268,7 @@ def _update_draw_matrix(self, matrix, idx, gate, gate_symbol=None):
 
         return matrix, idx
 
-    def _diagram(self, line_wrap: int = 70, legend: bool = False) -> str:
+    def diagram(self, line_wrap: int = 70, legend: bool = False) -> str:
         # build string representation of gates
         matrix = [[] for _ in range(self.nqubits)]
         idx = [0] * self.nqubits
@@ -1361,7 +1361,7 @@ def chunkstring(string, length):
         return output.rstrip("\n")
 
     def __str__(self):
-        return self._diagram()
+        return self.diagram()
 
     def draw(self, line_wrap: int = 70, legend: bool = False):
         """Draw text circuit using unicode symbols.
@@ -1381,11 +1381,11 @@ def draw(self, line_wrap: int = 70, legend: bool = False):
             + "The in-place method is currently implemented as ``Circuit.display``, but "
             + "will be renamed as ``Circuit.draw`` on release 0.2.13. "
             + "In release 0.2.12, the in-place display of circuits is accessible as "
-            + "``Circuit._display``."
+            + "``Circuit.display``."
         )
-        return self._diagram(line_wrap, legend)
+        return self.diagram(line_wrap, legend)
 
-    def _display(self, line_wrap: int = 70, legend: bool = False):
+    def display(self, line_wrap: int = 70, legend: bool = False):
         """Draw text circuit using unicode symbols.
 
         Args:
@@ -1398,4 +1398,4 @@ def _display(self, line_wrap: int = 70, legend: bool = False):
         Returns:
             String containing text circuit diagram.
         """
-        sys.stdout.write(self._diagram(line_wrap, legend))
+        sys.stdout.write(self.diagram(line_wrap, legend))
diff --git a/tests/test_models_circuit.py b/tests/test_models_circuit.py
index 236aafd867..f05bc6c979 100644
--- a/tests/test_models_circuit.py
+++ b/tests/test_models_circuit.py
@@ -915,7 +915,7 @@ def test_circuit_draw_names(capsys):
     assert circuit.draw() == ref
 
     # Testing circuit text draw when ``output_string == False``
-    circuit._display()
+    circuit.display()
     out, _ = capsys.readouterr()
     assert out == ref
 

From aff69eebf8a0ff931b19fc802021fefa1d0798bf Mon Sep 17 00:00:00 2001
From: BrunoLiegiBastonLiegi <andreapapaluca@gmail.com>
Date: Wed, 18 Sep 2024 10:01:13 +0200
Subject: [PATCH 36/44] doc: added docstring to _curve_fit

---
 src/qibo/models/error_mitigation.py | 22 +++++++++++++++++++++-
 1 file changed, 21 insertions(+), 1 deletion(-)

diff --git a/src/qibo/models/error_mitigation.py b/src/qibo/models/error_mitigation.py
index bbb475cbb5..18a0b2fe6e 100644
--- a/src/qibo/models/error_mitigation.py
+++ b/src/qibo/models/error_mitigation.py
@@ -307,9 +307,29 @@ def sample_training_circuit_cdr(
 
 
 def _curve_fit(
-    backend, model, params, xdata, ydata, lr=1, max_iter=int(1e2), tolerance_grad=1e-5
+    backend, model, params, xdata, ydata, lr=1.0, max_iter=int(1e2), tolerance_grad=1e-5
 ):
+    """
+    Fits a model with given parameters on the data points (x,y). This is generally based on the
+    `scipy.optimize.curve_fit` function, except for the `PyTorchBackend` which makes use of the
+    `torch.optim.LBFGS` optimizer.
+
+    Args:
+    backend (:class:`qibo.backends.Backend`): simulation engine, this is only useful for `pytorch`.
+    model (function): model to fit, it should be a callable ``model(x, *params)``.
+    params (ndarray): initial parameters of the model.
+    xdata (ndarray): x data, i.e. inputs to the model.
+    ydata (ndarray): y data, i.e. targets ``y = model(x, *params)``.
+    lr (float, optional): learning rate, defaults to ``1``. Used only in the `pytorch` case.
+    max_iter (int, optional): maximum number of iterations, defaults to ``100``. Used only in the `pytorch` case.
+    tolerance_grad (float, optional): gradient tolerance, optimization stops after reaching it, defaults to ``1e-5``. Used only in the `pytorch` case.
+
+    Returns:
+        ndarray: the optimal parameters.
+    """
     if backend.name == "pytorch":
+        # pytorch has some problems with the `scipy.optim.curve_fit` function
+        # thus we use a `torch.optim` optimizer
         loss = lambda pred, target: backend.np.mean((pred - target) ** 2)
         optimizer = backend.np.optim.LBFGS(
             [params], lr=lr, max_iter=max_iter, tolerance_grad=tolerance_grad

From 9b556d651876a8e5d724aeeb3253a46ed42f07ed Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Wed, 18 Sep 2024 13:25:20 +0400
Subject: [PATCH 37/44] fix doc tests

---
 doc/source/code-examples/advancedexamples.rst | 4 ++--
 doc/source/code-examples/examples.rst         | 2 +-
 examples/qcnn_classifier/qcnn_demo.ipynb      | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/doc/source/code-examples/advancedexamples.rst b/doc/source/code-examples/advancedexamples.rst
index e6740b5141..154fd67110 100644
--- a/doc/source/code-examples/advancedexamples.rst
+++ b/doc/source/code-examples/advancedexamples.rst
@@ -1151,7 +1151,7 @@ Additionally, one can also pass single-qubit readout error probabilities (`reado
     )
 
     print("raw circuit:")
-    circuit.draw()
+    print(circuit.draw())
 
     parameters = {
         "t1": {"0": 250*1e-06, "1": 240*1e-06},
@@ -1168,7 +1168,7 @@ Additionally, one can also pass single-qubit readout error probabilities (`reado
     noisy_circuit = noise_model.apply(circuit)
 
     print("noisy circuit:")
-    noisy_circuit.draw()
+    print(noisy_circuit.draw())
 
 .. testoutput::
    :hide:
diff --git a/doc/source/code-examples/examples.rst b/doc/source/code-examples/examples.rst
index 9b931e4ec3..081e8fc71d 100644
--- a/doc/source/code-examples/examples.rst
+++ b/doc/source/code-examples/examples.rst
@@ -310,7 +310,7 @@ For example
     from qibo.models import QFT
 
     c = QFT(5)
-    print(c.draw(output_string=True))
+    print(c.draw())
     # Prints
     '''
     q0: ─H─U1─U1─U1─U1───────────────────────────x───
diff --git a/examples/qcnn_classifier/qcnn_demo.ipynb b/examples/qcnn_classifier/qcnn_demo.ipynb
index 6b372e22e1..0f72938bab 100644
--- a/examples/qcnn_classifier/qcnn_demo.ipynb
+++ b/examples/qcnn_classifier/qcnn_demo.ipynb
@@ -240,7 +240,7 @@
    "source": [
     "test = QuantumCNN(nqubits=4, nlayers=1, nclasses=2)\n",
     "testcircuit = test._circuit\n",
-    "testcircuit.draw()"
+    "print(testcircuit.draw())"
    ]
   },
   {

From 3a96e3ea0c78dc97c174ac723ba78bea22b509b0 Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Wed, 18 Sep 2024 09:26:48 +0000
Subject: [PATCH 38/44] Update doc/source/code-examples/advancedexamples.rst

---
 doc/source/code-examples/advancedexamples.rst | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/source/code-examples/advancedexamples.rst b/doc/source/code-examples/advancedexamples.rst
index 154fd67110..50ebdef539 100644
--- a/doc/source/code-examples/advancedexamples.rst
+++ b/doc/source/code-examples/advancedexamples.rst
@@ -1242,7 +1242,7 @@ Let's see how to use them. For starters, let's define a dummy circuit with some
    circ.add(gates.M(*range(nqubits)))
 
    # visualize the circuit
-   circ.draw()
+   print(circ.draw())
 
    #  q0: ─RZ─RX─RZ─RX─RZ─o────o────────M─
    #  q1: ─RZ─RX─RZ─RX─RZ─X─RZ─X─o────o─M─

From d3dc681c797a485db092301e82b0163563a6974d Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Wed, 18 Sep 2024 09:27:23 +0000
Subject: [PATCH 39/44] Update examples/adiabatic_qml/adiabatic-qml.ipynb

---
 examples/adiabatic_qml/adiabatic-qml.ipynb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/adiabatic_qml/adiabatic-qml.ipynb b/examples/adiabatic_qml/adiabatic-qml.ipynb
index 072d02392c..0ee08d3d32 100644
--- a/examples/adiabatic_qml/adiabatic-qml.ipynb
+++ b/examples/adiabatic_qml/adiabatic-qml.ipynb
@@ -568,7 +568,7 @@
     "circ1 = rotcirc.rotations_circuit(t=0.1)\n",
     "circ2 = rotcirc.rotations_circuit(t=0.8)\n",
     "\n",
-    "print(f\"Circuit diagram: {print(circ1.draw())}\")\n",
+    "print(f\"Circuit diagram: {circ1.draw()}\")\n",
     "print(f\"\\nCirc1 params: {circ1.get_parameters()}\")\n",
     "print(f\"\\nCirc2 params: {circ2.get_parameters()}\")"
    ]

From c89f86115a522e09f8a101074487e8c05d38c4c2 Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Wed, 18 Sep 2024 09:27:52 +0000
Subject: [PATCH 40/44] Update examples/anomaly_detection/test.py

---
 examples/anomaly_detection/test.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/anomaly_detection/test.py b/examples/anomaly_detection/test.py
index 6104fa6294..043db58a0c 100644
--- a/examples/anomaly_detection/test.py
+++ b/examples/anomaly_detection/test.py
@@ -99,7 +99,7 @@ def compute_loss_test(encoder, vector):
     encoder_test = make_encoder(n_qubits, n_layers, trained_params, q_compression)
     encoder_test.compile()
     print("Circuit model summary")
-    encoder_test.draw()
+    print(encoder_test.draw())
 
     print("Computing losses...")
     # Compute loss for standard data

From f32786f467392df6de0f72a7464555ec17ba1b1d Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Wed, 18 Sep 2024 13:30:11 +0400
Subject: [PATCH 41/44] fix test

---
 examples/anomaly_detection/train.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/examples/anomaly_detection/train.py b/examples/anomaly_detection/train.py
index 0406a1f122..0f662a01f3 100644
--- a/examples/anomaly_detection/train.py
+++ b/examples/anomaly_detection/train.py
@@ -123,7 +123,7 @@ def train_step(batch_size, encoder, params, dataset):
     # Create and print encoder circuit
     encoder = make_encoder(n_qubits, n_layers, params, q_compression)
     print("Circuit model summary")
-    encoder.draw()
+    print(encoder.draw())
 
     # Define optimizer parameters
     steps_for_epoch = math.ceil(train_size / batch_size)

From e9041f63c20518b01513ac18ccff849dac0e3df7 Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Wed, 18 Sep 2024 13:31:16 +0400
Subject: [PATCH 42/44] fix test

---
 src/qibo/gates/abstract.py     | 2 +-
 src/qibo/gates/measurements.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/qibo/gates/abstract.py b/src/qibo/gates/abstract.py
index 3429cb3c8a..250c309934 100644
--- a/src/qibo/gates/abstract.py
+++ b/src/qibo/gates/abstract.py
@@ -268,7 +268,7 @@ def on_qubits(self, qubit_map) -> "Gate":
                 c.add(gates.CNOT(2, 3).on_qubits({2: 3, 3: 0})) # equivalent to gates.CNOT(3, 0)
                 c.add(gates.CNOT(2, 3).on_qubits({2: 1, 3: 3})) # equivalent to gates.CNOT(1, 3)
                 c.add(gates.CNOT(2, 3).on_qubits({2: 2, 3: 1})) # equivalent to gates.CNOT(2, 1)
-                c.draw()
+                print(c.draw())
             .. testoutput::
 
                 q0: ───X─────
diff --git a/src/qibo/gates/measurements.py b/src/qibo/gates/measurements.py
index 5e50ecf1c6..64a7a98e50 100644
--- a/src/qibo/gates/measurements.py
+++ b/src/qibo/gates/measurements.py
@@ -247,7 +247,7 @@ def on_qubits(self, qubit_map) -> "Gate":
                 c = models.Circuit(3)
                 c.add(measurement.on_qubits({0: 0, 1: 2}))
                 assert c.queue[0].result is measurement.result
-                c.draw()
+                print(c.draw())
             .. testoutput::
 
                 q0: ─M─

From 2515b242b0225cf67f9c299e5ef46891c5bc70a1 Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Wed, 18 Sep 2024 13:32:10 +0400
Subject: [PATCH 43/44] fix test

---
 examples/qfiae/qfiae_demo.ipynb | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/examples/qfiae/qfiae_demo.ipynb b/examples/qfiae/qfiae_demo.ipynb
index 04f118d5ba..50448ccd75 100644
--- a/examples/qfiae/qfiae_demo.ipynb
+++ b/examples/qfiae/qfiae_demo.ipynb
@@ -655,7 +655,7 @@
    ],
    "source": [
     "circuit_a_prob = create_circuit_a(n_qubits = 4,b_max = x_max_int, b_min = x_min_int)\n",
-    "circuit_a_prob.draw()"
+    "print(circuit_a_prob.draw())"
    ]
   },
   {
@@ -753,7 +753,7 @@
     }
    ],
    "source": [
-    "create_circuit_q(n_qubits=4,circuit_a=circuit_a_prob).draw()"
+    "print(create_circuit_q(n_qubits=4,circuit_a=circuit_a_prob).draw())"
    ]
   },
   {

From a8d007fd9e19a5b651e0e0077ba5765f8ecc0478 Mon Sep 17 00:00:00 2001
From: Renato Mello <renato.msf@gmail.com>
Date: Thu, 19 Sep 2024 04:58:05 +0000
Subject: [PATCH 44/44] Update src/qibo/models/circuit.py

Co-authored-by: Alessandro Candido <candido.ale@gmail.com>
---
 src/qibo/models/circuit.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/qibo/models/circuit.py b/src/qibo/models/circuit.py
index e356dd0214..32be6d9dc6 100644
--- a/src/qibo/models/circuit.py
+++ b/src/qibo/models/circuit.py
@@ -1269,6 +1269,7 @@ def _update_draw_matrix(self, matrix, idx, gate, gate_symbol=None):
         return matrix, idx
 
     def diagram(self, line_wrap: int = 70, legend: bool = False) -> str:
+        """Build the string representation of the circuit diagram."""
         # build string representation of gates
         matrix = [[] for _ in range(self.nqubits)]
         idx = [0] * self.nqubits