iqm-benchmarks 2.44__py3-none-any.whl → 2.45__py3-none-any.whl

mGST/low_level_jit.py

@@ -104,8 +104,8 @@ def contract(X, j_vec):
     return res
 
 
-@njit(cache=True, fastmath=True, parallel=True)
-def objf(X, E, rho, J, y):
+@njit(cache=True, fastmath=True)  # , parallel=True)
+def objf(X, E, rho, J, y, mle=False):
     """Calculate the objective function value for matrices, POVM elements, and target values.
 
     This function computes the objective function value based on input matrices X, POVM elements E,
@@ -123,6 +123,8 @@ def objf(X, E, rho, J, y):
         A 2D array representing the indices for which the objective function will be evaluated.
     y : numpy.ndarray
         A 2D array of shape (n_povm, len(J)) containing the target values.
+    mle : bool
+        If True, the log-likelihood objective function is used, otherwise the least squares objective function is used
 
     Returns
     -------
@@ -139,8 +141,11 @@ def objf(X, E, rho, J, y):
         for ind in j[::-1]:
             state = X[ind] @ state
         for o in range(n_povm):
-            objf_ += abs(E[o].conj() @ state - y[o, i]) ** 2
-    return objf_ / m / n_povm
+            if mle:
+                objf_ -= np.log(abs(E[o].conj() @ state)) * y[o, i]
+            else:
+                objf_ += abs(E[o].conj() @ state - y[o, i]) ** 2 / m / n_povm
+    return objf_
 
 
 @njit(cache=True)
@@ -242,8 +247,8 @@ def Mp_norm_lower(X_true, E_true, rho_true, X, E, rho, J, n_povm, p):
     return dist ** (1 / p) / m / n_povm, max_dist ** (1 / p)
 
 
-@njit(cache=True, parallel=True)
-def dK(X, K, E, rho, J, y, d, r, rK):
+@njit(cache=True)  # , parallel=True)
+def dK(X, K, E, rho, J, y, d, r, rK, mle=False):
     """Compute the derivative of the objective function with respect to the Kraus tensor K.
 
     This function calculates the derivative of the Kraus operator K, based on the
@@ -269,6 +274,8 @@ def dK(X, K, E, rho, J, y, d, r, rK):
         The rank of the problem.
     rK : int
         The number of rows in the reshaped Kraus operator K.
+    mle : bool
+        If True, the log-likelihood objective function is used, otherwise the least squares objective function is used
 
     Returns
     -------
@@ -296,13 +303,29 @@ def dK(X, K, E, rho, J, y, d, r, rK):
                         L = E[o].conj()
                         for ind in j[:i]:
                             L = L @ X[ind]
-                        D_ind = L @ X[k] @ R - y[o, n]
-                        dK_[k] += D_ind * K[k].conj() @ np.kron(L.reshape(pdim, pdim).T, R.reshape(pdim, pdim).T)
-    return dK_.reshape(d, rK, pdim, pdim) * 2 / m / n_povm
-
-
-@njit(cache=True, parallel=False)
-def dK_dMdM(X, K, E, rho, J, y, d, r, rK):
+                        if mle:
+                            p_ind = L @ X[k] @ R
+                            dK_[k] -= (
+                                K[k].conj()
+                                @ np.kron(L.reshape(pdim, pdim).T, R.reshape(pdim, pdim).T)
+                                * y[o, n]
+                                / p_ind
+                            )
+                        else:
+                            D_ind = L @ X[k] @ R - y[o, n]
+                            dK_[k] += (
+                                D_ind
+                                * K[k].conj()
+                                @ np.kron(L.reshape(pdim, pdim).T, R.reshape(pdim, pdim).T)
+                                * 2
+                                / m
+                                / n_povm
+                            )
+    return dK_.reshape(d, rK, pdim, pdim)
+
+
+@njit(cache=True)  # , parallel=False)
+def dK_dMdM(X, K, E, rho, J, y, d, r, rK, mle=False):
     """Compute the derivatives of the objective function with respect to K and the
     product of derivatives of the measurement map with respect to K.
 
@@ -329,6 +352,8 @@ def dK_dMdM(X, K, E, rho, J, y, d, r, rK):
         The number of rows for the matrix K.
     rK : int
         The number of columns for the matrix K.
+    mle : bool
+        If True, the log-likelihood objective function is used, otherwise the least squares objective function is used
 
     Returns
     -------
@@ -346,24 +371,40 @@ def dK_dMdM(X, K, E, rho, J, y, d, r, rK):
     for n in range(m):
         j = J[n][J[n] >= 0]
         dM = np.ascontiguousarray(np.zeros((n_povm, d, rK, r)).astype(np.complex128))
-        for i, _ in enumerate(j):
-            k = j[i]
-            C = contract(X, j[:i])
-            R = contract(X, j[i + 1 :]) @ rho
-            for o in range(n_povm):
-                L = E[o].conj() @ C
-                D_ind = L @ X[k] @ R - y[o, n]
+        p_ind_array = np.zeros(n_povm).astype(np.complex128)
+        for o in range(n_povm):
+            for i, k in enumerate(j):
+                R = rho.copy()
+                for ind in j[i + 1 :][::-1]:
+                    R = X[ind] @ R
+                L = E[o].conj().copy()
+                for ind in j[:i]:
+                    L = L @ X[ind]
                 dM_loc = K[k].conj() @ np.kron(L.reshape((pdim, pdim)).T, R.reshape((pdim, pdim)).T)
-                dM[o, k, :, :] += dM_loc
-                dK_[k] += D_ind * dM_loc
+                p_ind = L @ X[k] @ R
+                if mle:
+                    dM[o, k] += dM_loc
+                    dK_[k] -= dM_loc * y[o, n] / p_ind
+                else:
+                    dM[o, k] += dM_loc
+                    D_ind = p_ind - y[o, n]
+                    dK_[k] += D_ind * dM_loc * 2 / m / n_povm
+            if len(j) == 0:
+                p_ind_array[o] = E[o].conj() @ rho
+            else:
+                p_ind_array[o] = p_ind
         for o in range(n_povm):
-            dM11 += np.kron(dM[o].conj().reshape(-1), dM[o].reshape(-1))
-            dM10 += np.kron(dM[o].reshape(-1), dM[o].reshape(-1))
-    return (dK_.reshape((d, rK, pdim, pdim)) * 2 / m / n_povm, 2 * dM10 / m / n_povm, 2 * dM11 / m / n_povm)
+            if mle:
+                dM11 += np.kron(dM[o].conj().reshape(-1), dM[o].reshape(-1)) * y[o, n] / p_ind_array[o] ** 2
+                dM10 += np.kron(dM[o].reshape(-1), dM[o].reshape(-1)) * y[o, n] / p_ind_array[o] ** 2
+            else:
+                dM11 += np.kron(dM[o].conj().reshape(-1), dM[o].reshape(-1)) * 2 / m / n_povm
+                dM10 += np.kron(dM[o].reshape(-1), dM[o].reshape(-1)) * 2 / m / n_povm
+    return (dK_.reshape((d, rK, pdim, pdim)), dM10, dM11)
 
 
-@njit(cache=True, parallel=False)
-def ddM(X, K, E, rho, J, y, d, r, rK):
+@njit(cache=True)  # , parallel=False)
+def ddM(X, K, E, rho, J, y, d, r, rK, mle=False):
     """Compute the second derivative of the objective function with respect to the Kraus tensor K.
 
     This function calculates the second derivative of the objective function for a given
@@ -389,6 +430,8 @@ def ddM(X, K, E, rho, J, y, d, r, rK):
         Dimension of the local basis.
     rK : int
         Number of rows in the Kraus operator matrix.
+    mle : bool
+        If True, the log-likelihood objective function is used, otherwise the least squares objective function is used
 
     Returns
     -------
@@ -421,11 +464,12 @@ def ddM(X, K, E, rho, J, y, d, r, rK):
                             for o in range(n_povm):
                                 L = E[o].conj() @ L0
                                 if i1 == i2:
-                                    D_ind = L @ X[k1] @ R - y[o, n]
+                                    p_ind = L @ X[k1] @ R
                                 elif i1 < i2:
-                                    D_ind = L @ X[k1] @ C.reshape(r, r) @ X[k2] @ R - y[o, n]
+                                    p_ind = L @ X[k1] @ C.reshape(r, r) @ X[k2] @ R
                                 else:
-                                    D_ind = L @ X[k2] @ C.reshape(r, r) @ X[k1] @ R - y[o, n]
+                                    p_ind = L @ X[k2] @ C.reshape(r, r) @ X[k1] @ R
+                                D_ind = p_ind - y[o, n]
 
                                 ddK_loc = np.zeros((rK**2, r, r)).astype(np.complex128)
                                 dconjdK_loc = np.zeros((rK**2, r, r)).astype(np.complex128)
@@ -479,16 +523,19 @@ def ddM(X, K, E, rho, J, y, d, r, rK):
                                                 .reshape(pdim, pdim, pdim, pdim)
                                                 .transpose(2, 0, 1, 3)
                                             ).reshape(r, r)
-
-                                ddK[k1 * d + k2] += D_ind * ddK_loc
-                                dconjdK[k1 * d + k2] += D_ind * dconjdK_loc
+                                if mle:
+                                    ddK[k1 * d + k2] -= ddK_loc * y[o, n] / p_ind
+                                    dconjdK[k1 * d + k2] -= dconjdK_loc * y[o, n] / p_ind
+                                else:
+                                    ddK[k1 * d + k2] += D_ind * ddK_loc * 2 / m / n_povm
+                                    dconjdK[k1 * d + k2] += D_ind * dconjdK_loc * 2 / m / n_povm
     return (
-        ddK.reshape(d, d, rK, rK, pdim, pdim, pdim, pdim) * 2 / m / n_povm,
-        dconjdK.reshape(d, d, rK, rK, pdim, pdim, pdim, pdim) * 2 / m / n_povm,
+        ddK.reshape(d, d, rK, rK, pdim, pdim, pdim, pdim),
+        dconjdK.reshape(d, d, rK, rK, pdim, pdim, pdim, pdim),
     )
 
 
-@njit(parallel=True, cache=True)
+@njit(cache=True)  # , parallel=True)
 def dA(X, A, B, J, y, r, pdim, n_povm):
     """Compute the derivative of to the objective function with respect to the POVM tensor A
 
@@ -526,7 +573,8 @@ def dA(X, A, B, J, y, r, pdim, n_povm):
     rho = (B @ B.T.conj()).reshape(-1)
     dA_ = np.zeros((n_povm, pdim, pdim)).astype(np.complex128)
     m = len(J)
-    for n in prange(m):  # pylint: disable=not-an-iterable
+    # pylint: disable=not-an-iterable
+    for n in prange(m):
         j = J[n][J[n] >= 0]
         inner_deriv = contract(X, j) @ rho
         dA_step = np.zeros((n_povm, pdim, pdim)).astype(np.complex128)
@@ -537,7 +585,7 @@ def dA(X, A, B, J, y, r, pdim, n_povm):
     return dA_ * 2 / m / n_povm
 
 
-@njit(parallel=True, cache=True)
+@njit(cache=True)  # , parallel=True)
 def dB(X, A, B, J, y, pdim):
     """Compute the derivative of the objective function with respect to the state tensor B.
 
@@ -577,8 +625,8 @@ def dB(X, A, B, J, y, pdim):
     return dB_
 
 
-@njit(parallel=True, cache=True)
-def ddA_derivs(X, A, B, J, y, r, pdim, n_povm):
+@njit(cache=True)  # , parallel=True)
+def ddA_derivs(X, A, B, J, y, r, pdim, n_povm, mle=False):
     """Calculate all nonzero terms of the second derivatives with respect to the POVM tensor A.
 
     Parameters
@@ -599,6 +647,8 @@ def ddA_derivs(X, A, B, J, y, r, pdim, n_povm):
         The dimension of the input matrices A and B.
     n_povm : int
         The number of POVM elements.
+    mle : bool
+        If True, the log-likelihood objective function is used, otherwise the least squares objective function is used
 
     Returns
     -------
@@ -629,21 +679,32 @@ def ddA_derivs(X, A, B, J, y, r, pdim, n_povm):
         dMconjdM_step = np.zeros((n_povm, r, r)).astype(np.complex128)
         dconjdA_step = np.zeros((n_povm, r, r)).astype(np.complex128)
         for o in range(n_povm):
-            D_ind = E[o].conj() @ R - y[o, n]
             dM = A[o].conj() @ R.reshape(pdim, pdim).T
-            dMdM_step[o] += np.outer(dM, dM)
-            dMconjdM_step[o] += np.outer(dM.conj(), dM)
-            dA_step[o] += D_ind * dM
-            dconjdA_step[o] += D_ind * np.kron(np.eye(pdim).astype(np.complex128), R.reshape(pdim, pdim).T)
+            if mle:
+                p_ind = E[o].conj() @ R
+                dMdM_step[o] += np.outer(dM, dM) * y[o, n] / p_ind**2
+                dMconjdM_step[o] += np.outer(dM.conj(), dM) * y[o, n] / p_ind**2
+                dA_step[o] -= dM * y[o, n] / p_ind
+                dconjdA_step[o] -= (
+                    np.kron(np.eye(pdim).astype(np.complex128), R.reshape(pdim, pdim).T) * y[o, n] / p_ind
+                )
+            else:
+                D_ind = E[o].conj() @ R - y[o, n]
+                dMdM_step[o] += np.outer(dM, dM) * 2 / m / n_povm
+                dMconjdM_step[o] += np.outer(dM.conj(), dM) * 2 / m / n_povm
+                dA_step[o] += D_ind * dM * 2 / m / n_povm
+                dconjdA_step[o] += (
+                    D_ind * np.kron(np.eye(pdim).astype(np.complex128), R.reshape(pdim, pdim).T) * 2 / m / n_povm
+                )
         dA_ += dA_step
         dMdM += dMdM_step
         dMconjdM += dMconjdM_step
         dconjdA += dconjdA_step
-    return dA_ * 2 / m / n_povm, dMdM * 2 / m / n_povm, dMconjdM * 2 / m / n_povm, dconjdA * 2 / m / n_povm
+    return dA_, dMdM, dMconjdM, dconjdA
 
 
-@njit(parallel=True, cache=True)
-def ddB_derivs(X, A, B, J, y, r, pdim):
+@njit(cache=True)  # , parallel=True)
+def ddB_derivs(X, A, B, J, y, r, pdim, mle=False):
     """Calculate all nonzero terms of the second derivative with respect to the state tensor B.
 
     Parameters
@@ -690,12 +751,17 @@ def ddB_derivs(X, A, B, J, y, r, pdim):
         C = contract(X, j)
         for o in range(n_povm):
             L = E[o].conj() @ C
-            D_ind = L @ rho - y[o, n]
-
             dM = L.reshape(pdim, pdim) @ B.conj()
-            dMdM += np.outer(dM, dM)
-            dMconjdM += np.outer(dM.conj(), dM)
-
-            dB_ += D_ind * dM
-            dconjdB += D_ind * np.kron(L.reshape(pdim, pdim), np.eye(pdim).astype(np.complex128))
-    return dB_ * 2 / m / n_povm, dMdM * 2 / m / n_povm, dMconjdM * 2 / m / n_povm, dconjdB.T * 2 / m / n_povm
+            if mle:
+                p_ind = L @ rho
+                dMdM += np.outer(dM, dM) * y[o, n] / p_ind**2
+                dMconjdM += np.outer(dM.conj(), dM) * y[o, n] / p_ind**2
+                dB_ -= dM * y[o, n] / p_ind
+                dconjdB -= np.kron(L.reshape(pdim, pdim), np.eye(pdim).astype(np.complex128)) * y[o, n] / p_ind
+            else:
+                D_ind = L @ rho - y[o, n]
+                dMdM += np.outer(dM, dM) * 2 / m / n_povm
+                dMconjdM += np.outer(dM.conj(), dM) * 2 / m / n_povm
+                dB_ += D_ind * dM * 2 / m / n_povm
+                dconjdB += D_ind * np.kron(L.reshape(pdim, pdim), np.eye(pdim).astype(np.complex128)) * 2 / m / n_povm
+    return dB_, dMdM, dMconjdM, dconjdB.T

mGST/optimization.py

@@ -95,7 +95,7 @@ def update_K_geodesic(K, H, a):
     return K_new.reshape(d, rK, pdim, pdim)
 
 
-def lineobjf_isom_geodesic(a, H, K, E, rho, J, y):
+def lineobjf_isom_geodesic(a, H, K, E, rho, J, y, mle):
     """Compute objective function at position on geodesic
 
     Parameters
@@ -115,6 +115,8 @@ def lineobjf_isom_geodesic(a, H, K, E, rho, J, y):
     y : numpy array
         2D array of measurement outcomes for sequences in J;
         The columns contain the outcome probabilities for different povm elements
+    mle : bool
+        If True, the log-likelihood objective function is used, otherwise the least squares objective function is used
 
     Returns
     -------
@@ -126,7 +128,7 @@ def lineobjf_isom_geodesic(a, H, K, E, rho, J, y):
     r = pdim**2
     K_test = update_K_geodesic(K, H, a)
     X_test = np.einsum("ijkl,ijnm -> iknlm", K_test, K_test.conj()).reshape((d, r, r))
-    return objf(X_test, E, rho, J, y)
+    return objf(X_test, E, rho, J, y, mle=mle)
 
 
 def update_A_geodesic(A, H, a):
@@ -196,7 +198,7 @@ def update_B_geodesic(B, H, a):
     return B_temp.reshape(pdim, pdim)
 
 
-def lineobjf_A_geodesic(a, H, X, A, rho, J, y):
+def lineobjf_A_geodesic(a, H, X, A, rho, J, y, mle=False):
     """Compute objective function at position on geodesic for POVM parametrization
 
     Parameters
@@ -216,6 +218,8 @@ def lineobjf_A_geodesic(a, H, X, A, rho, J, y):
     y : numpy array
         2D array of measurement outcomes for sequences in J;
         The columns contain the outcome probabilities for different povm elements
+    mle : bool
+        If True, the log-likelihood objective function is used, otherwise the least squares objective function is used
 
     Returns
     -------
@@ -225,10 +229,10 @@ def lineobjf_A_geodesic(a, H, X, A, rho, J, y):
     n_povm = A.shape[0]
     A_test = update_A_geodesic(A, H, a)
     E_test = np.array([(A_test[i].T.conj() @ A_test[i]).reshape(-1) for i in range(n_povm)])
-    return objf(X, E_test, rho, J, y)
+    return objf(X, E_test, rho, J, y, mle=mle)
 
 
-def lineobjf_B_geodesic(a, H, X, E, B, J, y):
+def lineobjf_B_geodesic(a, H, X, E, B, J, y, mle=False):
     """Compute objective function at position on geodesic for the initial state parametrization
 
     Parameters
@@ -248,6 +252,8 @@ def lineobjf_B_geodesic(a, H, X, E, B, J, y):
     y : numpy array
         2D array of measurement outcomes for sequences in J;
         The columns contain the outcome probabilities for different povm elements
+    mle : bool
+        If True, the log-likelihood objective function is used, otherwise the least squares objective function is used
 
     Returns
     -------
@@ -256,7 +262,7 @@ def lineobjf_B_geodesic(a, H, X, E, B, J, y):
     """
     B_test = update_B_geodesic(B, H, a)
     rho_test = (B_test @ B_test.T.conj()).reshape(-1)
-    return objf(X, E, rho_test, J, y)
+    return objf(X, E, rho_test, J, y, mle=mle)
 
 
 def lineobjf_A_B(a, v, delta_v, X, C, y, J, argument):

mGST/qiskit_interface.py

@@ -9,9 +9,7 @@ from qiskit.circuit.library import IGate
 from qiskit.quantum_info import Operator
 
 from iqm.qiskit_iqm import IQMCircuit as QuantumCircuit
-from mGST import additional_fns, algorithm, low_level_jit
-from mGST.compatibility import arrays_to_pygsti_model
-from mGST.reporting.reporting import gauge_opt, quick_report
+from mGST import low_level_jit
 
 
 def qiskit_gate_to_operator(gate_set):
@@ -131,6 +129,69 @@ def get_qiskit_circuits(gate_sequences, gate_set, n_qubits, active_qubits):
     return qiskit_circuits
 
 
+def get_composed_qiskit_circuits(gate_sequences, gate_set, n_qubits, qubit_layouts, gate_context=None, parallel=False):
+    """Turn GST sequences into Qiskit circuits, adding context gates if provided.
+
+    For each GST sequence, either a single circuit is created for all qubit layouts if `parallel=True`, or a separate circuit if
+    `parallel=False`.
+
+    Parameters
+    ----------
+    gate_sequences : list of list of int
+        Sequences of gate indices to apply. Each integer corresponds to a gate in the gate_set.
+    gate_set : list
+        The gate set defined as a list of Qiskit quantum circuits.
+    n_qubits : int
+        Total number of qubits in the system.
+    qubit_layouts : list of list of int
+        Lists of qubits on which the GST experiment is run.
+    gate_context : QuantumCircuit or list of QuantumCircuit, optional
+        Optional context circuit(s) to apply during each gate on qubits that are not measured for GST.
+    parallel : bool, optional
+        Whether GST for all qubits layouts is done in parallel on the backend.
+        If True, applies gates to all qubit layouts in a single circuit.
+        If False, creates separate circuits for each layout. Default is False.
+
+    Returns
+    -------
+    list or list of list of QuantumCircuit
+        If parallel=True: A list of QuantumCircuits, one for each gate sequence.
+        If parallel=False: A list of lists of QuantumCircuits, where the outer list corresponds
+        to qubit layouts and the inner list corresponds to gate sequences.
+    """
+    if gate_context is not None and not isinstance(gate_context, list):
+        gate_context = [gate_context] * len(gate_set)
+    qiskit_circuits = []
+    if parallel:
+        all_qubits = [q for qubits in qubit_layouts for q in qubits]
+        all_clbits = [i for i, _ in enumerate(all_qubits)]
+        for gate_sequence in gate_sequences:
+            qc = QuantumCircuit(n_qubits, len(all_clbits))
+            for gate_num in gate_sequence:
+                if gate_context is not None:
+                    qc.compose(gate_context[gate_num], inplace=True)
+                for qubits in qubit_layouts:
+                    qc.compose(gate_set[gate_num], qubits, inplace=True)
+                qc.barrier()
+            qc.measure(all_qubits, all_clbits)
+            qiskit_circuits.append(qc)
+    else:
+        for qubits in qubit_layouts:
+            clbits = [i for i, _ in enumerate(qubits)]
+            layout_circuits = []
+            for gate_sequence in gate_sequences:
+                qc = QuantumCircuit(n_qubits, len(clbits))
+                for gate_num in gate_sequence:
+                    if gate_context is not None:
+                        qc.compose(gate_context[gate_num], inplace=True)
+                    qc.compose(gate_set[gate_num], qubits, inplace=True)
+                    qc.barrier()
+                qc.measure(qubits, clbits)
+                layout_circuits.append(qc)
+            qiskit_circuits.append(layout_circuits)
+    return qiskit_circuits
+
+
 def get_gate_sequence(sequence_number, sequence_length, gate_set_length):
     """Generate a set of random gate sequences.
 
@@ -196,87 +257,3 @@ def job_counts_to_mgst_format(active_qubits, n_povm, result_dict):
         y.append(row / np.sum(row))
     y = np.array(y).T
     return y
-
-
-def get_gate_estimation(gate_set, gate_sequences, sequence_results, shots, rK=4):
-    """Estimate quantum gates using a modified Gate Set Tomography (mGST) algorithm.
-
-    This function simulates quantum gates, applies noise, and then uses the mGST algorithm
-    to estimate the gates. It calculates and prints the Mean Variation Error (MVE) of the
-    estimation.
-
-    Parameters
-    ----------
-    gate_set : array_like
-        The set of quantum gates to be estimated.
-    gate_sequences : array_like
-        The sequences of gates applied in the quantum circuit.
-    sequence_results : array_like
-        The results of executing the gate sequences.
-    shots : int
-        The number of shots (repetitions) for each measurement.
-    """
-
-    K_target = qiskit_gate_to_operator(gate_set)
-    gate_set_length = len(gate_set)
-    pdim = K_target.shape[-1]  # Physical dimension
-    r = pdim**2  # Matrix dimension of gate superoperators
-    n_povm = pdim  # Number of POVM elements
-    sequence_length = gate_sequences.shape[0]
-
-    X_target = np.einsum("ijkl,ijnm -> iknlm", K_target, K_target.conj()).reshape(
-        (gate_set_length, pdim**2, pdim**2)
-    )  # tensor of superoperators
-
-    # Initial state |0>
-    rho_target = (
-        np.kron(additional_fns.basis(pdim, 0).T.conj(), additional_fns.basis(pdim, 0)).reshape(-1).astype(np.complex128)
-    )
-
-    # Computational basis measurement:
-    E_target = np.array(
-        [
-            np.kron(additional_fns.basis(pdim, i).T.conj(), additional_fns.basis(pdim, i)).reshape(-1)
-            for i in range(pdim)
-        ]
-    ).astype(np.complex128)
-    target_mdl = arrays_to_pygsti_model(X_target, E_target, rho_target, basis="std")
-
-    K_init = additional_fns.perturbed_target_init(X_target, rK)
-
-    bsize = 30 * pdim  # Batch size for optimization
-    _, X, E, rho, _ = algorithm.run_mGST(
-        sequence_results,
-        gate_sequences,
-        sequence_length,
-        gate_set_length,
-        r,
-        rK,
-        n_povm,
-        bsize,
-        shots,
-        method="SFN",
-        max_inits=10,
-        max_iter=100,
-        final_iter=50,
-        target_rel_prec=1e-4,
-        init=[K_init, E_target, rho_target],
-    )
-
-    # Output the final mean variation error
-    mean_var_error = additional_fns.MVE(
-        X_target, E_target, rho_target, X, E, rho, gate_set_length, sequence_length, n_povm
-    )[0]
-    print(f"Mean variation error:", mean_var_error)
-    print(f"Optimizing gauge...")
-    weights = dict({f"G%i" % i: 1 for i in range(gate_set_length)}, **{"spam": 1})
-    X_opt, E_opt, rho_opt = gauge_opt(X, E, rho, target_mdl, weights)
-    print("Compressive GST routine complete")
-
-    # Making sense of the outcomes
-    df_g, df_o = quick_report(X_opt, E_opt, rho_opt, gate_sequences, sequence_results, target_mdl)
-    print("First results:")
-    print(df_g.to_string())
-    print(df_o.T.to_string())
-
-    return X_opt, E_opt, rho_opt