qaoalib 0.3.0__tar.gz → 0.3.1__tar.gz

{qaoalib-0.3.0/qaoalib.egg-info → qaoalib-0.3.1}/PKG-INFO

@@ -1,37 +1,23 @@
 Metadata-Version: 2.4
 Name: qaoalib
-Version: 0.3.0
+Version: 0.3.1
 Summary: A package for QAOA Maxcut calculations
-Home-page: https://github.com/xenoicwyce/qaoalib
-Author: Xinwei Lee
-Author-email: xenoicwyce@gmail.com
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
+Project-URL: Homepage, https://github.com/xenoicwyce/qaoalib
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
 Requires-Dist: qiskit
 Requires-Dist: qiskit_optimization
 Requires-Dist: qiskit_algorithms
 Requires-Dist: qiskit_aer
-Requires-Dist: numpy
-Requires-Dist: scipy
 Requires-Dist: pytest
 Requires-Dist: pytest-cov
 Requires-Dist: matplotlib
 Requires-Dist: networkx
 Requires-Dist: pydantic
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
 Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
 
 # qaoalib
 Implementations of VQA simulations for combinatorial optimization (mainly with graph and Max-cut).

qaoalib-0.3.1/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools", "wheel", "numpy", "networkx"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "qaoalib"
+version = "0.3.1"
+description = "A package for QAOA Maxcut calculations"
+readme = "README.md"
+requires-python = ">=3.9"
+dependencies = [
+    "numpy",
+    "scipy",
+    "qiskit",
+    "qiskit_optimization",
+    "qiskit_algorithms",
+    "qiskit_aer",
+    "pytest",
+    "pytest-cov",
+    "matplotlib",
+    "networkx",
+    "pydantic",
+]
+
+[project.urls]
+Homepage = "https://github.com/xenoicwyce/qaoalib"

qaoalib-0.3.1/qaoalib/__init__.py

@@ -0,0 +1,4 @@
+from importlib.metadata import version
+from .utils import *
+
+__version__ = version("qaoalib")

qaoalib-0.3.1/qaoalib/legacy/qaoa/__init__.py

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

qaoalib-0.3.1/qaoalib/legacy/qaoa/landscape/__init__.py

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

qaoalib-0.3.1/qaoalib/legacy/qaoa/landscape/base.py

@@ -0,0 +1,90 @@
+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.3.1/qaoalib/legacy/qaoa/landscape/direct_numpy.py

@@ -0,0 +1,79 @@
+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.3.1/qaoalib/legacy/qaoa/landscape/hadamard_test.py

@@ -0,0 +1,39 @@
+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.3.1/qaoalib/legacy/qaoa/landscape/hybrid_fast.py

@@ -0,0 +1,44 @@
+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.3.1/qaoalib/legacy/qaoa/layerwise.py

@@ -0,0 +1,184 @@
+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.3.1/qaoalib/legacy/qaoa/qis.py

@@ -0,0 +1,59 @@
+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.3.1/qaoalib/legacy/qaoa/qmc.py

@@ -0,0 +1,51 @@
+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.3.1/qaoalib/legacy/qaoa/strategy.py

@@ -0,0 +1,70 @@
+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.3.1/qaoalib/legacy/qaoa/utils.py

@@ -0,0 +1,135 @@
+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.3.0 → qaoalib-0.3.1/qaoalib.egg-info}/PKG-INFO

@@ -1,37 +1,23 @@
 Metadata-Version: 2.4
 Name: qaoalib
-Version: 0.3.0
+Version: 0.3.1
 Summary: A package for QAOA Maxcut calculations
-Home-page: https://github.com/xenoicwyce/qaoalib
-Author: Xinwei Lee
-Author-email: xenoicwyce@gmail.com
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
+Project-URL: Homepage, https://github.com/xenoicwyce/qaoalib
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
 Requires-Dist: qiskit
 Requires-Dist: qiskit_optimization
 Requires-Dist: qiskit_algorithms
 Requires-Dist: qiskit_aer
-Requires-Dist: numpy
-Requires-Dist: scipy
 Requires-Dist: pytest
 Requires-Dist: pytest-cov
 Requires-Dist: matplotlib
 Requires-Dist: networkx
 Requires-Dist: pydantic
-Dynamic: author
-Dynamic: author-email
-Dynamic: classifier
-Dynamic: description
-Dynamic: description-content-type
-Dynamic: home-page
 Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
 
 # qaoalib
 Implementations of VQA simulations for combinatorial optimization (mainly with graph and Max-cut).

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

@@ -0,0 +1,31 @@
+LICENSE
+MANIFEST.in
+README.md
+pyproject.toml
+requirements.txt
+qaoalib/__init__.py
+qaoalib/ansatz.py
+qaoalib/json.py
+qaoalib/math.py
+qaoalib/utils.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/legacy/qaoa/__init__.py
+qaoalib/legacy/qaoa/layerwise.py
+qaoalib/legacy/qaoa/qis.py
+qaoalib/legacy/qaoa/qmc.py
+qaoalib/legacy/qaoa/strategy.py
+qaoalib/legacy/qaoa/utils.py
+qaoalib/legacy/qaoa/landscape/__init__.py
+qaoalib/legacy/qaoa/landscape/base.py
+qaoalib/legacy/qaoa/landscape/direct_numpy.py
+qaoalib/legacy/qaoa/landscape/hadamard_test.py
+qaoalib/legacy/qaoa/landscape/hybrid_fast.py
+qaoalib/models/__init__.py
+qaoalib/models/result.py
+qaoalib/solver/__init__.py
+qaoalib/solver/lcc_vqe.py
+qaoalib/solver/vqe.py

qaoalib-0.3.0/qaoalib/__init__.py

@@ -1,2 +0,0 @@
-from .version import __version__
-from .utils import *

qaoalib-0.3.0/qaoalib/version.py

@@ -1 +0,0 @@
-0.3.0

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

@@ -1,21 +0,0 @@
-LICENSE
-MANIFEST.in
-README.md
-requirements.txt
-setup.py
-qaoalib/__init__.py
-qaoalib/ansatz.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/lcc_vqe.py
-qaoalib/solver/vqe.py

qaoalib-0.3.0/setup.py

@@ -1,29 +0,0 @@
-from setuptools import setup, find_packages
-
-with open("README.md", "r", encoding="utf-8") as fh:
-    long_description = fh.read()
-
-with open("qaoalib/version.py", "r") as f:
-    __version__ = f.read().strip()
-
-with open("requirements.txt", "r") as f:
-    requirements = [package.strip() for package in f]
-
-setup(
-    name="qaoalib",
-    version=__version__,
-    author="Xinwei Lee",
-    author_email="xenoicwyce@gmail.com",
-    description="A package for QAOA Maxcut calculations",
-    long_description=long_description,
-    long_description_content_type="text/markdown",
-    url="https://github.com/xenoicwyce/qaoalib",
-    classifiers=[
-        "Programming Language :: Python :: 3",
-        "License :: OSI Approved :: MIT License",
-        "Operating System :: OS Independent",
-    ],
-    packages=find_packages(exclude=["test*"]),
-    python_requires=">=3.9",
-    install_requires=requirements,
-)

{qaoalib-0.3.0 → qaoalib-0.3.1}/qaoalib.egg-info/requires.txt

@@ -1,9 +1,9 @@
+numpy
+scipy
 qiskit
 qiskit_optimization
 qiskit_algorithms
 qiskit_aer
-numpy
-scipy
 pytest
 pytest-cov
 matplotlib