qflux 0.0.1__py3-none-any.whl

qflux/variational_methods/qmad/effh.py

@@ -0,0 +1,75 @@
+import numpy as np
+from scipy.linalg import expm, kron
+ 
+
+def vectorize_comm(A):
+    # Create an identity matrix with the same dimension as A
+    iden = np.eye(A.shape[0])
+    # Compute the vectorized commutator [A, .] as the Kronecker product 
+    return kron(iden, A) - kron(A.T, iden)
+
+class VectorizedEffectiveHamiltonian_class:
+    def __init__(self, He, Ha):
+        self.He = He
+        self.Ha = Ha
+
+def VectorizedEffectiveHamiltonian(H, gamma, lind):
+    # Create an identity matrix with the same dimension as H
+    iden = np.eye(H.shape[0])
+    # Get the dimension of H
+    d = H.shape[0]
+    # Compute the vectorized commutator for the Hamiltonian H
+    vec_H = vectorize_comm(H)
+    # Initialize the result matrix with zeros (complex type)
+    res = np.zeros((d**2, d**2), dtype=np.complex128)
+    
+    # Compute the conjugate of the Lindblad operator
+    L_conj = lind.conj()
+    L_dagger_L = L_conj.T @ lind
+    # Compute the Lindblad contribution to the effective Hamiltonian
+    res -= gamma * (kron(L_conj, lind) - (kron(iden, L_dagger_L) + kron(L_dagger_L.T, iden)) / 2)
+
+    # Return an instance of the VectorizedEffectiveHamiltonian_class with vec_H and res
+    return VectorizedEffectiveHamiltonian_class(vec_H, res)
+
+class EffectiveHamiltonian_class:
+    def __init__(self, He, Ha, Llist, LdL):
+        self.He = He  # Hermitian part
+        self.Ha = Ha  # Anti-Hermitian part
+        self.Llist = Llist  # List of Lindblad operators
+        self.LdL = LdL  # List of L†L
+
+def EffectiveHamiltonian( mats, Llist):
+    """
+    Create an EffectiveHamiltonian object based on provided parameters.
+    :param mats: List of matrices (Hamiltonian terms).
+    :param Llist: List of lists of Lindblad operators.
+    :return: An instance of EffectiveHamiltonian_class.
+    """
+    # Directly use the input matrices as the Hermitian part (assuming they are Hermitian)
+    He = sum(mats)  # Sum of Hamiltonian terms as Hermitian part
+    Ha = 0.0  # Initialize anti-Hermitian part
+    LdL = []  # Initialize the list for Lindblad operator products
+
+    for  LL in Llist:
+        for L in LL:
+            L_dagger_L = (L.conj().T @ L) 
+            
+            LdL.append(L_dagger_L)  # Append to LdL list
+            Ha += L_dagger_L  # Sum for the anti-Hermitian part
+
+    # Return the Effective Hamiltonian object
+    return EffectiveHamiltonian_class(He, 0.5 * Ha, [L for LL in Llist for L in LL], LdL)
+
+# Helper methods that align with the Julia logic
+def herm(H, t):
+    return H.He(t)  # Assuming He is callable with t
+
+def antiherm(H):
+    return H.Ha
+
+def get_LdL(H):
+    return H.LdL
+
+def get_L(H):
+    return H.Llist

qflux/variational_methods/qmad/solver.py

@@ -0,0 +1,356 @@
+import numpy as np
+from itertools import combinations, product
+from scipy.linalg import expm, kron
+from numpy.random import rand
+random_numbers = np.random.uniform(low=10000, high=99999)
+np.random.seed(int(random_numbers))
+from .ansatz import *
+from .ansatzVect import *
+
+# Helper Functions for evolution
+# def tag(A):
+#     return A.tag if A else None #!!!!!!!a.any or a.all??
+def tag(A):
+    return getattr(A, 'tag', None) if A is not None else None
+
+
+def aexp(A, theta):
+    return expm(-1j * theta * A.mat / 2)
+
+def add_A(A, P):
+    A.A.append(P)
+    A.theta = np.append(A.theta, 0)
+
+def lmul(A, ψ):
+    # print("ehrerw:",A)
+    # print("amat:",np.shape(A.mat))
+    # print("her in lmul",A.mat @ ψ)
+    return A.mat @ ψ
+
+def update_theta(ansatz, dtheta, dt):
+    ansatz.theta = ansatz.theta + dtheta * dt
+
+def partial_theta(A):
+    len_A = len(A.A)
+    ψ = A.ref.copy()
+    res = []
+    for i in range(len_A):
+        ψ = aexp(A.A[i], A.theta[i]) @ ψ
+        ψt = -0.5j * lmul(A.A[i], ψ)
+        for j in range(i + 1, len_A):
+            ψt = aexp(A.A[j], A.theta[j]) @ ψt
+        res.append(ψt)
+    return res
+
+def build_m(ψ, dψ):
+    l = len(dψ)
+    res = np.zeros((l, l))
+    ψ = ψ[:, np.newaxis] if len(ψ.shape) == 1 else ψ
+
+    for μ in range(l):
+        for ν in range(l):
+            res[μ, ν] = 2 * np.real(dψ[μ].T.conj() @ dψ[ν] + ψ.T.conj() @ dψ[μ] @ ψ.T.conj() @ dψ[ν])
+    return res
+
+def update_m(m, dψa, ψ, dψ):
+    l = m.shape[0]
+    mp = np.zeros((l + 1, l + 1))
+    dψa = dψa[:, np.newaxis]
+    ψ = ψ[:, np.newaxis]
+    mp[l, l] = 2 * np.real((dψa.T.conj() @ dψa + ψ.T.conj() @ dψa @ ψ.T.conj() @ dψa).item())
+    mp[:l, :l] = m
+    for μ in range(l):
+        temp = 2 * np.real(dψ[μ].T.conj() @ dψa + ψ.T.conj() @ dψ[μ] @ ψ.T.conj() @ dψa)
+        mp[μ, l] = temp.item()
+        mp[l, μ] = temp.item()
+    return mp
+
+def build_v(ψ, dψ, He, Ha):
+    L = -1j * (He - 1j * Ha)
+    l = len(dψ)
+    ψ = ψ[:, np.newaxis] if len(ψ.shape) == 1 else ψ
+    res = np.zeros(l)
+    for μ in range(l):
+        res[μ] = 2 * np.real((dψ[μ].T.conj() @ L @ ψ + dψ[μ].T.conj() @ ψ @ ψ.T.conj() @ L.T.conj() @ ψ).item())
+    return res
+
+def update_v(v, dψₐ, ψ, He, Ha):
+    L = -1j * (He - 1j * Ha)
+    l = len(v)
+    dψₐ = dψₐ[:, np.newaxis]
+    ψ = ψ[:, np.newaxis]
+    vp = np.zeros(l + 1)
+    vp[:l] = v
+    vp[l] = 2 * np.real((dψₐ.T.conj() @ L @ ψ + dψₐ.T.conj() @ ψ @ ψ.T.conj() @ L.T.conj() @ ψ).item())
+    return vp
+
+def lin_solve(m, v, λ=1e-4):
+    A = m.T @ m
+    try:
+        xλ = np.linalg.solve(A + λ**2 * np.eye(A.shape[0]), m.T @ v)
+    except np.linalg.LinAlgError:
+        xλ = np.linalg.lstsq(A + λ**2 * np.eye(A.shape[0]), m.T @ v, rcond=None)[0]
+    return xλ, 2 * v.T @ xλ - xλ.T @ m @ xλ
+
+def get_newest_A(A):
+    return A.A[-1] if A.A else None
+
+def update_state(A):
+    if A.A:
+        state = A.ref.copy()
+        for i in range(len(A.A)):
+            state = aexp(A.A[i], A.theta[i]) @ state
+        A.state = state
+    else:
+        A.state = A.ref
+
+def set_ref(A, ref):
+    A.ref = ref
+
+def reset(A):
+    A.theta = np.array([])
+    A.A = []
+    update_state(A)
+
+class Result:
+    def __init__(self, t, psi, energy, pop, theta, A, jump_t, jump_L, status):
+        self.t = t
+        self.psi = psi
+        self.energy = energy  # Add energy attribute
+        self.pop = pop
+        self.theta = theta
+        self.A = A
+        self.jump_t = jump_t
+        self.jump_L = jump_L
+        self.status = status
+
+    def __repr__(self):
+        return f"Result(t={self.t}, psi={self.psi}, energy={self.energy}, pop={self.pop}, theta={self.theta}, A={self.A}, jump_t={self.jump_t}, jump_L={self.jump_L}, status={self.status})"
+
+class AVQDSol:
+    def __init__(self, t, u, θ, A, jump_L, jump_t, status=0, norm=[]):
+        self.t = t
+        self.u = u
+        self.θ = θ
+        self.A = A
+        self.jump_L = jump_L
+        self.jump_t = jump_t
+        self.status = status
+        self.norm = norm
+
+def one_step(A, He, Ha, dt):
+
+    relrcut = A.relrcut
+    psi_ = A.state
+    dpsi_ = partial_theta(A)
+    M = build_m(psi_, dpsi_)
+    V = build_v(psi_, dpsi_, He, Ha)
+    dtheta, vmv = lin_solve(M, V)
+    vmvMax = vmv
+    Mtmp = M
+    Vtmp = V
+    dthetatmp = dtheta
+    opTmp = None
+    dpsi_ₐTmp = None
+    add_flag = True
+
+    while add_flag:
+        # print("here in onestep While")
+        tagTmp = None
+        # print("Ansatz pool:",A.pool)
+        for op in A.pool:
+            # print("opertaro from pool:",(op.tag))
+            if tag(get_newest_A(A)) == tag(op):
+                # print("here in get newest_A")
+                continue
+            # print("here in op for loop")
+            dpsi_ₐ = -0.5j * lmul(op, psi_)
+
+            Mop = update_m(M, dpsi_ₐ, psi_, dpsi_)
+            # print("Mop:",Mop)
+            Vop = update_v(V, dpsi_ₐ, psi_, He, Ha)
+            dthetaop, vmvOp = lin_solve(Mop, Vop)
+            # print("berfore the if:","vmvOp:",vmvOp, "vmvMax:",vmvMax)
+
+            if vmvOp > vmvMax:
+                # print("vmvOp:",vmvOp, "vmvMax:",vmvMax)
+
+                Mtmp = Mop
+                Vtmp = Vop
+                vmvMax = vmvOp
+                dthetatmp = dthetaop
+                opTmp = op
+                tagTmp = tag(op)
+                # print("tagTmp:",tagTmp)
+                dpsi_ₐTmp = dpsi_ₐ
+        # print("vmvMax - vmv:",vmvMax-vmv)
+        add_flag = vmvMax - vmv >= relrcut
+
+        
+
+        if tagTmp is not None and add_flag:
+
+            add_A(A, opTmp)
+            vmv = vmvMax
+            M = Mtmp
+            V = Vtmp
+            dtheta = dthetatmp
+            dpsi_.append(dpsi_ₐTmp)
+
+    update_theta(A, dtheta, dt)
+    # print("Ansatz:",A.theta)
+    update_state(A)
+
+
+def solve_avq_traj(H, A, tspan, dt, save_state=True, save_everystep=True):
+    # Store initial reference state for reinitialization
+    ref_init = A.ref.copy()
+    update_state(A)
+    
+    # Initialize time and recorder lists
+    t = tspan[0]
+    t_list = []
+    u_list = []
+    theta_list = []
+    A_list = []
+    jump_L_list = []
+    jump_t_list = []
+
+    # Break flag for error handling
+    break_flag = False
+    Gamma = 0  # Jump recorder
+    q = rand()  # Random number for quantum jump
+    # print("expo:",np.exp(-Gamma))
+    # print("random q:", q)
+
+    if save_everystep:
+        t_list.append(t)
+        theta_list.append(A.theta.copy())
+
+        A_list.append([tag(a) for a in A.A])
+        if save_state:
+            u_list.append(A.state.copy())
+
+    # Main evolution loop
+    # This loop performs the simulation of quantum system evolution over a set time span.
+    # It integrates the system state forward in time while handling both deterministic 
+    # evolution and stochastic quantum jumps.
+
+    while t + dt <= tspan[1]:  # Loop over the total time span with step size dt
+        # print("timestep:", dt)  # Print current time step size for monitoring
+        He = H.He  # Extract Hermitian Hamiltonian component for deterministic evolution
+        Ha = H.Ha  # Extract Antihermitian Hamiltonian component for jump handling
+
+        if np.exp(-Gamma) > q:  # Check if no quantum jump occurs, based on jump probability threshold
+            try:
+                one_step(A, He, Ha, dt)  # Perform deterministic evolution for one time step
+            except Exception:  # In case of failure, exit the loop with a flag
+                break_flag = True
+                break
+            psi_ = A.state  # Update the current state of the system
+            Gamma += 2 * np.real(psi_.T.conj() @ Ha @ psi_) * dt  # Update accumulated Gamma for jump probability
+
+            if save_everystep:  # Option to save state at every time step
+                t_list.append(t + dt)  # Save current time
+                theta_list.append(A.theta.copy())  # Save current ansatz parameters
+                A_list.append([tag(a) for a in A.A])  # Save current state of ansatz components
+
+        else:  # Quantum jump occurs
+            psi_ = A.state  # Get current state before jump
+
+            # Compute the probabilities for different jump operators
+            weights = np.array([np.real(psi_.T.conj() @ LdL @ psi_) for LdL in H.LdL])
+
+            # Randomly choose a jump operator based on computed probabilities
+            L_index = np.random.choice([i for i in range(np.shape(H.Llist)[0])], p=weights/weights.sum())
+            L = H.Llist[L_index]  # Select corresponding jump operator
+
+            # Apply the jump operator to the state and normalize it
+            psi_n = L @ psi_ / np.linalg.norm(L @ psi_)
+
+            # Record the jump event details (time and operator used)
+            jump_t_list.append(t)
+            jump_L_list.append(tag(L))
+
+            # Record the state and parameters post-jump
+            t_list.append(t + dt)
+            set_ref(A, psi_n)  # Update the state with post-jump state
+            reset(A)  # Reset the ansatz parameters after jump
+
+            # Save updated ansatz parameters post-jump
+            theta_list.append(A.theta.copy())
+            A_list.append([tag(a) for a in A.A])
+
+            # Reset the jump probability accumulator
+            Gamma = 0
+            q = rand()  # Generate a new random number for the next jump check
+
+        # Optionally save the state at each time step
+        if save_state:
+            u_list.append(A.state.copy())  # Store the current state
+
+        # Increment the simulation time by dt
+        t += dt
+
+
+    # Final check for status if no errors occurred
+    if not break_flag:
+        if (not jump_t_list or not np.isclose(t, jump_t_list[-1])) and not save_everystep:
+            theta_list.append(A.theta.copy())
+            A_list.append([tag(a) for a in A.A])
+
+    # Reset the ansatz to the initial condition
+    # print("ansatz before reset:",A.A)
+    set_ref(A, ref_init)
+    reset(A)
+    # print("tlist:",t_list)
+    # Return solution object
+    return AVQDSol(t_list, u_list, theta_list, A_list, jump_L_list, jump_t_list, status=0 if not break_flag else 1)
+
+# Function to evolve a single trajectory and collect results
+def solve_avq_trajectory(H, ansatz, tf, dt):
+    # Solve for a single trajectory using solve_avq
+    res = solve_avq_traj(H, ansatz, [0, tf], dt, save_state=True, save_everystep=True)
+    
+    # Post-process the results to extract energy and populations
+    tlist = res.t
+    psi_list = res.u
+    energy = []
+    pop = []
+    
+    for i in range(len(tlist)):
+        psi = psi_list[i]
+        energy.append(np.real(np.conj(psi.T) @ (H.He) @ psi))  # Energy
+        pop.append([np.abs(psi[0])**2, np.abs(psi[1])**2])  # Population in ground/excited states for amplitude damping
+
+    return Result(tlist, psi_list, energy, pop, res.θ, res.A, res.jump_t, res.jump_L, res.status)
+    pass
+
+def solve_avq_vect(H, A, tspan, dt):
+    ref_init = A.ref.copy()
+    nqbit = A.nqbit
+    update_state(A)
+    t = tspan[0]
+    t_list = [t]
+    u_list = [A.state.reshape(2**nqbit, 2**nqbit)]
+    theta_list = [A.theta.copy()]
+    A_list = [[tag(a) for a in A.A]]
+    norm_list = [1.0]
+    Gamma = 0
+    while t + dt <= tspan[1]:
+        He = H.He
+        Ha = H.Ha
+        one_step(A, He, Ha, dt)
+        psi_ = A.state
+        Gamma += 2 * np.real(psi_.T.conj() @ Ha @ psi_) * dt
+        ρ = psi_.reshape(2**nqbit, 2**nqbit)
+        ρ /= np.trace(ρ)
+        t += dt
+        t_list.append(t)
+        u_list.append(ρ)
+        theta_list.append(A.theta.copy())
+        A_list.append([tag(a) for a in A.A])
+        norm_list.append(np.exp(-Gamma))
+    set_ref(A, ref_init)
+    reset(A)
+    return AVQDSol(t_list, u_list, theta_list, A_list, [], [], norm=norm_list)

qflux-0.0.1.dist-info/METADATA

@@ -0,0 +1,144 @@
+Metadata-Version: 2.4
+Name: qflux
+Version: 0.0.1
+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
+Project-URL: Homepage, https://github.com/batistagroup/qflux
+Project-URL: Issues, https://github.com/batistagroup/qflux/issues
+Project-URL: Documentation, https://qflux.batistalab.com
+Keywords: Quantum Computing,chemistry,quantum dynamics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: importlib-metadata
+Requires-Dist: qiskit>=2.0.0
+Requires-Dist: qiskit-aer>=0.17.0
+Requires-Dist: qiskit-algorithms>=0.3.1
+Requires-Dist: qiskit-ibm-runtime>=0.37.0
+Requires-Dist: tomli>=2.2.1
+Requires-Dist: matplotlib>=3.10
+Requires-Dist: numpy>=2.0
+Requires-Dist: pylatexenc>=2.10
+Requires-Dist: qutip>=5.0
+Requires-Dist: scipy
+Requires-Dist: tqdm
+Provides-Extra: dev
+Requires-Dist: ipykernel>=6.29.5; extra == "dev"
+Requires-Dist: rich>=13.9.4; extra == "dev"
+Requires-Dist: pre-commit>=4.1.0; extra == "dev"
+Requires-Dist: ruff>=0.9.6; extra == "dev"
+Requires-Dist: pytest>=8.3.4; extra == "dev"
+Requires-Dist: mypy>=1.15.0; extra == "dev"
+Requires-Dist: mkdocs>=1.6.1; extra == "dev"
+Requires-Dist: mkdocstrings-python>=1.15.0; extra == "dev"
+Requires-Dist: material-plausible-plugin>=0.3.0; extra == "dev"
+Requires-Dist: mkdocs-material>=9.6.4; extra == "dev"
+Requires-Dist: types-tqdm>=4.67.0.20241221; extra == "dev"
+Provides-Extra: gqme
+Requires-Dist: mpsqd; extra == "gqme"
+Dynamic: license-file
+
+[![License: GNU AGPL v3](https://img.shields.io/badge/License-GNU_AGPL_v3-lightgrey.svg)](LICENCE)
+[![Static Badge](https://img.shields.io/badge/CQDMQD-00268d?style=flat&logoColor=00268d&label=NSF&labelColor=00268d&color=00268d&link=https%3A%2F%2Fcqdmqd.yale.edu%2F)](https://cqdmqd.yale.edu/)
+
+
+# QFlux - A Quantum Computer Dynamics Package
+
+This repository contains various protocols for performing quantum dynamics simulations with quantum devices. Each submodule contains object implementations for these protocols as demonstrated in a publication, as well as comprehensive tutorial notebooks designed to help users understand, implement and build upon various simulation techniques for studying quantum dynamics using quantum computer frameworks. Each tutorial is provided in Python, using Jupyter Notebooks to offer detailed explanations in both markdown and code comments.
+
+
+## Table of Contents
+
+1. [Getting Started](#start)
+   - [Documentation](#docs)
+   - [Notebooks For Tutorial Manuscript](#notebooks)
+   - [Additional Repositories](#repos)
+2. [Contribution Guidelines](#contribute)
+3. [Citation](#citation)
+4. [License](#license)
+5. [Acknowledgements](#acknowledgement)
+
+
+## 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`.
+
+If using uv through the commandline, use the following syntax to create and activate a virtual environment:
+
+```bash
+uv venv
+source .venv/bin/activate
+```
+
+The necessary packages, including development, can be installed as follows:
+
+```bash
+uv pip install -e ".[dev]"
+```
+
+### Documentation <a name="docs"></a>
+
+Documentation for QFlux, illustrating its features and representative examples, is available at the following page:
+
+https://qflux.batistalab.com/
+
+### Notebooks For Tutorial Manuscript <a name="notebooks"></a>
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/batistagroup/qflux/blob/master/demos/tutorial/Part_I.ipynb) | Part I - Closed Quantum Dynamics and Simulation Protocols
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/batistagroup/qflux/blob/master/demos/tutorial/Part_I_appendixA.ipynb) | Part I - Appendix A: Variational Methods
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/batistagroup/qflux/blob/master/demos/tutorial/Part_I_appendixB.ipynb) | Part I - Appendix B: Bosonic Simulation
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/batistagroup/qflux/blob/master/demos/tutorial/Part_II.ipynb) | Part II - Open Quantum Dynamics
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/batistagroup/qflux/blob/master/demos/tutorial/Part_III_B.ipynb) | Part III - Variational Quantum Trajectory Dynamics for FMO
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/batistagroup/qflux/blob/master/demos/tutorial/Part_III_A.ipynb) | Part III - Variational Quantum Dynamics for Amplitude Damping
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/batistagroup/qflux/blob/master/demos/tutorial/Part_IV.ipynb) | Part IV - Generalized Quantum Master Equation Dynamics
+
+### 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.
+
+### Additional Repositories <a name="repos"></a>
+
+[![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
+
+[![Static Badge](https://img.shields.io/badge/Open_in_Github-181717.svg?&logo=github&logoColor=white)](https://github.com/XiaohanDan97/CCI_PartIII_GQME) | GQME Tutorial Repository
+
+
+## Citation <a name="citation"></a>
+
+Please cite the preprint of our work when using this code until the journal version becomes available.
+
+
+## Licensing <a name="license"></a>
+
+Each notebook or repository might have its own licensing. Please refer to the individual README files and notebooks within each directory for specific licensing information.
+
+## Acknowledgement <a name="acknowledgement"></a>
+
+We acknowledge the financial support of the National Science Foundation under award number 2124511, CCI Phase I: NSF Center for Quantum Dynamics on Modular Quantum Devices (CQD-MQD).

qflux-0.0.1.dist-info/RECORD

@@ -0,0 +1,38 @@
+qflux/__init__.py,sha256=j0hovUC2F2GdGooe2jExe89bXQh4HSozB26mOmOx03o,129
+qflux/GQME/__init__.py,sha256=zeTbgWoan3pUfp5aa7MU-ywWBTHAOp4RpLNE4IXW6bU,115
+qflux/GQME/dynamics_GQME.py,sha256=pFK75IqyTsLhODKSHnQiRMyQn8YDgyt-eFPiFAHjwUQ,16849
+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/__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
+qflux/closed_systems/hamiltonians.py,sha256=ArdljgB7ASUq5QIKdN8CRdhf7b_2nFyb8OPacOGGvEs,3156
+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/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/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
+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-0.0.1.dist-info/WHEEL

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