qflux 0.0.2__tar.gz → 0.0.4__tar.gz

{qflux-0.0.2/src/qflux.egg-info → qflux-0.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qflux
-Version: 0.0.2
+Version: 0.0.4
 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

{qflux-0.0.2 → qflux-0.0.4}/pyproject.toml

@@ -11,7 +11,7 @@ where = ["src"]
 
 [project]
 name = "qflux"
-version = "0.0.2"
+version = "0.0.4"
 description = "qflux is a package for running quantum dynamics calculations on quantum devices."
 readme = "README.md"
 requires-python = ">=3.10"

{qflux-0.0.2 → qflux-0.0.4}/src/qflux/GQME/dynamics_GQME.py

@@ -59,7 +59,7 @@ class DynamicsGQME:
 
     
     def get_Liouvillian(self) -> None:
-        """
+        r"""
         Construct the Liouvillian superoperator using the system Hamiltonian.
         
         The Liouvillian is defined as:

{qflux-0.0.2 → qflux-0.0.4}/src/qflux/closed_systems/VarQTE.py

@@ -3,15 +3,14 @@ import numpy.typing as npt
 from typing import List, Optional, Tuple
 
 from qiskit import QuantumCircuit
-from qiskit.primitives import Estimator
+from qiskit_aer.primitives import EstimatorV2 as Estimator
 from qiskit.quantum_info import SparsePauliOp
-from qiskit.providers.aer.noise import NoiseModel
-from qiskit.providers.fake_provider import FakeSherbrooke
-
+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.float_], i: int, qc: QuantumCircuit, N: int
+    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
@@ -24,7 +23,7 @@ def apply_param(
         qc (QuantumCircuit): The qiskit ansatz quantum circuit currently being constructed.
         N (int): Number of qubits
     """
-    qc.rx(params[i], i % N))
+    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)
@@ -43,7 +42,7 @@ def measure_der(i: int, qc: QuantumCircuit, N: int) -> None:
     qc.cx(N, i % N)
 
 
-def A_Circuit(params: npt.NDArray[np.float_], i: int, j: int, N: int) -> QuantumCircuit:
+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:
@@ -73,11 +72,11 @@ def A_Circuit(params: npt.NDArray[np.float_], i: int, j: int, N: int) -> Quantum
 
 def Measure_A(
     init_circ: QuantumCircuit,
-    params: npt.NDArray[np.float_],
+    params: npt.NDArray[np.float64],
     N: int,
     shots: int = 2**10,
     noisy: bool = False,
-) -> npt.NDArray[np.float_]:
+) -> npt.NDArray[np.float64]:
     """Create the A_ij matrix through measuring quantum circuits corresponding to each element.
 
     Args:
@@ -104,23 +103,19 @@ def Measure_A(
                 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,
-                    }
+                estimator = Estimator(options={
+                                    "backend_options":{"noise_model": noise_model},
+                                    "run_options":{"shots": shots}}
                 )
             else:
-                estimator = Estimator(options={"shots": shots})
-            result = estimator.run(qc, observable).result()
-            A[i][i + j] = result.values[0]
+                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.float_],
+    params: npt.NDArray[np.float64],
     i: int,
     pauli_string: str,
     N: int,
@@ -162,13 +157,13 @@ def C_Circuit(
 
 def Measure_C(
     init_circ: QuantumCircuit,
-    params: npt.NDArray[np.float_],
+    params: npt.NDArray[np.float64],
     H: SparsePauliOp,
     N: int,
     shots: int = 2**10,
     evolution_type: str = "real",
     noisy: bool = False,
-) -> npt.NDArray[np.float_]:
+) -> npt.NDArray[np.float64]:
     """Create the C_i vector through measuring quantum circuits corresponding to each element.
 
     Args:
@@ -199,19 +194,15 @@ def Measure_C(
                 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,
-                    }
-                )
+                estimator = Estimator(options={
+                                        "backend_options":{"noise_model": noise_model},
+                                        "run_options":{"shots": shots}}
+                    )
             else:
-                estimator = Estimator(options={"shots": shots})
-            result = estimator.run(qc, observable).result()
+                estimator = Estimator(options={"run_options":{"shots": shots}})
+            result = estimator.run([(qc, observable)]).result()
 
-            C[i] -= 1 / 2 * H.coeffs[pauli_string].real * result.values[0]
+            C[i] -= 1 / 2 * H.coeffs[pauli_string].real * result[0].data.evs
     return np.array(C)
 
 
@@ -233,7 +224,7 @@ def pauli_measure(qc: QuantumCircuit, pauli_string: str) -> None:
 
 
 def Construct_Ansatz(
-    init_circ: QuantumCircuit, params: npt.NDArray[np.float_], N: int
+    init_circ: QuantumCircuit, params: npt.NDArray[np.float64], N: int
 ) -> QuantumCircuit:
     """Construct the full ansatz for use in measuring observables.
 
@@ -258,7 +249,7 @@ def Construct_Ansatz(
 
 def ansatz_energy(
     init_circ: QuantumCircuit,
-    params: npt.NDArray[np.float_],
+    params: npt.NDArray[np.float64],
     H: SparsePauliOp,
     shots: int = 2**14,
     noisy: bool = False,
@@ -282,19 +273,15 @@ def ansatz_energy(
         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,
-            }
-        )
+        estimator = Estimator(options={
+                                "backend_options":{"noise_model": noise_model},
+                                "run_options":{"shots": shots}}
+                                )
     else:
-        estimator = Estimator(options={"shots": shots})
+        estimator = Estimator(options={"run_options":{"shots": shots}})
     qc = Construct_Ansatz(init_circ, params, N)
-    result = estimator.run(qc, H).result()
-    return result.values[0], result.metadata[0]["variance"]
+    result = estimator.run([(qc, H)]).result()
+    return result[0].data.evs, result[0].data.stds
 
 
 def VarQRTE(
@@ -305,7 +292,7 @@ def VarQRTE(
     init_circ: Optional[QuantumCircuit] = None,
     shots: int = 2**10,
     noisy: bool = False,
-) -> List[npt.NDArray[np.float_]]:
+) -> 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.
 
@@ -368,7 +355,7 @@ def VarQITE(
     init_circ: Optional[QuantumCircuit] = None,
     shots: int = 2**10,
     noisy: bool = False,
-) -> List[npt.NDArray[np.float_]]:
+) -> 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.
 

{qflux-0.0.2 → qflux-0.0.4}/src/qflux/closed_systems/__init__.py

@@ -15,3 +15,4 @@ spin_dynamics_oo.py  --> SpinDynamicsS, SpinDynamicsH : Statevector and hadamard
 from .classical_methods import DynamicsCS
 from .qubit_methods import QubitDynamicsCS
 from .spin_dynamics_oo import SpinDynamicsS, SpinDynamicsH
+from .direct_method import hamiltonian_simulation

qflux-0.0.4/src/qflux/closed_systems/direct_method.py

@@ -0,0 +1,119 @@
+import numpy as np
+from qiskit import QuantumCircuit, QuantumRegister
+
+def exp_all_z(circuit, quantum_register, pauli_indexes, control_qubit=None, t=1):
+    r"""
+    Implements \( e^{-i t Z \otimes \cdots \otimes Z} \) on specified qubits.
+    
+    Args:
+        circuit (QuantumCircuit): The circuit to modify.
+        quantum_register (QuantumRegister): Register containing target qubits.
+        pauli_indexes (list): Indices of qubits where \( Z \) acts.
+        control_qubit (Qubit, optional): Optional control qubit for conditional application.
+        t (float): Evolution time.
+    
+    Returns:
+        QuantumCircuit: Updated circuit with the operation applied.
+    """
+    if control_qubit and control_qubit.register not in circuit.qregs:
+        circuit.add_register(control_qubit.register)
+
+    if not pauli_indexes:
+        if control_qubit:
+            circuit.p(t, control_qubit)  # Phase gate
+        return circuit
+
+    # Parity computation
+    for i in range(len(pauli_indexes) - 1):
+        circuit.cx(quantum_register[pauli_indexes[i]], quantum_register[pauli_indexes[i + 1]])
+
+    # Apply phase rotation
+    target = quantum_register[pauli_indexes[-1]]
+    angle = -2 * t
+    if control_qubit:
+        circuit.crz(angle, control_qubit, target)
+    else:
+        circuit.rz(angle, target)
+
+    # Uncompute parity
+    for i in reversed(range(len(pauli_indexes) - 1)):
+        circuit.cx(quantum_register[pauli_indexes[i]], quantum_register[pauli_indexes[i + 1]])
+
+    return circuit
+
+
+def exp_pauli(pauli, quantum_register, control_qubit=None, t=1):
+    r"""
+    Implements \( e^{-i t P} \) for a Pauli string \( P \).
+
+    Args:
+        pauli (str): Pauli string (e.g., "XIZY").
+        quantum_register (QuantumRegister): Target register.
+        control_qubit (Qubit, optional): Optional control qubit.
+        t (float): Evolution time.
+
+    Returns:
+        QuantumCircuit: Circuit implementing the Pauli evolution.
+    """
+    if len(pauli) != len(quantum_register):
+        raise ValueError("Pauli string length must match register size.")
+
+    pauli_indexes = []
+    pre_circuit = QuantumCircuit(quantum_register)
+
+    for i, op in enumerate(pauli):
+        if op == 'I':
+            continue
+        elif op == 'X':
+            pre_circuit.h(i)
+            pauli_indexes.append(i)
+        elif op == 'Y':
+            pre_circuit.rx(np.pi/2, i)
+            pauli_indexes.append(i)
+        elif op == 'Z':
+            pauli_indexes.append(i)
+        else:
+            raise ValueError(f"Invalid Pauli operator '{op}' at position {i}.")
+
+    circuit = QuantumCircuit(quantum_register)
+    circuit.compose(pre_circuit, inplace=True)
+    circuit = exp_all_z(circuit, quantum_register, pauli_indexes, control_qubit, t)
+    circuit.compose(pre_circuit.inverse(), inplace=True)
+    return circuit
+
+
+def hamiltonian_simulation(hamiltonian, quantum_register=None, control_qubit=None, t=1, trotter_number=1):
+    r"""
+    Implements \( e^{-i H t} \) using first-order Trotterization.
+    
+    Args:
+        hamiltonian (dict): Pauli terms with coefficients (e.g., {"ZZ": 0.5, "XX": 0.3}).
+        quantum_register (QuantumRegister, optional): Target register.
+        control_qubit (Qubit, optional): Optional control qubit.
+        t (float): Simulation time.
+        trotter_number (int): Number of Trotter steps.
+    
+    Returns:
+        QuantumCircuit: Trotterized Hamiltonian evolution circuit.
+    """
+    if not hamiltonian:
+        raise ValueError("Hamiltonian must contain at least one term.")
+    
+    n_qubits = len(next(iter(hamiltonian)))
+    if quantum_register is None:
+        quantum_register = QuantumRegister(n_qubits)
+    
+    delta_t = t / trotter_number
+    circuit = QuantumCircuit(quantum_register)
+    
+    for pauli_str, coeff in hamiltonian.items():
+        term_circuit = exp_pauli(pauli_str, quantum_register, control_qubit, coeff * delta_t)
+        circuit.compose(term_circuit, inplace=True)
+    
+    full_circuit = QuantumCircuit(quantum_register)
+    for _ in range(trotter_number):
+        full_circuit.compose(circuit, inplace=True)
+    
+    return full_circuit
+
+

{qflux-0.0.2 → qflux-0.0.4}/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.2 → qflux-0.0.4}/src/qflux/closed_systems/spin_dynamics_oo.py

@@ -4,6 +4,9 @@ from .utils import execute
 from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
 from qiskit_aer import Aer
 from .spin_propagators import get_time_evolution_operator
+import numpy.typing as npt
+import os 
+
 
 class SpinDynamicsS:
     """
@@ -37,7 +40,6 @@ class SpinDynamicsS:
             evolution_timestep (float): Time step for the evolution.
             trotter_steps (int): Number of Trotter steps for the simulation.
             hamiltonian_coefficients (list): Hamiltonian coefficients for the system.
-            initial_state (str or list): Initial state of the system, represented as a binary string or list.
         """
         self.num_qubits = num_qubits
         self.evolution_timestep = evolution_timestep
@@ -64,7 +66,7 @@ class SpinDynamicsS:
         Prepare the initial state vector from the binary string or list.
 
         Returns:
-            ndarray: Flattened initial state vector.
+            psin (npt.ArrayLike): Flattened initial state vector.
         """
         zero_state = np.array([[1], [0]])
         one_state = np.array([[0], [1]])
@@ -83,12 +85,13 @@ class SpinDynamicsS:
     def qsolve_statevector(self, psin):
         """
         Perform statevector propagation for the quantum circuit.
+            initial_state (str or list): Initial state of the system, represented as a binary string or list.
 
         Args:
-            psin (ndarray): Input statevector.
+            psin (npt.ArrayLike): Input statevector.
 
         Returns:
-            ndarray: Final statevector after execution.
+            ndarray (npt.ArrayLike): Final statevector after execution.
         """
         d = int(np.log2(np.size(psin)))
         qre = QuantumRegister(d)
@@ -204,7 +207,7 @@ class SpinDynamicsH:
             imag_expectation (bool): Whether to evaluate the imaginary component (default: False).
 
         Returns:
-            QuantumCircuit: The constructed Hadamard test circuit.
+            qc (QuantumCircuit): The constructed Hadamard test circuit.
         """
         qr = QuantumRegister(self.num_qubits + 1)
         cr = ClassicalRegister(1)
@@ -233,7 +236,7 @@ class SpinDynamicsH:
             num_shots (int): Number of shots for circuit execution (default: 100).
 
         Returns:
-            dict: Measurement counts.
+            dict (dict): Measurement counts.
         """
         job = execute(qc, self.simulator, shots=num_shots)
         return job.result().get_counts()
@@ -247,7 +250,7 @@ class SpinDynamicsH:
             counts (dict): Measurement counts.
 
         Returns:
-            float: Average spin correlation.
+            results (float): Average spin correlation.
         """
         qubit_to_spin_map = {'0': 1, '1': -1}
         total_counts = sum(counts.values())
@@ -264,7 +267,7 @@ class SpinDynamicsH:
             state_string (str): Binary string representing the initial state.
 
         Returns:
-            QuantumCircuit: Circuit for initializing the state.
+            qc (QuantumCircuit): Circuit for initializing the state.
         """
         state_string = ''.join('1' if char == '0' else '0' for char in state_string)
         qr = QuantumRegister(num_qubits)
@@ -325,10 +328,14 @@ class SpinDynamicsH:
             prefix (str): Prefix for loading precomputed reference data.
         """
         abs_corr = np.abs(np.array(self.real_amp_list) + 1j * np.array(self.imag_amp_list))
-
+        
         plt.plot(self.time_range, abs_corr, '.', label='Hadamard Test')
-        ref_sa = np.load(f'../../../data/{self.num_qubits}_spin_chain_SA_obs.npy')
-        ref_time = np.load(f'../../../data/{self.num_qubits}_spin_chain_time.npy')
+        reference_filename = f'data/{self.num_qubits}_spin_chain_SA_obs.npy'
+        if os.path.exists(reference_filename):
+            ref_sa = np.load(f'data/{self.num_qubits}_spin_chain_SA_obs.npy')
+            ref_time = np.load(f'data/{self.num_qubits}_spin_chain_time.npy')
+        else:
+            print('No reference data file found!')
         plt.plot(ref_time, ref_sa, '-', label='Statevector')
 
         plt.xlabel('Time')

{qflux-0.0.2 → qflux-0.0.4/src/qflux.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qflux
-Version: 0.0.2
+Version: 0.0.4
 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

{qflux-0.0.2 → qflux-0.0.4}/src/qflux.egg-info/SOURCES.txt

@@ -17,6 +17,7 @@ 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
+src/qflux/closed_systems/direct_method.py
 src/qflux/closed_systems/hamiltonians.py
 src/qflux/closed_systems/qubit_methods.py
 src/qflux/closed_systems/spin_dynamics_oo.py

qflux-0.0.4/tests/test_import.py

@@ -0,0 +1,24 @@
+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))
+
+print("Checking qmad modules...")
+
+from qflux.variational_methods.qmad import effh, ansatz, ansatzVect, solver
+print("Methods from effh:")
+print(dir(effh))
+
+print("Methods from ansatz:")
+print(dir(ansatz))
+
+print("Methods from ansatzVect:")
+print(dir(ansatzVect))
+
+print("Methods from solver:")
+print(dir(solver))

qflux-0.0.2/tests/test_import.py

@@ -1,9 +0,0 @@
-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))