qflux 0.0.1__tar.gz → 0.0.3__tar.gz

{qflux-0.0.1/src/qflux.egg-info → qflux-0.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qflux
-Version: 0.0.1
+Version: 0.0.3
 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 → qflux-0.0.3}/README.md

@@ -21,7 +21,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:
 
@@ -60,27 +66,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 → qflux-0.0.3}/pyproject.toml

@@ -11,7 +11,7 @@ where = ["src"]
 
 [project]
 name = "qflux"
-version = "0.0.1"
+version = "0.0.3"
 description = "qflux is a package for running quantum dynamics calculations on quantum devices."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -28,7 +28,8 @@ dependencies = [
     "pylatexenc>=2.10",
     "qutip>=5.0",
     "scipy",
-    "tqdm"
+    "tqdm",
+    "graycode>=1.0.5"
 ]
 authors = [
            { name = "Brandon Allen", email = "brandon.allen@yale.edu" },

qflux-0.0.3/src/qflux/closed_systems/VarQTE.py

@@ -0,0 +1,420 @@
+import numpy as np
+import numpy.typing as npt
+from typing import List, Optional, Tuple
+
+from qiskit import QuantumCircuit
+from qiskit_aer.primitives import EstimatorV2 as Estimator
+from qiskit.quantum_info import SparsePauliOp
+from qiskit_aer.noise import NoiseModel
+from qiskit_ibm_runtime.fake_provider import FakeSherbrooke
+
+# To change the ansatz, apply_param and measure_der must both be modified.
+def apply_param(
+    params: npt.NDArray[np.float64], 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.float64], 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.float64],
+    N: int,
+    shots: int = 2**10,
+    noisy: bool = False,
+) -> npt.NDArray[np.float64]:
+    """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={
+                                    "backend_options":{"noise_model": noise_model},
+                                    "run_options":{"shots": shots}}
+                )
+            else:
+                estimator = Estimator(options={"run_options":{"shots": shots}})
+            result = estimator.run([(qc, observable)]).result()
+            A[i][i + j] = result[0].data.evs
+    return np.array(A)
+
+
+def C_Circuit(
+    params: npt.NDArray[np.float64],
+    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.float64],
+    H: SparsePauliOp,
+    N: int,
+    shots: int = 2**10,
+    evolution_type: str = "real",
+    noisy: bool = False,
+) -> npt.NDArray[np.float64]:
+    """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={
+                                        "backend_options":{"noise_model": noise_model},
+                                        "run_options":{"shots": shots}}
+                    )
+            else:
+                estimator = Estimator(options={"run_options":{"shots": shots}})
+            result = estimator.run([(qc, observable)]).result()
+
+            C[i] -= 1 / 2 * H.coeffs[pauli_string].real * result[0].data.evs
+    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.float64], 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.float64],
+    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={
+                                "backend_options":{"noise_model": noise_model},
+                                "run_options":{"shots": shots}}
+                                )
+    else:
+        estimator = Estimator(options={"run_options":{"shots": shots}})
+    qc = Construct_Ansatz(init_circ, params, N)
+    result = estimator.run([(qc, H)]).result()
+    return result[0].data.evs, result[0].data.stds
+
+
+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.float64]]:
+    """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.float64]]:
+    """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-0.0.1 → qflux-0.0.3}/src/qflux/closed_systems/qubit_methods.py

@@ -220,7 +220,7 @@ class QubitDynamicsCS(DynamicsCS):
 
 
     def propagate_qmatvec(self, backend=None, n_shots: int = 1024, hamiltonian_matrix=None, initial_state=None):
-        """
+        r"""
             Function to propagate dynamics object with the qubit matvec method.
 
             Args:

{qflux-0.0.1 → qflux-0.0.3}/src/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-0.0.1 → qflux-0.0.3}/src/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-0.0.3/src/qflux/variational_methods/__init__.py

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

qflux-0.0.3/src/qflux/variational_methods/qmad/__init__.py

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

{qflux-0.0.1 → qflux-0.0.3}/src/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-0.0.1 → qflux-0.0.3}/src/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-0.0.1 → qflux-0.0.3}/src/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-0.0.1 → qflux-0.0.3}/src/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 → qflux-0.0.3/src/qflux.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qflux
-Version: 0.0.1
+Version: 0.0.3
 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 → qflux-0.0.3}/src/qflux.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ src/qflux/GQME/params.py
 src/qflux/GQME/readwrite.py
 src/qflux/GQME/tdvp.py
 src/qflux/GQME/tt_tfd.py
+src/qflux/closed_systems/VarQTE.py
 src/qflux/closed_systems/__init__.py
 src/qflux/closed_systems/classical_methods.py
 src/qflux/closed_systems/custom_execute.py

{qflux-0.0.1 → qflux-0.0.3}/src/qflux.egg-info/requires.txt

@@ -11,6 +11,7 @@ pylatexenc>=2.10
 qutip>=5.0
 scipy
 tqdm
+graycode>=1.0.5
 
 [dev]
 ipykernel>=6.29.5

qflux-0.0.3/tests/test_import.py

@@ -0,0 +1,9 @@
+import qflux
+
+from qflux.closed_systems import DynamicsCS
+print("Checking Closed Systems...")
+print(dir(DynamicsCS))
+
+from qflux.variational_methods import qmad
+print("Checking Variational Methods...")
+print(dir(qmad))

qflux-0.0.1/src/qflux/variational_methods/__init__.py

@@ -1 +0,0 @@
-# initialization

qflux-0.0.1/tests/test_import.py

@@ -1,5 +0,0 @@
-import qflux
-
-from qflux.closed_systems import DynamicsCS
-
-print(dir(DynamicsCS))