sqdtoolz 0.9.1.dev1__tar.gz → 0.9.3.dev1__tar.gz

{sqdtoolz-0.9.1.dev1 → sqdtoolz-0.9.3.dev1}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: sqdtoolz
-Version: 0.9.1.dev1
+Version: 0.9.3.dev1
 Summary: toolbox to control and run experiments
-Author-email: Prasanna Pakkiam <p.pakkiam@uq.edu.au>, Rohit Beriwal <r.beriwal@uq.edu.au>
+Author-email: Prasanna Pakkiam <p.pakkiam@uq.edu.au>, Rohit Beriwal <f20150302d@alumni.bits-pilani.ac.in>
 Project-URL: Homepage, https://github.com/sqdlab/sqdtoolz
 Keywords: control toolbox,timing
 Classifier: Development Status :: 3 - Alpha

{sqdtoolz-0.9.1.dev1 → sqdtoolz-0.9.3.dev1}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sqdtoolz"
-version = "0.9.1.dev1"
+version = "0.9.3.dev1"
 description = "toolbox to control and run experiments"
 readme = "README.md"
 requires-python = ">=3.10"
 authors = [
     { name = "Prasanna Pakkiam", email = "p.pakkiam@uq.edu.au" },
-    { name = "Rohit Beriwal", email = "r.beriwal@uq.edu.au" }
+    { name = "Rohit Beriwal", email = "f20150302d@alumni.bits-pilani.ac.in" }
 ]
 keywords = ["control toolbox", "timing"]
 

{sqdtoolz-0.9.1.dev1 → sqdtoolz-0.9.3.dev1}/sqdtoolz/Experiments/Experimental/ExpZIQASMDataViewer.py

@@ -3,6 +3,7 @@ from pathlib import Path
 import shutil
 from sqdtoolz.Utilities.FileIO import FileIOReader
 import json
+import numpy as np
 
 class ExpZIQASMDataViewer:
     def __init__(self, expziqasm_data_folder_path):
@@ -19,11 +20,14 @@ class ExpZIQASMDataViewer:
         leData = FileIOReader(file_path)
         arr = leData.get_numpy_array()
         if self._meas_params['acq_type'] == 'DISCRIMINATION':
-            arr = arr[...,0]
+            arr = np.array(arr[...,0], dtype=int)
         if arr.size == 1:
             arr = float(arr)
         return arr
 
+    def get_number_of_shots(self):
+        return self._meas_params['NumRepetitions']
+
     def get_inner_slicing_vars(self):
         match self._meas_params['acq_type']:
             case 'DISCRIMINATION':

{sqdtoolz-0.9.1.dev1 → sqdtoolz-0.9.3.dev1}/sqdtoolz/Experiments/Experimental/ExpZIqubit.py

@@ -31,6 +31,10 @@ class ExpZIqubit(Experiment):
         self._transition = kwargs.pop('transition', 'ge')
         #
         self._plot_ZI = kwargs.pop('ZI_plot', False)
+        self._skip_ZI_analysis = kwargs.pop('skip_ZI_analysis', True)
+        if self._plot_ZI:
+            #Cannot plot_ZI without executing the ZI analysis workflow...
+            self._skip_ZI_analysis = False
         self._args = kwargs
         self._show_pulse_sheet = kwargs.pop('show_pulse_sheet', False)
     
@@ -55,6 +59,8 @@ class ExpZIqubit(Experiment):
             getattr(options, 'transition')(self._transition)
         if hasattr(options, 'close_figures'):
             options.close_figures(not self._plot_ZI)
+        if hasattr(options, 'do_analysis'):
+            getattr(options, 'do_analysis')(not self._skip_ZI_analysis)
         if hasattr(options, 'cal_states'):
             #Automatically default to transition for calibration states... Note that this only matters if use_cal_traces is True...
             getattr(options, 'cal_states')( self._args.get('cal_states', self._transition) )
@@ -116,7 +122,7 @@ class ExpZIqubit(Experiment):
             #Another hack for the case where they iterate once per qubit in the experiment for a given workflow...
             if 'qubits' in zi_wfw_params and not ('qubits' in zi_exp_params) and 'qubit' in zi_exp_params:
                 execution_time *= len(leQubits)
-                qubit_kwarg = {'qubits': leQubits}
+                qubit_kwarg = {'qubits': [x.uid for x in leQubits]}
 
             if kwargs.get('print_estimated_execution_time',True):
                 print(f"Expected Runtime: {execution_time:.3f}s")

sqdtoolz-0.9.3.dev1/sqdtoolz/Utilities/DataDensityMatrix.py

@@ -0,0 +1,307 @@
+import itertools
+import numpy as np
+import scipy.optimize
+import matplotlib.pyplot as plt
+
+class DataDensityMatrix:
+    def __init__(self, density_matrix):
+        self._rho = density_matrix
+        self._num_qubits = int(np.log2(density_matrix.shape[0]))
+        self._eigs = np.linalg.eigvalsh(density_matrix)
+
+    @classmethod
+    def fromDataViewer(cls, dataviewer, dataviewer_reg='c'):
+        """
+        This assumes that the data was taken with ExpZIQASM and that the data in register
+        dataviewer_reg is structured as the Pauli ordering of measurements. For example, for
+        two qubits, it'd be II, IX, IY, IZ, XI, XX etc. So in this case it'd be such that every
+        two entries correspond to an array of qubit shots for the first and second qubit
+        respectively. If it is an I measurement, the array slot will be ignored in this analysis,
+        so it may be None.
+        """
+        data = dataviewer.get_data(dataviewer_reg)
+        num_measurements = len(data)
+        N = 0
+        while (N+1) * 4**(N+1) <= num_measurements:
+            N += 1
+        assert N*4**N==num_measurements, "The number of measurements/qubits do not correspond. For N qubits, there should be N*4^N measurements..."
+        #Assuming that data is divided into groups of N (for N qubits) for each measurement type (e.g. IXZI etc.)
+        #Also assuming that measurement of 1-state gives -1 eigenvalue for X/Y/Z...
+        measurements = [''.join(item) for item in itertools.product(['I','X','Y','Z'], repeat=N)]
+        num_shots = dataviewer.get_number_of_shots()
+        #
+        expectation_values = []
+        for m,cur_measurement in enumerate(measurements):
+            if m == 0:
+                expectation_values.append(1.0)
+                continue
+            cur_data_set = data[m*N:(m+1)*N]
+            #
+            #Calculate expectation value
+            cur_prod = np.ones(num_shots, dtype=int)
+            valid_shots = np.ones(num_shots, dtype=bool)
+            for ind, pauli in enumerate(cur_measurement):
+                if pauli == 'I':
+                    continue    #Pauli I does not contribute...
+                cur_data = cur_data_set[ind]
+                #Any F-state (i.e. 2) invalidates the entire shot
+                valid_shots &= (cur_data != 2)
+                #0 -> +1, 1 -> -1
+                cur_prod *= 1 - 2*cur_data
+            #Calculate the product across the shot +/-1 values and take mean
+            expectation = np.mean(cur_prod[valid_shots])
+            expectation_values.append(float(expectation))
+        #
+        return cls(DataDensityMatrix.estimate_rho_from_expectations(np.array(expectation_values)))
+
+    @staticmethod
+    def estimate_rho_from_expectations(expectation_values):
+        """
+        Reconstruct an N-qubit physical density matrix from expectation values
+        of all N-qubit Pauli strings.
+
+        expectation_values should contain the expectation values corresponding to
+        the Pauli strings in the ordering:
+            II...I, II...X, II...Y, II...Z, ..., ZZ...Z
+
+        i.e. the ordering generated by itertools.product(['I','X','Y','Z'], repeat=N).
+        """
+        #Number of Pauli operators = 4^N
+        n_paulis = len(expectation_values)
+        N = int(np.log2(n_paulis)/2)
+        assert 4**N == n_paulis, f"Expected 4^N expectation values, but got {n_paulis}."
+
+        I = np.eye(2, dtype=complex)
+        X = np.array([[0, 1], [1, 0]], dtype=complex)
+        Y = np.array([[0, -1j], [1j, 0]], dtype=complex)
+        Z = np.array([[1, 0], [0, -1]], dtype=complex)
+        paulis = {'I': I,'X': X,'Y': Y,'Z': Z}
+        pauli_strings = list(itertools.product(['I', 'X', 'Y', 'Z'], repeat=N))
+
+        #Create the Pauli tensor-product operators...
+        E_ops = []
+        for pauli_string in pauli_strings:
+            E = np.array([[1]], dtype=complex)
+            for p in pauli_string:
+                E = np.kron(E, paulis[p])
+            E_ops.append(E)
+
+        dim = 2**N
+        n_params = 2 * dim * dim
+
+        def params_to_rho(params):
+            #First dim^2 are real components, while second dim^2 are imaginary components
+            T_real = params[:dim**2].reshape((dim, dim))
+            T_imag = params[dim**2:].reshape((dim, dim))
+            T = T_real + 1j * T_imag
+            #Guarantee Hermitian & positive semidefiniteness
+            rho_unnorm = T.conj().T @ T
+            #Normalize trace to 1
+            trace_val = np.trace(rho_unnorm).real
+            if trace_val < 1e-12:
+                return np.eye(dim, dtype=complex) / dim  #A bit harsh - could just divide and make it positive...?
+            return rho_unnorm / trace_val
+
+        def objective_function(params):
+            rho = params_to_rho(params)
+            predicted = np.array([np.trace(rho @ E).real for E in E_ops])   #Calculate tr(rho*pauli) to get expectation value
+            return np.sum((predicted - expectation_values)**2)              #Compare with measured expectation value
+
+        init_params = np.random.uniform(-1, 1, n_params)
+        result = scipy.optimize.minimize(objective_function, init_params, method='BFGS')
+
+        reconstructed_rho = params_to_rho(result.x)
+
+        return reconstructed_rho
+
+    def get_purity(self):
+        return np.trace(self._rho @ self._rho).real
+
+    def get_fidelity_pure_state(self, target_state):
+        """
+        Fidelity between a reconstructed density matrix and a pure
+        target state given in the usual computational basis.
+
+        Parameters
+        ----------
+        target_state : ndarray, shape (2^N)
+            Target pure state |psi>. Does not need to be normalized;
+            it will be normalized internally.
+
+        Returns
+        -------
+        float
+            State fidelity in [0, 1].
+        """
+        psi = np.asarray(target_state, dtype=complex).reshape(-1)
+        assert self._rho.shape[0] == len(psi), "Target_state dimension must match density matrix size."
+        psi_norm = np.linalg.norm(psi)
+        assert psi_norm > 0, "Target_state must be non-zero in magnitude."
+        psi = psi / psi_norm
+
+        #Don't need to use Uhlmann fidelity here. Just go <psi|rho|psi>
+        F = np.vdot(psi, self._rho @ psi)
+        F = float(np.real_if_close(F))
+        return float(np.clip(F, 0.0, 1.0))
+
+
+    def plot3D(self, target_state=None, use_abs_phase=False):
+        """
+        Plot the real part of the density matrix as a 3D bar plot.
+
+        The reconstructed density matrix is taken from self._rho and the
+        number of qubits from self._num_qubits.
+
+        Parameters
+        ----------
+        target_state : array-like, optional
+            Target pure state vector |psi>. If provided, its density matrix
+            |psi><psi| is shown as transparent red bars underneath the
+            reconstructed state.
+        use_abs_phase : bool
+            If True, then the two plots will be magnitude/phase instead of
+            real/imag...
+
+        Notes
+        -----
+        Computational basis states are shown on both axes.
+
+        Colors:
+            Blue  = reconstructed state
+            Red   = target state
+            Purple = overlap between target and reconstructed state
+        """
+
+        # ------------------------------------------------------------------
+        # Validate reconstructed density matrix
+        # ------------------------------------------------------------------
+        rho = np.asarray(self._rho, dtype=complex)
+        n_qubits = self._num_qubits
+        dim = 2 ** n_qubits
+
+        target_rho = None
+        if target_state is not None:
+            psi = np.asarray(target_state, dtype=complex).reshape(-1)
+            assert self._rho.shape[0] == len(psi), "Target_state dimension must match density matrix size."
+            psi_norm = np.linalg.norm(psi)
+            assert psi_norm > 0, "Target_state must be non-zero in magnitude."
+            psi = psi / psi_norm
+            target_rho = np.outer(psi, psi.conj())
+
+        basis_labels = [rf"$|{i:0{n_qubits}b}\rangle$" for i in range(dim)]
+
+        xpos, ypos = np.meshgrid(np.arange(dim), np.arange(dim))
+        xpos = xpos.flatten()
+        ypos = ypos.flatten()
+        zpos = np.zeros_like(xpos, dtype=float)
+
+        dx = dy = 0.7
+
+        if use_abs_phase:
+            actual_vals = [np.abs(rho).flatten(), np.angle(rho).flatten()]
+            z_labels = ['Magnitude', 'Argument']
+        else:
+            actual_vals = [np.real(rho).flatten(), np.imag(rho).flatten()]
+            z_labels = ['Real part', 'Imag part']
+        if target_rho is not None:
+            if use_abs_phase:
+                target_vals = [np.abs(target_rho).flatten(), np.angle(target_rho).flatten()]
+            else:
+                target_vals = [np.real(target_rho).flatten(), np.imag(target_rho).flatten()]
+
+        fig = plt.figure(); fig.set_figwidth(12); fig.set_figheight(10)
+        axs = [None, None]
+        axs[0] = fig.add_subplot(1, 2, 1, projection="3d")
+        axs[1] = fig.add_subplot(1, 2, 2, projection="3d")
+        #Hack on the position of the title; may not work for more than 2 qubits?
+        if target_rho is None:
+            fig.suptitle(f"Density matrix", y=0.7)
+        else:
+            fig.suptitle(f"Density matrix\nblue = reconstructed, red = target, purple = overlap", y=0.7)
+
+        for m,ax in enumerate(axs):
+            if target_rho is not None:
+                ax.bar3d(xpos, ypos, zpos, dx, dy, target_vals[m], color="red", alpha=0.10, shade=False)
+            ax.bar3d(xpos, ypos, zpos, dx, dy, actual_vals[m], color="steelblue", alpha=0.75, shade=True)
+
+            ax.set_box_aspect(None, zoom=0.85)   #Hack to get z-axis labels to appear in frame...
+            ax.set_xticks(np.arange(dim) + dx / 2)
+            ax.set_yticks(np.arange(dim) + dy / 2)
+            ax.set_xticklabels(basis_labels, rotation=45, ha="right")
+            ax.set_yticklabels(basis_labels, rotation=-45, ha="left")
+            ax.set_xlabel("Column basis state", labelpad=15)
+            ax.set_ylabel("Row basis state", labelpad=15)
+            ax.set_zlabel(z_labels[m])
+
+            max_val = np.max(np.abs(actual_vals[m]))
+            if target_rho is not None:
+                max_val = max(max_val, np.max(np.abs(target_vals[m])))
+            max_val = max(max_val, 1e-12)
+            if m == 0 and use_abs_phase:
+                ax.set_zlim(0, 1.1 * max_val)
+            else:
+                ax.set_zlim(-1.1 * max_val, 1.1 * max_val)
+            ax.view_init(elev=25, azim=-55)
+        fig.tight_layout()
+
+    @staticmethod
+    def generate_tomography_qasm(state_prep, num_qubits, qasm_header_str=None, save=None, qasm_include="stdgates_transmon_fixed_coupler.inc"):
+        '''
+        Generates a QASM script which does full N-qubit tomography
+        for a given state_prep, which is a string containing a QASM script for preparation
+        of a target state (for example, a two qubit Bell state).
+
+        The tomography is ordered such that the bases are measured according to the standard
+        arrangement of Pauli matrices: 
+            II...I, II...X, II...Y, II...Z, ..., ZZ...Z
+        
+        The start of the QASM script, with the include file, and the register setup. Defaults to:
+            f"""OPENQASM 3;
+            include "{qasm_include}";
+
+            bit[{((num_qubits*4)**num_qubits)/2}] c;
+            qubit[{num_qubits}] q;
+            """
+        
+        The qasm script is returned as a string, or can be saved as a file by passing a
+        filename to the save argument, for example: save="test.qasm".
+        '''
+        assert isinstance(num_qubits, int)
+        assert isinstance(state_prep, str)
+        #
+        N = int(num_qubits)
+        if qasm_header_str is None:
+            qasm_str = f'OPENQASM 3;\ninclude "{qasm_include}";\n\nbit[{int(((N*4)**N)/2)}] c;\nqubit[{N}] q;\n'
+        else:
+            qasm_str = qasm_header_str
+        
+        paulis = sorted({'I', 'X', 'Y', 'Z'})
+        pauli_combinations = list(itertools.product(paulis, repeat=N))
+        # imports, register etc.
+        for m, bases in enumerate(pauli_combinations):
+            assert len(bases)==N
+            qasm_str += f"\n//"
+            for b in range(N):
+                qasm_str += f"{bases[b]}"
+            qasm_str += "\n" + state_prep + "delay[0] q;\n"
+            # do rotations to measure different bases
+            for q in range(N):
+                if bases[q]=='X':
+                    qasm_str += f"ry(-pi/2) q[{q}];\n"
+                if bases[q]=='Y':
+                    qasm_str += f"rx(pi/2) q[{q}];\n"
+            # add delay before measurements 
+            qasm_str += "delay[0] q;\n"
+            # measures
+            for c in range(N):
+                if bases[c] != 'I':
+                    qasm_str += f"c[{m*N + c}] = measure q[{c}];\n"
+
+        if save is not None: 
+            assert isinstance(save, str)
+            if not save.endswith(".qasm"):
+                save += ".qasm"
+            with open(save, "w") as f:
+                f.write(qasm_str)
+
+        return qasm_str