qaoalib 0.1.11__tar.gz → 0.2.1__tar.gz

{qaoalib-0.1.11 → qaoalib-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qaoalib
-Version: 0.1.11
+Version: 0.2.1
 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.11 → qaoalib-0.2.1}/qaoalib/models/result.py

@@ -76,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.1/qaoalib/solver/__init__.py

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

qaoalib-0.2.1/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.1/qaoalib/version.py

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

{qaoalib-0.1.11 → qaoalib-0.2.1}/qaoalib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qaoalib
-Version: 0.1.11
+Version: 0.2.1
 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.2.1/qaoalib.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+setup.py
+qaoalib/__init__.py
+qaoalib/json.py
+qaoalib/math.py
+qaoalib/utils.py
+qaoalib/version.py
+qaoalib.egg-info/PKG-INFO
+qaoalib.egg-info/SOURCES.txt
+qaoalib.egg-info/dependency_links.txt
+qaoalib.egg-info/requires.txt
+qaoalib.egg-info/top_level.txt
+qaoalib/models/__init__.py
+qaoalib/models/result.py
+qaoalib/solver/__init__.py
+qaoalib/solver/vqe.py
+test/test.py

qaoalib-0.2.1/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.11 → qaoalib-0.2.1}/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.2.1/test/test.py

@@ -0,0 +1,5 @@
+from qaoalib import *
+from qaoalib.models import *
+from qaoalib.solver import *
+# from qaoalib.qaoa import *
+# from qaoalib.qaoa.landscape import *

qaoalib-0.1.11/qaoalib/qaoa/__init__.py

@@ -1,3 +0,0 @@
-from .qmc import Qmc, QmcFastKron
-from .layerwise import Layerwise
-from .utils import *

qaoalib-0.1.11/qaoalib/qaoa/landscape/__init__.py

@@ -1,3 +0,0 @@
-from .direct_numpy import DirectNumpy
-from .hybrid_fast import HybridFast
-from .hadamard_test import HadamardTest

qaoalib-0.1.11/qaoalib/qaoa/landscape/base.py

@@ -1,90 +0,0 @@
-import numpy as np
-import matplotlib.pyplot as plt
-
-DEFAULT_RTOL = 1e-5
-DEFAULT_ATOL = 1e-8
-
-class QmcLandscapeBase:
-    """
-    This is a base class.
-    It should be only used for inhertiance.
-    """
-    def __init__(self, G, prev_params=None):
-        if prev_params is not None:
-            if len(prev_params) % 2:
-                raise ValueError(f'Constructor failed. prev_params must have even length, got {len(prev_params)}.')
-        self.graph = G
-        self.num_qubits = len(G.nodes)
-        self.edge_list = list(G.edges)
-        self.prev_params = prev_params
-        self.grange = None
-        self.brange = None
-        self.exp_arr = None
-        self.depth = 1 if prev_params is None else len(prev_params)//2+1
-        self.npts = None
-
-    def _meshgrid(self):
-        gmin, gmax = min(self.grange), max(self.grange)
-        bmin, bmax = min(self.brange), max(self.brange)
-        gspace = np.linspace(gmin, gmax, self.npts)
-        bspace = np.linspace(bmin, bmax, self.npts)
-        return np.meshgrid(gspace, bspace)
-
-    def get_max(self, rtol=DEFAULT_RTOL, atol=DEFAULT_ATOL):
-        if self.exp_arr is None:
-            raise ValueError('Grid not found. Run create_grid() method first.')
-
-        gmesh, bmesh = self._meshgrid()
-        exp_max = np.max(self.exp_arr)
-        whr = np.where(np.isclose(self.exp_arr, exp_max, rtol=rtol, atol=atol))
-        indices = zip(whr[0], whr[1])
-        angle_list = [(gmesh[idx], bmesh[idx]) for idx in indices]
-        return (exp_max, angle_list)
-
-    def get_min(self, rtol=DEFAULT_RTOL, atol=DEFAULT_ATOL):
-        if self.exp_arr is None:
-            raise ValueError('Grid not found. Run create_grid() method first.')
-
-        gmesh, bmesh = self._meshgrid()
-        exp_min = np.min(self.exp_arr)
-        whr = np.where(np.isclose(self.exp_arr, exp_min, rtol=rtol, atol=atol))
-        indices = zip(whr[0], whr[1])
-        angle_list = [(gmesh[idx], bmesh[idx]) for idx in indices]
-        return (exp_min, angle_list)
-
-    def show_landscape(self, **plot_options):
-        defaults = {
-            'figsize': (16, 9),
-        }
-        defaults.update(plot_options)
-        figsize = defaults['figsize']
-
-        fig, ax = plt.subplots(subplot_kw={'projection': '3d'}, figsize=figsize)
-
-        if self.exp_arr is None:
-            raise ValueError('Grid not found. Run create_grid() method first.')
-
-        gmesh, bmesh = self._meshgrid()
-        surf = ax.plot_surface(gmesh, bmesh, self.exp_arr, cmap='coolwarm')
-        ax.set_xlabel('gamma')
-        ax.set_ylabel('beta')
-        ax.set_zlabel('expectation')
-        fig.colorbar(surf, shrink=.5)
-
-        plt.show()
-
-    def show_heatmap(self, legacy=False):
-        if self.exp_arr is None:
-            raise ValueError('Grid not found. Run create_grid() method first.')
-
-        if legacy:
-            plt.xlabel('norm(gamma_p)')
-            plt.ylabel('norm(beta_p)')
-            plt.imshow(self.exp_arr, cmap='coolwarm', origin='lower', extent=[0, 1, 0, 1])
-        else:
-            fig, ax = plt.subplots()
-            gmesh, bmesh = self._meshgrid()
-            ax.pcolormesh(gmesh, bmesh, self.exp_arr, cmap='coolwarm')
-            ax.set_xlabel('gamma')
-            ax.set_ylabel('beta')
-            plt.show()

qaoalib-0.1.11/qaoalib/qaoa/landscape/direct_numpy.py

@@ -1,79 +0,0 @@
-import numpy as np
-
-from .base import QmcLandscapeBase
-from ..utils import I, Z, plus
-from ..utils import rx, make_params_vec
-
-
-class DirectNumpy(QmcLandscapeBase):
-    def __init__(self, G, prev_params=None):
-        super().__init__(G, prev_params)
-        self.plusxn = self._mplus()
-        self.hamiltonian = self._hmt()
-
-    def _mplus(self):
-        ans = plus
-        for q in range(1, self.num_qubits):
-            ans = np.kron(ans, plus)
-        return ans
-
-    def _hmt(self):
-        N = 2 ** self.num_qubits
-        ans = np.zeros((N, N))
-        for u, v in self.edge_list:
-            ans += np.eye(N) - self.tensor(Z, [u, v])
-        return ans/2
-
-    def tensor(self, u3, qubits):
-        if 0 in qubits:
-            ans = u3
-        else:
-            ans = I
-
-        for idx in range(1, self.num_qubits):
-            if idx in qubits:
-                ans = np.kron(ans, u3)
-            else:
-                ans = np.kron(ans, I)
-        return ans
-
-    def ucost(self, q1, q2, gamma):
-        return np.diag(np.exp(1j*gamma/2*np.diag(np.eye(2**self.num_qubits)-self.tensor(Z, [q1, q2]))))
-
-    def umixer_all(self, beta):
-        return self.tensor(rx(2*beta), list(range(self.num_qubits)))
-
-    def ansatz(self, gamma_vec, beta_vec):
-        ans = self.plusxn
-        for gamma, beta in zip(gamma_vec, beta_vec):
-            for u, v in self.edge_list:
-                ans = self.ucost(u, v, gamma) @ ans
-            ans = self.umixer_all(beta) @ ans
-        return ans
-
-    def expectation(self, params):
-        if self.plusxn is None or self.hamiltonian is None:
-            self.plusxn = self._mplus()
-            self.hamiltonian = self._hmt()
-        depth = len(params)//2
-        gamma_vec = params[:depth]
-        beta_vec = params[depth:]
-        ansatz = self.ansatz(gamma_vec, beta_vec)
-        ans = ansatz.conj().T @ self.hamiltonian @ ansatz
-        ans = ans[0][0]
-        if np.isclose(ans.real, np.abs(ans)):
-            return ans.real
-        else:
-            return ans
-
-    def create_grid(self, npts=100, gmin=0, gmax=2*np.pi, bmin=0, bmax=np.pi):
-        self.grange = (gmin, gmax)
-        self.brange = (bmin, bmax)
-        self.npts = npts
-        gmesh, bmesh = self._meshgrid()
-        gg = gmesh.reshape((-1,))
-        bb = bmesh.reshape((-1,))
-
-        exp_arr = np.array(list(map(self.expectation, make_params_vec(gg, bb, self.prev_params))))\
-                        .reshape((npts, npts))
-        self.exp_arr = exp_arr

qaoalib-0.1.11/qaoalib/qaoa/landscape/hadamard_test.py

@@ -1,39 +0,0 @@
-import numpy as np
-
-from .base import QmcLandscapeBase
-from ..utils import interp, ht_expectation
-from ..qis import hadamard_test_circuits, run_many_circuits
-
-
-class HadamardTest(QmcLandscapeBase):
-    def __init__(self, G, prev_params=None):
-        super().__init__(G, prev_params)
-
-    def get_circuits(self, params):
-        return hadamard_test_circuits(self.graph, params)
-
-    def expectation_grid(self, gspace, bspace, npts, prev_params=None):
-        qc_list = []
-        for beta in bspace:
-            for gamma in gspace:
-                if prev_params is None:
-                    qc_list += self.get_circuits([gamma, beta])
-                else:
-                    qc_list += self.get_circuits(interp(prev_params, [gamma, beta]))
-
-        sv_list = run_many_circuits(qc_list)
-        exp_arr = np.array(list(map(ht_expectation, sv_list)))\
-                    .reshape((npts*npts, len(self.edge_list)))
-        exp_arr = np.sum(exp_arr, axis=1).reshape((npts, npts))
-        return exp_arr
-
-    def create_grid(self, npts=100, gmin=0, gmax=2*np.pi, bmin=0, bmax=np.pi):
-        self.grange = (gmin, gmax)
-        self.brange = (bmin, bmax)
-        self.npts = npts
-        gmesh, bmesh = self._meshgrid()
-
-        gspace = np.linspace(gmin, gmax, npts)
-        bspace = np.linspace(bmin, bmax, npts)
-        exp_arr = self.expectation_grid(gspace, bspace, npts, self.prev_params)
-        self.exp_arr = exp_arr

qaoalib-0.1.11/qaoalib/qaoa/landscape/hybrid_fast.py

@@ -1,44 +0,0 @@
-import numpy as np
-
-from .base import QmcLandscapeBase
-from ..utils import I, Z, interp
-from ..qis import qaoa_circuit, run_many_circuits
-from ...math import fast_kron
-
-
-class HybridFast(QmcLandscapeBase):
-    def __init__(self, G, prev_params=None):
-        super().__init__(G, prev_params)
-
-    def get_circuit(self, params):
-        return qaoa_circuit(self.graph, params)
-
-    def _fast_kron_exp(self, sv):
-        sum_ = 0
-        for edge in self.edge_list:
-            kron_list = [Z if i in edge else I for i in range(self.num_qubits)]
-            kron_list.reverse()
-            sum_ += (sv.conj().T @ fast_kron(kron_list, sv)).item().real
-        # return a single expectation value
-        return (len(self.edge_list) - sum_)/2
-
-    def expectation_grid(self, gspace, bspace, npts, prev_params=None):
-        if prev_params is None:
-            qc_list = [self.get_circuit([gamma, beta]) for beta in bspace for gamma in gspace]
-        else:
-            qc_list = [self.get_circuit(interp(prev_params, [gamma, beta]))
-                        for beta in bspace for gamma in gspace]
-        ansatz_list = run_many_circuits(qc_list)
-        exp_arr = np.array(list(map(self._fast_kron_exp, ansatz_list))).reshape((npts, npts))
-        return exp_arr
-
-    def create_grid(self, npts=100, gmin=0, gmax=2*np.pi, bmin=0, bmax=np.pi):
-        self.grange = (gmin, gmax)
-        self.brange = (bmin, bmax)
-        self.npts = npts
-        gmesh, bmesh = self._meshgrid()
-
-        gspace = np.linspace(gmin, gmax, npts)
-        bspace = np.linspace(bmin, bmax, npts)
-        exp_arr = self.expectation_grid(gspace, bspace, npts, self.prev_params)
-        self.exp_arr = exp_arr

qaoalib-0.1.11/qaoalib/qaoa/layerwise.py

@@ -1,184 +0,0 @@
-import pickle
-import numpy as np
-import matplotlib.pyplot as plt
-
-from matplotlib import cm
-
-from .utils import I, Z
-from .utils import rx
-
-class Layerwise:
-    def __init__(self, G):
-        self.graph = G
-        self.num_qubits = len(G.nodes)
-        self.edge_list = list(G.edges)
-        self.hamiltonian = self.get_maxcut_hmt()
-        self.maxcut = np.max(self.hamiltonian)
-        self.best_ansatz = self.plusxn()
-        self.best_params = None
-        self.exp_arr = None
-        self.npts = None
-        self.gmesh = None
-        self.bmesh = None
-        self.max_exps = None
-        self.depth = 0
-
-    def tensor_prod(self, u3, qubits):
-        if 0 in qubits:
-            ans = u3
-        else:
-            ans = I
-
-        for idx in range(1, self.num_qubits):
-            if idx in qubits:
-                ans = np.kron(ans, u3)
-            else:
-                ans = np.kron(ans, I)
-        return ans
-
-    def plusxn(self):
-        N = 2 ** self.num_qubits
-        return np.ones((N, 1))/np.sqrt(N)
-
-    def get_maxcut_hmt(self):
-        N = 2 ** self.num_qubits
-        ans = np.zeros((N, N))
-        for u, v in self.edge_list:
-            ans += np.eye(N) - self.tensor_prod(Z, [u, v])
-        return ans/2
-
-    def ehz(self, gamma):
-        eigs = np.diag(self.hamiltonian)
-        return np.diag(np.exp(1j*gamma/2*eigs))
-
-    def ehx(self, beta):
-        return self.tensor_prod(rx(2*beta), list(range(self.num_qubits)))
-
-    def ansatz(self, gamma, beta):
-        ans = self.best_ansatz[:, -1][:, np.newaxis]
-        return self.ehx(beta) @ self.ehz(gamma) @ ans
-
-    def expectation(self, gamma, beta):
-        right = self.ansatz(gamma, beta)
-        left = right.conj().T
-        return (left @ self.hamiltonian @ right).real
-
-    def create_grid(self, npts, gmin=0, gmax=2*np.pi, bmin=0, bmax=np.pi):
-        grange = np.linspace(gmin, gmax, npts)
-        brange = np.linspace(bmin, bmax, npts)
-        gmesh, bmesh = np.meshgrid(grange, brange)
-        gg = gmesh.reshape((-1,))
-        bb = bmesh.reshape((-1,))
-
-        exp_arr = np.array(list(map(self.expectation, gg, bb)))\
-                        .reshape((npts, npts))
-
-        self.npts = npts
-        self.gmesh = gmesh
-        self.bmesh = bmesh
-        if self.exp_arr is None:
-            self.exp_arr = exp_arr[:, :, np.newaxis]
-        else:
-            self.exp_arr = np.dstack((self.exp_arr, exp_arr))
-
-    # def get_max(self, p):
-    #     if self.exp_arr is None:
-    #         raise ValueError('Grid not found. Run create_grid() method first.')
-
-    #     exp_arr = self.exp_arr[:, :, p-1]
-    #     max_exp = np.max(exp_arr)
-    #     whr = np.where(np.isclose(exp_arr, max_exp))
-    #     indices = zip(whr[0], whr[1])
-    #     angle_list = [(self.gmesh[idx], self.bmesh[idx]) for idx in indices]
-    #     return (max_exp, angle_list)
-
-    def find_args(self, p, value):
-        """ Find the nearest args given a value. """
-
-        if self.exp_arr is None:
-            raise ValueError('Grid not found. Run create_grid() method first.')
-
-        dist_arr = np.abs(self.exp_arr[:, :, p-1] - value)
-        nearest = np.min(dist_arr)
-        whr = np.where(np.isclose(dist_arr, nearest))
-        indices = zip(whr[0], whr[1])
-        angle_list = [(self.gmesh[idx], self.bmesh[idx]) for idx in indices]
-        return angle_list
-
-    def run(self, p_end, npts=50, cutoff=1.0):
-        for i in range(1, p_end + 1):
-            print(f'Creating grid for p={i}')
-            self.create_grid(npts)
-            max_exp = np.max(self.exp_arr[:, :, i-1])
-            best_params = self.find_args(i, cutoff * max_exp)[0] # take only one pair of angles
-
-            if self.max_exps is None:
-                self.max_exps = max_exp
-            else:
-                self.max_exps = np.hstack((self.max_exps, max_exp))
-
-            if self.best_params is None:
-                self.best_params = np.array(best_params)
-            else:
-                self.best_params = np.column_stack((self.best_params, best_params))
-
-            best_ansatz = self.ansatz(best_params[0], best_params[1])
-            self.best_ansatz = np.hstack((self.best_ansatz, best_ansatz))
-
-            self.depth += 1
-
-    def show_landscape(self, p, **plot_options):
-        defaults = {
-            'figsize': (16, 9),
-        }
-        defaults.update(plot_options)
-        figsize = defaults['figsize']
-
-        fig, ax = plt.subplots(subplot_kw={'projection': '3d'}, figsize=figsize)
-
-        if self.gmesh is None or self.bmesh is None or self.exp_arr is None:
-            raise ValueError('Grid not found. Run create_grid() method first.')
-
-        exp_arr = self.exp_arr[:, :, p-1]
-        surf = ax.plot_surface(self.gmesh, self.bmesh, exp_arr, cmap=cm.coolwarm)
-        ax.set_xlabel('gamma')
-        ax.set_ylabel('beta')
-        ax.set_zlabel('expectation')
-        fig.colorbar(surf, shrink=.5)
-
-        plt.show()
-
-    def show_heatmap(self, p):
-        if self.exp_arr is None:
-            raise ValueError('Grid not found. Run create_grid() method first.')
-
-        exp_arr = self.exp_arr[:, :, p-1]
-        plt.xlabel('gamma_p/2pi')
-        plt.ylabel('beta_p/pi')
-        plt.imshow(exp_arr, cmap=cm.coolwarm, origin='lower', extent=[0, 1, 0, 1])
-
-    def plot_alpha(self, alpha=True):
-        p_range = range(1, self.depth + 1)
-
-        fig, ax = plt.subplots()
-        ax.set_xlabel('Circuit depth, $p$')
-        ax.grid(True)
-        ax.set_xticks(p_range)
-        if alpha:
-            ax.set_ylabel('Approx. ratio')
-            ax.plot(p_range, self.max_exps/self.maxcut, marker='.')
-        else:
-            ax.set_ylabel('Expectation')
-            ax.plot(p_range, self.max_exps, marker='.')
-
-        plt.show()
-
-    def status(self):
-        if not self.depth:
-            print('Paramters fixing not yet executed.')
-        else:
-            print(f'Parameters fixing executed up to p={self.depth}.')
-
-    def dump(self, path):
-        with open(path, 'wb') as f:
-            pickle.dump(self, f)

qaoalib-0.1.11/qaoalib/qaoa/qis.py

@@ -1,59 +0,0 @@
-from qiskit import QuantumRegister, QuantumCircuit
-from qiskit import Aer, execute
-
-
-sv_backend = Aer.get_backend('statevector_simulator')
-aer_backend = Aer.get_backend('aer_simulator')
-
-def qaoa_circuit(G, params):
-    """
-    QAOA circuit for Max-cut \sum(I-ZZ). No longer follow qiskit QAOA circuit.
-    If want to reproduce the circuit used in qiskit \sum(-ZZ), substitute
-    gamma as -gamma will do.
-    """
-    depth = len(params)//2
-    gamma = params[:depth]
-    beta = params[depth:]
-
-    q = QuantumRegister(len(G.nodes))
-    qc = QuantumCircuit(q)
-
-    qc.h(q)
-    for p in range(depth):
-        for u, v, d in G.edges(data=True):
-            weight = d.get('weight', 1)
-            qc.cx(u, v)
-            qc.rz(-gamma[p]*weight, v)
-            qc.cx(u, v)
-        qc.rx(2*beta[p], q)
-    return qc
-
-def hadamard_test_circuits(G, params):
-    """
-    Return a list of QuantumCircuit's for hadamard tests.
-    """
-    qc_list = []
-    ansatz_circ = qaoa_circuit(G, params)
-
-    for u, v in G.edges:
-        q = QuantumRegister(1)
-        ansatz = QuantumRegister(ansatz_circ.num_qubits)
-        qc = QuantumCircuit(q, ansatz)
-
-        qc.h(q)
-        qc.append(ansatz_circ, ansatz)
-        qc.cz(q, ansatz[u])
-        qc.cz(q, ansatz[v])
-        qc.h(q)
-
-        # bit reversal is required to calculate probabilities
-        qc = qc.reverse_bits()
-        qc_list.append(qc)
-
-    return qc_list
-
-def run_many_circuits(qc_list):
-    job = execute(qc_list, sv_backend)
-    result = job.result()
-    # return a list of np.ndarray of statevectors
-    return [result.get_statevector(idx) for idx in range(len(qc_list))]

qaoalib-0.1.11/qaoalib/qaoa/qmc.py

@@ -1,51 +0,0 @@
-import numpy as np
-from qiskit import Aer, execute
-
-from .qis import qaoa_circuit, sv_backend
-from .utils import expectation, I, Z
-from ..math import fast_kron
-
-
-class Qmc:
-    def __init__(self, G, params):
-        self.graph = G
-        self.params = params
-        self.circuit = qaoa_circuit(self.graph, self.params)
-        self.result = None
-        self.expectation = None
-
-    def run(self, backend_name='qasm_simulator', **execute_kw):
-        qc = self.circuit
-        if backend_name == 'qasm_simulator':
-            qc.measure_all()
-
-        backend = Aer.get_backend(backend_name)
-        job = execute(self.circuit, backend, **execute_kw)
-        result = job.result()
-        if backend_name == 'qasm_simulator':
-            self.result = result.get_counts()
-        elif backend_name == 'statevector_simulator':
-            self.result = np.asarray(result.get_statevector())
-
-        self.expectation = expectation(self.graph, self.result)
-
-
-class QmcFastKron(Qmc):
-    def __init__(self, G, params):
-        super().__init__(G, params)
-
-    def _fast_kron_exp(self, sv):
-        sum_ = 0
-        for u, v, d in self.graph.edges(data=True):
-            edge = (u,v)
-            kron_list = [Z if i in edge else I for i in range(len(self.graph.nodes))]
-            kron_list.reverse()
-            weight = d.get('weight', 1)
-            sum_ += weight * (1 - (sv.conj().T @ fast_kron(kron_list, sv)).item().real)
-        # return a single expectation value
-        return sum_/2
-
-    def run(self, **execute_kw):
-        job = execute(self.circuit, sv_backend, **execute_kw) # currently only support sv type
-        self.result = job.result().get_statevector()
-        self.expectation = self._fast_kron_exp(self.result)

qaoalib-0.1.11/qaoalib/qaoa/strategy.py

@@ -1,70 +0,0 @@
-import numpy as np
-from typing import TYPE_CHECKING, Optional, Union, Sequence
-from typing_extensions import TypeAlias
-# from .params import Params
-
-if TYPE_CHECKING:
-    import numpy.typing as npt
-
-Params: TypeAlias = Union[Sequence[float], "npt.NDArray[np.float_]"]
-
-
-def interp():
-    ...
-
-def bilinear(
-    prev_params: Params,
-    pp_params: Params,
-    gamma_bound: Optional[tuple[float, float]] = None,
-    beta_bound: Optional[tuple[float, float]] = None,
-) -> "npt.NDArray[np.float_]":
-    if gamma_bound is None:
-        gamma_bound = (0, np.pi)
-    if beta_bound is None:
-        beta_bound = (0, np.pi/2)
-
-    prev_params = np.asarray(prev_params)
-    pp_params = np.asarray(pp_params) # prev_prev_params (p-2)
-
-    # split into gamma and beta
-    prev_gb = np.split(prev_params, 2)
-    pp_gb = np.split(pp_params, 2)
-
-    new_gb = []
-    for i in range(2):
-        delta2 = prev_gb[i][-2] - pp_gb[i][-1]
-        pp_gb[i] = np.hstack([pp_gb[i], prev_gb[i][-1] - delta2])
-
-        diff = prev_gb[i] - pp_gb[i]
-        new_x = prev_gb[i] + diff
-
-        delta3 = new_x[-1] - new_x[-2]
-        new_x = np.hstack([new_x, new_x[-1] + delta3])
-
-        if i == 0:
-            new_x = np.clip(new_x, *gamma_bound)
-        else:
-            new_x = np.clip(new_x, *beta_bound)
-
-        new_gb.append(new_x)
-
-    return np.hstack(new_gb)
-
-
-def params_fixing(
-    prev_params: Params,
-    gamma_bound: Optional[tuple[float, float]] = None,
-    beta_bound: Optional[tuple[float, float]] = None,
-) -> "npt.NDArray[np.float_]":
-    if gamma_bound is None:
-        gamma_bound = (0, np.pi)
-    if beta_bound is None:
-        beta_bound = (0, np.pi/2)
-
-    prev_params = np.asarray(prev_params)
-    gamma, beta = np.split(prev_params)
-
-    gamma = np.hstack([gamma, np.random.uniform(*gamma_bound)])
-    beta = np.hstack([beta, np.random.uniform(*beta_bound)])
-
-    return np.hstack([gamma, beta])

qaoalib-0.1.11/qaoalib/qaoa/utils.py

@@ -1,135 +0,0 @@
-import numpy as np
-
-
-# globals
-I = np.eye(2)
-X = np.array([
-    [0, 1],
-    [1, 0],
-])
-Z = np.array([
-    [1, 0],
-    [0, -1],
-])
-cnot = np.array([
-    [1, 0, 0, 0],
-    [0, 1, 0, 0],
-    [0, 0, 0, 1],
-    [0, 0, 1, 0],
-])
-plus = np.ones((2, 1)) * 1/np.sqrt(2)
-
-# functions
-def split_gb(params):
-    depth = len(params)//2
-    gamma = params[:depth]
-    beta = params[depth:]
-    return gamma, beta
-
-def random_qaoa_params(p, grange=None, brange=None):
-    """Generate random QAOA parameters."""
-    if grange is None:
-        grange = (0, 2*np.pi)
-    if brange is None:
-        brange = (0, np.pi)
-
-    rng = np.random.default_rng()
-    # rng.uniform(low=0., high=1., size=None)
-    grand = rng.uniform(grange[0], grange[1], p)
-    brand = rng.uniform(brange[0], brange[1], p)
-    return np.hstack([grand, brand])
-
-def interp(old_params, new_params):
-    gamma, beta = split_gb(old_params)
-    new_gamma, new_beta = split_gb(new_params)
-    return np.hstack((gamma, new_gamma, beta, new_beta)).tolist()
-
-def interp_rand(params, grange=None, brange=None):
-    """
-    Adds a new random angle to the params array, and return
-    the params required by (p+1).
-    """
-    if grange is None:
-        grange = (0, 2*np.pi)
-    if brange is None:
-        brange = (0, np.pi)
-
-    depth = len(params)//2
-    gamma = params[:depth]
-    beta = params[depth:]
-
-    rng = np.random.default_rng()
-    grand = rng.uniform(grange[0], grange[1], 1)
-    brand = rng.uniform(brange[0], brange[1], 1)
-    return np.hstack([gamma, grand, beta, brand])
-
-def rx(theta):
-    return np.array([
-        [np.cos(theta/2), -1j*np.sin(theta/2)],
-        [-1j*np.sin(theta/2), np.cos(theta/2)],
-    ])
-
-def rz(theta):
-    return np.array([
-        [np.exp(-1j*theta/2), 0],
-        [0, np.exp(1j*theta/2)],
-    ])
-
-def make_params_vec(gamma1d, beta1d, prev_params=None):
-    if prev_params is None:
-        return zip(gamma1d, beta1d)
-
-    npts = gamma1d.shape[0]
-    depth = len(prev_params)//2
-    prev_gamma = prev_params[:depth]
-    prev_beta = prev_params[depth:]
-
-    gamma_list = (np.zeros((npts, depth)) + np.array(prev_gamma)).T.tolist()
-    beta_list = (np.zeros((npts, depth)) + np.array(prev_beta)).T.tolist()
-
-    return zip(*gamma_list, gamma1d, *beta_list, beta1d)
-
-def ht_expectation(sv):
-    zero, one = np.split(sv, 2)
-    zero_prob = np.sum(np.abs(zero)**2)
-    one_prob = np.sum(np.abs(one)**2)
-    return zero_prob - one_prob
-
-def _cut_value(G, eigenstate):
-    eigenstate = eigenstate[::-1]
-    cut = 0
-    for u, v, d in G.edges(data=True):
-        if eigenstate[u] != eigenstate[v]:
-            weight = d.get('weight', 1)
-            cut += weight
-    return cut
-
-def _sv2dict(sv):
-    num_qubits = np.log2(sv.shape[0])
-    if num_qubits % 1:
-        raise ValueError('Input vector is not a valid statevector.')
-    num_qubits = int(num_qubits)
-
-    sv_dict = {
-        f'{idx:0{num_qubits}b}': sv[idx]
-        for idx in range(2**num_qubits)
-    }
-    return sv_dict
-
-def expectation(G, counts_or_sv):
-    sum_ = 0
-    if isinstance(counts_or_sv, dict):
-        counts = counts_or_sv
-        total = sum(counts.values())
-        for eigs, count in counts.items():
-            sum_ += _cut_value(G, eigs) * count / total
-        return sum_
-
-    elif isinstance(counts_or_sv, np.ndarray):
-        sv = _sv2dict(counts_or_sv)
-        for eigs, count in sv.items():
-            sum_ += _cut_value(G, eigs) * (np.abs(sv[eigs])**2)
-        return sum_
-
-    else:
-        raise TypeError(f'Unrecognized type {type(counts_or_sv)}.')

qaoalib-0.1.11/qaoalib/version.py

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

qaoalib-0.1.11/qaoalib.egg-info/SOURCES.txt

@@ -1,27 +0,0 @@
-LICENSE
-README.md
-setup.py
-qaoalib/__init__.py
-qaoalib/json.py
-qaoalib/math.py
-qaoalib/utils.py
-qaoalib/version.py
-qaoalib.egg-info/PKG-INFO
-qaoalib.egg-info/SOURCES.txt
-qaoalib.egg-info/dependency_links.txt
-qaoalib.egg-info/requires.txt
-qaoalib.egg-info/top_level.txt
-qaoalib/models/__init__.py
-qaoalib/models/result.py
-qaoalib/qaoa/__init__.py
-qaoalib/qaoa/layerwise.py
-qaoalib/qaoa/qis.py
-qaoalib/qaoa/qmc.py
-qaoalib/qaoa/strategy.py
-qaoalib/qaoa/utils.py
-qaoalib/qaoa/landscape/__init__.py
-qaoalib/qaoa/landscape/base.py
-qaoalib/qaoa/landscape/direct_numpy.py
-qaoalib/qaoa/landscape/hadamard_test.py
-qaoalib/qaoa/landscape/hybrid_fast.py
-test/test.py

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

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

qaoalib-0.1.11/test/test.py

@@ -1,3 +0,0 @@
-from qaoalib import *
-from qaoalib.qaoa import *
-from qaoalib.qaoa.landscape import *