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

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