qflux 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

qflux/closed_systems/VarQTE.py

@@ -0,0 +1,433 @@
+import numpy as np
+import numpy.typing as npt
+from typing import List, Optional, Tuple
+
+from qiskit import QuantumCircuit
+from qiskit.primitives import Estimator
+from qiskit.quantum_info import SparsePauliOp
+from qiskit.providers.aer.noise import NoiseModel
+from qiskit.providers.fake_provider import FakeSherbrooke
+
+
+# To change the ansatz, apply_param and measure_der must both be modified.
+def apply_param(
+    params: npt.NDArray[np.float_], i: int, qc: QuantumCircuit, N: int
+) -> None:
+    """Apply parameter i to the quantum circuit currently constructing the ansatz.
+        The ansatz must be built in a peicewise manner to allow for hadamard tests
+        of the generators of the parameters to later be inserted to measure the A_ij
+        and C_i matrix elements.
+
+    Args:
+        params (numpy.array): An array containing the values of all the ansatz parameters.
+        parameter (int): Index of the parameter being applied.
+        qc (QuantumCircuit): The qiskit ansatz quantum circuit currently being constructed.
+        N (int): Number of qubits
+    """
+    qc.rx(params[i], i % N))
+    if i % N == N - 1 and i != len(params) - 1:
+        for i in range(N - 1):
+            qc.cz(i, i + 1)
+
+
+def measure_der(i: int, qc: QuantumCircuit, N: int) -> None:
+    """Append a Hadamard test to the circuit to measure the generator of parameter i in the ansatz.
+        The ansatz currently used is simply the two-local ansatz with only rx gates.
+        Therefore the generator is only x-gates on the corresponding qubit.
+
+    Args:
+        parameter (int): The index of the parameter whose generator will be measured.
+        qc (QuantumCircuit): The qiskit quantum circuit which is in the process of assembling the ansatz.
+        N (int): Number of qubits
+    """
+    qc.cx(N, i % N)
+
+
+def A_Circuit(params: npt.NDArray[np.float_], i: int, j: int, N: int) -> QuantumCircuit:
+    """Constructs the qiskit quantum circuits used to measure each element of the A_ij matrix.
+
+    Args:
+        params (numpy.array): A numpy array containing the values of each parameter of the ansatz.
+        i (int): The index from A_ij.  This also corresponds to the ansatz parameter i being measured.
+        j (int): The index from A_ij.  This also corresponds to the ansatz parameter j being measured.
+        N (int): The number of qubits.
+
+    Returns:
+        QuantumCircuit: The quantum circuit for an element of the A_ij matrix, in the form of a
+            hadamard test of the generators of parameters i and j.  The value of the A_ij matrix
+            can be found by measuring the ancilla qubit (qubit N) in the Z basis.
+    """
+    qc = QuantumCircuit(N + 1, 1)
+    qc.h(N)
+    for parameter in range(len(params)):  # Apply parameterized gates
+        if parameter == i:
+            qc.x(N)
+            measure_der(parameter, qc, N)  # Measure generator for i
+            qc.x(N)
+        if parameter == j:
+            measure_der(parameter, qc, N)  # Measure second generator for j
+        apply_param(params, parameter, qc, N)
+    qc.h(N)
+    return qc
+
+
+def Measure_A(
+    init_circ: QuantumCircuit,
+    params: npt.NDArray[np.float_],
+    N: int,
+    shots: int = 2**10,
+    noisy: bool = False,
+) -> npt.NDArray[np.float_]:
+    """Create the A_ij matrix through measuring quantum circuits corresponding to each element.
+
+    Args:
+        init_circ (QuantumCircuit): The qiskit circuit representing the initial state of the system.
+        params (numpy.array): A numpy array which contains the values of each parameter of the ansatz.
+        N (int): The number of qubits.
+        shots (int, optional): The number of shots used to estimate each element of the A_ij matrix. Defaults to 2**10.
+        noisy (bool, optional): A boolean used to turn on and off the Fake-Sherbrooke qiskit noisy backend. Defaults to False.
+
+    Returns:
+        numpy.array: The A_ij matrix
+    """
+    A = [[0.0 for i in range(len(params))] for j in range(len(params))]
+    for i in range(len(params)):
+        for j in range(len(params) - i):
+            qc = QuantumCircuit(N + 1, 1)
+            ansatz = A_Circuit(params, i, i + j, N)
+            qc = qc.compose(init_circ, [k for k in range(N)])
+            qc = qc.compose(ansatz, [k for k in range(N + 1)])
+
+            observable = SparsePauliOp.from_list([("Z" + "I" * N, 1.0)])
+            if noisy:
+                device_backend = FakeSherbrooke()
+                coupling_map = device_backend.coupling_map
+                noise_model = NoiseModel.from_backend(device_backend)
+                basis_gates = noise_model.basis_gates
+                estimator = Estimator(
+                    options={
+                        "shots": shots,
+                        "noise_model": noise_model,
+                        "coupling_map": coupling_map,
+                        "basis_gates": basis_gates,
+                    }
+                )
+            else:
+                estimator = Estimator(options={"shots": shots})
+            result = estimator.run(qc, observable).result()
+            A[i][i + j] = result.values[0]
+    return np.array(A)
+
+
+def C_Circuit(
+    params: npt.NDArray[np.float_],
+    i: int,
+    pauli_string: str,
+    N: int,
+    evolution_type: str = "real",
+) -> QuantumCircuit:
+
+    """Create the qiskit quantum circuits to measure each element of the C_i vector.
+
+    Args:
+        params (numpy.array): A numpy array which contains the values of each parameter of the ansatz.
+        i (int): The index of the C_i vector being measured. This also corresponds
+            to the index i of the parameter whose generator will be measured
+        pauli_string (str): A string containing a description of the pauli operator of the Hamiltonian which will be measured.
+        N (int): The number of qubits.
+        evolution_type (str, optional): This determines if the evolution will be real-time or imaginary-time
+            through the addition of an extra gate. Defaults to "real".
+
+    Returns:
+        QuantumCircuit: The quantum circuit for an element of the C_i matrix, in the form of a
+            hadamard test of the generators of parameter i.  The value of the C_i matrix
+            can be found by measuring the ancilla qubit (qubit N) in the Z basis.
+    """
+    qc = QuantumCircuit(N + 1, 1)
+    qc.h(N)
+    if evolution_type == "imaginary":
+        qc.s(N)  # To get only imaginary component
+    else:
+        qc.z(N)
+    for parameter in range(len(params)):  # Apply parameterized gates
+        if parameter == i:
+            qc.x(N)
+            measure_der(parameter, qc, N)  # Measure generators
+            qc.x(N)
+        apply_param(params, parameter, qc, N)
+    pauli_measure(qc, pauli_string)
+    qc.h(N)
+    return qc
+
+
+def Measure_C(
+    init_circ: QuantumCircuit,
+    params: npt.NDArray[np.float_],
+    H: SparsePauliOp,
+    N: int,
+    shots: int = 2**10,
+    evolution_type: str = "real",
+    noisy: bool = False,
+) -> npt.NDArray[np.float_]:
+    """Create the C_i vector through measuring quantum circuits corresponding to each element.
+
+    Args:
+        init_circ (QuantumCircuit): A qiskit circuit constructing the initial state of the system.
+        params (numpy.array): A numpy array containing the values of the parameters of the ansatz.
+        H (SparsePauliOp): The Hamiltonian.
+        N (int): The number of qubits.
+        shots (int, optional): The number of shots to be used to measure each element of the C_i vector. Defaults to 2**10.
+        evolution_type (str, optional): This determines if the evolution will be real-time or imaginary-time
+            through the addition of an extra gate. Defaults to "real".
+        noisy (bool, optional): A boolean used to turn on and off the Fake-Sherbrooke qiskit noisy backend. Defaults to False.
+
+    Returns:
+        numpy.array: The C_i vector.
+    """
+    C = [0.0 for i in range(len(params))]
+    for i in range(len(params)):
+        for pauli_string in range(len(H.paulis)):
+            qc = QuantumCircuit(N + 1, 1)
+            ansatz = C_Circuit(
+                params, i, H.paulis[pauli_string], N, evolution_type=evolution_type
+            )
+            qc = qc.compose(init_circ, [k for k in range(N)])
+            qc = qc.compose(ansatz, [k for k in range(N + 1)])
+            observable = SparsePauliOp.from_list([("Z" + "I" * N, 1.0)])
+            if noisy:
+                device_backend = FakeSherbrooke()
+                coupling_map = device_backend.coupling_map
+                noise_model = NoiseModel.from_backend(device_backend)
+                basis_gates = noise_model.basis_gates
+                estimator = Estimator(
+                    options={
+                        "shots": shots,
+                        "noise_model": noise_model,
+                        "coupling_map": coupling_map,
+                        "basis_gates": basis_gates,
+                    }
+                )
+            else:
+                estimator = Estimator(options={"shots": shots})
+            result = estimator.run(qc, observable).result()
+
+            C[i] -= 1 / 2 * H.coeffs[pauli_string].real * result.values[0]
+    return np.array(C)
+
+
+def pauli_measure(qc: QuantumCircuit, pauli_string: str) -> None:
+    """Measure the given pauli string on the provided quantum circuit using a hadamard test.
+
+    Args:
+        qc (QuantumCircuit): The quantum circuit ansatz being constructed.
+        pauli_string (str): The pauli string to be measured as a string.
+    """
+    N = len(pauli_string)
+    for i in range(len(pauli_string)):  # Measure Pauli Strings
+        if str(pauli_string[i]) == "X":
+            qc.cx(N, i)
+        if str(pauli_string[i]) == "Y":
+            qc.cy(N, i)
+        if str(pauli_string[i]) == "Z":
+            qc.cz(N, i)
+
+
+def Construct_Ansatz(
+    init_circ: QuantumCircuit, params: npt.NDArray[np.float_], N: int
+) -> QuantumCircuit:
+    """Construct the full ansatz for use in measuring observables.
+
+    Args:
+        init_circ (QuantumCircuit): A qiskit circuit constructing the initial state of the system.
+        params (numpy.array): A numpy vector containing the values of the parameters of the ansatz at a specific time.
+        N (int): The number of qubits.
+
+    Returns:
+        QuantumCircuit: The full ansatz as a qiskit.QuantumCircuit.
+    """
+    qc = QuantumCircuit(N, 0)
+    qc = qc.compose(init_circ, [k for k in range(N)])
+
+    ansatz = QuantumCircuit(N, 0)
+    for parameter in range(len(params)):  # Apply parameterized gates
+        apply_param(params, parameter, ansatz, N)
+
+    qc = qc.compose(ansatz, [k for k in range(N)])
+    return qc
+
+
+def ansatz_energy(
+    init_circ: QuantumCircuit,
+    params: npt.NDArray[np.float_],
+    H: SparsePauliOp,
+    shots: int = 2**14,
+    noisy: bool = False,
+) -> Tuple[float, float]:
+    """Measure the energy of the ansatz.
+
+    Args:
+        init_circ (QuantumCircuit): A qiskit circuit constructing the initial state of the system.
+        params (numpy.array): A numpy vector containing the values of the parameters of the ansatz at a specific time.
+        H (SparsePauliOp): The Hamiltonian.
+        shots (_type_, optional): The number of shots to be used to measure the energy. Defaults to 2**14.
+        noisy (bool, optional): A boolean used to turn on and off the Fake-Sherbrooke qiskit noisy backend. Defaults to False.
+
+    Returns:
+        (float, float): Return (energy, variance) from the measured observables.
+    """
+    N = H.num_qubits
+
+    if noisy:
+        device_backend = FakeSherbrooke()
+        coupling_map = device_backend.coupling_map
+        noise_model = NoiseModel.from_backend(device_backend)
+        basis_gates = noise_model.basis_gates
+        estimator = Estimator(
+            options={
+                "shots": shots,
+                "noise_model": noise_model,
+                "coupling_map": coupling_map,
+                "basis_gates": basis_gates,
+            }
+        )
+    else:
+        estimator = Estimator(options={"shots": shots})
+    qc = Construct_Ansatz(init_circ, params, N)
+    result = estimator.run(qc, H).result()
+    return result.values[0], result.metadata[0]["variance"]
+
+
+def VarQRTE(
+    n_reps_ansatz: int,
+    hamiltonian: SparsePauliOp,
+    total_time: float = 1.0,
+    timestep: float = 0.1,
+    init_circ: Optional[QuantumCircuit] = None,
+    shots: int = 2**10,
+    noisy: bool = False,
+) -> List[npt.NDArray[np.float_]]:
+    """The Variational Quantum Real Time Evolution (VarQRTE) algorithm.  This uses quantum circuits to measure
+        the elements of two objects, the A_ij matrix and the C_i vector.
+
+    Args:
+        n_reps_ansatz (int): The number of repetitions of the variational ansatz used to simulate Real-Time evolution.
+        hamiltonian (SparsePauliOp): The Hamiltonian of the system.
+        total_time (float, optional): A float to determine the total evolution time of the quantum system. Defaults to 1.0.
+        timestep (float, optional): A float to determine the size of a single timestep. Defaults to 0.1.
+        init_circ (QuantumCircuit, optional): A qiskit circuit constructing the initial state of the system.. Defaults to None.
+        shots (int, optional): Number of shots to be used to measure observables. Defaults to 2**10.
+        noisy (bool, optional): A boolean used to turn on and off the Fake-Sherbrooke qiskit noisy backend. Defaults to False.
+
+    Returns:
+        numpy.array: An array containing all the parameter values of the ansatz throughout its time evolution.
+            These values can be put into Construct_Ansatz, or anstaz_energy to obtain observables of the system.
+    """
+    if init_circ is None:
+        init_circ = QuantumCircuit(hamiltonian.num_qubits)
+
+    initial_params = np.zeros(hamiltonian.num_qubits * (n_reps_ansatz + 1))
+    num_timesteps = int(total_time / timestep)
+    all_params = [np.copy(initial_params)]
+    my_params = np.copy(initial_params)  # Reset Initial Parameters after each run
+    for i in range(num_timesteps):
+        print(f"Simulating Time={str(timestep*(i+1))}                      ", end="\r")
+        theta_dot = np.array([0.0 for j in range(len(my_params))])
+        A = Measure_A(
+            init_circ, my_params, hamiltonian.num_qubits, shots=shots, noisy=noisy
+        )
+        C = Measure_C(
+            init_circ,
+            my_params,
+            hamiltonian,
+            hamiltonian.num_qubits,
+            shots=shots,
+            evolution_type="real",
+            noisy=noisy,
+        )
+
+        # Approximately invert A using Truncated SVD
+        u, s, v = np.linalg.svd(A)
+        for j in range(len(s)):
+            if s[j] < 1e-2:
+                s[j] = 1e8
+        t = np.diag(s**-1)
+        A_inv = np.dot(v.transpose(), np.dot(t, u.transpose()))
+
+        theta_dot = np.matmul(A_inv, C)
+
+        my_params -= theta_dot * timestep
+        all_params.append(np.copy(my_params))
+    return all_params
+
+
+def VarQITE(
+    n_reps_ansatz: int,
+    hamiltonian: SparsePauliOp,
+    total_time: float,
+    timestep: float,
+    init_circ: Optional[QuantumCircuit] = None,
+    shots: int = 2**10,
+    noisy: bool = False,
+) -> List[npt.NDArray[np.float_]]:
+    """The Variational Quantum Imaginary Time Evolution (VarQITE) algorithm.  This uses quantum circuits to measure
+        the elements of two objects, the A_ij matrix and the C_i vector.
+
+    Args:
+        n_reps_ansatz (int): The number of repetitions of the variational ansatz used to simulate Imaginary-Time evolution.
+        hamiltonian (SparsePauliOp): The Hamiltonian of the system.
+        total_time (float, optional): A float to determine the total evolution time of the quantum system. Defaults to 1.0.
+        timestep (float, optional): A float to determine the size of a single timestep. Defaults to 0.1.
+        init_circ (QuantumCircuit, optional): A qiskit circuit constructing the initial state of the system.. Defaults to None.
+        shots (int, optional): Number of shots to be used to measure observables. Defaults to 2**10.
+        noisy (bool, optional): A boolean used to turn on and off the Fake-Sherbrooke qiskit noisy backend. Defaults to False.
+
+    Returns:
+        numpy.array: An array containing all the parameter values of the ansatz throughout its time evolution.
+            These values can be put into Construct_Ansatz, or anstaz_energy to obtain observables of the system.
+    """
+    if init_circ is None:
+        init_circ = QuantumCircuit(hamiltonian.num_qubits)
+
+    initial_params = np.zeros(hamiltonian.num_qubits * (n_reps_ansatz + 1))
+    num_timesteps = int(total_time / timestep)
+    all_params = [np.copy(initial_params)]
+
+    my_params = np.copy(initial_params)  # Reset Initial Parameters after each run
+    for i in range(num_timesteps):
+        print(f"Timestep: {str(i*timestep)}                      ", end="\r")
+        theta_dot = np.array([0.0 for j in range(len(my_params))])
+        A = np.array(
+            Measure_A(
+                init_circ, my_params, hamiltonian.num_qubits, shots=shots, noisy=noisy
+            )
+        )
+        C = np.array(
+            Measure_C(
+                init_circ,
+                my_params,
+                hamiltonian,
+                hamiltonian.num_qubits,
+                shots=shots,
+                noisy=noisy,
+                evolution_type="imaginary",
+            )
+        )
+
+        # Approximately invert A using Truncated SVD
+        u, s, v = np.linalg.svd(A)
+        for j in range(len(s)):
+            if s[j] < 1e-2:
+                s[j] = 1e7
+        t = np.diag(s**-1)
+        A_inv = np.dot(v.transpose(), np.dot(t, u.transpose()))
+        # A_inv=np.dot(v,np.dot(t,u.transpose()))
+
+        theta_dot = np.matmul(A_inv, C)
+
+        my_params += theta_dot * timestep
+        all_params.append(np.copy(my_params))
+
+        # print("Theta dot: "+str(np.sum(np.abs(theta_dot))))
+        # print("(Energy ,Variance): "+str(ansatz_energy(init_circ, my_params[:], hamiltonian)))
+        # print()
+    return all_params

qflux/closed_systems/utils.py

@@ -120,7 +120,7 @@ def nested_kronecker_product(a):
 
 def Hilbert_Schmidt(mat1, mat2):
     'Return the Hilbert-Schmidt Inner Product of two matrices.'
-    return np.trace(mat1.conj().T * mat2)
+    return np.trace(mat1.conj().T @ mat2)
 
 
 def decompose(Ham_arr, tol=12, subset = None):
@@ -163,7 +163,7 @@ def decompose(Ham_arr, tol=12, subset = None):
         pauli_str = ''.join(sigma_combinations[ii])
 
         # Convert the Pauli string into a list of matrices
-        tmp_mat_list = vec_query(np.array(sigma_combinations[ii]), pms)
+        tmp_mat_list = vec_query(np.array(list(sigma_combinations[ii])), pms)
 
         # Evaluate the Kronecker product of the matrix array
         tmp_p_matrix = nested_kronecker_product(tmp_mat_list)

qflux/open_systems/quantum_simulation.py

@@ -215,13 +215,14 @@ class QubitDynamicsOS(DynamicsOS):
     def qc_simulation_kraus(
         self,
         time_arr: List[float],
-        shots: int = 1024,
         Kraus: Optional[Dict[int, List[np.ndarray]]] = None,
+        backend: Any = AerSimulator(), 
         Gprop: Optional[List[np.ndarray]] = None,
         tolk: float = 1e-5,
         tolo: float = 1e-5,
+        Is_store_circuit = False,
         **kwargs: Any
-    ) -> np.ndarray:
+        ) -> np.ndarray:
         """
         Perform quantum simulation using the Kraus operator representation.
 
@@ -231,17 +232,22 @@ class QubitDynamicsOS(DynamicsOS):
 
         Args:
             time_arr (List[float]): List of time steps for simulation.
-            shots (int, optional): Number of shots for each measurement. Defaults to 1024.
+            
             Kraus (Optional[Dict[int, List[np.ndarray]]], optional): Dictionary mapping time step index to a list of Kraus operators.
                 If None, Kraus operators are generated from the propagator. Defaults to None.
+            backend (Any, optional): Quantum simulation backend. Defaults to AerSimulator().
             Gprop (Optional[List[np.ndarray]], optional): Propagator matrix (or list of matrices) for simulation.
                 If None, it will be calculated. Defaults to None.
             tolk (float, optional): Tolerance for generating Kraus operators. Defaults to 1e-5.
             tolo (float, optional): Tolerance for observable decomposition. Defaults to 1e-5.
+            Is_store_circuit (bool, optional): If True, store the generated quantum circuits at each time step. Defaults to False.
             **kwargs: Additional keyword arguments for propagator calculation.
 
         Returns:
-            np.ndarray: Array containing the quantum simulation results.
+            Dict[str, Any]: A dictionary containing quantum simulation results, including:
+                - 'data' (np.ndarray): Array of shape (nsteps,), containing the accumulated observable expectation values at each time step.
+                - 'circuits' (List[List[QuantumCircuit]], optional): If `Is_store_circuit` is True, this field contains a list of lists of quantum circuits.
+                  Each outer list corresponds to a time step, and each inner list contains all circuits used for that step (across different Kraus operators and initial states).
         """
         nsteps = len(time_arr)
 
@@ -258,7 +264,7 @@ class QubitDynamicsOS(DynamicsOS):
         print('Kraus operator generation complete')
 
         # Perform Qiskit simulation using the Estimator.
-        estimator = Estimator()
+        estimator = Estimator(mode=backend)
 
         statevec, prob = self.init_statevec_Kraus()
         n_inistate = len(statevec)
@@ -269,7 +275,10 @@ class QubitDynamicsOS(DynamicsOS):
         obs_q = self._get_qiskit_observable(Isdilate=True, tol=tolo)
 
         print('Starting quantum simulation')
-        result_simulation = np.zeros(nsteps, dtype=np.float64)
+        
+        result_simu = {}
+        result_simu['data'] = np.zeros(nsteps, dtype=np.float64)
+        if(Is_store_circuit):  result_simu['circuits'] = [ [] for _ in range(nsteps) ]
 
         for i in range(nsteps):
             print('Simulation step', i, 'of', nsteps)
@@ -278,10 +287,12 @@ class QubitDynamicsOS(DynamicsOS):
             for kraus_op in current_kraus_list:
                 for istate in range(n_inistate):
                     qc = self._create_circuit(kraus_op, statevec[istate], Isscale=False)
-                    result = estimator.run(qc, obs_q, shots=shots).result()
-                    result_simulation[i] += result.values[0] * prob[istate]
+                    result = estimator.run([(qc, obs_q)]).result()
+                    
+                    if(Is_store_circuit):  result_simu['circuits'][i].append(qc)
+                    result_simu['data'][i] += result[0].data.evs * prob[istate]
 
-        return result_simulation
+        return result_simu
 
     def qc_simulation_vecdens(
         self,
@@ -306,7 +317,11 @@ class QubitDynamicsOS(DynamicsOS):
             **kwargs: Additional keyword arguments for propagator calculation.
 
         Returns:
-            np.ndarray: Array containing the quantum simulation results.
+            Dict[str, Any]: A dictionary containing the quantum simulation results, including:
+                - 'data' (np.ndarray): Array of shape (nsteps, n_bitstr), storing the processed probability amplitudes 
+                (i.e., normalized square root of the measured probabilities, scaled by norm factors) at each time step.
+                - 'circuits' (List[QuantumCircuit]): List of generated quantum circuits for each time step.
+                - 'norm' (List[float]): List of norm correction factors used in post-processing at each time step.
         """
         if Gprop is None:
             Gprop = self.Gt_matrix_expo(time_arr, **kwargs)
@@ -318,21 +333,32 @@ class QubitDynamicsOS(DynamicsOS):
 
         n_bitstr = len(self.count_str)
         statevec, norm0 = self.init_statevec_vecdens()
-        result = np.zeros((nsteps, n_bitstr), dtype=np.float64)
-
+        
+        result = {}
+        result['data'] = np.zeros((nsteps, n_bitstr), dtype=np.float64)
+        result['circuits'] = []
+        result['norm'] = []
+        
         for i in range(nsteps):
             if i % 100 == 0:
                 print('Quantum simulation step', i)
             Gt = Gprop[i]
+            
+            #create the circuit
             circuit, norm = self._create_circuit(Gt, statevec, Isscale=True)
             circuit.measure(range(self.Nqb + 1), range(self.Nqb + 1))
             if self.dilation_method == 'SVD-Walsh':
                 circuit = transpile(circuit, backend)
+            
+            #store the circuits and norm to the result
+            result['circuits'].append(circuit)
+            result['norm'].append(norm)
+            
             counts = backend.run(circuit, shots=shots).result().get_counts()
             for j in range(n_bitstr):
                 bitstr = self.count_str[j]
                 if bitstr in counts:
-                    result[i, j] = np.sqrt(counts[bitstr] / shots) * norm * norm0
+                    result['data'][i, j] = np.sqrt(counts[bitstr] / shots) * norm * norm0
                 else:
                     print('At time', i, 'with shots =', shots, "no counts for", bitstr)
 

qflux/variational_methods/__init__.py

@@ -1 +1,2 @@
 # initialization
+from . import qmad

qflux/variational_methods/qmad/__init__.py

@@ -0,0 +1,4 @@
+from . import ansatz
+from . import ansatzVect
+from . import effh
+from . import solver

qflux/variational_methods/qmad/ansatz.py

@@ -1,3 +1,27 @@
+'''
+MIT License
+
+Copyright (c) 2024 Saurabh Shivpuje
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+'''
+
 import numpy as np
 from itertools import combinations, product
 from scipy.linalg import expm, kron

qflux/variational_methods/qmad/ansatzVect.py

@@ -1,3 +1,27 @@
+'''
+MIT License
+
+Copyright (c) 2024 Saurabh Shivpuje
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+'''
+
 import numpy as np
 from itertools import combinations, product
 from scipy.linalg import expm, kron

qflux/variational_methods/qmad/effh.py

@@ -1,3 +1,27 @@
+'''
+MIT License
+
+Copyright (c) 2024 Saurabh Shivpuje
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+'''
+
 import numpy as np
 from scipy.linalg import expm, kron
  

qflux/variational_methods/qmad/solver.py

@@ -1,3 +1,27 @@
+'''
+MIT License
+
+Copyright (c) 2024 Saurabh Shivpuje
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+'''
+
 import numpy as np
 from itertools import combinations, product
 from scipy.linalg import expm, kron

{qflux-0.0.1.dist-info → qflux-0.0.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qflux
-Version: 0.0.1
+Version: 0.0.2
 Summary: qflux is a package for running quantum dynamics calculations on quantum devices.
 Author-email: Brandon Allen <brandon.allen@yale.edu>, Delmar Cabral <delmar.azevedocabral@yale.edu>, Alexander Soudackov <alexander.soudackov@yale.edu>, Anton Morgunov <anton@ischemist.com>
 License: MIT
@@ -24,6 +24,7 @@ Requires-Dist: pylatexenc>=2.10
 Requires-Dist: qutip>=5.0
 Requires-Dist: scipy
 Requires-Dist: tqdm
+Requires-Dist: graycode>=1.0.5
 Provides-Extra: dev
 Requires-Dist: ipykernel>=6.29.5; extra == "dev"
 Requires-Dist: rich>=13.9.4; extra == "dev"
@@ -63,7 +64,13 @@ This repository contains various protocols for performing quantum dynamics simul
 
 ## Getting Started <a name="start"></a>
 
-Simply select a notebook and execute them locally or in google collab. Necessary dependencies will be installed using `pip`.
+`qflux` can be installed via `pip`: 
+
+```bash
+pip install qflux
+```
+
+To get started, one can simply select a notebook and execute them locally or in google collab. Necessary dependencies will be installed using `pip`.
 
 If using uv through the commandline, use the following syntax to create and activate a virtual environment:
 
@@ -102,27 +109,12 @@ https://qflux.batistalab.com/
 
 ### Contribution Guidelines <a name="contribute"></a>
 
-To contribute to the repository, clone the qflux repository and create a new branch:
-
-```bash
-git clone git@github.com:batistagroup/qflux.git
-git pull
-git checkout -b part_II_docs_spinchain
-```
-
-For example to contribute to the documentation, written in markdown (.md), edit the markdown in some form and make it complete (vim spin_chain.md for example).
-Once complete, commit changes to file: 
-
-```bash
-git add spin_chain.md
-git commit -m 'DOCS: Added docs on the spin chain example with Lindblad'
-git push
-```
-
-Generate a new pull request through github and assign to a tentative reviewer.
+To contribute to the repository, follow the procedure outlined in the [Contribution Guidelines](https://github.com/batistagroup/qflux/blob/master/CONTRIBUTING.md) markdown file. 
 
 ### Additional Repositories <a name="repos"></a>
 
+This section includes additional repositories with functionality that has been integrated within QFlux.
+
 [![Static Badge](https://img.shields.io/badge/Open_in_Github-181717.svg?&logo=github&logoColor=white)](https://github.com/dcabral00/qc_spin_tutorial) | Spin Chain Tutorial Repository 
 
 [![Static Badge](https://img.shields.io/badge/Open_in_Github-181717.svg?&logo=github&logoColor=white)](https://github.com/saurabhshivpuje/QMAD) | QMultiAdapt Repository

{qflux-0.0.1.dist-info → qflux-0.0.2.dist-info}/RECORD

@@ -5,6 +5,7 @@ qflux/GQME/params.py,sha256=u7mHRdbbf88ccTIvw9Hb4AunlfNBrzara0OZTL80vwk,1822
 qflux/GQME/readwrite.py,sha256=JUUEsDL8Ep705P8iwlQ4YjAm7MswQ-eNpH1wa8_P-_I,3583
 qflux/GQME/tdvp.py,sha256=32Z_cLJornzM4D63nmqekhwtc-OosrQcZhIeEZAqq9s,7136
 qflux/GQME/tt_tfd.py,sha256=-RPH9aiCinLzG0VdZo43UBVKWcuoplkFmi77oOtv5zU,15204
+qflux/closed_systems/VarQTE.py,sha256=8Znw6R0jBsHnV_e5eGGMumcSG9HlUfRltuqevlBka9A,17956
 qflux/closed_systems/__init__.py,sha256=CBnnqCBp0MD7jCGq1P0nzwCyR3okp4jkC8tvqWUTBCY,472
 qflux/closed_systems/classical_methods.py,sha256=Etqjd9OkqCgPzhC2-FgQWlIiTu66V2_7LRftPDwBrb8,15882
 qflux/closed_systems/custom_execute.py,sha256=Mk24DEvEbQlnu52MqhnSOGBpplHoAMz5__AcBKo1E_4,656
@@ -12,12 +13,12 @@ qflux/closed_systems/hamiltonians.py,sha256=ArdljgB7ASUq5QIKdN8CRdhf7b_2nFyb8OPa
 qflux/closed_systems/qubit_methods.py,sha256=NPC0pLM8Jok4bpkTBcDvDNO3YqsCpw9S6MVMxRHwcuU,10882
 qflux/closed_systems/spin_dynamics_oo.py,sha256=cn4aRM3wYkP6CBbL-LhlUMR4dqQSQK7bpSV-twSzFbU,13925
 qflux/closed_systems/spin_propagators.py,sha256=pMg4ttThkXw2kzBlY2yDpdomTn-7alRtpKUAxD-vSl8,11496
-qflux/closed_systems/utils.py,sha256=mv5zGM9WAM4NCOhD5SpzGNS3iuCNZTPVfV_pbGQUlMQ,6969
+qflux/closed_systems/utils.py,sha256=eiB5V0xvi43-jC35nKl2kMY_vr9r_-2njNn5qPLh494,6975
 qflux/open_systems/__init__.py,sha256=pHbE5rHa0ktH9ZCWUECbmgXQxeS_dJ4PQ5GBhtM9uJk,102
 qflux/open_systems/dilation_circuit.py,sha256=hzzIga8vE4HAyJT1WM0eOB4jA-e32g0dv7P70BfpazA,5908
 qflux/open_systems/numerical_methods.py,sha256=Hv9CJwRa_Kdp8dP7nHt2JJfBx_5w1qMIj_Faaqs9IzM,11981
 qflux/open_systems/params.py,sha256=VsMGDwPqmgxnyl1G_oufopZaNx2duiOQ3g-Bpjp3yJA,676
-qflux/open_systems/quantum_simulation.py,sha256=rwAAr23mFouc0vg2L9QetfV4X1H5_F1eiMzfBUXdvsM,14969
+qflux/open_systems/quantum_simulation.py,sha256=5cd2b9BRyo7ZFk43KGrp45eq6KN4W7u2S4n9gh7aIzw,16723
 qflux/open_systems/trans_basis.py,sha256=KG0BNDdW72CUcJ_Qffu8PjrMfJMCc9qhUwUloVX14Bw,4092
 qflux/open_systems/walsh_gray_optimization.py,sha256=5IgHjknFYhWEslOzElicJvJUYwCWNZNqn3N1z-AQzMY,7682
 qflux/typing/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -25,14 +26,14 @@ qflux/typing/examples.py,sha256=Sj66GKPZas2ALTsy5Cq14ds26xOpsOQDhifAQ9tKVFw,853
 qflux/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qflux/utils/io.py,sha256=-d_nRKp2ePvLjOJNlRF9x8rs_2z6C5_jLBh-BuUFa80,480
 qflux/utils/logging_config.py,sha256=xvrzBmXYGfd8NdNViT1ebyngXs8_UqRtkeY_4gQmV1w,2264
-qflux/variational_methods/__init__.py,sha256=rQCX9vWIrWJg54Xt-dZ7r6lXt6oh16SmD3tBDVuChIA,17
-qflux/variational_methods/qmad/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qflux/variational_methods/qmad/ansatz.py,sha256=cWhXnE6KgOD7Shd9sXtZXhYhfjDan3pPhu3WKTDY-4o,1887
-qflux/variational_methods/qmad/ansatzVect.py,sha256=KrqBVqoYYXcQWUGtRxVP10NCrl5gq0v_-uqGeHAkGFo,1852
-qflux/variational_methods/qmad/effh.py,sha256=_T7MiDFGOYB9WA0KxEnaLKs-iIn4dZEKuUep71xh-h0,2640
-qflux/variational_methods/qmad/solver.py,sha256=eYHlAYOY_QzA322v-fQgXPc5M-F_FSjSgupHs7mCupA,11669
-qflux-0.0.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-qflux-0.0.1.dist-info/METADATA,sha256=ZPDxnoYwkFclZ3cM9kAIUH17tbsom4KN7uNjp93GpkU,7055
-qflux-0.0.1.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-qflux-0.0.1.dist-info/top_level.txt,sha256=GZgw1Z1DZDPg78NCF1dXCHw_f4usRh5HP5yLtgECIpo,6
-qflux-0.0.1.dist-info/RECORD,,
+qflux/variational_methods/__init__.py,sha256=lySF34XS-R-_cEIjpdXJEcB8_HQ-y-rk4U0hiqYoKNo,36
+qflux/variational_methods/qmad/__init__.py,sha256=zK6Fgtes61fpubi-NQqw_l2ZL5hb2dOAQCmW8r9Np2w,86
+qflux/variational_methods/qmad/ansatz.py,sha256=2ttVOrueLYycyXaBy1uxPkaTNEtkctL9wLc54LHHJOE,2969
+qflux/variational_methods/qmad/ansatzVect.py,sha256=OJdRDhKBYou93fwetri5KXFoAj9N4cdjj799Nqu-qmE,2934
+qflux/variational_methods/qmad/effh.py,sha256=l74femDGDDVCiHerfDDj2k30phyrYIlI_ssn4YU426g,3722
+qflux/variational_methods/qmad/solver.py,sha256=1B9DpcuT7bpKcIWt1kHkxT3-gwQECdEzKFcBtJlFYDg,12751
+qflux-0.0.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+qflux-0.0.2.dist-info/METADATA,sha256=1rRhjqS2949C8qCYtHxjAnemMNy7vEr-N6p_ZQ-B3qg,6871
+qflux-0.0.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+qflux-0.0.2.dist-info/top_level.txt,sha256=GZgw1Z1DZDPg78NCF1dXCHw_f4usRh5HP5yLtgECIpo,6
+qflux-0.0.2.dist-info/RECORD,,

{qflux-0.0.1.dist-info → qflux-0.0.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.4.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any