qaoalib 0.1.10__tar.gz → 0.2.0__tar.gz

{qaoalib-0.1.10 → qaoalib-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qaoalib
-Version: 0.1.10
+Version: 0.2.0
 Summary: A package for QAOA Maxcut calculations
 Home-page: https://github.com/xenoicwyce/qaoalib
 Author: Xinwei Lee
@@ -11,10 +11,15 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy>=1.17
+Requires-Dist: qiskit
+Requires-Dist: qiskit_optimization
+Requires-Dist: qiskit_aer
+Requires-Dist: numpy==1.26.0
+Requires-Dist: scipy
+Requires-Dist: pytest
+Requires-Dist: pytest-cov
 Requires-Dist: matplotlib
 Requires-Dist: networkx
-Requires-Dist: qiskit>=0.25.0
 Requires-Dist: pydantic
 
 # qaoalib

{qaoalib-0.1.10 → qaoalib-0.2.0}/qaoalib/models/result.py

@@ -1,4 +1,5 @@
 import numpy as np
+import networkx as nx
 import json
 
 from pydantic import BaseModel, Field
@@ -19,8 +20,22 @@ class BaseResult(BaseModel):
         G = graph_from_name(self.name)
         self.true_obj, _ = maxcut_brute(G)
 
+    def solve_gurobi(self) -> None:
+        from qiskit_optimization.algorithms import GurobiOptimizer
+        from qiskit_optimization.applications import Maxcut
+        
+        G = graph_from_name(self.name)
+        w = nx.adjacency_matrix(G)
+        maxcut = Maxcut(w)
+        qp = maxcut.to_quadratic_program()
+
+        grb_result = GurobiOptimizer().solve(qp)
+        self.true_obj = int(grb_result.fval)
+
     def dump(self, target_dir='.') -> None:
         target_dir = Path(target_dir)
+        if not target_dir.exists():
+            target_dir.mkdir(parents=True)
         with open(target_dir/f'{self.name}.json', 'w') as f:
             json.dump(self.dict(), f, default=to_serializable)
 
@@ -61,3 +76,11 @@ class MultipleTrialResult(BaseResult):
 
 class ItlwResult(MultipleTrialResult):
     pass
+
+
+class VQEResult(BaseResult):
+    expectations: list[float] = Field(default_factory=list)
+    nfevs: list[int] = Field(default_factory=list)
+    initial_params: list[list[float]] = Field(default_factory=list)
+    opt_params: list[list[float]] = Field(default_factory=list)
+    alphas: list[float] = Field(default_factory=list)

qaoalib-0.2.0/qaoalib/solver/__init__.py

@@ -0,0 +1 @@
+from vqe import VQE

qaoalib-0.2.0/qaoalib/solver/vqe.py

@@ -0,0 +1,137 @@
+import numpy as np
+
+from qiskit import QuantumCircuit
+from qiskit.circuit import ParameterVector
+from qiskit.primitives import (
+    BackendSamplerV2 as BackendSampler,
+    BackendEstimatorV2 as BackendEstimator,
+)
+from qiskit.quantum_info import SparsePauliOp, Pauli
+
+from qiskit_optimization import QuadraticProgram
+from qiskit_optimization.converters import QuadraticProgramToQubo
+from qiskit_optimization.algorithms import GurobiOptimizer
+from qiskit_algorithms.optimizers import COBYLA, OptimizerResult
+from qiskit_aer import AerSimulator
+
+TWO_PI = 2 * np.pi
+
+
+class VQE:
+    def __init__(
+        self,
+        quadratic_program: QuadraticProgram,
+        ansatz: QuantumCircuit = None,
+        reps: int = 1,
+        shots: int = None,
+        sampler=None,
+        estimator=None,
+        optimizer=None,        
+    ) -> None:
+        self.qp = quadratic_program
+        self.converter = QuadraticProgramToQubo()
+        self.qubo = self.converter.convert(self.qp)
+
+        hamiltonian, offset = self.qubo.to_ising()
+        self.hamiltonian: SparsePauliOp = hamiltonian
+        self.offset: float = offset
+
+        self.num_qubits = hamiltonian.num_qubits
+        self.ansatz = self.generate_full_ansatz(hamiltonian.num_qubits, reps) if ansatz is None else ansatz
+
+        backend_sv = AerSimulator(method='statevector')
+        backend_mps = AerSimulator(method='matrix_product_state')
+        self.sampler = BackendSampler(backend=backend_mps) if sampler is None else sampler
+        self.estimator = BackendEstimator(backend=backend_sv) if estimator is None else estimator
+        self.optimizer = COBYLA() if optimizer is None else optimizer
+        self.shots = shots
+
+        self.optimal_params = None
+        self.optimal_solution = None
+    
+    @staticmethod
+    def generate_full_ansatz(num_qubits: int, reps: int) -> QuantumCircuit:
+        qc = QuantumCircuit(num_qubits)
+        theta = ParameterVector('θ', (reps + 1) * num_qubits)
+        
+        for k in range(num_qubits):
+            qc.ry(theta[k], k)
+
+        for r in range(1, reps + 1):
+            for k in range(num_qubits):
+                qc.cz(k, (k + 1) % num_qubits)
+
+            for k in range(num_qubits):
+                qc.ry(theta[r * num_qubits + k], k)
+
+        return qc
+    
+    def generate_random_params(self, scale=TWO_PI):
+        return np.random.rand(self.ansatz.num_parameters) * scale
+    
+    def generate_pubs(
+        self, 
+        params: list[float] | np.ndarray,
+    ) -> list[tuple[QuantumCircuit, SparsePauliOp, np.ndarray]]:
+        return [(self.ansatz, self.hamiltonian, params)]
+    
+    def compute_energy(self, params: list[float] | np.ndarray) -> float:
+        """
+        Computes the sum of expectation of the ZZ terms.
+        """
+        pubs = self.generate_pubs(params)
+        results = self.estimator.run(pubs).result()
+        evs = [result.data.evs for result in results]
+        return sum(evs)
+    
+    def _sample_optimal_circuit(self) -> dict[str, int]:
+        """
+        Run the full circuit with sampler to get the solution. 
+        """
+        if self.optimal_params is None:
+            raise ValueError('Problem not yet solved. Run LCCVQE.solve() to solve the problem.')
+        
+        ansatz = self.ansatz.copy()
+        ansatz.measure_all()
+        result = self.sampler.run([(ansatz, self.optimal_params)], shots=self.shots).result()[0]
+        return result.data.meas.get_counts()
+
+    def _sample_most_likely(self) -> list[int]:
+        counts = self._sample_optimal_circuit()
+        highest_count = max(counts.values())
+
+        for bit_string, count in counts.items():
+            if count == highest_count:
+                return list(map(int, bit_string[::-1])) # flip the bit-string due to qiskit ordering
+            
+    def get_qp_solution(self) -> list[float]:
+        qubo_solution = self._sample_most_likely()
+        return self.converter.interpret(qubo_solution)
+
+    def solve(
+        self, 
+        initial_point: list[float] | np.ndarray = None,
+        run_sampler: bool = False,
+    ) -> OptimizerResult:
+        """
+        Calls the Scipy minimize function and returns the OptimizerResult object.
+        """
+        if initial_point is None:
+            initial_point = self.generate_random_params()
+        else:
+            assert np.asarray(initial_point).shape[0] == self.ansatz.num_parameters, 'Parameter length does not match.'
+        
+        def obj_func(params):
+            return self.compute_energy(params)
+
+        result = self.optimizer.minimize(obj_func, initial_point)
+        self.optimal_params = result.x
+
+        if run_sampler:
+            self.optimal_solution = self.get_qp_solution()
+
+        return result
+
+    def solve_gurobi(self) -> float:
+        result = GurobiOptimizer().solve(self.qp)
+        return result.fval

qaoalib-0.2.0/qaoalib/version.py

@@ -0,0 +1 @@
+__version__ = '0.2.0'

{qaoalib-0.1.10 → qaoalib-0.2.0}/qaoalib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qaoalib
-Version: 0.1.10
+Version: 0.2.0
 Summary: A package for QAOA Maxcut calculations
 Home-page: https://github.com/xenoicwyce/qaoalib
 Author: Xinwei Lee
@@ -11,10 +11,15 @@ Classifier: Operating System :: OS Independent
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy>=1.17
+Requires-Dist: qiskit
+Requires-Dist: qiskit_optimization
+Requires-Dist: qiskit_aer
+Requires-Dist: numpy==1.26.0
+Requires-Dist: scipy
+Requires-Dist: pytest
+Requires-Dist: pytest-cov
 Requires-Dist: matplotlib
 Requires-Dist: networkx
-Requires-Dist: qiskit>=0.25.0
 Requires-Dist: pydantic
 
 # qaoalib

{qaoalib-0.1.10 → qaoalib-0.2.0}/qaoalib.egg-info/SOURCES.txt

@@ -24,4 +24,6 @@ qaoalib/qaoa/landscape/base.py
 qaoalib/qaoa/landscape/direct_numpy.py
 qaoalib/qaoa/landscape/hadamard_test.py
 qaoalib/qaoa/landscape/hybrid_fast.py
+qaoalib/solver/__init__.py
+qaoalib/solver/vqe.py
 test/test.py

qaoalib-0.2.0/qaoalib.egg-info/requires.txt

@@ -0,0 +1,10 @@
+qiskit
+qiskit_optimization
+qiskit_aer
+numpy==1.26.0
+scipy
+pytest
+pytest-cov
+matplotlib
+networkx
+pydantic

{qaoalib-0.1.10 → qaoalib-0.2.0}/setup.py

@@ -22,10 +22,15 @@ setup(
     packages=find_packages(exclude=["test*"]),
     python_requires=">=3.9",
     install_requires=[
-        "numpy>=1.17",
+        "qiskit",
+        "qiskit_optimization",
+        "qiskit_aer",
+        "numpy==1.26.0",
+        "scipy",
+        "pytest",
+        "pytest-cov",
         "matplotlib",
         "networkx",
-        "qiskit>=0.25.0",
         "pydantic",
-    ]
+    ],
 )

qaoalib-0.1.10/qaoalib/version.py

@@ -1 +0,0 @@
-__version__ = '0.1.10'

qaoalib-0.1.10/qaoalib.egg-info/requires.txt

@@ -1,5 +0,0 @@
-numpy>=1.17
-matplotlib
-networkx
-qiskit>=0.25.0
-pydantic